Model_Training_Final.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Oyn1Sr9YjwJm"
      },
      "source": [
        "## Import Libraries\n",
        "Import necessary libraries for data processing, model building, and visualization (os, re, random, numpy, tensorflow, keras, scikit-learn, matplotlib, seaborn)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "s00bUu90aKIJ"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import re\n",
        "import random\n",
        "import numpy as np\n",
        "import tensorflow as tf\n",
        "from tensorflow import keras\n",
        "from tensorflow.keras import layers, regularizers\n",
        "from tensorflow.keras.layers import Dropout, Conv2D, MaxPooling2D, BatchNormalization\n",
        "from sklearn.model_selection import train_test_split\n",
        "from collections import Counter\n",
        "import matplotlib.pyplot as plt\n",
        "from sklearn.metrics import confusion_matrix\n",
        "import seaborn as sns"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "itnD465mjyAr"
      },
      "source": [
        "## Set Hyperparameters and Filenames\n",
        "Define the hyperparameters of the dataset, including phonemes and classes. Load the training data and parse the filenames."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YGZ8FJFn9RE7",
        "outputId": "7f8b1165-9bfb-4352-b6f5-ecc913a3f957"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "X_filename: X_all44_3220_4_5_5.npy\n",
            "y_filename: y_all44_3220_4_5_5.npy\n",
            "CLASSES: 45\n"
          ]
        }
      ],
      "source": [
        "PHONEMES = ['_', 'B', 'D', 'F', 'G', 'HH', 'JH', 'K', 'L', 'M', 'N', 'P', 'R', 'S', 'T', 'V', 'W', 'Y', 'Z', 'CH', 'SH', 'NG', 'DH', 'TH', 'ZH', 'WH', 'AA', 'AI(R)', 'I(R)', 'A(R)', 'ER', 'EY', 'IY', 'AY', 'OW', 'UW', 'AE', 'EH', 'IH', 'AO', 'AH', 'UH', 'OO', 'AW', 'OY']\n",
        "\n",
        "CLASSES = len(PHONEMES)\n",
        "\n",
        "def get_files_with_prefix(directory, prefix):\n",
        "    files = os.listdir(directory)\n",
        "    filtered_files = [file for file in files if file.startswith(prefix)]\n",
        "    return filtered_files\n",
        "\n",
        "directory = \"/content\"\n",
        "X_filename = get_files_with_prefix(directory, f\"X_all44\")[0]\n",
        "y_filename = get_files_with_prefix(directory, f\"y_all44\")[0]\n",
        "\n",
        "print(f\"X_filename: {X_filename}\")\n",
        "print(f\"y_filename: {y_filename}\")\n",
        "print(f\"CLASSES: {CLASSES}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aalsn8xfjyjk"
      },
      "source": [
        "## Parse Filename"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "t2xEQMyL-6du",
        "outputId": "4707692a-b301-40a8-f25c-67262692f1e0"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "NUM_EXAMPLES: 3220\n",
            "channels: 4\n",
            "size: 5\n"
          ]
        }
      ],
      "source": [
        "def parse_filename(filename):\n",
        "    # Regular expression pattern to extract the required information from the filename\n",
        "    pattern = r\"X_all44_(\\d+)_(\\d+)_(\\d+)_(\\d+).npy\"\n",
        "\n",
        "    # Use regular expression to search and extract the required information\n",
        "    match = re.search(pattern, filename)\n",
        "\n",
        "    if match:\n",
        "        num_examples = int(match.group(1))\n",
        "        channels = int(match.group(2))\n",
        "        size = int(match.group(3))\n",
        "\n",
        "        return num_examples, channels, size\n",
        "    else:\n",
        "        raise ValueError(\"Invalid filename format\")\n",
        "\n",
        "NUM_EXAMPLES, CHANNELS, SIZE = parse_filename(X_filename)\n",
        "\n",
        "print(\"NUM_EXAMPLES:\", NUM_EXAMPLES)\n",
        "print(\"channels:\", CHANNELS)\n",
        "print(\"size:\", SIZE)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p0Fo2g3SjzQG"
      },
      "source": [
        "## Train/Test Split"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xzbuWMuWaOP1",
        "outputId": "be3c52c9-6907-4242-ad68-e94d07967c9b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "X_train.shape: (2576, 4, 5) - 2576 training examples\n",
            "X_test.shape: (644, 4, 5) - 644 testing examples\n"
          ]
        }
      ],
      "source": [
        "# Load the training data\n",
        "X_train_og = np.load(X_filename)\n",
        "y_train_og = np.load(y_filename)\n",
        "\n",
        "# Split into training and testing data\n",
        "X_train, X_test, y_train, y_test = train_test_split(X_train_og, y_train_og, test_size=0.2, random_state=489)\n",
        "\n",
        "# Prepare the data - N training examples, 4 channels (muscle groups) per example, each SIZE timesteps long\n",
        "X_train = X_train.reshape(-1, CHANNELS, SIZE)\n",
        "X_test = X_test.reshape(-1, CHANNELS, SIZE)\n",
        "\n",
        "print(f\"X_train.shape: {X_train.shape} - {X_train.shape[0]} training examples\")\n",
        "print(f\"X_test.shape: {X_test.shape} - {X_test.shape[0]} testing examples\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wywUKJ69jztl"
      },
      "source": [
        "## Original/Training/Test Set Distributions\n",
        "Print info about training example distrubtions across phonemes/classes."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "7GtrNLAmFUmY"
      },
      "outputs": [],
      "source": [
        "# # UNCOMMENT FOR SET DISTRIBUTIONS\n",
        "\n",
        "# # Count the occurrences of each class in the training set\n",
        "# y_og_counts = Counter(y_train_og)\n",
        "\n",
        "# # Count the occurrences of each class in the training set\n",
        "# y_train_counts = Counter(y_train)\n",
        "\n",
        "# # Count the occurrences of each class in the test set\n",
        "# y_test_counts = Counter(y_test)\n",
        "\n",
        "# # Print the occurrences\n",
        "# print(\"Occurrences in the original set:\")\n",
        "# for phoneme_index, count in sorted(y_og_counts.items()):\n",
        "#     print(f\"\\tPhoneme {PHONEMES[phoneme_index]}: {count}\")\n",
        "\n",
        "# print(\"Occurrences in the training set:\")\n",
        "# for phoneme_index, count in sorted(y_train_counts.items()):\n",
        "#     print(f\"\\tPhoneme {PHONEMES[phoneme_index]}: {count}\")\n",
        "\n",
        "# print(\"Occurrences in the test set:\")\n",
        "# for phoneme_index, count in sorted(y_test_counts.items()):\n",
        "#     print(f\"\\tPhoneme {PHONEMES[phoneme_index]}: {count}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fNG1cnDmj0VP"
      },
      "source": [
        "## Define the Model\n",
        "Create a sequential model using various layers such as Conv1D, Dropout, LSTM, and Dense, then compile the model with loss, optimizer, and metrics."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J9WfqHmaaZRQ",
        "outputId": "f166466c-d777-46c2-e3ba-d965cc621804"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_4\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " conv1d_7 (Conv1D)           (None, 4, 256)            4096      \n",
            "                                                                 \n",
            " dropout_14 (Dropout)        (None, 4, 256)            0         \n",
            "                                                                 \n",
            " lstm_6 (LSTM)               (None, 128)               197120    \n",
            "                                                                 \n",
            " dropout_15 (Dropout)        (None, 128)               0         \n",
            "                                                                 \n",
            " dense_9 (Dense)             (None, 128)               16512     \n",
            "                                                                 \n",
            " dense_10 (Dense)            (None, 45)                5805      \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 223,533\n",
            "Trainable params: 223,533\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "# Define the model\n",
        "model = tf.keras.Sequential([\n",
        "    layers.Conv1D(256, 3, activation='relu', input_shape=(CHANNELS, SIZE), padding='same'),\n",
        "    layers.Dropout(0.5),\n",
        "    # layers.Conv1D(256, 3, activation='relu', strides=2, padding='same'),\n",
        "    # layers.Dropout(0.5),\n",
        "    # layers.LSTM(128, return_sequences=True, kernel_regularizer=regularizers.l2(1e-4)),\n",
        "    # layers.Dropout(0.5),\n",
        "    layers.LSTM(128, kernel_regularizer=regularizers.l2(1e-4)),\n",
        "    layers.Dropout(0.5),\n",
        "    layers.Dense(128, activation='relu'),\n",
        "    # layers.Dropout(0.5),\n",
        "    # layers.Dense(128, activation='relu'),\n",
        "    layers.Dense(CLASSES, activation='softmax')\n",
        "])\n",
        "\n",
        "model.compile(loss='sparse_categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\n",
        "\n",
        "model.summary()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "75usI6Acj1R-"
      },
      "source": [
        "## Define Early Stopping callback\n",
        "Define an EarlyStopping callback function to prevent overfitting."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "id": "nEfYVJDucjhK"
      },
      "outputs": [],
      "source": [
        "# Define Early Stopping callback\n",
        "callback = tf.keras.callbacks.EarlyStopping(\n",
        "    monitor='val_accuracy',\n",
        "    min_delta=0,\n",
        "    patience=250,\n",
        "    mode='max',\n",
        "    restore_best_weights=True\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ac9ZrJc0j10x"
      },
      "source": [
        "## Train the Model\n",
        "Fit the model on the training data and validate it on the testing data using the early stopping callback."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CdvHEkKzadbp",
        "outputId": "84959472-ae46-4ae4-f07b-46de2ee8f1f4"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/2000\n",
            "21/21 [==============================] - 5s 66ms/step - loss: 3.8252 - accuracy: 0.0248 - val_loss: 3.7877 - val_accuracy: 0.0171\n",
            "Epoch 2/2000\n",
            "21/21 [==============================] - 1s 38ms/step - loss: 3.7475 - accuracy: 0.0260 - val_loss: 3.6261 - val_accuracy: 0.0776\n",
            "Epoch 3/2000\n",
            "21/21 [==============================] - 1s 34ms/step - loss: 3.4781 - accuracy: 0.0718 - val_loss: 3.0637 - val_accuracy: 0.1149\n",
            "Epoch 4/2000\n",
            "21/21 [==============================] - 1s 35ms/step - loss: 2.8888 - accuracy: 0.1134 - val_loss: 2.4149 - val_accuracy: 0.1475\n",
            "Epoch 5/2000\n",
            "21/21 [==============================] - 1s 36ms/step - loss: 2.5085 - accuracy: 0.1518 - val_loss: 2.1093 - val_accuracy: 0.2469\n",
            "\n...\n\n",
            "Epoch 738/2000\n",
            "21/21 [==============================] - 1s 40ms/step - loss: 0.1978 - accuracy: 0.9363 - val_loss: 0.1079 - val_accuracy: 0.9752\n",
            "Epoch 739/2000\n",
            "21/21 [==============================] - 1s 42ms/step - loss: 0.1719 - accuracy: 0.9437 - val_loss: 0.1098 - val_accuracy: 0.9643\n",
            "Epoch 740/2000\n",
            "21/21 [==============================] - 1s 38ms/step - loss: 0.1860 - accuracy: 0.9379 - val_loss: 0.1062 - val_accuracy: 0.9720\n",
            "Epoch 741/2000\n",
            "21/21 [==============================] - 1s 39ms/step - loss: 0.1868 - accuracy: 0.9379 - val_loss: 0.1009 - val_accuracy: 0.9814\n",
            "Epoch 742/2000\n",
            "21/21 [==============================] - 1s 38ms/step - loss: 0.2054 - accuracy: 0.9262 - val_loss: 0.1100 - val_accuracy: 0.9674\n",
            "Epoch 743/2000\n",
            "21/21 [==============================] - 1s 38ms/step - loss: 0.2017 - accuracy: 0.9348 - val_loss: 0.1109 - val_accuracy: 0.9689\n"
          ]
        }
      ],
      "source": [
        "# Train the model\n",
        "history = model.fit(\n",
        "    X_train,\n",
        "    y_train,\n",
        "    batch_size=128,\n",
        "    epochs=2000,\n",
        "    verbose=1,\n",
        "    validation_data=(X_test, y_test),\n",
        "    callbacks=[callback]\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k8nvxeF4j2lD"
      },
      "source": [
        "## Evaluate the Model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "euKg1EaQS6Xt",
        "outputId": "b1ea8177-3610-40dc-bbee-bfae99495b39"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Example Count: 644\n",
            "Test Loss: 0.11591044068336487\n",
            "Test Accuracy: 0.9813664555549622\n",
            "Test Correctness: 632 / 644\n"
          ]
        }
      ],
      "source": [
        "# Evaluate the model on the test set\n",
        "test_loss, test_accuracy = model.evaluate(X_test, y_test, verbose=0)\n",
        "\n",
        "print(f\"Test Example Count: {len(y_test)}\")\n",
        "print(f\"Test Loss: {test_loss}\")\n",
        "print(f\"Test Accuracy: {test_accuracy}\")\n",
        "print(f\"Test Correctness: {int(np.round(test_accuracy * len(y_test)))} / {len(y_test)}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mBRJ286ej3NJ"
      },
      "source": [
        "## Plotting Training and Validation Loss and Accuracy\n",
        "Create plots for training and validation loss, as well as training and validation accuracy."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "id": "LNDUas23bd9W",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 927
        },
        "outputId": "5a213473-c547-4326-f23c-5180655f0926"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "# Plot training and validation loss\n",
        "plt.figure()\n",
        "plt.plot(history.history['loss'], label='Training Loss')\n",
        "plt.plot(history.history['val_loss'], label='Validation Loss')\n",
        "plt.title('Loss')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "plt.legend()\n",
        "plt.show()\n",
        "\n",
        "# Plot training and validation accuracy\n",
        "plt.figure()\n",
        "plt.plot(history.history['accuracy'], label='Training Accuracy')\n",
        "plt.plot(history.history['val_accuracy'], label='Validation Accuracy')\n",
        "plt.title('Accuracy')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.legend()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NqDGYyouj3sI"
      },
      "source": [
        "## Calculate and Display Confusion Matrix\n",
        "Get the predicted classes for the entire test set, then create and display the confusion matrix using a heatmap."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "id": "TeRmLEcoEaKj",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "cedf6c9b-5b5b-45d1-e5a1-94f81dc71fb6"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x1200 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "# Get the predicted classes for the entire test set\n",
        "y_predicted = model.predict(X_test, verbose=0)\n",
        "y_predicted_classes = np.argmax(y_predicted, axis=1)\n",
        "\n",
        "# Create the confusion matrix\n",
        "cm = confusion_matrix(y_test, y_predicted_classes)\n",
        "\n",
        "# Display the confusion matrix using a heatmap\n",
        "plt.figure(figsize=(12, 12))\n",
        "heatmap = sns.heatmap(\n",
        "                      cm,\n",
        "                      annot=True,\n",
        "                      cmap=\"Blues\",\n",
        "                      fmt='d',  # <- Set integer format for the annotations\n",
        "                      xticklabels=[PHONEMES[i] for i in range(CLASSES)],\n",
        "                      yticklabels=[PHONEMES[i] for i in range(CLASSES)],\n",
        ")\n",
        "\n",
        "# Modify the rotation of the y-axis labels\n",
        "heatmap.set_yticklabels(heatmap.get_yticklabels(), rotation=0)\n",
        "\n",
        "plt.title(\"Confusion Matrix\")\n",
        "plt.xlabel(\"Predicted Phonemes\")\n",
        "plt.ylabel(\"Actual Phonemes\")\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sLOn_GxMj4bt"
      },
      "source": [
        "## Test Model on Random Examples\n",
        "Choose some random examples from the test set and display their actual and predicted phonemes."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "id": "vzc2IetQEZlC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d80678b5-0520-4544-9812-18cf8df83730"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Example 1:\n",
            "\tActual Phoneme: I(R)\n",
            "\tPredicted Phoneme: I(R)\n",
            "Example 2:\n",
            "\tActual Phoneme: A(R)\n",
            "\tPredicted Phoneme: A(R)\n",
            "Example 3:\n",
            "\tActual Phoneme: T\n",
            "\tPredicted Phoneme: T\n",
            "Example 4:\n",
            "\tActual Phoneme: R\n",
            "\tPredicted Phoneme: R\n",
            "Example 5:\n",
            "\tActual Phoneme: T\n",
            "\tPredicted Phoneme: T\n",
            "Example 6:\n",
            "\tActual Phoneme: AW\n",
            "\tPredicted Phoneme: AW\n",
            "Example 7:\n",
            "\tActual Phoneme: TH\n",
            "\tPredicted Phoneme: TH\n",
            "Example 8:\n",
            "\tActual Phoneme: M\n",
            "\tPredicted Phoneme: M\n",
            "Example 9:\n",
            "\tActual Phoneme: K\n",
            "\tPredicted Phoneme: K\n",
            "Example 10:\n",
            "\tActual Phoneme: AY\n",
            "\tPredicted Phoneme: AY\n"
          ]
        }
      ],
      "source": [
        "# Choose 10 random examples from the test set\n",
        "random_indices = random.sample(range(X_test.shape[0]), 10)\n",
        "random_X = X_test[random_indices]\n",
        "random_y_actual = y_test[random_indices]\n",
        "\n",
        "# Predict the phoneme using the model\n",
        "predictions = model.predict(random_X, verbose=0)\n",
        "random_y_predicted = np.argmax(predictions, axis=1)\n",
        "\n",
        "# Show actual and predicted phoneme for each picked example\n",
        "for i in range(10):\n",
        "    print(f\"Example {i + 1}:\")\n",
        "    print(f\"\\tActual Phoneme: {PHONEMES[random_y_actual[i]]}\")\n",
        "    print(f\"\\tPredicted Phoneme: {PHONEMES[random_y_predicted[i]]}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Gl7yBxnCj4_E"
      },
      "source": [
        "## Save Model\n",
        "Save to a formatted filename path, store not just weights but also hyperparameters for simpler model loading."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "id": "w-Ewmel6dpTg",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "36a696be-e382-4306-898d-b9dd85fbc8a5"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _update_step_xla, lstm_cell_6_layer_call_fn, lstm_cell_6_layer_call_and_return_conditional_losses while saving (showing 4 of 4). These functions will not be directly callable after loading.\n"
          ]
        }
      ],
      "source": [
        "  # Create filepath\n",
        "filepath = f'LSTM_all44_seed489_{SIZE}_{SIZE}_224k'\n",
        "\n",
        "# Saving the model\n",
        "model.save(filepath)"
      ]
    }
  ]
}