classify_Actionset_3.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from norm import *\n",
    "from utils import *\n",
    "from MostJoints.getMostInformativeJoints import *\n",
    "import os\n",
    "from itertools import chain\n",
    "import setting\n",
    "import pickle\n",
    "\n",
    "from sklearn.multiclass import OneVsRestClassifier\n",
    "from sklearn.svm import LinearSVC\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA_PATH = 'data/'\n",
    "ACTION_SETS_PATH = 'actionsets/'\n",
    "ACTION_SETS  = ['actionsets/ActionSet1.txt', 'actionsets/ActionSet2.txt', 'actionsets/ActionSet3.txt']\n",
    "ACTION_NAMES = ['Wave','Hammer','Smash','Catch','Forward Punch','Throw','Draw X','Draw Tick','Draw ',\n",
    "               'Circle','Clapping Hand','Two hand Wave','Side Boxing','Bend','Forward Kick','Side Kick','Jogging',\n",
    "               'Tennis Swing','Tennis Serve','Golf Swing','Pickup&throw']\n",
    "TRAINING_SUBJECTS = ['s01','s03','s05','s07','s09']\n",
    "TESTING_SUBJECTS = ['s02','s04','s06','s08','s10']\n",
    "\n",
    "with open(ACTION_SETS_PATH + 'ActionSet3.txt', 'r') as f:\n",
    "    as3_names = f.readlines()\n",
    "for i in range(len(as3_names)):\n",
    "    as3_names[i] = as3_names[i].rstrip(\"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_as3_names = [as3_names[i] for i in range(len(as3_names)) if as3_names[i][4:7] in TRAINING_SUBJECTS]\n",
    "test_as3_names = [as3_names[i] for i in range(len(as3_names)) if as3_names[i][4:7] in TESTING_SUBJECTS]\n",
    "train_as3_names = [train_as3_names[i] + '_skeleton3D.txt' for i in range(len(train_as3_names))]\n",
    "test_as3_names = [test_as3_names[i] + '_skeleton3D.txt' for i in range(len(test_as3_names))]\n",
    "as3_names = [as3_names[i] + '_skeleton3D.txt' for i in range(len(as3_names))]\n",
    "train_as3_names = sorted(train_as3_names)\n",
    "test_as3_names = sorted(test_as3_names)\n",
    "as3_names = sorted(as3_names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_most_informative_joints(filenames):\n",
    "    # Notice that filenames shoube be sorted before fitting into this method\n",
    "    # For training phase\n",
    "    noFramesList = []\n",
    "    d1 = {'a0' + str(i) : [] for i in range(1,10)}\n",
    "    d2 = {'a' + str(i) : [] for i in range(10, 21)}\n",
    "    mostInformativeJointsList = dict(chain.from_iterable(d.items() for d in (d1,d2)))\n",
    "    for i in range(len(filenames)):\n",
    "        with open('data/' + filenames[i], 'r') as f:\n",
    "            skeleton_i_th = [line.rstrip('\\n') for line in f]\n",
    "        for j in range(len(skeleton_i_th)):\n",
    "            skeleton_i_th[j] = [float(coord) for coord in skeleton_i_th[j].split(' ')]\n",
    "        skeleton_i_th = np.asarray(skeleton_i_th)\n",
    "        noFrames = int(skeleton_i_th.shape[0]/setting.NUMBER_OF_JOINTS)\n",
    "        x = skeleton_i_th[:,0]\n",
    "        y = skeleton_i_th[:,1]\n",
    "        z = skeleton_i_th[:,2]\n",
    "        x = x.reshape(setting.NUMBER_OF_JOINTS, int(skeleton_i_th.shape[0]/setting.NUMBER_OF_JOINTS))\n",
    "        y = y.reshape(setting.NUMBER_OF_JOINTS, int(skeleton_i_th.shape[0]/setting.NUMBER_OF_JOINTS))\n",
    "        z = z.reshape(setting.NUMBER_OF_JOINTS, int(skeleton_i_th.shape[0]/setting.NUMBER_OF_JOINTS))\n",
    "        t = np.arange(1, noFrames+1)\n",
    "        noFramesList.append(noFrames)\n",
    "        listIdxMostJoints = getMostJoints(x.T,y.T,z.T,1,setting.NUMBER_OF_JOINTS)\n",
    "        mostInformativeJointsList[filenames[i][0:3]].append(listIdxMostJoints)\n",
    "    return noFramesList, mostInformativeJointsList"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_as3_noFrameList, train_as3_mostInformativeJointsList = get_most_informative_joints(train_as3_names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_histograms(action_label):\n",
    "    action = train_as3_mostInformativeJointsList[action_label]\n",
    "    Ns_4 = [0 for i in range(20)]\n",
    "    Ns_8 = [0 for i in range(20)]\n",
    "    Ns_12 = [0 for i in range(20)]\n",
    "    \n",
    "    for i in range(len(action)):\n",
    "        for j in range(0, 20):\n",
    "            if action[i][j] > 15 :\n",
    "                Ns_4[j] += 1\n",
    "            if action[i][j] > 11:\n",
    "                Ns_8[j] += 1\n",
    "            if action[i][j] > 7:\n",
    "                Ns_12[j] += 1\n",
    "    x_labels = [i for i in range(1,21)]\n",
    "    fig, ax = plt.subplots(figsize=(10,6))\n",
    "    ind = np.arange(20)\n",
    "    width = 0.35\n",
    "    p1 = ax.bar(ind, Ns_4, width, color='indianred')\n",
    "    p2 = ax.bar(ind+width, Ns_8, width, color='dimgray')\n",
    "    p3 = ax.bar(ind+width*2, Ns_12, width, color='lightseagreen')\n",
    "    ax.set_title('Joint apperances of action' + action_label)\n",
    "    ax.set_xticks(ind+width/2)\n",
    "    ax.set_xticklabels(x_labels)\n",
    "    ax.legend((p1[0], p2[0], p3[0]), ('Ns_4', 'Ns_8', 'Ns_12'))\n",
    "    ax.autoscale_view()\n",
    "    plt.show()\n",
    "    return Ns_4, Ns_8, Ns_12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlMAAAF1CAYAAADMXG9eAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3XuYXXV97/H3VwaIkARICCkSYsYbFDiGhhxjRdEY2xARtT1CRQ0CcuZpA9VAuHqpEbFHayiWQy2C8XI0ogYDEpEGLFKtR6IkEAHhiJhIIvcgwRAQgt/zx16JwzCTmcxv7ZnZk/freeaZvdft+117z579md9ae01kJpIkSeqfFwx2A5IkSa3MMCVJklTAMCVJklTAMCVJklTAMCVJklTAMCVJklTAMCUNERGxMSJeMth96I8iYnxE/CAifhcRFzS51h0R8YZm1pDUHIYpqcki4saIOLm35TJzZGb+qo/bzIh4WXl36kUH8AgwOjPn1bXRiPhSRJzfeVpmHpyZN9ZVYxu1D42IFRGxqfp+aJf5U6oAuTEiHoyIDzS7J6nVGaYkNU1EtA12D4VeDPw8h8nVjSNiF+DbwFeBvYAvA9+uphMRewP/DnwOGAu8DLhucLqVWodhShpAEfE/I+KXEfFoRFwdES/qNG/raFM1cvGvEXFNdYhpeUS8tJr3g2qVVdXowd90U+elEXFDRKyPiEciYlFE7Nlp/pqIODcifh4Rv42IL0bEiGreGyJiXUR8sFp3TUS8u9O6u0bEgoi4txq5uCQiXthl3bMj4gHgixGxV0R8JyIermp9JyImdNrejRHx8Yj4UbWv11Vv6lvmvzYi/m9EPBYRayPihD70sXdV57Hqsf5hRHT7+y4iXhMRP42IDdX312x5DoD3AmdVj/Obuln3qIi4JSIer3qb32X+83qPiA7g3Z22u7TTc/KmTvv2mYi4r/r6TETs2uUxnhcRD0XE/RFxYh97egPQBnwmM3+fmRcBAbyxmn86sCwzF1Xzf5eZd3b3uEn6I8OUNEAi4o3A/wKOBfYFfg18fRurvBP4GI0RhF8CnwDIzCOq+ZOrQ4Pf6K5cVetFwJ8C+wPzuyzzbmAm8FLgFcCHO837E2BvYD8ageLSiDigmvfJavlDaYxc7Af8Q5d1x9AY1emg8Xvmi9X9icCTwMVdenkXcCKwD7ALcAZARLwYuBb438C4quatfehjHrCuWmc88EHgeaNLETEGuAa4iMZIzD8D10TE2Mw8AVgE/FP1OH+v6/rAE8DxwJ7AUcDfRcTbt9V7Zl7aZbtHd7PdDwGvrtaZDLyK5z8/e1T7/D7gXyNir956Ag4GftZlpO1n1XSqmo9WAfChiFgaERO76U9SJ4YpaeC8G/hCZq7MzN8D5wJ/HhGTelj+ysz8SWZupvHme2gPyz1PZv4yM6+vRhcephESXt9lsYszc21mPkojqB3XZf5HqvX/k0bgODYigkZAOi0zH83M3wH/SCP4bfEH4KPVuk9m5vrM/FZmbqqW/0Q3vXwxM3+RmU8C3+y0r+8CvpeZl2fmM9W2bu1DH8/QCKwvrtb7YQ+H6o4C7s7Mr2Tm5sy8HLgL6C7gPE9m3piZt2XmHzLzZ8Dlnfat2977sl0aPyvnZeZD1fP3MWB2p/nPVPOfyczvAhuBA/rQ00hgQ5daG4BR1e0JNMLzB2gE39XV+pK2odXPZ5BayYuAlVvuZObGiFhPY3RhTTfLP9Dp9iYab4R9EhHjgX8BXkfjjfIFwG+7LLa20+1fV/1t8dvMfKKb+eOA3YAVjTzTKAfs1GnZhzPzqU697AZcCBxJY5QNYFRE7JSZz1b3e9rX/YF7utnF3vr4NI2RuOuq+Zdm5ie72c6Lqn3r7Nc0npNeRcQ0GiNkh9AYUdsVWNxL733Rta+uz8/6KmRvsfUx66WnjcDoLrVGA7+rbj9JI8T/tNrWx4BHImKPzOwawiRVHJmSBs59NA51ARARu9M4tPSbJtT6RxqHtf5bZo4G3kMjbHS2f6fbE6v+ttir6q/r/EdovOEenJl7Vl97ZGbnoNd1BGgejVGTaVUvWw5Tdu2nO2tpHIbsapt9VOf6zMvMlwBvBU6PiBndbOc5z0mnfe3rc/I14Gpg/8zcA7iEP+5XT71DN4cce+mr6/PT357uAF4ZnRIo8MpqOjQO+XXubViceC81m2FKGjiXAydG46Ppu9IIPMszc00/tvUgsK1rUo2iMQqxISL2A87sZplTImJCdd7Qh4Cu5159LCJ2iYjXAW8BFmfmH4DLgAsjYh+AiNgvImb20suTwGNVrY/2Yf+2WAS8KSKOjYi2iBgbEYf21kdEvCUiXlaFhg3AszQOP3b1XeAVEfGuavt/AxwEfKeP/Y0CHs3MpyLiVTQO7W2z92peb8/f5cCHI2JcdTL+P9D4BF5pTzfSeCzeX53kfmo1/Ybq+xeBv6p+RncGPgL8l6NS0rYZpqSBkdUJzB8BvgXcT2PU4p3bXKtn84EvV58SO7ab+R8DptAIEtcAS7pZ5ms0Pvb+KxqHozpf9+gBGocF76MRCv42M++q5p1N44T4myLiceB7VOfr9OAzwAtpjCbdROOj932SmfcCb6YxuvUojZPPJ/ehj5dX9zcCPwY+m5nf72b762kExXnAeuAs4C2Z+UgfW5wDnBcRv6MReL7Zx94XAgdVz99V3Wz3fOBmGiNFt9E4PHx+N8ttb09PA2+ncYL6Y8BJwNur6WTmDTRO1r8GeIjGif3vQtI2xTC5fIo0ZEXEShonC3f3pjkoImINcHJ3n1CLxlW4v5qZE7rOkyQ9nyNTUhNFxME0Lk1wy2D3IklqDsOU1CQR8Skah9HOzsyunxiTJA0THuaTJEkq4MiUJElSAcOUJElSgQG9Avree++dkyZNGsiSkiRJ/bJixYpHMnNcb8sNaJiaNGkSN99880CWlCRJ6peI6NOHhzzMJ0mSVMAwJUmSVMAwJUmSVGBAz5mSNPw888wzrFu3jqeeemqwWxk0I0aMYMKECey8886D3YqkQWCYklRk3bp1jBo1ikmTJhERg93OgMtM1q9fz7p162hvbx/sdiQNAg/zSSry1FNPMXbs2B0ySAFEBGPHjt2hR+akHZ1hSlKxHTVIbbGj77+0ozNMSZIkFfCcKUm1Wjl7dq3bm/KVr/S6TERw+umnc8EFFwCwYMECNm7cyPz587e73r333stBBx3E/PnzOeOMM7Z7fUk7HkemJLW8XXfdlSVLlvDII48Ub+v0009n1qxZNXQlaUdhmJLU8tra2ujo6ODCCy983rzFixdzyCGHMHnyZI444ohtbueqq66ivb2dgw8+uFmtShqGDFOShoVTTjmFRYsWsWHDhudMP++881i2bBmrVq3i6quv7nH9jRs38qlPfYqPfvSjzW5V0jBjmJI0LIwePZrjjz+eiy666DnTDz/8cE444QQuu+wynn322R7Xnz9/PqeddhojR45sdquShhlPQB9E7UsX97rM6qOPaXqdOmpIQ8HcuXOZMmUKJ5544tZpl1xyCcuXL+eaa67hsMMOY8WKFYwdO/Z56y5fvpwrrriCs846i8cee4wXvOAFjBgxglNPPXUgd0Ea9ubMmdPrMtfOmt7rMkPpvcswJWnYGDNmDMceeywLFy7kpJNOAuCee+5h2rRpTJs2jWuvvZa1a9d2G6Z++MMfbr09f/58Ro4caZCS1CeGKUm16sulDJpp3rx5XHzxxVvvn3nmmdx9991kJjNmzGDy5MmD2J2k4cgwJanlbdy4cevt8ePHs2nTpq33lyxZst3b68/1qSTtuDwBXZIkqYAjU5J2KMuWLePss89+zrT29nauvPLKQepIUqszTEnaocycOZOZM2cOdhuShhEP80mSJBUwTEmSJBUwTEmSJBUwTEmSJBXwBHRJterLv4rYHp/97Gd7XSYiOP3007ngggsAWLBgARs3btyu60U988wznHzyyaxcuZLNmzdz/PHHc+655/a3bUk7EEemJLW8XXfdlSVLlvDII4/0exuLFy/m97//PbfddhsrVqzgc5/7HGvWrKmvSUnDlmFKUstra2ujo6ODCy+88HnzFi9ezCGHHMLkyZM54ogjetxGRPDEE0+wefNmnnzySXbZZRdGjx7dzLYlDROGKUnDwimnnMKiRYvYsGHDc6afd955LFu2jFWrVnH11Vf3uP473vEOdt99d/bdd18mTpzIGWecwZgxY5rdtqRhwDAlaVgYPXo0xx9/PBdddNFzph9++OGccMIJXHbZZTz77LM9rv+Tn/yEnXbaifvuu4/Vq1dzwQUX8Ktf/arZbUsaBgxTkoaNuXPnsnDhQp544omt0y655BLOP/981q5dy2GHHcb69eu7XfdrX/saRx55JDvvvDP77LMPhx9+ODfffPNAtS6phfUapiLiCxHxUETc3s28eRGREbF3c9qTpL4bM2YMxx57LAsXLtw67Z577mHatGmcd955jBs3jrVr13a77sSJE7nhhhsAeOKJJ7jppps48MADB6RvSa2tL5dG+BJwMfB/Ok+MiP2BvwTurb8tSa2qL5cyaKZ58+Zx8cUXb71/5plncvfdd5OZzJgxg8mTJ3e73imnnMKJJ57IwQcfTGZy4okn8spXvnKg2pbUwnoNU5n5g4iY1M2sC4GzgG/X3JMkbZeNGzduvT1+/Hg2bdq09f6SJUv6tI2RI0eyePHi2nuTNPz165ypiHgb8JvMXFVzP5IkSS1lu6+AHhG7AR+kcYivL8t3AB3QOCehVbQv7f0v1NVHH9PjvD5dBXrW9O1paVDrSMPFsmXLOPvss58zrb29nSuvvHKQOpLU6vrz72ReCrQDqyICYAKwMiJelZkPdF04My8FLgWYOnVqFvQqScVmzpzJzJkzB7sNScPIdoepzLwN2GfL/YhYA0zNzP7/HwdJkqQW1ZdLI1wO/Bg4ICLWRcT7mt+WJElSa+jLp/mO62X+pNq6kSRJajH9OWdKknrUlw9vbI9tfdBDkoYC/52MpJYXEcybN2/r/QULFjB//vzt2sb69euZPn06I0eO5NRTT906fdOmTRx11FEceOCBHHzwwZxzzjl1tS1pmDBMSWp5u+66K0uWLOGRR/r/OZgRI0bw8Y9/nAULFjxv3hlnnMFdd93FLbfcwo9+9COuvfbaknYlDTOGKUktr62tjY6ODi688MLnzVu8eDGHHHIIkydP5ogjjuhxG7vvvjuvfe1rGTFixHOm77bbbkyf3rhW2y677MKUKVNYt25dvTsgqaUZpiQNC6eccgqLFi1iw4YNz5l+3nnnsWzZMlatWsXVV19dVOOxxx5j6dKlzJgxo2g7koYXw5SkYWH06NEcf/zxXHTRRc+Zfvjhh3PCCSdw2WWX8eyzz/Z7+5s3b+a4447j/e9/Py95yUtK25U0jBimJA0bc+fOZeHChTzxxBNbp11yySWcf/75rF27lsMOO4z169f3a9sdHR28/OUvZ+7cuXW1K2mY8NIIkmo1mJcyGDNmDMceeywLFy7kpJNOAuCee+5h2rRpTJs2jWuvvZa1a9cyduzY7druhz/8YTZs2MDnP//5ZrQtqcUZpiQNK/PmzePiiy/eev/MM8/k7rvvJjOZMWMGkydP7nHdSZMm8fjjj/P0009z1VVXcd111zF69Gg+8YlPcOCBBzJlyhQATj31VE4++eSm74uk1mCYktTyNm7cuPX2+PHj2bRp09b7S5Ys6fN21qxZ0+30TP9Hu6Seec6UJElSAUemJO1Qli1bxtlnn/2cae3t7Vx55ZWD1JGkVmeYklQsM4mIwW6jT2bOnMnMmTNr3aaHAaUdm4f5JBUZMWIE69ev32EDRWayfv365105XdKOw5EpSUUmTJjAunXrePjhhwe7lUEzYsQIJkyYMNhtSBokhilJRXbeeWfa29sHuw1JGjSGKdWifeniXpcpvZjjQNSQJPXM38Pd85wpSZKkAoYpSZKkAoYpSZKkAoYpSZKkAoYpSZKkAoYpSZKkAoYpSZKkAoYpSZKkAoYpSZKkAoYpSZKkAoYpSZKkAoYpSZKkAoYpSZKkAoYpSZKkAoYpSZKkAoYpSZKkAr2GqYj4QkQ8FBG3d5r26Yi4KyJ+FhFXRsSezW1TkiRpaOrLyNSXgCO7TLseOCQzXwn8Aji35r4kSZJaQq9hKjN/ADzaZdp1mbm5unsTMKEJvUmSJA15bTVs4yTgGz3NjIgOoANg4sSJNZSTJElD1crZs7e9wKhRA9PIACo6AT0iPgRsBhb1tExmXpqZUzNz6rhx40rKSZIkDTn9HpmKiBOAtwAzMjNr60iSJKmF9CtMRcSRwFnA6zNzU70tSZIktY6+XBrhcuDHwAERsS4i3gdcDIwCro+IWyPikib3KUmSNCT1OjKVmcd1M3lhE3qRJElqOV4BXZIkqYBhSpIkqYBhSpIkqYBhSpIkqYBhSpIkqYBhSpIkqYBhSpIkqYBhSpIkqYBhSpIkqYBhSpIkqYBhSpIkqYBhSpIkqYBhSpIkqYBhSpIkqYBhSpIkqUDbYDcgDTXtSxdvc/7qo49peo266kjS9pgzZ862F5g1fWAaaTGOTEmSJBUwTEmSJBUwTEmSJBUwTEmSJBUwTEmSJBUwTEmSJBUwTEmSJBUwTEmSJBUwTEmSJBUwTEmSJBUwTEmSJBUwTEmSJBUwTEmSJBUwTEmSJBUwTEmSJBUwTEmSJBXoNUxFxBci4qGIuL3TtDERcX1E3F1936u5bUqSJA1NfRmZ+hJwZJdp5wD/kZkvB/6jui9JkrTD6TVMZeYPgEe7TH4b8OXq9peBt9fclyRJUkvo7zlT4zPz/ur2A8D4mvqRJElqKW2lG8jMjIjsaX5EdAAdABMnTiwtV4s5c+b0vtCs6c1vpEX4eLWm9qWLe11m9dHHDEAnkgaCr/nB09+RqQcjYl+A6vtDPS2YmZdm5tTMnDpu3Lh+lpMkSRqa+humrgbeW91+L/DtetqRJElqLX25NMLlwI+BAyJiXUS8D/gk8BcRcTfwpuq+JEnSDqfXc6Yy87geZs2ouRdJkqSW4xXQJUmSChimJEmSChimJEmSChimJEmSChimJEmSChimJEmSChimJEmSChimJEmSChimJEmSChimJEmSChimJEmSChimJEmSChimJEmSChimJEmSChimJEmSCrQNdgOtbOXs2T3PHDWq+TVqrLOjmDNnTu8LzZre/Ea0XdqXLu51mdVHHzMAnUjS8zkyJUmSVMAwJUmSVMAwJUmSVMAwJUmSVMAwJUmSVMAwJUmSVMAwJUmSVMAwJUmSVMAwJUmSVMAwJUmSVMAwJUmSVMAwJUmSVMAwJUmSVMAwJUmSVMAwJUmSVMAwJUmSVMAwJUmSVKAoTEXEaRFxR0TcHhGXR8SIuhqTJElqBf0OUxGxH/B+YGpmHgLsBLyzrsYkSZJaQelhvjbghRHRBuwG3FfekiRJUuto6++KmfmbiFgA3As8CVyXmdd1XS4iOoAOgIkTJ/a3nCRJTdG+dPE2568++pgB6kStquQw317A24B24EXA7hHxnq7LZealmTk1M6eOGzeu/51KkiQNQSWH+d4ErM7MhzPzGWAJ8Jp62pIkSWoNJWHqXuDVEbFbRAQwA7iznrYkSZJaQ7/DVGYuB64AVgK3Vdu6tKa+JEmSWkK/T0AHyMyPAh+tqRdJkqSW4xXQJUmSChimJEmSChimJEmSChimJEmSChimJEmSChimJEmSChimJEmSChimJEmSChimJEmSChimJEmSChimJEmSChimJEmSChimJEmSChimJEmSChimJEmSCrQNdgMSwJw5c3pfaNb05jciSU3QvnRxr8usPvqYHuf5O3Joc2RKkiSpgGFKkiSpgGFKkiSpgGFKkiSpgGFKkiSpgGFKkiSpgGFKkiSpgGFKkiSpgGFKkiSpgGFKkiSpgGFKkiSpgGFKkiSpgGFKkiSpgGFKkiSpgGFKkiSpgGFKkiSpQFGYiog9I+KKiLgrIu6MiD+vqzFJkqRW0Fa4/r8A/56Z74iIXYDdauhJkiSpZfQ7TEXEHsARwAkAmfk08HQ9bUmSJLWGksN87cDDwBcj4paI+HxE7F5TX5IkSS2h5DBfGzAF+PvMXB4R/wKcA3yk80IR0QF0AEycOLGgnCRJKrFy9uxtLzBq1MA0MsyUjEytA9Zl5vLq/hU0wtVzZOalmTk1M6eOGzeuoJwkSdLQ0+8wlZkPAGsj4oBq0gzg57V0JUmS1CJKP83398Ci6pN8vwJOLG9JkiSpdRSFqcy8FZhaUy+SJEktxyugS5IkFTBMSZIkFTBMSZIkFTBMSZIkFTBMSZIkFTBMSZIkFTBMSZIkFTBMSZIkFTBMSZIkFTBMSZIkFTBMSZIkFTBMSZIkFTBMSZIkFTBMSZIkFTBMSZIkFWgb7AYkta72pYt7XWb10ccMQCdS9+bMmdP7QrOmD/kaGtocmZIkSSpgmJIkSSpgmJIkSSpgmJIkSSpgmJIkSSpgmJIkSSpgmJIkSSpgmJIkSSpgmJIkSSpgmJIkSSpgmJIkSSpgmJIkSSpgmJIkSSpgmJIkSSpgmJIkSSpgmJIkSSpgmJIkSSpQHKYiYqeIuCUivlNHQ5IkSa2kjpGpDwB31rAdSZKkllMUpiJiAnAU8Pl62pEkSWotbYXrfwY4CxjV0wIR0QF0AEycOLGwXO9Wzp7d+0Kjemx3h9TrY+bjJdWifeniXpdZffQxA9CJtoe/I9Wbfo9MRcRbgIcyc8W2lsvMSzNzamZOHTduXH/LSZIkDUklh/kOB94aEWuArwNvjIiv1tKVJElSi+h3mMrMczNzQmZOAt4J3JCZ76mtM0mSpBbgdaYkSZIKlJ6ADkBm3gjcWMe2JEmSWokjU5IkSQUMU5IkSQUMU5IkSQUMU5IkSQUMU5IkSQUMU5IkSQUMU5IkSQUMU5IkSQUMU5IkSQUMU5IkSQUMU5IkSQUMU5IkSQUMU5IkSQUMU5IkSQUMU5IkSQXaBrsB7ThWzp7d88xRowaukSabM2dO7wvNmj7kawyU4bQvqlf70sW9LrP66GMGoBNp2xyZkiRJKmCYkiRJKmCYkiRJKmCYkiRJKmCYkiRJKmCYkiRJKmCYkiRJKmCYkiRJKmCYkiRJKmCYkiRJKmCYkiRJKmCYkiRJKmCYkiRJKmCYkiRJKmCYkiRJKmCYkiRJKtDvMBUR+0fE9yPi5xFxR0R8oM7GJEmSWkFbwbqbgXmZuTIiRgErIuL6zPx5Tb1JkiQNef0emcrM+zNzZXX7d8CdwH51NSZJktQKSkamtoqIScCfAcu7mdcBdABMnDixjnJSj1bOnr3tBUaNGphGarDNfRmg/ZgzZ862F5g1vddttMpz0r50ca/LrD76mAHopDX4eNVvKLzm1T/FJ6BHxEjgW8DczHy86/zMvDQzp2bm1HHjxpWWkyRJGlKKwlRE7EwjSC3KzCX1tCRJktQ6Sj7NF8BC4M7M/Of6WpIkSWodJSNThwOzgTdGxK3V15tr6kuSJKkl9PsE9Mz8LyBq7EWSJKnleAV0SZKkAoYpSZKkAoYpSZKkAoYpSZKkAoYpSZKkAoYpSZKkAoYpSZKkAoYpSZKkAoYpSZKkAoYpSZKkAoYpSZKkAoYpSZKkAoYpSZKkAoYpSZKkAoYpSZKkAm2D3YAkDQdz5szpfaFZ05vfSIuo6/FaOXv2thcYNaqPHUn958iUJElSAcOUJElSAcOUJElSAcOUJElSAcOUJElSAcOUJElSAcOUJElSAcOUJElSAcOUJElSAcOUJElSAcOUJElSAcOUJElSAcOUJElSAcOUJElSAcOUJElSAcOUJElSgaIwFRFHRsT/i4hfRsQ5dTUlSZLUKvodpiJiJ+BfgVnAQcBxEXFQXY1JkiS1gpKRqVcBv8zMX2Xm08DXgbfV05YkSVJrKAlT+wFrO91fV02TJEnaYURm9m/FiHcAR2bmydX92cC0zDy1y3IdQEd19wDg//W/3drsDTwyDGoMVJ3hUmOg6gyXGgNVxxpDr85wqTFQdYZLjYGqM1D7UocXZ+a43hZqKyjwG2D/TvcnVNOeIzMvBS4tqFO7iLg5M6e2eo2BqjNcagxUneFSY6DqWGPo1RkuNQaqznCpMVB1BmpfBlLJYb6fAi+PiPaI2AV4J3B1PW1JkiS1hn6PTGXm5og4FVgG7AR8ITPvqK0zSZKkFlBymI/M/C7w3Zp6GUgDcdhxoA5tDpd98fEaejUGqo41hl6d4VJjoOoMlxoDVWdInfpTh36fgC5JkiT/nYwkSVKRHSpMRcQXIuKhiLi9iTX2j4jvR8TPI+KOiPhAE2qMiIifRMSqqsbH6q7RqdZOEXFLRHyniTXWRMRtEXFrRNzcpBp7RsQVEXFXRNwZEX/ehBoHVPuw5evxiJjbhDqnVc/77RFxeUSMaEKND1Tbv6POfejuNRgRYyLi+oi4u/q+VxNqHFPtyx8iovhTRD3U+HT18/WziLgyIvZsUp2PVzVujYjrIuJFddfoNG9eRGRE7F13jYiYHxG/6fR6eXPdNarpf189L3dExD+V1OipTkR8o9N+rImIW5tQ49CIuGnL78mIeFUTakyOiB9Xv4+XRsTowhrdvh/W/ZofEjJzh/kCjgCmALc3sca+wJTq9ijgF8BBNdcIYGR1e2dgOfDqJu3P6cDXgO808TFbA+zd5Of+y8DJ1e1dgD2bXG8n4AEa1yipc7v7AauBF1b3vwmcUHONQ4Dbgd1onFf5PeBlNW37ea9B4J+Ac6rb5wCfakKNP6VxnbsbgalN2o+/BNqq258q3Y9t1Bnd6fb7gUvqrlFN35/GB4x+Xfr67GE/5gNn1PFztY0a06uf312r+/s0o06X+RcA/9CEfbkOmFXdfjNwYxNq/BR4fXX7JODjhTW6fT+s+zU/FL52qJGpzPwB8GiTa9yfmSur278D7qTmK8Nnw8bq7s7VV+0nv0XEBOAo4PN1b3sgRcQeNH5xLATIzKcz87Eml50B3JOZv27CttuAF0ZEG43Ac1/N2/9TYHlmbsrMzcB/An9dx4Z7eA2+jUbYpfr+9rprZOadmVnbBYN7qHFd9XgB3ETj2nvNqPN4p7u7U/ja38bvxQvk5zuMAAAEyElEQVSBs0q330uN2vRQ4++AT2bm76tlHmpSHQAiIoBjgcubUCOBLSNFe1D4uu+hxiuAH1S3rwf+R2GNnt4Pa33NDwU7VJgaaBExCfgzGiNHdW97p2oo+SHg+sysvQbwGRq/TP/QhG13lsB1EbEiGlfMr1s78DDwxeqQ5ecjYvcm1OnsnRT+Qu1OZv4GWADcC9wPbMjM62ouczvwuogYGxG70fgreP9e1ikxPjPvr24/AIxvYq2BchJwbbM2HhGfiIi1wLuBf2jC9t8G/CYzV9W97S5OrQ5ZfqFJh3peQeNneXlE/GdE/Pcm1OjsdcCDmXl3E7Y9F/h09bwvAM5tQo07+OP/2D2GGl/3Xd4Ph91r3jDVJBExEvgWMLfLX5K1yMxnM/NQGn/9vioiDqlz+xHxFuChzFxR53Z78NrMnALMAk6JiCNq3n4bjeHsf8vMPwOeoDG03BTRuIjtW4HFTdj2XjR+2bUDLwJ2j4j31FkjM++kcZjqOuDfgVuBZ+ussY3aSRNGWQdSRHwI2AwsalaNzPxQZu5f1Ti1t+W3RxWgP0gTQloX/wa8FDiUxh8GFzShRhswBng1cCbwzWr0qFmOowl/RFX+Djitet5Poxppr9lJwJyIWEHjsNzTdWx0W++Hw+E1D4appoiInWn84CzKzCXNrFUdrvo+cGTNmz4ceGtErAG+DrwxIr5acw1g62jLliH4K4GiEyu7sQ5Y12n07goa4apZZgErM/PBJmz7TcDqzHw4M58BlgCvqbtIZi7MzMMy8wjgtzTOdWiWByNiX4Dqe/GhmMESEScAbwHeXb1JNNsiCg/FdOOlNML6qur1PwFYGRF/UmeRzHyw+qPwD8Bl1P+6h8Zrf0l1asRPaIyyF51M35PqsPtfA99oxvaB99J4vUPjD7XaH6/MvCsz/zIzD6MRCu8p3WYP74fD5jW/hWGqZtVfPQuBOzPzn5tUY9yWTwpFxAuBvwDuqrNGZp6bmRMycxKNQ1Y3ZGatIyAAEbF7RIzacpvGSby1ftoyMx8A1kbEAdWkGcDP66zRRTP/Or0XeHVE7Fb9rM2gcR5CrSJin+r7RBpvEF+ru0YnV9N4o6D6/u0m1mqaiDiSxmHxt2bmpibWeXmnu2+j/tf+bZm5T2ZOql7/62icRPxAnXW2vJlW/oqaX/eVq2ichE5EvILGh0+a9Q923wTclZnrmrT9+4DXV7ffCNR+KLHT6/4FwIeBSwq319P74bB4zT/HYJ8BP5BfNN7g7geeofEL4n1NqPFaGkOWP6NxeORW4M0113glcEtV43YKPznSh3pvoEmf5gNeAqyqvu4APtSkOocCN1eP2VXAXk2qszuwHtijic/Hx2i8gd4OfIXqk0o11/ghjcC5CphR43af9xoExgL/QePN4XvAmCbU+Kvq9u+BB4FlTajxS2Btp9d90afstlHnW9Vz/zNgKbBf3TW6zF9D+af5utuPrwC3VftxNbBvE2rsAny1erxWAm9sxnNSTf8S8LdNfJ28FlhRvSaXA4c1ocYHaIxC/wL4JNWFvQtqdPt+WPdrfih8eQV0SZKkAh7mkyRJKmCYkiRJKmCYkiRJKmCYkiRJKmCYkiRJKmCYkiRJKmCYkiRJKmCYkiRJKvD/AV6PXMAPuiKrAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "([4, 9, 9, 4, 3, 2, 0, 2, 0, 2, 0, 0, 0, 0, 0, 1, 4, 2, 6, 12],\n",
       " [10, 14, 14, 10, 7, 9, 3, 3, 2, 3, 0, 1, 0, 0, 1, 5, 5, 7, 11, 15],\n",
       " [14, 15, 15, 13, 13, 11, 11, 10, 5, 9, 2, 4, 0, 2, 3, 8, 7, 10, 13, 15])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot_histograms('a06')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "([0, 4, 3, 5, 1, 7, 3, 1, 2, 3, 0, 2, 1, 4, 4, 2, 3, 2, 1, 8],\n",
       " [1, 6, 5, 7, 3, 10, 7, 6, 5, 3, 3, 3, 5, 8, 5, 7, 9, 5, 2, 12],\n",
       " [4, 9, 8, 9, 11, 11, 12, 9, 6, 5, 4, 6, 8, 11, 7, 10, 11, 10, 5, 12])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot_histograms('a14')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "([0, 1, 0, 0, 3, 9, 10, 10, 8, 3, 0, 0, 1, 0, 0, 1, 1, 0, 2, 3],\n",
       " [0, 7, 7, 6, 5, 12, 12, 11, 8, 8, 2, 0, 1, 1, 1, 2, 2, 2, 6, 11],\n",
       " [10, 13, 12, 10, 11, 12, 12, 11, 10, 10, 5, 3, 2, 1, 1, 5, 4, 4, 7, 13])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot_histograms('a20')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sort_and_keep_indexes(Ns, numOfJoints):\n",
    "    Ns = sorted(range(len(Ns)), key = Ns.__getitem__)\n",
    "    Ns = Ns[len(Ns)-numOfJoints:]\n",
    "    return Ns\n",
    "\n",
    "def get_idx_mostJoints(action_label):\n",
    "    action = train_as3_mostInformativeJointsList[action_label]\n",
    "    Ns_4 = [0 for i in range(20)]\n",
    "    Ns_8 = [0 for i in range(20)]\n",
    "    Ns_12 = [0 for i in range(20)]\n",
    "\n",
    "    for i in range(len(action)):\n",
    "        for j in range(0, 20):\n",
    "            if action[i][j] > 15 :\n",
    "                Ns_4[j] += 1\n",
    "            if action[i][j] > 11:\n",
    "                Ns_8[j] += 1\n",
    "            if action[i][j] > 7:\n",
    "                Ns_12[j] += 1\n",
    "    Ns_4 = np.asarray(sort_and_keep_indexes(Ns_4, 4))\n",
    "    Ns_8 = np.asarray(sort_and_keep_indexes(Ns_8, 8))\n",
    "    Ns_12 = np.asarray(sort_and_keep_indexes(Ns_12, 12))\n",
    "    return Ns_4, Ns_8, Ns_12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "action_label_list = ['a06', 'a14', 'a15', 'a16', 'a17', 'a18', 'a19', 'a20']\n",
    "Ns4_as3_list = np.zeros((len(action_label_list), 4), dtype=np.int)\n",
    "for i in range(Ns4_as3_list.shape[0]):\n",
    "    Ns_4, _, _ = get_idx_mostJoints(action_label_list[i])\n",
    "    Ns4_as3_list[i] = Ns_4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[17  0  1 18]\n",
      " [13  2  4 18]\n",
      " [13 14  2 18]\n",
      " [-1  1 18  0]\n",
      " [ 0 17  1 18]\n",
      " [17  2  0 18]\n",
      " [14 11 17 18]\n",
      " [ 7  4  5  6]]\n"
     ]
    }
   ],
   "source": [
    "Ns4_as3_list = Ns4_as3_list-1\n",
    "print(Ns4_as3_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run from here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "Ns4_as3_list = np.array([[9,11,13,2], [17,19,15,12],[17,19,13,15],[12,13,10,11],\n",
    " [11,13,9,8], [11,12,13,10], [10,12,13,11], [11,13,9,12]])\n",
    "Ns4_as3_list = Ns4_as3_list-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def reshape_skeleton(X):\n",
    "    noFrames = int(X.shape[0]/setting.NUMBER_OF_JOINTS)\n",
    "    reshaped_X = []\n",
    "    for i in range(setting.NUMBER_OF_JOINTS):\n",
    "        reshaped_X.append([X[j] for j in range(i, X.shape[0], 20)])\n",
    "    reshaped_X = np.asarray(reshaped_X)\n",
    "    return reshaped_X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_MIJ_matrices(filename):\n",
    "    \n",
    "    action_label = int(filename[1:3])\n",
    "    \n",
    "    with open('data/' + filename, 'r') as f:\n",
    "        skeleton_matrix = [line.rstrip('\\n') for line in f]\n",
    "    for j in range(len(skeleton_matrix)):\n",
    "        skeleton_matrix[j] = [float(coord) for coord in skeleton_matrix[j].split(' ')]\n",
    "    \n",
    "    skeleton_matrix = np.asarray(skeleton_matrix)\n",
    "    noFrames = int(skeleton_matrix.shape[0]/setting.NUMBER_OF_JOINTS)\n",
    "    x = skeleton_matrix[:,0]\n",
    "    y = skeleton_matrix[:,1]\n",
    "    z = skeleton_matrix[:,2]\n",
    "    \n",
    "    x = reshape_skeleton(x)\n",
    "    y = reshape_skeleton(y)\n",
    "    z = reshape_skeleton(z)\n",
    "    t = np.arange(1, noFrames+1).T\n",
    "    if action_label == 6:\n",
    "        x = x[Ns4_as3_list[0]]\n",
    "        y = y[Ns4_as3_list[0]]\n",
    "        z = z[Ns4_as3_list[0]]\n",
    "    else:\n",
    "        x = x[Ns4_as3_list[action_label-13]]\n",
    "        y = y[Ns4_as3_list[action_label-13]]\n",
    "        z = z[Ns4_as3_list[action_label-13]]\n",
    "    return x,y,z,t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculateCovarianceMat(X, Y, Z, T, nLevels, overlap = False, timeVar=True):\n",
    "    nFrames = X.shape[0]\n",
    "    nJoins = X.shape[1]\n",
    "    assert Y.shape[0] == nFrames\n",
    "    assert Z.shape[0] == nFrames\n",
    "    assert T.shape[0] == nFrames\n",
    "    assert Y.shape[1] == nJoins\n",
    "    assert Z.shape[1] == nJoins\n",
    "\n",
    "    # Normalize skeleton coordinators\n",
    "\n",
    "    normX = normCord(X)\n",
    "    normY = normCord(Y)\n",
    "    normZ = normCord(Z)\n",
    "    normT = normSeT(T)\n",
    "\n",
    "    # Create a list of full covariance matrices\n",
    "    fullCovMats = [[] for i in range(nLevels)]\n",
    "    covMats = [[] for i in range(nLevels)]\n",
    "\n",
    "    if timeVar:\n",
    "        sizeMatrix = nJoins*3+1\n",
    "    else:\n",
    "        sizeMatrix = nJoins*3\n",
    "\n",
    "    listIdxMatrix = getValueMatrix(sizeMatrix) # get half of covariance matrix indexes\n",
    "\n",
    "\n",
    "    for l in range(1,nLevels+1):\n",
    "        # Compute covariance matrixes for each level\n",
    "        nofMats = 2**(l-1)\n",
    "        sizeWindow = 1/nofMats\n",
    "        stepWindow = sizeWindow\n",
    "        if overlap:\n",
    "            stepWindow = stepWindow/2\n",
    "            nofMats = nofMats*2-1\n",
    "        startFrameTimes = [stepWindow*i for i in range(nofMats)]\n",
    "        fullCovMats[l-1] = [[] for i in range(nofMats)]\n",
    "        covMats[l-1] = [[] for i in range(nofMats)]\n",
    "        for i in range(len(startFrameTimes)):\n",
    "            startTime = startFrameTimes[i]\n",
    "            endTime = startFrameTimes[i] + sizeWindow + 2*np.finfo(float).eps\n",
    "            sliceInds = [j for j in range(T.shape[0]) if normT[j] >= startTime and normT[j] < endTime]\n",
    "            sliceX = normX[sliceInds, :]\n",
    "            sliceY = normY[sliceInds, :]\n",
    "            sliceZ = normZ[sliceInds, :]\n",
    "            sliceT = normT[sliceInds]\n",
    "            if not timeVar:\n",
    "                sliceVars = np.concatenate((np.concatenate((sliceX,sliceY), axis=1), sliceZ), axis=1)\n",
    "            else:\n",
    "                sliceVars = np.concatenate((np.concatenate((sliceX, sliceY), axis=1), np.concatenate((sliceZ, sliceT), axis=1)), axis=1)\n",
    "            covarianceMat = np.cov(sliceVars.T)\n",
    "            fullCovMats[l-1][i] = covarianceMat\n",
    "            # Get half of covarianceMat and save it as a vector (1-D matrix)\n",
    "            one_half_vector = []\n",
    "            mask = np.zeros_like(covarianceMat, dtype=np.bool)\n",
    "            mask[np.triu_indices_from(mask)] = True\n",
    "            for row in range(covarianceMat.shape[0]):\n",
    "                for column in range(covarianceMat.shape[0]):\n",
    "                    if mask[row][column] == True:\n",
    "                        one_half_vector.append(covarianceMat[row][column])\n",
    "            covMats[l-1][i] = np.asarray(one_half_vector)\n",
    "        covMats[l-1] = np.asarray(covMats[l-1])\n",
    "        \n",
    "    covMats = np.asarray(covMats)\n",
    "    vec = np.empty(0)\n",
    "    for i in range(covMats.shape[0]):\n",
    "        for j in range(covMats[i].shape[0]):\n",
    "            vec = np.hstack((vec, covMats[i][j]))\n",
    "    return fullCovMats, vec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_covariance_vector(x,y,z,t):\n",
    "    fullCovmat, vec_covMat = calculateCovarianceMat(x.T, y.T, z.T, t, nLevels=3, overlap=True, timeVar=False)\n",
    "    return vec_covMat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_preprocessed_training_data(filenames):\n",
    "    X_train, y_train = [], []\n",
    "    for i in range(len(filenames)):\n",
    "        x, y, z, t = get_MIJ_matrices(filenames[i])\n",
    "        vec_covMat = get_covariance_vector(x,y,z,t)\n",
    "        label = int(filenames[i][1:3])\n",
    "        X_train.append(vec_covMat)\n",
    "        y_train.append(label)\n",
    "    X_train = np.asarray(X_train)\n",
    "    y_train = np.asarray(y_train)\n",
    "    return X_train, y_train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, y_train = make_preprocessed_training_data(train_as3_names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.svm import SVC\n",
    "model = OneVsRestClassifier(LinearSVC(random_state=0)).fit(X_train, y_train)\n",
    "mode_name = 'as3_svm_model.pkl'\n",
    "with open(mode_name, 'wb') as f:\n",
    "    pickle.dump(model, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_test, y_test = make_preprocessed_training_data(test_as3_names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_hat = model.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "99.04761904761905\n"
     ]
    }
   ],
   "source": [
    "def get_acc(y_test, y_hat):\n",
    "    count = 0\n",
    "    for i in range(y_test.shape[0]):\n",
    "        if y_test[i] == y_hat[i]:\n",
    "            count += 1\n",
    "    acc = (count/y_test.shape[0])*100\n",
    "    return acc\n",
    "print(get_acc(y_test, y_hat))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import f1_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9904761904761905"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f1_score(y_test, y_hat, average='micro')  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train[0].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Gán nhãn thủ công\n",
    "Đánh giá chất lượng phân đoạn\n"
   ]
  }
 ],
 "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.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}