train-NN - Final.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Neural Network model "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The code here represents the Neural Network machine learning model to predict whether a person is affected by covid or pneumonia or whether the person is in normal state using the chest X-Ray. The Chest X-Ray images have been preproccessed and then the features have been extracted and stored in .mat files. We now load these files and create the Neural Network model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing the required packages\n",
    "from utils import*\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix\n",
    "from sklearn.neural_network import MLPClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Mentioning the working directory\n",
    "source_dir='./'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Accessing covid.mat file and getting the data from the file\n",
    "covid_features=sio.loadmat(os.path.join(source_dir,'covid.mat')) \n",
    "covid_features=covid_features['covid'] \n",
    "# Accessing normal.mat file and getting the data from the file\n",
    "normal_features=sio.loadmat(os.path.join(source_dir,'normal.mat')) \n",
    "normal_features=normal_features['normal']  \n",
    "# Accessing pneumonia.mat file and getting the data from the file\n",
    "pneumonia_features=sio.loadmat(os.path.join(source_dir,'pneumonia.mat')) \n",
    "pneumonia_features=pneumonia_features['pneumonia']  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Extracting the scores-i.e the inputs and storing it in X\n",
    "X=np.concatenate((covid_features[:,:-1],normal_features[:,:-1],pneumonia_features[:,:-1]), axis=0)\n",
    "# Extracting the target labels, the last column alone\n",
    "y=np.concatenate((covid_features[:,-1],normal_features[:,-1],pneumonia_features[:,-1]), axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Normalization of the data between 0 and 1\n",
    "min_max_scaler=MinMaxScaler()\n",
    "X = min_max_scaler.fit_transform(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We use Kernel to reduce the feature components to 64 for the input data\n",
    "transformer = KernelPCA(n_components=64, kernel='linear')\n",
    "X = transformer.fit_transform(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We do the splitting of data set and set the training data to be 80% ,i.e, test data = 20%\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1)\n",
    "# From that 80%, test data fraction is set as 25% to get a better output as there is more randomness in the dataset for testing\n",
    "X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.25, random_state=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Size of train data: (225, 64)\n",
      "Size of train label: (225,)\n",
      "Size of test data: (76, 64)\n",
      "Size of test label: (76,)\n"
     ]
    }
   ],
   "source": [
    "# Printing the size for each of the data\n",
    "print(\"Size of train data:\", np.shape(X_train))\n",
    "print(\"Size of train label:\", np.shape(y_train))\n",
    "print(\"Size of test data:\", np.shape(X_test))\n",
    "print(\"Size of test label:\", np.shape(y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MLPClassifier(activation='relu', alpha=1e-05, batch_size='auto', beta_1=0.9,\n",
       "              beta_2=0.999, early_stopping=False, epsilon=1e-08,\n",
       "              hidden_layer_sizes=(5, 2), learning_rate='constant',\n",
       "              learning_rate_init=0.001, max_iter=200, momentum=0.9,\n",
       "              n_iter_no_change=10, nesterovs_momentum=True, power_t=0.5,\n",
       "              random_state=1, shuffle=True, solver='lbfgs', tol=0.0001,\n",
       "              validation_fraction=0.1, verbose=False, warm_start=False)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating the Neural Network with hidden layer size as 5 x 2\n",
    "clf = MLPClassifier(solver='lbfgs', alpha=1e-5, hidden_layer_sizes=(5, 2), random_state=1)\n",
    "# Training the dataset\n",
    "clf.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "F:\\Anaconda\\lib\\site-packages\\sklearn\\metrics\\classification.py:1437: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples.\n",
      "  'precision', 'predicted', average, warn_for)\n",
      "F:\\Anaconda\\lib\\site-packages\\sklearn\\metrics\\classification.py:1437: UndefinedMetricWarning: F-score is ill-defined and being set to 0.0 in labels with no predicted samples.\n",
      "  'precision', 'predicted', average, warn_for)\n"
     ]
    }
   ],
   "source": [
    "# Predicting/ testing the model\n",
    "y_pred = clf.predict(X_test)\n",
    "#print(y_pred)\n",
    "#Obtaining the evaluation metrics for the model\n",
    "conf_mat = confusion_matrix(y_test, y_pred) # Confusion matrix\n",
    "accuracy = accuracy_score(y_test, y_pred) # Accuracy of prediction\n",
    "precision = precision_score(y_test, y_pred, average='macro') # Precision\n",
    "recall = recall_score(y_test, y_pred, average='macro') # Recall\n",
    "f1 = f1_score(y_test, y_pred, average='macro') # F1-score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Accuracy of the model is: 0.6973684210526315\n"
     ]
    }
   ],
   "source": [
    "print(\"The Accuracy of the model is: \" + str(accuracy))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Precision of the model is: 0.5220125786163522\n"
     ]
    }
   ],
   "source": [
    "print(\"The Precision of the model is: \" + str(precision))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Recall of the model is: 0.5888888888888889\n"
     ]
    }
   ],
   "source": [
    "print(\"The Recall of the model is: \" + str(recall))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The F1-Score for the model is: 0.5302720315223157\n"
     ]
    }
   ],
   "source": [
    "print(\"The F1-Score for the model is: \" + str(f1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Confusion matrix is: \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[23,  0,  7],\n",
       "       [ 0,  0, 16],\n",
       "       [ 0,  0, 30]], dtype=int64)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"The Confusion matrix is: \")\n",
    "conf_mat"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}