CNN_Coronary_Heart_Disease.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CNN using coronary heart disease data "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This work is aiming at the design and testing of a deep neural network architecture on Coronary heart disease using Tensorflow and Keras."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import copy\n",
    "from sklearn import preprocessing\n",
    "import tensorflow as tf\n",
    "from tensorflow import keras\n",
    "import os\n",
    "import pandas as pd\n",
    "from matplotlib import pyplot as plt\n",
    "from numpy.random import seed\n",
    "np.random.seed(2095)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reading the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "./heartDisease/4_CardiacPrediction.xlsx\n",
      "Index(['SEQN', 'Gender', 'Age', 'Annual-Family-Income',\n",
      "       'Ratio-Family-Income-Poverty', 'X60-sec-pulse', 'Systolic', 'Diastolic',\n",
      "       'Weight', 'Height', 'Body-Mass-Index', 'White-Blood-Cells',\n",
      "       'Lymphocyte', 'Monocyte', 'Eosinophils', 'Basophils', 'Red-Blood-Cells',\n",
      "       'Hemoglobin', 'Mean-Cell-Vol', 'Mean-Cell-Hgb-Conc.',\n",
      "       'Mean-cell-Hemoglobin', 'Platelet-count', 'Mean-Platelet-Vol',\n",
      "       'Segmented-Neutrophils', 'Hematocrit', 'Red-Cell-Distribution-Width',\n",
      "       'Albumin', 'ALP', 'AST', 'ALT', 'Cholesterol', 'Creatinine', 'Glucose',\n",
      "       'GGT', 'Iron', 'LDH', 'Phosphorus', 'Bilirubin', 'Protein', 'Uric.Acid',\n",
      "       'Triglycerides', 'Total-Cholesterol', 'HDL', 'Glycohemoglobin',\n",
      "       'Vigorous-work', 'Moderate-work', 'Health-Insurance', 'Diabetes',\n",
      "       'Blood-Rel-Diabetes', 'Blood-Rel-Stroke', 'CoronaryHeartDisease'],\n",
      "      dtype='object')\n"
     ]
    }
   ],
   "source": [
    "# read input file\n",
    "#file = 'E:\\\\Comsats\\\\python\\\\HeartDiseasePrediction\\\\heartDisease\\\\4_CardiacPrediction.xlsx'\n",
    "file = './heartDisease/4_CardiacPrediction.xlsx'\n",
    "print(file) \n",
    "#ipData = pd.read_excel(file, sheet_name='Stroke')\n",
    "#ipData = pd.read_excel(file, sheet_name='CoroHeartDis')\n",
    "ipData = pd.read_excel(file, sheet_name=0)\n",
    "print(ipData.columns) "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Drop variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# data drop\n",
    "opLabel = np.array(ipData['CoronaryHeartDisease'])\n",
    "ipData.drop(['SEQN','CoronaryHeartDisease','Annual-Family-Income','Height','Ratio-Family-Income-Poverty','X60-sec-pulse',\n",
    "          'Health-Insurance','Lymphocyte','Monocyte','Eosinophils','Total-Cholesterol','Mean-Cell-Vol','Mean-Cell-Hgb-Conc.','Hematocrit','Segmented-Neutrophils'], axis = 1, inplace=True)\n",
    "\n",
    "\n",
    "#opLabel = np.array(ipData['Stroke'])\n",
    "#ipData.drop(['SEQN','Stroke','Annual-Family-Income','Height','Ratio-Family-Income-Poverty','X60-sec-pulse',\n",
    "#          'Health-Insurance','Lymphocyte','Monocyte','Eosinophils','Total-Cholesterol','Mean-Cell-Vol','Mean-Cell-Hgb-Conc.','Hematocrit','Segmented-Neutrophils'], axis = 1, inplace=True)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dummy variable for categorical variables\n",
    "ipData = pd.get_dummies(ipData,columns=[\"Gender\",\"Diabetes\",\"Blood-Rel-Diabetes\",\"Blood-Rel-Stroke\",\"Vigorous-work\",\"Moderate-work\"]) \n",
    "\n",
    "varb = np.array(ipData.columns)\n",
    "ipData = np.array(ipData)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(37079, 45)\n",
      "['Age' 'Systolic' 'Diastolic' 'Weight' 'Body-Mass-Index'\n",
      " 'White-Blood-Cells' 'Basophils' 'Red-Blood-Cells' 'Hemoglobin'\n",
      " 'Mean-cell-Hemoglobin' 'Platelet-count' 'Mean-Platelet-Vol'\n",
      " 'Red-Cell-Distribution-Width' 'Albumin' 'ALP' 'AST' 'ALT' 'Cholesterol'\n",
      " 'Creatinine' 'Glucose' 'GGT' 'Iron' 'LDH' 'Phosphorus' 'Bilirubin'\n",
      " 'Protein' 'Uric.Acid' 'Triglycerides' 'HDL' 'Glycohemoglobin' 'Gender_1'\n",
      " 'Gender_2' 'Diabetes_1' 'Diabetes_2' 'Diabetes_3' 'Blood-Rel-Diabetes_1'\n",
      " 'Blood-Rel-Diabetes_2' 'Blood-Rel-Stroke_1' 'Blood-Rel-Stroke_2'\n",
      " 'Vigorous-work_1' 'Vigorous-work_2' 'Vigorous-work_3' 'Moderate-work_1'\n",
      " 'Moderate-work_2' 'Moderate-work_3']\n",
      "35571\n",
      "1508\n"
     ]
    }
   ],
   "source": [
    "print(ipData.shape)\n",
    "print(varb)\n",
    "print(len(opLabel[opLabel==0]))\n",
    "print(len(opLabel[opLabel==1]))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Feature Nomination using LASSO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(45,)\n"
     ]
    }
   ],
   "source": [
    "#Data condensation using LASSO penalty\n",
    "from sklearn.linear_model import Lasso, LogisticRegression\n",
    "\n",
    "\n",
    "featureVote = np.zeros(ipData.shape[1])\n",
    "print(featureVote.shape)\n",
    "\n",
    "iteR = 100\n",
    "\n",
    "for num in range(iteR):\n",
    "    label0_indx = np.where(opLabel==0)[0]   #no coronary heart disease\n",
    "    label1_indx = np.where(opLabel==1)[0]   #coronary heart disease \n",
    "    numTrainData0 = 1300\n",
    "    numTrainData1 = 1300\n",
    "    np.random.shuffle(label0_indx)\n",
    "    np.random.shuffle(label1_indx)\n",
    "    \n",
    "    label0_indx_train = label0_indx[0:numTrainData0-1]\n",
    "    label1_indx_train = label1_indx[0:numTrainData1-1]\n",
    "    label0_indx_test  = label0_indx[numTrainData0-1:]\n",
    "    label1_indx_test  = label1_indx[numTrainData1-1:]\n",
    "    \n",
    "    testIndx  = np.append(label0_indx_test,label1_indx_test)\n",
    "    trainIndx = np.append(label0_indx_train,label1_indx_train)    \n",
    "    trainData  =  ipData[trainIndx]\n",
    "    trainLabel =  opLabel[trainIndx]\n",
    "    testData   =  ipData[testIndx]\n",
    "    testLabel  =  opLabel[testIndx]    \n",
    "    \n",
    "    ##%% data standardization\n",
    "    scaler = preprocessing.StandardScaler().fit(trainData)\n",
    "    trainData_scaled = scaler.transform(trainData)\n",
    "    testData_scaled  = scaler.transform(testData)\n",
    "    \n",
    "    ##%% Elastic net and Lasso from scikit\n",
    "    #regr = ElasticNet(random_state=0, alpha=1, l1_ratio=0.03, tol=0.000001, max_iter=100000)\n",
    "    regr = Lasso(random_state=0, alpha=0.006, tol=0.000001, max_iter=100000)\n",
    "    #regr = LogisticRegression(penalty='l1',random_state=0,C=100,tol=0.000001,max_iter=100,class_weight='balanced')\n",
    "    regr.fit(trainData_scaled, trainLabel)\n",
    "    cof = np.abs(regr.coef_)    \n",
    "    colIndx = np.where(cof != 0)[0]\n",
    "    for col in colIndx:\n",
    "        featureVote[col]+=1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[100.  33.  82.  39.  14.  91.  50.  67.   9.  19. 100.  49. 100.  47.\n",
      "  26.  24.   9. 100.  88.  14.  36.  33. 100.  24.  47.  25. 100.  99.\n",
      "  96.  95. 100.  59.  86.  73.   5.  87.  49. 100.  60.  14.  13.  89.\n",
      "   2.  99.  64.]\n",
      "<built-in function iter>\n"
     ]
    }
   ],
   "source": [
    "print(featureVote)\n",
    "print(iter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Age' 'Systolic' 'Diastolic' 'Weight' 'Body-Mass-Index'\n",
      " 'White-Blood-Cells' 'Basophils' 'Red-Blood-Cells' 'Hemoglobin'\n",
      " 'Mean-cell-Hemoglobin' 'Platelet-count' 'Mean-Platelet-Vol'\n",
      " 'Red-Cell-Distribution-Width' 'Albumin' 'ALP' 'AST' 'ALT' 'Cholesterol'\n",
      " 'Creatinine' 'Glucose' 'GGT' 'Iron' 'LDH' 'Phosphorus' 'Bilirubin'\n",
      " 'Protein' 'Uric.Acid' 'Triglycerides' 'HDL' 'Glycohemoglobin' 'Gender_1'\n",
      " 'Gender_2' 'Diabetes_1' 'Diabetes_2' 'Diabetes_3' 'Blood-Rel-Diabetes_1'\n",
      " 'Blood-Rel-Diabetes_2' 'Blood-Rel-Stroke_1' 'Blood-Rel-Stroke_2'\n",
      " 'Vigorous-work_1' 'Vigorous-work_2' 'Vigorous-work_3' 'Moderate-work_1'\n",
      " 'Moderate-work_2' 'Moderate-work_3']\n"
     ]
    }
   ],
   "source": [
    "# feature nomination via Lasso (from feature 1 to 30)\n",
    "# We keep the dummy variables\n",
    "\n",
    "#thresH = iteR//5. Pick features occuring more than 5 times\n",
    "thresH = 5\n",
    "featureIndx = np.where(featureVote[0:30]>=thresH)[0]\n",
    "featureIndx = np.append(featureIndx, np.arange(30,ipData.shape[1]))\n",
    "print(varb[featureIndx])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(45,)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "featureIndx.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "tInx = np.arange(ipData.shape[1])\n",
    "rrInx = tInx[~np.isin(tInx,featureIndx)]\n",
    "print(varb[rrInx])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dataset reduction (Re-run every time you change the number of training data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "reduced_data = ipData[:,featureIndx]\n",
    "\n",
    "label0_indx = np.where(opLabel==0)[0]   #no cardiac arrest\n",
    "label1_indx = np.where(opLabel==1)[0]   #cardiac arrest \n",
    "numTrainData0 = 4300\n",
    "numTrainData1 = 1169\n",
    "np.random.shuffle(label0_indx)\n",
    "np.random.shuffle(label1_indx)\n",
    "\n",
    "label0_indx_train = label0_indx[0:numTrainData0]\n",
    "label1_indx_train = label1_indx[0:numTrainData1]\n",
    "label0_indx_test  = label0_indx[numTrainData0:]\n",
    "label1_indx_test  = label1_indx[numTrainData1:]\n",
    "\n",
    "testIndx  = np.append(label0_indx_test,label1_indx_test)\n",
    "trainIndx = np.append(label0_indx_train,label1_indx_train)    \n",
    "x_train  =  reduced_data[trainIndx]\n",
    "y_train  =  opLabel[trainIndx]\n",
    "x_test   =  reduced_data[testIndx]\n",
    "y_test   =  opLabel[testIndx]    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "31271\n"
     ]
    }
   ],
   "source": [
    "print(len(label0_indx_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "scaler = preprocessing.StandardScaler().fit(x_train)\n",
    "x_train = scaler.transform(x_train)\n",
    "x_test  = scaler.transform(x_test)\n",
    "\n",
    "x_train_org = copy.deepcopy(x_train)\n",
    "x_test_org  = copy.deepcopy(x_test)\n",
    "y_train_org     = copy.deepcopy(y_train)\n",
    "y_test_org      = copy.deepcopy(y_test)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## t-SNE visualization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# t-SNE visualization\n",
    "import imblearn\n",
    "from collections import Counter\n",
    "from sklearn.manifold import TSNE\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\Mubshr07\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\sklearn\\manifold\\_t_sne.py:800: FutureWarning: The default initialization in TSNE will change from 'random' to 'pca' in 1.2.\n",
      "  warnings.warn(\n",
      "c:\\Users\\Mubshr07\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\sklearn\\manifold\\_t_sne.py:810: FutureWarning: The default learning rate in TSNE will change from 200.0 to 'auto' in 1.2.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[t-SNE] Computing 91 nearest neighbors...\n",
      "[t-SNE] Indexed 5469 samples in 0.000s...\n",
      "[t-SNE] Computed neighbors for 5469 samples in 0.672s...\n",
      "[t-SNE] Computed conditional probabilities for sample 1000 / 5469\n",
      "[t-SNE] Computed conditional probabilities for sample 2000 / 5469\n",
      "[t-SNE] Computed conditional probabilities for sample 3000 / 5469\n",
      "[t-SNE] Computed conditional probabilities for sample 4000 / 5469\n",
      "[t-SNE] Computed conditional probabilities for sample 5000 / 5469\n",
      "[t-SNE] Computed conditional probabilities for sample 5469 / 5469\n",
      "[t-SNE] Mean sigma: 1.776332\n",
      "[t-SNE] KL divergence after 250 iterations with early exaggeration: 83.262047\n",
      "[t-SNE] KL divergence after 300 iterations: 2.202406\n"
     ]
    }
   ],
   "source": [
    "X_embedded = TSNE(n_components=3, n_iter = 300, verbose=1).fit_transform(x_train)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "'c' argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with 'x' & 'y'.  Please use a 2-D array with a single row if you really want to specify the same RGB or RGBA value for all points.\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 540x540 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "\n",
    "cin = sns.color_palette(\"Set1\")[1]\n",
    "edge_color = []\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111, projection='3d')\n",
    "ax.set_facecolor('w')\n",
    "ax.scatter(X_embedded[:,0],X_embedded[:,1],X_embedded[:,2],c=[sns.color_palette(\"Set1\")[x] for x in y_train],\\\n",
    "           edgecolors='k',label='no-CHD')\n",
    "ax.scatter(0,0,0,c=cin,edgecolors='k',label='CHD')\n",
    "ax.azim = 20\n",
    "ax.elev = 20\n",
    "ax.set_xlabel(\"t-SNE Dim 1\", size=\"x-large\")\n",
    "ax.set_ylabel(\"t-SNE Dim 2\", size=\"x-large\")\n",
    "ax.set_zlabel(\"t-SNE Dim 3\", size=\"x-large\")\n",
    "plt.title(\"Random subsampling 3:1\",size=\"xx-large\")\n",
    "ax.legend(loc='upper left')\n",
    "fig.set_size_inches(7.5,7.5)\n",
    "fig.savefig('tSNE_RUS.png', dpi=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train = x_train.reshape(x_train.shape[0],x_train.shape[1],1)\n",
    "x_test = x_test.reshape(x_test.shape[0],x_test.shape[1],1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "#%% one-hot-encoding\n",
    "y_train = keras.utils.to_categorical(y_train,2)\n",
    "y_test  = keras.utils.to_categorical(y_test,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, ..., 1, 1, 1], dtype=int64)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#y_train.shape\n",
    "#y_train\n",
    "y_train_org"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "from sklearn.metrics import classification_report, confusion_matrix, ConfusionMatrixDisplay, accuracy_score, f1_score, precision_score, recall_score,  precision_recall_fscore_support\n",
    "from sklearn.metrics import roc_auc_score\n",
    "from sklearn.metrics import roc_curve\n",
    "def evaluation(y_test, predicted_Y):\n",
    "    accuracyValue = (accuracy_score(y_test, predicted_Y)*100.0) \n",
    "    recallValue = (recall_score(y_test, predicted_Y, average='weighted') * 100.0)\n",
    "    precisionValue = (precision_score(y_test, predicted_Y) * 100.0) \n",
    "    f1Score = (f1_score(y_test, predicted_Y, average='weighted') * 100.0)\n",
    "\n",
    "\n",
    "    print(\"Accuracy : {:.3f} %\".format( accuracyValue) )\n",
    "    print('Recall : {:.3f} %'.format(recallValue))\n",
    "    print('Precision : {:.3f} %'.format(precisionValue)  )\n",
    "    print('F1 Score : {:.3f} %'.format(f1Score)  )\n",
    "\n",
    " "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Running the part above is MANDATORY for training any Network below"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MLP only"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " input_1 (InputLayer)        [(None, 45, 1)]           0         \n",
      "                                                                 \n",
      " reshape (Reshape)           (None, 45)                0         \n",
      "                                                                 \n",
      " dense (Dense)               (None, 512)               23552     \n",
      "                                                                 \n",
      " batch_normalization (BatchN  (None, 512)              2048      \n",
      " ormalization)                                                   \n",
      "                                                                 \n",
      " activation (Activation)     (None, 512)               0         \n",
      "                                                                 \n",
      " dropout (Dropout)           (None, 512)               0         \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 128)               65664     \n",
      "                                                                 \n",
      " batch_normalization_1 (Batc  (None, 128)              512       \n",
      " hNormalization)                                                 \n",
      "                                                                 \n",
      " activation_1 (Activation)   (None, 128)               0         \n",
      "                                                                 \n",
      " dropout_1 (Dropout)         (None, 128)               0         \n",
      "                                                                 \n",
      " dense_2 (Dense)             (None, 2)                 258       \n",
      "                                                                 \n",
      " activation_2 (Activation)   (None, 2)                 0         \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 92,034\n",
      "Trainable params: 90,754\n",
      "Non-trainable params: 1,280\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\Mubshr07\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\keras\\optimizers\\optimizer_v2\\adam.py:114: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.\n",
      "  super().__init__(name, **kwargs)\n"
     ]
    }
   ],
   "source": [
    "# MLP -2\n",
    "inputs = keras.layers.Input(shape=(x_train.shape[1],1))\n",
    "RS0    = keras.layers.Reshape((x_train.shape[1], ))(inputs)\n",
    "FC0    = keras.layers.Dense(512, bias_initializer=keras.initializers.VarianceScaling())(RS0)\n",
    "BN0    = keras.layers.BatchNormalization(axis=-1)(FC0)\n",
    "AC0    = keras.layers.Activation('relu')(BN0)\n",
    "DP0    = keras.layers.Dropout(0.2)(AC0)\n",
    "\n",
    "FC1    = keras.layers.Dense(128, bias_initializer=keras.initializers.VarianceScaling())(DP0)\n",
    "BN1    = keras.layers.BatchNormalization(axis=-1)(FC1)\n",
    "AC1    = keras.layers.Activation('relu')(BN1)\n",
    "DP1    = keras.layers.Dropout(0.2)(AC1)\n",
    "\n",
    "\n",
    "FC2 =   keras.layers.Dense(2, bias_initializer=keras.initializers.VarianceScaling())(DP1)\n",
    "outputs = keras.layers.Activation('softmax')(FC2)\n",
    "\n",
    "myMLP = keras.Model(inputs=inputs,outputs=outputs)\n",
    "myMLP.compile(optimizer=keras.optimizers.Adam(lr=0.01),\n",
    "                 loss='categorical_crossentropy',\n",
    "                 metrics=['accuracy'])\n",
    "myMLP.summary()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/50\n",
      "11/11 [==============================] - 6s 25ms/step - loss: 1.9569 - accuracy: 0.5718\n",
      "Epoch 2/50\n",
      "11/11 [==============================] - 0s 23ms/step - loss: 1.1767 - accuracy: 0.7107\n",
      "Epoch 3/50\n",
      "11/11 [==============================] - 0s 21ms/step - loss: 1.0644 - accuracy: 0.6623\n",
      "Epoch 4/50\n",
      "11/11 [==============================] - 0s 21ms/step - loss: 1.0055 - accuracy: 0.7010\n",
      "Epoch 5/50\n",
      "11/11 [==============================] - 0s 21ms/step - loss: 0.9621 - accuracy: 0.7045\n",
      "Epoch 6/50\n",
      "11/11 [==============================] - 0s 15ms/step - loss: 0.9216 - accuracy: 0.7285\n",
      "Epoch 7/50\n",
      "11/11 [==============================] - 0s 16ms/step - loss: 0.9090 - accuracy: 0.7248\n",
      "Epoch 8/50\n",
      "11/11 [==============================] - 0s 15ms/step - loss: 0.8836 - accuracy: 0.7308\n",
      "Epoch 9/50\n",
      "11/11 [==============================] - 0s 15ms/step - loss: 0.8784 - accuracy: 0.7378\n",
      "Epoch 10/50\n",
      "11/11 [==============================] - 0s 15ms/step - loss: 0.8258 - accuracy: 0.7446\n",
      "Epoch 11/50\n",
      "11/11 [==============================] - 0s 15ms/step - loss: 0.8022 - accuracy: 0.7661\n",
      "Epoch 12/50\n",
      "11/11 [==============================] - 0s 24ms/step - loss: 0.7869 - accuracy: 0.7457\n",
      "Epoch 13/50\n",
      "11/11 [==============================] - 0s 15ms/step - loss: 0.7542 - accuracy: 0.7877\n",
      "Epoch 14/50\n",
      "11/11 [==============================] - 0s 15ms/step - loss: 0.7473 - accuracy: 0.7661\n",
      "Epoch 15/50\n",
      "11/11 [==============================] - 0s 17ms/step - loss: 0.7067 - accuracy: 0.7916\n",
      "Epoch 16/50\n",
      "11/11 [==============================] - 0s 21ms/step - loss: 0.7209 - accuracy: 0.7954\n",
      "Epoch 17/50\n",
      "11/11 [==============================] - 0s 20ms/step - loss: 0.7133 - accuracy: 0.7797\n",
      "Epoch 18/50\n",
      "11/11 [==============================] - 0s 14ms/step - loss: 0.7058 - accuracy: 0.7961\n",
      "Epoch 19/50\n",
      "11/11 [==============================] - 0s 14ms/step - loss: 0.7061 - accuracy: 0.7872\n",
      "Epoch 20/50\n",
      "11/11 [==============================] - 0s 15ms/step - loss: 0.6352 - accuracy: 0.8022\n",
      "Epoch 21/50\n",
      "11/11 [==============================] - 0s 14ms/step - loss: 0.6050 - accuracy: 0.8124\n",
      "Epoch 22/50\n",
      "11/11 [==============================] - 0s 16ms/step - loss: 0.5858 - accuracy: 0.8278\n",
      "Epoch 23/50\n",
      "11/11 [==============================] - 0s 23ms/step - loss: 0.5717 - accuracy: 0.8256\n",
      "Epoch 24/50\n",
      "11/11 [==============================] - 0s 17ms/step - loss: 0.5557 - accuracy: 0.8486\n",
      "Epoch 25/50\n",
      "11/11 [==============================] - 0s 15ms/step - loss: 0.5608 - accuracy: 0.8373\n",
      "Epoch 26/50\n",
      "11/11 [==============================] - 0s 15ms/step - loss: 0.5643 - accuracy: 0.8331\n",
      "Epoch 27/50\n",
      "11/11 [==============================] - 0s 19ms/step - loss: 0.5608 - accuracy: 0.8367\n",
      "Epoch 28/50\n",
      "11/11 [==============================] - 0s 15ms/step - loss: 0.5687 - accuracy: 0.8323\n",
      "Epoch 29/50\n",
      "11/11 [==============================] - 0s 15ms/step - loss: 0.5061 - accuracy: 0.8588\n",
      "Epoch 30/50\n",
      "11/11 [==============================] - 0s 16ms/step - loss: 0.4931 - accuracy: 0.8479\n",
      "Epoch 31/50\n",
      "11/11 [==============================] - 0s 14ms/step - loss: 0.4751 - accuracy: 0.8614\n",
      "Epoch 32/50\n",
      "11/11 [==============================] - 0s 15ms/step - loss: 0.4292 - accuracy: 0.8707\n",
      "Epoch 33/50\n",
      "11/11 [==============================] - 0s 16ms/step - loss: 0.4284 - accuracy: 0.8652\n",
      "Epoch 34/50\n",
      "11/11 [==============================] - 0s 15ms/step - loss: 0.4265 - accuracy: 0.8872\n",
      "Epoch 35/50\n",
      "11/11 [==============================] - 0s 15ms/step - loss: 0.3659 - accuracy: 0.8905\n",
      "Epoch 36/50\n",
      "11/11 [==============================] - 0s 14ms/step - loss: 0.3740 - accuracy: 0.8987\n",
      "Epoch 37/50\n",
      "11/11 [==============================] - 0s 14ms/step - loss: 0.4193 - accuracy: 0.8746\n",
      "Epoch 38/50\n",
      "11/11 [==============================] - 0s 20ms/step - loss: 0.4047 - accuracy: 0.8897\n",
      "Epoch 39/50\n",
      "11/11 [==============================] - 0s 15ms/step - loss: 0.4522 - accuracy: 0.8835\n",
      "Epoch 40/50\n",
      "11/11 [==============================] - 0s 15ms/step - loss: 0.4593 - accuracy: 0.8749\n",
      "Epoch 41/50\n",
      "11/11 [==============================] - 0s 14ms/step - loss: 0.4756 - accuracy: 0.8713\n",
      "Epoch 42/50\n",
      "11/11 [==============================] - 0s 15ms/step - loss: 0.3998 - accuracy: 0.8905\n",
      "Epoch 43/50\n",
      "11/11 [==============================] - 0s 18ms/step - loss: 0.3902 - accuracy: 0.8907\n",
      "Epoch 44/50\n",
      "11/11 [==============================] - 0s 15ms/step - loss: 0.3292 - accuracy: 0.9064\n",
      "Epoch 45/50\n",
      "11/11 [==============================] - 0s 16ms/step - loss: 0.3118 - accuracy: 0.9093\n",
      "Epoch 46/50\n",
      "11/11 [==============================] - 0s 15ms/step - loss: 0.3109 - accuracy: 0.9099\n",
      "Epoch 47/50\n",
      "11/11 [==============================] - 0s 16ms/step - loss: 0.2790 - accuracy: 0.9227\n",
      "Epoch 48/50\n",
      "11/11 [==============================] - 0s 15ms/step - loss: 0.2988 - accuracy: 0.9217\n",
      "Epoch 49/50\n",
      "11/11 [==============================] - 0s 19ms/step - loss: 0.3112 - accuracy: 0.9104\n",
      "Epoch 50/50\n",
      "11/11 [==============================] - 0s 16ms/step - loss: 0.3298 - accuracy: 0.9086\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.History at 0x20a09033be0>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class_weight = {0: 1, 1: 10}\n",
    "\n",
    "myMLP.fit(x_train,y_train,epochs=50,batch_size=500,verbose=1, class_weight=class_weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "988/988 [==============================] - 11s 11ms/step - loss: 0.7026 - accuracy: 0.7987\n",
      "0.7987029552459717\n"
     ]
    }
   ],
   "source": [
    "test_loss,test_acc = myMLP.evaluate(x_test,y_test)\n",
    "print(test_acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "988/988 [==============================] - 5s 5ms/step\n",
      "[[25012  6259]\n",
      " [  104   235]]\n"
     ]
    }
   ],
   "source": [
    "from sklearn import metrics\n",
    "predlabel = myMLP.predict(x_test)\n",
    "f = np.argmax(predlabel,axis=1)\n",
    "confMat = metrics.confusion_matrix(np.argmax(y_test,axis=1),f)\n",
    "print(confMat)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MLP with additional layers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_1\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " input_2 (InputLayer)        [(None, 45, 1)]           0         \n",
      "                                                                 \n",
      " reshape_1 (Reshape)         (None, 45)                0         \n",
      "                                                                 \n",
      " dense_3 (Dense)             (None, 64)                2944      \n",
      "                                                                 \n",
      " batch_normalization_2 (Batc  (None, 64)               256       \n",
      " hNormalization)                                                 \n",
      "                                                                 \n",
      " activation_3 (Activation)   (None, 64)                0         \n",
      "                                                                 \n",
      " dropout_2 (Dropout)         (None, 64)                0         \n",
      "                                                                 \n",
      " dense_4 (Dense)             (None, 128)               8320      \n",
      "                                                                 \n",
      " batch_normalization_3 (Batc  (None, 128)              512       \n",
      " hNormalization)                                                 \n",
      "                                                                 \n",
      " activation_4 (Activation)   (None, 128)               0         \n",
      "                                                                 \n",
      " dropout_3 (Dropout)         (None, 128)               0         \n",
      "                                                                 \n",
      " dense_5 (Dense)             (None, 256)               33024     \n",
      "                                                                 \n",
      " batch_normalization_4 (Batc  (None, 256)              1024      \n",
      " hNormalization)                                                 \n",
      "                                                                 \n",
      " activation_5 (Activation)   (None, 256)               0         \n",
      "                                                                 \n",
      " dense_6 (Dense)             (None, 2)                 514       \n",
      "                                                                 \n",
      " activation_6 (Activation)   (None, 2)                 0         \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 46,594\n",
      "Trainable params: 45,698\n",
      "Non-trainable params: 896\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\Mubshr07\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\keras\\optimizers\\optimizer_v2\\adam.py:114: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.\n",
      "  super().__init__(name, **kwargs)\n"
     ]
    }
   ],
   "source": [
    "# MLP -3 :: Input => Hidden(64) => Hidden(128) => Hidden(256)\n",
    "inputs = keras.layers.Input(shape=(x_train.shape[1],1))\n",
    "RS0    = keras.layers.Reshape((x_train.shape[1], ))(inputs)\n",
    "FC0    = keras.layers.Dense(64, bias_initializer=keras.initializers.VarianceScaling())(RS0)\n",
    "BN0    = keras.layers.BatchNormalization(axis=-1)(FC0)\n",
    "AC0    = keras.layers.Activation('relu')(BN0)\n",
    "DP0    = keras.layers.Dropout(0.2)(AC0)\n",
    "\n",
    "FC1    = keras.layers.Dense(128, bias_initializer=keras.initializers.VarianceScaling())(DP0)\n",
    "BN1    = keras.layers.BatchNormalization(axis=-1)(FC1)\n",
    "AC1    = keras.layers.Activation('relu')(BN1)\n",
    "DP1    = keras.layers.Dropout(0.2)(AC1)\n",
    "\n",
    "FC2    = keras.layers.Dense(256, bias_initializer=keras.initializers.VarianceScaling())(DP1)\n",
    "BN2    = keras.layers.BatchNormalization(axis=-1)(FC2)\n",
    "AC2    = keras.layers.Activation('relu')(BN2)\n",
    "#DP2    = keras.layers.Dropout(0.2)(AC2)\n",
    "\n",
    "\n",
    "FC3 =   keras.layers.Dense(2, bias_initializer=keras.initializers.VarianceScaling())(AC2)\n",
    "outputs = keras.layers.Activation('softmax')(FC3)\n",
    "\n",
    "myMLP3 = keras.Model(inputs=inputs,outputs=outputs)\n",
    "myMLP3.compile(optimizer=keras.optimizers.Adam(lr=0.01),\n",
    "                 loss='categorical_crossentropy',\n",
    "                 metrics=['accuracy'])\n",
    "myMLP3.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "171/171 [==============================] - 6s 20ms/step - loss: 0.7118 - accuracy: 0.7647\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.History at 0x20b26d46b00>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class_weight = {0: 1, 1: 2.2}\n",
    "\n",
    "myMLP3.fit(x_train,y_train,epochs=1,verbose=1, class_weight=class_weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "988/988 [==============================] - 11s 11ms/step - loss: 0.3041 - accuracy: 0.8416\n",
      "0.8415691256523132\n"
     ]
    }
   ],
   "source": [
    "test_loss,test_acc = myMLP3.evaluate(x_test,y_test)\n",
    "print(test_acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "988/988 [==============================] - 7s 6ms/step\n",
      "[[26381  4890]\n",
      " [  118   221]]\n"
     ]
    }
   ],
   "source": [
    "from sklearn import metrics\n",
    "predlabel = myMLP3.predict(x_test)\n",
    "f = np.argmax(predlabel,axis=1)\n",
    "confMat = metrics.confusion_matrix(np.argmax(y_test,axis=1),f)\n",
    "print(confMat)\n",
    "#evaluation(y_test, np.array(predlabel))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introducing convolutional layers"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MLP+Conv :: Input => Hidden(128)  => Conv(4) => Output (2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_2\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " input_3 (InputLayer)        [(None, 45, 1)]           0         \n",
      "                                                                 \n",
      " reshape_2 (Reshape)         (None, 45)                0         \n",
      "                                                                 \n",
      " dense_7 (Dense)             (None, 128)               5888      \n",
      "                                                                 \n",
      " batch_normalization_5 (Batc  (None, 128)              512       \n",
      " hNormalization)                                                 \n",
      "                                                                 \n",
      " activation_7 (Activation)   (None, 128)               0         \n",
      "                                                                 \n",
      " dropout_4 (Dropout)         (None, 128)               0         \n",
      "                                                                 \n",
      " reshape_3 (Reshape)         (None, 128, 1)            0         \n",
      "                                                                 \n",
      " conv1d (Conv1D)             (None, 126, 4)            16        \n",
      "                                                                 \n",
      " batch_normalization_6 (Batc  (None, 126, 4)           16        \n",
      " hNormalization)                                                 \n",
      "                                                                 \n",
      " activation_8 (Activation)   (None, 126, 4)            0         \n",
      "                                                                 \n",
      " max_pooling1d (MaxPooling1D  (None, 63, 4)            0         \n",
      " )                                                               \n",
      "                                                                 \n",
      " flatten (Flatten)           (None, 252)               0         \n",
      "                                                                 \n",
      " dense_8 (Dense)             (None, 2)                 506       \n",
      "                                                                 \n",
      " activation_9 (Activation)   (None, 2)                 0         \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 6,938\n",
      "Trainable params: 6,674\n",
      "Non-trainable params: 264\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "\n",
    "inputs = keras.layers.Input(shape=(x_train.shape[1],1))\n",
    "RS0    = keras.layers.Reshape((x_train.shape[1], ))(inputs)\n",
    "FC0    = keras.layers.Dense(128, bias_initializer=keras.initializers.VarianceScaling())(RS0)\n",
    "BN0    = keras.layers.BatchNormalization(axis=-1)(FC0)\n",
    "AC0    = keras.layers.Activation('relu')(BN0)\n",
    "DP0    = keras.layers.Dropout(0.2)(AC0)\n",
    "\n",
    "RS1    = keras.layers.Reshape((128,1))(DP0)\n",
    "FC1    = keras.layers.Conv1D(4,3,strides=1)(RS1)\n",
    "BN1    = keras.layers.BatchNormalization(axis=-1)(FC1)\n",
    "AC1    = keras.layers.Activation('relu')(BN1)\n",
    "Pool1 = keras.layers.MaxPool1D(pool_size=2)(AC1)\n",
    "FL1   = keras.layers.Flatten()(Pool1)\n",
    "\n",
    "FC3 =   keras.layers.Dense(2, bias_initializer=keras.initializers.VarianceScaling())(FL1)\n",
    "outputs = keras.layers.Activation('softmax')(FC3)\n",
    "\n",
    "myCNN1D1 = keras.Model(inputs=inputs,outputs=outputs)\n",
    "myCNN1D1.compile(optimizer=keras.optimizers.Adam(),\n",
    "                 loss='categorical_crossentropy',\n",
    "                 metrics=['accuracy'])\n",
    "\n",
    "myCNN1D1.summary()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "171/171 [==============================] - 15s 16ms/step - loss: 1.0010 - accuracy: 0.7148\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.History at 0x20b3aca8fa0>"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class_weight = {0: 1, 1: 4}\n",
    "\n",
    "myCNN1D1.fit(x_train,y_train,epochs=1,verbose=1, class_weight=class_weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "988/988 [==============================] - 10s 10ms/step - loss: 0.7104 - accuracy: 0.6552\n",
      "0.6552040576934814\n"
     ]
    }
   ],
   "source": [
    "test_loss,test_acc = myCNN1D1.evaluate(x_test,y_test)\n",
    "print(test_acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "988/988 [==============================] - 6s 6ms/step\n",
      "[[20417 10854]\n",
      " [   45   294]]\n"
     ]
    }
   ],
   "source": [
    "from sklearn import metrics\n",
    "predlabel = myCNN1D1.predict(x_test)\n",
    "f = np.argmax(predlabel,axis=1)\n",
    "confMat = metrics.confusion_matrix(np.argmax(y_test,axis=1),f)\n",
    "print(confMat)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  MLP+CONV: Input => Hidden(128)  => Conv(4) => Conv(8) => Output (2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_3\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " input_4 (InputLayer)        [(None, 45, 1)]           0         \n",
      "                                                                 \n",
      " reshape_4 (Reshape)         (None, 45)                0         \n",
      "                                                                 \n",
      " dense_9 (Dense)             (None, 128)               5888      \n",
      "                                                                 \n",
      " batch_normalization_7 (Batc  (None, 128)              512       \n",
      " hNormalization)                                                 \n",
      "                                                                 \n",
      " activation_10 (Activation)  (None, 128)               0         \n",
      "                                                                 \n",
      " dropout_5 (Dropout)         (None, 128)               0         \n",
      "                                                                 \n",
      " reshape_5 (Reshape)         (None, 128, 1)            0         \n",
      "                                                                 \n",
      " conv1d_1 (Conv1D)           (None, 126, 4)            16        \n",
      "                                                                 \n",
      " batch_normalization_8 (Batc  (None, 126, 4)           16        \n",
      " hNormalization)                                                 \n",
      "                                                                 \n",
      " activation_11 (Activation)  (None, 126, 4)            0         \n",
      "                                                                 \n",
      " average_pooling1d (AverageP  (None, 63, 4)            0         \n",
      " ooling1D)                                                       \n",
      "                                                                 \n",
      " conv1d_2 (Conv1D)           (None, 59, 8)             168       \n",
      "                                                                 \n",
      " batch_normalization_9 (Batc  (None, 59, 8)            32        \n",
      " hNormalization)                                                 \n",
      "                                                                 \n",
      " activation_12 (Activation)  (None, 59, 8)             0         \n",
      "                                                                 \n",
      " average_pooling1d_1 (Averag  (None, 29, 8)            0         \n",
      " ePooling1D)                                                     \n",
      "                                                                 \n",
      " flatten_1 (Flatten)         (None, 232)               0         \n",
      "                                                                 \n",
      " dense_10 (Dense)            (None, 2)                 466       \n",
      "                                                                 \n",
      " activation_13 (Activation)  (None, 2)                 0         \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 7,098\n",
      "Trainable params: 6,818\n",
      "Non-trainable params: 280\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "inputs = keras.layers.Input(shape=(x_train.shape[1],1))\n",
    "RS0    = keras.layers.Reshape((x_train.shape[1], ))(inputs)\n",
    "FC0    = keras.layers.Dense(128, bias_initializer=keras.initializers.VarianceScaling())(RS0)\n",
    "BN0    = keras.layers.BatchNormalization(axis=-1)(FC0)\n",
    "AC0    = keras.layers.Activation('relu')(BN0)\n",
    "DP0    = keras.layers.Dropout(0.2)(AC0)\n",
    "\n",
    "RS1    = keras.layers.Reshape((128,1))(DP0)\n",
    "FC1    = keras.layers.Conv1D(4,3,strides=1)(RS1)\n",
    "BN1    = keras.layers.BatchNormalization(axis=-1)(FC1)\n",
    "AC1    = keras.layers.Activation('relu')(BN1)\n",
    "Pool1 = keras.layers.AveragePooling1D(pool_size=2)(AC1)\n",
    "\n",
    "FC2    = keras.layers.Conv1D(8,5,strides=1)(Pool1)\n",
    "BN2    = keras.layers.BatchNormalization(axis=-1)(FC2)\n",
    "AC2    = keras.layers.Activation('relu')(BN2)\n",
    "Pool2 = keras.layers.AveragePooling1D(pool_size=2)(AC2)\n",
    "\n",
    "FL1   = keras.layers.Flatten()(Pool2)\n",
    "\n",
    "FC3 =   keras.layers.Dense(2, bias_initializer=keras.initializers.VarianceScaling())(FL1)\n",
    "outputs = keras.layers.Activation('softmax')(FC3)\n",
    "\n",
    "myCNN1D2 = keras.Model(inputs=inputs,outputs=outputs)\n",
    "myCNN1D2.compile(optimizer=keras.optimizers.Adam(),\n",
    "                 loss='categorical_crossentropy',\n",
    "                 metrics=['accuracy'])\n",
    "\n",
    "myCNN1D2.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "171/171 [==============================] - 6s 19ms/step - loss: 0.9671 - accuracy: 0.6899\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.History at 0x20b47276e60>"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class_weight = {0: 1, 1: 4.5}\n",
    "\n",
    "myCNN1D2.fit(x_train,y_train,epochs=1,verbose=1, class_weight=class_weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "988/988 [==============================] - 11s 11ms/step - loss: 0.7061 - accuracy: 0.5734\n",
      "0.5734261274337769\n"
     ]
    }
   ],
   "source": [
    "test_loss,test_acc = myCNN1D2.evaluate(x_test,y_test)\n",
    "print(test_acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "988/988 [==============================] - 9s 9ms/step\n",
      "[[17807 13464]\n",
      " [   20   319]]\n"
     ]
    }
   ],
   "source": [
    "from sklearn import metrics\n",
    "predlabel = myCNN1D2.predict(x_test)\n",
    "f = np.argmax(predlabel,axis=1)\n",
    "confMat = metrics.confusion_matrix(np.argmax(y_test,axis=1),f)\n",
    "print(confMat)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MLP+Conv :: Input => Hidden(64) => Conv(2) => Hidden(512)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_4\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " input_5 (InputLayer)        [(None, 45, 1)]           0         \n",
      "                                                                 \n",
      " reshape_6 (Reshape)         (None, 45)                0         \n",
      "                                                                 \n",
      " dense_11 (Dense)            (None, 32)                1472      \n",
      "                                                                 \n",
      " batch_normalization_10 (Bat  (None, 32)               128       \n",
      " chNormalization)                                                \n",
      "                                                                 \n",
      " activation_14 (Activation)  (None, 32)                0         \n",
      "                                                                 \n",
      " dropout_6 (Dropout)         (None, 32)                0         \n",
      "                                                                 \n",
      " reshape_7 (Reshape)         (None, 32, 1)             0         \n",
      "                                                                 \n",
      " conv1d_3 (Conv1D)           (None, 30, 2)             8         \n",
      "                                                                 \n",
      " batch_normalization_11 (Bat  (None, 30, 2)            8         \n",
      " chNormalization)                                                \n",
      "                                                                 \n",
      " activation_15 (Activation)  (None, 30, 2)             0         \n",
      "                                                                 \n",
      " max_pooling1d_1 (MaxPooling  (None, 15, 2)            0         \n",
      " 1D)                                                             \n",
      "                                                                 \n",
      " flatten_2 (Flatten)         (None, 30)                0         \n",
      "                                                                 \n",
      " dense_12 (Dense)            (None, 512)               15872     \n",
      "                                                                 \n",
      " batch_normalization_12 (Bat  (None, 512)              2048      \n",
      " chNormalization)                                                \n",
      "                                                                 \n",
      " activation_16 (Activation)  (None, 512)               0         \n",
      "                                                                 \n",
      " dense_13 (Dense)            (None, 2)                 1026      \n",
      "                                                                 \n",
      " activation_17 (Activation)  (None, 2)                 0         \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 20,562\n",
      "Trainable params: 19,470\n",
      "Non-trainable params: 1,092\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "\n",
    "inputs = keras.layers.Input(shape=(x_train.shape[1],1))\n",
    "RS0    = keras.layers.Reshape((x_train.shape[1], ))(inputs)\n",
    "FC0    = keras.layers.Dense(32, bias_initializer=keras.initializers.VarianceScaling())(RS0)\n",
    "BN0    = keras.layers.BatchNormalization(axis=-1)(FC0)\n",
    "AC0    = keras.layers.Activation('relu')(BN0)\n",
    "DP0    = keras.layers.Dropout(0.2)(AC0)\n",
    "\n",
    "RS1    = keras.layers.Reshape((32,1))(DP0)\n",
    "FC1    = keras.layers.Conv1D(2,3,strides=1)(RS1)\n",
    "BN1    = keras.layers.BatchNormalization(axis=-1)(FC1)\n",
    "AC1    = keras.layers.Activation('relu')(BN1)\n",
    "Pool1 = keras.layers.MaxPool1D(pool_size=2)(AC1)\n",
    "FL1   = keras.layers.Flatten()(Pool1)\n",
    "\n",
    "FC2    = keras.layers.Dense(512, bias_initializer=keras.initializers.VarianceScaling())(FL1)\n",
    "BN2    = keras.layers.BatchNormalization(axis=-1)(FC2)\n",
    "AC2    = keras.layers.Activation('relu')(BN2)\n",
    "#DP2    = keras.layers.Dropout(0.2)(AC2)\n",
    "\n",
    "\n",
    "FC3 =   keras.layers.Dense(2, bias_initializer=keras.initializers.VarianceScaling())(AC2)\n",
    "outputs = keras.layers.Activation('softmax')(FC3)\n",
    "\n",
    "myCNN1D3 = keras.Model(inputs=inputs,outputs=outputs)\n",
    "myCNN1D3.compile(optimizer=keras.optimizers.Adam(),\n",
    "                 loss='categorical_crossentropy',\n",
    "                 metrics=['accuracy'])\n",
    "myCNN1D3.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/5\n",
      "171/171 [==============================] - 5s 17ms/step - loss: 3.1366 - accuracy: 0.2529\n",
      "Epoch 2/5\n",
      "171/171 [==============================] - 3s 18ms/step - loss: 2.5230 - accuracy: 0.3258\n",
      "Epoch 3/5\n",
      "171/171 [==============================] - 3s 19ms/step - loss: 2.4144 - accuracy: 0.3776\n",
      "Epoch 4/5\n",
      "171/171 [==============================] - 3s 19ms/step - loss: 2.3238 - accuracy: 0.3754\n",
      "Epoch 5/5\n",
      "171/171 [==============================] - 3s 19ms/step - loss: 2.2187 - accuracy: 0.4220\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.History at 0x20b9ce56b60>"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class_weight = {0: 1, 1: 50}\n",
    "\n",
    "myCNN1D3.fit(x_train,y_train,epochs=5,verbose=1, class_weight=class_weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "988/988 [==============================] - 15s 15ms/step - loss: 2.1184 - accuracy: 0.2194\n",
      "0.2193925976753235\n"
     ]
    }
   ],
   "source": [
    "test_loss,test_acc = myCNN1D3.evaluate(x_test,y_test)\n",
    "print(test_acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "988/988 [==============================] - 8s 8ms/step\n",
      "[[ 6598 24673]\n",
      " [    2   337]]\n"
     ]
    }
   ],
   "source": [
    "from sklearn import metrics\n",
    "predlabel = myCNN1D3.predict(x_test)\n",
    "f = np.argmax(predlabel,axis=1)\n",
    "confMat = metrics.confusion_matrix(np.argmax(y_test,axis=1),f)\n",
    "print(confMat)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MLP+ CONV: Input => Dense(64) => Conv(2) => Conv(4) = Dense(512) => Dense (2) [Best model]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "inputs = keras.layers.Input(shape=(x_train.shape[1],1))\n",
    "RS0    = keras.layers.Reshape((x_train.shape[1], ))(inputs)\n",
    "FC0    = keras.layers.Dense(64, bias_initializer=keras.initializers.VarianceScaling())(RS0)\n",
    "BN0    = keras.layers.BatchNormalization(axis=-1)(FC0)\n",
    "AC0    = keras.layers.Activation('relu')(BN0)\n",
    "DP0    = keras.layers.Dropout(0.2)(AC0)\n",
    "\n",
    "RS1    = keras.layers.Reshape((64,1))(DP0)\n",
    "FC1    = keras.layers.Conv1D(2,3,strides=1)(RS1)\n",
    "BN1    = keras.layers.BatchNormalization(axis=-1)(FC1)\n",
    "AC1    = keras.layers.Activation('relu')(BN1)\n",
    "Pool1  = keras.layers.AveragePooling1D(pool_size=2)(AC1)\n",
    "\n",
    "FC2    = keras.layers.Conv1D(4,5,strides=1)(Pool1)\n",
    "BN2    = keras.layers.BatchNormalization(axis=-1)(FC2)\n",
    "AC2    = keras.layers.Activation('relu')(BN2)\n",
    "Pool2  = keras.layers.AveragePooling1D(pool_size=2)(AC2)\n",
    "\n",
    "FL1    = keras.layers.Flatten()(Pool2)\n",
    "\n",
    "FC3    = keras.layers.Dense(512, bias_initializer=keras.initializers.VarianceScaling())(FL1)\n",
    "BN3    = keras.layers.BatchNormalization(axis=-1)(FC3)\n",
    "AC3    = keras.layers.Activation('relu')(BN3)\n",
    "DP3    = keras.layers.Dropout(0.2)(AC3)\n",
    "\n",
    "\n",
    "FC4    = keras.layers.Dense(2)(DP3)\n",
    "outputs = keras.layers.Activation('softmax')(FC4)\n",
    "\n",
    "myCNN1D4 = keras.Model(inputs=inputs,outputs=outputs)\n",
    "myCNN1D4.compile(optimizer=keras.optimizers.Adam(),\n",
    "                 loss='categorical_crossentropy',\n",
    "                 metrics=['accuracy'])\n",
    "\n",
    "#myCNN1D4.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "171/171 [==============================] - 7s 23ms/step - loss: 0.9480 - accuracy: 0.6787\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.History at 0x20ba0297730>"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class_weight = {0: 1, 1: 2.9}\n",
    "\n",
    "myCNN1D4.fit(x_train,y_train,epochs=1,verbose=1, class_weight=class_weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "988/988 [==============================] - 13s 13ms/step - loss: 0.6576 - accuracy: 0.7354\n",
      "0.7354001998901367\n"
     ]
    }
   ],
   "source": [
    "test_loss,test_acc = myCNN1D4.evaluate(x_test,y_test)\n",
    "print(test_acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "988/988 [==============================] - 10s 10ms/step\n",
      "[[23051  8220]\n",
      " [  144   195]]\n"
     ]
    }
   ],
   "source": [
    "from sklearn import metrics\n",
    "predlabel = myCNN1D4.predict(x_test)\n",
    "f = np.argmax(predlabel,axis=1)\n",
    "confMat = metrics.confusion_matrix(np.argmax(y_test,axis=1),f)\n",
    "print(confMat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.024390243902439025"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train @ np.transpose(np.array([0, 1]))\n",
    "1/41"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Input => Dense(64) => Conv(2) => Conv(4) = Conv(8) => Dense (2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_6\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " input_7 (InputLayer)        [(None, 45, 1)]           0         \n",
      "                                                                 \n",
      " reshape_10 (Reshape)        (None, 45)                0         \n",
      "                                                                 \n",
      " dense_17 (Dense)            (None, 64)                2944      \n",
      "                                                                 \n",
      " batch_normalization_17 (Bat  (None, 64)               256       \n",
      " chNormalization)                                                \n",
      "                                                                 \n",
      " activation_23 (Activation)  (None, 64)                0         \n",
      "                                                                 \n",
      " dropout_9 (Dropout)         (None, 64)                0         \n",
      "                                                                 \n",
      " reshape_11 (Reshape)        (None, 64, 1)             0         \n",
      "                                                                 \n",
      " conv1d_6 (Conv1D)           (None, 62, 2)             8         \n",
      "                                                                 \n",
      " batch_normalization_18 (Bat  (None, 62, 2)            8         \n",
      " chNormalization)                                                \n",
      "                                                                 \n",
      " activation_24 (Activation)  (None, 62, 2)             0         \n",
      "                                                                 \n",
      " average_pooling1d_4 (Averag  (None, 31, 2)            0         \n",
      " ePooling1D)                                                     \n",
      "                                                                 \n",
      " conv1d_7 (Conv1D)           (None, 27, 4)             44        \n",
      "                                                                 \n",
      " batch_normalization_19 (Bat  (None, 27, 4)            16        \n",
      " chNormalization)                                                \n",
      "                                                                 \n",
      " activation_25 (Activation)  (None, 27, 4)             0         \n",
      "                                                                 \n",
      " average_pooling1d_5 (Averag  (None, 13, 4)            0         \n",
      " ePooling1D)                                                     \n",
      "                                                                 \n",
      " conv1d_8 (Conv1D)           (None, 7, 6)              174       \n",
      "                                                                 \n",
      " batch_normalization_20 (Bat  (None, 7, 6)             24        \n",
      " chNormalization)                                                \n",
      "                                                                 \n",
      " activation_26 (Activation)  (None, 7, 6)              0         \n",
      "                                                                 \n",
      " average_pooling1d_6 (Averag  (None, 3, 6)             0         \n",
      " ePooling1D)                                                     \n",
      "                                                                 \n",
      " flatten_4 (Flatten)         (None, 18)                0         \n",
      "                                                                 \n",
      " dense_18 (Dense)            (None, 2)                 38        \n",
      "                                                                 \n",
      " activation_27 (Activation)  (None, 2)                 0         \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 3,512\n",
      "Trainable params: 3,360\n",
      "Non-trainable params: 152\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "inputs = keras.layers.Input(shape=(x_train.shape[1],1))\n",
    "RS0    = keras.layers.Reshape((x_train.shape[1], ))(inputs)\n",
    "FC0    = keras.layers.Dense(64, bias_initializer=keras.initializers.VarianceScaling())(RS0)\n",
    "BN0    = keras.layers.BatchNormalization(axis=-1)(FC0)\n",
    "AC0    = keras.layers.Activation('relu')(BN0)\n",
    "DP0    = keras.layers.Dropout(0.2)(AC0)\n",
    "\n",
    "RS1    = keras.layers.Reshape((64,1))(DP0)\n",
    "FC1    = keras.layers.Conv1D(2,3,strides=1)(RS1)\n",
    "BN1    = keras.layers.BatchNormalization(axis=-1)(FC1)\n",
    "AC1    = keras.layers.Activation('relu')(BN1)\n",
    "Pool1  = keras.layers.AveragePooling1D(pool_size=2)(AC1)\n",
    "\n",
    "FC2    = keras.layers.Conv1D(4,5,strides=1)(Pool1)\n",
    "BN2    = keras.layers.BatchNormalization(axis=-1)(FC2)\n",
    "AC2    = keras.layers.Activation('relu')(BN2)\n",
    "Pool2  = keras.layers.AveragePooling1D(pool_size=2)(AC2)\n",
    "\n",
    "\n",
    "FC3    = keras.layers.Conv1D(6,7,strides=1)(Pool2)\n",
    "BN3    = keras.layers.BatchNormalization(axis=-1)(FC3)\n",
    "AC3    = keras.layers.Activation('relu')(BN3)\n",
    "Pool3  = keras.layers.AveragePooling1D(pool_size=2)(AC3)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "FL1    = keras.layers.Flatten()(Pool3)\n",
    "\n",
    "#FC3    = keras.layers.Dense(512, bias_initializer=keras.initializers.VarianceScaling())(FL1)\n",
    "#BN3    = keras.layers.BatchNormalization(axis=-1)(FC3)\n",
    "#AC3    = keras.layers.Activation('relu')(BN3)\n",
    "#DP3    = keras.layers.Dropout(0.2)(AC3)\n",
    "\n",
    "\n",
    "FC4    = keras.layers.Dense(2)(FL1)\n",
    "outputs = keras.layers.Activation('softmax')(FC4)\n",
    "\n",
    "myCNN5D4 = keras.Model(inputs=inputs,outputs=outputs)\n",
    "myCNN5D4.compile(optimizer=keras.optimizers.Adam(),\n",
    "                 loss='categorical_crossentropy',\n",
    "                 metrics=['accuracy'])\n",
    "\n",
    "myCNN5D4.summary()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "171/171 [==============================] - 7s 24ms/step - loss: 0.8907 - accuracy: 0.6603\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.History at 0x20ba6713ee0>"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class_weight = {0: 1, 1: 3.0}\n",
    "\n",
    "myCNN5D4.fit(x_train,y_train,epochs=1,verbose=1, class_weight=class_weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "988/988 [==============================] - 12s 11ms/step - loss: 0.3739 - accuracy: 0.9288\n",
      "0.9287567138671875\n"
     ]
    }
   ],
   "source": [
    "test_loss,test_acc = myCNN5D4.evaluate(x_test,y_test)\n",
    "print(test_acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "988/988 [==============================] - 11s 11ms/step\n",
      "[[29263  2008]\n",
      " [  244    95]]\n"
     ]
    }
   ],
   "source": [
    "from sklearn import metrics\n",
    "predlabel = myCNN5D4.predict(x_test)\n",
    "f = np.argmax(predlabel,axis=1)\n",
    "confMat = metrics.confusion_matrix(np.argmax(y_test,axis=1),f)\n",
    "print(confMat)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Input => Dense(64) => Conv(2) => Dense (128) = Conv(4) => Dense (2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_7\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " input_8 (InputLayer)        [(None, 45, 1)]           0         \n",
      "                                                                 \n",
      " reshape_12 (Reshape)        (None, 45)                0         \n",
      "                                                                 \n",
      " dense_19 (Dense)            (None, 64)                2944      \n",
      "                                                                 \n",
      " batch_normalization_21 (Bat  (None, 64)               256       \n",
      " chNormalization)                                                \n",
      "                                                                 \n",
      " activation_28 (Activation)  (None, 64)                0         \n",
      "                                                                 \n",
      " dropout_10 (Dropout)        (None, 64)                0         \n",
      "                                                                 \n",
      " reshape_13 (Reshape)        (None, 64, 1)             0         \n",
      "                                                                 \n",
      " conv1d_9 (Conv1D)           (None, 62, 2)             8         \n",
      "                                                                 \n",
      " batch_normalization_22 (Bat  (None, 62, 2)            8         \n",
      " chNormalization)                                                \n",
      "                                                                 \n",
      " activation_29 (Activation)  (None, 62, 2)             0         \n",
      "                                                                 \n",
      " average_pooling1d_7 (Averag  (None, 31, 2)            0         \n",
      " ePooling1D)                                                     \n",
      "                                                                 \n",
      " flatten_5 (Flatten)         (None, 62)                0         \n",
      "                                                                 \n",
      " dense_20 (Dense)            (None, 128)               8064      \n",
      "                                                                 \n",
      " batch_normalization_23 (Bat  (None, 128)              512       \n",
      " chNormalization)                                                \n",
      "                                                                 \n",
      " activation_30 (Activation)  (None, 128)               0         \n",
      "                                                                 \n",
      " dropout_11 (Dropout)        (None, 128)               0         \n",
      "                                                                 \n",
      " reshape_14 (Reshape)        (None, 128, 1)            0         \n",
      "                                                                 \n",
      " conv1d_10 (Conv1D)          (None, 124, 4)            24        \n",
      "                                                                 \n",
      " batch_normalization_24 (Bat  (None, 124, 4)           16        \n",
      " chNormalization)                                                \n",
      "                                                                 \n",
      " activation_31 (Activation)  (None, 124, 4)            0         \n",
      "                                                                 \n",
      " average_pooling1d_8 (Averag  (None, 62, 4)            0         \n",
      " ePooling1D)                                                     \n",
      "                                                                 \n",
      " flatten_6 (Flatten)         (None, 248)               0         \n",
      "                                                                 \n",
      " dense_21 (Dense)            (None, 2)                 498       \n",
      "                                                                 \n",
      " activation_32 (Activation)  (None, 2)                 0         \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 12,330\n",
      "Trainable params: 11,934\n",
      "Non-trainable params: 396\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "inputs = keras.layers.Input(shape=(x_train.shape[1],1))\n",
    "RS0    = keras.layers.Reshape((x_train.shape[1], ))(inputs)\n",
    "FC0    = keras.layers.Dense(64, bias_initializer=keras.initializers.VarianceScaling())(RS0)\n",
    "BN0    = keras.layers.BatchNormalization(axis=-1)(FC0)\n",
    "AC0    = keras.layers.Activation('relu')(BN0)\n",
    "DP0    = keras.layers.Dropout(0.2)(AC0)\n",
    "\n",
    "RS1    = keras.layers.Reshape((64,1))(DP0)\n",
    "FC1    = keras.layers.Conv1D(2,3,strides=1)(RS1)\n",
    "BN1    = keras.layers.BatchNormalization(axis=-1)(FC1)\n",
    "AC1    = keras.layers.Activation('relu')(BN1)\n",
    "Pool1  = keras.layers.AveragePooling1D(pool_size=2)(AC1)\n",
    "\n",
    "FL0 = keras.layers.Flatten()(Pool1)\n",
    "\n",
    "AA1 = keras.layers.Dense(128, bias_initializer=keras.initializers.VarianceScaling())(FL0)\n",
    "BB1 = keras.layers.BatchNormalization(axis=-1)(AA1)\n",
    "CC1 = keras.layers.Activation('relu')(BB1)\n",
    "Pool2 = keras.layers.Dropout(0.2)(CC1)\n",
    "\n",
    "\n",
    "RS2    = keras.layers.Reshape((128,1))(Pool2)\n",
    "FC2    = keras.layers.Conv1D(4,5,strides=1)(RS2)\n",
    "BN2    = keras.layers.BatchNormalization(axis=-1)(FC2)\n",
    "AC2    = keras.layers.Activation('relu')(BN2)\n",
    "Pool3  = keras.layers.AveragePooling1D(pool_size=2)(AC2)\n",
    "\n",
    "\n",
    "\n",
    "FL1    = keras.layers.Flatten()(Pool3)\n",
    "\n",
    "#FC3    = keras.layers.Dense(512, bias_initializer=keras.initializers.VarianceScaling())(FL1)\n",
    "#BN3    = keras.layers.BatchNormalization(axis=-1)(FC3)\n",
    "#AC3    = keras.layers.Activation('relu')(BN3)\n",
    "#DP3    = keras.layers.Dropout(0.2)(AC3)\n",
    "\n",
    "\n",
    "FC4    = keras.layers.Dense(2)(FL1)\n",
    "outputs = keras.layers.Activation('softmax')(FC4)\n",
    "\n",
    "myCNN5D4 = keras.Model(inputs=inputs,outputs=outputs)\n",
    "myCNN5D4.compile(optimizer=keras.optimizers.Adam(),\n",
    "                 loss='categorical_crossentropy',\n",
    "                 metrics=['accuracy'])\n",
    "\n",
    "myCNN5D4.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "171/171 [==============================] - 6s 22ms/step - loss: 0.7914 - accuracy: 0.7292\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.History at 0x20bb2be5db0>"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class_weight = {0: 1, 1: 2.5}\n",
    "\n",
    "myCNN5D4.fit(x_train,y_train,epochs=1,verbose=1, class_weight=class_weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "988/988 [==============================] - 13s 13ms/step - loss: 0.5468 - accuracy: 0.8800\n",
      "0.8800063133239746\n"
     ]
    }
   ],
   "source": [
    "test_loss,test_acc = myCNN5D4.evaluate(x_test,y_test)\n",
    "print(test_acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "988/988 [==============================] - 9s 9ms/step\n",
      "[[27649  3622]\n",
      " [  171   168]]\n"
     ]
    }
   ],
   "source": [
    "from sklearn import metrics\n",
    "predlabel = myCNN5D4.predict(x_test)\n",
    "f = np.argmax(predlabel,axis=1)\n",
    "confMat = metrics.confusion_matrix(np.argmax(y_test,axis=1),f)\n",
    "print(confMat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Running SVM on the subsampled data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[22274  8997]\n",
      " [   57   282]]\n"
     ]
    }
   ],
   "source": [
    "from sklearn.svm import SVC\n",
    "from sklearn import metrics\n",
    "\n",
    "svcCAD = SVC(C= 0.05, gamma=1/41, kernel='rbf', class_weight='balanced')\n",
    "svcCAD.fit(x_train_org,y_train_org)\n",
    "predlabel = svcCAD.predict(x_test_org)\n",
    "confMat = metrics.confusion_matrix(y_test_org,predlabel)\n",
    "print(confMat)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Running random forest and adaboost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[28348  2923]\n",
      " [  179   160]]\n",
      "Accuracy : 90.187 %\n",
      "Recall : 90.187 %\n",
      "Precision : 5.190 %\n",
      "F1 Score : 93.896 %\n"
     ]
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier\n",
    "class_weight = {0: 1, 1: 3}\n",
    "adaboostCAD = AdaBoostClassifier(n_estimators=1000, random_state=0)\n",
    "adaboostCAD.fit(x_train_org,y_train_org)\n",
    "predlabel = adaboostCAD.predict(x_test_org)\n",
    "confMat = metrics.confusion_matrix(y_test_org,predlabel)\n",
    "print(confMat)\n",
    "evaluation(y_test_org, predlabel)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>#sk-container-id-1 {color: black;background-color: white;}#sk-container-id-1 pre{padding: 0;}#sk-container-id-1 div.sk-toggleable {background-color: white;}#sk-container-id-1 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-1 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-1 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-1 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-1 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-1 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-1 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-1 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-1 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-1 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-1 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-1 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-1 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-1 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-1 div.sk-item {position: relative;z-index: 1;}#sk-container-id-1 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-1 div.sk-item::before, #sk-container-id-1 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-1 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-1 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-1 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-1 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-1 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-1 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-1 div.sk-label-container {text-align: center;}#sk-container-id-1 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-1 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>GridSearchCV(cv=5,\n",
       "             estimator=RandomForestClassifier(class_weight=&#x27;balanced_subsample&#x27;,\n",
       "                                              random_state=0),\n",
       "             param_grid={&#x27;max_depth&#x27;: (2, 3),\n",
       "                         &#x27;n_estimators&#x27;: (10, 30, 50, 100, 130, 160, 200)})</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item sk-dashed-wrapped\"><div class=\"sk-label-container\"><div class=\"sk-label sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" ><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">GridSearchCV</label><div class=\"sk-toggleable__content\"><pre>GridSearchCV(cv=5,\n",
       "             estimator=RandomForestClassifier(class_weight=&#x27;balanced_subsample&#x27;,\n",
       "                                              random_state=0),\n",
       "             param_grid={&#x27;max_depth&#x27;: (2, 3),\n",
       "                         &#x27;n_estimators&#x27;: (10, 30, 50, 100, 130, 160, 200)})</pre></div></div></div><div class=\"sk-parallel\"><div class=\"sk-parallel-item\"><div class=\"sk-item\"><div class=\"sk-label-container\"><div class=\"sk-label sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-2\" type=\"checkbox\" ><label for=\"sk-estimator-id-2\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">estimator: RandomForestClassifier</label><div class=\"sk-toggleable__content\"><pre>RandomForestClassifier(class_weight=&#x27;balanced_subsample&#x27;, random_state=0)</pre></div></div></div><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-3\" type=\"checkbox\" ><label for=\"sk-estimator-id-3\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">RandomForestClassifier</label><div class=\"sk-toggleable__content\"><pre>RandomForestClassifier(class_weight=&#x27;balanced_subsample&#x27;, random_state=0)</pre></div></div></div></div></div></div></div></div></div></div>"
      ],
      "text/plain": [
       "GridSearchCV(cv=5,\n",
       "             estimator=RandomForestClassifier(class_weight='balanced_subsample',\n",
       "                                              random_state=0),\n",
       "             param_grid={'max_depth': (2, 3),\n",
       "                         'n_estimators': (10, 30, 50, 100, 130, 160, 200)})"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "#randomforestCAD = RandomForestClassifier(max_depth=3, random_state=0, class_weight='balanced_subsample')\n",
    "\n",
    "parameters = {'n_estimators': (10,30,50,100,130,160,200), 'max_depth': (2, 3)}\n",
    "randomforestCAD = GridSearchCV(RandomForestClassifier(random_state=0, class_weight='balanced_subsample'),\n",
    "                               parameters, cv=5)\n",
    "\n",
    "\n",
    "\n",
    "randomforestCAD.fit(x_train_org,y_train_org)\n",
    "#predlabel = randomforestCAD.predict(x_test_org)\n",
    "#confMat = metrics.confusion_matrix(y_test_org,predlabel)\n",
    "#print(confMat)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'mean_fit_time': array([0.06079102, 0.1495924 , 0.27076225, 0.47584376, 0.77800851,\n",
      "       1.12319956, 1.2296473 , 0.06880393, 0.25119534, 0.34719925,\n",
      "       0.73978696, 1.19199057, 1.00523119, 1.20152597]), 'std_fit_time': array([0.00467365, 0.00966165, 0.03931759, 0.02188637, 0.12364948,\n",
      "       0.16149884, 0.20192076, 0.00587721, 0.0539748 , 0.01504696,\n",
      "       0.12421057, 0.55180799, 0.08956473, 0.13977145]), 'mean_score_time': array([0.00320988, 0.00720491, 0.00960817, 0.01998692, 0.03599992,\n",
      "       0.03839889, 0.04742789, 0.00240049, 0.01360726, 0.01360064,\n",
      "       0.03200245, 0.03681016, 0.04000125, 0.04239621]), 'std_score_time': array([0.00160499, 0.0015877 , 0.00195712, 0.00253917, 0.00758658,\n",
      "       0.0054286 , 0.01100523, 0.00195999, 0.0093255 , 0.00195959,\n",
      "       0.00799966, 0.00688085, 0.01012036, 0.00196659]), 'param_max_depth': masked_array(data=[2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3],\n",
      "             mask=[False, False, False, False, False, False, False, False,\n",
      "                   False, False, False, False, False, False],\n",
      "       fill_value='?',\n",
      "            dtype=object), 'param_n_estimators': masked_array(data=[10, 30, 50, 100, 130, 160, 200, 10, 30, 50, 100, 130,\n",
      "                   160, 200],\n",
      "             mask=[False, False, False, False, False, False, False, False,\n",
      "                   False, False, False, False, False, False],\n",
      "       fill_value='?',\n",
      "            dtype=object), 'params': [{'max_depth': 2, 'n_estimators': 10}, {'max_depth': 2, 'n_estimators': 30}, {'max_depth': 2, 'n_estimators': 50}, {'max_depth': 2, 'n_estimators': 100}, {'max_depth': 2, 'n_estimators': 130}, {'max_depth': 2, 'n_estimators': 160}, {'max_depth': 2, 'n_estimators': 200}, {'max_depth': 3, 'n_estimators': 10}, {'max_depth': 3, 'n_estimators': 30}, {'max_depth': 3, 'n_estimators': 50}, {'max_depth': 3, 'n_estimators': 100}, {'max_depth': 3, 'n_estimators': 130}, {'max_depth': 3, 'n_estimators': 160}, {'max_depth': 3, 'n_estimators': 200}], 'split0_test_score': array([0.7440585 , 0.75137112, 0.74954296, 0.75411335, 0.74862888,\n",
      "       0.75502742, 0.75411335, 0.75411335, 0.75411335, 0.7559415 ,\n",
      "       0.75685558, 0.75411335, 0.7559415 , 0.75411335]), 'split1_test_score': array([0.78793419, 0.78427788, 0.78702011, 0.78884826, 0.78793419,\n",
      "       0.78884826, 0.7833638 , 0.79250457, 0.7797075 , 0.78427788,\n",
      "       0.78793419, 0.78427788, 0.78244973, 0.78244973]), 'split2_test_score': array([0.74771481, 0.7559415 , 0.74497258, 0.74588665, 0.74223035,\n",
      "       0.74131627, 0.74314442, 0.75502742, 0.75045704, 0.74862888,\n",
      "       0.75137112, 0.75045704, 0.74771481, 0.74771481]), 'split3_test_score': array([0.74862888, 0.73491773, 0.73674589, 0.74497258, 0.75319927,\n",
      "       0.74862888, 0.75045704, 0.74223035, 0.74954296, 0.73765996,\n",
      "       0.74497258, 0.74131627, 0.74131627, 0.74223035]), 'split4_test_score': array([0.7483989 , 0.74199451, 0.73559012, 0.7483989 , 0.74565416,\n",
      "       0.74473925, 0.74748399, 0.75754803, 0.77218664, 0.75663312,\n",
      "       0.75663312, 0.75937786, 0.75297347, 0.75388838]), 'mean_test_score': array([0.75534706, 0.75370055, 0.75077433, 0.75644395, 0.75552937,\n",
      "       0.75571202, 0.75571252, 0.76028474, 0.7612015 , 0.75662827,\n",
      "       0.75955332, 0.75790848, 0.75607915, 0.75607932]), 'std_test_score': array([0.0163769 , 0.01694253, 0.01884829, 0.01651207, 0.0165982 ,\n",
      "       0.01718307, 0.01428591, 0.01695461, 0.01236731, 0.0154192 ,\n",
      "       0.01483796, 0.01444114, 0.01409238, 0.01389836]), 'rank_test_score': array([12, 13, 14,  6, 11, 10,  9,  2,  1,  5,  3,  4,  8,  7])}\n",
      "RandomForestClassifier(class_weight='balanced_subsample', max_depth=3,\n",
      "                       n_estimators=30, random_state=0)\n"
     ]
    }
   ],
   "source": [
    "print(randomforestCAD.cv_results_)\n",
    "print(randomforestCAD.best_estimator_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "RandomForestClassifier.__init__() got an unexpected keyword argument 'min_impurity_split'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32me:\\Comsats\\python\\heartDiseasePrediction\\CNN_Coronary_Heart_Disease.ipynb Cell 79\u001b[0m in \u001b[0;36m1\n\u001b[1;32m----> <a href='vscode-notebook-cell:/e%3A/Comsats/python/heartDiseasePrediction/CNN_Coronary_Heart_Disease.ipynb#Y140sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m randomforestCADopt \u001b[39m=\u001b[39m RandomForestClassifier(bootstrap\u001b[39m=\u001b[39;49m\u001b[39mTrue\u001b[39;49;00m, class_weight\u001b[39m=\u001b[39;49m\u001b[39m'\u001b[39;49m\u001b[39mbalanced_subsample\u001b[39;49m\u001b[39m'\u001b[39;49m,\n\u001b[0;32m      <a href='vscode-notebook-cell:/e%3A/Comsats/python/heartDiseasePrediction/CNN_Coronary_Heart_Disease.ipynb#Y140sZmlsZQ%3D%3D?line=1'>2</a>\u001b[0m             criterion\u001b[39m=\u001b[39;49m\u001b[39m'\u001b[39;49m\u001b[39mgini\u001b[39;49m\u001b[39m'\u001b[39;49m, max_depth\u001b[39m=\u001b[39;49m\u001b[39m2\u001b[39;49m, max_features\u001b[39m=\u001b[39;49m\u001b[39m'\u001b[39;49m\u001b[39mauto\u001b[39;49m\u001b[39m'\u001b[39;49m,\n\u001b[0;32m      <a href='vscode-notebook-cell:/e%3A/Comsats/python/heartDiseasePrediction/CNN_Coronary_Heart_Disease.ipynb#Y140sZmlsZQ%3D%3D?line=2'>3</a>\u001b[0m             max_leaf_nodes\u001b[39m=\u001b[39;49m\u001b[39mNone\u001b[39;49;00m, min_impurity_decrease\u001b[39m=\u001b[39;49m\u001b[39m0.0\u001b[39;49m,\n\u001b[0;32m      <a href='vscode-notebook-cell:/e%3A/Comsats/python/heartDiseasePrediction/CNN_Coronary_Heart_Disease.ipynb#Y140sZmlsZQ%3D%3D?line=3'>4</a>\u001b[0m             min_impurity_split\u001b[39m=\u001b[39;49m\u001b[39mNone\u001b[39;49;00m, min_samples_leaf\u001b[39m=\u001b[39;49m\u001b[39m1\u001b[39;49m,\n\u001b[0;32m      <a href='vscode-notebook-cell:/e%3A/Comsats/python/heartDiseasePrediction/CNN_Coronary_Heart_Disease.ipynb#Y140sZmlsZQ%3D%3D?line=4'>5</a>\u001b[0m             min_samples_split\u001b[39m=\u001b[39;49m\u001b[39m2\u001b[39;49m, min_weight_fraction_leaf\u001b[39m=\u001b[39;49m\u001b[39m0.0\u001b[39;49m,\n\u001b[0;32m      <a href='vscode-notebook-cell:/e%3A/Comsats/python/heartDiseasePrediction/CNN_Coronary_Heart_Disease.ipynb#Y140sZmlsZQ%3D%3D?line=5'>6</a>\u001b[0m             n_estimators\u001b[39m=\u001b[39;49m\u001b[39m50\u001b[39;49m, n_jobs\u001b[39m=\u001b[39;49m\u001b[39mNone\u001b[39;49;00m, oob_score\u001b[39m=\u001b[39;49m\u001b[39mFalse\u001b[39;49;00m, random_state\u001b[39m=\u001b[39;49m\u001b[39m0\u001b[39;49m,\n\u001b[0;32m      <a href='vscode-notebook-cell:/e%3A/Comsats/python/heartDiseasePrediction/CNN_Coronary_Heart_Disease.ipynb#Y140sZmlsZQ%3D%3D?line=6'>7</a>\u001b[0m             verbose\u001b[39m=\u001b[39;49m\u001b[39m0\u001b[39;49m, warm_start\u001b[39m=\u001b[39;49m\u001b[39mFalse\u001b[39;49;00m)\n\u001b[0;32m      <a href='vscode-notebook-cell:/e%3A/Comsats/python/heartDiseasePrediction/CNN_Coronary_Heart_Disease.ipynb#Y140sZmlsZQ%3D%3D?line=8'>9</a>\u001b[0m randomforestCADopt\u001b[39m.\u001b[39mfit(x_train_org,y_train_org)\n\u001b[0;32m     <a href='vscode-notebook-cell:/e%3A/Comsats/python/heartDiseasePrediction/CNN_Coronary_Heart_Disease.ipynb#Y140sZmlsZQ%3D%3D?line=9'>10</a>\u001b[0m predlabel \u001b[39m=\u001b[39m randomforestCADopt\u001b[39m.\u001b[39mpredict(x_test_org)\n",
      "\u001b[1;31mTypeError\u001b[0m: RandomForestClassifier.__init__() got an unexpected keyword argument 'min_impurity_split'"
     ]
    }
   ],
   "source": [
    "randomforestCADopt = RandomForestClassifier(bootstrap=True, class_weight='balanced_subsample',\n",
    "            criterion='gini', max_depth=2, max_features='auto',\n",
    "            max_leaf_nodes=None, min_impurity_decrease=0.0,\n",
    "            min_impurity_split=None, min_samples_leaf=1,\n",
    "            min_samples_split=2, min_weight_fraction_leaf=0.0,\n",
    "            n_estimators=50, n_jobs=None, oob_score=False, random_state=0,\n",
    "            verbose=0, warm_start=False)\n",
    "\n",
    "randomforestCADopt.fit(x_train_org,y_train_org)\n",
    "predlabel = randomforestCADopt.predict(x_test_org)\n",
    "confMat = metrics.confusion_matrix(y_test_org,predlabel)\n",
    "print(confMat)\n",
    "evaluation(y_test_org,predlabel)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The following section shows the result when 70% of data are used for training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "# With train-test split\n",
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test, Y_train, Y_test = train_test_split(reduced_data, opLabel, test_size = 0.3, random_state = 24)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "scaler = preprocessing.StandardScaler().fit(X_train)\n",
    "X_train = scaler.transform(X_train)\n",
    "X_test  = scaler.transform(X_test)\n",
    "X_train = X_train.reshape(X_train.shape[0],X_train.shape[1],1)\n",
    "X_test = X_test.reshape(X_test.shape[0],X_test.shape[1],1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "#%% one-hot-encoding\n",
    "Y_train = keras.utils.to_categorical(Y_train,2)\n",
    "Y_test  = keras.utils.to_categorical(Y_test,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_8\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " input_9 (InputLayer)        [(None, 45, 1)]           0         \n",
      "                                                                 \n",
      " reshape_15 (Reshape)        (None, 45)                0         \n",
      "                                                                 \n",
      " dense_22 (Dense)            (None, 512)               23552     \n",
      "                                                                 \n",
      " batch_normalization_25 (Bat  (None, 512)              2048      \n",
      " chNormalization)                                                \n",
      "                                                                 \n",
      " activation_33 (Activation)  (None, 512)               0         \n",
      "                                                                 \n",
      " dropout_12 (Dropout)        (None, 512)               0         \n",
      "                                                                 \n",
      " dense_23 (Dense)            (None, 128)               65664     \n",
      "                                                                 \n",
      " batch_normalization_26 (Bat  (None, 128)              512       \n",
      " chNormalization)                                                \n",
      "                                                                 \n",
      " activation_34 (Activation)  (None, 128)               0         \n",
      "                                                                 \n",
      " dropout_13 (Dropout)        (None, 128)               0         \n",
      "                                                                 \n",
      " dense_24 (Dense)            (None, 2)                 258       \n",
      "                                                                 \n",
      " activation_35 (Activation)  (None, 2)                 0         \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 92,034\n",
      "Trainable params: 90,754\n",
      "Non-trainable params: 1,280\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\Mubshr07\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\keras\\optimizers\\optimizer_v2\\adam.py:114: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.\n",
      "  super().__init__(name, **kwargs)\n"
     ]
    }
   ],
   "source": [
    "# MLP -2\n",
    "inputs = keras.layers.Input(shape=(x_train.shape[1],1))\n",
    "RS0    = keras.layers.Reshape((x_train.shape[1], ))(inputs)\n",
    "FC0    = keras.layers.Dense(512, bias_initializer=keras.initializers.VarianceScaling())(RS0)\n",
    "BN0    = keras.layers.BatchNormalization(axis=-1)(FC0)\n",
    "AC0    = keras.layers.Activation('relu')(BN0)\n",
    "DP0    = keras.layers.Dropout(0.2)(AC0)\n",
    "\n",
    "FC1    = keras.layers.Dense(128, bias_initializer=keras.initializers.VarianceScaling())(DP0)\n",
    "BN1    = keras.layers.BatchNormalization(axis=-1)(FC1)\n",
    "AC1    = keras.layers.Activation('relu')(BN1)\n",
    "DP1    = keras.layers.Dropout(0.2)(AC1)\n",
    "\n",
    "\n",
    "FC2 =   keras.layers.Dense(2, bias_initializer=keras.initializers.VarianceScaling())(DP1)\n",
    "outputs = keras.layers.Activation('softmax')(FC2)\n",
    "\n",
    "myMLP = keras.Model(inputs=inputs,outputs=outputs)\n",
    "myMLP.compile(optimizer=keras.optimizers.Adam(lr=0.01),\n",
    "                 loss='categorical_crossentropy',\n",
    "                 metrics=['accuracy'])\n",
    "myMLP.summary()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(25955,)\n",
      "(25955,)\n"
     ]
    }
   ],
   "source": [
    "print(np.where(Y_train==0)[0].shape)\n",
    "print(np.where(Y_train==1)[0].shape)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "22/22 [==============================] - 3s 31ms/step - loss: 1.5940 - accuracy: 0.6158\n",
      "Epoch 2/10\n",
      "22/22 [==============================] - 0s 13ms/step - loss: 1.0919 - accuracy: 0.6542\n",
      "Epoch 3/10\n",
      "22/22 [==============================] - 0s 13ms/step - loss: 1.0705 - accuracy: 0.6843\n",
      "Epoch 4/10\n",
      "22/22 [==============================] - 0s 14ms/step - loss: 1.0010 - accuracy: 0.6777\n",
      "Epoch 5/10\n",
      "22/22 [==============================] - 0s 14ms/step - loss: 0.9779 - accuracy: 0.6991\n",
      "Epoch 6/10\n",
      "22/22 [==============================] - 0s 13ms/step - loss: 0.9330 - accuracy: 0.7081\n",
      "Epoch 7/10\n",
      "22/22 [==============================] - 0s 13ms/step - loss: 0.9441 - accuracy: 0.7090\n",
      "Epoch 8/10\n",
      "22/22 [==============================] - 0s 14ms/step - loss: 0.8834 - accuracy: 0.7179\n",
      "Epoch 9/10\n",
      "22/22 [==============================] - 0s 14ms/step - loss: 0.8576 - accuracy: 0.7260\n",
      "Epoch 10/10\n",
      "22/22 [==============================] - 0s 19ms/step - loss: 0.8531 - accuracy: 0.7356\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.History at 0x20bb7d14550>"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class_weight = {0: 1, 1: 40}\n",
    "\n",
    "myMLP.fit(X_train,Y_train,epochs=10,batch_size=1200,verbose=1, class_weight=class_weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "348/348 [==============================] - 4s 10ms/step - loss: 0.5918 - accuracy: 0.7103\n",
      "0.71026611328125\n"
     ]
    }
   ],
   "source": [
    "test_loss,test_acc = myMLP.evaluate(X_test,Y_test)\n",
    "print(test_acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "348/348 [==============================] - 2s 6ms/step\n",
      "[[7512 3147]\n",
      " [  76  389]]\n"
     ]
    }
   ],
   "source": [
    "from sklearn import metrics\n",
    "predlabel = myMLP.predict(X_test)\n",
    "f = np.argmax(predlabel,axis=1)\n",
    "confMat = metrics.confusion_matrix(np.argmax(Y_test,axis=1),f)\n",
    "print(confMat)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logistic Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s finished\n"
     ]
    }
   ],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "clf = LogisticRegression(solver = 'lbfgs',max_iter=100000, \n",
    "                           class_weight= {0:1, 1:3.0}, verbose=1, random_state = 2)\n",
    "model = clf.fit(x_train_org,y_train_org)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[24944  6327]\n",
      " [   77   262]]\n",
      "Accuracy : 79.741 %\n",
      "Recall : 79.741 %\n",
      "Precision : 3.976 %\n",
      "F1 Score : 87.754 %\n"
     ]
    }
   ],
   "source": [
    "predlabel = model.predict(x_test_org)\n",
    "confMat = metrics.confusion_matrix(y_test_org,predlabel)\n",
    "print(confMat)\n",
    "evaluation(y_test_org, predlabel)"
   ]
  },
  {
   "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.10.4"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}