DTW-BicepCurl.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import math\n",
    "import glob\n",
    "import utils\n",
    "\n",
    "from parse import load_ps\n",
    "from pprint import pprint\n",
    "from scipy.signal import medfilt\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.neighbors import DistanceMetric\n",
    "from sklearn.metrics import classification_report"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array(['bicep_bad_10.npy', 'bicep_bad_3.npy', 'bicep_good_6.npy',\n",
      "       'bicep_bad_5.npy', 'bicep_bad_8.npy', 'bicep_good_1.npy',\n",
      "       'bicep_good_3.npy', 'bicep_bad_4.npy', 'bicep_bad_7.npy'],\n",
      "      dtype='<U16')\n",
      "array([0, 0, 1, 0, 0, 1, 1, 0, 0])\n",
      "array(['bicep_bad_1.npy', 'bicep_bad_2.npy', 'bicep_bad_6.npy',\n",
      "       'bicep_good_5.npy', 'bicep_good_4.npy', 'bicep_good_2.npy',\n",
      "       'bicep_bad_9.npy'], dtype='<U16')\n",
      "array([0, 0, 0, 1, 1, 1, 0])\n"
     ]
    }
   ],
   "source": [
    "files = utils.files_in_order('poses_compressed/bicep')\n",
    "#print(files)\n",
    "X_train_names, X_test_names = train_test_split(files, test_size=0.4, random_state=42)\n",
    "y_train = utils.get_labels(X_train_names)\n",
    "y_test = utils.get_labels(X_test_names)\n",
    "pprint(X_train_names)\n",
    "pprint(y_train)\n",
    "pprint(X_test_names)\n",
    "pprint(y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_features(names):\n",
    "    output1 = [] # List of upper arm torso angles\n",
    "    output2 = [] # List of forearm upper arm angles\n",
    "    for filename in names:\n",
    "        ps = load_ps('poses_compressed/bicep/'+filename)\n",
    "        poses = ps.poses\n",
    "\n",
    "        right_present = [1 for pose in poses \n",
    "                if pose.rshoulder.exists and pose.relbow.exists and pose.rwrist.exists]\n",
    "        left_present = [1 for pose in poses\n",
    "                if pose.lshoulder.exists and pose.lelbow.exists and pose.lwrist.exists]\n",
    "        right_count = sum(right_present)\n",
    "        left_count = sum(left_present)\n",
    "        side = 'right' if right_count > left_count else 'left'\n",
    "\n",
    "        if side == 'right':\n",
    "            joints = [(pose.rshoulder, pose.relbow, pose.rwrist, pose.rhip, pose.neck) for pose in poses]\n",
    "        else:\n",
    "            joints = [(pose.lshoulder, pose.lelbow, pose.lwrist, pose.lhip, pose.neck) for pose in poses]\n",
    "\n",
    "        # filter out data points where a part does not exist\n",
    "        joints = [joint for joint in joints if all(part.exists for part in joint)]\n",
    "        \n",
    "        upper_arm_vecs = np.array([(joint[0].x - joint[1].x, joint[0].y - joint[1].y) for joint in joints])\n",
    "        torso_vecs = np.array([(joint[4].x - joint[3].x, joint[4].y - joint[3].y) for joint in joints])\n",
    "        forearm_vecs = np.array([(joint[2].x - joint[1].x, joint[2].y - joint[1].y) for joint in joints])\n",
    "        \n",
    "        upper_arm_vecs = upper_arm_vecs / np.expand_dims(np.linalg.norm(upper_arm_vecs, axis=1), axis=1)\n",
    "        torso_vecs = torso_vecs / np.expand_dims(np.linalg.norm(torso_vecs, axis=1), axis=1)\n",
    "        forearm_vecs = forearm_vecs / np.expand_dims(np.linalg.norm(forearm_vecs, axis=1), axis=1)\n",
    "        \n",
    "        upper_arm_torso_angle = np.degrees(np.arccos(np.clip(np.sum(np.multiply(upper_arm_vecs, torso_vecs), axis=1), -1.0, 1.0)))\n",
    "        upper_arm_torso_angle_filtered = medfilt(medfilt(upper_arm_torso_angle, 5), 5)\n",
    "        \n",
    "        upper_arm_forearm_angle = np.degrees(np.arccos(np.clip(np.sum(np.multiply(upper_arm_vecs, forearm_vecs), axis=1), -1.0, 1.0)))\n",
    "        upper_arm_forearm_angle_filtered = medfilt(medfilt(upper_arm_forearm_angle, 5), 5)\n",
    "\n",
    "        output1.append(upper_arm_torso_angle_filtered.tolist())\n",
    "        output2.append(upper_arm_forearm_angle_filtered.tolist())\n",
    "    return output1, output2\n",
    "\n",
    "X_train_1, X_train_2 = load_features(X_train_names)\n",
    "X_test_1, X_test_2 = load_features(X_test_names)\n",
    "#features = load_features(files)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             precision    recall  f1-score   support\n",
      "\n",
      "    correct       0.80      1.00      0.89         4\n",
      "  incorrect       1.00      0.67      0.80         3\n",
      "\n",
      "avg / total       0.89      0.86      0.85         7\n",
      "\n"
     ]
    }
   ],
   "source": [
    "predictions = []\n",
    "for example in range(len(X_test_names)):\n",
    "    # Store the average distance to good and bad training examples\n",
    "    f1_good, f1_bad, f2_good, f2_bad = [[] for i in range(4)]\n",
    "    \n",
    "    # Compare distance of current test example with all training examples\n",
    "    for i in range(len(X_train_1)):\n",
    "        dist1 = utils.DTWDistance(X_train_1[i], X_test_1[example])\n",
    "        dist2 = utils.DTWDistance(X_train_2[i], X_test_2[example])\n",
    "        if y_train[i]:\n",
    "            f1_good.append(dist1)\n",
    "            f2_good.append(dist2)\n",
    "        else:\n",
    "            f1_bad.append(dist1)\n",
    "            f2_bad.append(dist2)\n",
    "    good_score = np.mean(f1_good) + np.mean(f2_good)\n",
    "    bad_score = np.mean(f1_bad) + np.mean(f2_bad)\n",
    "    \n",
    "    if good_score < bad_score:\n",
    "        predictions.append(1)\n",
    "    else:\n",
    "        predictions.append(0)\n",
    "print(classification_report(y_test, predictions, target_names=['correct', 'incorrect']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print(len(X_train))\n",
    "# print(len(X_test))\n",
    "# print(y_train.shape)\n",
    "# knn = KNeighborsClassifier(n_neighbors=2, metric=DTWDistance)\n",
    "# #knn.fit(X_train, y_train)"
   ]
  }
 ],
 "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.5.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}