1252 lines (1251 with data), 276.8 kB

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Imports the required libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "\"\"\" Imports the required libraries \"\"\"\n",
    "\n",
    "# import tensorflow as tf\n",
    "import keras\n",
    "from keras.models import Sequential\n",
    "from keras.optimizers import Adam\n",
    "from keras.layers import Dense,  Activation, Conv2D, MaxPool2D, MaxPooling2D\n",
    "from keras.layers import Flatten, Dropout, BatchNormalization, Reshape\n",
    "from keras.utils.vis_utils import plot_model\n",
    "\n",
    "import os\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import scipy.stats as stats\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn import preprocessing\n",
    "from sklearn.model_selection import train_test_split, cross_val_score, KFold\n",
    "from sklearn.preprocessing import StandardScaler, LabelEncoder\n",
    "from mlxtend.plotting import plot_confusion_matrix\n",
    "from sklearn.metrics import confusion_matrix, classification_report\n",
    "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Stores the path of the sensor files in the corresponding list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" Stores the path of the sensor files in the corresponding list \"\"\"\n",
    "\n",
    "base_path = \"./data/raw_data/\"\n",
    "phone_accel_file_paths = []\n",
    "phone_gyro_file_paths = []\n",
    "watch_accel_file_paths = []\n",
    "watch_gyro_file_paths = []\n",
    "\n",
    "for directories, subdirectories, files in os.walk(base_path):\n",
    "    for filename in files:\n",
    "        if \"phone\" in filename and \"accel\" in filename:\n",
    "            phone_accel_file_paths.append(f\"{base_path}phone/accel/{filename}\")\n",
    "        elif \"phone\" in filename and \"gyro\" in filename:\n",
    "            phone_gyro_file_paths.append(f\"{base_path}phone/gyro/{filename}\")\n",
    "        elif \"watch\" in filename and \"accel\" in filename:\n",
    "            watch_accel_file_paths.append(f\"{base_path}watch/accel/{filename}\")\n",
    "        elif \"watch\" in filename and \"gyro\" in filename:\n",
    "            watch_gyro_file_paths.append(f\"{base_path}watch/gyro/{filename}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Stores the actual name of each activity in the dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" Stores the actual name of each activity in the dictionary \"\"\"\n",
    "\n",
    "activity_dict= {\"A\":\"Walking\",\n",
    "                \"B\":\"Jogging\",\n",
    "                \"C\":\"Stairs\",\n",
    "                \"D\":\"Sitting\",\n",
    "                \"E\":\"Standing\",\n",
    "                \"F\":\"Typing\",\n",
    "                \"G\":\"Brushing\",\n",
    "                \"H\":\"Eat Soup\",\n",
    "                \"I\":\"Eat Chips\",\n",
    "                \"J\":\"Eat Pasta\",\n",
    "                \"K\":\"Drinking\",\n",
    "                \"L\":\"Eat Sandwich\",\n",
    "                \"M\":\"Kicking\",\n",
    "                \"O\":\"Playing\",\n",
    "                \"P\":\"Dribblinlg\",\n",
    "                \"Q\":\"Writing\",\n",
    "                \"R\":\"Clapping\",\n",
    "                \"S\":\"Folding\"}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Removes the columns \"SubjectID\" and \"Timestamp\" from the dataframe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def clean_data(dataframe):\n",
    "    \"\"\" Removes the columns \"SubjectID\" and \"Timestamp\" from the dataframe \"\"\"\n",
    "\n",
    "    cleaned_df = dataframe.drop([\"SubjectID\", \"Timestamp\"], axis = 1).copy()\n",
    "\n",
    "    return cleaned_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Normalizes the data using StandardScaler() function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def scale_data(data):\n",
    "    \"\"\" Normalizes the data using StandardScaler() function \"\"\"\n",
    "    \n",
    "    le = LabelEncoder()\n",
    "    data['ActivityCode'] = le.fit_transform(data['ActivityCode'])\n",
    "    \n",
    "    X = data[['X', 'Y', 'Z']]\n",
    "    y = data['ActivityCode']\n",
    "    \n",
    "    scaler = StandardScaler()\n",
    "    X = scaler.fit_transform(X)\n",
    "    \n",
    "    scaled_df = pd.DataFrame(data = X, columns = ['X', 'Y', 'Z'])\n",
    "    scaled_df['ActivityCode'] = y.values\n",
    "    \n",
    "    return scaled_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Decodes the activity labels and stores them in a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def activity_dictionary(dataframe):    \n",
    "    \"\"\" Decodes the activity labels and stores them in the dictionary \"\"\"\n",
    "\n",
    "    activity_labels = dataframe[\"ActivityCode\"]\n",
    "    le = LabelEncoder()\n",
    "    activity_indices = le.fit_transform(activity_labels)\n",
    "    mapped_labels = dict(zip(le.transform(le.classes_), le.classes_))\n",
    "    \n",
    "    return mapped_labels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Preprocesses the data using clean() and scale() functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def preprocess_data(dataframe):    \n",
    "    \"\"\" Preprocesses the data using clean() and scale() functions \"\"\"\n",
    "\n",
    "    cleaned_df = clean_data(dataframe)\n",
    "    \n",
    "    return scale_data(cleaned_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Prints the cross validation report"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def crossval_report(accuracy_per_fold, loss_per_fold):\n",
    "    \"\"\" Prints the cross validation report \"\"\"\n",
    "\n",
    "    print('------------------------------------------------------------------------')\n",
    "    print('Score per fold')\n",
    "    for i in range(10):\n",
    "        print('------------------------------------------------------------------------')\n",
    "        print(f'> Fold {i+1} - Loss: {loss_per_fold[i]:.4f} - Accuracy: {accuracy_per_fold[i]:.4f}%')\n",
    "    print('------------------------------------------------------------------------')\n",
    "    print('Average scores for all folds:')\n",
    "    print(f'> Accuracy: {np.mean(accuracy_per_fold):.4f} (+- {np.std(accuracy_per_fold):.4f})')\n",
    "    print(f'> Loss: {np.mean(loss_per_fold):.4f}')\n",
    "    print('------------------------------------------------------------------------')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Plots training & validation accuracy values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_learningCurve(history, epochs):\n",
    "    \"\"\" Plots training & validation accuracy values \"\"\"\n",
    "\n",
    "    epoch_range = range(1, epochs+1)\n",
    "    plt.plot(epoch_range, history.history['accuracy'])\n",
    "    plt.plot(epoch_range, history.history[\"val_accuracy\"])\n",
    "    plt.title('Model accuracy')\n",
    "    plt.ylabel('Accuracy')\n",
    "    plt.xlabel('Epoch')\n",
    "    plt.legend(['Train', 'Val'], loc='lower right')\n",
    "    plt.show()\n",
    "    \n",
    "    \"\"\" Plots training & validation loss values \"\"\"\n",
    "    \n",
    "    plt.plot(epoch_range, history.history['loss'])\n",
    "    plt.plot(epoch_range, history.history['val_loss'])\n",
    "    plt.title('Model loss')\n",
    "    plt.ylabel('Loss')\n",
    "    plt.xlabel('Epoch')\n",
    "    plt.legend(['Train', 'Val'], loc='upper right')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Divides data into 2D frames\n",
    "###### To write this code cell, we used part of this tutorial: https://www.youtube.com/watch?v=lUI6VMj43PE&t=2112s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" Divides data into 2D frames \"\"\"\n",
    "\n",
    "frequency = 20 # Based on Hertz\n",
    "time_period = 10 # Based on Second\n",
    "frame_size = frequency * time_period\n",
    "step_size = frame_size # In order not to have an overlap\n",
    "\n",
    "def get_frames(df, frame_size, step_size):\n",
    "    n_features = 3\n",
    "    frames = []\n",
    "    labels = []\n",
    "    for i in range(0, len(df) - frame_size, step_size):\n",
    "        x = df['X'].values[i: i + frame_size]\n",
    "        y = df['Y'].values[i: i + frame_size]\n",
    "        z = df['Z'].values[i: i + frame_size]\n",
    "        \n",
    "        label = stats.mode(df['ActivityCode'][i: i + frame_size])[0][0]\n",
    "        frames.append([x, y, z])\n",
    "        labels.append(label)\n",
    "\n",
    "    frames = np.asarray(frames).reshape(-1, frame_size, n_features)\n",
    "    labels = np.asarray(labels)\n",
    "\n",
    "    return frames, labels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Builds the model (the Convolutional Neural Network)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_model():\n",
    "    \"\"\" Builds the model (the Convolutional Neural Network) \"\"\"\n",
    "    \n",
    "    # Defines model\n",
    "    model = Sequential()\n",
    "    model.add(Conv2D(64, (2, 2), activation = 'relu', input_shape = inputs[0].shape))\n",
    "#     model.add(Dropout(0.1))\n",
    "#     model.add(Conv2D(64, (2, 2), activation='relu'))\n",
    "#     model.add(Dropout(0.2))\n",
    "    model.add(MaxPooling2D(pool_size=2))\n",
    "    model.add(Flatten())\n",
    "    model.add(Dense(128, activation = 'relu'))\n",
    "    model.add(Dense(128, activation = 'relu'))\n",
    "    model.add(Dropout(0.5))\n",
    "    model.add(Dense(18, activation='softmax'))\n",
    "\n",
    "    # Compiles model\n",
    "    model.compile(optimizer=Adam(learning_rate = 0.001), \n",
    "                  loss = 'sparse_categorical_crossentropy', \n",
    "                  metrics = ['accuracy'])\n",
    "    \n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Phone Accelerometer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" Phone Accelerometer \"\"\"\n",
    "\n",
    "num_folds = 10\n",
    "kfold = KFold(n_splits=num_folds, shuffle=True)\n",
    "\n",
    "phone_accel_accuracy_per_fold = {}\n",
    "phone_accel_loss_per_fold = {}\n",
    "\n",
    "phone_accel_accuracy = {}\n",
    "phone_accel_precision = {}\n",
    "phone_accel_recall = {}\n",
    "phone_accel_f1 = {}\n",
    "\n",
    "phone_accel_matrix = {}\n",
    "phone_accel_activity_accuracy = {}\n",
    "phone_accel_classification_reports={}\n",
    "\n",
    "fold_number = 1\n",
    "\n",
    "for subjectid, file in enumerate(phone_accel_file_paths[:]):\n",
    "    subjectid = file.split(\"_\")[1]\n",
    "\n",
    "    data = pd.read_csv(file, verbose=False)\n",
    "\n",
    "    activity_labels = list(activity_dictionary(data).values())\n",
    "\n",
    "    processed_data = preprocess_data(data)\n",
    "\n",
    "    X, y = get_frames(processed_data, frame_size, step_size)\n",
    "\n",
    "    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, stratify = y)\n",
    "\n",
    "    # Makes the input data form 4-Dimensional\n",
    "    X_train = X_train.reshape(X_train.shape[0], X_train.shape[1], 3, 1)\n",
    "    X_test = X_test.reshape(X_test.shape[0], X_test.shape[1], 3, 1)\n",
    "\n",
    "    inputs = np.concatenate((X_train, X_test), axis=0)\n",
    "    targets = np.concatenate((y_train, y_test), axis=0)\n",
    "\n",
    "    acc_per_fold = []\n",
    "    loss_per_fold = []    \n",
    "    print(\"#########################################################################################\")\n",
    "    print(subjectid)\n",
    "    fold_no = 1\n",
    "    for train, test in kfold.split(inputs, targets):\n",
    "        model = get_model()\n",
    "\n",
    "        history = model.fit(inputs[train], targets[train], batch_size=128, epochs=70, validation_split=0.2, verbose=1)\n",
    "\n",
    "        print('------------------------------------------------------------------------')\n",
    "        print(f'Training for fold {fold_no} ...')\n",
    "\n",
    "        scores = model.evaluate(inputs[train], targets[train], verbose=0)\n",
    "\n",
    "        print(f'Score for fold {fold_no}: {model.metrics_names[0]} of {scores[0]}; {model.metrics_names[1]} of {scores[1]*100}%')\n",
    "        acc_per_fold.append(scores[1] * 100)\n",
    "        loss_per_fold.append(scores[0])\n",
    "\n",
    "        # Increases fold number\n",
    "        fold_no = fold_no + 1\n",
    "\n",
    "    phone_accel_accuracy_per_fold[subjectid] = acc_per_fold\n",
    "    phone_accel_loss_per_fold[subjectid] = loss_per_fold\n",
    "\n",
    "    y_true = targets[test]\n",
    "    y_pred = model.predict_classes(inputs[test], verbose=0)\n",
    "\n",
    "    # Accuracy: (tp + tn) / (p + n)\n",
    "    phone_accel_accuracy[subjectid] = accuracy_score(y_true, y_pred)\n",
    "\n",
    "    # Precision tp / (tp + fp)\n",
    "    precision = precision_score(y_true, y_pred, average=None, zero_division=1)\n",
    "    phone_accel_precision[subjectid] = dict(zip(activity_labels, precision))\n",
    "\n",
    "    # Recall: tp / (tp + fn)\n",
    "    recall = recall_score(y_true, y_pred, average=None, zero_division=1)\n",
    "    phone_accel_recall[subjectid] = dict(zip(activity_labels, recall))\n",
    "\n",
    "    # F1: 2 tp / (2 tp + fp + fn)\n",
    "    f1 = f1_score(y_true, y_pred, average=None, zero_division=1)\n",
    "    phone_accel_f1[subjectid] = dict(zip(activity_labels, f1))    \n",
    "    \n",
    "#     phone_accel_classification_reports[subjectid] = classification_report(y_test, y_pred, zero_division=1)\n",
    "    \n",
    "#     matrix = confusion_matrix(y_test, y_pred)\n",
    "#     phone_accel_matrix[subjectid] = matrix\n",
    "    \n",
    "#     accu_per_class = matrix.diagonal()/ matrix.sum(axis=1)\n",
    "#     phone_accel_activity_accuracy[subjectid] = dict(zip(activity_labels, accu_per_class))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### The cross validation report"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "------------------------------------------------------------------------\n",
      "Score per fold\n",
      "------------------------------------------------------------------------\n",
      "> Fold 1 - Loss: 0.2271 - Accuracy: 93.7500%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 2 - Loss: 0.2516 - Accuracy: 95.8477%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 3 - Loss: 0.1782 - Accuracy: 96.1938%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 4 - Loss: 0.1891 - Accuracy: 94.8097%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 5 - Loss: 0.2165 - Accuracy: 95.5017%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 6 - Loss: 0.2196 - Accuracy: 95.1557%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 7 - Loss: 0.2086 - Accuracy: 96.5398%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 8 - Loss: 0.1336 - Accuracy: 96.5398%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 9 - Loss: 0.1705 - Accuracy: 96.8858%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 10 - Loss: 0.1841 - Accuracy: 95.1557%\n",
      "------------------------------------------------------------------------\n",
      "Average scores for all folds:\n",
      "> Accuracy: 95.6380 (+- 0.9094)\n",
      "> Loss: 0.1979\n",
      "------------------------------------------------------------------------\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_learningCurve(history, 70)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### In order to prevent overfitting, we applied dropout (0.5) before the last layer of the network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_learningCurve(history, 70)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Phone Gyroscope"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" Phone Gyroscope \"\"\"\n",
    "\n",
    "num_folds = 10\n",
    "kfold = KFold(n_splits=num_folds, shuffle=True)\n",
    "\n",
    "phone_gyro_accuracy_per_fold = {}\n",
    "phone_gyro_loss_per_fold = {}\n",
    "\n",
    "phone_gyro_accuracy = {}\n",
    "phone_gyro_precision = {}\n",
    "phone_gyro_recall = {}\n",
    "phone_gyro_f1 = {}\n",
    "\n",
    "phone_gyro_matrix = {}\n",
    "phone_gyro_activity_accuracy = {}\n",
    "phone_gyro_classification_reports={}\n",
    "\n",
    "\n",
    "fold_number = 1\n",
    "\n",
    "for subjectid, file in enumerate(phone_gyro_file_paths[:]):\n",
    "    subjectid = file.split(\"_\")[1]\n",
    "\n",
    "    data = pd.read_csv(file, verbose=False)\n",
    "\n",
    "    activity_labels = list(activity_dictionary(data).values())\n",
    "\n",
    "    processed_data = preprocess_data(data)\n",
    "\n",
    "    X, y = get_frames(processed_data, frame_size, step_size)\n",
    "\n",
    "    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, stratify = y)\n",
    "\n",
    "    # Makes the input data form 4-Dimensional\n",
    "    X_train = X_train.reshape(X_train.shape[0], X_train.shape[1], 3, 1)\n",
    "    X_test = X_test.reshape(X_test.shape[0], X_test.shape[1], 3, 1)\n",
    "\n",
    "    inputs = np.concatenate((X_train, X_test), axis=0)\n",
    "    targets = np.concatenate((y_train, y_test), axis=0)\n",
    "\n",
    "    acc_per_fold = []\n",
    "    loss_per_fold = []    \n",
    "    print(\"#########################################################################################\")\n",
    "    print(subjectid)\n",
    "    fold_no = 1\n",
    "    for train, test in kfold.split(inputs, targets):\n",
    "        model = get_model()\n",
    "\n",
    "        history = model.fit(inputs[train], targets[train], batch_size=128, epochs=70, validation_split=0.2, verbose=1)\n",
    "\n",
    "        print('------------------------------------------------------------------------')\n",
    "        print(f'Training for fold {fold_no} ...')\n",
    "\n",
    "        scores = model.evaluate(inputs[train], targets[train], verbose=0)\n",
    "\n",
    "        print(f'Score for fold {fold_no}: {model.metrics_names[0]} of {scores[0]}; {model.metrics_names[1]} of {scores[1]*100}%')\n",
    "        acc_per_fold.append(scores[1] * 100)\n",
    "        loss_per_fold.append(scores[0])\n",
    "\n",
    "        # Increases fold number\n",
    "        fold_no = fold_no + 1\n",
    "\n",
    "    phone_gyro_accuracy_per_fold[subjectid] = acc_per_fold\n",
    "    phone_gyro_loss_per_fold[subjectid] = loss_per_fold\n",
    "\n",
    "    y_true = targets[test]\n",
    "    y_pred = model.predict_classes(inputs[test], verbose=0)\n",
    "\n",
    "    # Accuracy: (tp + tn) / (p + n)\n",
    "    phone_gyro_accuracy[subjectid] = accuracy_score(y_true, y_pred)\n",
    "\n",
    "    # Precision tp / (tp + fp)\n",
    "    precision = precision_score(y_true, y_pred, average=None, zero_division=1)\n",
    "    phone_gyro_precision[subjectid] = dict(zip(activity_labels, precision))\n",
    "\n",
    "    # Recall: tp / (tp + fn)\n",
    "    recall = recall_score(y_true, y_pred, average=None, zero_division=1)\n",
    "    phone_gyro_recall[subjectid] = dict(zip(activity_labels, recall))\n",
    "\n",
    "    # F1: 2 tp / (2 tp + fp + fn)\n",
    "    f1 = f1_score(y_true, y_pred, average=None, zero_division=1)\n",
    "    phone_gyro_f1[subjectid] = dict(zip(activity_labels, f1))    \n",
    "    \n",
    "#     phone_gyro_classification_reports[subjectid] = classification_report(y_test, y_pred, zero_division=1)\n",
    "    \n",
    "#     matrix = confusion_matrix(y_test, y_pred)\n",
    "#     phone_gyro_matrix[subjectid] = matrix\n",
    "    \n",
    "#     accu_per_class = matrix.diagonal()/ matrix.sum(axis=1)\n",
    "#     phone_gyro_activity_accuracy[subjectid] = dict(zip(activity_labels, accu_per_class))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### The cross validation report"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "------------------------------------------------------------------------\n",
      "Score per fold\n",
      "------------------------------------------------------------------------\n",
      "> Fold 1 - Loss: 0.7301 - Accuracy: 88.1944%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 2 - Loss: 0.9662 - Accuracy: 87.5433%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 3 - Loss: 0.9321 - Accuracy: 85.4671%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 4 - Loss: 0.9679 - Accuracy: 87.5433%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 5 - Loss: 0.9317 - Accuracy: 87.8893%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 6 - Loss: 1.1612 - Accuracy: 86.8512%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 7 - Loss: 0.8738 - Accuracy: 87.5433%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 8 - Loss: 0.8802 - Accuracy: 87.1972%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 9 - Loss: 0.9409 - Accuracy: 89.2734%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 10 - Loss: 0.7402 - Accuracy: 86.1592%\n",
      "------------------------------------------------------------------------\n",
      "Average scores for all folds:\n",
      "> Accuracy: 87.3662 (+- 1.0024)\n",
      "> Loss: 0.9124\n",
      "------------------------------------------------------------------------\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Watch Accelerometer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# \"\"\" Watch Accelerometer \"\"\"\n",
    "\n",
    "num_folds = 10\n",
    "kfold = KFold(n_splits=num_folds, shuffle=True)\n",
    "\n",
    "watch_accel_accuracy_per_fold = {}\n",
    "watch_accel_loss_per_fold = {}\n",
    "\n",
    "watch_accel_accuracy = {}\n",
    "watch_accel_precision = {}\n",
    "watch_accel_recall = {}\n",
    "watch_accel_f1 = {}\n",
    "\n",
    "watch_accel_matrix = {}\n",
    "watch_accel_activity_accuracy = {}\n",
    "watch_accel_classification_reports={}\n",
    "\n",
    "fold_number = 1\n",
    "\n",
    "for subjectid, file in enumerate(watch_accel_file_paths[:]):\n",
    "    subjectid = file.split(\"_\")[1]\n",
    "\n",
    "    data = pd.read_csv(file, verbose=False)\n",
    "\n",
    "    activity_labels = list(activity_dictionary(data).values())\n",
    "\n",
    "    processed_data = preprocess_data(data)\n",
    "\n",
    "    X, y = get_frames(processed_data, frame_size, step_size)\n",
    "\n",
    "    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, stratify = y)\n",
    "\n",
    "    # Makes the input data form 4-Dimensional\n",
    "    X_train = X_train.reshape(X_train.shape[0], X_train.shape[1], 3, 1)\n",
    "    X_test = X_test.reshape(X_test.shape[0], X_test.shape[1], 3, 1)\n",
    "\n",
    "    inputs = np.concatenate((X_train, X_test), axis=0)\n",
    "    targets = np.concatenate((y_train, y_test), axis=0)\n",
    "\n",
    "    acc_per_fold = []\n",
    "    loss_per_fold = []    \n",
    "    print(\"#########################################################################################\")\n",
    "    print(subjectid)\n",
    "    fold_no = 1\n",
    "    for train, test in kfold.split(inputs, targets):\n",
    "        model = get_model()\n",
    "\n",
    "        history = model.fit(inputs[train], targets[train], batch_size=128, epochs=2, validation_split=0.2, verbose=1)\n",
    "\n",
    "        print('------------------------------------------------------------------------')\n",
    "        print(f'Training for fold {fold_no} ...')\n",
    "\n",
    "        scores = model.evaluate(inputs[train], targets[train], verbose=0)\n",
    "\n",
    "        print(f'Score for fold {fold_no}: {model.metrics_names[0]} of {scores[0]}; {model.metrics_names[1]} of {scores[1]*100}%')\n",
    "        acc_per_fold.append(scores[1] * 100)\n",
    "        loss_per_fold.append(scores[0])\n",
    "\n",
    "        # Increases fold number\n",
    "        fold_no = fold_no + 1\n",
    "\n",
    "    watch_accel_accuracy_per_fold[subjectid] = acc_per_fold\n",
    "    watch_accel_loss_per_fold[subjectid] = loss_per_fold\n",
    "\n",
    "    y_true = targets[test]\n",
    "    y_pred = model.predict_classes(inputs[test], verbose=0)\n",
    "\n",
    "    # Accuracy: (tp + tn) / (p + n)\n",
    "    watch_accel_accuracy[subjectid] = accuracy_score(y_true, y_pred)\n",
    "\n",
    "    # Precision tp / (tp + fp)\n",
    "    precision = precision_score(y_true, y_pred, average=None, zero_division=1)\n",
    "    watch_accel_precision[subjectid] = dict(zip(activity_labels, precision))\n",
    "\n",
    "    # Recall: tp / (tp + fn)\n",
    "    recall = recall_score(y_true, y_pred, average=None, zero_division=1)\n",
    "    watch_accel_recall[subjectid] = dict(zip(activity_labels, recall))\n",
    "\n",
    "    # F1: 2 tp / (2 tp + fp + fn)\n",
    "    f1 = f1_score(y_true, y_pred, average=None, zero_division=1)\n",
    "    watch_accel_f1[subjectid] = dict(zip(activity_labels, f1))    \n",
    "    \n",
    "#     watch_accel_classification_reports[subjectid] = classification_report(y_test, y_pred, zero_division=1)\n",
    "    \n",
    "#     matrix = confusion_matrix(y_test, y_pred)\n",
    "#     watch_accel_matrix[subjectid] = matrix\n",
    "    \n",
    "#     accu_per_class = matrix.diagonal()/ matrix.sum(axis=1)\n",
    "#     watch_accel_activity_accuracy[subjectid] = dict(zip(activity_labels, accu_per_class))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### The cross validation report"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "------------------------------------------------------------------------\n",
      "Score per fold\n",
      "------------------------------------------------------------------------\n",
      "> Fold 1 - Loss: 0.2169 - Accuracy: 95.8730%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 2 - Loss: 0.2066 - Accuracy: 94.9367%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 3 - Loss: 0.1725 - Accuracy: 95.2532%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 4 - Loss: 0.2720 - Accuracy: 94.3038%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 5 - Loss: 0.2252 - Accuracy: 94.6203%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 6 - Loss: 0.2351 - Accuracy: 93.0380%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 7 - Loss: 0.2449 - Accuracy: 95.8861%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 8 - Loss: 0.2657 - Accuracy: 93.6709%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 9 - Loss: 0.3390 - Accuracy: 94.3038%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 10 - Loss: 0.2642 - Accuracy: 93.3544%\n",
      "------------------------------------------------------------------------\n",
      "Average scores for all folds:\n",
      "> Accuracy: 94.5240 (+- 0.9374)\n",
      "> Loss: 0.2442\n",
      "------------------------------------------------------------------------\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Watch Gyroscope"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" Watch Gyroscope \"\"\"\n",
    "\n",
    "num_folds = 10\n",
    "kfold = KFold(n_splits=num_folds, shuffle=True)\n",
    "\n",
    "watch_gyro_accuracy_per_fold = {}\n",
    "watch_gyro_loss_per_fold = {}\n",
    "\n",
    "watch_gyro_accuracy = {}\n",
    "watch_gyro_precision = {}\n",
    "watch_gyro_recall = {}\n",
    "watch_gyro_f1 = {}\n",
    "\n",
    "watch_gyro_matrix = {}\n",
    "watch_gyro_activity_accuracy = {}\n",
    "watch_gyro_classification_reports={}\n",
    "\n",
    "fold_number = 1\n",
    "\n",
    "for subjectid, file in enumerate(watch_gyro_file_paths[:]):\n",
    "    subjectid = file.split(\"_\")[1]\n",
    "\n",
    "    data = pd.read_csv(file, verbose=False)\n",
    "\n",
    "    activity_labels = list(activity_dictionary(data).values())\n",
    "\n",
    "    processed_data = preprocess_data(data)\n",
    "\n",
    "    X, y = get_frames(processed_data, frame_size, step_size)\n",
    "\n",
    "    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, stratify = y)\n",
    "\n",
    "    # Makes the input data form 4-Dimensional\n",
    "    X_train = X_train.reshape(X_train.shape[0], X_train.shape[1], 3, 1)\n",
    "    X_test = X_test.reshape(X_test.shape[0], X_test.shape[1], 3, 1)\n",
    "\n",
    "    inputs = np.concatenate((X_train, X_test), axis=0)\n",
    "    targets = np.concatenate((y_train, y_test), axis=0)\n",
    "\n",
    "    acc_per_fold = []\n",
    "    loss_per_fold = []    \n",
    "    print(\"#########################################################################################\")\n",
    "    print(subjectid)\n",
    "    fold_no = 1\n",
    "    for train, test in kfold.split(inputs, targets):\n",
    "        model = get_model()\n",
    "\n",
    "        history = model.fit(inputs[train], targets[train], batch_size=128, epochs=70, validation_split=0.2, verbose=1)\n",
    "\n",
    "        print('------------------------------------------------------------------------')\n",
    "        print(f'Training for fold {fold_no} ...')\n",
    "\n",
    "        scores = model.evaluate(inputs[train], targets[train], verbose=0)\n",
    "\n",
    "        print(f'Score for fold {fold_no}: {model.metrics_names[0]} of {scores[0]}; {model.metrics_names[1]} of {scores[1]*100}%')\n",
    "        acc_per_fold.append(scores[1] * 100)\n",
    "        loss_per_fold.append(scores[0])\n",
    "\n",
    "        # Increases fold number\n",
    "        fold_no = fold_no + 1\n",
    "\n",
    "    watch_gyro_accuracy_per_fold[subjectid] = acc_per_fold\n",
    "    watch_gyro_loss_per_fold[subjectid] = loss_per_fold\n",
    "\n",
    "    y_true = targets[test]\n",
    "    y_pred = model.predict_classes(inputs[test], verbose=0)\n",
    "\n",
    "    # Accuracy: (tp + tn) / (p + n)\n",
    "    watch_gyro_accuracy[subjectid] = accuracy_score(y_true, y_pred)\n",
    "\n",
    "    # Precision tp / (tp + fp)\n",
    "    precision = precision_score(y_true, y_pred, average=None, zero_division=1)\n",
    "    watch_gyro_precision[subjectid] = dict(zip(activity_labels, precision))\n",
    "\n",
    "    # Recall: tp / (tp + fn)\n",
    "    recall = recall_score(y_true, y_pred, average=None, zero_division=1)\n",
    "    watch_gyro_recall[subjectid] = dict(zip(activity_labels, recall))\n",
    "\n",
    "    # F1: 2 tp / (2 tp + fp + fn)\n",
    "    f1 = f1_score(y_true, y_pred, average=None, zero_division=1)\n",
    "    watch_gyro_f1[subjectid] = dict(zip(activity_labels, f1))   \n",
    "    \n",
    "#     watch_gyro_classification_reports[subjectid] = classification_report(y_test, y_pred, zero_division=1)\n",
    "    \n",
    "#     matrix = confusion_matrix(y_test, y_pred)\n",
    "#     watch_gyro_matrix[subjectid] = matrix\n",
    "    \n",
    "#     accu_per_class = matrix.diagonal()/ matrix.sum(axis=1)\n",
    "#     watch_gyro_activity_accuracy[subjectid] = dict(zip(activity_labels, accu_per_class))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### The cross validation report"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "------------------------------------------------------------------------\n",
      "Score per fold\n",
      "------------------------------------------------------------------------\n",
      "> Fold 1 - Loss: 0.4807 - Accuracy: 89.8413%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 2 - Loss: 0.3752 - Accuracy: 91.4557%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 3 - Loss: 0.5942 - Accuracy: 90.8228%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 4 - Loss: 0.6152 - Accuracy: 90.1899%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 5 - Loss: 0.5313 - Accuracy: 91.1392%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 6 - Loss: 0.5823 - Accuracy: 89.2405%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 7 - Loss: 0.4954 - Accuracy: 90.1899%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 8 - Loss: 0.6890 - Accuracy: 88.9241%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 9 - Loss: 0.6603 - Accuracy: 88.9241%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 10 - Loss: 0.6202 - Accuracy: 90.1899%\n",
      "------------------------------------------------------------------------\n",
      "Average scores for all folds:\n",
      "> Accuracy: 90.0917 (+- 0.8388)\n",
      "> Loss: 0.5644\n",
      "------------------------------------------------------------------------\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Accuracy obtained using different values of learning rate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 424,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th>Learning Rate</th>\n",
       "      <th>0.0001</th>\n",
       "      <th>0.0010</th>\n",
       "      <th>0.0100</th>\n",
       "      <th>10.0000</th>\n",
       "      <th>1.0000</th>\n",
       "      <th>10.0000</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Accuracy</th>\n",
       "      <td>79.93</td>\n",
       "      <td>95.96</td>\n",
       "      <td>85.9</td>\n",
       "      <td>30.1</td>\n",
       "      <td>10.53</td>\n",
       "      <td>5.88</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Learning Rate  0.0001   0.0010   0.0100   10.0000  1.0000   10.0000\n",
       "Accuracy         79.93    95.96     85.9     30.1    10.53     5.88"
      ]
     },
     "execution_count": 424,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "learning_rates = [1e-4, 1e-3, 1e-2, 1e1, 1.0, 10.0]\n",
    "accuracies = [79.93, 95.96, 85.9, 30.10, 10.53, 5.88]\n",
    "data = {'Learning Rate': learning_rates, 'Accuracy': accuracies}\n",
    "df = pd.DataFrame(data=data)\n",
    "df.set_index('Learning Rate', inplace=True)\n",
    "df.transpose()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Plots training accuracy values w.r.t learning rate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_learningCurve():\n",
    "    \"\"\" Plots training accuracy values w.r.t learning rate \"\"\"\n",
    "    \n",
    "    x = [-4, -3, -2, -1, 0, 1]\n",
    "    y = [79.93, 95.96, 85.9, 30.10, 10.53, 5.98]\n",
    "    \n",
    "    plt.plot(x, y, color='green', lw=2, linestyle='--', marker='D', markerfacecolor='red', markeredgecolor='red', markersize=5)\n",
    "    plt.title('Model accuracy w.r.t learning rate', fontweight='bold', fontsize=15)\n",
    "    plt.xlabel(\"Learning Rate (10^)\", fontsize=13)\n",
    "    plt.ylabel(\"Accuracy (%)\", fontsize=13)\n",
    "    plt.grid(color='b', linestyle='--', linewidth=0.5)\n",
    "#     plt.xticks([0.1, 0.01, 0.001, 0.0001])\n",
    "    plt.yticks(y)\n",
    "#     plt.xlim(1.5, 12.5)\n",
    "    plt.ylim(0, 100)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_learningCurve()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "activity_dict= {0:\"Walking\",\n",
    "                1:\"Jogging\",\n",
    "                2:\"Stairs\",\n",
    "                3:\"Sitting\",\n",
    "                4:\"Standing\",\n",
    "                5:\"Typing\",\n",
    "                6:\"Brushing Teeth\",\n",
    "                7:\"Eating Soup\",\n",
    "                8:\"Eating Chips\",\n",
    "                9:\"Eating Pasta\",\n",
    "                10:\"Drinking from Cup\",\n",
    "                11:\"Eating Sandwich\",\n",
    "                12:\"Kicking\",\n",
    "                13:\"Playing Catch\",\n",
    "                14:\"Dribblinlg Basketball\",\n",
    "                15:\"Writing\",\n",
    "                16:\"Clapping\",\n",
    "                17:\"Folding Clothes\"}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Plots the confusion Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "y_pred = model.predict_classes(X_test)\n",
    "matrix = confusion_matrix(y_test, y_pred)\n",
    "matrix_plot = plot_confusion_matrix(conf_mat=matrix, class_names=activity_dict.values(), show_normed=True, figsize=(15,15), cmap=plt.cm.Purples);\n",
    "plt.title('Confusion Matrix')\n",
    "plt.show()"
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}