train-and-evaluate.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training and Evaluating the Model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This script will be used to train and evaluate an Ensemble Extra Trees model on featurized data. The model will then be saved to a pickle file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import pickle\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import librosa\n",
    "import librosa.display\n",
    "\n",
    "from IPython import display\n",
    "from matplotlib import pyplot\n",
    "from sklearn.ensemble import BaggingClassifier, ExtraTreesClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A simple wrapper class for (1-channel) audio data\n",
    "# data is a 1-D NumPy array containing the data\n",
    "# rate is a number expressing the samples per second\n",
    "class Audio:\n",
    "    def __init__(self, data, rate):\n",
    "        self.data = data\n",
    "        self.rate = rate\n",
    "    def play(self):\n",
    "        return display.Audio(self.data, rate=self.rate)\n",
    "    def plot_wave(self):\n",
    "        librosa.display.waveplot(self.data, sr=self.rate)\n",
    "    def plot_spectrum(self):\n",
    "        n_fft = int(self.rate / 20)\n",
    "        D = librosa.amplitude_to_db(np.abs(librosa.stft(self.data, n_fft)), ref=np.max)\n",
    "        librosa.display.specshow(D, y_axis='linear', sr=self.rate, hop_length=n_fft/4)\n",
    "    @classmethod\n",
    "    def fromfile(cls, fn):\n",
    "        return cls(*librosa.load(fn, sr=None))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Credit to Yihui Xiong, 2017, \n",
    "# https://github.com/xiongyihui/tdoa/blob/master/gcc_phat.py\n",
    "def gcc_phat(sig, refsig, fs=1, max_tau=None, interp=16):\n",
    "    '''\n",
    "    This function computes the offset between the signal sig and the reference signal refsig\n",
    "    using the Generalized Cross Correlation - Phase Transform (GCC-PHAT)method.\n",
    "    '''\n",
    "    \n",
    "    # make sure the length for the FFT is larger or equal than len(sig) + len(refsig)\n",
    "    n = sig.shape[0] + refsig.shape[0]\n",
    "\n",
    "    # Generalized Cross Correlation Phase Transform\n",
    "    SIG = np.fft.rfft(sig, n=n)\n",
    "    REFSIG = np.fft.rfft(refsig, n=n)\n",
    "    R = SIG * np.conj(REFSIG)\n",
    "\n",
    "    cc = np.fft.irfft(R / np.abs(R), n=(interp * n))\n",
    "\n",
    "    max_shift = int(interp * n / 2)\n",
    "    if max_tau:\n",
    "        max_shift = np.minimum(int(interp * fs * max_tau), max_shift)\n",
    "\n",
    "    cc = np.concatenate((cc[-max_shift:], cc[:max_shift+1]))\n",
    "\n",
    "    # find max cross correlation index\n",
    "    shift = np.argmax(np.abs(cc)) - max_shift\n",
    "\n",
    "    tau = shift / float(interp * fs)\n",
    "    \n",
    "    return tau, cc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load training and testing data\n",
    "train_df = pd.read_csv('data/featurized/featurized_train_data.csv')\n",
    "test_df = pd.read_csv('data/featurized/featurized_test_data.csv')  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Facing Constitutes as -90 to 90"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_df = train_df.loc[:,list(map(lambda c: c not in ['sample', 'trial', 'angle_pos', 'dov'], list(train_df.columns)))]\n",
    "X = X_df.values\n",
    "y_df = train_df.loc[:,\"dov\"]\n",
    "y_df = y_df.map(lambda x: int(x in [0,45,90,270,315]))\n",
    "y = y_df.values\n",
    "X[np.isnan(X)] = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "tc = ExtraTreesClassifier(n_estimators=1000)\n",
    "tc_fitted = BaggingClassifier(tc).fit(X,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.00043402777777777775"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Z = tc_fitted.predict(X) - y\n",
    "\n",
    "# training error\n",
    "(Z.T @ Z)/Z.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_df_t = test_df.loc[:,list(map(lambda c: c not in ['sample', 'trial', 'angle_pos', 'dov'], list(test_df.columns)))]\n",
    "Xt = X_df_t.values\n",
    "y_df_t = test_df.loc[:,\"dov\"]\n",
    "y_df_t = y_df_t.map(lambda x: int(x in [0,45,90,270,315]))\n",
    "yt = y_df_t.values\n",
    "Xt[np.isnan(Xt)] = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.796875"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Zt = (tc_fitted.predict(Xt) - yt)\n",
    "\n",
    "# testing accuracy\n",
    "1 - ((Zt.T @ Zt) / Zt.size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename = 'models/model-90to90.sav'\n",
    "pickle.dump(tc_fitted, open(filename, 'wb'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Facing Constitutes as -45 to 45"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_df = train_df.loc[:,list(map(lambda c: c not in ['sample', 'trial', 'angle_pos', 'dov'], list(train_df.columns)))]\n",
    "X = X_df.values\n",
    "y_df = train_df.loc[:,\"dov\"]\n",
    "y_df = y_df.map(lambda x: int(x in [0,45,315]))\n",
    "y = y_df.values\n",
    "X[np.isnan(X)] = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "tc = ExtraTreesClassifier(n_estimators=1000)\n",
    "tc_fitted = BaggingClassifier(tc).fit(X,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0008680555555555555"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Z = tc_fitted.predict(X) - y\n",
    "\n",
    "# training error\n",
    "(Z.T @ Z)/Z.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_df_t = test_df.loc[:,list(map(lambda c: c not in ['sample', 'trial', 'angle_pos', 'dov'], list(test_df.columns)))]\n",
    "Xt = X_df_t.values\n",
    "y_df_t = test_df.loc[:,\"dov\"]\n",
    "y_df_t = y_df_t.map(lambda x: int(x in [0,45,315]))\n",
    "yt = y_df_t.values\n",
    "Xt[np.isnan(Xt)] = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8194444444444444"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Zt = (tc_fitted.predict(Xt) - yt)\n",
    "\n",
    "# testing accuracy\n",
    "1 - ((Zt.T @ Zt) / Zt.size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename = 'models/model-45to45.sav'\n",
    "pickle.dump(tc_fitted, open(filename, 'wb'))"
   ]
  }
 ],
 "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.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}