1-Feature-Extraction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**MUSIC CLASSIFICATION**\n",
    "\n",
    "This project will seek to train models that predict the genre of music.\n",
    "\n",
    "The GTZAN genre classification datasets was used to obtain audio samples with similar size and frequency range.\n",
    "- 1000 audio samples\n",
    "- 30 seconds each\n",
    "\n",
    "Dataset: http://marsyas.info/downloads/datasets.html\n",
    "\n",
    "**10 Music Genres:**\n",
    "- Blues\n",
    "- Classical\n",
    "- Country\n",
    "- Disco\n",
    "- Hiphop\n",
    "- Jazz\n",
    "- Metal\n",
    "- Pop\n",
    "- Reggae\n",
    "- Rock\n",
    "\n",
    "**Models**\n",
    "- Start with K-nearest neighbour\n",
    "\n",
    "\n",
    "NOTE:\n",
    "This notebook's content is mainly taken from https://data-flair.training/blogs/python-project-music-genre-classification/ and serves as a starting point for this project!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import math, random, pickle, os, operator\n",
    "from tempfile import TemporaryFile\n",
    "\n",
    "from scipy.io import wavfile\n",
    "from python_speech_features import mfcc\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Feature Extraction**\n",
    "\n",
    "MFCC (Mel Frequency Cepstral Coefficients):\n",
    "- cepstrum reprsents information on the rate of change in spectral bands\n",
    "    - spectrum of the log of frequency spectrum of time signal\n",
    "- relates perceived frequency of tone to actual measured frequency\n",
    "    - scales frequency to match what a human hears (can identify small changes at lower frequencies)\n",
    "- MFCC gives representation of phonemes being produced through shape of vocal tract\n",
    "- Algorithm:\n",
    "    1. divide signals into smaller frames (20-40ms) as samples they constantly change\n",
    "    2. Identify frequencies in each frame\n",
    "    3. Use Mel filterbank to find sum of energy in different frequency bands\n",
    "    4. Take log (as perceived volume scales logarithmically)\n",
    "    5. Compute Discrete Cosing Transform (DCT)\n",
    "        - filterbanks overlapping, so energies are correlated - DCT \"decorrelates energies\", so diagonal covariance matrices can be used to model features\n",
    "    6. we only keep the lower 13 DCT coefficients as higher DCT coefficients represent faster changes in filterbank energies - 13 MFCC coefficients is usually enough to represent the shape of the spectrum\n",
    "\n",
    "Cepstral features\n",
    "- can separate impact of source (vocal cords) and filter (vocal tract) in a signal as they occur in different regions of the cepstral domain\n",
    "\n",
    "    \n",
    "http://www.practicalcryptography.com/miscellaneous/machine-learning/guide-mel-frequency-cepstral-coefficients-mfccs/\n",
    "https://www.researchgate.net/post/Why_we_take_only_12-13_MFCC_coefficients_in_feature_extraction\n",
    "https://medium.com/@tanveer9812/mfccs-made-easy-7ef383006040\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# feature extraction\n",
    "path  = \"D:/Datasets/genres/\"\n",
    "f = open(\"feat.dat\",'wb')\n",
    "\n",
    "genre=0\n",
    "for fold in os.listdir(path):\n",
    "    genre+=1\n",
    "    if genre==11:\n",
    "        break\n",
    "    for file in os.listdir(path+fold):\n",
    "        (rate, sig) = wavfile.read(path+fold+\"/\"+file) # returns sample rate and data (sig)\n",
    "        mfcc_feat = mfcc(sig, rate, winlen=0.02, appendEnergy = False) # returns NUMFRAMES by 13 array)\n",
    "        covariance = np.cov(np.matrix.transpose(mfcc_feat))\n",
    "        mean_matrix = mfcc_feat.mean(0) # mean along column\n",
    "        feature = (mean_matrix, covariance, genre)\n",
    "        pickle.dump(feature, f)\n",
    "\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# loading data - could try converting ot pandas Dataframe instead\n",
    "dataset = []\n",
    "train = []\n",
    "test = []\n",
    "with open(\"feat.dat\", 'rb') as f:\n",
    "    while True:\n",
    "        try:\n",
    "            dataset.append(pickle.load(f))\n",
    "        except EOFError:\n",
    "            f.close()\n",
    "            break\n",
    "    \n",
    "    for x in range(len(dataset)):\n",
    "        if random.random() < 0.66:\n",
    "            train.append(dataset[x])\n",
    "        else:\n",
    "            test.append(dataset[x])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "333"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Implementing KNN Model**\n",
    "\n",
    "This model is from https://data-flair.training/blogs/python-project-music-genre-classification/."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get distance between examples\n",
    "def distance (inst1, inst2, k):\n",
    "    distance = 0\n",
    "    mm1 = inst1[0]\n",
    "    cm1 = inst1[1]\n",
    "    mm2 = inst2[0]\n",
    "    cm2 = inst2[1]\n",
    "    distance = np.trace(np.dot(np.linalg.inv(cm2), cm1)) # \n",
    "    distance += np.dot(np.dot((mm2-mm1).transpose(), np.linalg.inv(cm2)), mm2-mm1)\n",
    "    distance += np.log(np.linalg.det(cm2)) - np.log(np.linalg.det(cm1))\n",
    "    distance -= k\n",
    "    return distance\n",
    "    \n",
    "\n",
    "# get distance between feature vector and find neighbors\n",
    "def getNeighbours(trainingSet, instance, k):\n",
    "    distances = []\n",
    "    for x in range (len(trainingSet)):\n",
    "        dist = distance(trainingSet[x], instance, k) + distance(instance, trainingSet[x], k)\n",
    "        distances.append((trainingSet[x][2], dist)) # distance with label\n",
    "    distances.sort(key=operator.itemgetter(1)) # sort by distance (index 1 in tuple)\n",
    "    neighbours = []\n",
    "    for x in range(k): \n",
    "        neighbours.append(distances[x][0]) \n",
    "    return neighbours # nearest k instances\n",
    "\n",
    "def nearestClass(neighbours):\n",
    "    classVote = {}\n",
    "    for x in range(len(neighbours)):\n",
    "        response = neighbours[x] # distance\n",
    "        if response in classVote:\n",
    "            classVote[response]+=1\n",
    "        else:\n",
    "            classVote[response]=1\n",
    "    sorter = sorted(classVote.items(), key = operator.itemgetter(1), reverse=True)\n",
    "    return sorter[0][0]\n",
    "\n",
    "# model evaluation\n",
    "def getAccuracy(testSet, predictions):\n",
    "    correct = 0\n",
    "    for x in range(len(testSet)):\n",
    "        if testSet[x][-1]==predictions[x]:\n",
    "            correct+=1\n",
    "    return 1.0*correct/len(testSet) # fraction correct\n",
    "        \n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6336336336336337\n",
      "0.6336336336336337\n",
      "0.6516516516516516\n",
      "0.6816816816816816\n",
      "0.6876876876876877\n",
      "0.6906906906906907\n",
      "0.6906906906906907\n",
      "0.6846846846846847\n"
     ]
    }
   ],
   "source": [
    "# make prediction and get accuracies for K values from 1-8\n",
    "accuracies = []\n",
    "for k in range(1,9):\n",
    "    predictions = []\n",
    "    for x in range(len(test)):\n",
    "        predictions.append(nearestClass(getNeighbours(train, test[x], k)))\n",
    "\n",
    "    accuracy = getAccuracy(test, predictions)\n",
    "    accuracies.append(accuracy)\n",
    "    print(accuracy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Model evaluation\n",
    "\n",
    "- K nearest neighbour model accuracies for different K values\n",
    "\n",
    "<table>\n",
    "    <tr>\n",
    "        <th>K value</th>\n",
    "        <th>Accuracy</th>\n",
    "    </tr>\n",
    "    <tr><td>1</td><td>0.6336</td></tr>\n",
    "    <tr><td>2</td><td>0.6336</td></tr>\n",
    "    <tr><td>3</td><td>0.6517</td></tr>\n",
    "    <tr><td>4</td><td>0.6817</td></tr>\n",
    "    <tr><td>5</td><td>0.6877</td></tr>\n",
    "    <tr><td>6</td><td>0.6907</td></tr>\n",
    "    <tr><td>7</td><td>0.6907</td></tr>\n",
    "    <tr><td>8</td><td>0.6847</td></tr>\n",
    "</table>\n",
    "\n",
    "Accuracy seems to peak at around K=6 or 7 and then falls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:xlabel='K', ylabel='Accuracy'>"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot of accuracies\n",
    "acc = pd.DataFrame(accuracies)\n",
    "acc.columns = [\"Accuracy\"]\n",
    "acc[\"K\"] = list(range(1,9))\n",
    "\n",
    "sns.barplot(x=\"K\", y=\"Accuracy\", data=acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "acc.columns = [\"Accuracy\"]\n",
    "acc[\"K\"] = list(range(1,9))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Accuracy</th>\n",
       "      <th>K</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.633634</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.633634</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.651652</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.681682</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.687688</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0.690691</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>0.690691</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>0.684685</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Accuracy  K\n",
       "0  0.633634  1\n",
       "1  0.633634  2\n",
       "2  0.651652  3\n",
       "3  0.681682  4\n",
       "4  0.687688  5\n",
       "5  0.690691  6\n",
       "6  0.690691  7\n",
       "7  0.684685  8"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "acc"
   ]
  }
 ],
 "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}