SVM-baseline.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### README\n",
    "This script build and tests a baseline SVM model. The intent of this model is to\n",
    "serve as a goal for our CNN+BiLSTM model to beat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import required libraries\n",
    "import pandas as pd # for holding data in a dataframe\n",
    "import os # for manipulating directories and listing files\n",
    "from matplotlib import pyplot as plt #visualization\n",
    "import numpy as np # linear algebra and array work\n",
    "from sklearn import svm # Model for training\n",
    "from sklearn.model_selection import train_test_split #Splitting data\n",
    "from sklearn.metrics import accuracy_score, classification_report #accuracy report"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_csvs(dirPath,marker):\n",
    "    '''\n",
    "    This function reads all the .csv files at the specified director \n",
    "    and then loads them individually into a merged dataframe. It \n",
    "    returns a merged dataframe with a reset index. It also appends the video number\n",
    "    into the dataframe.\n",
    "    '''\n",
    "    # list files in directory\n",
    "    files = os.listdir(dirPath)\n",
    "    \n",
    "    # Create list of valid .csv files in directory and sort numerically\n",
    "    csvs = [csv for csv in files if csv.endswith('.csv')]\n",
    "    csvs.sort(key = lambda x: int(x[1:-4]))\n",
    "    \n",
    "    # Parse through csv files\n",
    "    for inx,csv in enumerate(csvs):\n",
    "        # If this is the first file, we need to create the merged_df\n",
    "        if inx == 0:\n",
    "            merged_df = pd.read_csv(dirPath + csv)\n",
    "            merged_df['video'] = str(0)+marker \n",
    "        # else we just read and append\n",
    "        else :\n",
    "            temp_df = pd.read_csv(dirPath + csv)\n",
    "            temp_df['video'] = str(inx) + marker\n",
    "            merged_df = merged_df.append(temp_df)\n",
    "\n",
    "    return merged_df.reset_index(drop=True)\n",
    "\n",
    "def keys_to_array(df, keys):\n",
    "    '''\n",
    "    Takes a dataframe and list of strings, as input. Takes the keys and indexes\n",
    "    the required rows and then returns the array of values ready to go into\n",
    "    a learning algorithm or to be tested\n",
    "    '''\n",
    "    \n",
    "    inx = df['video'].isin(keys)\n",
    "    temp_df = df.loc[inx, :].drop(['video'],axis=1)\n",
    "\n",
    "    y = temp_df.pop('isNerv').values\n",
    "    X = temp_df.values\n",
    "    \n",
    "    return X, y\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load happy data\n",
    "happyPath = 'dataset/happy_frames_openface/'\n",
    "happy_df = read_csvs(happyPath,'h')\n",
    "happy_df['isNerv'] = 0\n",
    "\n",
    "# Load nervous data\n",
    "nervousPath = 'dataset/nervous_frames_openface/'\n",
    "nervous_df = read_csvs(nervousPath,'n')\n",
    "nervous_df['isNerv'] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "merged_df = happy_df.append(nervous_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create list of AUs and cols that we want to extract from the imported dataset\n",
    "cols = [' AU01_r', ' AU02_r', ' AU04_r', ' AU05_r', ' AU06_r', ' AU07_r',\n",
    "       ' AU09_r', ' AU10_r', ' AU12_r', ' AU14_r', ' AU15_r', ' AU17_r',\n",
    "       ' AU20_r', ' AU23_r', ' AU25_r', ' AU26_r', ' AU45_r', 'video', 'isNerv']\n",
    "# Create a pointer to the original df that only includes the columns we want\n",
    "merged_df = merged_df.loc[:,cols]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create list of keys corresponding to the video for splitting\n",
    "X_keys = merged_df['video'].unique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Split into train/test\n",
    "X_train_keys, X_test_keys = train_test_split(X_keys, random_state=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Go from X_train_keys to X_train and etc\n",
    "X_train, y_train = keys_to_array(merged_df, X_train_keys)\n",
    "X_test, y_test = keys_to_array(merged_df, X_test_keys)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.68      0.82      0.75      3731\n",
      "           1       0.41      0.24      0.30      1895\n",
      "\n",
      "    accuracy                           0.63      5626\n",
      "   macro avg       0.55      0.53      0.52      5626\n",
      "weighted avg       0.59      0.63      0.60      5626\n",
      "\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "Initialize default model with rbf kernel, train and then test the model. \n",
    "We understand that not tuning gamma and C will lead to worse performance.\n",
    "However, we have already performed ~5 hours \n",
    "of hyperparameter tuning with minimal improvments to scores. Tuning of the SVM leads\n",
    "to the SVM simply predicting 0 for everything. Further, this test is just a baseline\n",
    "to serve as a goal for our NN implementation to beat.\n",
    "'''\n",
    "SVM = svm.SVC(kernel='rbf')\n",
    "\n",
    "SVM.fit(X_train,y_train)\n",
    "\n",
    "y_pred = SVM.predict(X_test)\n",
    "\n",
    "print(classification_report(y_test,y_pred))"
   ]
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}