Music_Instrument_prediction.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Music_Instrument_prediction.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "mount_file_id": "12goxbYfhTSWb9mebJyhkQy9xEeuFRJHj",
      "authorship_tag": "ABX9TyOlX0VuwU0TTr0Lq7N7zc3q",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/anirudhs123/EE5180-Group-4/blob/main/Music_Instrument_prediction.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8WiZ6hnbFroK"
      },
      "source": [
        "# Data Preparation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8QGRrwPjFtNp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9f29fe75-61c2-4c1d-b821-6924c53822e1"
      },
      "source": [
        "#Importing the required packages and libraries\n",
        "import os\n",
        "import librosa\n",
        "import pickle\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "from tqdm import tqdm\n",
        "\n",
        "!pip install python_speech_features\n",
        "from python_speech_features import mfcc\n",
        "\n",
        "from sklearn.preprocessing import LabelEncoder, OneHotEncoder\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.metrics import confusion_matrix\n",
        "from keras.layers import Conv2D, MaxPool2D, Flatten, Dense, Dropout,LSTM,Concatenate,Activation,Input\n",
        "from keras.optimizers import Adam, RMSprop\n",
        "from keras.models import Model\n",
        "from keras.models import Sequential\n",
        "\n",
        "!pip install -q tensorflow-model-optimization\n",
        "import tensorflow as tf\n",
        "import tensorflow_model_optimization as tfmot\n",
        "from sklearn.metrics import accuracy_score,classification_report\n",
        "import tempfile"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: python_speech_features in /usr/local/lib/python3.7/dist-packages (0.6)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UTk1GSp3cOVz",
        "outputId": "49b4a2f6-31c1-4431-ac3d-b9833ab2f8cb"
      },
      "source": [
        "%cd /content/drive/My Drive/EEML_data/Instrument_classification_data\n",
        "#!unzip \\*.zip"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/content/drive/.shortcut-targets-by-id/1PjT1G82CmVhCm_zwGAqPNoFojg9HS9Oc/EEML_data/Instrument_classification_data\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4YWVqwaCP_6F"
      },
      "source": [
        "df = pd.read_csv('train.csv')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6liWtKbfF90S",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4490e571-f052-4743-f7a3-0d2acaf7651b"
      },
      "source": [
        "#Getting the counts if each classes in the dataset\n",
        "#Originally there are 41 classes\n",
        "df['label'].value_counts()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Snare_drum               300\n",
              "Hi-hat                   300\n",
              "Double_bass              300\n",
              "Fart                     300\n",
              "Applause                 300\n",
              "Squeak                   300\n",
              "Saxophone                300\n",
              "Bass_drum                300\n",
              "Tearing                  300\n",
              "Fireworks                300\n",
              "Trumpet                  300\n",
              "Clarinet                 300\n",
              "Shatter                  300\n",
              "Flute                    300\n",
              "Cello                    300\n",
              "Laughter                 300\n",
              "Violin_or_fiddle         300\n",
              "Acoustic_guitar          300\n",
              "Oboe                     299\n",
              "Gong                     292\n",
              "Knock                    279\n",
              "Writing                  270\n",
              "Cough                    243\n",
              "Bark                     239\n",
              "Tambourine               221\n",
              "Burping_or_eructation    210\n",
              "Cowbell                  191\n",
              "Harmonica                165\n",
              "Drawer_open_or_close     158\n",
              "Meow                     155\n",
              "Electric_piano           150\n",
              "Gunshot_or_gunfire       147\n",
              "Microwave_oven           146\n",
              "Keys_jangling            139\n",
              "Telephone                120\n",
              "Computer_keyboard        119\n",
              "Finger_snapping          117\n",
              "Chime                    115\n",
              "Bus                      109\n",
              "Scissors                  95\n",
              "Glockenspiel              94\n",
              "Name: label, dtype: int64"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AlV3ALNdQRZR"
      },
      "source": [
        "#Filtering out the Top 5 classes \n",
        "#Each class has 300 samples each\n",
        "df = df[df['label'].isin(['Cello','Saxophone','Acoustic_guitar','Double_bass', 'Clarinet'])]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 296
        },
        "id": "-C4rxC-6gSKZ",
        "outputId": "3680bb16-852f-4342-90bb-e39a7a0bafda"
      },
      "source": [
        "#Plot to show the distribution of classes individually\n",
        "plt.bar(np.unique(df['label'].values),df['label'].value_counts())\n",
        "plt.ylabel('Count')\n",
        "plt.xlabel('Instruments')\n",
        "plt.title('Count of instruments vs Type of Instruments')\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "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": "code",
      "metadata": {
        "id": "87OyK0HuYTPG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ac3d329e-f109-450f-f828-3ced2100dfc4"
      },
      "source": [
        "#Collecting the Audio data from the .wav files\n",
        "#Librosa is used to directly load the .wav file into numy array format\n",
        "path = 'audio_train/'\n",
        "audio_data = list()\n",
        "for i in tqdm(range(df.shape[0])):\n",
        "    audio_data.append(librosa.load(path+df['fname'].iloc[i]))\n",
        "audio_data = np.array(audio_data)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1500/1500 [17:41<00:00,  1.41it/s]\n",
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:7: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n",
            "  import sys\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mlkT42vXYc-O"
      },
      "source": [
        "#The audio data and corresponding Sample frequency is stored in the dataframe\n",
        "df['audio_waves'] = audio_data[:,0]\n",
        "df['samplerate'] = audio_data[:,1]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VPPqUnppTP6t"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U88xeXOJdc_r"
      },
      "source": [
        "#Bit lengths - Length of the sampled audio data \n",
        "#Second length- Length if the audio ins Seconds\n",
        "bit_lengths = list()\n",
        "for i in range(df.shape[0]):\n",
        "    bit_lengths.append(len(df['audio_waves'].iloc[i]))\n",
        "bit_lengths = np.array(bit_lengths)\n",
        "df['bit_lengths'] = bit_lengths\n",
        "df['seconds_length'] = df['bit_lengths']/df['samplerate']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oCSCSBwMddHA"
      },
      "source": [
        "#Outlier Removal-I\n",
        "#We remove the parts of data with length of audio < 2 seconds\n",
        "#This is reasoned out because it is difficult for a model to learn/identify without sufficient second lengths\n",
        "df = df[df['seconds_length'] >= 2.0]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SPbmFjbesUCl"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BRf0KpXei47_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "07a25e11-1a6d-400e-b18c-bfea522f6279"
      },
      "source": [
        "#df['seconds_length'].max()\n",
        "#Identifying the Minnimum of length of Bits and Length in seconds of the audio data \n",
        "min_bits = np.min(df['bit_lengths'])\n",
        "print('Minimum Bit Length: {}'.format(min_bits))\n",
        "\n",
        "min_seconds = np.min(df['seconds_length'])\n",
        "print('Minimum Seconds length: {}'.format(min_seconds))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Minimum Bit Length: 44100\n",
            "Minimum Seconds length: 2.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "7aqnj4EUh5R7",
        "outputId": "ab845579-1217-4275-bdd6-ec3980138b3e"
      },
      "source": [
        "plt.hist(df['seconds_length'])\n",
        "plt.title('Histogram of Duration of audio signals')\n",
        "plt.xlabel('Duration in (s)')\n",
        "#plt.grid()\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAEWCAYAAACdaNcBAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAY6klEQVR4nO3de5SlVX3m8e9jg4BiRKBFbrFVyBiMAU3raHQMis54h6xFXCAqOiiTiWYZ7+h4wUQNGG+4vA2Kgldk0AjxsgQVxSvaKCpIMrbYDCDQLdBACyqX3/zx7tLT5alLd1V1dW2+n7Vqnffsd5/33fu8p57aZ7/nvJWqQpLUlzstdgMkSfPPcJekDhnuktQhw12SOmS4S1KHDHdJ6pDhvkiSXJTkwMVux2JK8tdJLkuyIcmDFrs9U1mMY5XBh5Jcl+S7W2B/lWSftvy+JK+Z5+1/IcmR87nNKfZzcpI3LPR+loJtFrsBPUqyBnhuVX1ppOzZreyRAFX1gFlsZwXwc2Dbqrp1Idq6yN4CvKCqzhi3MkkBNwEF/Aa4ADixqj65UA1KcjJweVW9eqJsNsdqATwSeBywV1X9akvuuKr+dgG2+YT53qam58j9DizJYv9xvzdw0Qx19q+qHYH/BJwMvCvJ6zZnZ1tBfzfFvYE1WzrY1Q/DfZEkWZPksW35oUlWJbkhydVJ3taqndtu17epi4cnuVOSVye5NMnaJB9OcveR7T6rrbsmyWsm7efYJKcn+WiSG4Bnt31/O8n6JFcmeVeSO49sr5L8XZKfJrkxyT8luV+Sb7X2njZaf1Ifx7Y1yXZJNgDLgB8m+dlMz1dV/bKqPgL8T+CVSXaZ/DyO9PGjbXlFa/9RSf4f8JVW/n+SXJXk+iTnJnlAKz8aOAJ4eXu+/23MsdouyTuS/KL9vCPJdm3dgUkuT/KS1t8rkzxnmtfAHknOTHJtktVJntfKjwI+ADy8teP1Yx57vyRfacf5l0k+lmSnScdtn5H7G01XJHlZa98vkvz3SdueXPd5rX3XtvbuMUV/tm+vrWva6+l7SXZr676a5LlteVmSt7Z2/zzJC1p7txmp+09Jvtlec2cl2XVkP2OP35j27Jrks60t1yb5epI7TObdYTq6lTsBOKGq/gi4H3BaK39Uu92pqnasqm8Dz24/jwbuC+wIvAsgyX7AexgCanfg7sCek/Z1MHA6sBPwMeA24EXArsDDgYOAv5v0mP8G/AXwMODlwInAM4C9gT8DDp+iX2PbWlW/aaNxGEbm95v6qfkDZzBMJz50Ex7zV8Cftn4AfAHYF7gn8H2G54GqOrEtv7k9308Zs63/xfA8HADs39rx6pH19+L3z/tRwLuT3GOKdp0KXA7sARwKvCnJY6rqJOBvgW+3dox7pxLgn9tj/5ThWBw7/dPQHpg8Hngpw7TPvsBjp6n7mLafpzG8pi5t7R7nSIa+7w3s0vpw85h6zwOewPAcPhg4ZEydpwPPYThGd27tnTD2+I3xEobndzmwG/Aqhim+OwTDfeF8po0Y1idZzxC6U7kF2CfJrlW1oaq+M03dI4C3VdUlVbUBeCVwWBv1HAr8W1V9o6p+C7yWP3wxf7uqPlNVt1fVzVV1flV9p6purao1wP9mCMNRb66qG6rqIuBC4Ky2/+sZftGmOhk6XVs3S1XdAvwS2HkTHnZsVf2qqm5u2/hgVd1YVb9hCMT9M/LuZwZHAP9YVWurah3weuCZI+tvaetvqarPAxsYppQ2kmRv4BHAK6rq11V1AcNo/VmzaURVra6qs9sfynXA2/jD4zaVpwEfqqoL27TPsdPUPQL4YFV9vz1fr2R4R7FiTN1bGEJ9n6q6rb22bphi/ydU1eVVdR1w3Jg6H6qq/9uO2WkMfwiATTp+tzD8Qbp3Ox5frzvQxbQM94VzSFXtNPHDH46GRx0F/Anw7+2t7JOnqbsHw+hpwqUMI9nd2rrLJlZU1U3ANZMef9nonSR/0t66XpVhquZNDKP4UVePLN885v6OjDddWzdLkm0ZRmLXbsLDftfnNiVwXJKftf6uaasm93kq4/o0Ok1xzaST3zcx/vnZA7i2qm6ctK3J77TGSrJbklOTXNH68VE2rQ+jr4NLp6rIpP62P9LXTNHOjwBfBE5t0z1vbsdrpv1fNqbOVSPLv3sON/H4/QuwGjgrySVJjhnXwV4Z7luBqvppVR3O8DbzeOD0JHdl/FvIXzCcbJvwx8CtDIF7JbDXxIokOzCMpDba3aT77wX+Hdi3TQu9iuEt/3yYrq2b6+C2jYmPB/4KuMvI+nuNecxon5/etvFYhimEFa08Y+qOM65Pv5ip0VNsZ+ckd5u0rStm+fg3MbT1ge24PYONj9tNTP28XMkwdTK63+na+bv+ttflLuPa2UbHr6+q/YC/BJ7M+HciG71OJ7VlJjMdv9H23FhVL6mq+wJPBV6c5KBN2NeSZrhvBZI8I8nyqrodWN+KbwfWtdv7jlT/BPCiJPdJsiPDL/kn22jxdOApSf4yw0nOY5k5qO8G3ABsSHJ/hhOW82W6tm6SJDsnOQJ4N3B8VU28I7mAYapn2yQrGaampnM3ho9VXsMQfm+atP5qNn6+J/sE8Ooky9tJvtcyjJo3SVVdBnwL+Od2IvLPGd7BzXZbd2OY8rk+yZ7AyyatvwB4ehvpPp6Np2xOYziZvl+SuwDTffroE8BzkhyQ4cTxm4Dz2hTeRpI8OskDkyxjeE3dwvD6new04IVJ9mwngV8xmw43Mx2/0fY8Ock+SQJcz3B+aVx7umS4bx0eD1yU4RMkJwCHtfnwm4A3At9sc/cPAz7I8Pb3XIbPwP8a+HuANif+9wwnvK5k+OVfy/DLMJWXMoyGbgTeD8znZ8inbOsm+GF7XlYDzwVeVFWvHVn/GoaT0NcxzH9/fIbtfZhhmuEK4CfA5PMbJwH7tef7M2Me/wZgFfAj4McMJ/Q290szhzOMPH8B/CvwutHvRszg9QwnI68HPgd8etL6FwJPYRgsHAH8ri9V9QXgHQyfHlrdbsdq7XkN8CmG19T9gMOmqH4vhgHGDcDFwNcYjv9k7wfOYngOfwB8nuHd2G1TtWPETMdv1L7Alxh+D74NvKeqzpnFPrqQO9D5hTucNlpezzDl8vPFbo80TpInAO+rqnvPWFmz5si9M0mekuQubW70LQyjyzWL2yrp95LskOSJSbZpU0qvY3jnonlkuPfnYIa3+b9geFt62B3p419aEsIwrXQdw7TMxQznLjSPnJaRpA45cpekDm0VF1Ladddda8WKFYvdDElaUs4///xfVtXyceu2inBfsWIFq1atWuxmSNKSkmTKbxc7LSNJHTLcJalDhrskdchwl6QOGe6S1CHDXZI6ZLhLUocMd0nqkOEuSR3aKr6hOhcrjvncou17zXFPWrR9S9J0HLlLUocMd0nqkOEuSR0y3CWpQ4a7JHXIcJekDhnuktQhw12SOmS4S1KHDHdJ6pDhLkkdMtwlqUOGuyR1yHCXpA4Z7pLUIcNdkjpkuEtShwx3SeqQ4S5JHTLcJalDhrskdchwl6QOGe6S1KFZh3uSZUl+kOSz7f59kpyXZHWSTya5cyvfrt1f3davWJimS5Kmsikj9xcCF4/cPx54e1XtA1wHHNXKjwKua+Vvb/UkSVvQrMI9yV7Ak4APtPsBHgOc3qqcAhzSlg9u92nrD2r1JUlbyGxH7u8AXg7c3u7vAqyvqlvb/cuBPdvynsBlAG399a3+RpIcnWRVklXr1q3bzOZLksbZZqYKSZ4MrK2q85McOF87rqoTgRMBVq5cWfO13S1pxTGfW5T9rjnuSYuyX0lLx4zhDjwCeGqSJwLbA38EnADslGSbNjrfC7ii1b8C2Bu4PMk2wN2Ba+a95ZKkKc04LVNVr6yqvapqBXAY8JWqOgI4Bzi0VTsSOKMtn9nu09Z/paqW5MhckpaquXzO/RXAi5OsZphTP6mVnwTs0spfDBwztyZKkjbVbKZlfqeqvgp8tS1fAjx0TJ1fA38zD22TJG0mv6EqSR0y3CWpQ4a7JHXIcJekDhnuktQhw12SOmS4S1KHDHdJ6pDhLkkdMtwlqUOGuyR1yHCXpA4Z7pLUIcNdkjpkuEtShwx3SeqQ4S5JHTLcJalDhrskdchwl6QOGe6S1CHDXZI6ZLhLUocMd0nqkOEuSR0y3CWpQ4a7JHXIcJekDhnuktQhw12SOmS4S1KHDHdJ6pDhLkkdMtwlqUOGuyR1yHCXpA7NGO5Jtk/y3SQ/THJRkte38vskOS/J6iSfTHLnVr5du7+6rV+xsF2QJE02m5H7b4DHVNX+wAHA45M8DDgeeHtV7QNcBxzV6h8FXNfK397qSZK2oBnDvQYb2t1t208BjwFOb+WnAIe05YPbfdr6g5Jk3losSZrRrObckyxLcgGwFjgb+BmwvqpubVUuB/Zsy3sClwG09dcDu4zZ5tFJViVZtW7durn1QpK0kVmFe1XdVlUHAHsBDwXuP9cdV9WJVbWyqlYuX758rpuTJI3YpE/LVNV64Bzg4cBOSbZpq/YCrmjLVwB7A7T1dweumZfWSpJmZTafllmeZKe2vAPwOOBihpA/tFU7EjijLZ/Z7tPWf6Wqaj4bLUma3jYzV2F34JQkyxj+GJxWVZ9N8hPg1CRvAH4AnNTqnwR8JMlq4FrgsAVotyRpGjOGe1X9CHjQmPJLGObfJ5f/GvibeWmdJGmz+A1VSeqQ4S5JHTLcJalDhrskdchwl6QOGe6S1CHDXZI6ZLhLUocMd0nqkOEuSR0y3CWpQ4a7JHXIcJekDhnuktQhw12SOmS4S1KHDHdJ6pDhLkkdMtwlqUOGuyR1yHCXpA4Z7pLUIcNdkjpkuEtShwx3SeqQ4S5JHTLcJalDhrskdchwl6QOGe6S1CHDXZI6ZLhLUocMd0nqkOEuSR0y3CWpQ4a7JHVoxnBPsneSc5L8JMlFSV7YyndOcnaSn7bbe7TyJHlnktVJfpTkwQvdCUnSxmYzcr8VeElV7Qc8DHh+kv2AY4AvV9W+wJfbfYAnAPu2n6OB9857qyVJ05ox3Kvqyqr6flu+EbgY2BM4GDilVTsFOKQtHwx8uAbfAXZKsvu8t1ySNKVNmnNPsgJ4EHAesFtVXdlWXQXs1pb3BC4bedjlrWzyto5OsirJqnXr1m1isyVJ05l1uCfZEfgU8A9VdcPouqoqoDZlx1V1YlWtrKqVy5cv35SHSpJmMKtwT7ItQ7B/rKo+3YqvnphuabdrW/kVwN4jD9+rlUmStpDZfFomwEnAxVX1tpFVZwJHtuUjgTNGyp/VPjXzMOD6kekbSdIWsM0s6jwCeCbw4yQXtLJXAccBpyU5CrgUeFpb93ngicBq4CbgOfPaYknSjGYM96r6BpApVh80pn4Bz59juyRJc+A3VCWpQ4a7JHXIcJekDs3mhKq2MiuO+dyi7XvNcU9atH1Lmj1H7pLUIcNdkjpkuEtShwx3SeqQ4S5JHTLcJalDhrskdchwl6QOGe6S1CHDXZI6ZLhLUocMd0nqkOEuSR0y3CWpQ4a7JHXIcJekDhnuktQhw12SOmS4S1KHDHdJ6pDhLkkdMtwlqUOGuyR1yHCXpA4Z7pLUIcNdkjpkuEtShwx3SeqQ4S5JHTLcJalDhrskdchwl6QOzRjuST6YZG2SC0fKdk5ydpKfttt7tPIkeWeS1Ul+lOTBC9l4SdJ4sxm5nww8flLZMcCXq2pf4MvtPsATgH3bz9HAe+enmZKkTTFjuFfVucC1k4oPBk5py6cAh4yUf7gG3wF2SrL7fDVWkjQ7mzvnvltVXdmWrwJ2a8t7ApeN1Lu8lf2BJEcnWZVk1bp16zazGZKkceZ8QrWqCqjNeNyJVbWyqlYuX758rs2QJI3Y3HC/emK6pd2ubeVXAHuP1NurlUmStqDNDfczgSPb8pHAGSPlz2qfmnkYcP3I9I0kaQvZZqYKST4BHAjsmuRy4HXAccBpSY4CLgWe1qp/HngisBq4CXjOArRZkjSDGcO9qg6fYtVBY+oW8Py5NkqSNDd+Q1WSOmS4S1KHDHdJ6pDhLkkdMtwlqUOGuyR1aMaPQkqjVhzzuUXZ75rjnrQo+5WWKkfuktQhw12SOmS4S1KHDHdJ6pDhLkkdMtwlqUOGuyR1yHCXpA4Z7pLUIcNdkjpkuEtSh7y2jJaExbqmzWLyejqaC0fuktQhw12SOmS4S1KHDHdJ6pDhLkkdMtwlqUN+FFLaSvkvDTUXjtwlqUOO3CVtNXy3Mn8Md0kbuSN+G7hHTstIUoccuUu6w1vMdysLNSXkyF2SOmS4S1KHDHdJ6pDhLkkdMtwlqUMLEu5JHp/kP5KsTnLMQuxDkjS1eQ/3JMuAdwNPAPYDDk+y33zvR5I0tYUYuT8UWF1Vl1TVb4FTgYMXYD+SpCksxJeY9gQuG7l/OfCfJ1dKcjRwdLu7Icl/LEBbtpRdgV8udiMWSK9967Vf0G/fuuxXjgc2v2/3nmrFon1DtapOBE5crP3PpySrqmrlYrdjIfTat177Bf32rdd+wcL0bSGmZa4A9h65v1crkyRtIQsR7t8D9k1ynyR3Bg4DzlyA/UiSpjDv0zJVdWuSFwBfBJYBH6yqi+Z7P1uZLqaXptBr33rtF/Tbt177BQvQt1TVfG9TkrTI/IaqJHXIcJekDhnuc5RkTZIfJ7kgyarFbs/mSvLBJGuTXDhStnOSs5P8tN3eYzHbuLmm6NuxSa5ox+2CJE9czDZujiR7JzknyU+SXJTkha18yR+3afq2pI9bku2TfDfJD1u/Xt/K75PkvHbJlk+2D6PMbV/Ouc9NkjXAyqpa0l+uSPIoYAPw4ar6s1b2ZuDaqjquXSPoHlX1isVs5+aYom/HAhuq6i2L2ba5SLI7sHtVfT/J3YDzgUOAZ7PEj9s0fXsaS/i4JQlw16rakGRb4BvAC4EXA5+uqlOTvA/4YVW9dy77cuQuAKrqXODaScUHA6e05VMYfrmWnCn6tuRV1ZVV9f22fCNwMcM3xJf8cZumb0taDTa0u9u2nwIeA5zeyuflmBnuc1fAWUnOb5dU6MluVXVlW74K2G0xG7MAXpDkR23aZslNXYxKsgJ4EHAenR23SX2DJX7ckixLcgGwFjgb+BmwvqpubVUuZx7+kBnuc/fIqnoww1Uwn9+mALpTw/xdT3N47wXuBxwAXAm8dXGbs/mS7Ah8CviHqrphdN1SP25j+rbkj1tV3VZVBzB8e/+hwP0XYj+G+xxV1RXtdi3wrwwHqxdXt7nPiTnQtYvcnnlTVVe3X7LbgfezRI9bm7f9FPCxqvp0K+7iuI3rWy/HDaCq1gPnAA8Hdkoy8aXSeblki+E+B0nu2k72kOSuwH8FLpz+UUvKmcCRbflI4IxFbMu8mgi/5q9ZgsetnZw7Cbi4qt42smrJH7ep+rbUj1uS5Ul2ass7AI9jOJ9wDnBoqzYvx8xPy8xBkvsyjNZhuJTDx6vqjYvYpM2W5BPAgQyXHr0aeB3wGeA04I+BS4GnVdWSOzE5Rd8OZHhrX8Aa4H+MzFMvCUkeCXwd+DFweyt+FcPc9JI+btP07XCW8HFL8ucMJ0yXMQyuT6uqf2xZciqwM/AD4BlV9Zs57ctwl6T+OC0jSR0y3CWpQ4a7JHXIcJekDhnuktQhw11bnSS3tSv+XdSunveSJPP2Wk3y7CR7jNz/QJL95mG7T20X6tqUx+yQ5GtJlk1T50tL8Wv2Wlx+FFJbnSQbqmrHtnxP4OPAN6vqdZuwjWVVddsU674KvLSqFv0SzUmeD2xTVSdMU+dIYK+l+h0KLQ5H7tqqtcs6HM1wsai0Ufe7JtYn+WySA9vyhiRvTfJD4OFJXpvke0kuTHJie/yhwErgY+3dwQ5JvppkZdvG4Rmuz39hkuNH9rMhyRvbO4nvJPmDi3GNti3JyUnemeRbSS5p+x3nCNq3EZPsnuTc1q4Lk/yXVudMhi/vSLNmuGurV1WXMHyj754zVL0rcF5V7V9V3wDeVVUPaddw3wF4clWdDqwCjqiqA6rq5okHt6ma4xkuv3oA8JAkh4xs+ztVtT9wLvC8WTR9d+CRwJOB4yavbP+Q4b5VtaYVPR34Yruo1P7ABa3/1wHbJdllFvuUAMNdfbmN4UJTEx6d4b/b/JghsB8ww+MfAny1qta1y69+DJi4yudvgc+25fOBFbNoz2eq6vaq+gnjL7u7K7B+5P73gOe0fyTywHYd8wlrgT2QZslw11avXXfjNoaAu5WNX7fbjyz/emKePcn2wHuAQ6vqgQxXEBytu6luqd+foLqN4VpCMxm9NkjGrL95tE3tn4o8iuGKgCcnedZI3e1bfWlWDHdt1ZIsB97HMMUycbGoA5LcKcneTH3J14nQ/GW7JvjonPeNwN3GPOa7wF8l2bV9euVw4Gvz0I2x2nTLsvaHiCT3Bq6uqvcDHwAe3MoD3Iuh79KszGb0IW1pO7T/VLMtw0j9I8DEZV+/Cfwc+AnDpVK/P24DVbU+yfsZLgl7FcOUx4STgfcluZnhWtoTj7myfZTxHIaR9ueqaqEvl3sWw7z8lxiuVPmyJLcw/M/XiZH7XzDM9986dgvSGH4UUlpESR4MvKiqnjlNnROAM6vqy1uuZVrqnJaRFlH7J9DnTPclJuBCg12bypG7JHXIkbskdchwl6QOGe6S1CHDXZI6ZLhLUof+P4V3vyQHvVKpAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H1CSdGQNKyAp"
      },
      "source": [
        "# Data Preprocessing"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WjEeHzf_ddZR",
        "outputId": "79a7d1d4-3ab1-4224-ee77-ee05ad46b48d"
      },
      "source": [
        "#Fenerating audio waves and setting up correspnding labels\n",
        "#Num samples to be generated is a hyper parameter\n",
        "\n",
        "num_samples = 6000\n",
        "generated_audio_waves = list()\n",
        "generated_audio_labels = list()\n",
        "for i in tqdm(range(num_samples)):\n",
        "    try:\n",
        "        chosen_file = np.random.choice(df['fname'].values)\n",
        "        chosen_initial = np.random.choice(np.arange(0,df[df['fname']==chosen_file]['bit_lengths'].values-min_bits))\n",
        "        generated_audio_waves.append(df[df['fname']==chosen_file]['audio_waves'].values[0][chosen_initial:chosen_initial+min_bits])\n",
        "        \n",
        "        generated_audio_labels.append(df[df['fname']==chosen_file]['label'].values)\n",
        "    except ValueError:\n",
        "        continue\n",
        "generated_audio_waves = np.array(generated_audio_waves)\n",
        "generated_audio_labels = np.array(generated_audio_labels)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 6000/6000 [00:10<00:00, 555.64it/s]\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_naQjfe38ivq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "caeca582-44c4-43fa-dcee-1d9ffc80ba6a"
      },
      "source": [
        "#Converting the label names into Integers\n",
        "# ['Cello','Saxophone','Acoustic_guitar','Double_bass', 'Clarinet'] is converted into intergers from 0-4\n",
        "label_encoder = LabelEncoder()\n",
        "label_encoded = label_encoder.fit_transform(generated_audio_labels)\n",
        "\n",
        "label_encoded = label_encoded[:, np.newaxis]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/sklearn/preprocessing/_label.py:251: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
            "  y = column_or_1d(y, warn=True)\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7c9T9_rD8kVx"
      },
      "source": [
        "#Converting the labels into one hot encoded form\n",
        "#This converts each label from its integer represntation to 1*5 vector form\n",
        "# Label 3 becomes - [0,0,0,1,0]\n",
        "one_hot_encoder = OneHotEncoder(sparse=False)\n",
        "one_hot_encoded = one_hot_encoder.fit_transform(label_encoded)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bWCOlMiS8MIr"
      },
      "source": [
        "# with open('audio_df.pickle', 'rb') as f:\n",
        "#     df = pickle.load(f)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "meTPeEp_eEZ_",
        "outputId": "78478774-0931-4e1d-9287-356d313a65f0"
      },
      "source": [
        "#Generating the MFCC features from the generated Audio waves data\n",
        "#We make use of the Python_speech_ features for conversion\n",
        "mfcc_features = list()\n",
        "for i in tqdm(range(len(generated_audio_waves))):\n",
        "    mfcc_features.append(mfcc(generated_audio_waves[i]))\n",
        "mfcc_features = np.array(mfcc_features)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 5976/5976 [00:45<00:00, 130.14it/s]\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i_hGuFGbebsS",
        "outputId": "9a6a8663-4fa0-4d2f-f6a0-9b8f13f5662e"
      },
      "source": [
        "print(generated_audio_waves.shape)\n",
        "print(mfcc_features.shape)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(5976, 44100)\n",
            "(5976, 275, 13)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 173
        },
        "id": "n8N6OmCSebvS",
        "outputId": "6a23613b-1493-48ad-d41a-f01383637daa"
      },
      "source": [
        "# Sample Plot of generated Audiowave data\n",
        "plt.figure(figsize=(12,2))\n",
        "plt.plot(generated_audio_waves[2])\n",
        "plt.title(generated_audio_labels[2])\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 864x144 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 96
        },
        "id": "wGyYnGt8qez7",
        "outputId": "35b64e54-cdde-42ce-aa63-895237984e6c"
      },
      "source": [
        "#Sample plot of corresponding MFCC feature plot\n",
        "plt.figure(figsize=(12, 2))\n",
        "plt.imshow(mfcc_features[0].T, cmap='hot')\n",
        "plt.title(generated_audio_labels[0])\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 864x144 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "agQLYYs0M9AA"
      },
      "source": [
        "#Forming the dependent and independent variables for model creation\n",
        "#X is the input to the model\n",
        "#y is expected output (Ground truth values) \n",
        "X = mfcc_features\n",
        "y = one_hot_encoded"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SwwZ3bYWeb8x"
      },
      "source": [
        "#Data scaling\n",
        "#Using Range scaling operation\n",
        "#This converts the input array values between [0,1]\n",
        "X = (X-X.min())/(X.max()-X.min())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C1Ig56-zNLrz"
      },
      "source": [
        "#Splitting the data into train and test sets\n",
        "#Train- 0.8, Test -0.2\n",
        "#Random state is fixed to replicate the split in the data\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BlfWW0OveyzE"
      },
      "source": [
        "#Shape of the input data into the CNN model\n",
        "input_shape = (X_train.shape[1], X_train.shape[2], 1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k6fiWQB6ey6C"
      },
      "source": [
        "X_train = X_train.reshape(X_train.shape[0], X_train.shape[1], X_train.shape[2], 1)\n",
        "#print(X_train.shape)\n",
        "X_test = X_test.reshape(X_test.shape[0], X_test.shape[1], X_test.shape[2], 1)\n",
        "#print(X_test.shape)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gfmcWaF-N0hX"
      },
      "source": [
        "# CNN Model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ryqHBycmezAz"
      },
      "source": [
        "#Building a CNN model with two Conv layers and three Dense layers\n",
        "# Optimal Parameters for each of these layers are obtained from Keras-Tuner\n",
        "\n",
        "model = Sequential()\n",
        "model.add(Conv2D(40, (1, 1), activation='relu', strides=(1, 1),padding='same', input_shape=input_shape))\n",
        "model.add(Dropout(0.2))\n",
        "model.add(Conv2D(32, (5, 5), activation='relu', strides=(1, 1), padding='same'))\n",
        "model.add(Dropout(0.2))\n",
        "model.add(Conv2D(16, (1, 1), activation='relu', strides=(1, 1), padding='same'))\n",
        "model.add(Dropout(0.2))\n",
        "model.add(Flatten())\n",
        "model.add(Dense(64, activation='relu'))\n",
        "model.add(Dropout(0.2))\n",
        "model.add(Dense(16, activation='relu'))\n",
        "model.add(Dropout(0.2))\n",
        "model.add(Dense(12, activation='relu'))\n",
        "model.add(Dropout(0.1))\n",
        "model.add(Dense(5, activation='softmax'))\n",
        "\n",
        "model.compile(loss='categorical_crossentropy', \n",
        "     optimizer='adam',\n",
        "     metrics=['accuracy'])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i1w6S3ByezHL"
      },
      "source": [
        "#Training the data for 30 epochs\n",
        "#Using Model checkpoints to avoid overfitting\n",
        "#Using a validation split of 0.2 from the train data\n",
        "\n",
        "checkpoint_filepath = '/tmp/checkpoint'\n",
        "\n",
        "model_checkpoint_callback = tf.keras.callbacks.ModelCheckpoint(\n",
        "    filepath=checkpoint_filepath,\n",
        "    save_weights_only=True,\n",
        "    monitor='val_accuracy',\n",
        "    mode='max',\n",
        "    save_best_only=True)\n",
        "\n",
        "history=model.fit(X_train,y_train,epochs=30,batch_size=16,\n",
        "          callbacks=[model_checkpoint_callback],\n",
        "          validation_split=0.2)\n",
        "\n",
        "model.load_weights(checkpoint_filepath)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Iwb-eSJyezNY"
      },
      "source": [
        "#Ploting the variation in Train and Validation loss vs Epochs\n",
        "#Ploting the variation in Train and Validation accuracy vs Epochs\n",
        "\n",
        "plt.figure(figsize=(8,8))\n",
        "plt.title('Loss Value')\n",
        "plt.plot(history.history['loss'])\n",
        "plt.plot(history.history['val_loss'])\n",
        "plt.legend(['loss', 'val_loss'])\n",
        "print('loss:', history.history['loss'][-1])\n",
        "print('val_loss:', history.history['val_loss'][-1])\n",
        "plt.show()\n",
        "\n",
        "plt.figure(figsize=(8,8))\n",
        "plt.title('Accuracy')\n",
        "plt.plot(history.history['accuracy'])\n",
        "plt.plot(history.history['val_accuracy'])\n",
        "plt.legend(['accuracy', 'val_accuracy'])\n",
        "plt.show()\n",
        "\n",
        "print('Train accuracy at the end of 30 epochs:', history.history['accuracy'][-1])\n",
        "print('val_accuracy at the end of 30 epochs:', history.history['val_accuracy'][-1])\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q-ZbhvO3ezTg"
      },
      "source": [
        "#Making predictions on the test set for the trtained model\n",
        "predictions = model.predict(X_test)\n",
        "#Identifying the class with highest probability of prediction\n",
        "predictions = np.argmax(predictions, axis=1)\n",
        "\n",
        "#Converting the 1*5 vectors back into interger form\n",
        "y_test_1 = one_hot_encoder.inverse_transform(y_test)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BeL8dXckwADX",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "25f59a82-9a28-42eb-ceab-0de7ea444f53"
      },
      "source": [
        "print('Accuracy of CNN model {}'.format(accuracy_score(y_test_1,predictions)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Accuracy of CNN model 0.7978187919463087\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 498
        },
        "id": "6wheiikNezes",
        "outputId": "f81c2258-c86f-4a9d-aee7-6e6748dd3b9b"
      },
      "source": [
        "#Printing the Confusion matrox to visualize the model predictions\n",
        "#Confusion matrix gives us an idea about the model capabilities\n",
        "cm = confusion_matrix(y_test_1, predictions)\n",
        "plt.figure(figsize=(8,8))\n",
        "sns.heatmap(cm, annot=True, xticklabels=label_encoder.classes_, yticklabels=label_encoder.classes_, fmt='d', cmap=plt.cm.Blues, cbar=False)\n",
        "plt.xlabel('Predicted Label')\n",
        "plt.ylabel('True Label')\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 576x576 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "68lIWhGNt2Nj"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E-1pYCWnQgTo"
      },
      "source": [
        "# Cut Mix algorithm"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sn6qoqvFt2RA"
      },
      "source": [
        "#Generation of random subspace within the input 2D array\n",
        "def rand_bbox(size, lamb):\n",
        "    \"\"\" Generate random subspace \n",
        "    Args:\n",
        "        - size: width,height of the subspace\n",
        "        - lamb: (lambda) cut ratio parameter\n",
        "    Returns:\n",
        "        - Bounding interval\n",
        "    \"\"\"\n",
        "    W = size[0]\n",
        "    H = size[1]\n",
        "    cut_rat = np.sqrt(1. - lamb)\n",
        "    cut_w = np.int(W * cut_rat)\n",
        "    cut_h = np.int(H * cut_rat)\n",
        "    \n",
        "\n",
        "    # uniform\n",
        "    cx = np.random.randint(W)\n",
        "    cy = np.random.randint(H)\n",
        "    bbx1 = np.clip(cx - cut_w // 2, 0, W)\n",
        "    bby1 = np.clip(cy - cut_h // 2, 0, H)\n",
        "    bbx2 = np.clip(cx + cut_w // 2, 0, W)\n",
        "    bby2 = np.clip(cy + cut_h // 2, 0, H)\n",
        "\n",
        "    \n",
        "    return bbx1, bby1, bbx2, bby2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BUe3m3d4ezkN"
      },
      "source": [
        "def generate_cutmix_image(image_batch, image_batch_labels, beta):\n",
        "    # generate mixed sample\n",
        "    #We sample out the lambda parameter from a Beta distribution\n",
        "    lam = np.random.beta(beta, beta)\n",
        "    #We choose a random audio element to make perturbations with\n",
        "    rand_index = np.random.permutation(len(image_batch))\n",
        "    #Taget a - Label of original audio\n",
        "    #Target b- Label of Randomly picked audio\n",
        "    target_a = image_batch_labels\n",
        "    target_b = image_batch_labels[rand_index]\n",
        "    #We obtain the region to perturbed in the original audio\n",
        "    bbx1, bby1, bbx2, bby2 = rand_bbox(image_batch[0].shape, lam)\n",
        "\n",
        "    image_batch_updated = image_batch.copy()\n",
        "    image_batch_updated[:, bbx1:bbx2, bby1:bby2, :] = image_batch[rand_index, bbx1:bbx2, bby1:bby2, :]\n",
        "   \n",
        "    # adjusting lambda to exactly match pixel ratio\n",
        "    lam = 1 - ((bbx2 - bbx1) * (bby2 - bby1) / (image_batch.shape[1] * image_batch.shape[2]))\n",
        "    label = target_a * lam + target_b * (1. - lam)\n",
        "    \n",
        "    return image_batch_updated, label"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N7h35aRiezuK"
      },
      "source": [
        "def gendata(X_train,y_train,beta=1):\n",
        "  X_aug,y_aug=generate_cutmix_image(X_train,y_train,beta)\n",
        "  return(X_aug,y_aug)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X5eqSZrbtncH"
      },
      "source": [
        "#Betas is a hyperparameter list\n",
        "#We sample out different betas to get different lambdas and different perturbed audio signals\n",
        "betas=[1,0.9,0.8]\n",
        "i=0\n",
        "for beta in betas:\n",
        "  X_train1,y_train1=gendata(X_train,y_train,beta)\n",
        "  if(i==0):\n",
        "    Xs=X_train1\n",
        "    ys=y_train1\n",
        "    i+=1\n",
        "  else:  \n",
        "    Xs=np.vstack([Xs,X_train1])\n",
        "    ys=np.vstack([ys,y_train1])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k3rMTN6Xtr-I"
      },
      "source": [
        "#Augmenting the perturbed audio signals with the oroginal train data\n",
        "#This helps us increase the available train data by 3 folds\n",
        "X_train=np.vstack([X_train,Xs])\n",
        "y_train=np.vstack([y_train,ys])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SAEpEYtEzqIf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "695f2eda-239b-4981-f639-fe5c7ee2b792"
      },
      "source": [
        "X_train.shape, y_train.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "((19120, 275, 13, 1), (19120, 5))"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LasHRrWdR8m_"
      },
      "source": [
        "# CNN model with Cut Mix"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PAh5GtORztrC"
      },
      "source": [
        "#Building CNN model\n",
        "\n",
        "model_cutmix = Sequential()\n",
        "model_cutmix .add(Conv2D(40, (1, 1), activation='relu', input_shape=input_shape))\n",
        "model_cutmix .add(Dropout(0.2))\n",
        "model_cutmix .add(Conv2D(32, (5, 5), activation='relu'))\n",
        "model_cutmix .add(Dropout(0.2))\n",
        "model_cutmix .add(Conv2D(16, (1, 1), activation='relu'))\n",
        "model_cutmix .add(Dropout(0.2))\n",
        "model_cutmix .add(Flatten())\n",
        "model_cutmix .add(Dense(64, activation='relu'))\n",
        "model_cutmix .add(Dropout(0.2))\n",
        "model_cutmix .add(Dense(16, activation='relu'))\n",
        "model_cutmix .add(Dropout(0.2))\n",
        "model_cutmix .add(Dense(12, activation='relu'))\n",
        "model_cutmix .add(Dropout(0.1))\n",
        "model_cutmix .add(Dense(5, activation='softmax'))\n",
        "\n",
        "model_cutmix .compile(loss='categorical_crossentropy', \n",
        "     optimizer='adam',\n",
        "     metrics=['accuracy'])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xK_lvVTo0BCR"
      },
      "source": [
        "#Training the data for 50 epochs\n",
        "#Using Model checkpoints to avoid overfitting\n",
        "#Using a validation split of 0.2 from the train data\n",
        "\n",
        "checkpoint_filepath = '/tmp/checkpoint'\n",
        "\n",
        "model_checkpoint_callback = tf.keras.callbacks.ModelCheckpoint(\n",
        "    filepath=checkpoint_filepath,\n",
        "    save_weights_only=True,\n",
        "    monitor='val_accuracy',\n",
        "    mode='max',\n",
        "    save_best_only=True)\n",
        "\n",
        "history_cutmix =model_cutmix .fit(X_train,y_train,epochs=50,batch_size=32,\n",
        "          callbacks=[model_checkpoint_callback],\n",
        "          #validation_split=0.2\n",
        "          validation_data=(X_test,y_test))\n",
        "\n",
        "model_cutmix .load_weights(checkpoint_filepath)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "XsLRVM5N0ENM",
        "outputId": "608c288b-5342-43e6-f877-1d54b9d62254"
      },
      "source": [
        "#Ploting the variation in Train and Validation loss vs Epochs\n",
        "#Ploting the variation in Train and Validation accuracy vs Epochs\n",
        "\n",
        "plt.figure(figsize=(8,8))\n",
        "plt.title('Loss Value')\n",
        "plt.plot(history_cutmix .history['loss'])\n",
        "plt.plot(history_cutmix .history['val_loss'])\n",
        "plt.legend(['loss', 'val_loss'])\n",
        "print('loss:', history_cutmix .history['loss'][-1])\n",
        "print('val_loss:', history_cutmix .history['val_loss'][-1])\n",
        "plt.show()\n",
        "\n",
        "plt.figure(figsize=(8,8))\n",
        "plt.title('Accuracy')\n",
        "plt.plot(history_cutmix .history['accuracy'])\n",
        "plt.plot(history_cutmix .history['val_accuracy'])\n",
        "plt.legend(['accuracy', 'val_accuracy'])\n",
        "plt.show()\n",
        "\n",
        "print('Train accuracy at the end of 50 epochs:', history_cutmix .history['accuracy'][-1])\n",
        "print('val_accuracy at the end of 50 epochs:', history_cutmix .history['val_accuracy'][-1])\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "loss: 0.48519957065582275\n",
            "val_loss: 0.5782576203346252\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 576x576 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 576x576 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Train accuracy at the end of 50 epochs: 0.9224895238876343\n",
            "val_accuracy at the end of 50 epochs: 0.818561851978302\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jFm1bH1OeAaK"
      },
      "source": [
        "#Defining function for determining Model performance for DL models\n",
        "def model_performance_DL(model,X_train,y_train,X_test,y_test,y_test_1):\n",
        "  #Model is fit on the train set and then used to predict ono Test set\n",
        "  y_pred = model.predict(X_test)\n",
        "  predicted=[]\n",
        "  predicted_prob=y_pred\n",
        "  for i in range(len(y_pred)):\n",
        "    predicted.append(np.argmax(y_pred[i]))\n",
        "    \n",
        "  \n",
        "  #Different metrics are used to check the model performance\n",
        "  #Weighted precision,recall,f1_score is reported for all models\n",
        "  classes = np.unique(y_test_1)\n",
        "  #y_test_array = pd.get_dummies(y_test, drop_first=False).values\n",
        "  y_test_array=y_test_1\n",
        "\n",
        "  accuracy = accuracy_score(y_test_1, predicted)\n",
        "  print(\"Accuracy:\",  round(accuracy,2))\n",
        "  #print(\"Auc:\", round(auc,2))\n",
        "  print(\"Detail:\")\n",
        "  print(classification_report(y_test_1, predicted))\n",
        "\n",
        "  ## Plot confusion matrix\n",
        "  cm = confusion_matrix(y_test_1, predicted)\n",
        "  cmn = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
        "  fig, ax = plt.subplots()\n",
        "  sns.heatmap(cmn, annot=True, fmt='.2f', ax=ax, cmap='YlGnBu', \n",
        "            )\n",
        "  ax.set(xlabel=\"Pred\", ylabel=\"True\", xticklabels=classes, \n",
        "       yticklabels=classes, title=\"Confusion matrix\")\n",
        "  plt.yticks(rotation=0)\n",
        "  "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 533
        },
        "id": "Hl92GAlPel2R",
        "outputId": "4cf73f5c-33fc-47af-ce68-057088d2216d"
      },
      "source": [
        "model_performance_DL(model_cutmix,X_train,y_train,X_test,y_test,y_test_1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Accuracy: 0.84\n",
            "Detail:\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.82      0.83      0.82       258\n",
            "           1       0.84      0.80      0.82       281\n",
            "           2       0.90      0.85      0.88       253\n",
            "           3       0.84      0.89      0.86       166\n",
            "           4       0.81      0.87      0.84       238\n",
            "\n",
            "    accuracy                           0.84      1196\n",
            "   macro avg       0.84      0.85      0.84      1196\n",
            "weighted avg       0.84      0.84      0.84      1196\n",
            "\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zA4pCSbq0dyU"
      },
      "source": [
        "#Making predictions on the test set for the trtained model\n",
        "predictions = model_cutmix.predict(X_test)\n",
        "#Identifying the class with highest probability of prediction\n",
        "predictions = np.argmax(predictions, axis=1)\n",
        "\n",
        "#Converting the 1*5 vectors back into interger form\n",
        "y_test_1 = one_hot_encoder.inverse_transform(y_test)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8j2Xw6dJvvYy",
        "outputId": "44d4f36b-de87-424f-d7b3-15230dc119d4"
      },
      "source": [
        "print('Accuracy Cut-Mix {}'.format(accuracy_score(y_test_1,predictions)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Accuracy Cut-Mix 0.8419732441471572\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WCNpG2LHhkAg",
        "outputId": "6b7a353e-8c0c-4b18-eb8e-53ae6f6c1d14"
      },
      "source": [
        "print(classification_report(y_test_1,predictions))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.82      0.83      0.82       258\n",
            "           1       0.84      0.80      0.82       281\n",
            "           2       0.90      0.85      0.88       253\n",
            "           3       0.84      0.89      0.86       166\n",
            "           4       0.81      0.87      0.84       238\n",
            "\n",
            "    accuracy                           0.84      1196\n",
            "   macro avg       0.84      0.85      0.84      1196\n",
            "weighted avg       0.84      0.84      0.84      1196\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pm0MBoHNxm9k"
      },
      "source": [
        "#model_cutmix.save_weights('/content/best_weights_MIC_CNN_CUTMIX.h5')\n",
        "#model_cutmix.load_weights(\"/content/best_weights_MIC_CNN_CUTMIX.h5\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 498
        },
        "id": "_xvYLZNb0oIy",
        "outputId": "ccee511d-ea22-46a5-aff0-c117775d985b"
      },
      "source": [
        "#Printing the Confusion matrox to visualize the model predictions\n",
        "#Confusion matrix gives us an idea about the model capabilities\n",
        "\n",
        "cm = confusion_matrix(y_test_1, predictions)\n",
        "plt.figure(figsize=(8,8))\n",
        "sns.heatmap(cm, annot=True, xticklabels=label_encoder.classes_, yticklabels=label_encoder.classes_, fmt='d', cmap=plt.cm.Blues, cbar=False)\n",
        "plt.xlabel('Predicted Label')\n",
        "plt.ylabel('True Label')\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 576x576 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "44L8sK6sTUqk"
      },
      "source": [
        "# Model Pruning "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rxVnr7S92mtH"
      },
      "source": [
        "prune_low_magnitude = tfmot.sparsity.keras.prune_low_magnitude\n",
        "\n",
        "# Compute end step to finish pruning after 2 epochs.\n",
        "batch_size = 16\n",
        "epochs = 30\n",
        "validation_split = 0.2 # 20% of training set will be used for validation set. \n",
        "\n",
        "num_images = X_train.shape[0] * (1 - validation_split)\n",
        "end_step = np.ceil(num_images / batch_size).astype(np.int32) * epochs\n",
        "\n",
        "# Define model for pruning.\n",
        "pruning_params = {\n",
        "      'pruning_schedule': tfmot.sparsity.keras.PolynomialDecay(initial_sparsity=0.50,\n",
        "                                                               final_sparsity=0.80,\n",
        "                                                               begin_step=0,\n",
        "                                                               end_step=end_step)\n",
        "}\n",
        "\n",
        "model_for_pruning = prune_low_magnitude(model_cutmix, **pruning_params)\n",
        "\n",
        "# prune_low_magnitude requires a recompile.\n",
        "model_for_pruning.compile(optimizer='adam',\n",
        "              loss=tf.keras.losses.CategoricalCrossentropy(from_logits=True),\n",
        "              metrics=['accuracy'])\n",
        "\n",
        "model_for_pruning.summary()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Rs3c8qOy1YgZ",
        "outputId": "b50a81d2-8fea-4003-977d-28950d1fc7d9"
      },
      "source": [
        "model_cutmix.summary()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Model: \"sequential_1\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "conv2d_6 (Conv2D)            (None, 275, 13, 40)       400       \n",
            "_________________________________________________________________\n",
            "dropout_12 (Dropout)         (None, 275, 13, 40)       0         \n",
            "_________________________________________________________________\n",
            "conv2d_7 (Conv2D)            (None, 275, 13, 32)       1312      \n",
            "_________________________________________________________________\n",
            "dropout_13 (Dropout)         (None, 275, 13, 32)       0         \n",
            "_________________________________________________________________\n",
            "conv2d_8 (Conv2D)            (None, 275, 13, 16)       528       \n",
            "_________________________________________________________________\n",
            "dropout_14 (Dropout)         (None, 275, 13, 16)       0         \n",
            "_________________________________________________________________\n",
            "flatten_2 (Flatten)          (None, 57200)             0         \n",
            "_________________________________________________________________\n",
            "dense_8 (Dense)              (None, 64)                3660864   \n",
            "_________________________________________________________________\n",
            "dropout_15 (Dropout)         (None, 64)                0         \n",
            "_________________________________________________________________\n",
            "dense_9 (Dense)              (None, 16)                1040      \n",
            "_________________________________________________________________\n",
            "dropout_16 (Dropout)         (None, 16)                0         \n",
            "_________________________________________________________________\n",
            "dense_10 (Dense)             (None, 12)                204       \n",
            "_________________________________________________________________\n",
            "dropout_17 (Dropout)         (None, 12)                0         \n",
            "_________________________________________________________________\n",
            "dense_11 (Dense)             (None, 5)                 65        \n",
            "=================================================================\n",
            "Total params: 3,664,413\n",
            "Trainable params: 3,664,413\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "795dMQyw3BMv"
      },
      "source": [
        "import tempfile\n",
        "logdir = tempfile.mkdtemp()\n",
        "callbacks = [\n",
        "  tfmot.sparsity.keras.UpdatePruningStep(),\n",
        "  tfmot.sparsity.keras.PruningSummaries(log_dir=logdir),\n",
        "]\n",
        "model_for_pruning.fit(X_train, y_train,\n",
        "                  batch_size=batch_size, epochs=epochs, validation_split=validation_split,\n",
        "                  callbacks=callbacks)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XbO99XlB3f5N"
      },
      "source": [
        "#Making predictions on the test set for the trtained model\n",
        "predictions=model_for_pruning.predict(X_test)\n",
        "#Identifying the class with highest probability of prediction\n",
        "predictions = np.argmax(predictions, axis=1)\n",
        "#Converting the 1*5 vectors back into interger form\n",
        "y_test_1 = one_hot_encoder.inverse_transform(y_test)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lb211Mch1D0g",
        "outputId": "37e9712b-e31c-4063-f0eb-b118e0e93a92"
      },
      "source": [
        "print('Accuracy Pruned Model {}'.format(accuracy_score(y_test_1,predictions)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Accuracy Pruned Model 0.7986577181208053\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HbWFBmQWUTy2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 498
        },
        "outputId": "d31e51b3-774e-4971-9869-d08e96f39a67"
      },
      "source": [
        "#Printing the Confusion matrox to visualize the model predictions\n",
        "#Confusion matrix gives us an idea about the model capabilities\n",
        "\n",
        "cm = confusion_matrix(y_test_1, predictions)\n",
        "plt.figure(figsize=(8,8))\n",
        "sns.heatmap(cm, annot=True, xticklabels=label_encoder.classes_, yticklabels=label_encoder.classes_, fmt='d', cmap=plt.cm.Blues, cbar=False)\n",
        "plt.xlabel('Predicted Label')\n",
        "plt.ylabel('True Label')\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 576x576 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2W8IzMh44H7w",
        "outputId": "9f36acfa-b8f5-44a1-b5e1-f0bb90a7ac8f"
      },
      "source": [
        "print(classification_report(y_test_1,predictions))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.90      0.61      0.73       270\n",
            "           1       0.69      0.85      0.77       273\n",
            "           2       0.84      0.88      0.86       250\n",
            "           3       0.84      0.81      0.82       191\n",
            "           4       0.79      0.86      0.82       208\n",
            "\n",
            "    accuracy                           0.80      1192\n",
            "   macro avg       0.81      0.80      0.80      1192\n",
            "weighted avg       0.81      0.80      0.80      1192\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Fv7pCm704Cpy",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1f4f57f1-a4de-4203-86da-267c0fd127ff"
      },
      "source": [
        "_, model_for_pruning_accuracy = model_for_pruning.evaluate(X_test, y_test, verbose=0)\n",
        "_, model_accuracy = model.evaluate(X_test, y_test, verbose=0)\n",
        "_, model_cutmix_accuracy = model_cutmix.evaluate(X_test, y_test, verbose=0)\n",
        "\n",
        "print('Baseline Model test accuracy:', model_accuracy)\n",
        "print('Cut-Mix Model test accuracy:', model_cutmix_accuracy)\n",
        "print('Pruned test accuracy:', model_for_pruning_accuracy)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Baseline Model test accuracy: 0.7978187799453735\n",
            "Cut-Mix Model test accuracy: 0.7986577153205872\n",
            "Pruned test accuracy: 0.7986577153205872\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q_9l1OvTUhZN"
      },
      "source": [
        "# Class Activation Maps "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YjwNEmqt1rR0"
      },
      "source": [
        "x=np.reshape(X_test[10],(1,X_test[0].shape[0],X_test[0].shape[1],X_test[0].shape[2]))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XbLh5CZf59y6"
      },
      "source": [
        "def make_gradcam_heatmap(img_array, model):\n",
        "    # First, we create a model that maps the input image to the activations\n",
        "    # of the last conv layer\n",
        "    last_conv_layer = model.layers[5]\n",
        "    last_conv_layer_model = keras.Model(model.inputs, last_conv_layer.output)\n",
        "    \n",
        "    # Mark the classifying layers\n",
        "    classifier_layers = model.layers[-8:]\n",
        "\n",
        "    # Second, we create a model that maps the activations of the last conv\n",
        "    # layer to the final class predictions\n",
        "    classifier_input = keras.Input(shape=last_conv_layer.output.shape[1:])\n",
        "    x = classifier_input\n",
        "    for classifier_layer in classifier_layers:\n",
        "        x = classifier_layer(x)\n",
        "    classifier_model = keras.Model(classifier_input, x)\n",
        "\n",
        "    # Then, we compute the gradient of the top predicted class for our input image\n",
        "    # with respect to the activations of the last conv layer\n",
        "    with tf.GradientTape() as tape:\n",
        "        # Compute activations of the last conv layer and make the tape watch it\n",
        "        last_conv_layer_output = last_conv_layer_model(img_array)\n",
        "        tape.watch(last_conv_layer_output)\n",
        "        # Compute class predictions\n",
        "        preds = classifier_model(last_conv_layer_output)\n",
        "        top_pred_index = tf.argmax(preds[0])\n",
        "        top_class_channel = preds[:, top_pred_index]\n",
        "\n",
        "    # This is the gradient of the top predicted class with regard to\n",
        "    # the output feature map of the last conv layer\n",
        "    grads = tape.gradient(top_class_channel, last_conv_layer_output)\n",
        "\n",
        "    # This is a vector where each entry is the mean intensity of the gradient\n",
        "    # over a specific feature map channel\n",
        "    pooled_grads = tf.reduce_mean(grads, axis=(0, 1, 2))\n",
        "\n",
        "    # We multiply each channel in the feature map array\n",
        "    # by \"how important this channel is\" with regard to the top predicted class\n",
        "    last_conv_layer_output = last_conv_layer_output.numpy()[0]\n",
        "    pooled_grads = pooled_grads.numpy()\n",
        "    for i in range(pooled_grads.shape[-1]):\n",
        "        last_conv_layer_output[:, :, i] *= pooled_grads[i]\n",
        "\n",
        "    # The channel-wise mean of the resulting feature map\n",
        "    # is our heatmap of class activation\n",
        "    heatmap = np.mean(last_conv_layer_output, axis=-1)\n",
        "\n",
        "    # For visualization purpose, we will also normalize the heatmap between 0 & 1\n",
        "    heatmap = np.maximum(heatmap, 0) / np.max(heatmap)\n",
        "    return heatmap"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 363
        },
        "id": "W-_vr5sbz79e",
        "outputId": "3dd1b129-fc7f-4571-f417-eca30ec439d4"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.cm as cm\n",
        "import keras\n",
        "plt.figure(figsize=(6,6))\n",
        "for n in range(1):\n",
        "    #ax = plt.subplot(1,1,n+1)\n",
        "    #heatmap = make_gradcam_heatmap(x, model_for_pruning)\n",
        "    heatmap = make_gradcam_heatmap(x, model_cutmix)\n",
        "    # We rescale heatmap to a range 0-255\n",
        "    heatmap = np.uint8(255 * heatmap)\n",
        "    pred=np.argmax(model.predict(x))\n",
        "    #plt.imshow(np.matmul(heatmap.T,heatmap))\n",
        "    plt.imshow(heatmap[:13,:])\n",
        "    plt.title('Attention map across DCT Coefs')\n",
        "    plt.colorbar()\n",
        "    plt.xlabel('Head')\n",
        "    plt.ylabel('Layer')\n",
        "    plt.axis(\"off\")\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x432 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XWn3t2ftWpyi"
      },
      "source": [
        "# Comparative Models"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gHOKvhZBWyOQ"
      },
      "source": [
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.tree import DecisionTreeClassifier\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "from sklearn.svm import SVC\n",
        "from sklearn.naive_bayes import GaussianNB\n",
        "from sklearn.ensemble import AdaBoostClassifier\n",
        "from sklearn.ensemble import GradientBoostingClassifier"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2qTkthP_WyRm"
      },
      "source": [
        "#Splitting the data into train and test sets\n",
        "#Train- 0.8, Test -0.2\n",
        "#Random state is fixed to replicate the split in the data\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kvc5k5LnhCwY"
      },
      "source": [
        "import warnings\n",
        "warnings.filterwarnings(\"ignore\")\n",
        "\n",
        "from sklearn.metrics import f1_score"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IvnVJScSWyUQ"
      },
      "source": [
        "Y_train=one_hot_encoder.inverse_transform(y_train)\n",
        "Y_test=one_hot_encoder.inverse_transform(y_test)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QTGSwRjAgGVv"
      },
      "source": [
        "x_train=np.reshape(X_train,(X_train.shape[0],-1))\n",
        "x_test=np.reshape(X_test,(X_test.shape[0],-1))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "t6REdbevWyXE",
        "outputId": "7107edc5-4e04-43ea-d80d-708d71198f25"
      },
      "source": [
        "#Logistic Regression\n",
        "model=LogisticRegression(max_iter=300)\n",
        "model.fit(x_train,Y_train)\n",
        "y_pred=model.predict(x_test)\n",
        "\n",
        "print('Accuracy of Logistic Reg : {:.2f}'.format(accuracy_score(Y_test,y_pred)))\n",
        "print(classification_report(Y_test,y_pred))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Accuracy of Logistic Reg : 0.68\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.68      0.62      0.65       270\n",
            "           1       0.77      0.63      0.69       273\n",
            "           2       0.67      0.71      0.69       250\n",
            "           3       0.67      0.81      0.73       191\n",
            "           4       0.60      0.66      0.63       208\n",
            "\n",
            "    accuracy                           0.68      1192\n",
            "   macro avg       0.68      0.68      0.68      1192\n",
            "weighted avg       0.68      0.68      0.68      1192\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J1iLKHYdWyZ6",
        "outputId": "6955d3c1-872d-429d-91a2-d71243a8d97e"
      },
      "source": [
        "#NB\n",
        "model=GaussianNB()\n",
        "model.fit(x_train,Y_train)\n",
        "y_pred=model.predict(x_test)\n",
        "\n",
        "print('Accuracy of Naive Bayes Clf : {:.2f}'.format(accuracy_score(Y_test,y_pred)))\n",
        "print(classification_report(Y_test,y_pred))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Accuracy of Naive Bayes Reg : 0.58\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.69      0.37      0.48       270\n",
            "           1       0.63      0.46      0.53       273\n",
            "           2       0.75      0.67      0.71       250\n",
            "           3       0.49      0.76      0.60       191\n",
            "           4       0.45      0.71      0.55       208\n",
            "\n",
            "    accuracy                           0.58      1192\n",
            "   macro avg       0.60      0.60      0.58      1192\n",
            "weighted avg       0.62      0.58      0.57      1192\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TzNfABLaWydE",
        "outputId": "e762604c-cf94-49fd-d9e5-29d7a0a5809e"
      },
      "source": [
        "#SVM \n",
        "model=SVC(kernel='linear')\n",
        "model.fit(x_train,Y_train)\n",
        "y_pred=model.predict(x_test)\n",
        "\n",
        "print('Accuracy of SVM Clf: {:.2f}'.format(accuracy_score(Y_test,y_pred)))\n",
        "print(classification_report(Y_test,y_pred))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Accuracy of SVM Clf: 0.71\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.68      0.71      0.70       270\n",
            "           1       0.77      0.67      0.71       273\n",
            "           2       0.72      0.69      0.70       250\n",
            "           3       0.74      0.82      0.78       191\n",
            "           4       0.63      0.66      0.64       208\n",
            "\n",
            "    accuracy                           0.71      1192\n",
            "   macro avg       0.71      0.71      0.71      1192\n",
            "weighted avg       0.71      0.71      0.71      1192\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "n-KCAcKVWyfg",
        "outputId": "00c0d834-33dd-4174-fc72-e04432dc0014"
      },
      "source": [
        "#DT Clf\n",
        "model=DecisionTreeClassifier()\n",
        "model.fit(x_train,Y_train)\n",
        "y_pred=model.predict(x_test)\n",
        "\n",
        "print('Accuracy of Decision Tree Clf: {:.2f}'.format(accuracy_score(Y_test,y_pred)))\n",
        "print(classification_report(Y_test,y_pred))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Accuracy of Decision Tree Clf: 0.64\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.62      0.65      0.63       270\n",
            "           1       0.63      0.64      0.64       273\n",
            "           2       0.71      0.65      0.68       250\n",
            "           3       0.65      0.61      0.63       191\n",
            "           4       0.58      0.63      0.61       208\n",
            "\n",
            "    accuracy                           0.64      1192\n",
            "   macro avg       0.64      0.63      0.64      1192\n",
            "weighted avg       0.64      0.64      0.64      1192\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "S5fWJ-Ujk3gg",
        "outputId": "55aa0901-bce5-413a-f56e-bc81cec994b6"
      },
      "source": [
        "#Random Forest\n",
        "model=RandomForestClassifier(n_estimators=50)\n",
        "model.fit(x_train,Y_train)\n",
        "y_pred=model.predict(x_test)\n",
        "\n",
        "print('Accuracy of RF Clf: {:.2f}'.format(accuracy_score(Y_test,y_pred)))\n",
        "print(classification_report(Y_test,y_pred))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Accuracy of SVM Clf: 0.82\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.81      0.79      0.80       270\n",
            "           1       0.82      0.80      0.81       273\n",
            "           2       0.84      0.89      0.87       250\n",
            "           3       0.85      0.85      0.85       191\n",
            "           4       0.80      0.80      0.80       208\n",
            "\n",
            "    accuracy                           0.82      1192\n",
            "   macro avg       0.82      0.83      0.82      1192\n",
            "weighted avg       0.82      0.82      0.82      1192\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yadafN7ok3mV",
        "outputId": "011889aa-cf8a-424d-a4c7-9da6719afe9e"
      },
      "source": [
        "# Adaboost\n",
        "model=AdaBoostClassifier(n_estimators=100)\n",
        "model.fit(x_train,Y_train)\n",
        "y_pred=model.predict(x_test)\n",
        "\n",
        "print('Accuracy of Adaboost Clf: {:.2f}'.format(accuracy_score(Y_test,y_pred)))\n",
        "print(classification_report(Y_test,y_pred))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Accuracy of Adaboost Clf: 0.62\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.54      0.44      0.48       270\n",
            "           1       0.66      0.69      0.68       273\n",
            "           2       0.73      0.71      0.72       250\n",
            "           3       0.58      0.68      0.63       191\n",
            "           4       0.59      0.63      0.61       208\n",
            "\n",
            "    accuracy                           0.62      1192\n",
            "   macro avg       0.62      0.63      0.62      1192\n",
            "weighted avg       0.62      0.62      0.62      1192\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uDo3Qg6RxY_y"
      },
      "source": [
        "# Hyperparameter Tuning"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sCJ3OP3A6Vxc"
      },
      "source": [
        "! pip install keras-tuner"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bmJhnSNB6V6j"
      },
      "source": [
        "import tensorflow as tf\n",
        "from tensorflow import keras\n",
        "\n",
        "#Building model\n",
        "from keras.layers import Dense,LeakyReLU,ELU,PReLU,Dropout,Conv2D\n",
        "from keras.models import Sequential"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ako9_4cKxcgj"
      },
      "source": [
        "def  build_model(hp):\n",
        "  model=keras.Sequential([\n",
        "                          keras.layers.Conv2D(filters=hp.Int('Conv_1_filter',min_value=16,max_value=32,step=8),\n",
        "                                              kernel_size=hp.Choice('Convo_1_kernels',values=[1,3,5]),\n",
        "                                              activation='relu',\n",
        "                                              input_shape=input_shape),\n",
        "                           keras.layers.Dropout(0.2),\n",
        "                           keras.layers.Conv2D(filters=hp.Int('Conv_2_filter',min_value=8,max_value=16,step=4),\n",
        "                                              kernel_size=hp.Choice('Convo_2_kernels',values=[1,3,5]),\n",
        "                                              activation='relu'),\n",
        "                           keras.layers.Dropout(0.2),\n",
        "                           keras.layers.Conv2D(filters=hp.Int('Conv_3_filter',min_value=4,max_value=8,step=2),\n",
        "                                              kernel_size=hp.Choice('Convo_3_kernels',values=[1,3,5]),\n",
        "                                              activation='relu'),\n",
        "                          keras.layers.Dropout(0.2),\n",
        "                          keras.layers.Flatten(),\n",
        "                          keras.layers.Dense(units=hp.Int('Dense_1_units',min_value=16,max_value=32,step=8),\n",
        "                                             activation='relu'\n",
        "                                             ),\n",
        "                          keras.layers.Dropout(0.2),\n",
        "                          keras.layers.Dense(units=hp.Int('Dense_2_units',min_value=8,max_value=16,step=4),\n",
        "                                             activation='relu'\n",
        "                                             ),\n",
        "                          keras.layers.Dropout(0.2),\n",
        "                          keras.layers.Dense(units=hp.Int('Dense_3_units',min_value=4,max_value=8,step=2),\n",
        "                                             activation='relu'\n",
        "                                             ),\n",
        "                          keras.layers.Dropout(0.1),\n",
        "                          keras.layers.Dense(units=5,activation='softmax')\n",
        "                          \n",
        "                                             ])\n",
        "  model .compile(loss='categorical_crossentropy',optimizer='adam',metrics=['accuracy'])\n",
        "  model.summary()\n",
        "  return(model)\n",
        "\n",
        "from kerastuner import RandomSearch\n",
        "import kerastuner.engine.hyperparameters as Hyperparameters\n",
        "\n",
        "tuner_search=RandomSearch(build_model,\n",
        "                          objective='val_accuracy',\n",
        "                          max_trials=10\n",
        "                          )\n",
        "tuner_search.search(X_train,y_train,epochs=10,validation_split=0.1)\n",
        "model=tuner_search.get_best_models(num_models=1)[0]\n",
        "model.summary()\n",
        "model.fit(X_train,y_train,epochs=50,validation_split=0.2,initial_epoch=10)\n",
        "\n",
        "preds_y=model.predict(X_test)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "orpFsfL0-LXs"
      },
      "source": [
        "#Making predictions on the test set for the trtained model\n",
        "predictions = model.predict(X_test)\n",
        "#Identifying the class with highest probability of prediction\n",
        "predictions = np.argmax(predictions, axis=1)\n",
        "\n",
        "#Converting the 1*5 vectors back into interger form\n",
        "y_test_1 = one_hot_encoder.inverse_transform(y_test)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oBFNo22bBheZ",
        "outputId": "3541d609-38ba-4149-aa36-3550c58cb763"
      },
      "source": [
        "print('Accuracy of CNN model {}'.format(accuracy_score(y_test_1,predictions)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Accuracy of CNN model 0.8352842809364549\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CqixHEmeCZoj"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sFh9b3p55isl"
      },
      "source": [
        "# Ablation study"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "85Z0frCl5nLH"
      },
      "source": [
        "#Building CNN model\n",
        "#Commenting out unwanted columns to note down the results only with required layers\n",
        "\n",
        "model_cutmix = Sequential()\n",
        "# model_cutmix .add(Conv2D(40, (3, 3), activation='relu', strides=(1, 1),padding='same', input_shape=input_shape))\n",
        "# model_cutmix .add(Dropout(0.2))\n",
        "# model_cutmix .add(Conv2D(32, (1, 1), activation='relu', strides=(1, 1),padding='same'))\n",
        "# model_cutmix .add(Dropout(0.2))\n",
        "# model_cutmix .add(Conv2D(16, (1, 1), activation='relu', strides=(1, 1),padding='same'))\n",
        "# model_cutmix .add(Dropout(0.2))\n",
        "# model_cutmix .add(Flatten())\n",
        "model_cutmix .add(Dense(64, activation='relu',input_shape=(3575,)))\n",
        "model_cutmix .add(Dropout(0.2))\n",
        "model_cutmix .add(Dense(16, activation='relu'))\n",
        "model_cutmix .add(Dropout(0.2))\n",
        "model_cutmix .add(Dense(12, activation='relu'))\n",
        "model_cutmix .add(Dropout(0.1))\n",
        "model_cutmix .add(Dense(5, activation='softmax'))\n",
        "\n",
        "model_cutmix .compile(loss='categorical_crossentropy', \n",
        "     optimizer='adam',\n",
        "     metrics=['accuracy'])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L25bK6th5o0j",
        "outputId": "4d18d27e-8332-4dd0-bd99-1a822d1656ab"
      },
      "source": [
        "#Training the data for 50 epochs\n",
        "#Using Model checkpoints to avoid overfitting\n",
        "#Using a validation split of 0.2 from the train data\n",
        "\n",
        "checkpoint_filepath = '/tmp/checkpoint'\n",
        "\n",
        "model_checkpoint_callback = tf.keras.callbacks.ModelCheckpoint(\n",
        "    filepath=checkpoint_filepath,\n",
        "    save_weights_only=True,\n",
        "    monitor='val_accuracy',\n",
        "    mode='max',\n",
        "    save_best_only=True)\n",
        "\n",
        "history_cutmix =model_cutmix .fit(np.reshape(X_train,(X_train.shape[0],-1)),y_train,epochs=50,batch_size=32,\n",
        "          callbacks=[model_checkpoint_callback],\n",
        "          #validation_split=0.2\n",
        "          validation_data=(np.reshape(X_test,(X_test.shape[0],-1)),y_test))\n",
        "\n",
        "model_cutmix .load_weights(checkpoint_filepath)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/50\n",
            "598/598 [==============================] - 3s 4ms/step - loss: 1.5951 - accuracy: 0.2568 - val_loss: 1.4029 - val_accuracy: 0.3186\n",
            "Epoch 2/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.4739 - accuracy: 0.3203 - val_loss: 1.3299 - val_accuracy: 0.3746\n",
            "Epoch 3/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.4515 - accuracy: 0.3429 - val_loss: 1.3788 - val_accuracy: 0.3612\n",
            "Epoch 4/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.4288 - accuracy: 0.3525 - val_loss: 1.3064 - val_accuracy: 0.4197\n",
            "Epoch 5/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.4233 - accuracy: 0.3576 - val_loss: 1.3721 - val_accuracy: 0.3620\n",
            "Epoch 6/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.4319 - accuracy: 0.3508 - val_loss: 1.3335 - val_accuracy: 0.3896\n",
            "Epoch 7/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.4244 - accuracy: 0.3552 - val_loss: 1.2996 - val_accuracy: 0.4331\n",
            "Epoch 8/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.4204 - accuracy: 0.3541 - val_loss: 1.3010 - val_accuracy: 0.4122\n",
            "Epoch 9/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.4189 - accuracy: 0.3564 - val_loss: 1.2931 - val_accuracy: 0.4206\n",
            "Epoch 10/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.4177 - accuracy: 0.3532 - val_loss: 1.2933 - val_accuracy: 0.4398\n",
            "Epoch 11/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.4204 - accuracy: 0.3569 - val_loss: 1.3005 - val_accuracy: 0.4214\n",
            "Epoch 12/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.4190 - accuracy: 0.3561 - val_loss: 1.3002 - val_accuracy: 0.4415\n",
            "Epoch 13/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.4087 - accuracy: 0.3585 - val_loss: 1.2918 - val_accuracy: 0.4406\n",
            "Epoch 14/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.4046 - accuracy: 0.3634 - val_loss: 1.3644 - val_accuracy: 0.3436\n",
            "Epoch 15/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.4116 - accuracy: 0.3639 - val_loss: 1.3132 - val_accuracy: 0.4038\n",
            "Epoch 16/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.4037 - accuracy: 0.3659 - val_loss: 1.2843 - val_accuracy: 0.4540\n",
            "Epoch 17/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.4069 - accuracy: 0.3707 - val_loss: 1.3410 - val_accuracy: 0.3570\n",
            "Epoch 18/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.4132 - accuracy: 0.3569 - val_loss: 1.2786 - val_accuracy: 0.4548\n",
            "Epoch 19/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.4057 - accuracy: 0.3662 - val_loss: 1.2944 - val_accuracy: 0.4130\n",
            "Epoch 20/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.4066 - accuracy: 0.3631 - val_loss: 1.3067 - val_accuracy: 0.4139\n",
            "Epoch 21/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.4198 - accuracy: 0.3542 - val_loss: 1.3349 - val_accuracy: 0.3696\n",
            "Epoch 22/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.4017 - accuracy: 0.3629 - val_loss: 1.2961 - val_accuracy: 0.4147\n",
            "Epoch 23/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.4052 - accuracy: 0.3674 - val_loss: 1.3332 - val_accuracy: 0.3813\n",
            "Epoch 24/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.4175 - accuracy: 0.3587 - val_loss: 1.2821 - val_accuracy: 0.4498\n",
            "Epoch 25/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.4067 - accuracy: 0.3692 - val_loss: 1.3587 - val_accuracy: 0.3612\n",
            "Epoch 26/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.4025 - accuracy: 0.3616 - val_loss: 1.2930 - val_accuracy: 0.4398\n",
            "Epoch 27/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.3989 - accuracy: 0.3681 - val_loss: 1.2753 - val_accuracy: 0.4164\n",
            "Epoch 28/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.3981 - accuracy: 0.3790 - val_loss: 1.3381 - val_accuracy: 0.3595\n",
            "Epoch 29/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.4039 - accuracy: 0.3660 - val_loss: 1.2813 - val_accuracy: 0.4398\n",
            "Epoch 30/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.4034 - accuracy: 0.3723 - val_loss: 1.2845 - val_accuracy: 0.4339\n",
            "Epoch 31/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.3914 - accuracy: 0.3829 - val_loss: 1.3454 - val_accuracy: 0.3495\n",
            "Epoch 32/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.4073 - accuracy: 0.3739 - val_loss: 1.3113 - val_accuracy: 0.4156\n",
            "Epoch 33/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.4022 - accuracy: 0.3716 - val_loss: 1.3072 - val_accuracy: 0.3754\n",
            "Epoch 34/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.3961 - accuracy: 0.3765 - val_loss: 1.3199 - val_accuracy: 0.4047\n",
            "Epoch 35/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.4045 - accuracy: 0.3702 - val_loss: 1.2891 - val_accuracy: 0.4523\n",
            "Epoch 36/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.3990 - accuracy: 0.3768 - val_loss: 1.3193 - val_accuracy: 0.3704\n",
            "Epoch 37/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.4052 - accuracy: 0.3743 - val_loss: 1.2857 - val_accuracy: 0.4507\n",
            "Epoch 38/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.3847 - accuracy: 0.3808 - val_loss: 1.3888 - val_accuracy: 0.3712\n",
            "Epoch 39/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.3882 - accuracy: 0.3810 - val_loss: 1.3082 - val_accuracy: 0.4281\n",
            "Epoch 40/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.4032 - accuracy: 0.3794 - val_loss: 1.2750 - val_accuracy: 0.4674\n",
            "Epoch 41/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.4006 - accuracy: 0.3785 - val_loss: 1.3499 - val_accuracy: 0.4055\n",
            "Epoch 42/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.3955 - accuracy: 0.3890 - val_loss: 1.3454 - val_accuracy: 0.4064\n",
            "Epoch 43/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.3914 - accuracy: 0.3820 - val_loss: 1.3874 - val_accuracy: 0.3871\n",
            "Epoch 44/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.3892 - accuracy: 0.3867 - val_loss: 1.3302 - val_accuracy: 0.4239\n",
            "Epoch 45/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.3981 - accuracy: 0.3845 - val_loss: 1.3051 - val_accuracy: 0.4281\n",
            "Epoch 46/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.3901 - accuracy: 0.3800 - val_loss: 1.3632 - val_accuracy: 0.4022\n",
            "Epoch 47/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.3890 - accuracy: 0.3846 - val_loss: 1.2831 - val_accuracy: 0.4640\n",
            "Epoch 48/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.4023 - accuracy: 0.3816 - val_loss: 1.3681 - val_accuracy: 0.4030\n",
            "Epoch 49/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.3975 - accuracy: 0.3799 - val_loss: 1.3480 - val_accuracy: 0.4089\n",
            "Epoch 50/50\n",
            "598/598 [==============================] - 2s 3ms/step - loss: 1.3976 - accuracy: 0.3827 - val_loss: 1.2596 - val_accuracy: 0.4699\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tensorflow.python.training.tracking.util.CheckpointLoadStatus at 0x7f12aa71d190>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 150
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g2fSpUrNHbHb"
      },
      "source": [
        "#np.reshape(X_train,(X_train.shape[0],-1))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KiZ5-BWq9SQD"
      },
      "source": [
        "#Making predictions on the test set for the trtained model\n",
        "#predictions = model_cutmix.predict(X_test)\n",
        "predictions = model_cutmix.predict(np.reshape(X_test,(X_test.shape[0],-1)))\n",
        "#Identifying the class with highest probability of prediction\n",
        "predictions = np.argmax(predictions, axis=1)\n",
        "\n",
        "#Converting the 1*5 vectors back into interger form\n",
        "y_test_1 = one_hot_encoder.inverse_transform(y_test)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3i1FcIox9WoT"
      },
      "source": [
        "print('Accuracy of CNN model {}'.format(accuracy_score(y_test_1,predictions)))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WQCV2Fmt-aBj"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}