Inference-hard.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.io.wavfile import read as read_wav\n",
    "from IPython.display import Audio\n",
    "import matplotlib.pyplot as plt\n",
    "from collections import Counter\n",
    "import tensorflow as tf\n",
    "import librosa as lr\n",
    "import seaborn as sn\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import scipy\n",
    "import pydub\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "genres = {\n",
    "    'disco': 0,\n",
    "    'country': 1,\n",
    "    'jazz': 2,\n",
    "    'classical': 3,\n",
    "    'blues': 4,\n",
    "    'hiphop': 5,\n",
    "    'metal': 6,\n",
    "    'rock': 7,\n",
    "    'pop': 8,\n",
    "    'reggae': 9\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "hparams = {\n",
    "    'samplerate': 22050,\n",
    "    'seq_length': 256,\n",
    "    'hop_length': 512,\n",
    "    'fft_window': 2048\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_features(filepath, hparams):\n",
    "    \n",
    "    audio_data_array = lr.load(filepath, sr=hparams['samplerate'], mono=True)\n",
    "    \n",
    "    # normalized = lr.util.normalize(audio_data_array[0])\n",
    "    \n",
    "    features = [\n",
    "        \n",
    "        # MFCC Features:\n",
    "        lr.feature.mfcc(\n",
    "            y          = audio_data_array[0],\n",
    "            sr         = hparams['samplerate'],\n",
    "            hop_length = hparams['hop_length'],\n",
    "            n_fft      = hparams['fft_window']\n",
    "        ),\n",
    "\n",
    "        # Chroma STFT:\n",
    "        lr.feature.chroma_stft(\n",
    "            y          = audio_data_array[0],\n",
    "            sr         = hparams['samplerate'],\n",
    "            hop_length = hparams['hop_length'],\n",
    "            n_fft      = hparams['fft_window']\n",
    "        ),\n",
    "        \n",
    "        # Spectral Centroid:\n",
    "        lr.feature.spectral_centroid(\n",
    "            y          = audio_data_array[0],\n",
    "            sr         = hparams['samplerate'],\n",
    "            hop_length = hparams['hop_length'],\n",
    "            n_fft      = hparams['fft_window']\n",
    "        ),\n",
    "        \n",
    "        # Spectral Contrast:\n",
    "        lr.feature.spectral_contrast(\n",
    "            y          = audio_data_array[0],\n",
    "            sr         = hparams['samplerate'],\n",
    "            hop_length = hparams['hop_length'],\n",
    "            n_fft      = hparams['fft_window']\n",
    "        )\n",
    "    ]\n",
    "    \n",
    "    return np.vstack(features)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "lstm_1_model = tf.keras.models.load_model('LSTM-1/models/model')\n",
    "lstm_2a_model = tf.keras.models.load_model('LSTM-2a/models/model')\n",
    "lstm_2b_model = tf.keras.models.load_model('LSTM-2b/models/model')\n",
    "lstm_3a_model = tf.keras.models.load_model('LSTM-3a/models/model')\n",
    "lstm_3b_model = tf.keras.models.load_model('LSTM-3b/models/model')\n",
    "lstm_3c_model = tf.keras.models.load_model('LSTM-3c/models/model')\n",
    "lstm_3d_model = tf.keras.models.load_model('LSTM-3d/models/model')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lookup(arr):\n",
    "    if arr == [0, 0, 0]:\n",
    "        return 'hiphop'\n",
    "    elif arr == [0, 0, 1]:\n",
    "        return 'metal'\n",
    "    elif arr == [0, 0, 2]:\n",
    "        return 'rock'\n",
    "    elif arr == [0, 1, 0]:\n",
    "        return 'pop'\n",
    "    elif arr == [0, 1, 1]:\n",
    "        return 'reggae'\n",
    "    elif arr == [1, 0, 0]:\n",
    "        return 'disco'\n",
    "    elif arr == [1, 0, 1]:\n",
    "        return 'country'\n",
    "    elif arr == [1, 1, 0]:\n",
    "        return 'jazz'\n",
    "    elif arr == [1, 1, 1]:\n",
    "        return 'classical'\n",
    "    else:\n",
    "        return 'blues'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(features, nseg, hparams):\n",
    "    \n",
    "    result = []\n",
    "    \n",
    "    lstm_1_res_arr = []\n",
    "    for i in range(nseg):\n",
    "        lstm_1_res_arr += [np.argmax(\n",
    "            lstm_1_model.predict(\n",
    "                np.moveaxis(\n",
    "                    features[:, i * hparams['seq_length']:(i+1) * hparams['seq_length']], 0, 1\n",
    "                ).reshape(1, 256, 40)\n",
    "            )\n",
    "        )]\n",
    "\n",
    "    lstm_1_res = list(Counter(lstm_1_res_arr))[0]    \n",
    "    result += [lstm_1_res]\n",
    "    \n",
    "    # strong classes:\n",
    "    if lstm_1_res == 0:\n",
    "        \n",
    "        lstm_2a_res_arr = []\n",
    "        for i in range(nseg):\n",
    "            lstm_2a_res_arr += [np.argmax(\n",
    "                lstm_2a_model.predict(\n",
    "                    np.moveaxis(\n",
    "                        features[:, i * hparams['seq_length']:(i+1) * hparams['seq_length']], 0, 1\n",
    "                    ).reshape(1, 256, 40)\n",
    "                )\n",
    "            )]\n",
    "\n",
    "        lstm_2a_res = list(Counter(lstm_2a_res_arr))[0]\n",
    "        \n",
    "        result += [lstm_2a_res]\n",
    "        \n",
    "        # substrong-1:\n",
    "        if lstm_2a_res == 0:\n",
    "            \n",
    "            lstm_3a_res_arr = []\n",
    "            for i in range(nseg):\n",
    "                lstm_3a_res_arr += [np.argmax(\n",
    "                    lstm_3a_model.predict(\n",
    "                        np.moveaxis(\n",
    "                            features[:, i * hparams['seq_length']:(i+1) * hparams['seq_length']], 0, 1\n",
    "                        ).reshape(1, 256, 40)\n",
    "                    )\n",
    "                )]\n",
    "\n",
    "            lstm_3a_res = list(Counter(lstm_3a_res_arr))[0]\n",
    "        \n",
    "            result += [lstm_3a_res]\n",
    "            \n",
    "        # substrong-2:\n",
    "        else:\n",
    "            \n",
    "            lstm_3b_res_arr = []\n",
    "            for i in range(nseg):\n",
    "                lstm_3b_res_arr += [np.argmax(\n",
    "                    lstm_3b_model.predict(\n",
    "                        np.moveaxis(\n",
    "                            features[:, i * hparams['seq_length']:(i+1) * hparams['seq_length']], 0, 1\n",
    "                        ).reshape(1, 256, 40)\n",
    "                    )\n",
    "                )]\n",
    "\n",
    "            lstm_3b_res = list(Counter(lstm_3b_res_arr))[0]\n",
    "\n",
    "            result += [lstm_3b_res]\n",
    "            \n",
    "    # mild classes:\n",
    "    else:\n",
    "        \n",
    "        lstm_2b_res_arr = []\n",
    "        for i in range(nseg):\n",
    "            lstm_2b_res_arr += [np.argmax(\n",
    "                lstm_2b_model.predict(\n",
    "                    np.moveaxis(\n",
    "                        features[:, i * hparams['seq_length']:(i+1) * hparams['seq_length']], 0, 1\n",
    "                    ).reshape(1, 256, 40)\n",
    "                )\n",
    "            )]\n",
    "\n",
    "        lstm_2b_res = list(Counter(lstm_2b_res_arr))[0]\n",
    "        \n",
    "        result += [lstm_2b_res]\n",
    "        \n",
    "        \n",
    "        # submild-1:\n",
    "        if lstm_2b_res == 0:\n",
    "            \n",
    "            lstm_3c_res_arr = []\n",
    "            for i in range(nseg):\n",
    "                lstm_3c_res_arr += [np.argmax(\n",
    "                    lstm_3c_model.predict(\n",
    "                        np.moveaxis(\n",
    "                            features[:, i * hparams['seq_length']:(i+1) * hparams['seq_length']], 0, 1\n",
    "                        ).reshape(1, 256, 40)\n",
    "                    )\n",
    "                )]\n",
    "\n",
    "            lstm_3c_res = list(Counter(lstm_3c_res_arr))[0]            \n",
    "            result += [lstm_3c_res]\n",
    "            \n",
    "        # submild-2:\n",
    "        else:\n",
    "            \n",
    "            lstm_3d_res_arr = []\n",
    "            for i in range(nseg):\n",
    "                lstm_3d_res_arr += [np.argmax(\n",
    "                    lstm_3d_model.predict(\n",
    "                        np.moveaxis(\n",
    "                            features[:, i * hparams['seq_length']:(i+1) * hparams['seq_length']], 0, 1\n",
    "                        ).reshape(1, 256, 40)\n",
    "                    )\n",
    "                )]\n",
    "\n",
    "            lstm_3d_res = list(Counter(lstm_3d_res_arr))[0]            \n",
    "            result += [lstm_3d_res]\n",
    "            \n",
    "    return lookup(list(result))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accuracy on GTZAN Validation and Test Set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "confusion_mat = np.zeros(shape=(10, 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===================================\n",
      "Original Genre:  pop\n",
      "===================================\n",
      "Original Genre:  jazz\n",
      "===================================\n",
      "Original Genre:  reggae\n",
      "===================================\n",
      "Original Genre:  disco\n",
      "===================================\n",
      "Original Genre:  blues\n",
      "===================================\n",
      "Original Genre:  hiphop\n",
      "===================================\n",
      "Original Genre:  rock\n",
      "===================================\n",
      "Original Genre:  metal\n",
      "===================================\n",
      "Original Genre:  classical\n",
      "===================================\n",
      "Original Genre:  country\n"
     ]
    }
   ],
   "source": [
    "for genre in os.listdir('dataset/'):\n",
    "    \n",
    "    filelist = os.listdir('./dataset/' + genre)\n",
    "    \n",
    "    print('===================================')\n",
    "    print('Original Genre: ', genre)\n",
    "    for i in range(90, 100, 1):\n",
    "        features = extract_features('dataset/' + genre + '/' + filelist[i], hparams)\n",
    "        nseg = features.shape[1] // 256\n",
    "        result = predict(features, nseg, hparams)\n",
    "        \n",
    "        if result == genre:\n",
    "            confusion_mat[genres[genre]][genres[genre]] += 1\n",
    "        else:\n",
    "            confusion_mat[genres[genre]][genres[result]] += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "confusion_dataframe = pd.DataFrame(\n",
    "    data=confusion_mat,\n",
    "    index=list(genres.keys()),\n",
    "    columns=list(genres.keys())\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(8, 6))\n",
    "\n",
    "sn.set(font_scale=1.4) # for label size\n",
    "sn.heatmap(confusion_dataframe, annot=True, annot_kws={\"size\": 10})\n",
    "\n",
    "fig.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 54.0 %\n"
     ]
    }
   ],
   "source": [
    "accuracy = 100 * (np.sum(np.diag(confusion_mat)) / np.sum(confusion_mat))\n",
    "print('Accuracy: {} %'.format(accuracy))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}