967 lines (966 with data), 157.1 kB

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Imports the required libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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, Conv1D, MaxPooling1D, MaxPooling2D\n",
    "from keras.layers import Flatten, Dropout, BatchNormalization, Reshape\n",
    "from keras.utils.vis_utils import plot_model\n",
    "from keras.wrappers.scikit_learn import KerasClassifier\n",
    "\n",
    "import os\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "from mlxtend.plotting import plot_confusion_matrix\n",
    "\n",
    "import sklearn\n",
    "from sklearn.model_selection import train_test_split, cross_val_score, KFold\n",
    "from sklearn.preprocessing import StandardScaler, LabelEncoder\n",
    "from sklearn.metrics import classification_report, confusion_matrix\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": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" Stores the path of the sensor files in the corresponding list \"\"\"\n",
    "\n",
    "base_path = \"./data/transformed_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": 4,
   "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\"}\n",
    "\n",
    "def get_key(val): \n",
    "    for key, value in activity_dict.items(): \n",
    "        if val == value: \n",
    "            return key "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Plots the distribution of data among activities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns\n",
    "def plot_distribution(data):\n",
    "    \"\"\" Plots the distribution of data among activities \"\"\"\n",
    "    \n",
    "    activity_df = pd.DataFrame()\n",
    "    activity_df[\"Activity\"] = [activity_dict[item] for item in np.unique(data['ACTIVITY'])]\n",
    "    act_percentages = []\n",
    "\n",
    "    for act in activity_df[\"Activity\"]:\n",
    "        act_percentages.append(len(data[data[\"ACTIVITY\"] == get_key(act)])/len(data)*100)\n",
    "    activity_df[\"Distr. of Data Among Activities %\"] = act_percentages\n",
    "    \n",
    "    sns.set(style=\"whitegrid\")\n",
    "    fig, ax = plt.subplots(figsize=(10, 4))\n",
    "\n",
    "    act = sns.barplot(x=\"Activity\", y=\"Distr. of Data Among Activities %\", data=activity_df)\n",
    "    ax.set_xlabel(\"Activity\", fontsize = 14)\n",
    "    ax.set_ylabel(\"Distr. of Data Among Activities %\", fontsize = 13)\n",
    "#     ax.set_title(\"Distribution of Data Among Activities\", fontsize = 15)\n",
    "    plt.xticks(rotation=90);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Distribution of Data Among Activities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data = pd.read_csv(\"./data/raw_data/all_data.csv\", verbose=False)\n",
    "plot_distribution(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The data is slightly imbalanced\n",
    "#### In order to balance the data, the first 17 data rows of each activity are taken"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def balance_data(dataframe):\n",
    "    \"\"\"  Takes only the first 17 data rows for each activity \"\"\"\n",
    "\n",
    "    A = dataframe[dataframe['ACTIVITY']=='A'].head(17).copy()\n",
    "    B = dataframe[dataframe['ACTIVITY']=='B'].head(17).copy()\n",
    "    C = dataframe[dataframe['ACTIVITY']=='C'].head(17).copy()\n",
    "    D = dataframe[dataframe['ACTIVITY']=='D'].head(17).copy()\n",
    "    E = dataframe[dataframe['ACTIVITY']=='E'].head(17).copy()\n",
    "    F = dataframe[dataframe['ACTIVITY']=='F'].head(17).copy()\n",
    "    G = dataframe[dataframe['ACTIVITY']=='G'].head(17).copy()\n",
    "    H = dataframe[dataframe['ACTIVITY']=='H'].head(17).copy()\n",
    "    I = dataframe[dataframe['ACTIVITY']=='I'].head(17).copy()\n",
    "    J = dataframe[dataframe['ACTIVITY']=='J'].head(17).copy()\n",
    "    K = dataframe[dataframe['ACTIVITY']=='K'].head(17).copy()\n",
    "    L = dataframe[dataframe['ACTIVITY']=='L'].head(17).copy()\n",
    "    M = dataframe[dataframe['ACTIVITY']=='M'].head(17).copy()\n",
    "    O = dataframe[dataframe['ACTIVITY']=='O'].head(17).copy()\n",
    "    P = dataframe[dataframe['ACTIVITY']=='P'].head(17).copy()\n",
    "    Q = dataframe[dataframe['ACTIVITY']=='Q'].head(17).copy()\n",
    "    R = dataframe[dataframe['ACTIVITY']=='R'].head(17).copy()\n",
    "    S = dataframe[dataframe['ACTIVITY']=='S'].head(17).copy()\n",
    "\n",
    "    balanced_data = pd.DataFrame()\n",
    "    balanced_data = balanced_data.append([A, B, C, D, E, F, G, H, I, J, K, L, M, O, P, Q, R, S], ignore_index=True)\n",
    "\n",
    "    return balanced_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Takes only 43 important features of the dataframe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def clean_data(dataframe):\n",
    "    \"\"\" Removes the columns \"ACTIVITY\" and \"class\" from the dataframe \"\"\"\n",
    "    \"\"\" Takes only 43 important features of the dataframe  \"\"\"\n",
    "    \n",
    "    df = dataframe.drop(['ACTIVITY', 'class'], axis = 1).copy()\n",
    "    x1 = df.loc[:, \"X0\":\"ZSTANDDEV\"]\n",
    "    x2 = df.loc[:, 'RESULTANT']   \n",
    "    cleaned_df = pd.concat([x1, x2], axis=1, join='inner')\n",
    "    \n",
    "    return cleaned_df "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Normalizes the data using StandardScaler() function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def scale_data(data, labels):\n",
    "    \"\"\" Normalizes the data using StandardScaler() function \"\"\"\n",
    "\n",
    "    le = LabelEncoder()\n",
    "    activity_labels = le.fit_transform(labels)\n",
    "    \n",
    "    X_train, X_test, y_train, y_test = train_test_split(data, activity_labels, test_size=0.3, random_state=0)\n",
    "    \n",
    "    scaler = StandardScaler().fit(X_train)\n",
    "    X_train = scaler.transform(X_train)\n",
    "    X_test = scaler.transform(X_test)\n",
    "\n",
    "    return X_train, X_test, y_train, y_test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Decodes the activity labels and stores them in a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def activity_dictionary(dataframe):    \n",
    "    \"\"\" Decodes the activity labels and stores them in a dictionary \"\"\"\n",
    "\n",
    "    activity_labels = dataframe[\"ACTIVITY\"]\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 balance(), clean(), and scale() functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def preprocess_data(dataframe):\n",
    "    \"\"\" Preprocesses the data using balance(), clean(), and scale() functions \"\"\"\n",
    "\n",
    "    balanced_df = balance_data(dataframe)\n",
    "    activity_labels = balanced_df[\"ACTIVITY\"]\n",
    "    cleaned_df = clean_data(balanced_df)\n",
    "    \n",
    "    return scale_data(cleaned_df, activity_labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Prints the cross validation report"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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: {accuracy_per_fold[i]} - Accuracy: {loss_per_fold[i]}%')\n",
    "    print('------------------------------------------------------------------------')\n",
    "    print('Average scores for all folds:')\n",
    "    print(f'> Accuracy: {np.mean(accuracy_per_fold)} (+- {np.std(accuracy_per_fold)})')\n",
    "    print(f'> Loss: {np.mean(loss_per_fold)}')\n",
    "    print('------------------------------------------------------------------------')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Plots training & validation accuracy values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "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": [
    "##### Builds the model (the Convolutional Neural Network)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_model():\n",
    "    \"\"\" Builds the model (the Convolutional Neural Network) \"\"\"\n",
    "    \n",
    "    # Defines model\n",
    "    model = Sequential()\n",
    "    model.add(Conv1D(filters=43, kernel_size=1, activation='relu', input_shape=(1,43)))\n",
    "#     model.add(Conv1D(filters=64, kernel_size=1, activation='relu'))\n",
    "    model.add(MaxPooling1D(pool_size=1))\n",
    "    model.add(Flatten())\n",
    "#     model.add(Dense(256, activation='relu',name='D1'))\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": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" Phone Accelerometer \"\"\"\n",
    "\n",
    "num_folds = 10\n",
    "kfold = KFold(n_splits=num_folds, shuffle=False)\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",
    "for subjectid, file in enumerate(phone_accel_file_paths[:]):\n",
    "    subjectid = file.split(\"_\")[2]\n",
    "    \n",
    "    data = pd.read_csv(file, verbose=False)\n",
    "    \n",
    "    activity_labels = list(activity_dictionary(data).values())\n",
    "    X_train, X_test, y_train, y_test = preprocess_data(data)\n",
    "    \n",
    "    # Makes the input data form 3-Dimensional\n",
    "    X_train = X_train.reshape(X_train.shape[0], 1, 43)\n",
    "    X_test = X_test.reshape(X_test.shape[0], 1, 43)\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=1, 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": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "------------------------------------------------------------------------\n",
      "Score per fold\n",
      "------------------------------------------------------------------------\n",
      "> Fold 1 - Loss: 94.18181777000427 - Accuracy: 0.3544494605064392%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 2 - Loss: 92.36363768577576 - Accuracy: 0.4488078521056609%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 3 - Loss: 92.72727370262146 - Accuracy: 0.5173578348891301%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 4 - Loss: 92.00000166893005 - Accuracy: 0.5027308412031694%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 5 - Loss: 92.00000166893005 - Accuracy: 0.5405109715461731%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 6 - Loss: 93.81818175315857 - Accuracy: 0.41282150837508114%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 7 - Loss: 93.478262424469 - Accuracy: 0.4353983595535375%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 8 - Loss: 95.28985619544983 - Accuracy: 0.38435162728031474%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 9 - Loss: 95.652174949646 - Accuracy: 0.22068002890201582%\n",
      "------------------------------------------------------------------------\n",
      "> Fold 10 - Loss: 95.652174949646 - Accuracy: 0.2679230518963026%\n",
      "------------------------------------------------------------------------\n",
      "Average scores for all folds:\n",
      "> Accuracy: 93.7163382768631 (+- 1.37674542221131)\n",
      "> Loss: 0.4085031536257825\n",
      "------------------------------------------------------------------------\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "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": 30,
   "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": [
    "## Phone Gyroscope"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" Phone Gyroscope \"\"\"\n",
    "\n",
    "num_folds = 10\n",
    "kfold = KFold(n_splits=num_folds, shuffle=False)\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",
    "for subjectid, file in enumerate(phone_gyro_file_paths[:]):\n",
    "    subjectid = file.split(\"_\")[2]\n",
    "    \n",
    "    data = pd.read_csv(file, verbose=False)\n",
    "    \n",
    "    activity_labels = list(activity_dictionary(data).values())\n",
    "    X_train, X_test, y_train, y_test = preprocess_data(data)\n",
    "    \n",
    "    # Makes the input data form 3-Dimensional\n",
    "    X_train = X_train.reshape(X_train.shape[0], 1, 43)\n",
    "    X_test = X_test.reshape(X_test.shape[0], 1, 43)\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",
    "    \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=1, 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[test], targets[test], 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": [
    "## Watch Accelerometer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" Watch Accelerometer \"\"\"\n",
    "\n",
    "num_folds = 10\n",
    "kfold = KFold(n_splits=num_folds, shuffle=False)\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",
    "for subjectid, file in enumerate(watch_accel_file_paths[:]):\n",
    "    subjectid = file.split(\"_\")[2]\n",
    "    \n",
    "    data = pd.read_csv(file, verbose=False)\n",
    "    \n",
    "    activity_labels = list(activity_dictionary(data).values())\n",
    "    X_train, X_test, y_train, y_test = preprocess_data(data)\n",
    "    \n",
    "    # Makes the input data form 3-Dimensional\n",
    "    X_train = X_train.reshape(X_train.shape[0], 1, 43)\n",
    "    X_test = X_test.reshape(X_test.shape[0], 1, 43)\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",
    "    \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=1, 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[test], targets[test], 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": [
    "## Watch Gyroscope"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" Watch Gyroscope \"\"\"\n",
    "\n",
    "num_folds = 10\n",
    "kfold = KFold(n_splits=num_folds, shuffle=False)\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",
    "for subjectid, file in enumerate(watch_gyro_file_paths[:]):\n",
    "    subjectid = file.split(\"_\")[2]\n",
    "    \n",
    "    data = pd.read_csv(file, verbose=False)\n",
    "    \n",
    "    activity_labels = list(activity_dictionary(data).values())\n",
    "    X_train, X_test, y_train, y_test = preprocess_data(data)\n",
    "    \n",
    "    # Makes the input data form 3-Dimensional\n",
    "    X_train = X_train.reshape(X_train.shape[0], 1, 43)\n",
    "    X_test = X_test.reshape(X_test.shape[0], 1, 43)\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",
    "    \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=1, 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_recal [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": "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}