build_model_db_mel_spectrogram.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# This notebook builds a model using Bayesian optimization and mel-spectrograms as input feature to the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "import keras_tuner\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from sklearn.model_selection import train_test_split\n",
    "from tensorflow import keras\n",
    "from tensorflow.keras import layers\n",
    "from tensorflow.keras.layers import Conv2D, MaxPool2D\n",
    "from tensorflow.keras.models import Sequential\n",
    "\n",
    "from methods_audio import data_handling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Get data (file names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Metal device set to: Apple M1 Pro\n",
      "\n",
      "systemMemory: 16.00 GB\n",
      "maxCacheSize: 5.33 GB\n",
      "\n"
     ]
    }
   ],
   "source": [
    "data = data_handling.get_data()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Read data (transforming file names into waves) <br>\n",
    "Additionally, the mean is removed and the data is normalized. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = data.map(data_handling.read_in_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Get input for model training "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-05-14 09:59:28.185802: W tensorflow/tsl/platform/profile_utils/cpu_utils.cc:128] Failed to get CPU frequency: 0 Hz\n"
     ]
    }
   ],
   "source": [
    "samples, labels = data_handling.extract_samples_labels(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Split data into train and validation sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "validation_set_size = 0.20\n",
    "x_train, x_valid, y_train, y_valid = train_test_split(samples, labels, test_size=validation_set_size, random_state=123)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. Transform data to db mel-spectrograms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "type_transformation = \"db_mel_spectrogram\"\n",
    "x_train = data_handling.transform_data(x_train, type_transformation)\n",
    "x_valid = data_handling.transform_data(x_valid, type_transformation)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Build model with hyperparameter tunning \n",
    "https://keras.io/guides/keras_tuner/getting_started/ <br>\n",
    "https://www.youtube.com/watch?v=6Nf1x7qThR8&ab_channel=GregHogg "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def build_model(hp):\n",
    "    input = (624, 128, 1)\n",
    "    model = keras.Sequential()\n",
    "\n",
    "    # Add input layer\n",
    "    # matching samples.shape\n",
    "    model.add(\n",
    "        Conv2D(\n",
    "            filters=hp.Int(\"conv_filters_0\", min_value=8, max_value=128, step=16),\n",
    "            activation=hp.Choice(\"conv_activation_0\", [\"relu\", \"tanh\"]),\n",
    "            kernel_size=(3, 3),\n",
    "            input_shape=input,\n",
    "        )\n",
    "    )\n",
    "    model.add(MaxPool2D(pool_size=(2, 2)))\n",
    "\n",
    "    # Tune the number of Conv layers\n",
    "    for i in range(hp.Int(\"num_conv_layers\", 1, 4)):\n",
    "        model.add(\n",
    "            Sequential(\n",
    "                [\n",
    "                    layers.Conv2D(\n",
    "                        filters=hp.Int(f\"conv_filters_{i}\", min_value=8, max_value=128, step=16),\n",
    "                        activation=hp.Choice(f\"conv_activation_{i}\", [\"relu\", \"tanh\"]),\n",
    "                        kernel_size=(4, 3),\n",
    "                    ),\n",
    "                    layers.MaxPool2D(pool_size=(2, 2)),\n",
    "                ]\n",
    "            )\n",
    "        )\n",
    "\n",
    "    model.add(layers.Flatten())\n",
    "\n",
    "    # Tune the number of Dense layers and Tune whether to use dropout layer\n",
    "    for i in range(hp.Int(\"num_dense_layers\", 1, 6)):\n",
    "        model.add(\n",
    "            Sequential(\n",
    "                [\n",
    "                    layers.Dense(\n",
    "                        # Tune number of units separately.\n",
    "                        units=hp.Int(f\"dense_units_{i}\", min_value=50, max_value=600, step=50),\n",
    "                        activation=hp.Choice(f\"dense_activation_{i}\", [\"relu\", \"tanh\"]),\n",
    "                    ),\n",
    "                    layers.Dropout(rate=hp.Float(f\"dense_dropout_{i}\", min_value=0, max_value=1)),\n",
    "                ]\n",
    "            )\n",
    "        )\n",
    "\n",
    "    model.add(\n",
    "        layers.Dense(\n",
    "            units=1,  # because we have 2 classes\n",
    "            activation=hp.Choice(\"activatio_last_layer\", [\"softmax\", \"sigmoid\"]),\n",
    "        )\n",
    "    )\n",
    "\n",
    "    # Define the optimizer learning rate as a hyperparameter.\n",
    "    # sampling=\"log\", the step is multiplied between samples.\n",
    "    lr = hp.Float(\"learning_rate\", min_value=1e-4, max_value=1e-1, sampling=\"log\")\n",
    "    model.compile(\n",
    "        optimizer=keras.optimizers.SGD(learning_rate=lr),\n",
    "        loss=\"BinaryCrossentropy\",\n",
    "        metrics=[\"accuracy\"],\n",
    "    )\n",
    "\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:At this time, the v2.11+ optimizer `tf.keras.optimizers.SGD` runs slowly on M1/M2 Macs, please use the legacy Keras optimizer instead, located at `tf.keras.optimizers.legacy.SGD`.\n",
      "WARNING:absl:There is a known slowdown when using v2.11+ Keras optimizers on M1/M2 Macs. Falling back to the legacy Keras optimizer, i.e., `tf.keras.optimizers.legacy.SGD`.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.engine.sequential.Sequential at 0x34545b040>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "build_model(keras_tuner.HyperParameters())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initialize tuner by specifying different arguments "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:At this time, the v2.11+ optimizer `tf.keras.optimizers.SGD` runs slowly on M1/M2 Macs, please use the legacy Keras optimizer instead, located at `tf.keras.optimizers.legacy.SGD`.\n",
      "WARNING:absl:There is a known slowdown when using v2.11+ Keras optimizers on M1/M2 Macs. Falling back to the legacy Keras optimizer, i.e., `tf.keras.optimizers.legacy.SGD`.\n"
     ]
    }
   ],
   "source": [
    "tuner = keras_tuner.BayesianOptimization(\n",
    "    hypermodel=build_model,\n",
    "    objective=\"val_accuracy\",  # we want maximize accuracy\n",
    "    max_trials=50,\n",
    "    overwrite=True,\n",
    "    directory=\"param_optimization\",\n",
    "    project_name=\"db_mel_spectrogram\",\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "stop_early = tf.keras.callbacks.EarlyStopping(monitor=\"val_loss\", patience=5)\n",
    "# patience refers to number of epochs: if the val loss is not improving fter 5 ephocs, we stop it."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### During the search, the model is called with different hyperparameters "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Search space summary\n",
      "Default search space size: 9\n",
      "conv_filters_0 (Int)\n",
      "{'default': None, 'conditions': [], 'min_value': 8, 'max_value': 128, 'step': 16, 'sampling': 'linear'}\n",
      "conv_activation_0 (Choice)\n",
      "{'default': 'relu', 'conditions': [], 'values': ['relu', 'tanh'], 'ordered': False}\n",
      "num_conv_layers (Int)\n",
      "{'default': None, 'conditions': [], 'min_value': 1, 'max_value': 4, 'step': 1, 'sampling': 'linear'}\n",
      "num_dense_layers (Int)\n",
      "{'default': None, 'conditions': [], 'min_value': 1, 'max_value': 6, 'step': 1, 'sampling': 'linear'}\n",
      "dense_units_0 (Int)\n",
      "{'default': None, 'conditions': [], 'min_value': 50, 'max_value': 600, 'step': 50, 'sampling': 'linear'}\n",
      "dense_activation_0 (Choice)\n",
      "{'default': 'relu', 'conditions': [], 'values': ['relu', 'tanh'], 'ordered': False}\n",
      "dense_dropout_0 (Float)\n",
      "{'default': 0.0, 'conditions': [], 'min_value': 0.0, 'max_value': 1.0, 'step': None, 'sampling': 'linear'}\n",
      "activatio_last_layer (Choice)\n",
      "{'default': 'softmax', 'conditions': [], 'values': ['softmax', 'sigmoid'], 'ordered': False}\n",
      "learning_rate (Float)\n",
      "{'default': 0.0001, 'conditions': [], 'min_value': 0.0001, 'max_value': 0.1, 'step': None, 'sampling': 'log'}\n"
     ]
    }
   ],
   "source": [
    "tuner.search_space_summary()\n",
    "# Default search space size: number of hyper parameters that we are tunning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "epochs = 50\n",
    "start_time = time.time()\n",
    "\n",
    "tuner.search(\n",
    "    np.stack(x_train),\n",
    "    np.stack(y_train),\n",
    "    epochs=epochs,\n",
    "    validation_data=(np.stack(x_valid), np.stack(y_valid)),\n",
    "    callbacks=[stop_early],\n",
    ")  # similar to fit\n",
    "\n",
    "end_time = time.time()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "elapsed_time = end_time - start_time\n",
    "print(f\"The search took {elapsed_time:.2f} seconds to finish.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tuner.results_summary()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### After all of that we don't have a model yet but rather a set of hyper parameters. Let's query the results and create a model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "best_hps = tuner.get_best_hyperparameters(num_trials=1)[0]\n",
    "print(best_hps.values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "learning_rate = best_hps.get(\"learning_rate\")\n",
    "print(learning_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = tuner.hypermodel.build(best_hps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "location = \"data/models/db_mel_spectrogram\"\n",
    "model.save(location)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "bach_thesis_4",
   "language": "python",
   "name": "python3"
  },
  "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"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}