Arrhythmia_Classification.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "7rr_9pwF-BXl"
   },
   "source": [
    "# Prediction and Classification of Cardiac Arrhythmia using Machine Learning - Team 21\n",
    "\n",
    "### Automated Learning and Data Analysis - CSC522\n",
    "### Curriculum Project - Spring 2020 \n",
    "### Team Members (Project Team 21):\n",
    "\n",
    "Mangalnathan Vijayagopal - mvijaya2\n",
    "\n",
    "Nishcal Badarinath Kashyap - nkashya\n",
    "\n",
    "Shreyas Chikkballapur Muralidhara - schikkb                        \n",
    "\n",
    "Pawandeep Singh Mendiratta - psmendir"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "7Mu3nX4v6kiU"
   },
   "source": [
    "## Introduction\n",
    "\n",
    "Most cardiac disorders cause irregularities in heartbeat. These irregular patterns in rhythm of heartbeat is called Arrhythmia. Only with a quick response can the cardiac Arrhythmia be detected in patients at the critical phase. Thereby reducing the complications that might have resulted in late detection. The diagnosis of arrhythmia involves handling of huge amount of ECG data, physicians may not interpret Electrocardiogram for large datasets effectively as it is time consuming and can also cause misclassification of beats. Hence, computer assisted analysis of the ECG data using Supervised Machine Learning can play a huge role as a decision support system to the physicians."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "8DDRejeN_nGr"
   },
   "source": [
    "## Objective\n",
    "Implementing supervised Machine Learning Algorithms to analyze various features of electrocardiogram(ECG) details of patients. We will use publically available Cardiac Arrhythmia dataset on UCI Machine Learning Repository to develop the classification models.\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "sGuuiQCNeJVA"
   },
   "source": [
    "## Dataset\n",
    "\n",
    "The cardiac Arrhythmia dataset is acquired from Arrhythmia dataset in UCI repository. In this dataset, the Electrocardiogram (ECG) readings along with physical description of 452 patients. Each patient record is described by 279 attributes - 206 Linear and 73 nominal, with categorial class attribute. There are 16 classes based on value of attributes.Class are as follows:\n",
    "\n",
    "* Class 1 - Normal\n",
    "* Class 2 to 15 - Each class indicating various types of Arrhythmia.\n",
    "* Class 16 - Unknowns\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_2dNiiGveD3U"
   },
   "source": [
    "## Importing data and Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "id": "uHo-l2qs4OkF",
    "outputId": "142dfc1a-49cf-45e5-9055-ec02b7b5520f"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(452, 280)"
      ]
     },
     "execution_count": 1,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Import the necessary libraries to implemnet it.\n",
    "#!pip install tensorflow==1.14.0\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import keras\n",
    "import tensorflow as tf\n",
    "import ssl\n",
    "import math\n",
    "import matplotlib.pyplot as plt\n",
    "import operator\n",
    "\n",
    "from collections import defaultdict\n",
    "from sklearn import preprocessing\n",
    "from sklearn.model_selection import train_test_split, KFold\n",
    "from sklearn.impute import SimpleImputer\n",
    "from sklearn.preprocessing import normalize, StandardScaler\n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.svm import LinearSVC, SVC\n",
    "from sklearn.metrics import confusion_matrix, classification_report, f1_score,accuracy_score\n",
    "from sklearn.feature_selection import SelectFromModel\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Dense, Dropout, Flatten, LSTM\n",
    "from tensorflow.keras.layers import Conv1D, MaxPooling1D,BatchNormalization,GlobalMaxPooling1D,MaxPooling1D\n",
    "from keras.regularizers import l2,l1\n",
    "from keras.utils import to_categorical\n",
    "from keras.optimizers import RMSprop, SGD, adam\n",
    "\n",
    "# Import the Arrhythmia dataset from the library and replace missing values by '?'.\n",
    "repo_url = \"https://archive.ics.uci.edu/ml/machine-learning-databases/arrhythmia/arrhythmia.data\"\n",
    "ssl._create_default_https_context = ssl._create_unverified_context\n",
    "df = pd.read_csv(repo_url, delimiter=',', header=None,)\n",
    "\n",
    "# Make sure the data frame has 452 rows along with 280 columns. \n",
    "df.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "iYn6c8oWihsV"
   },
   "source": [
    "## Data Preprocessing\n",
    "The Data Preprocessing is carried out in 3 steps:\n",
    "1. **Remove unwanted columns** - Deleting the attributes having more than 40% missing values. \n",
    "2. **Replace missing values** - Impute the missing values by replacing them with the attribute median.\n",
    "3. **Attribute Scaling** - Normalize the attributes so that values are scaled up by processing. \n",
    "\n",
    "NOTE: The reason to replace missing attribute values with median instead of mean is to avoid the effect of outliers for attributes with higher standard deviation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "Lukhjj8RrxQG",
    "outputId": "946d8f08-717a-4ba4-e87e-8489b417ba4a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(452, 278)\n"
     ]
    }
   ],
   "source": [
    "# Split the frame as Data attribute and Class\n",
    "df_data = df.iloc[:,:-1]\n",
    "df_class = df.iloc[:,-1]\n",
    "\n",
    "# Replace ? by NaN\n",
    "df_data = df_data.replace('?', np.NaN)\n",
    "\n",
    "# Remove unwanted columns\n",
    "# Deleting the attributes having more than 40% missing values.\n",
    "thresh = len(df_data) * 0.4\n",
    "df_data.dropna(thresh = thresh, axis = 1, inplace = True)\n",
    "\n",
    "# Replace Missing values \n",
    "# Imputing the remaining missing values with median of the values in the column\n",
    "imp_mean = SimpleImputer(missing_values=np.NaN, strategy='median')\n",
    "imputer = imp_mean.fit(df_data)\n",
    "df_imp = imputer.transform(df_data)\n",
    "df_data = pd.DataFrame(df_imp)\n",
    "\n",
    "# Attribute Scaling\n",
    "# Normalize the values except for the class labels for each attribute using StandardScaler.\n",
    "std_scaler = StandardScaler()\n",
    "x_scaled = std_scaler.fit_transform(df_data.values) \n",
    "df_data = pd.DataFrame(x_scaled, index = df_data.index)\n",
    "\n",
    "print(df_data.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "sD3MG_xSdI2E"
   },
   "source": [
    "## Split the data into train, test and validation.\n",
    "\n",
    "Before we proceed further with building the Supervised Machine learning models, we split the model into train and test data.\n",
    "\n",
    "Using the pre processed dataframe as input, the split is as follows:  \n",
    "\n",
    "* Train - 70% - 316 records\n",
    "* Test - 30% - 136 records"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "96rup9r4hzoV",
    "outputId": "08e6030a-e7e7-4a20-b930-8f177bad2ce0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(316, 278) (316,) (136, 278) (136,)\n"
     ]
    }
   ],
   "source": [
    "# Splitting into training and testing data\n",
    "\n",
    "X_train, X_test, Y_train, Y_test = train_test_split(df_data, df_class, test_size=0.3, shuffle = True, stratify = df_class, random_state=43)\n",
    "\n",
    "# Splitting into training and validation data\n",
    "#X_train, X_val, Y_train, Y_val = train_test_split(X_trainval, Y_trainval, test_size=0.2, shuffle = True, stratify = Y_trainval, random_state=43)\n",
    "\n",
    "print(X_train.shape, Y_train.shape, X_test.shape, Y_test.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Ya64uE6aocyq"
   },
   "source": [
    "## Determining the class weights for imbalanced dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 105
    },
    "colab_type": "code",
    "id": "eQLz5X9VojRa",
    "outputId": "5a576444-053c-4e50-c44c-86f3ad42bade"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "66.48389473526794\n",
      "{1: 0.14215024741340532, 2: 0.7841191066997518, 3: 2.2097902097902096, 4: 2.2097902097902096, 5: 2.700854700854701, 6: 1.4298642533936652, 7: 12.153846153846153, 8: 24.307692307692307, 9: 4.051282051282051, 10: 0.6945054945054945, 14: 8.102564102564102, 15: 6.076923076923077, 16: 1.6205128205128205}\n",
      "[  0 171  31  11  11   9  17   2   1   6  35   0   0   0   3   4  15]\n",
      "[ 0 74 13  4  4  4  8  1  1  3 15  0  0  0  1  1  7]\n"
     ]
    }
   ],
   "source": [
    "from sklearn.utils import class_weight\n",
    "class_wt = class_weight.compute_class_weight('balanced', np.unique(Y_train), Y_train)\n",
    "class_weights = dict(zip([1,2,3,4,5,6,7,8,9,10,14,15,16], class_wt))\n",
    "#class_weights[0] = 0\n",
    "#class_weights[11] = 0\n",
    "#class_weights[12] = 0\n",
    "#class_weights[13] = 0\n",
    "print(class_wt.sum())\n",
    "print(class_weights)\n",
    "\n",
    "print(np.bincount(Y_train))\n",
    "print(np.bincount(Y_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "h0wp_fVOc0S5"
   },
   "source": [
    "## Feature Selection - Train dataset\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Lazpb7zzUb1L"
   },
   "source": [
    "  ### Principle Component Analysis (PCA)\n",
    "  Grid search on various number of PCA components to be retained.\n",
    "  \n",
    "  Deciding the number of components to be selected based on the plots of:\n",
    "  * Plot of Eigen values v/s No of components.\n",
    "  * Plot of Percent of cumulative variance v/s No of components.\n",
    "\n",
    "Based on the plots select all the components with eigen value greater than or equal to 1 (Rule of Thumb).\n",
    "\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 658
    },
    "colab_type": "code",
    "id": "XFDKb-PvdlgM",
    "outputId": "25034ad3-267d-49f7-e105-6e25f6bb771d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Components from Feature selection using PCA (Having Eigen values >=1)- 88\n",
      "\n",
      "Feature Selection using PCA complete for the train data.\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Implementation of PCA\n",
    "pca_dict = {}\n",
    "eigen_dict = {}\n",
    "for n_comp in df_data.columns:\n",
    "  pca = PCA(n_components=n_comp)\n",
    "  temp_train_pca = pca.fit_transform(X_train)\n",
    "  temp_test_pca = pca.transform(X_test)\n",
    "  eigen_values = pca.explained_variance_[:n_comp]\n",
    "  \n",
    "  if n_comp > 0:\n",
    "    #print (n_comp,pca.explained_variance_ratio_.sum(),eigen_values)[-1])\n",
    "    pca_dict[n_comp] = pca.explained_variance_ratio_.sum()\n",
    "    eigen_dict[n_comp] = eigen_values[-1]\n",
    "\n",
    "f = plt.figure(1)\n",
    "f.patch.set_facecolor('white')\n",
    "plt.title('PCA Variance')\n",
    "plt.xlabel('Principal Component Number')\n",
    "plt.ylabel('Variance Ratio')\n",
    "plt.plot(list(pca_dict.keys()),list(pca_dict.values()),'r')\n",
    "f.show()\n",
    "\n",
    "g = plt.figure(2)\n",
    "g.patch.set_facecolor('white')\n",
    "plt.title('PCA Eigen value')\n",
    "plt.xlabel('Principal Component Number')\n",
    "plt.ylabel('Eigen Values')\n",
    "plt.plot(list(eigen_dict.keys()),list(eigen_dict.values()),'r')\n",
    "g.show()\n",
    "\n",
    "# Selecting components with Eigen value greater than 1 from the list\n",
    "#pca_comp_eigen = max([key for key,val in eigen_dict.items() if val >= 1])\n",
    "pca_comp_eigen = max([key for key,val in pca_dict.items() if val < 0.95])\n",
    "\n",
    "print('Components from Feature selection using PCA (Having Eigen values >=1)- ' + str(pca_comp_eigen) + '\\n')\n",
    "\n",
    "# Performing PCA for the train data with the fixed components\n",
    "pca = PCA(n_components=pca_comp_eigen)\n",
    "X_train_pca = pca.fit_transform(X_train)\n",
    "X_test_pca = pca.transform(X_test)\n",
    "print('Feature Selection using PCA complete for the train data.\\n\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "XDyhO5YXUjxN"
   },
   "source": [
    "### Random Forest Classifier\n",
    "\n",
    "This model works on a portion of training dataset by continuously sampling with replacement. Then fitting a decision tree to the model. Each decision tree is a sequence of yes-no questions based on a single or combination of features. All the features are not considered by the tree, which conirms that individual decision trees are not corelated. Hence the classifier less prone to overfitting.\n",
    "\n",
    "The measure of impurity is by Gini index .\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "id": "_6plv8F9duIY",
    "outputId": "75037063-264f-4c1b-faa8-0497cd081bf6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Components from Feature Selection using Random Forest Classifier -  99\n",
      "99 99\n"
     ]
    }
   ],
   "source": [
    "# Implementation for Random forest\n",
    "rfc = SelectFromModel(RandomForestClassifier(n_estimators = 20, random_state=0, n_jobs = -1))\n",
    "rfc.fit(X_train, Y_train)\n",
    "\n",
    "rfc_comp = X_train.columns[(rfc.get_support())]\n",
    "print(\"Components from Feature Selection using Random Forest Classifier - \",len(rfc_comp))\n",
    "\n",
    "# Transform the model to contain only the new data.\n",
    "X_train_rfc= rfc.transform(X_train)\n",
    "X_test_rfc = rfc.transform(X_test)\n",
    "# Confirm that the transformed model has reduced components only\n",
    "print(len(X_train_rfc[0]), len(X_test_rfc[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "xr_km588KDUr"
   },
   "source": [
    "### Support Vector Machines\n",
    "\n",
    "Support Vector Machines(SVM) is a supervised machine learning algorithm used for classification, clustering and regression.\n",
    "\n",
    "An SVM model is a representation of the examples as points in space, mapped so that the examples of the separate categories are divided by a clear gap that is as wide as possible.New examples are then mapped into that same space and predicted to belong to a category based on the side of the gap on which they fall.\n",
    "\n",
    "Below is the implementaion of SVM by tuning the model on hyperparameters:  \n",
    "* Kernal type - linear, rbf, poly and sigmoid.\n",
    "* Scale of regularization parameters - 10^-3, 10^-2, 10^-1, 10^0, 10^1, 10^2, 10^3.\n",
    "\n",
    "\n",
    "### **SVM implementation using PCA** :\n",
    "Below is the SVM model implementations of different types of SVM (linear, rbf and kernel) for classification of arrhythmia for the features selected by Principal Component Analysis (PCA). We will be comparing the accuracy scores of these SVM types to decide which one is better."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 488
    },
    "colab_type": "code",
    "id": "6HgaNKxUjbbY",
    "outputId": "0434548f-effb-47ac-8d18-9793193ad212"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVM Accuracies - PCA: \n",
      "Linear kernal has maximum accuracy - 0.7353 for critical factor 0.01\n",
      "\n",
      "Radial Basis Function Kernel SVM accuracy - 0.6618 for critical factor 100\n",
      "\n",
      "Polynomial Kernel SVM has maximum accuracy - 0.6838 for critical factor 1000\n",
      "\n",
      "Sigmoid Kernel SVM has maximum accuracy - 0.6985 for critical factor 1\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Hyperaeter tuning on regularization parameter and kernal for SVM\n",
    "c_list = [0.001, 0.01, 0.1, 1, 10, 100, 1000]\n",
    "kernals = ['linear','rbf','poly','sigmoid']\n",
    "\n",
    "pca_accuracy = {'linear':[], 'rbf':[], 'poly':[], 'sigmoid':[]}\n",
    "#pca_f1_score = {'linear':[], 'rbf':[], 'poly':[], 'sigmoid':[]} \n",
    "\n",
    "for kernal in kernals:\n",
    "  for cval in c_list:\n",
    "    \n",
    "    clf = SVC(max_iter=100000, kernel=kernal, C=cval)\n",
    "\n",
    "    clf.fit(X_train_pca, Y_train)\n",
    "    pca_accuracy[kernal].append(clf.score(X_test_pca, Y_test))\n",
    "    yPred = clf.predict(X_test_pca)\n",
    "    #pca_f1_score[kernal].append(f1_score(Y_test, yPred, average='weighted'))\n",
    "\n",
    "    del clf\n",
    "    del yPred\n",
    "\n",
    "print('SVM Accuracies - PCA: ')\n",
    "print('Linear kernal has maximum accuracy - '+ str(round(max(pca_accuracy['linear']),4)) + ' for critical factor ' + str(c_list[pca_accuracy['linear'].index(max(pca_accuracy['linear']))]) )\n",
    "print('\\nRadial Basis Function Kernel SVM accuracy - '+ str(round(max(pca_accuracy['rbf']),4)) + ' for critical factor ' + str(c_list[pca_accuracy['rbf'].index(max(pca_accuracy['rbf']))]) )\n",
    "print('\\nPolynomial Kernel SVM has maximum accuracy - ' + str(round(max(pca_accuracy['poly']),4)) + ' for critical factor ' + str(c_list[pca_accuracy['poly'].index(max(pca_accuracy['poly']))]))\n",
    "print('\\nSigmoid Kernel SVM has maximum accuracy - ' + str(round(max(pca_accuracy['sigmoid']),4)) + ' for critical factor ' + str(c_list[pca_accuracy['sigmoid'].index(max(pca_accuracy['sigmoid']))]) +'\\n\\n')\n",
    "\n",
    "# Plot the Accuracy with C values\n",
    "fig = plt.figure(1)\n",
    "fig.patch.set_facecolor('white')\n",
    "plt.xscale('log')\n",
    "plt.title('Kernel SVM (Principle Component Analysis)')\n",
    "plt.xlabel('Critical Factor')\n",
    "plt.ylabel('Model Accuracy')\n",
    "plt.plot(c_list, pca_accuracy['linear'], 'r', label = 'Linear')\n",
    "plt.plot(c_list, pca_accuracy['rbf'], 'g', label = 'Radial Basis')\n",
    "plt.plot(c_list, pca_accuracy['poly'], 'b', label = 'Polynomial')\n",
    "plt.plot(c_list, pca_accuracy['sigmoid'], 'y', label = 'Sigmoid')\n",
    "plt.legend(bbox_to_anchor = (0., 1.02, 1., .202), loc = 10, ncol=4, borderaxespad = 0)\n",
    "fig.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "fEVOdGWtUvwy"
   },
   "source": [
    "####**SVM implementation using Random Forest Classifier**\n",
    "Below is the SVM model implementations of different types of SVM (linear, rbf and kernel) for classification of arrhythmia for the features selected by Random Forests. We will be comparing the accuracy scores of these SVM types to decide which one is better."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 488
    },
    "colab_type": "code",
    "id": "FvKeZl5ZV6rz",
    "outputId": "a4a478cb-c06d-498a-aa33-38708b87116c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVM Accuracies - Random Forest Classifier: \n",
      "Linear kernal has maximum accuracy - 0.7353 for critical factor 0.1\n",
      "\n",
      "Radial Basis Function Kernel SVM accuracy - 0.7132 for critical factor 10\n",
      "\n",
      "Polynomial Kernel SVM has maximum accuracy - 0.6765 for critical factor 10\n",
      "\n",
      "Sigmoid Kernel SVM has maximum accuracy - 0.6985 for critical factor 1\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Hyperaeter tuning on regularization parameter and kernal for SVM\n",
    "c_list = [0.001, 0.01, 0.1, 1, 10, 100, 1000]\n",
    "kernals = ['linear','rbf','poly','sigmoid']\n",
    "\n",
    "rfc_accuracy = {'linear':[], 'rbf':[], 'poly':[], 'sigmoid':[]}\n",
    "#rfc_f1_score = {'linear':[], 'rbf':[], 'poly':[], 'sigmoid':[]} \n",
    "\n",
    "for kernal in kernals:\n",
    "  for cval in c_list:\n",
    "    \n",
    "    clf = SVC(max_iter=100000, kernel=kernal, C=cval)\n",
    "\n",
    "    clf.fit(X_train_rfc, Y_train)\n",
    "    rfc_accuracy[kernal].append(clf.score(X_test_rfc, Y_test))\n",
    "    yPred = clf.predict(X_test_rfc)\n",
    "    #pca_f1_score[kernal].append(f1_score(Y_test, yPred, average='weighted'))\n",
    "\n",
    "    del clf\n",
    "    del yPred\n",
    "\n",
    "print('SVM Accuracies - Random Forest Classifier: ')\n",
    "print('Linear kernal has maximum accuracy - '+ str(round(max(rfc_accuracy['linear']),4)) + ' for critical factor ' + str(c_list[rfc_accuracy['linear'].index(max(rfc_accuracy['linear']))]) )\n",
    "print('\\nRadial Basis Function Kernel SVM accuracy - '+ str(round(max(rfc_accuracy['rbf']),4)) + ' for critical factor ' + str(c_list[rfc_accuracy['rbf'].index(max(rfc_accuracy['rbf']))]) )\n",
    "print('\\nPolynomial Kernel SVM has maximum accuracy - ' + str(round(max(rfc_accuracy['poly']),4)) + ' for critical factor ' + str(c_list[rfc_accuracy['poly'].index(max(rfc_accuracy['poly']))]))\n",
    "print('\\nSigmoid Kernel SVM has maximum accuracy - ' + str(round(max(rfc_accuracy['sigmoid']),4)) + ' for critical factor ' + str(c_list[rfc_accuracy['sigmoid'].index(max(rfc_accuracy['sigmoid']))]) +'\\n\\n')\n",
    "\n",
    "# Plot the Accuracy with C values\n",
    "fig = plt.figure(1)\n",
    "fig.patch.set_facecolor('white')\n",
    "plt.xscale('log')\n",
    "plt.title('Kernal SVM (Random Forest Classifier)')\n",
    "plt.xlabel('Critical Factor')\n",
    "plt.ylabel('Model Accuracy')\n",
    "plt.plot(c_list, rfc_accuracy['linear'], 'r', label = 'Linear')\n",
    "plt.plot(c_list, rfc_accuracy['rbf'], 'g', label = 'Radial Basis')\n",
    "plt.plot(c_list, rfc_accuracy['poly'], 'b', label = 'Polynomial')\n",
    "plt.plot(c_list, rfc_accuracy['sigmoid'], 'y', label = 'Sigmoid')\n",
    "plt.legend(bbox_to_anchor = (0., 1.02, 1., .202), loc = 10, ncol=4, borderaxespad = 0)\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "HFv4Wmrja0Tw"
   },
   "source": [
    "### Best SVM model\n",
    "\n",
    "Feature Selection - PCA and Random forest - equally good  \n",
    "SVM Kernel - Linear SVM  \n",
    "Regularization parameter - 10^-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 445
    },
    "colab_type": "code",
    "id": "Q8Et8-5Jd50P",
    "outputId": "3a5b1712-952e-431d-caad-09552cccd716"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy for SVM - Linear Kernal -  0.7353\n",
      "\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           1       0.70      0.96      0.81        74\n",
      "           2       0.75      0.69      0.72        13\n",
      "           3       1.00      1.00      1.00         4\n",
      "           4       0.60      0.75      0.67         4\n",
      "           5       1.00      0.25      0.40         4\n",
      "           6       0.00      0.00      0.00         8\n",
      "           7       0.00      0.00      0.00         1\n",
      "           8       0.00      0.00      0.00         1\n",
      "           9       1.00      0.67      0.80         3\n",
      "          10       1.00      0.67      0.80        15\n",
      "          14       0.00      0.00      0.00         1\n",
      "          15       0.00      0.00      0.00         1\n",
      "          16       0.00      0.00      0.00         7\n",
      "\n",
      "    accuracy                           0.74       136\n",
      "   macro avg       0.47      0.38      0.40       136\n",
      "weighted avg       0.66      0.74      0.68       136\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/sklearn/metrics/_classification.py:1272: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n"
     ]
    }
   ],
   "source": [
    "#Assign the best values for the SVM parameter\n",
    "clf = SVC(max_iter=100000, kernel='linear', C=0.01)\n",
    "\n",
    "clf.fit(X_train_pca, Y_train)\n",
    "\n",
    "yPred_svm = clf.predict(X_test_pca)\n",
    "\n",
    "acc = accuracy_score(yPred_svm,Y_test)\n",
    "print('Accuracy for SVM - Linear Kernal - ',round(acc,4))\n",
    "\n",
    "result = classification_report(Y_test, yPred_svm)\n",
    "print(\"\\n\",result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "x4-jm3tDWfXX"
   },
   "source": [
    "### KNN implementation using Euclidean distance\n",
    "K Nearest Neighbours is simple approach to of classification where each object is classified based majority class of its k nearest neighbours. Identifying the nearest neighbours is done by finding the distance between the a node with respect to all its neighbours using **Euclidean distance**.  \n",
    "\n",
    "Since kNN is sensitive to irrelevant and redundant features, we will considering the Feature selection dataframes to train and test the kNN model. We have split the data as test and train befor feature selection and we cannout use kfold validation with kNN.\n",
    "\n",
    "In kNN hyperparameter to be tuned is **k value of neighbours**. The result from model displays the accuracy with different values to k.  \n",
    "\n",
    "Below is kNN method from scratch without the standard libraries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ZwIkiRk9tix6"
   },
   "outputs": [],
   "source": [
    "# kNN with Euclidean distance returns distance between \n",
    "def knn(testdata,k,post_train_array,class_array):\n",
    "  dictionary = {}\n",
    "  \n",
    "  # Using Euclidean distance to compute the distance between the 2 vectors.\n",
    "  for cnt,i in enumerate(post_train_array):\n",
    "    c = math.sqrt(sum([(i[val] - testdata[val])**2 for val in range(len(i))]))\n",
    "    dictionary[cnt] = [c,class_array[cnt]]\n",
    "  \n",
    "  \n",
    "\n",
    "  # Sorting the counts in decreaing order and selecting the top k values from the list\n",
    "  sorted_d = sorted(dictionary.items(), key=lambda x: x[1])\n",
    "  required = sorted_d[0:k]\n",
    "  preddic = {}\n",
    "  for i in required:\n",
    "    j = i\n",
    "    class_values = j[1][1]\n",
    "    if j[1][1] not in preddic:\n",
    "      preddic[class_values] = 1\n",
    "    else:\n",
    "      preddic[class_values] += 1\n",
    "\n",
    "  #identifying the majority class fromm the selected k values and return class variables.\n",
    "  sorted_d = sorted(preddic.items(), key=operator.itemgetter(1))\n",
    "  sorted_d = sorted_d[::-1]\n",
    "  return sorted_d[0][0]\n",
    "\n",
    "\n",
    "# Hyperparameter tuning for k neighbours\n",
    "def kNN_k_tuning(feature,hyperparameter):\n",
    "  plot_x = []\n",
    "  plot_y = []\n",
    "  \n",
    "  kfoldval = 7\n",
    "  kfdata = KFold(n_splits=kfoldval, shuffle = True)\n",
    "  print(kfoldval,' fold kNN Cross validation Implementation for ',feature,'\\n')\n",
    "\n",
    "  # Compute the kNN for odd-k ranging between 1 - 11 \n",
    "  for k in range(1,13,2):\n",
    "\n",
    "    total_accuracy = 0\n",
    "    for j,i in enumerate(kfdata.split(df_data)):\n",
    "      X_train = np.array(df_data)[i[0]]\n",
    "      X_test = np.array(df_data)[i[1]]\n",
    "      X_train, X_test = pd.DataFrame(X_train),pd.DataFrame(X_test)\n",
    "\n",
    "      Y_train = np.array(df_class)[i[0]]\n",
    "      Y_test = np.array(df_class)[i[1]]\n",
    "      Y_train, Y_test = pd.Series(Y_train),pd.Series(Y_test)\n",
    "\n",
    "      class_array = Y_train.values\n",
    "      test_array = Y_test.values\n",
    "\n",
    "      if feature =='Random Forest':\n",
    "        rfc = SelectFromModel(RandomForestClassifier(n_estimators = hyperparameter, random_state=0, n_jobs = -1))\n",
    "        rfc.fit(X_train, Y_train)\n",
    "        rfc_comp = X_train.columns[(rfc.get_support())]\n",
    "        post_train_array= rfc.transform(X_train)\n",
    "        post_test_array = rfc.transform(X_test) \n",
    "\n",
    "      elif feature =='PCA':\n",
    "        \n",
    "        pca = PCA(n_components=hyperparameter)\n",
    "        post_train_array = pca.fit_transform(X_train)\n",
    "        post_test_array = pca.transform(X_test)\n",
    "\n",
    "      accuracy_count = 0\n",
    "      new_count = 0  \n",
    "    \n",
    "      for i in post_test_array:\n",
    "        m = knn(i,k,post_train_array,class_array)\n",
    "        if m==test_array[new_count]:\n",
    "          accuracy_count+=1\n",
    "        new_count += 1\n",
    "      \n",
    "      percentage = accuracy_count/len(test_array)\n",
    "      total_accuracy += percentage\n",
    "\n",
    "    plot_x.append(k)\n",
    "    plot_y.append(total_accuracy*100/kfoldval)\n",
    "    print(\"\")\n",
    "    print(\"kNN Accuracy with \", feature,\" for k -\",k,\" is \",str(round(total_accuracy*100/kfoldval,4)))\n",
    "    \n",
    "  fig = plt.figure(1)\n",
    "  fig.patch.set_facecolor('white')\n",
    "  plt.title('Accuracy of 7 fold kNN using '+ feature)\n",
    "  plt.xlabel('Values for K')\n",
    "  plt.ylabel('Model Accuracy')\n",
    "  plt.plot(plot_x, plot_y,'b')\n",
    "  fig.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "G0BsWWQl0H7S"
   },
   "source": [
    "### kNN classification with PCA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 533
    },
    "colab_type": "code",
    "id": "JzsJyoAM74kY",
    "outputId": "e81b13da-d9ed-4e6a-b302-699ad6070fd0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7  fold kNN Cross validation Implementation for  PCA \n",
      "\n",
      "\n",
      "kNN Accuracy with  PCA  for k - 1  is  56.8441\n",
      "\n",
      "kNN Accuracy with  PCA  for k - 3  is  59.9451\n",
      "\n",
      "kNN Accuracy with  PCA  for k - 5  is  61.2637\n",
      "\n",
      "kNN Accuracy with  PCA  for k - 7  is  58.8462\n",
      "\n",
      "kNN Accuracy with  PCA  for k - 9  is  59.296\n",
      "\n",
      "kNN Accuracy with  PCA  for k - 11  is  58.1937\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_comp = 49\n",
    "kNN_k_tuning('PCA',n_comp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "p4RjnigJM0b6"
   },
   "source": [
    "### kNN classification using Random Forest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 533
    },
    "colab_type": "code",
    "id": "SSe6-ei8MzWe",
    "outputId": "27ff9424-6796-4958-96be-e502c72fdb0f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7  fold kNN Cross validation Implementation for  Random Forest \n",
      "\n",
      "\n",
      "kNN Accuracy with  Random Forest  for k - 1  is  59.9416\n",
      "\n",
      "kNN Accuracy with  Random Forest  for k - 3  is  65.4945\n",
      "\n",
      "kNN Accuracy with  Random Forest  for k - 5  is  64.1861\n",
      "\n",
      "kNN Accuracy with  Random Forest  for k - 7  is  62.6133\n",
      "\n",
      "kNN Accuracy with  Random Forest  for k - 9  is  62.8297\n",
      "\n",
      "kNN Accuracy with  Random Forest  for k - 11  is  63.5165\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_estimators = 20\n",
    "kNN_k_tuning('Random Forest',n_estimators)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "HoQrKzL-mUxF"
   },
   "source": [
    "#### Best model Kfold - KNN Implementation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "qq---AQ_kHL9"
   },
   "source": [
    "## 1D CNN Classification"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "0E6iUiVY-Mob"
   },
   "source": [
    "#### mounting the drive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 120
    },
    "colab_type": "code",
    "id": "3YurbbvT-LsP",
    "outputId": "ddf536a0-dc83-47a4-911f-59f409010ed0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Go to this URL in a browser: https://accounts.google.com/o/oauth2/auth?client_id=947318989803-6bn6qk8qdgf4n4g3pfee6491hc0brc4i.apps.googleusercontent.com&redirect_uri=urn%3aietf%3awg%3aoauth%3a2.0%3aoob&response_type=code&scope=email%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdocs.test%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdrive%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdrive.photos.readonly%20https%3a%2f%2fwww.googleapis.com%2fauth%2fpeopleapi.readonly\n",
      "\n",
      "Enter your authorization code:\n",
      "··········\n",
      "Mounted at /content/drive\n"
     ]
    }
   ],
   "source": [
    "from google.colab import drive\n",
    "drive.mount('/content/drive')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 100
    },
    "colab_type": "code",
    "id": "GN9HYW8hkG2q",
    "outputId": "24474bf3-2a74-4d9a-938e-9f0b84804c89"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(316, 278, 1) (316, 17) (136, 278, 1) (136, 17)\n",
      "[  0 171  31  11  11   9  17   2   1   6  35   0   0   0   3   4  15]\n",
      "[ 0 74 13  4  4  4  8  1  1  3 15  0  0  0  1  1  7]\n",
      "[  0 130  25   9   9   7  13   2   1   6  31   0   0   0   2   4  13]\n",
      "[ 0 41  6  2  2  2  4  0  0  0  4  0  0  0  1  0  2]\n"
     ]
    }
   ],
   "source": [
    "# Split the data into train and validation\n",
    "X_train_cnn, X_val_cnn, Y_train_cnn, Y_val_cnn = train_test_split(X_train, Y_train, test_size=0.2,  random_state=0)\n",
    "\n",
    "Xtrain = np.expand_dims(X_train, 2)\n",
    "Ytrain = to_categorical(Y_train)\n",
    "Xval = np.expand_dims(X_test, 2)\n",
    "Yval = to_categorical(Y_test)\n",
    "print(Xtrain.shape,Ytrain.shape,Xval.shape,Yval.shape)\n",
    "\n",
    "print(np.bincount(Y_train))\n",
    "print(np.bincount(Y_test))\n",
    "print(np.bincount(Y_train_cnn))\n",
    "print(np.bincount(Y_val_cnn))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "O9bZAYWUtDmA"
   },
   "source": [
    "#### Determining class weights for imbalanced dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 70
    },
    "colab_type": "code",
    "id": "0z3RqKCXtDMg",
    "outputId": "dd00c328-9f5c-4cb9-db20-ad953744727c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "66.48389473526794\n",
      "{1: 0.14215024741340532, 2: 0.7841191066997518, 3: 2.2097902097902096, 4: 2.2097902097902096, 5: 2.700854700854701, 6: 1.4298642533936652, 7: 12.153846153846153, 8: 24.307692307692307, 9: 4.051282051282051, 10: 0.6945054945054945, 14: 8.102564102564102, 15: 6.076923076923077, 16: 1.6205128205128205, 0: 0, 11: 0, 12: 0, 13: 0}\n"
     ]
    }
   ],
   "source": [
    "from sklearn.utils import class_weight\n",
    "class_weights = class_weight.compute_class_weight('balanced', np.unique(Y_train), Y_train)\n",
    "class_weights_dict = dict(zip([1,2,3,4,5,6,7,8,9,10,14,15,16], class_weights))\n",
    "class_weights_dict[0] = 0\n",
    "class_weights_dict[11] = 0\n",
    "class_weights_dict[12] = 0\n",
    "class_weights_dict[13] = 0\n",
    "print(class_weights.sum())\n",
    "print(class_weights_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "U3bnEB3kdSZv"
   },
   "source": [
    "### delete model h5 files if experiment useless"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ZCIue9nTdKQx"
   },
   "outputs": [],
   "source": [
    "!rm *.h5;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "q3C4hkHJBF2o"
   },
   "source": [
    "#### Defining Weighted 1D CNN model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 383
    },
    "colab_type": "code",
    "id": "LkFfkxLkeolm",
    "outputId": "1f9a449a-5834-4d17-866c-fb992ac55d60"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_2\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv1d_4 (Conv1D)            (None, 269, 64)           704       \n",
      "_________________________________________________________________\n",
      "conv1d_5 (Conv1D)            (None, 260, 128)          82048     \n",
      "_________________________________________________________________\n",
      "dropout_2 (Dropout)          (None, 260, 128)          0         \n",
      "_________________________________________________________________\n",
      "flatten_2 (Flatten)          (None, 33280)             0         \n",
      "_________________________________________________________________\n",
      "dense_6 (Dense)              (None, 128)               4259968   \n",
      "_________________________________________________________________\n",
      "dense_7 (Dense)              (None, 64)                8256      \n",
      "_________________________________________________________________\n",
      "dense_8 (Dense)              (None, 17)                1105      \n",
      "=================================================================\n",
      "Total params: 4,352,081\n",
      "Trainable params: 4,352,081\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "#model\n",
    "model = Sequential()\n",
    "\n",
    "model.add(Conv1D(filters=64, kernel_size=10,activation='relu',kernel_initializer='he_uniform', input_shape=(278,1)))\n",
    "model.add(Conv1D(filters=128, kernel_size=10,activation='relu',kernel_initializer='he_uniform'))\n",
    "model.add(Dropout(0.3))\n",
    "model.add(Flatten())\n",
    "model.add(Dense(128, activation='relu'))\n",
    "model.add(Dense(64, activation='relu'))\n",
    "model.add(Dense(17, activation='softmax'))\n",
    "model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\n",
    "\n",
    "model.summary()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "coPw3NZ54_18"
   },
   "source": [
    "#### train the model and save best validation accuracy checkpoint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "colab_type": "code",
    "id": "8ZA0RPeVudyb",
    "outputId": "d3b66621-299e-4489-82b7-9d194a97ef66"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      "20/20 [==============================] - ETA: 0s - loss: 4.0992 - accuracy: 0.1994\n",
      "Epoch 00001: val_accuracy improved from -inf to 0.51471, saving model to model-epoch-001-valacc-0.514706.h5\n",
      "20/20 [==============================] - 2s 103ms/step - loss: 4.0992 - accuracy: 0.1994 - val_loss: 2.6113 - val_accuracy: 0.5147\n",
      "Epoch 2/20\n",
      "20/20 [==============================] - ETA: 0s - loss: 2.0121 - accuracy: 0.6139\n",
      "Epoch 00002: val_accuracy did not improve from 0.51471\n",
      "20/20 [==============================] - 2s 94ms/step - loss: 2.0121 - accuracy: 0.6139 - val_loss: 2.0967 - val_accuracy: 0.2794\n",
      "Epoch 3/20\n",
      "20/20 [==============================] - ETA: 0s - loss: 0.9706 - accuracy: 0.5538\n",
      "Epoch 00003: val_accuracy did not improve from 0.51471\n",
      "20/20 [==============================] - 2s 92ms/step - loss: 0.9706 - accuracy: 0.5538 - val_loss: 2.1444 - val_accuracy: 0.4118\n",
      "Epoch 4/20\n",
      "20/20 [==============================] - ETA: 0s - loss: 0.5303 - accuracy: 0.7500\n",
      "Epoch 00004: val_accuracy did not improve from 0.51471\n",
      "20/20 [==============================] - 2s 92ms/step - loss: 0.5303 - accuracy: 0.7500 - val_loss: 2.2720 - val_accuracy: 0.4559\n",
      "Epoch 5/20\n",
      "20/20 [==============================] - ETA: 0s - loss: 0.3105 - accuracy: 0.7658\n",
      "Epoch 00005: val_accuracy did not improve from 0.51471\n",
      "20/20 [==============================] - 2s 92ms/step - loss: 0.3105 - accuracy: 0.7658 - val_loss: 2.1369 - val_accuracy: 0.4412\n",
      "Epoch 6/20\n",
      "20/20 [==============================] - ETA: 0s - loss: 0.1557 - accuracy: 0.8291\n",
      "Epoch 00006: val_accuracy improved from 0.51471 to 0.58088, saving model to model-epoch-006-valacc-0.580882.h5\n",
      "20/20 [==============================] - 2s 96ms/step - loss: 0.1557 - accuracy: 0.8291 - val_loss: 2.1868 - val_accuracy: 0.5809\n",
      "Epoch 7/20\n",
      "20/20 [==============================] - ETA: 0s - loss: 0.0674 - accuracy: 0.9589\n",
      "Epoch 00007: val_accuracy did not improve from 0.58088\n",
      "20/20 [==============================] - 2s 94ms/step - loss: 0.0674 - accuracy: 0.9589 - val_loss: 2.2295 - val_accuracy: 0.5588\n",
      "Epoch 8/20\n",
      "20/20 [==============================] - ETA: 0s - loss: 0.0450 - accuracy: 0.9209\n",
      "Epoch 00008: val_accuracy improved from 0.58088 to 0.58824, saving model to model-epoch-008-valacc-0.588235.h5\n",
      "20/20 [==============================] - 2s 96ms/step - loss: 0.0450 - accuracy: 0.9209 - val_loss: 2.1836 - val_accuracy: 0.5882\n",
      "Epoch 9/20\n",
      "20/20 [==============================] - ETA: 0s - loss: 0.0254 - accuracy: 0.9810\n",
      "Epoch 00009: val_accuracy improved from 0.58824 to 0.59559, saving model to model-epoch-009-valacc-0.595588.h5\n",
      "20/20 [==============================] - 2s 100ms/step - loss: 0.0254 - accuracy: 0.9810 - val_loss: 2.3683 - val_accuracy: 0.5956\n",
      "Epoch 10/20\n",
      "20/20 [==============================] - ETA: 0s - loss: 0.0210 - accuracy: 0.9620\n",
      "Epoch 00010: val_accuracy improved from 0.59559 to 0.66176, saving model to model-epoch-010-valacc-0.661765.h5\n",
      "20/20 [==============================] - 2s 99ms/step - loss: 0.0210 - accuracy: 0.9620 - val_loss: 2.6637 - val_accuracy: 0.6618\n",
      "Epoch 11/20\n",
      "20/20 [==============================] - ETA: 0s - loss: 0.0070 - accuracy: 0.9968\n",
      "Epoch 00011: val_accuracy did not improve from 0.66176\n",
      "20/20 [==============================] - 2s 92ms/step - loss: 0.0070 - accuracy: 0.9968 - val_loss: 2.3179 - val_accuracy: 0.6324\n",
      "Epoch 12/20\n",
      "20/20 [==============================] - ETA: 0s - loss: 0.0040 - accuracy: 0.9968\n",
      "Epoch 00012: val_accuracy did not improve from 0.66176\n",
      "20/20 [==============================] - 2s 93ms/step - loss: 0.0040 - accuracy: 0.9968 - val_loss: 2.4955 - val_accuracy: 0.6544\n",
      "Epoch 13/20\n",
      "20/20 [==============================] - ETA: 0s - loss: 0.0023 - accuracy: 1.0000\n",
      "Epoch 00013: val_accuracy did not improve from 0.66176\n",
      "20/20 [==============================] - 2s 92ms/step - loss: 0.0023 - accuracy: 1.0000 - val_loss: 2.5803 - val_accuracy: 0.6544\n",
      "Epoch 14/20\n",
      "20/20 [==============================] - ETA: 0s - loss: 0.0014 - accuracy: 1.0000\n",
      "Epoch 00014: val_accuracy did not improve from 0.66176\n",
      "20/20 [==============================] - 2s 92ms/step - loss: 0.0014 - accuracy: 1.0000 - val_loss: 2.6713 - val_accuracy: 0.6618\n",
      "Epoch 15/20\n",
      "20/20 [==============================] - ETA: 0s - loss: 0.0012 - accuracy: 1.0000\n",
      "Epoch 00015: val_accuracy did not improve from 0.66176\n",
      "20/20 [==============================] - 2s 91ms/step - loss: 0.0012 - accuracy: 1.0000 - val_loss: 2.7561 - val_accuracy: 0.6618\n",
      "Epoch 16/20\n",
      "20/20 [==============================] - ETA: 0s - loss: 0.0011 - accuracy: 1.0000\n",
      "Epoch 00016: val_accuracy improved from 0.66176 to 0.66912, saving model to model-epoch-016-valacc-0.669118.h5\n",
      "20/20 [==============================] - 2s 98ms/step - loss: 0.0011 - accuracy: 1.0000 - val_loss: 2.8019 - val_accuracy: 0.6691\n",
      "Epoch 17/20\n",
      "20/20 [==============================] - ETA: 0s - loss: 7.7756e-04 - accuracy: 1.0000\n",
      "Epoch 00017: val_accuracy did not improve from 0.66912\n",
      "20/20 [==============================] - 2s 94ms/step - loss: 7.7756e-04 - accuracy: 1.0000 - val_loss: 2.8241 - val_accuracy: 0.6691\n",
      "Epoch 18/20\n",
      "20/20 [==============================] - ETA: 0s - loss: 8.1930e-04 - accuracy: 1.0000\n",
      "Epoch 00018: val_accuracy did not improve from 0.66912\n",
      "20/20 [==============================] - 2s 94ms/step - loss: 8.1930e-04 - accuracy: 1.0000 - val_loss: 2.8774 - val_accuracy: 0.6691\n",
      "Epoch 19/20\n",
      "20/20 [==============================] - ETA: 0s - loss: 6.8462e-04 - accuracy: 1.0000\n",
      "Epoch 00019: val_accuracy did not improve from 0.66912\n",
      "20/20 [==============================] - 2s 92ms/step - loss: 6.8462e-04 - accuracy: 1.0000 - val_loss: 2.9063 - val_accuracy: 0.6691\n",
      "Epoch 20/20\n",
      "20/20 [==============================] - ETA: 0s - loss: 5.4684e-04 - accuracy: 1.0000\n",
      "Epoch 00020: val_accuracy did not improve from 0.66912\n",
      "20/20 [==============================] - 2s 93ms/step - loss: 5.4684e-04 - accuracy: 1.0000 - val_loss: 2.9181 - val_accuracy: 0.6691\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping\n",
    "batch_size= 16\n",
    "no_epochs = 20\n",
    "\n",
    "earlystop = EarlyStopping(monitor='val_accuracy', patience=20)\n",
    "checkpoint = ModelCheckpoint('model-epoch-{epoch:03d}-valacc-{val_accuracy:03f}.h5', verbose=1, monitor='val_accuracy',save_best_only=True, mode='auto')\n",
    "\n",
    "# Generate the fit model\n",
    "hist = model.fit(Xtrain, Ytrain, \n",
    "                 epochs=no_epochs, \n",
    "                 batch_size=batch_size, \n",
    "                 validation_data=(Xval, Yval),\n",
    "                 callbacks=[earlystop, checkpoint],\n",
    "                 class_weight = class_weights_dict)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "-KJ5cQk-IxdY"
   },
   "outputs": [],
   "source": [
    "!cp model-epoch-010-valacc-0.661765.h5 /content/drive/Shared\\ drives/ALDA\\ Project/ClassWeights/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "-n5hUp7vNI2J"
   },
   "source": [
    "#### Visualizing training and validation accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 541
    },
    "colab_type": "code",
    "id": "VHtGzd6mNOxd",
    "outputId": "4379b0f4-9471-4b32-c7bf-652def085abd"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sub=0\n",
    "# visualizing losses and accuracy\n",
    "train_loss = hist.history['loss'][sub:]\n",
    "val_loss = hist.history['val_loss'][sub:]\n",
    "train_accu = hist.history['accuracy'][sub:]\n",
    "val_accu = hist.history['val_accuracy'][sub:]\n",
    "xc = range(len(val_loss))\n",
    "\n",
    "fig1 = plt.figure()\n",
    "fig1.patch.set_facecolor('white')\n",
    "plt.plot(xc, train_loss, label='Training loss')\n",
    "plt.plot(xc, val_loss, label='Validation loss')\n",
    "plt.legend(loc=\"upper right\")\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Loss')\n",
    "fig1.show()\n",
    "\n",
    "fig2 = plt.figure()\n",
    "fig2.patch.set_facecolor('white')\n",
    "plt.plot(xc, train_accu, label='Training accuracy')\n",
    "plt.plot(xc, val_accu, label='Validation accuracy')\n",
    "plt.legend(loc=\"lower right\")\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Accuracy')\n",
    "fig2.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "bQbKuDf6LN2O"
   },
   "source": [
    "### Test Model on the test data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 50
    },
    "colab_type": "code",
    "id": "hVeoZK5x23yV",
    "outputId": "8dd46f10-d058-4a11-82b0-49dc0f25027e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0 97 13  5  3  2  3  0  0  2 10  0  0  0  0  0  1]\n",
      "[ 0 74 13  4  4  4  8  1  1  3 15  0  0  0  1  1  7]\n"
     ]
    }
   ],
   "source": [
    "!cp /content/drive/Shared\\ drives/ALDA\\ Project/ClassWeights/model-epoch-008-valacc-0.698529.h5 /content/\n",
    "\n",
    "from sklearn.metrics import confusion_matrix, accuracy_score, classification_report\n",
    "from tensorflow import keras\n",
    "\n",
    "model = keras.models.load_model('model-epoch-008-valacc-0.698529.h5')\n",
    "model.load_weights('model-epoch-008-valacc-0.698529.h5')\n",
    "\n",
    "model.save('model-epoch-008-valacc-0.698529.h5')\n",
    "\n",
    "Ypred = model.predict_classes(np.expand_dims(X_test, 2), batch_size=16)\n",
    "print(np.bincount(Ypred))\n",
    "print(np.bincount(Y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 453
    },
    "colab_type": "code",
    "id": "HUU6YQ76-rBT",
    "outputId": "737d61d1-f732-48c1-a032-68f4bf4fd050"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of Weighted 1D-CNN model -  0.6985\n",
      "\n",
      "Classification Report for model\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           1       0.70      0.92      0.80        74\n",
      "           2       0.54      0.54      0.54        13\n",
      "           3       0.80      1.00      0.89         4\n",
      "           4       1.00      0.75      0.86         4\n",
      "           5       0.50      0.25      0.33         4\n",
      "           6       0.67      0.25      0.36         8\n",
      "           7       0.00      0.00      0.00         1\n",
      "           8       0.00      0.00      0.00         1\n",
      "           9       1.00      0.67      0.80         3\n",
      "          10       0.80      0.53      0.64        15\n",
      "          14       0.00      0.00      0.00         1\n",
      "          15       0.00      0.00      0.00         1\n",
      "          16       0.00      0.00      0.00         7\n",
      "\n",
      "    accuracy                           0.70       136\n",
      "   macro avg       0.46      0.38      0.40       136\n",
      "weighted avg       0.65      0.70      0.66       136\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/sklearn/metrics/_classification.py:1272: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n"
     ]
    }
   ],
   "source": [
    "# Compute Confusion matrix and accuracy score\n",
    "print('Accuracy of Weighted 1D-CNN model - ',round(accuracy_score(list(Y_test),Ypred),4))\n",
    "print('\\nClassification Report for model\\n',classification_report(list(Y_test), Ypred))\n",
    "\n",
    "#saving the predictions and probabilities to the Shared directory\n",
    "np.save('ypred_probs_0.6985294117647058.npy', Ypred)\n",
    "!cp *.npy /content/drive/Shared\\ drives/ALDA\\ Project/ClassWeights/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "pw5Unmy6swKh"
   },
   "source": [
    "### MLP(Multi Layer Perceptron) Classifier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "a5nFZrho3u40"
   },
   "source": [
    "#### Split the data into train and validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 33
    },
    "colab_type": "code",
    "id": "X0rbr8-fm8Cu",
    "outputId": "f7aa4d1e-304f-476e-da69-72477d4c82c0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(316, 278) (316, 17) (136, 278) (136, 17)\n"
     ]
    }
   ],
   "source": [
    "X_train_mlp, X_val_mlp, Y_train_mlp, Y_val_mlp = train_test_split(X_train, Y_train, test_size=0.2,  random_state=0)\n",
    "\n",
    "Xtrain = np.array(X_train)\n",
    "Ytrain = to_categorical(Y_train)\n",
    "Xval = np.array(X_test)\n",
    "Yval = to_categorical(Y_test)\n",
    "print(Xtrain.shape,Ytrain.shape,Xval.shape,Yval.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "TGGLsb3MKPxO"
   },
   "source": [
    "#### Determining class weights for imbalanced dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 70
    },
    "colab_type": "code",
    "id": "qyg16zZYKPxw",
    "outputId": "55393953-7aad-498c-83f5-3c14103bc893"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "66.48389473526794\n",
      "{1: 0.14215024741340532, 2: 0.7841191066997518, 3: 2.2097902097902096, 4: 2.2097902097902096, 5: 2.700854700854701, 6: 1.4298642533936652, 7: 12.153846153846153, 8: 24.307692307692307, 9: 4.051282051282051, 10: 0.6945054945054945, 14: 8.102564102564102, 15: 6.076923076923077, 16: 1.6205128205128205, 0: 0, 11: 0, 12: 0, 13: 0}\n"
     ]
    }
   ],
   "source": [
    "from sklearn.utils import class_weight\n",
    "mlp_class_weights = class_weight.compute_class_weight('balanced', np.unique(Y_train), Y_train)\n",
    "mlp_class_weights_dict = dict(zip([1,2,3,4,5,6,7,8,9,10,14,15,16], mlp_class_weights))\n",
    "mlp_class_weights_dict[0] = 0\n",
    "mlp_class_weights_dict[11] = 0\n",
    "mlp_class_weights_dict[12] = 0\n",
    "mlp_class_weights_dict[13] = 0\n",
    "print(mlp_class_weights.sum())\n",
    "print(mlp_class_weights_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "lyUXzs-_Oyu6"
   },
   "source": [
    "### delete model h5 files if experiment useless"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "UGds9lYMOyvA"
   },
   "outputs": [],
   "source": [
    "!rm *.h5;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "5Jil-2C5OyvG"
   },
   "source": [
    "#### Defining MLP model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 250
    },
    "colab_type": "code",
    "id": "BjjVREXiOyvG",
    "outputId": "d4fac68a-c112-4efd-f74e-3751404b8a35"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_4\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "dense_12 (Dense)             (None, 64)                17856     \n",
      "_________________________________________________________________\n",
      "dense_13 (Dense)             (None, 128)               8320      \n",
      "_________________________________________________________________\n",
      "dense_14 (Dense)             (None, 17)                2193      \n",
      "=================================================================\n",
      "Total params: 28,369\n",
      "Trainable params: 28,369\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "#model\n",
    "model = Sequential()\n",
    "\n",
    "model.add(Dense(units=64,activation='relu',input_shape=(278,)))\n",
    "model.add(Dense(units=128,activation='relu'))\n",
    "model.add(Dense(17, activation='softmax'))\n",
    "model.compile(loss='categorical_crossentropy',\n",
    "              optimizer='Adam',\n",
    "             metrics=['accuracy'])\n",
    "\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "fmJSKC7rVUmG"
   },
   "source": [
    "#### train the model and save best validation accuracy checkpoint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "colab_type": "code",
    "id": "jBH9Y9YFVUmL",
    "outputId": "dc7487ef-bc6a-4784-80bd-55429dcb3a51"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/30\n",
      "33/40 [=======================>......] - ETA: 0s - loss: 2.8751 - accuracy: 0.1439    \n",
      "Epoch 00001: val_accuracy improved from -inf to 0.22059, saving model to model-mlp-epoch-001-valacc-0.220588.h5\n",
      "40/40 [==============================] - 0s 5ms/step - loss: 2.7804 - accuracy: 0.1424 - val_loss: 2.3965 - val_accuracy: 0.2206\n",
      "Epoch 2/30\n",
      "33/40 [=======================>......] - ETA: 0s - loss: 1.7659 - accuracy: 0.3523\n",
      "Epoch 00002: val_accuracy improved from 0.22059 to 0.32353, saving model to model-mlp-epoch-002-valacc-0.323529.h5\n",
      "40/40 [==============================] - 0s 3ms/step - loss: 1.6753 - accuracy: 0.3513 - val_loss: 2.1231 - val_accuracy: 0.3235\n",
      "Epoch 3/30\n",
      "33/40 [=======================>......] - ETA: 0s - loss: 1.2188 - accuracy: 0.5189\n",
      "Epoch 00003: val_accuracy improved from 0.32353 to 0.44853, saving model to model-mlp-epoch-003-valacc-0.448529.h5\n",
      "40/40 [==============================] - 0s 4ms/step - loss: 1.1182 - accuracy: 0.5380 - val_loss: 1.8545 - val_accuracy: 0.4485\n",
      "Epoch 4/30\n",
      "33/40 [=======================>......] - ETA: 0s - loss: 0.7652 - accuracy: 0.6288\n",
      "Epoch 00004: val_accuracy improved from 0.44853 to 0.48529, saving model to model-mlp-epoch-004-valacc-0.485294.h5\n",
      "40/40 [==============================] - 0s 3ms/step - loss: 0.7217 - accuracy: 0.6361 - val_loss: 1.6786 - val_accuracy: 0.4853\n",
      "Epoch 5/30\n",
      "34/40 [========================>.....] - ETA: 0s - loss: 0.4789 - accuracy: 0.7279\n",
      "Epoch 00005: val_accuracy improved from 0.48529 to 0.51471, saving model to model-mlp-epoch-005-valacc-0.514706.h5\n",
      "40/40 [==============================] - 0s 3ms/step - loss: 0.5014 - accuracy: 0.7089 - val_loss: 1.6207 - val_accuracy: 0.5147\n",
      "Epoch 6/30\n",
      "32/40 [=======================>......] - ETA: 0s - loss: 0.3725 - accuracy: 0.7422\n",
      "Epoch 00006: val_accuracy improved from 0.51471 to 0.54412, saving model to model-mlp-epoch-006-valacc-0.544118.h5\n",
      "40/40 [==============================] - 0s 3ms/step - loss: 0.3671 - accuracy: 0.7500 - val_loss: 1.5530 - val_accuracy: 0.5441\n",
      "Epoch 7/30\n",
      "34/40 [========================>.....] - ETA: 0s - loss: 0.2730 - accuracy: 0.7941\n",
      "Epoch 00007: val_accuracy improved from 0.54412 to 0.59559, saving model to model-mlp-epoch-007-valacc-0.595588.h5\n",
      "40/40 [==============================] - 0s 3ms/step - loss: 0.2735 - accuracy: 0.7911 - val_loss: 1.4905 - val_accuracy: 0.5956\n",
      "Epoch 8/30\n",
      "35/40 [=========================>....] - ETA: 0s - loss: 0.2129 - accuracy: 0.8500\n",
      "Epoch 00008: val_accuracy did not improve from 0.59559\n",
      "40/40 [==============================] - 0s 3ms/step - loss: 0.2137 - accuracy: 0.8418 - val_loss: 1.5026 - val_accuracy: 0.5882\n",
      "Epoch 9/30\n",
      "36/40 [==========================>...] - ETA: 0s - loss: 0.1687 - accuracy: 0.8958\n",
      "Epoch 00009: val_accuracy did not improve from 0.59559\n",
      "40/40 [==============================] - 0s 3ms/step - loss: 0.1697 - accuracy: 0.8766 - val_loss: 1.4571 - val_accuracy: 0.5956\n",
      "Epoch 10/30\n",
      "32/40 [=======================>......] - ETA: 0s - loss: 0.1306 - accuracy: 0.9062\n",
      "Epoch 00010: val_accuracy improved from 0.59559 to 0.60294, saving model to model-mlp-epoch-010-valacc-0.602941.h5\n",
      "40/40 [==============================] - 0s 3ms/step - loss: 0.1426 - accuracy: 0.8987 - val_loss: 1.4985 - val_accuracy: 0.6029\n",
      "Epoch 11/30\n",
      "34/40 [========================>.....] - ETA: 0s - loss: 0.1128 - accuracy: 0.8971\n",
      "Epoch 00011: val_accuracy did not improve from 0.60294\n",
      "40/40 [==============================] - 0s 3ms/step - loss: 0.1124 - accuracy: 0.9019 - val_loss: 1.4452 - val_accuracy: 0.6029\n",
      "Epoch 12/30\n",
      "33/40 [=======================>......] - ETA: 0s - loss: 0.0929 - accuracy: 0.9432\n",
      "Epoch 00012: val_accuracy did not improve from 0.60294\n",
      "40/40 [==============================] - 0s 3ms/step - loss: 0.0917 - accuracy: 0.9304 - val_loss: 1.4796 - val_accuracy: 0.5882\n",
      "Epoch 13/30\n",
      "33/40 [=======================>......] - ETA: 0s - loss: 0.0779 - accuracy: 0.9470\n",
      "Epoch 00013: val_accuracy improved from 0.60294 to 0.62500, saving model to model-mlp-epoch-013-valacc-0.625000.h5\n",
      "40/40 [==============================] - 0s 3ms/step - loss: 0.0756 - accuracy: 0.9462 - val_loss: 1.4680 - val_accuracy: 0.6250\n",
      "Epoch 14/30\n",
      "35/40 [=========================>....] - ETA: 0s - loss: 0.0645 - accuracy: 0.9464\n",
      "Epoch 00014: val_accuracy improved from 0.62500 to 0.63971, saving model to model-mlp-epoch-014-valacc-0.639706.h5\n",
      "40/40 [==============================] - 0s 3ms/step - loss: 0.0633 - accuracy: 0.9462 - val_loss: 1.4805 - val_accuracy: 0.6397\n",
      "Epoch 15/30\n",
      "33/40 [=======================>......] - ETA: 0s - loss: 0.0541 - accuracy: 0.9470\n",
      "Epoch 00015: val_accuracy did not improve from 0.63971\n",
      "40/40 [==============================] - 0s 3ms/step - loss: 0.0540 - accuracy: 0.9494 - val_loss: 1.4901 - val_accuracy: 0.6324\n",
      "Epoch 16/30\n",
      "34/40 [========================>.....] - ETA: 0s - loss: 0.0457 - accuracy: 0.9632\n",
      "Epoch 00016: val_accuracy improved from 0.63971 to 0.64706, saving model to model-mlp-epoch-016-valacc-0.647059.h5\n",
      "40/40 [==============================] - 0s 3ms/step - loss: 0.0462 - accuracy: 0.9684 - val_loss: 1.5020 - val_accuracy: 0.6471\n",
      "Epoch 17/30\n",
      "34/40 [========================>.....] - ETA: 0s - loss: 0.0379 - accuracy: 0.9669\n",
      "Epoch 00017: val_accuracy did not improve from 0.64706\n",
      "40/40 [==============================] - 0s 3ms/step - loss: 0.0403 - accuracy: 0.9652 - val_loss: 1.5295 - val_accuracy: 0.6397\n",
      "Epoch 18/30\n",
      "33/40 [=======================>......] - ETA: 0s - loss: 0.0335 - accuracy: 0.9735\n",
      "Epoch 00018: val_accuracy did not improve from 0.64706\n",
      "40/40 [==============================] - 0s 3ms/step - loss: 0.0347 - accuracy: 0.9778 - val_loss: 1.5405 - val_accuracy: 0.6471\n",
      "Epoch 19/30\n",
      "34/40 [========================>.....] - ETA: 0s - loss: 0.0287 - accuracy: 0.9816\n",
      "Epoch 00019: val_accuracy improved from 0.64706 to 0.65441, saving model to model-mlp-epoch-019-valacc-0.654412.h5\n",
      "40/40 [==============================] - 0s 3ms/step - loss: 0.0304 - accuracy: 0.9747 - val_loss: 1.5717 - val_accuracy: 0.6544\n",
      "Epoch 20/30\n",
      "27/40 [===================>..........] - ETA: 0s - loss: 0.0242 - accuracy: 0.9861\n",
      "Epoch 00020: val_accuracy did not improve from 0.65441\n",
      "40/40 [==============================] - 0s 3ms/step - loss: 0.0266 - accuracy: 0.9842 - val_loss: 1.5956 - val_accuracy: 0.6471\n",
      "Epoch 21/30\n",
      "36/40 [==========================>...] - ETA: 0s - loss: 0.0240 - accuracy: 0.9792\n",
      "Epoch 00021: val_accuracy improved from 0.65441 to 0.66176, saving model to model-mlp-epoch-021-valacc-0.661765.h5\n",
      "40/40 [==============================] - 0s 3ms/step - loss: 0.0234 - accuracy: 0.9810 - val_loss: 1.6128 - val_accuracy: 0.6618\n",
      "Epoch 22/30\n",
      "36/40 [==========================>...] - ETA: 0s - loss: 0.0207 - accuracy: 0.9896\n",
      "Epoch 00022: val_accuracy did not improve from 0.66176\n",
      "40/40 [==============================] - 0s 3ms/step - loss: 0.0207 - accuracy: 0.9905 - val_loss: 1.6466 - val_accuracy: 0.6397\n",
      "Epoch 23/30\n",
      "34/40 [========================>.....] - ETA: 0s - loss: 0.0177 - accuracy: 0.9853\n",
      "Epoch 00023: val_accuracy did not improve from 0.66176\n",
      "40/40 [==============================] - 0s 3ms/step - loss: 0.0176 - accuracy: 0.9873 - val_loss: 1.6698 - val_accuracy: 0.6471\n",
      "Epoch 24/30\n",
      "35/40 [=========================>....] - ETA: 0s - loss: 0.0154 - accuracy: 0.9929\n",
      "Epoch 00024: val_accuracy did not improve from 0.66176\n",
      "40/40 [==============================] - 0s 3ms/step - loss: 0.0158 - accuracy: 0.9937 - val_loss: 1.7027 - val_accuracy: 0.6397\n",
      "Epoch 25/30\n",
      "30/40 [=====================>........] - ETA: 0s - loss: 0.0125 - accuracy: 1.0000\n",
      "Epoch 00025: val_accuracy did not improve from 0.66176\n",
      "40/40 [==============================] - 0s 3ms/step - loss: 0.0139 - accuracy: 0.9937 - val_loss: 1.7170 - val_accuracy: 0.6544\n",
      "Epoch 26/30\n",
      "32/40 [=======================>......] - ETA: 0s - loss: 0.0113 - accuracy: 1.0000\n",
      "Epoch 00026: val_accuracy did not improve from 0.66176\n",
      "40/40 [==============================] - 0s 3ms/step - loss: 0.0123 - accuracy: 0.9968 - val_loss: 1.7418 - val_accuracy: 0.6544\n",
      "Epoch 27/30\n",
      "31/40 [======================>.......] - ETA: 0s - loss: 0.0107 - accuracy: 0.9960\n",
      "Epoch 00027: val_accuracy did not improve from 0.66176\n",
      "40/40 [==============================] - 0s 3ms/step - loss: 0.0108 - accuracy: 0.9968 - val_loss: 1.7672 - val_accuracy: 0.6544\n",
      "Epoch 28/30\n",
      "35/40 [=========================>....] - ETA: 0s - loss: 0.0094 - accuracy: 1.0000\n",
      "Epoch 00028: val_accuracy did not improve from 0.66176\n",
      "40/40 [==============================] - 0s 3ms/step - loss: 0.0096 - accuracy: 1.0000 - val_loss: 1.7981 - val_accuracy: 0.6544\n",
      "Epoch 29/30\n",
      "30/40 [=====================>........] - ETA: 0s - loss: 0.0084 - accuracy: 1.0000\n",
      "Epoch 00029: val_accuracy did not improve from 0.66176\n",
      "40/40 [==============================] - 0s 3ms/step - loss: 0.0090 - accuracy: 1.0000 - val_loss: 1.8152 - val_accuracy: 0.6471\n",
      "Epoch 30/30\n",
      "33/40 [=======================>......] - ETA: 0s - loss: 0.0079 - accuracy: 1.0000\n",
      "Epoch 00030: val_accuracy did not improve from 0.66176\n",
      "40/40 [==============================] - 0s 3ms/step - loss: 0.0078 - accuracy: 1.0000 - val_loss: 1.8331 - val_accuracy: 0.6471\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping\n",
    "batch_size= 8\n",
    "no_epochs = 30\n",
    "\n",
    "earlystop = EarlyStopping(monitor='val_accuracy', patience=20)\n",
    "checkpoint = ModelCheckpoint('model-mlp-epoch-{epoch:03d}-valacc-{val_accuracy:03f}.h5', verbose=1, monitor='val_accuracy',save_best_only=True, mode='auto')\n",
    "\n",
    "# Generate the fit model\n",
    "hist = model.fit(Xtrain, Ytrain, \n",
    "                 epochs=no_epochs, \n",
    "                 batch_size=batch_size, \n",
    "                 validation_data=(Xval, Yval),\n",
    "                 callbacks=[earlystop, checkpoint],\n",
    "                 class_weight = mlp_class_weights_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 33
    },
    "colab_type": "code",
    "id": "vJL05vQbuBaT",
    "outputId": "0412bfed-2d2f-4f8a-e3c7-49081cdf37e2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cp: cannot stat 'model-mlp-epoch-019-valacc-0.669118.h5': No such file or directory\n"
     ]
    }
   ],
   "source": [
    "!cp model-mlp-epoch-019-valacc-0.669118.h5 /content/drive/Shared\\ drives/ALDA\\ Project/ClassWeights/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "G6EMhaoJaO4g"
   },
   "source": [
    "#### Visualizing training and validation accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 541
    },
    "colab_type": "code",
    "id": "pqfLJOMmaO4h",
    "outputId": "a7705b34-86b8-4901-f003-5778f197f0f2"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sub=0\n",
    "# visualizing losses and accuracy\n",
    "train_loss = hist.history['loss'][sub:]\n",
    "val_loss = hist.history['val_loss'][sub:]\n",
    "train_accu = hist.history['accuracy'][sub:]\n",
    "val_accu = hist.history['val_accuracy'][sub:]\n",
    "xc = range(no_epochs)\n",
    "\n",
    "fig1 = plt.figure()\n",
    "fig1.patch.set_facecolor('white')\n",
    "plt.plot(xc, train_loss, label='Training loss')\n",
    "plt.plot(xc, val_loss, label='Validation loss')\n",
    "plt.legend(loc=\"upper right\")\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Loss')\n",
    "fig1.show()\n",
    "\n",
    "fig2 = plt.figure()\n",
    "fig2.patch.set_facecolor('white')\n",
    "plt.plot(xc, train_accu, label='Training accuracy')\n",
    "plt.plot(xc, val_accu, label='Validation accuracy')\n",
    "plt.legend(loc=\"lower right\")\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Accuracy')\n",
    "fig2.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "nCHAvVmbupT6"
   },
   "source": [
    "### Test Model on the test data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 120
    },
    "colab_type": "code",
    "id": "5lON3Z5yupT7",
    "outputId": "c8f1375b-11ea-4fd8-9d7c-358dbaeb5516"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-8-398004267ae7>:11: Sequential.predict_classes (from tensorflow.python.keras.engine.sequential) is deprecated and will be removed after 2021-01-01.\n",
      "Instructions for updating:\n",
      "Please use instead:* `np.argmax(model.predict(x), axis=-1)`,   if your model does multi-class classification   (e.g. if it uses a `softmax` last-layer activation).* `(model.predict(x) > 0.5).astype(\"int32\")`,   if your model does binary classification   (e.g. if it uses a `sigmoid` last-layer activation).\n",
      "[ 0 85 15  5  4  3  7  0  0  2  8  0  0  0  1  2  4]\n",
      "[ 0 74 13  4  4  4  8  1  1  3 15  0  0  0  1  1  7]\n"
     ]
    }
   ],
   "source": [
    "!cp /content/drive/Shared\\ drives/ALDA\\ Project/ClassWeights/model-mlp-epoch-019-valacc-0.669118.h5 /content/\n",
    "\n",
    "from sklearn.metrics import confusion_matrix, accuracy_score, classification_report\n",
    "from tensorflow import keras\n",
    "\n",
    "model = keras.models.load_model('model-mlp-epoch-019-valacc-0.669118.h5')\n",
    "model.load_weights('model-mlp-epoch-019-valacc-0.669118.h5')\n",
    "\n",
    "model.save('model-mlp-epoch-019-valacc-0.669118.h5')\n",
    "\n",
    "Ypred = model.predict_classes(X_test, batch_size=16)\n",
    "print(np.bincount(Ypred))\n",
    "print(np.bincount(Y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 453
    },
    "colab_type": "code",
    "id": "NLE3IX_PupT-",
    "outputId": "7cf71bd4-73da-4681-d85a-236f7d85dac9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of Weighted MLP model -  0.6691\n",
      "\n",
      "Classification Report for model\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           1       0.74      0.85      0.79        74\n",
      "           2       0.40      0.46      0.43        13\n",
      "           3       0.80      1.00      0.89         4\n",
      "           4       0.75      0.75      0.75         4\n",
      "           5       0.67      0.50      0.57         4\n",
      "           6       0.43      0.38      0.40         8\n",
      "           7       0.00      0.00      0.00         1\n",
      "           8       0.00      0.00      0.00         1\n",
      "           9       1.00      0.67      0.80         3\n",
      "          10       0.75      0.40      0.52        15\n",
      "          14       1.00      1.00      1.00         1\n",
      "          15       0.50      1.00      0.67         1\n",
      "          16       0.00      0.00      0.00         7\n",
      "\n",
      "    accuracy                           0.67       136\n",
      "   macro avg       0.54      0.54      0.52       136\n",
      "weighted avg       0.65      0.67      0.65       136\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/sklearn/metrics/_classification.py:1272: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n"
     ]
    }
   ],
   "source": [
    "# Compute Confusion matrix and accuracy score\n",
    "print('Accuracy of Weighted MLP model - ',round(accuracy_score(list(Y_test),Ypred),4))\n",
    "cm = confusion_matrix(list(Y_test), Ypred)\n",
    "print('\\nClassification Report for model\\n',classification_report(list(Y_test),Ypred))\n",
    "\n",
    "#saving the predictions and probabilities to the Shared directory\n",
    "np.save('ypred_mlp_probs_0.6691.npy', Ypred)\n",
    "!cp *.npy /content/drive/Shared\\ drives/ALDA\\ Project/ClassWeights/"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "Arrhythmia_Classification .ipynb",
   "provenance": []
  },
  "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": 1
}