{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "838ffa12",
   "metadata": {},
   "source": [
    "This notebook demonstrates how the speech embedding model from Google (https://www.kaggle.com/models/google/speech-embedding/frameworks/tensorFlow1/variations/speech-embedding/versions/1) is re-implemented in Keras manually, which can then be converted to ONNX and tflite formats for use in openWakeWord.\n",
    "\n",
    "Note that Keras was used here, but in theory other deep learning frameworks (e.g., PyTorch) could work as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "893d29dc",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-01-18T00:26:11.649261Z",
     "start_time": "2024-01-18T00:26:10.190666Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-01-17 19:26:10.372628: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory\n",
      "2024-01-17 19:26:10.372640: I tensorflow/stream_executor/cuda/cudart_stub.cc:29] Ignore above cudart dlerror if you do not have a GPU set up on your machine.\n"
     ]
    }
   ],
   "source": [
    "# Imports\n",
    "\n",
    "import os\n",
    "import numpy as np\n",
    "import scipy\n",
    "import tensorflow as tf\n",
    "import tensorflow_hub as hub  # install with `pip install tensorflow_hub`\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe3054ae",
   "metadata": {},
   "source": [
    "# Load Orignal Model from TFHub"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "fa2bc0d3",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-01-18T00:26:12.257919Z",
     "start_time": "2024-01-18T00:26:11.650661Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-01-17 19:26:11.857817: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2024-01-17 19:26:11.858167: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory\n",
      "2024-01-17 19:26:11.858193: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcublas.so.11'; dlerror: libcublas.so.11: cannot open shared object file: No such file or directory\n",
      "2024-01-17 19:26:11.858215: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcublasLt.so.11'; dlerror: libcublasLt.so.11: cannot open shared object file: No such file or directory\n",
      "2024-01-17 19:26:11.858237: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcufft.so.10'; dlerror: libcufft.so.10: cannot open shared object file: No such file or directory\n",
      "2024-01-17 19:26:11.858258: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcurand.so.10'; dlerror: libcurand.so.10: cannot open shared object file: No such file or directory\n",
      "2024-01-17 19:26:11.858278: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcusolver.so.11'; dlerror: libcusolver.so.11: cannot open shared object file: No such file or directory\n",
      "2024-01-17 19:26:11.858299: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcusparse.so.11'; dlerror: libcusparse.so.11: cannot open shared object file: No such file or directory\n",
      "2024-01-17 19:26:11.858320: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudnn.so.8'; dlerror: libcudnn.so.8: cannot open shared object file: No such file or directory\n",
      "2024-01-17 19:26:11.858325: W tensorflow/core/common_runtime/gpu/gpu_device.cc:1850] Cannot dlopen some GPU libraries. Please make sure the missing libraries mentioned above are installed properly if you would like to use GPU. Follow the guide at https://www.tensorflow.org/install/gpu for how to download and setup the required libraries for your platform.\n",
      "Skipping registering GPU devices...\n",
      "2024-01-17 19:26:11.858458: I tensorflow/core/platform/cpu_feature_guard.cc:151] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 AVX512F FMA\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
     ]
    }
   ],
   "source": [
    "# Load the original speech embedding model (now hosted on Kaggle) as a KerasLayer object\n",
    "\n",
    "embedding_model_url = \"https://tfhub.dev/google/speech_embedding/1\"\n",
    "embedding_model = hub.KerasLayer(embedding_model_url, trainable=False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "6769931f",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-01-18T00:26:12.375204Z",
     "start_time": "2024-01-18T00:26:12.259632Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Embedding Output Shape: (1, 1, 1, 96)\n"
     ]
    }
   ],
   "source": [
    "# Get predictions from the embedding model for a chunk of ~775 ms audio data (at 16khz)\n",
    "# This is the minimum input size for the model per the documentation here: https://www.kaggle.com/models/google/speech-embedding/frameworks/tensorFlow1/variations/speech-embedding/versions/1\n",
    "\n",
    "# Load sample clip, and select a 775 ms chunk and normalize between -1 and 1\n",
    "sr, sample_data = scipy.io.wavfile.read(\"../tests/data/hey_mycroft_test.wav\")\n",
    "sample_data = (sample_data[0:12400][None,]/32767).astype(np.float32)\n",
    "embeddings = embedding_model(sample_data)\n",
    "print(\"Embedding Output Shape:\", embeddings.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8acfba9",
   "metadata": {},
   "source": [
    "# Convert original model to tflite"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b4ee1693",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-01-18T00:26:14.554068Z",
     "start_time": "2024-01-18T00:26:12.376427Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.\n",
      "2024-01-17 19:26:12.970115: W tensorflow/python/util/util.cc:368] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: google_speech_embedding_fixed_input/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: google_speech_embedding_fixed_input/assets\n",
      "2024-01-17 19:26:14.061242: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:357] Ignored output_format.\n",
      "2024-01-17 19:26:14.061261: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:360] Ignored drop_control_dependency.\n",
      "2024-01-17 19:26:14.061688: I tensorflow/cc/saved_model/reader.cc:43] Reading SavedModel from: google_speech_embedding_fixed_input\n",
      "2024-01-17 19:26:14.066816: I tensorflow/cc/saved_model/reader.cc:78] Reading meta graph with tags { serve }\n",
      "2024-01-17 19:26:14.066828: I tensorflow/cc/saved_model/reader.cc:119] Reading SavedModel debug info (if present) from: google_speech_embedding_fixed_input\n",
      "2024-01-17 19:26:14.076781: I tensorflow/cc/saved_model/loader.cc:228] Restoring SavedModel bundle.\n",
      "2024-01-17 19:26:14.173155: I tensorflow/cc/saved_model/loader.cc:212] Running initialization op on SavedModel bundle at path: google_speech_embedding_fixed_input\n",
      "2024-01-17 19:26:14.236537: I tensorflow/cc/saved_model/loader.cc:301] SavedModel load for tags { serve }; Status: success: OK. Took 174850 microseconds.\n",
      "2024-01-17 19:26:14.288965: I tensorflow/compiler/mlir/tensorflow/utils/dump_mlir_util.cc:237] disabling MLIR crash reproducer, set env var `MLIR_CRASH_REPRODUCER_DIRECTORY` to enable.\n",
      "2024-01-17 19:26:14.405541: W tensorflow/compiler/mlir/lite/flatbuffer_export.cc:1881] Graph contains the following resource op(s), that use(s) resource type. Currently, the resource type is not natively supported in TFLite. Please consider not using the resource type if there are issues with either TFLite converter or TFLite runtime:\n",
      "Resource ops: TensorArrayGatherV3, TensorArrayReadV3, TensorArrayScatterV3, TensorArrayV3, TensorArrayWriteV3\n",
      "Details:\n",
      "\ttf.TensorArrayGatherV3(tensor<2x!tf_type.resource<tensor<*xf32>>>, tensor<?xi32>, tensor<f32>) -> (tensor<?x?x1x32xf32>) : {device = \"\", element_shape = #tf_type.shape<?x1x32>}\n",
      "\ttf.TensorArrayReadV3(tensor<2x!tf_type.resource<tensor<*xf32>>>, tensor<i32>, tensor<f32>) -> (tensor<*xf32>) : {device = \"\"}\n",
      "\ttf.TensorArrayScatterV3(tensor<2x!tf_type.resource<tensor<*xf32>>>, tensor<?xi32>, tensor<?x12400xf32>, tensor<f32>) -> (tensor<f32>) : {device = \"\"}\n",
      "\ttf.TensorArrayV3(tensor<i32>) -> (tensor<2x!tf_type.resource<tensor<*xf32>>>, tensor<f32>) : {clear_after_read = true, device = \"\", dtype = f32, dynamic_size = false, element_shape = #tf_type.shape<*>, identical_element_shapes = true, tensor_array_name = \"\"}\n",
      "\ttf.TensorArrayWriteV3(tensor<2x!tf_type.resource<tensor<*xf32>>>, tensor<i32>, tensor<?x?x?xf32>, tensor<f32>) -> (tensor<f32>) : {device = \"\"}\n",
      "2024-01-17 19:26:14.405561: W tensorflow/compiler/mlir/lite/flatbuffer_export.cc:1892] TFLite interpreter needs to link Flex delegate in order to run the model since it contains the following Select TFop(s):\n",
      "Flex ops: FlexTensorArrayGatherV3, FlexTensorArrayReadV3, FlexTensorArrayScatterV3, FlexTensorArrayV3, FlexTensorArrayWriteV3\n",
      "Details:\n",
      "\ttf.TensorArrayGatherV3(tensor<2x!tf_type.resource<tensor<*xf32>>>, tensor<?xi32>, tensor<f32>) -> (tensor<?x?x1x32xf32>) : {device = \"\", element_shape = #tf_type.shape<?x1x32>}\n",
      "\ttf.TensorArrayReadV3(tensor<2x!tf_type.resource<tensor<*xf32>>>, tensor<i32>, tensor<f32>) -> (tensor<*xf32>) : {device = \"\"}\n",
      "\ttf.TensorArrayScatterV3(tensor<2x!tf_type.resource<tensor<*xf32>>>, tensor<?xi32>, tensor<?x12400xf32>, tensor<f32>) -> (tensor<f32>) : {device = \"\"}\n",
      "\ttf.TensorArrayV3(tensor<i32>) -> (tensor<2x!tf_type.resource<tensor<*xf32>>>, tensor<f32>) : {clear_after_read = true, device = \"\", dtype = f32, dynamic_size = false, element_shape = #tf_type.shape<*>, identical_element_shapes = true, tensor_array_name = \"\"}\n",
      "\ttf.TensorArrayWriteV3(tensor<2x!tf_type.resource<tensor<*xf32>>>, tensor<i32>, tensor<?x?x?xf32>, tensor<f32>) -> (tensor<f32>) : {device = \"\"}\n",
      "See instructions: https://www.tensorflow.org/lite/guide/ops_select\n"
     ]
    }
   ],
   "source": [
    "# Build model with specific input size, and save\n",
    "inputs = tf.keras.Input((12400,))\n",
    "x = embedding_model(inputs)\n",
    "model = tf.keras.Model(inputs=inputs, outputs=x)\n",
    "model.save(\"google_speech_embedding_fixed_input\")\n",
    "\n",
    "speech_embedding_dir = \"google_speech_embedding_fixed_input\"\n",
    "# speech_embedding_dir = \"google_speech_embedding_savedmodel/\"\n",
    "\n",
    "converter = tf.lite.TFLiteConverter.from_saved_model(speech_embedding_dir)#, tags=[\"train\"])\n",
    "# convert = tf.lite.TFLiteConverter.from_keras_model(embedding_model)\n",
    "converter.target_spec.supported_ops = [\n",
    "  tf.lite.OpsSet.TFLITE_BUILTINS, tf.lite.OpsSet.SELECT_TF_OPS\n",
    "]\n",
    "# converter.allow_custom_ops = True\n",
    "\n",
    "tflite_model = converter.convert()\n",
    "with open(speech_embedding_dir + '/speech_embeddings.tflite', 'wb') as f:\n",
    "    f.write(tflite_model)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "927ebfda",
   "metadata": {},
   "source": [
    "# Comparing Log-Mel Features"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48c7138b",
   "metadata": {},
   "source": [
    "The speech embedding model from Google computes it's own input features from raw audio, which is convenient, but not ideal as it combines pre-processing with the model in a way that makes the model less understandable. In particular, this is (to my knowledge) the total information provided about the feature creation:\n",
    "\n",
    "From the model page [here:](https://www.kaggle.com/models/google/speech-embedding/frameworks/tensorFlow1/variations/speech-embedding/versions/1)\n",
    "```\n",
    "The module computes its own 32 dimensional log-mel features from the provided audio samples using the following parameters:\n",
    "\n",
    "    stft window size: 25ms\n",
    "    stft window step: 10ms\n",
    "    mel band limits: 60Hz - 3800Hz\n",
    "    mel frequency bins: 32\n",
    "```\n",
    "\n",
    "And then this excerpt from the corresponding [paper](https://arxiv.org/abs/2002.01322):\n",
    "\n",
    "```\n",
    "Our model is designed for deployment in an environment\n",
    "where both memory and compute power are very limited,\n",
    "such as on a digital signal processor (DSP). It runs on top of a\n",
    "low footprint feature extractor that provides a 32 dimensional\n",
    "log mel feature vector covering the frequency range from\n",
    "60 Hz to 3800 Hz, quantized to 8 bits every 10 ms\n",
    "```\n",
    "\n",
    "It seems likely that this implementation is simply a [spectrogram](https://librosa.org/doc/main/generated/librosa.feature.melspectrogram.html) with [log scaling](https://librosa.org/doc/main/generated/librosa.power_to_db.html), but the investigation below shows that this may note be the case.\n",
    "\n",
    "If you have a theory as to what the original model is doing, or why a standard log-mel spectrogram does not match, please open an issue on the [openWakeWord](https://github.com/dscripka/openWakeWord), I would love learn more about this!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "6599a6a0",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-01-18T00:26:14.703602Z",
     "start_time": "2024-01-18T00:26:14.555114Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO: Created TensorFlow Lite delegate for select TF ops.\n",
      "2024-01-17 19:26:14.557849: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2024-01-17 19:26:14.558198: W tensorflow/core/common_runtime/gpu/gpu_device.cc:1850] Cannot dlopen some GPU libraries. Please make sure the missing libraries mentioned above are installed properly if you would like to use GPU. Follow the guide at https://www.tensorflow.org/install/gpu for how to download and setup the required libraries for your platform.\n",
      "Skipping registering GPU devices...\n",
      "INFO: TfLiteFlexDelegate delegate: 4 nodes delegated out of 76 nodes with 2 partitions.\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Embedding model features shape: (32, 76)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Use the converted tflite model and get intermediate outputs to extract the log-mel features\n",
    "\n",
    "interpreter = tf.lite.Interpreter(\n",
    "    model_path=os.path.join(speech_embedding_dir, \"speech_embeddings.tflite\"),\n",
    "    num_threads=1,\n",
    "    experimental_preserve_all_tensors=True\n",
    ")\n",
    "interpreter.allocate_tensors()\n",
    "\n",
    "# Get input and output tensors\n",
    "input_details = interpreter.get_input_details()\n",
    "output_details = interpreter.get_output_details()\n",
    "interpreter.set_tensor(input_details[0]['index'], sample_data)\n",
    "interpreter.invoke()\n",
    "\n",
    "spec = interpreter.get_tensor(65)  # This index is the log-mel features, to my knowledge\n",
    "spec = spec.squeeze().T  # transform for visualization\n",
    "print(\"Embedding model features shape:\", spec.shape)\n",
    "\n",
    "_ = plt.imshow(spec)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc88eeaa",
   "metadata": {},
   "source": [
    "This certainly *looks* like a log-mel spectrogram, and we can compute the same from the reference Librosa implementation for comparison."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5363ba83",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-01-18T00:26:26.195376Z",
     "start_time": "2024-01-18T00:26:25.418886Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Librosa features shape: (32, 76)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import librosa\n",
    "\n",
    "S = librosa.feature.melspectrogram(y=sample_data, win_length=int(0.025*16000), \n",
    "                                   hop_length=int(0.010*16000), n_fft=512, center=True,\n",
    "                                   sr=16000, n_mels=32, fmin=60, fmax=3800, power=2)#, norm=None)\n",
    "\n",
    "S = librosa.power_to_db(S).squeeze()[:, 1:-1] # convert to logmel and remove edge columns from center=True\n",
    "\n",
    "print(\"Librosa features shape:\", spec.shape)\n",
    "_ = plt.imshow(S)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f03308c2",
   "metadata": {},
   "source": [
    "Visually, these mel-spectrograms are very similar, but on closer inspection there are differences. Plotting at a single time slice better shows the difference:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d80091c0",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-01-18T00:26:30.675702Z",
     "start_time": "2024-01-18T00:26:30.579560Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot single time slice from both melspectrograms\n",
    "_ = plt.plot(spec[:, 33])\n",
    "_ = plt.plot(S[:, 33]/10 + 2)  # apply simple scalar transformation to better align the points\n",
    "_ = plt.xlabel(\"Frequency Bins\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98dce06c",
   "metadata": {},
   "source": [
    "While the overall trend and specific frequency features are very similar between the two, they are not exact. After some time investigating this difference, eventually I moved on to other tasks with openWakeWord, and assumed that the similarity of the spectrograms would mean the downstream model performance would be relatively unnaffected. This assumption seems to have been largely true, and typically the performance difference between the openWakeWord implementation and the original Google embedding model is small.\n",
    "\n",
    "For completeness, below is the implementation of a melspectrogram using just PyTorch, so that it can be converted to ONNX/tflite for more efficient computation on a wide range of devices. This code was based on the implementation from [torchlibrosa](https://github.com/qiuqiangkong/torchlibrosa) and is identical to the librosa reference implementation to within rounding error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "07e24374",
   "metadata": {},
   "outputs": [],
   "source": [
    "# torchlibrosa version of melspectrogram\n",
    "\n",
    "import torch\n",
    "import torchlibrosa as tl\n",
    "import numpy as np\n",
    "\n",
    "batch_size = 1\n",
    "sample_rate = 16000\n",
    "win_length = 400\n",
    "hop_length = 160\n",
    "n_mels = 32\n",
    "nfft=512\n",
    "\n",
    "batch_audio = torch.empty(batch_size, 32000).uniform_(-1, 1)  # (batch_size, sample_rate)\n",
    "\n",
    "def f(self, input):\n",
    "    r\"\"\"Power to db, this function is the pytorch implementation of \n",
    "    librosa.power_to_lb.\n",
    "    \"\"\"\n",
    "    ref_value = self.ref\n",
    "    log_spec = 10.0 * torch.log(torch.clamp(input, min=self.amin, max=np.inf))/torch.log(torch.tensor(10))\n",
    "    log_spec -= 10.0 * torch.log(torch.maximum(torch.tensor(self.amin), torch.tensor(ref_value)))/torch.log(torch.tensor(10))\n",
    "\n",
    "    if self.top_db is not None:\n",
    "        if self.top_db < 0:\n",
    "            raise librosa.util.exceptions.ParameterError('top_db must be non-negative')\n",
    "        log_spec = torch.clamp(log_spec, min=log_spec.max() - self.top_db, max=np.inf)\n",
    "\n",
    "    return log_spec\n",
    "\n",
    "tl.stft.LogmelFilterBank.power_to_db = f\n",
    "\n",
    "# TorchLibrosa feature extractor the same as librosa.feature.melspectrogram()\n",
    "feature_extractor = torch.nn.Sequential(\n",
    "    tl.Spectrogram(\n",
    "        center=False,\n",
    "        n_fft=nfft,\n",
    "        hop_length=hop_length,\n",
    "        win_length=win_length,\n",
    "    ), tl.LogmelFilterBank(\n",
    "        n_fft=nfft,\n",
    "        sr=sample_rate,\n",
    "        n_mels=n_mels,\n",
    "        fmin=60,\n",
    "        fmax=3800,\n",
    "        is_log=True, # Default is true\n",
    "    ))\n",
    "\n",
    "# export to onnx\n",
    "torch.onnx.export(feature_extractor, batch_audio, \"torchlibrosa_onnx_melspectrogram.onnx\",\n",
    "                  opset_version=12, input_names = ['input'], output_names = ['output'], \n",
    "                  dynamic_axes={\"input\": {0: 'batch_size', 1: 'samples'}, \"output\": {0: 'time'}})\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbf87b19",
   "metadata": {},
   "source": [
    "# Create New Model with Keras"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6bda8bd3",
   "metadata": {},
   "source": [
    "After separting the log-mel feature calculution from the embedding model, we can now re-produce the rest of the model manually in Keras.\n",
    "\n",
    "Note that for many of the layers below, the hard-coded values and parameters were obtained by inspecting the tflite version of the original embedding model, using a tool like [Netron](http://www.netron.app)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "4fca0fa3",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-01-18T00:27:56.152072Z",
     "start_time": "2024-01-18T00:27:55.876595Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_1\"\n",
      "__________________________________________________________________________________________________\n",
      " Layer (type)                   Output Shape         Param #     Connected to                     \n",
      "==================================================================================================\n",
      " input_2 (InputLayer)           [(None, 76, 32, 1)]  0           []                               \n",
      "                                                                                                  \n",
      " zero_padding2d (ZeroPadding2D)  (None, 76, 34, 1)   0           ['input_2[0][0]']                \n",
      "                                                                                                  \n",
      " conv2d (Conv2D)                (None, 74, 32, 24)   216         ['zero_padding2d[0][0]']         \n",
      "                                                                                                  \n",
      " batch_normalization (BatchNorm  (None, 74, 32, 24)  96          ['conv2d[0][0]']                 \n",
      " alization)                                                                                       \n",
      "                                                                                                  \n",
      " tf.math.multiply (TFOpLambda)  (None, 74, 32, 24)   0           ['batch_normalization[0][0]']    \n",
      "                                                                                                  \n",
      " tf.math.truediv (TFOpLambda)   (None, 74, 32, 24)   0           ['tf.math.multiply[0][0]']       \n",
      "                                                                                                  \n",
      " tf.math.maximum (TFOpLambda)   (None, 74, 32, 24)   0           ['tf.math.truediv[0][0]',        \n",
      "                                                                  'batch_normalization[0][0]']    \n",
      "                                                                                                  \n",
      " tf.math.maximum_1 (TFOpLambda)  (None, 74, 32, 24)  0           ['tf.math.maximum[0][0]']        \n",
      "                                                                                                  \n",
      " conv2d_1 (Conv2D)              (None, 74, 32, 24)   1728        ['tf.math.maximum_1[0][0]']      \n",
      "                                                                                                  \n",
      " batch_normalization_1 (BatchNo  (None, 74, 32, 24)  96          ['conv2d_1[0][0]']               \n",
      " rmalization)                                                                                     \n",
      "                                                                                                  \n",
      " tf.math.multiply_1 (TFOpLambda  (None, 74, 32, 24)  0           ['batch_normalization_1[0][0]']  \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " tf.math.truediv_1 (TFOpLambda)  (None, 74, 32, 24)  0           ['tf.math.multiply_1[0][0]']     \n",
      "                                                                                                  \n",
      " tf.math.maximum_2 (TFOpLambda)  (None, 74, 32, 24)  0           ['tf.math.truediv_1[0][0]',      \n",
      "                                                                  'batch_normalization_1[0][0]']  \n",
      "                                                                                                  \n",
      " tf.math.maximum_3 (TFOpLambda)  (None, 74, 32, 24)  0           ['tf.math.maximum_2[0][0]']      \n",
      "                                                                                                  \n",
      " conv2d_2 (Conv2D)              (None, 72, 32, 24)   1728        ['tf.math.maximum_3[0][0]']      \n",
      "                                                                                                  \n",
      " batch_normalization_2 (BatchNo  (None, 72, 32, 24)  96          ['conv2d_2[0][0]']               \n",
      " rmalization)                                                                                     \n",
      "                                                                                                  \n",
      " tf.math.multiply_2 (TFOpLambda  (None, 72, 32, 24)  0           ['batch_normalization_2[0][0]']  \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " tf.math.truediv_2 (TFOpLambda)  (None, 72, 32, 24)  0           ['tf.math.multiply_2[0][0]']     \n",
      "                                                                                                  \n",
      " tf.math.maximum_4 (TFOpLambda)  (None, 72, 32, 24)  0           ['tf.math.truediv_2[0][0]',      \n",
      "                                                                  'batch_normalization_2[0][0]']  \n",
      "                                                                                                  \n",
      " tf.math.maximum_5 (TFOpLambda)  (None, 72, 32, 24)  0           ['tf.math.maximum_4[0][0]']      \n",
      "                                                                                                  \n",
      " max_pooling2d (MaxPooling2D)   (None, 36, 16, 24)   0           ['tf.math.maximum_5[0][0]']      \n",
      "                                                                                                  \n",
      " conv2d_3 (Conv2D)              (None, 36, 16, 48)   3456        ['max_pooling2d[0][0]']          \n",
      "                                                                                                  \n",
      " batch_normalization_3 (BatchNo  (None, 36, 16, 48)  192         ['conv2d_3[0][0]']               \n",
      " rmalization)                                                                                     \n",
      "                                                                                                  \n",
      " tf.math.multiply_3 (TFOpLambda  (None, 36, 16, 48)  0           ['batch_normalization_3[0][0]']  \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " tf.math.truediv_3 (TFOpLambda)  (None, 36, 16, 48)  0           ['tf.math.multiply_3[0][0]']     \n",
      "                                                                                                  \n",
      " tf.math.maximum_6 (TFOpLambda)  (None, 36, 16, 48)  0           ['tf.math.truediv_3[0][0]',      \n",
      "                                                                  'batch_normalization_3[0][0]']  \n",
      "                                                                                                  \n",
      " tf.math.maximum_7 (TFOpLambda)  (None, 36, 16, 48)  0           ['tf.math.maximum_6[0][0]']      \n",
      "                                                                                                  \n",
      " conv2d_4 (Conv2D)              (None, 34, 16, 48)   6912        ['tf.math.maximum_7[0][0]']      \n",
      "                                                                                                  \n",
      " batch_normalization_4 (BatchNo  (None, 34, 16, 48)  192         ['conv2d_4[0][0]']               \n",
      " rmalization)                                                                                     \n",
      "                                                                                                  \n",
      " tf.math.multiply_4 (TFOpLambda  (None, 34, 16, 48)  0           ['batch_normalization_4[0][0]']  \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " tf.math.truediv_4 (TFOpLambda)  (None, 34, 16, 48)  0           ['tf.math.multiply_4[0][0]']     \n",
      "                                                                                                  \n",
      " tf.math.maximum_8 (TFOpLambda)  (None, 34, 16, 48)  0           ['tf.math.truediv_4[0][0]',      \n",
      "                                                                  'batch_normalization_4[0][0]']  \n",
      "                                                                                                  \n",
      " tf.math.maximum_9 (TFOpLambda)  (None, 34, 16, 48)  0           ['tf.math.maximum_8[0][0]']      \n",
      "                                                                                                  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " conv2d_5 (Conv2D)              (None, 34, 16, 48)   6912        ['tf.math.maximum_9[0][0]']      \n",
      "                                                                                                  \n",
      " batch_normalization_5 (BatchNo  (None, 34, 16, 48)  192         ['conv2d_5[0][0]']               \n",
      " rmalization)                                                                                     \n",
      "                                                                                                  \n",
      " tf.math.multiply_5 (TFOpLambda  (None, 34, 16, 48)  0           ['batch_normalization_5[0][0]']  \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " tf.math.truediv_5 (TFOpLambda)  (None, 34, 16, 48)  0           ['tf.math.multiply_5[0][0]']     \n",
      "                                                                                                  \n",
      " tf.math.maximum_10 (TFOpLambda  (None, 34, 16, 48)  0           ['tf.math.truediv_5[0][0]',      \n",
      " )                                                                'batch_normalization_5[0][0]']  \n",
      "                                                                                                  \n",
      " tf.math.maximum_11 (TFOpLambda  (None, 34, 16, 48)  0           ['tf.math.maximum_10[0][0]']     \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " conv2d_6 (Conv2D)              (None, 32, 16, 48)   6912        ['tf.math.maximum_11[0][0]']     \n",
      "                                                                                                  \n",
      " batch_normalization_6 (BatchNo  (None, 32, 16, 48)  192         ['conv2d_6[0][0]']               \n",
      " rmalization)                                                                                     \n",
      "                                                                                                  \n",
      " tf.math.multiply_6 (TFOpLambda  (None, 32, 16, 48)  0           ['batch_normalization_6[0][0]']  \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " tf.math.truediv_6 (TFOpLambda)  (None, 32, 16, 48)  0           ['tf.math.multiply_6[0][0]']     \n",
      "                                                                                                  \n",
      " tf.math.maximum_12 (TFOpLambda  (None, 32, 16, 48)  0           ['tf.math.truediv_6[0][0]',      \n",
      " )                                                                'batch_normalization_6[0][0]']  \n",
      "                                                                                                  \n",
      " tf.math.maximum_13 (TFOpLambda  (None, 32, 16, 48)  0           ['tf.math.maximum_12[0][0]']     \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " max_pooling2d_1 (MaxPooling2D)  (None, 32, 8, 48)   0           ['tf.math.maximum_13[0][0]']     \n",
      "                                                                                                  \n",
      " conv2d_7 (Conv2D)              (None, 32, 8, 72)    10368       ['max_pooling2d_1[0][0]']        \n",
      "                                                                                                  \n",
      " batch_normalization_7 (BatchNo  (None, 32, 8, 72)   288         ['conv2d_7[0][0]']               \n",
      " rmalization)                                                                                     \n",
      "                                                                                                  \n",
      " tf.math.multiply_7 (TFOpLambda  (None, 32, 8, 72)   0           ['batch_normalization_7[0][0]']  \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " tf.math.truediv_7 (TFOpLambda)  (None, 32, 8, 72)   0           ['tf.math.multiply_7[0][0]']     \n",
      "                                                                                                  \n",
      " tf.math.maximum_14 (TFOpLambda  (None, 32, 8, 72)   0           ['tf.math.truediv_7[0][0]',      \n",
      " )                                                                'batch_normalization_7[0][0]']  \n",
      "                                                                                                  \n",
      " tf.math.maximum_15 (TFOpLambda  (None, 32, 8, 72)   0           ['tf.math.maximum_14[0][0]']     \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " conv2d_8 (Conv2D)              (None, 30, 8, 72)    15552       ['tf.math.maximum_15[0][0]']     \n",
      "                                                                                                  \n",
      " batch_normalization_8 (BatchNo  (None, 30, 8, 72)   288         ['conv2d_8[0][0]']               \n",
      " rmalization)                                                                                     \n",
      "                                                                                                  \n",
      " tf.math.multiply_8 (TFOpLambda  (None, 30, 8, 72)   0           ['batch_normalization_8[0][0]']  \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " tf.math.truediv_8 (TFOpLambda)  (None, 30, 8, 72)   0           ['tf.math.multiply_8[0][0]']     \n",
      "                                                                                                  \n",
      " tf.math.maximum_16 (TFOpLambda  (None, 30, 8, 72)   0           ['tf.math.truediv_8[0][0]',      \n",
      " )                                                                'batch_normalization_8[0][0]']  \n",
      "                                                                                                  \n",
      " tf.math.maximum_17 (TFOpLambda  (None, 30, 8, 72)   0           ['tf.math.maximum_16[0][0]']     \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " conv2d_9 (Conv2D)              (None, 30, 8, 72)    15552       ['tf.math.maximum_17[0][0]']     \n",
      "                                                                                                  \n",
      " batch_normalization_9 (BatchNo  (None, 30, 8, 72)   288         ['conv2d_9[0][0]']               \n",
      " rmalization)                                                                                     \n",
      "                                                                                                  \n",
      " tf.math.multiply_9 (TFOpLambda  (None, 30, 8, 72)   0           ['batch_normalization_9[0][0]']  \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " tf.math.truediv_9 (TFOpLambda)  (None, 30, 8, 72)   0           ['tf.math.multiply_9[0][0]']     \n",
      "                                                                                                  \n",
      " tf.math.maximum_18 (TFOpLambda  (None, 30, 8, 72)   0           ['tf.math.truediv_9[0][0]',      \n",
      " )                                                                'batch_normalization_9[0][0]']  \n",
      "                                                                                                  \n",
      " tf.math.maximum_19 (TFOpLambda  (None, 30, 8, 72)   0           ['tf.math.maximum_18[0][0]']     \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " conv2d_10 (Conv2D)             (None, 28, 8, 72)    15552       ['tf.math.maximum_19[0][0]']     \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                                                                                  \n",
      " batch_normalization_10 (BatchN  (None, 28, 8, 72)   288         ['conv2d_10[0][0]']              \n",
      " ormalization)                                                                                    \n",
      "                                                                                                  \n",
      " tf.math.multiply_10 (TFOpLambd  (None, 28, 8, 72)   0           ['batch_normalization_10[0][0]'] \n",
      " a)                                                                                               \n",
      "                                                                                                  \n",
      " tf.math.truediv_10 (TFOpLambda  (None, 28, 8, 72)   0           ['tf.math.multiply_10[0][0]']    \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " tf.math.maximum_20 (TFOpLambda  (None, 28, 8, 72)   0           ['tf.math.truediv_10[0][0]',     \n",
      " )                                                                'batch_normalization_10[0][0]'] \n",
      "                                                                                                  \n",
      " tf.math.maximum_21 (TFOpLambda  (None, 28, 8, 72)   0           ['tf.math.maximum_20[0][0]']     \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " max_pooling2d_2 (MaxPooling2D)  (None, 14, 4, 72)   0           ['tf.math.maximum_21[0][0]']     \n",
      "                                                                                                  \n",
      " conv2d_11 (Conv2D)             (None, 14, 4, 96)    20736       ['max_pooling2d_2[0][0]']        \n",
      "                                                                                                  \n",
      " batch_normalization_11 (BatchN  (None, 14, 4, 96)   384         ['conv2d_11[0][0]']              \n",
      " ormalization)                                                                                    \n",
      "                                                                                                  \n",
      " tf.math.multiply_11 (TFOpLambd  (None, 14, 4, 96)   0           ['batch_normalization_11[0][0]'] \n",
      " a)                                                                                               \n",
      "                                                                                                  \n",
      " tf.math.truediv_11 (TFOpLambda  (None, 14, 4, 96)   0           ['tf.math.multiply_11[0][0]']    \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " tf.math.maximum_22 (TFOpLambda  (None, 14, 4, 96)   0           ['tf.math.truediv_11[0][0]',     \n",
      " )                                                                'batch_normalization_11[0][0]'] \n",
      "                                                                                                  \n",
      " tf.math.maximum_23 (TFOpLambda  (None, 14, 4, 96)   0           ['tf.math.maximum_22[0][0]']     \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " conv2d_12 (Conv2D)             (None, 12, 4, 96)    27648       ['tf.math.maximum_23[0][0]']     \n",
      "                                                                                                  \n",
      " batch_normalization_12 (BatchN  (None, 12, 4, 96)   384         ['conv2d_12[0][0]']              \n",
      " ormalization)                                                                                    \n",
      "                                                                                                  \n",
      " tf.math.multiply_12 (TFOpLambd  (None, 12, 4, 96)   0           ['batch_normalization_12[0][0]'] \n",
      " a)                                                                                               \n",
      "                                                                                                  \n",
      " tf.math.truediv_12 (TFOpLambda  (None, 12, 4, 96)   0           ['tf.math.multiply_12[0][0]']    \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " tf.math.maximum_24 (TFOpLambda  (None, 12, 4, 96)   0           ['tf.math.truediv_12[0][0]',     \n",
      " )                                                                'batch_normalization_12[0][0]'] \n",
      "                                                                                                  \n",
      " tf.math.maximum_25 (TFOpLambda  (None, 12, 4, 96)   0           ['tf.math.maximum_24[0][0]']     \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " conv2d_13 (Conv2D)             (None, 12, 4, 96)    27648       ['tf.math.maximum_25[0][0]']     \n",
      "                                                                                                  \n",
      " batch_normalization_13 (BatchN  (None, 12, 4, 96)   384         ['conv2d_13[0][0]']              \n",
      " ormalization)                                                                                    \n",
      "                                                                                                  \n",
      " tf.math.multiply_13 (TFOpLambd  (None, 12, 4, 96)   0           ['batch_normalization_13[0][0]'] \n",
      " a)                                                                                               \n",
      "                                                                                                  \n",
      " tf.math.truediv_13 (TFOpLambda  (None, 12, 4, 96)   0           ['tf.math.multiply_13[0][0]']    \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " tf.math.maximum_26 (TFOpLambda  (None, 12, 4, 96)   0           ['tf.math.truediv_13[0][0]',     \n",
      " )                                                                'batch_normalization_13[0][0]'] \n",
      "                                                                                                  \n",
      " tf.math.maximum_27 (TFOpLambda  (None, 12, 4, 96)   0           ['tf.math.maximum_26[0][0]']     \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " conv2d_14 (Conv2D)             (None, 10, 4, 96)    27648       ['tf.math.maximum_27[0][0]']     \n",
      "                                                                                                  \n",
      " batch_normalization_14 (BatchN  (None, 10, 4, 96)   384         ['conv2d_14[0][0]']              \n",
      " ormalization)                                                                                    \n",
      "                                                                                                  \n",
      " tf.math.multiply_14 (TFOpLambd  (None, 10, 4, 96)   0           ['batch_normalization_14[0][0]'] \n",
      " a)                                                                                               \n",
      "                                                                                                  \n",
      " tf.math.truediv_14 (TFOpLambda  (None, 10, 4, 96)   0           ['tf.math.multiply_14[0][0]']    \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " tf.math.maximum_28 (TFOpLambda  (None, 10, 4, 96)   0           ['tf.math.truediv_14[0][0]',     \n",
      " )                                                                'batch_normalization_14[0][0]'] \n",
      "                                                                                                  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " tf.math.maximum_29 (TFOpLambda  (None, 10, 4, 96)   0           ['tf.math.maximum_28[0][0]']     \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " max_pooling2d_3 (MaxPooling2D)  (None, 10, 2, 96)   0           ['tf.math.maximum_29[0][0]']     \n",
      "                                                                                                  \n",
      " conv2d_15 (Conv2D)             (None, 10, 2, 96)    27648       ['max_pooling2d_3[0][0]']        \n",
      "                                                                                                  \n",
      " batch_normalization_15 (BatchN  (None, 10, 2, 96)   384         ['conv2d_15[0][0]']              \n",
      " ormalization)                                                                                    \n",
      "                                                                                                  \n",
      " tf.math.multiply_15 (TFOpLambd  (None, 10, 2, 96)   0           ['batch_normalization_15[0][0]'] \n",
      " a)                                                                                               \n",
      "                                                                                                  \n",
      " tf.math.truediv_15 (TFOpLambda  (None, 10, 2, 96)   0           ['tf.math.multiply_15[0][0]']    \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " tf.math.maximum_30 (TFOpLambda  (None, 10, 2, 96)   0           ['tf.math.truediv_15[0][0]',     \n",
      " )                                                                'batch_normalization_15[0][0]'] \n",
      "                                                                                                  \n",
      " tf.math.maximum_31 (TFOpLambda  (None, 10, 2, 96)   0           ['tf.math.maximum_30[0][0]']     \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " conv2d_16 (Conv2D)             (None, 8, 2, 96)     27648       ['tf.math.maximum_31[0][0]']     \n",
      "                                                                                                  \n",
      " batch_normalization_16 (BatchN  (None, 8, 2, 96)    384         ['conv2d_16[0][0]']              \n",
      " ormalization)                                                                                    \n",
      "                                                                                                  \n",
      " tf.math.multiply_16 (TFOpLambd  (None, 8, 2, 96)    0           ['batch_normalization_16[0][0]'] \n",
      " a)                                                                                               \n",
      "                                                                                                  \n",
      " tf.math.truediv_16 (TFOpLambda  (None, 8, 2, 96)    0           ['tf.math.multiply_16[0][0]']    \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " tf.math.maximum_32 (TFOpLambda  (None, 8, 2, 96)    0           ['tf.math.truediv_16[0][0]',     \n",
      " )                                                                'batch_normalization_16[0][0]'] \n",
      "                                                                                                  \n",
      " tf.math.maximum_33 (TFOpLambda  (None, 8, 2, 96)    0           ['tf.math.maximum_32[0][0]']     \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " conv2d_17 (Conv2D)             (None, 8, 2, 96)     27648       ['tf.math.maximum_33[0][0]']     \n",
      "                                                                                                  \n",
      " batch_normalization_17 (BatchN  (None, 8, 2, 96)    384         ['conv2d_17[0][0]']              \n",
      " ormalization)                                                                                    \n",
      "                                                                                                  \n",
      " tf.math.multiply_17 (TFOpLambd  (None, 8, 2, 96)    0           ['batch_normalization_17[0][0]'] \n",
      " a)                                                                                               \n",
      "                                                                                                  \n",
      " tf.math.truediv_17 (TFOpLambda  (None, 8, 2, 96)    0           ['tf.math.multiply_17[0][0]']    \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " tf.math.maximum_34 (TFOpLambda  (None, 8, 2, 96)    0           ['tf.math.truediv_17[0][0]',     \n",
      " )                                                                'batch_normalization_17[0][0]'] \n",
      "                                                                                                  \n",
      " tf.math.maximum_35 (TFOpLambda  (None, 8, 2, 96)    0           ['tf.math.maximum_34[0][0]']     \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " conv2d_18 (Conv2D)             (None, 6, 2, 96)     27648       ['tf.math.maximum_35[0][0]']     \n",
      "                                                                                                  \n",
      " batch_normalization_18 (BatchN  (None, 6, 2, 96)    384         ['conv2d_18[0][0]']              \n",
      " ormalization)                                                                                    \n",
      "                                                                                                  \n",
      " tf.math.multiply_18 (TFOpLambd  (None, 6, 2, 96)    0           ['batch_normalization_18[0][0]'] \n",
      " a)                                                                                               \n",
      "                                                                                                  \n",
      " tf.math.truediv_18 (TFOpLambda  (None, 6, 2, 96)    0           ['tf.math.multiply_18[0][0]']    \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " tf.math.maximum_36 (TFOpLambda  (None, 6, 2, 96)    0           ['tf.math.truediv_18[0][0]',     \n",
      " )                                                                'batch_normalization_18[0][0]'] \n",
      "                                                                                                  \n",
      " tf.math.maximum_37 (TFOpLambda  (None, 6, 2, 96)    0           ['tf.math.maximum_36[0][0]']     \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " max_pooling2d_4 (MaxPooling2D)  (None, 3, 1, 96)    0           ['tf.math.maximum_37[0][0]']     \n",
      "                                                                                                  \n",
      " conv2d_19 (Conv2D)             (None, 1, 1, 96)     27648       ['max_pooling2d_4[0][0]']        \n",
      "                                                                                                  \n",
      "==================================================================================================\n",
      "Total params: 332,088\n",
      "Trainable params: 329,448\n",
      "Non-trainable params: 2,640\n",
      "__________________________________________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "# Recreate the embedding model after the melspectrogram layers\n",
    "# That is, have the melspectrogram of the audio as the input instead of the raw audio\n",
    "\n",
    "# A custom function for the leaky relu activation function, to make exporting to ONNX/tflite easier\n",
    "def MyLeakyReLU(alpha = 0.20000000298023224*2):\n",
    "    return lambda x : tf.keras.backend.maximum(alpha * x/2, x)\n",
    "\n",
    "# Define convolutional block helper functions\n",
    "def batch_norm_and_activation(x):\n",
    "    x = tf.keras.layers.BatchNormalization()(x)\n",
    "    x = MyLeakyReLU()(x)\n",
    "    x = tf.maximum(x, -0.4000000059604645)\n",
    "    return x\n",
    "\n",
    "# Define contraint for zero mean conv2d layer\n",
    "class CenterAround(tf.keras.constraints.Constraint):\n",
    "    \"\"\"Constrains weight tensors to be centered around `ref_value`.\"\"\"\n",
    "    def __init__(self, ref_value):\n",
    "        self.ref_value = ref_value\n",
    "\n",
    "    def __call__(self, w):\n",
    "        mean = tf.reduce_mean(w, axis=(0,1))\n",
    "        return w - mean + self.ref_value\n",
    "\n",
    "\n",
    "# Contruct inputs\n",
    "inputs = tf.keras.Input((76, 32, 1)) # melspectrogram shape when provided with 12400 samples at 16 khz\n",
    "\n",
    "# Input conv block\n",
    "x = tf.keras.layers.ZeroPadding2D((0,1))(inputs)\n",
    "x = tf.keras.layers.Conv2D(24, (3,3), use_bias=False, kernel_constraint=CenterAround(0.0),\n",
    "                           activation='relu', padding='valid')(x)\n",
    "x = batch_norm_and_activation(x)\n",
    "\n",
    "# Conv block #1\n",
    "x = tf.keras.layers.Conv2D(24, (1,3), use_bias=False, padding='same')(x)\n",
    "x = batch_norm_and_activation(x)\n",
    "x = tf.keras.layers.Conv2D(24, (3,1), use_bias=False, padding='valid')(x)\n",
    "x = batch_norm_and_activation(x)\n",
    "x = tf.keras.layers.MaxPool2D((2,2), (2,2), padding='valid')(x)\n",
    "x = tf.keras.layers.Conv2D(48, (1,3), use_bias=False, padding='same')(x)\n",
    "x = batch_norm_and_activation(x)\n",
    "x = tf.keras.layers.Conv2D(48, (3,1), use_bias=False, padding='valid')(x)\n",
    "x = batch_norm_and_activation(x)\n",
    "\n",
    "# Conv block #2\n",
    "x = tf.keras.layers.Conv2D(48, (1,3), use_bias=False, padding='same')(x)\n",
    "x = batch_norm_and_activation(x)\n",
    "x = tf.keras.layers.Conv2D(48, (3,1), use_bias=False, padding='valid')(x)\n",
    "x = batch_norm_and_activation(x)\n",
    "x = tf.keras.layers.MaxPool2D((1,2), (1,2), padding='same')(x)\n",
    "x = tf.keras.layers.Conv2D(72, (1,3), use_bias=False, padding='same')(x)\n",
    "x = batch_norm_and_activation(x)\n",
    "x = tf.keras.layers.Conv2D(72, (3,1), use_bias=False, padding='valid')(x)\n",
    "x = batch_norm_and_activation(x)\n",
    "\n",
    "# Conv block #3\n",
    "x = tf.keras.layers.Conv2D(72, (1,3), use_bias=False, padding='same')(x)\n",
    "x = batch_norm_and_activation(x)\n",
    "x = tf.keras.layers.Conv2D(72, (3,1), use_bias=False, padding='valid')(x)\n",
    "x = batch_norm_and_activation(x)\n",
    "x = tf.keras.layers.MaxPool2D((2,2), (2,2), padding='valid')(x)\n",
    "x = tf.keras.layers.Conv2D(96, (1,3), use_bias=False, padding='same')(x)\n",
    "x = batch_norm_and_activation(x)\n",
    "x = tf.keras.layers.Conv2D(96, (3,1), use_bias=False, padding='valid')(x)\n",
    "x = batch_norm_and_activation(x)\n",
    "\n",
    "# Conv block #4\n",
    "x = tf.keras.layers.Conv2D(96, (1,3), use_bias=False, padding='same')(x)\n",
    "x = batch_norm_and_activation(x)\n",
    "x = tf.keras.layers.Conv2D(96, (3,1), use_bias=False, padding='valid')(x)\n",
    "x = batch_norm_and_activation(x)\n",
    "x = tf.keras.layers.MaxPool2D((1,2), (1,2), padding='valid')(x)\n",
    "x = tf.keras.layers.Conv2D(96, (1,3), use_bias=False, padding='same')(x)\n",
    "x = batch_norm_and_activation(x)\n",
    "x = tf.keras.layers.Conv2D(96, (3,1), use_bias=False, padding='valid')(x)\n",
    "x = batch_norm_and_activation(x)\n",
    "\n",
    "# Conv block #5\n",
    "x = tf.keras.layers.Conv2D(96, (1,3), use_bias=False, padding='same')(x)\n",
    "x = batch_norm_and_activation(x)\n",
    "x = tf.keras.layers.Conv2D(96, (3,1), use_bias=False, padding='valid')(x)\n",
    "x = batch_norm_and_activation(x)\n",
    "x = tf.keras.layers.MaxPool2D((2,2), (2,2), padding=\"valid\")(x)\n",
    "x = tf.keras.layers.Conv2D(96, (3,1), use_bias=False, padding='valid')(x)\n",
    "\n",
    "# Build the keras model\n",
    "reimplemented_model = tf.keras.Model(inputs=inputs, outputs=x)\n",
    "reimplemented_model.summary()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "3a83d707",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-01-18T00:28:05.030126Z",
     "start_time": "2024-01-18T00:28:05.008907Z"
    }
   },
   "outputs": [],
   "source": [
    "# Manually set the weights of the new Keras model with those from the original embedding model\n",
    "\n",
    "# Set weights for all layers\n",
    "reimplemented_model.set_weights(embedding_model.get_weights())\n",
    "\n",
    "# Adjust weights of specific layer that needs to be centered around 0.0\n",
    "reimplemented_model.layers[2].set_weights([CenterAround(0.0)(reimplemented_model.layers[2].weights[0])])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eba224b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert the new keras model to tflite format (optional for this notebook)\n",
    "converter = tf.lite.TFLiteConverter.from_keras_model(model)\n",
    "tflite_model = converter.convert()\n",
    "\n",
    "# Save the model.\n",
    "with open('embedding_model.tflite', 'wb') as f:\n",
    "    f.write(tflite_model)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7cfc246b",
   "metadata": {},
   "source": [
    "# Compare Predictions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4907f757",
   "metadata": {},
   "source": [
    "Now that we have a re-implemented embedding model, we can verify that the predictions are the same as the original. Note that as discussed previously, the log-mel feature calculation is different, so we will start from the original audio features obtained via tflite and calculate the final embeddings from there."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "6d6ba4b5",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-01-18T00:29:27.288771Z",
     "start_time": "2024-01-18T00:29:27.165734Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Get original embedding model prediction\n",
    "original_embeddings = embedding_model(sample_data)\n",
    "\n",
    "# Reshape original log-mel inputs from tflite model above and pass to re-implemented model\n",
    "reimplemented_embeddings = reimplemented_model(spec.T[None, ..., None])\n",
    "\n",
    "# Plot final output embeddings for the sample data\n",
    "_ = plt.plot(original_embeddings.numpy().flatten(), label=\"Original Google Model\")\n",
    "_ = plt.plot(reimplemented_embeddings.numpy().flatten(), label=\"Reimplemented Model\")\n",
    "_ = plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "ea6f9936",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-01-18T00:29:29.894151Z",
     "start_time": "2024-01-18T00:29:29.882876Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.00010585785"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check maximum absolute difference in the output embeddings to confirm practical equivalence\n",
    "np.abs(original_embeddings.numpy().flatten() - reimplemented_embeddings.numpy().flatten()).max()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "openwakeword_dev",
   "language": "python",
   "name": "openwakeword_dev"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.16"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "384px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}