lstm_2.0.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "speaker recognition using LSTM 1.0 - SAFII",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "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.7.0"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r5NH4GwXPf-H"
      },
      "source": [
        "This notebook is based on https://keras.io/examples/audio/speaker_recognition_using_cnn/"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "G2o8EqLYRB2-",
        "outputId": "4f9de19f-3c8d-4116-cc81-515faa1444c4"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fE7504HqPf-X"
      },
      "source": [
        "## Setup"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "l3Tr1AmtPf-Y"
      },
      "source": [
        "import os\n",
        "import shutil\n",
        "import numpy as np\n",
        "\n",
        "import tensorflow as tf\n",
        "from tensorflow import keras\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "from pathlib import Path\n",
        "from IPython.display import display, Audio\n",
        "\n",
        "# Get the data from https://www.kaggle.com/kongaevans/speaker-recognition-dataset/download\n",
        "# and save it to the 'Downloads' folder in your HOME directory\n",
        "DATASET_ROOT = \"/content/drive/MyDrive/AI_Project/archive/16000_pcm_speeches\"\n",
        "\n",
        "# The folders in which we will put the audio samples and the noise samples\n",
        "AUDIO_SUBFOLDER = \"audio\"\n",
        "NOISE_SUBFOLDER = \"noise\"\n",
        "\n",
        "DATASET_AUDIO_PATH = os.path.join(DATASET_ROOT, AUDIO_SUBFOLDER)\n",
        "DATASET_NOISE_PATH = os.path.join(DATASET_ROOT, NOISE_SUBFOLDER)\n",
        "\n",
        "# Percentage of samples to use for validation\n",
        "VALID_SPLIT = 0.1\n",
        "\n",
        "# Seed to use when shuffling the dataset and the noise\n",
        "SHUFFLE_SEED = 43\n",
        "\n",
        "# The sampling rate to use.\n",
        "# This is the one used in all of the audio samples.\n",
        "# We will resample all of the noise to this sampling rate.\n",
        "# This will also be the output size of the audio wave samples\n",
        "# (since all samples are of 1 second long)\n",
        "SAMPLING_RATE = 16000\n",
        "\n",
        "# The factor to multiply the noise with according to:\n",
        "#   noisy_sample = sample + noise * prop * scale\n",
        "#      where prop = sample_amplitude / noise_amplitude\n",
        "SCALE = 0.5\n",
        "\n",
        "BATCH_SIZE = 64\n",
        "EPOCHS = 50\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ucuokhmjPf-a"
      },
      "source": [
        "## Data preparation\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a53l-S4TPf-c"
      },
      "source": [
        "# If folder `audio`, does not exist, create it, otherwise do nothing\n",
        "if os.path.exists(DATASET_AUDIO_PATH) is False:\n",
        "    os.makedirs(DATASET_AUDIO_PATH)\n",
        "\n",
        "# If folder `noise`, does not exist, create it, otherwise do nothing\n",
        "if os.path.exists(DATASET_NOISE_PATH) is False:\n",
        "    os.makedirs(DATASET_NOISE_PATH)\n",
        "\n",
        "for folder in os.listdir(DATASET_ROOT):\n",
        "    if os.path.isdir(os.path.join(DATASET_ROOT, folder)):\n",
        "        if folder in [AUDIO_SUBFOLDER, NOISE_SUBFOLDER]:\n",
        "            # If folder is `audio` or `noise`, do nothing\n",
        "            continue\n",
        "        elif folder in [\"other\", \"_background_noise_\"]:\n",
        "            # If folder is one of the folders that contains noise samples,\n",
        "            # move it to the `noise` folder\n",
        "            shutil.move(\n",
        "                os.path.join(DATASET_ROOT, folder),\n",
        "                os.path.join(DATASET_NOISE_PATH, folder),\n",
        "            )\n",
        "        else:\n",
        "            # Otherwise, it should be a speaker folder, then move it to\n",
        "            # `audio` folder\n",
        "            shutil.move(\n",
        "                os.path.join(DATASET_ROOT, folder),\n",
        "                os.path.join(DATASET_AUDIO_PATH, folder),\n",
        "            )"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GIyyY2rMPf-d"
      },
      "source": [
        "## Noise preparation\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hAt1lAEfPf-e",
        "outputId": "40347a28-edb4-4b02-bc3e-e02180178757"
      },
      "source": [
        "# Get the list of all noise files\n",
        "noise_paths = []\n",
        "for subdir in os.listdir(DATASET_NOISE_PATH):\n",
        "    subdir_path = Path(DATASET_NOISE_PATH) / subdir\n",
        "    if os.path.isdir(subdir_path):\n",
        "        noise_paths += [\n",
        "            os.path.join(subdir_path, filepath)\n",
        "            for filepath in os.listdir(subdir_path)\n",
        "            if filepath.endswith(\".wav\")\n",
        "        ]\n",
        "\n",
        "print(\n",
        "    \"Found {} files belonging to {} directories\".format(\n",
        "        len(noise_paths), len(os.listdir(DATASET_NOISE_PATH))\n",
        "    )\n",
        ")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Found 6 files belonging to 2 directories\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0GJ6aKitPf-g"
      },
      "source": [
        "Resample all noise samples to 16000 Hz"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J3lqyjExPf-j",
        "outputId": "e1d81639-00bc-4c47-8b68-7072b0ed34cb"
      },
      "source": [
        "command = (\n",
        "    \"for dir in `ls -1 \" + DATASET_NOISE_PATH + \"`; do \"\n",
        "    \"for file in `ls -1 \" + DATASET_NOISE_PATH + \"/$dir/*.wav`; do \"\n",
        "    \"sample_rate=`ffprobe -hide_banner -loglevel panic -show_streams \"\n",
        "    \"$file | grep sample_rate | cut -f2 -d=`; \"\n",
        "    \"if [ $sample_rate -ne 16000 ]; then \"\n",
        "    \"ffmpeg -hide_banner -loglevel panic -y \"\n",
        "    \"-i $file -ar 16000 temp.wav; \"\n",
        "    \"mv temp.wav $file; \"\n",
        "    \"fi; done; done\"\n",
        ")\n",
        "os.system(command)\n",
        "\n",
        "# Split noise into chunks of 16,000 steps each\n",
        "def load_noise_sample(path):\n",
        "    sample, sampling_rate = tf.audio.decode_wav(\n",
        "        tf.io.read_file(path), desired_channels=1\n",
        "    )\n",
        "    if sampling_rate == SAMPLING_RATE:\n",
        "        # Number of slices of 16000 each that can be generated from the noise sample\n",
        "        slices = int(sample.shape[0] / SAMPLING_RATE)\n",
        "        sample = tf.split(sample[: slices * SAMPLING_RATE], slices)\n",
        "        return sample\n",
        "    else:\n",
        "        print(\"Sampling rate for {} is incorrect. Ignoring it\".format(path))\n",
        "        return None\n",
        "\n",
        "\n",
        "noises = []\n",
        "for path in noise_paths:\n",
        "    sample = load_noise_sample(path)\n",
        "    if sample:\n",
        "        noises.extend(sample)\n",
        "noises = tf.stack(noises)\n",
        "\n",
        "print(\n",
        "    \"{} noise files were split into {} noise samples where each is {} sec. long\".format(\n",
        "        len(noise_paths), noises.shape[0], noises.shape[1] // SAMPLING_RATE\n",
        "    )\n",
        ")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "6 noise files were split into 354 noise samples where each is 1 sec. long\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zzDrLvOTPf-l"
      },
      "source": [
        "## Dataset generation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d1g7BQdFPf-l",
        "outputId": "0204e56e-7d0e-4603-ad93-64d30b73a474"
      },
      "source": [
        "\n",
        "def paths_and_labels_to_dataset(audio_paths, labels):\n",
        "    \"\"\"Constructs a dataset of audios and labels.\"\"\"\n",
        "    path_ds = tf.data.Dataset.from_tensor_slices(audio_paths)\n",
        "    audio_ds = path_ds.map(lambda x: path_to_audio(x))\n",
        "    label_ds = tf.data.Dataset.from_tensor_slices(labels)\n",
        "    return tf.data.Dataset.zip((audio_ds, label_ds))\n",
        "\n",
        "\n",
        "def path_to_audio(path):\n",
        "    \"\"\"Reads and decodes an audio file.\"\"\"\n",
        "    audio = tf.io.read_file(path)\n",
        "    audio, _ = tf.audio.decode_wav(audio, 1, SAMPLING_RATE)\n",
        "    return audio\n",
        "\n",
        "\n",
        "def add_noise(audio, noises=None, scale=0.5):\n",
        "    if noises is not None:\n",
        "        # Create a random tensor of the same size as audio ranging from\n",
        "        # 0 to the number of noise stream samples that we have.\n",
        "        tf_rnd = tf.random.uniform(\n",
        "            (tf.shape(audio)[0],), 0, noises.shape[0], dtype=tf.int32\n",
        "        )\n",
        "        noise = tf.gather(noises, tf_rnd, axis=0)\n",
        "\n",
        "        # Get the amplitude proportion between the audio and the noise\n",
        "        prop = tf.math.reduce_max(audio, axis=1) / tf.math.reduce_max(noise, axis=1)\n",
        "        prop = tf.repeat(tf.expand_dims(prop, axis=1), tf.shape(audio)[1], axis=1)\n",
        "\n",
        "        # Adding the rescaled noise to audio\n",
        "        audio = audio + noise * prop * scale\n",
        "\n",
        "    return audio\n",
        "\n",
        "\n",
        "def audio_to_fft(audio):\n",
        "    # Since tf.signal.fft applies FFT on the innermost dimension,\n",
        "    # we need to squeeze the dimensions and then expand them again\n",
        "    # after FFT\n",
        "    audio = tf.squeeze(audio, axis=-1)\n",
        "    fft = tf.signal.fft(\n",
        "        tf.cast(tf.complex(real=audio, imag=tf.zeros_like(audio)), tf.complex64)\n",
        "    )\n",
        "    fft = tf.expand_dims(fft, axis=-1)\n",
        "\n",
        "    # Return the absolute value of the first half of the FFT\n",
        "    # which represents the positive frequencies\n",
        "    return tf.math.abs(fft[:, : (audio.shape[1] // 2), :])\n",
        "\n",
        "\n",
        "# Get the list of audio file paths along with their corresponding labels\n",
        "\n",
        "class_names = os.listdir(DATASET_AUDIO_PATH)\n",
        "print(\"Our class names: {}\".format(class_names,))\n",
        "\n",
        "audio_paths = []\n",
        "labels = []\n",
        "for label, name in enumerate(class_names):\n",
        "    print(\"Processing speaker {}\".format(name,))\n",
        "    dir_path = Path(DATASET_AUDIO_PATH) / name\n",
        "    speaker_sample_paths = [\n",
        "        os.path.join(dir_path, filepath)\n",
        "        for filepath in os.listdir(dir_path)\n",
        "        if filepath.endswith(\".wav\")\n",
        "    ]\n",
        "    audio_paths += speaker_sample_paths\n",
        "    labels += [label] * len(speaker_sample_paths)\n",
        "\n",
        "print(\n",
        "    \"Found {} files belonging to {} classes.\".format(len(audio_paths), len(class_names))\n",
        ")\n",
        "\n",
        "# Shuffle\n",
        "rng = np.random.RandomState(SHUFFLE_SEED)\n",
        "rng.shuffle(audio_paths)\n",
        "rng = np.random.RandomState(SHUFFLE_SEED)\n",
        "rng.shuffle(labels)\n",
        "\n",
        "# Split into training and validation\n",
        "num_val_samples = int(VALID_SPLIT * len(audio_paths))\n",
        "print(\"Using {} files for training.\".format(len(audio_paths) - num_val_samples))\n",
        "train_audio_paths = audio_paths[:-num_val_samples]\n",
        "train_labels = labels[:-num_val_samples]\n",
        "\n",
        "print(\"Using {} files for validation.\".format(num_val_samples))\n",
        "valid_audio_paths = audio_paths[-num_val_samples:]\n",
        "valid_labels = labels[-num_val_samples:]\n",
        "\n",
        "# Create 2 datasets, one for training and the other for validation\n",
        "train_ds = paths_and_labels_to_dataset(train_audio_paths, train_labels)\n",
        "train_ds = train_ds.shuffle(buffer_size=BATCH_SIZE * 8, seed=SHUFFLE_SEED).batch(\n",
        "    BATCH_SIZE\n",
        ")\n",
        "\n",
        "valid_ds = paths_and_labels_to_dataset(valid_audio_paths, valid_labels)\n",
        "valid_ds = valid_ds.shuffle(buffer_size=32 * 8, seed=SHUFFLE_SEED).batch(32)\n",
        "\n",
        "\n",
        "# Add noise to the training set\n",
        "train_ds = train_ds.map(\n",
        "    lambda x, y: (add_noise(x, noises, scale=SCALE), y),\n",
        "    num_parallel_calls=tf.data.experimental.AUTOTUNE,\n",
        ")\n",
        "\n",
        "# Transform audio wave to the frequency domain using `audio_to_fft`\n",
        "train_ds = train_ds.map(\n",
        "    lambda x, y: (audio_to_fft(x), y), num_parallel_calls=tf.data.experimental.AUTOTUNE\n",
        ")\n",
        "train_ds = train_ds.prefetch(tf.data.experimental.AUTOTUNE)\n",
        "\n",
        "valid_ds = valid_ds.map(\n",
        "    lambda x, y: (audio_to_fft(x), y), num_parallel_calls=tf.data.experimental.AUTOTUNE\n",
        ")\n",
        "valid_ds = valid_ds.prefetch(tf.data.experimental.AUTOTUNE)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Our class names: ['Benjamin_Netanyau', 'Nelson_Mandela', 'Julia_Gillard', 'Jens_Stoltenberg', 'Magaret_Tarcher', 'Fatima_Azim', 'Safiya_Mehmood', 'Husun_Bano']\n",
            "Processing speaker Benjamin_Netanyau\n",
            "Processing speaker Nelson_Mandela\n",
            "Processing speaker Julia_Gillard\n",
            "Processing speaker Jens_Stoltenberg\n",
            "Processing speaker Magaret_Tarcher\n",
            "Processing speaker Fatima_Azim\n",
            "Processing speaker Safiya_Mehmood\n",
            "Processing speaker Husun_Bano\n",
            "Found 12002 files belonging to 8 classes.\n",
            "Using 10802 files for training.\n",
            "Using 1200 files for validation.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Mmg3sdNtPf-o"
      },
      "source": [
        "## Model Definition"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NwGfeGg3Pf-q",
        "outputId": "bba36f52-b0dd-4c5e-fa47-ee4b60b1ea9c"
      },
      "source": [
        "from keras.layers import LSTM, Dense, Dropout, Flatten\n",
        "from keras.models import Sequential\n",
        " \n",
        "def build_model():\n",
        "    input_shape = (None, 8000, 1)\n",
        "    \n",
        "    model = Sequential()\n",
        "    # model.add(LSTM(64, batch_input_shape=(None, 8000, 1), activation='tanh', return_sequences=True))\n",
        "    # model.add(LSTM(75, activation='tanh', return_sequences=True, dropout=0.2))\n",
        "    # model.add(LSTM(64, activation='tanh'))\n",
        "    # model.add(Dense(8, activation='softmax'))\n",
        "    model.add(LSTM(256, return_sequences=True, batch_input_shape=(None, 8000, 1), dropout=0.5))\n",
        "    model.add(LSTM(128, return_sequences=True))\n",
        "    model.add(Flatten())\n",
        "    model.add(Dense(128, activation='relu'))\n",
        "    model.add(Dropout(0.5))\n",
        "    model.add(Dense(8, activation='softmax'))\n",
        "    return model\n",
        " \n",
        "\n",
        "model = build_model()\n",
        "model.summary()\n",
        " \n",
        "#ADJUSTING LEARNING RATE\n",
        "optimizer = keras.optimizers.Adam(lr=0.001)\n",
        " \n",
        " \n",
        "# Compile the model using Adam's default learning rate\n",
        "model.compile(\n",
        "    optimizer=optimizer, loss=\"sparse_categorical_crossentropy\", metrics=[\"accuracy\"]\n",
        ")\n",
        " \n",
        "# Add callbacks:\n",
        "# 'EarlyStopping' to stop training when the model is not enhancing anymore\n",
        "# 'ModelCheckPoint' to always keep the model that has the best val_accuracy\n",
        "model_save_filename = \"model.h5\"\n",
        " \n",
        "earlystopping_cb = keras.callbacks.EarlyStopping(patience=5, restore_best_weights=True)\n",
        "mdlcheckpoint_cb = keras.callbacks.ModelCheckpoint(\n",
        "    model_save_filename, monitor=\"val_accuracy\", save_best_only=True\n",
        ")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Model: \"sequential_19\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "lstm_23 (LSTM)               (None, 8000, 256)         264192    \n",
            "_________________________________________________________________\n",
            "lstm_24 (LSTM)               (None, 8000, 128)         197120    \n",
            "_________________________________________________________________\n",
            "flatten_13 (Flatten)         (None, 1024000)           0         \n",
            "_________________________________________________________________\n",
            "dense_31 (Dense)             (None, 128)               131072128 \n",
            "_________________________________________________________________\n",
            "dropout_15 (Dropout)         (None, 128)               0         \n",
            "_________________________________________________________________\n",
            "dense_32 (Dense)             (None, 8)                 1032      \n",
            "=================================================================\n",
            "Total params: 131,534,472\n",
            "Trainable params: 131,534,472\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3Cj8U_IMSvFh",
        "outputId": "9003c5b9-e3ee-4195-a014-13c73c244927"
      },
      "source": [
        "train_ds"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<PrefetchDataset shapes: ((None, 8000, 1), (None,)), types: (tf.float32, tf.int32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "18oekipEPf-s"
      },
      "source": [
        "## Training"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "mXS_KTo4Pf-t",
        "outputId": "cdd55110-0087-4f36-82ad-99d5c2ebc972"
      },
      "source": [
        "history = model.fit(\n",
        "    train_ds,\n",
        "    batch_size=BATCH_SIZE,\n",
        "    #steps_per_epoch=50,\n",
        "    epochs=EPOCHS,\n",
        "    validation_data=valid_ds,\n",
        "    validation_steps=5,\n",
        "    callbacks=[earlystopping_cb, mdlcheckpoint_cb],\n",
        ")\n",
        "\n",
        "# list all data in history\n",
        "print(history.history.keys())\n",
        "# summarize history for accuracy\n",
        "plt.plot(history.history['accuracy'])\n",
        "plt.plot(history.history['val_accuracy'])  \n",
        "plt.title('model accuracy')\n",
        "plt.ylabel('accuracy')\n",
        "plt.xlabel('epoch')\n",
        "plt.legend(['train', 'test'], loc='upper left')\n",
        "plt.show()\n",
        "# summarize history for loss\n",
        "plt.plot(history.history['loss'])\n",
        "plt.plot(history.history['val_loss'])\n",
        "plt.title('model loss') \n",
        "plt.ylabel('loss')    \n",
        "plt.xlabel('epoch')\n",
        "plt.legend(['train', 'test'], loc='upper left') \n",
        "plt.show() "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/50\n",
            "169/169 [==============================] - 199s 1s/step - loss: 9.4691 - accuracy: 0.1870 - val_loss: 1.8011 - val_accuracy: 0.2875\n",
            "Epoch 2/50\n",
            "169/169 [==============================] - 197s 1s/step - loss: 1.8140 - accuracy: 0.2594 - val_loss: 1.7530 - val_accuracy: 0.3125\n",
            "Epoch 3/50\n",
            "169/169 [==============================] - 199s 1s/step - loss: 1.6506 - accuracy: 0.3112 - val_loss: 1.9579 - val_accuracy: 0.2562\n",
            "Epoch 4/50\n",
            "169/169 [==============================] - 199s 1s/step - loss: 1.4671 - accuracy: 0.3812 - val_loss: 1.7518 - val_accuracy: 0.2875\n",
            "Epoch 5/50\n",
            "169/169 [==============================] - 199s 1s/step - loss: 1.4358 - accuracy: 0.3877 - val_loss: 1.5396 - val_accuracy: 0.3313\n",
            "Epoch 6/50\n",
            "169/169 [==============================] - 200s 1s/step - loss: 1.4283 - accuracy: 0.4091 - val_loss: 1.3205 - val_accuracy: 0.4437\n",
            "Epoch 7/50\n",
            "169/169 [==============================] - 199s 1s/step - loss: 1.3382 - accuracy: 0.4413 - val_loss: 1.3077 - val_accuracy: 0.4875\n",
            "Epoch 8/50\n",
            "169/169 [==============================] - 200s 1s/step - loss: 1.3322 - accuracy: 0.4521 - val_loss: 1.2486 - val_accuracy: 0.4750\n",
            "Epoch 9/50\n",
            "169/169 [==============================] - 200s 1s/step - loss: 1.2570 - accuracy: 0.4808 - val_loss: 1.1780 - val_accuracy: 0.6062\n",
            "Epoch 10/50\n",
            "169/169 [==============================] - 200s 1s/step - loss: 1.2736 - accuracy: 0.4863 - val_loss: 1.1993 - val_accuracy: 0.5250\n",
            "Epoch 11/50\n",
            "169/169 [==============================] - 200s 1s/step - loss: 1.1848 - accuracy: 0.5225 - val_loss: 1.2443 - val_accuracy: 0.4750\n",
            "Epoch 12/50\n",
            "169/169 [==============================] - 200s 1s/step - loss: 1.1545 - accuracy: 0.5284 - val_loss: 1.5119 - val_accuracy: 0.4375\n",
            "Epoch 13/50\n",
            "169/169 [==============================] - 200s 1s/step - loss: 1.1382 - accuracy: 0.5458 - val_loss: 1.1593 - val_accuracy: 0.5125\n",
            "Epoch 14/50\n",
            "169/169 [==============================] - 200s 1s/step - loss: 1.1389 - accuracy: 0.5398 - val_loss: 1.2209 - val_accuracy: 0.5063\n",
            "Epoch 15/50\n",
            "169/169 [==============================] - 201s 1s/step - loss: 1.0613 - accuracy: 0.5714 - val_loss: 1.1483 - val_accuracy: 0.5625\n",
            "Epoch 16/50\n",
            "169/169 [==============================] - 200s 1s/step - loss: 0.9748 - accuracy: 0.6078 - val_loss: 1.6464 - val_accuracy: 0.4625\n",
            "Epoch 17/50\n",
            "169/169 [==============================] - 200s 1s/step - loss: 0.9174 - accuracy: 0.6372 - val_loss: 1.4940 - val_accuracy: 0.4875\n",
            "Epoch 18/50\n",
            "169/169 [==============================] - 201s 1s/step - loss: 0.9242 - accuracy: 0.6310 - val_loss: 0.9474 - val_accuracy: 0.5875\n",
            "Epoch 19/50\n",
            "169/169 [==============================] - 201s 1s/step - loss: 0.8966 - accuracy: 0.6381 - val_loss: 0.7523 - val_accuracy: 0.7250\n",
            "Epoch 20/50\n",
            "169/169 [==============================] - 201s 1s/step - loss: 0.8903 - accuracy: 0.6354 - val_loss: 1.0769 - val_accuracy: 0.6750\n",
            "Epoch 21/50\n",
            "169/169 [==============================] - 201s 1s/step - loss: 0.8426 - accuracy: 0.6584 - val_loss: 0.9727 - val_accuracy: 0.6687\n",
            "Epoch 22/50\n",
            "169/169 [==============================] - 200s 1s/step - loss: 0.8013 - accuracy: 0.6825 - val_loss: 1.0190 - val_accuracy: 0.6313\n",
            "Epoch 23/50\n",
            "169/169 [==============================] - 200s 1s/step - loss: 0.8076 - accuracy: 0.6853 - val_loss: 1.0051 - val_accuracy: 0.6313\n",
            "Epoch 24/50\n",
            "169/169 [==============================] - 201s 1s/step - loss: 0.7711 - accuracy: 0.6873 - val_loss: 1.0302 - val_accuracy: 0.7063\n",
            "dict_keys(['loss', 'accuracy', 'val_loss', 'val_accuracy'])\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HABBF8DgPf-u"
      },
      "source": [
        "## Evaluation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sYcmjZ-NdLFS",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8e70d728-6566-406f-8997-c1755113f02a"
      },
      "source": [
        "print(model.evaluate(train_ds))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "169/169 [==============================] - 134s 783ms/step - loss: 0.6303 - accuracy: 0.8164\n",
            "[0.6302580237388611, 0.8164228796958923]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zyXlfyawPf-w",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b5f5d580-3a01-4201-c901-863be559f025"
      },
      "source": [
        "print(model.evaluate(valid_ds))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "38/38 [==============================] - 18s 444ms/step - loss: 0.7644 - accuracy: 0.7533\n",
            "[0.7644160389900208, 0.753333330154419]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y4OX_XYUFK_q"
      },
      "source": [
        "###Final Accuracy after Hyperparameter Tuning: 75%"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WKc_OArQPf-y"
      },
      "source": [
        "## Demonstration\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YeKBqzb3Pf-z"
      },
      "source": [
        "SAMPLES_TO_DISPLAY = 20\n",
        "\n",
        "test_ds = paths_and_labels_to_dataset(valid_audio_paths, valid_labels)\n",
        "test_ds = test_ds.shuffle(buffer_size=BATCH_SIZE * 8, seed=SHUFFLE_SEED).batch(\n",
        "    BATCH_SIZE\n",
        ")\n",
        "\n",
        "test_ds = test_ds.map(lambda x, y: (add_noise(x, noises, scale=SCALE), y))\n",
        "\n",
        "for audios, labels in test_ds.take(1):\n",
        "    # Get the signal FFT\n",
        "    ffts = audio_to_fft(audios)\n",
        "    # Predict\n",
        "    y_pred = model.predict(ffts)\n",
        "    # Take random samples\n",
        "    rnd = np.random.randint(0, BATCH_SIZE, SAMPLES_TO_DISPLAY)\n",
        "    audios = audios.numpy()[rnd, :, :]\n",
        "    labels = labels.numpy()[rnd]\n",
        "    y_pred = np.argmax(y_pred, axis=-1)[rnd]\n",
        "\n",
        "    for index in range(SAMPLES_TO_DISPLAY):\n",
        "        # For every sample, print the true and predicted label\n",
        "        # as well as run the voice with the noise\n",
        "        print(\n",
        "            \"Speaker:\\33{} {}\\33[0m\\tPredicted:\\33{} {}\\33[0m\".format(\n",
        "                \"[92m\" if labels[index] == y_pred[index] else \"[91m\",\n",
        "                class_names[labels[index]],\n",
        "                \"[92m\" if labels[index] == y_pred[index] else \"[91m\",\n",
        "                class_names[y_pred[index]],\n",
        "            )\n",
        "        )\n",
        "        display(Audio(audios[index, :, :].squeeze(), rate=SAMPLING_RATE))"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}