OpenFace-DTW-SVM.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import necessary libraries\n",
    "\n",
    "# import built-in libraries\n",
    "import os\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from glob import glob\n",
    "import re\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "# import functions from tslearn\n",
    "from tslearn.utils import to_time_series_dataset\n",
    "from tslearn.preprocessing import TimeSeriesScalerMinMax\n",
    "from tslearn.svm import TimeSeriesSVC\n",
    "from tslearn.neighbors import KNeighborsTimeSeriesClassifier\n",
    "\n",
    "# import functions from sklearn\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.model_selection import KFold\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import classification_report"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a function that aggregates all csv files\n",
    "def aggregate_data(csv_dir, label):\n",
    "    \n",
    "    # get the list of all csv files\n",
    "    csv_lst = glob(os.path.join(csv_dir, '*.csv'))\n",
    "    \n",
    "    # compile a regular expression to extract\n",
    "    # the digits part of the file name\n",
    "    r = re.compile('\\D*(\\d*).csv')\n",
    "    \n",
    "    # create a lambda expression with this regular expression\n",
    "    extract_num = lambda x:int(r.search(x).group(1))\n",
    "    \n",
    "    # sort the file name in ascending order\n",
    "    csv_lst.sort(key=extract_num)\n",
    "                               \n",
    "    # create an empty dataframe to hold the results\n",
    "    df = pd.DataFrame()\n",
    "    \n",
    "    # process each csv file in turn\n",
    "    for csv in csv_lst:\n",
    "        \n",
    "        # read in the data from this csv file\n",
    "        df_tmp = pd.read_csv(csv)\n",
    "        \n",
    "        # strip the white spaces before and after the column names\n",
    "        df_tmp.columns = df_tmp.columns.str.strip()\n",
    "        \n",
    "        # add a column to denote the video id\n",
    "        df_tmp['vid'] = extract_num(csv)\n",
    "        \n",
    "        # add another column to denote the label\n",
    "        df_tmp['label'] = label\n",
    "        \n",
    "        # append this dataframe to the aggregated dataframe\n",
    "        df = df.append(df_tmp, ignore_index=True)\n",
    "        \n",
    "        # reset the index without keeping the old one\n",
    "        df.reset_index(drop=True, inplace=True)\n",
    "    \n",
    "    # return the resulting dataframe\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a function that sanitizes data\n",
    "def sanitize_data(df):\n",
    "    \n",
    "    # copy the dataset to tmp\n",
    "    df_tmp = df.copy()\n",
    "    \n",
    "    # create a filter that filters out unsuccessful entries\n",
    "    filt1 = df_tmp['success'] != 1\n",
    "    \n",
    "    # remove unsuccessful entries\n",
    "    df_tmp.drop(index=df.loc[filt1].index, inplace=True)\n",
    "    \n",
    "    # create a filter that filters out low-confidence entries\n",
    "    filt2 = df_tmp['confidence'] < 0.8\n",
    "    \n",
    "    # remove low-confidence entries\n",
    "    df_tmp.drop(index=df_tmp.loc[filt2].index, inplace=True)\n",
    "    \n",
    "    # reset the index without keeping the old one\n",
    "    df_tmp.reset_index(drop=True, inplace=True)\n",
    "    \n",
    "    # return the resulting dataframe\n",
    "    return df_tmp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set the root folder of the dataset\n",
    "root = 'dataset'\n",
    "\n",
    "# set the folder that contains the dataset for happy smiles\n",
    "dir_happy = os.path.join(root,'happy_frames_openface')\n",
    "\n",
    "# set the folder that contains the dataset for nervous smiles\n",
    "dir_nervous = os.path.join(root,'nervous_frames_openface')\n",
    "\n",
    "# aggregate the data for happy smiles\n",
    "# the label for happy smiles is 1\n",
    "df_happy = aggregate_data(dir_happy, 1)\n",
    "\n",
    "# aggregate the data for nervous smiles\n",
    "# the label for nervous smiles is 0\n",
    "df_nervous = aggregate_data(dir_nervous, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# data sanitizations\n",
    "\n",
    "# the data for the happy smiles\n",
    "df_happy = sanitize_data(df_happy)\n",
    "\n",
    "# the data for the nervous smiles\n",
    "df_nervous = sanitize_data(df_nervous)\n",
    "\n",
    "# save to files\n",
    "df_happy.to_csv('happy_smiles.csv')\n",
    "df_nervous.to_csv('nervous_smiles.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a function that groups frames \n",
    "# belonging to each video\n",
    "def group_featrues(df_features):\n",
    "    \n",
    "    # create an empty list to hold the results\n",
    "    lst = []\n",
    "    \n",
    "    # process each entry by video id\n",
    "    for vid in df_features['vid'].unique():\n",
    "        \n",
    "        # create a filter that leave frames\n",
    "        # belonging to this vid alone\n",
    "        filt = df_features['vid'] == vid\n",
    "        \n",
    "        # extract the frames belonging to this vid\n",
    "        # convert to ndarray and add to the list\n",
    "        lst.append(df_features[filt].drop(['vid'],axis=1).to_numpy())\n",
    "    \n",
    "    # return the results as a ndarray\n",
    "    return np.array(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# feature extraction\n",
    "\n",
    "# selected features for classification\n",
    "features = ['AU06_r','AU12_r', 'AU26_r','vid']\n",
    "\n",
    "# extract features for happy smiles\n",
    "df_happy_features = df_happy.loc[:,features]\n",
    "\n",
    "# extract features for nervous smiles\n",
    "df_nervous_features = df_nervous.loc[:,features]\n",
    "\n",
    "# group features to a ndarray\n",
    "np_happy_features = group_featrues(df_happy_features)\n",
    "np_nervous_features = group_featrues(df_nervous_features)\n",
    "\n",
    "# create a combined features\n",
    "X = np.concatenate([np_happy_features,np_nervous_features])\n",
    "\n",
    "# create a combined labels\n",
    "y = np.concatenate([np.ones(np_happy_features.shape[0]), np.zeros(np_nervous_features.shape[0])])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# split the dataset into the training set and test set\n",
    "X_train,X_test,y_train,y_test = train_test_split(X, y, shuffle=True, random_state=16, test_size = 0.2)\n",
    "\n",
    "# convert these features to time series\n",
    "\n",
    "# features from the training set \n",
    "X_train = to_time_series_dataset(X_train)\n",
    "\n",
    "# features from the test set\n",
    "X_test = to_time_series_dataset(X_test)\n",
    "\n",
    "# feature scaling\n",
    "\n",
    "# features from the training set \n",
    "#X_train = TimeSeriesScalerMinMax().fit_transform(X_train)\n",
    "\n",
    "# features from the test set\n",
    "#X_test = TimeSeriesScalerMinMax().fit_transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The optimal kernel for the kernel SVM is gak\n",
      "The optimal C for the kernel SVM is 4\n"
     ]
    }
   ],
   "source": [
    "# model selection\n",
    "\n",
    "# create a kNN model with the metric of DTW \n",
    "svc = TimeSeriesSVC()\n",
    "\n",
    "# possible k values\n",
    "pgrid = {'kernel': ['gak','rbf'], 'C':list(range(1,10))}\n",
    "\n",
    "# 5-fold cross-validation for training\n",
    "cv = KFold(n_splits=5, shuffle=True, random_state=0)\n",
    "\n",
    "# create a searcher for the optimal value of k\n",
    "grid_search = GridSearchCV(estimator=svc, n_jobs=6, param_grid=pgrid, cv=cv)\n",
    "\n",
    "# SVM parameter tuning with the training set\n",
    "grid_search.fit(X_train, y_train)\n",
    "\n",
    "# get the optimal kernel from the grid search\n",
    "k = grid_search.best_params_['kernel']\n",
    "\n",
    "# get the optimal kernel\n",
    "print(f'The optimal kernel for the kernel SVM is {k}')\n",
    "\n",
    "# get the optimal C, penalty parameter C of the error term\n",
    "# from the grid search\n",
    "c = grid_search.best_params_['C']\n",
    "\n",
    "# get the optimal kernel\n",
    "print(f'The optimal C for the kernel SVM is {c}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a optimal SVM model\n",
    "svc_opt = TimeSeriesSVC(kernel=k, C=c, n_jobs=6)\n",
    "\n",
    "# fit the SVM model to the training set\n",
    "svc_opt.fit(X_train, y_train)\n",
    "\n",
    "# predict the labels\n",
    "y_train_predict = svc_opt.predict(X_train)\n",
    "y_test_predict = svc_opt.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The average accuracy of training is 68.64%\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       1.00      1.00      1.00        91\n",
      "         1.0       1.00      1.00      1.00       180\n",
      "\n",
      "    accuracy                           1.00       271\n",
      "   macro avg       1.00      1.00      1.00       271\n",
      "weighted avg       1.00      1.00      1.00       271\n",
      "\n",
      "The confusion matrix for training:\n",
      "[[ 91   0]\n",
      " [  0 180]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# get the training accuracy\n",
    "# use 5-fold cross-validation\n",
    "cvs_trn = cross_val_score(svc_opt, X_train, y_train, cv=5, scoring=\"accuracy\")\n",
    "\n",
    "# report the mean accuracy of training\n",
    "print(f'The average accuracy of training is {np.mean(cvs_trn)*100:.2f}%')\n",
    "\n",
    "# print classification report\n",
    "print(classification_report(y_train, y_train_predict))\n",
    "\n",
    "# compute the confusion matrix\n",
    "cm_train = confusion_matrix(y_train, y_train_predict)\n",
    "\n",
    "# display the confusion matrix\n",
    "print('The confusion matrix for training:')\n",
    "print(cm_train)\n",
    "\n",
    "# plot the confusion matrix\n",
    "# as a seaborn heatmap\n",
    "\n",
    "# plot the heat map\n",
    "heat_map = sns.heatmap(cm_train, annot=True, cmap='hot')\n",
    "\n",
    "# set the tick labels\n",
    "heat_map.set_xticklabels(['Predicted Nervous', 'Predicted Joyful'],\n",
    "                         fontdict={'horizontalalignment': 'center'})\n",
    "\n",
    "heat_map.set_yticklabels(['True Nervous', 'True Joyful'],\n",
    "                         fontdict={'verticalalignment': 'center'})\n",
    "\n",
    "# set the title\n",
    "heat_map.set_title('The Confusion Matrix')\n",
    "\n",
    "# show the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The average accuracy of testing is 66.26%\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       1.00      0.22      0.36        23\n",
      "         1.0       0.71      1.00      0.83        45\n",
      "\n",
      "    accuracy                           0.74        68\n",
      "   macro avg       0.86      0.61      0.60        68\n",
      "weighted avg       0.81      0.74      0.67        68\n",
      "\n",
      "The confusion matrix for testing:\n",
      "[[ 5 18]\n",
      " [ 0 45]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# get the testing accuracy\n",
    "# use 5-fold cross-validation\n",
    "cvs_test = cross_val_score(svc_opt, X_test, y_test, cv=5, scoring=\"accuracy\")\n",
    "\n",
    "# report the mean accuracy of training\n",
    "print(f'The average accuracy of testing is {np.mean(cvs_test)*100:.2f}%')\n",
    "\n",
    "# print classification report\n",
    "print(classification_report(y_test, y_test_predict))\n",
    "\n",
    "# compute the confusion matrix\n",
    "cm_test = confusion_matrix(y_test, y_test_predict)\n",
    "\n",
    "# display the confusion matrix\n",
    "print('The confusion matrix for testing:')\n",
    "print(cm_test)\n",
    "\n",
    "# plot the confusion matrix\n",
    "# as a seaborn heatmap\n",
    "\n",
    "# plot the heat map\n",
    "heat_map = sns.heatmap(cm_test, annot=True, cmap='hot')\n",
    "\n",
    "# set the tick labels\n",
    "heat_map.set_xticklabels(['Predicted Nervous', 'Predicted Joyful'],\n",
    "                         fontdict={'horizontalalignment': 'center'})\n",
    "\n",
    "heat_map.set_yticklabels(['True Nervous', 'True Joyful'],\n",
    "                         fontdict={'verticalalignment': 'center'})\n",
    "\n",
    "# set the title\n",
    "heat_map.set_title('The Confusion Matrix')\n",
    "\n",
    "# show the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The optimal value of k is 1 for time series kNN~\n"
     ]
    }
   ],
   "source": [
    "# model selection\n",
    "\n",
    "# create a kNN model with the metric of DTW \n",
    "knn = KNeighborsTimeSeriesClassifier(metric=\"dtw\")\n",
    "\n",
    "# possible k values\n",
    "pgrid = {\"n_neighbors\": list(range(1, 3))}\n",
    "\n",
    "# 5-fold cross-validation for training\n",
    "cv = KFold(n_splits=5, shuffle=True, random_state=0)\n",
    "\n",
    "# create a searcher for the optimal value of k\n",
    "grid_search = GridSearchCV(estimator=knn, n_jobs=6, param_grid=pgrid, cv=cv)\n",
    "\n",
    "# kNN model tuning with the training set\n",
    "grid_search.fit(X_train, y_train)\n",
    "\n",
    "# get the best parameter from the grid search\n",
    "k_opt = grid_search.best_params_['n_neighbors']\n",
    "\n",
    "# get the optimal value of k\n",
    "print(f'The optimal value of k is {k_opt} for time series kNN~')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a kNN model with the optimal value of k\n",
    "knn_opt = KNeighborsTimeSeriesClassifier(n_neighbors=k_opt, metric=\"dtw\", n_jobs=6)\n",
    "\n",
    "# fit the kNN model to the training set\n",
    "knn_opt.fit(X_train, y_train)\n",
    "\n",
    "# predict the labels\n",
    "y_train_predict = knn_opt.predict(X_train)\n",
    "y_test_predict = knn_opt.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The average accuracy of training is 66.04%\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       1.00      1.00      1.00        91\n",
      "         1.0       1.00      1.00      1.00       180\n",
      "\n",
      "    accuracy                           1.00       271\n",
      "   macro avg       1.00      1.00      1.00       271\n",
      "weighted avg       1.00      1.00      1.00       271\n",
      "\n",
      "The confusion matrix for training:\n",
      "[[ 91   0]\n",
      " [  0 180]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# get the testing accuracy\n",
    "# use 5-fold cross-validation\n",
    "cvs_train = cross_val_score(knn_opt, X_train, y_train, cv=5, scoring=\"accuracy\")\n",
    "\n",
    "# report the mean accuracy of training\n",
    "print(f'The average accuracy of training is {np.mean(cvs_train)*100:.2f}%')\n",
    "\n",
    "# print classification report\n",
    "print(classification_report(y_train, y_train_predict))\n",
    "\n",
    "# compute the confusion matrix\n",
    "cm_train = confusion_matrix(y_train, y_train_predict)\n",
    "\n",
    "# display the confusion matrix\n",
    "print('The confusion matrix for training:')\n",
    "print(cm_train)\n",
    "\n",
    "# plot the confusion matrix\n",
    "# as a seaborn heatmap\n",
    "\n",
    "# plot the heat map\n",
    "heat_map = sns.heatmap(cm_train, annot=True, cmap='hot')\n",
    "\n",
    "# set the tick labels\n",
    "heat_map.set_xticklabels(['Predicted Nervous', 'Predicted Joyful'],\n",
    "                         fontdict={'horizontalalignment': 'center'})\n",
    "\n",
    "heat_map.set_yticklabels(['True Nervous', 'True Joyful'],\n",
    "                         fontdict={'verticalalignment': 'center'})\n",
    "\n",
    "# set the title\n",
    "heat_map.set_title('The Confusion Matrix(For Training)')\n",
    "\n",
    "# show the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The average accuracy of testing is 69.34%\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.42      0.35      0.38        23\n",
      "         1.0       0.69      0.76      0.72        45\n",
      "\n",
      "    accuracy                           0.62        68\n",
      "   macro avg       0.56      0.55      0.55        68\n",
      "weighted avg       0.60      0.62      0.61        68\n",
      "\n",
      "The confusion matrix for testing:\n",
      "[[ 8 15]\n",
      " [11 34]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# get the testing accuracy\n",
    "# use 5-fold cross-validation\n",
    "cvs_test = cross_val_score(knn_opt, X_test, y_test, cv=5, scoring=\"accuracy\")\n",
    "\n",
    "# report the mean accuracy of training\n",
    "print(f'The average accuracy of testing is {np.mean(cvs_test)*100:.2f}%')\n",
    "\n",
    "# print classification report\n",
    "print(classification_report(y_test, y_test_predict))\n",
    "\n",
    "# compute the confusion matrix\n",
    "cm_test = confusion_matrix(y_test, y_test_predict)\n",
    "\n",
    "# display the confusion matrix\n",
    "print('The confusion matrix for testing:')\n",
    "print(cm_test)\n",
    "\n",
    "# plot the confusion matrix\n",
    "# as a seaborn heatmap\n",
    "\n",
    "# plot the heat map\n",
    "heat_map = sns.heatmap(cm_test, annot=True, cmap='hot')\n",
    "\n",
    "# set the tick labels\n",
    "heat_map.set_xticklabels(['Predicted Nervous', 'Predicted Joyful'],\n",
    "                         fontdict={'horizontalalignment': 'center'})\n",
    "\n",
    "heat_map.set_yticklabels(['True Nervous', 'True Joyful'],\n",
    "                         fontdict={'verticalalignment': 'center'})\n",
    "\n",
    "# set the title\n",
    "heat_map.set_title('The Confusion Matrix(For Testing)')\n",
    "\n",
    "# show the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.466199999044546"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "svc_opt.gamma_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'auto'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "svc_opt.gamma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.466199999044546"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "svc_opt.gamma_"
   ]
  },
  {
   "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}