DSP Project Notebook-1st-Level-Final.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pool Ball Prediction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1st Level Classification"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook provides the 1st level classification of our project. ie, detecting pool ball into Solid or stripe "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dependencies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 392,
   "metadata": {},
   "outputs": [],
   "source": [
    "#depedencies\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import os\n",
    "import matplotlib.pyplot as plt\n",
    "from PIL import Image\n",
    "\n",
    "import keras\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense, Conv2D, Flatten, Activation,MaxPooling2D,Dropout\n",
    "from sklearn.model_selection import StratifiedShuffleSplit\n",
    "from sklearn.model_selection import train_test_split\n",
    "from keras.callbacks import EarlyStopping\n",
    "from keras.layers import GuassianNoise\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import f1_score\n",
    "from sklearn.metrics import precision_score\n",
    "from sklearn.metrics import recall_score\n",
    "from sklearn.metrics import mean_squared_error, r2_score\n",
    "from math import sqrt\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Import Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 393,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Black_Solid_8',\n",
       " 'Blue_Solid_2',\n",
       " 'Blue_Stripe_12',\n",
       " 'Brown_Solid_7',\n",
       " 'Brown_Stripe_15',\n",
       " 'Green_Solid_6',\n",
       " 'Green_Stripe_14',\n",
       " 'Orange_Solid_5',\n",
       " 'Orange_Stripe_13',\n",
       " 'Purple_Solid_4',\n",
       " 'Red_Solid_3',\n",
       " 'Red_Stripe_11',\n",
       " 'Yellow_Solid_1',\n",
       " 'Yellow_Stripe_9']"
      ]
     },
     "execution_count": 393,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Loading folders from Local System  \n",
    "ImageFolders=[]\n",
    "ImageFolders = os.listdir(\"D:/USF CourseWork/ISM 6251 DSP/FinalProject\")\n",
    "ImageFolders\n",
    "#We have 14 folders "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 394,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Loading Image Names from all the folders into databrae\n",
    "Total_data = []\n",
    "ImageFile = [0] * len(ImageFolders)\n",
    "length = 0\n",
    "for i in range(0,len(ImageFolders)):\n",
    "    ImageFile[i] = os.listdir(\"D:/USF CourseWork/ISM 6251 DSP/FinalProject\" + \"/\" + str(ImageFolders[i]))\n",
    "    length = length + len(ImageFile[i])    \n",
    "#ImageFile\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 395,
   "metadata": {},
   "outputs": [],
   "source": [
    "#loading images as numpy array into Jupyter notebook into a list\n",
    "ImageFiles = []\n",
    "for j in range(0, len(ImageFolders)):\n",
    "    for k in range(0,len(ImageFile[j])):\n",
    "        Img=np.array(Image.open(\"D:/USF CourseWork/ISM 6251 DSP/FinalProject\" + \"/\" + str(ImageFolders[j])+ \"/\" + str(ImageFile[j][k])).resize((160,120)))\n",
    "        Total_data.append([Img, ImageFolders[j]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 396,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Images</th>\n",
       "      <th>Labels</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>[[[158, 103, 49], [158, 103, 47], [159, 104, 4...</td>\n",
       "      <td>Black_Solid_8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>[[[157, 105, 53], [159, 108, 55], [162, 112, 5...</td>\n",
       "      <td>Black_Solid_8</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                              Images         Labels\n",
       "0  [[[158, 103, 49], [158, 103, 47], [159, 104, 4...  Black_Solid_8\n",
       "1  [[[157, 105, 53], [159, 108, 55], [162, 112, 5...  Black_Solid_8"
      ]
     },
     "execution_count": 396,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Converting Image list into pandas dataframe\n",
    "ImageDF = pd.DataFrame(Total_data)\n",
    "ImageDF=ImageDF.rename(columns={0: 'Images',1:'Labels'}) #rename pandas dataframe column names\n",
    "ImageDF.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 397,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Since loading images take lots of time, lets make a backup copy of the image files\n",
    "ImageDF1=ImageDF.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 398,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Images</th>\n",
       "      <th>Labels</th>\n",
       "      <th>Color</th>\n",
       "      <th>Type</th>\n",
       "      <th>Number</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>[[[158, 103, 49], [158, 103, 47], [159, 104, 4...</td>\n",
       "      <td>Black_Solid_8</td>\n",
       "      <td>Black</td>\n",
       "      <td>Solid</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>[[[157, 105, 53], [159, 108, 55], [162, 112, 5...</td>\n",
       "      <td>Black_Solid_8</td>\n",
       "      <td>Black</td>\n",
       "      <td>Solid</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>[[[163, 114, 36], [164, 115, 43], [161, 113, 4...</td>\n",
       "      <td>Black_Solid_8</td>\n",
       "      <td>Black</td>\n",
       "      <td>Solid</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                              Images         Labels  Color  \\\n",
       "0  [[[158, 103, 49], [158, 103, 47], [159, 104, 4...  Black_Solid_8  Black   \n",
       "1  [[[157, 105, 53], [159, 108, 55], [162, 112, 5...  Black_Solid_8  Black   \n",
       "2  [[[163, 114, 36], [164, 115, 43], [161, 113, 4...  Black_Solid_8  Black   \n",
       "\n",
       "    Type Number  \n",
       "0  Solid      8  \n",
       "1  Solid      8  \n",
       "2  Solid      8  "
      ]
     },
     "execution_count": 398,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Split label column into Colour type and Number \n",
    "ImageDF1[['Color','Type','Number']] = ImageDF1.Labels.str.split(\"_\",expand=True)\n",
    "ImageDF1.head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 399,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Images</th>\n",
       "      <th>Type</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>[[[158, 103, 49], [158, 103, 47], [159, 104, 4...</td>\n",
       "      <td>Solid</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>[[[157, 105, 53], [159, 108, 55], [162, 112, 5...</td>\n",
       "      <td>Solid</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>[[[163, 114, 36], [164, 115, 43], [161, 113, 4...</td>\n",
       "      <td>Solid</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                              Images   Type\n",
       "0  [[[158, 103, 49], [158, 103, 47], [159, 104, 4...  Solid\n",
       "1  [[[157, 105, 53], [159, 108, 55], [162, 112, 5...  Solid\n",
       "2  [[[163, 114, 36], [164, 115, 43], [161, 113, 4...  Solid"
      ]
     },
     "execution_count": 399,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Type dataframe for 1st level classsification, colour dataframe for 2nd level classsification\n",
    "ImageDF_Type = ImageDF1[['Images','Type']]\n",
    "ImageDF_Color = ImageDF1[['Images','Color','Type']]\n",
    "ImageDF_Type.head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 714,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "StratifiedShuffleSplit(n_splits=5, random_state=42, test_size=0.2,\n",
      "            train_size=None)\n"
     ]
    }
   ],
   "source": [
    "#Creating Test Set by startified split test size \"20%\"\n",
    "\n",
    "split = StratifiedShuffleSplit(n_splits=5,test_size = 0.2,random_state = 42)\n",
    "print(split)\n",
    "for train_index,test_index in split.split(ImageDF_Type,ImageDF_Type[\"Type\"]):\n",
    "    train_set = ImageDF_Type.iloc[train_index]\n",
    "    test_set = ImageDF_Type.iloc[test_index]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 715,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1401,) (351,) (351,) (351,)\n"
     ]
    }
   ],
   "source": [
    "##Creating Validation Set by startified split test size \"20%\"\n",
    "\n",
    "X_train,X_val,y_train,y_val = train_test_split(train_set[\"Images\"],train_set[\"Type\"],test_size=0.2,random_state=42)\n",
    "print(X_train.shape,X_val.shape,y_val.shape,y_val.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 716,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Converting Labels into binary Categorical variables.\n",
    "#y_train = pd.factorize(y_train)\n",
    "y_train_new=[0]*len(y_train)\n",
    "for i in range (0,len(y_train)):\n",
    "    if y_train.iloc[i] == 'Stripe':\n",
    "        y_train_new[i]=[1];\n",
    "    elif y_train.iloc[i] == 'Solid':\n",
    "        y_train_new[i]=[0];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 717,
   "metadata": {},
   "outputs": [],
   "source": [
    "#converting labels of train into numpy array for model\n",
    "y_train_new_array=np.array(y_train_new)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 718,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Similarly to Validation set\n",
    "y_val_new=[0]*len(y_val)\n",
    "for i in range (0,len(y_val)):\n",
    "    if y_val.iloc[i] == 'Stripe':\n",
    "        y_val_new[i]=[1];\n",
    "    elif y_val.iloc[i] == 'Solid':\n",
    "        y_val_new[i]=[0]\n",
    "y_val_new_array=np.array(y_val_new)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 719,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_val_new_array=np.array(y_val_new)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 720,
   "metadata": {},
   "outputs": [],
   "source": [
    "#converting each 3d image in a list into 4D tensor array as we need for input to CNN\n",
    "X_train_new =[0] * len(X_train) \n",
    "for i in range(0,len(X_train)):\n",
    "    X_train_new[i] = np.reshape((X_train.iloc[i]),(120,160,3))\n",
    "\n",
    "X_train_array = np.asarray(X_train_new)\n",
    "\n",
    "X_val_new=[0] * len(X_val)\n",
    "for i in range(0,len(X_val)):\n",
    "    X_val_new[i] = np.reshape((X_val.iloc[i]),(120,160,3))\n",
    "    \n",
    "X_val_array = np.asarray(X_val_new)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modelling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 721,
   "metadata": {},
   "outputs": [],
   "source": [
    "#model defining for CNN 1st level\n",
    "from keras.layers import GaussianNoise\n",
    "model = Sequential()\n",
    "model.add(Conv2D(32, (3, 3), padding='same',\n",
    "                 input_shape=X_train_array.shape[1:]))\n",
    "model.add(GaussianNoise(0.1))\n",
    "model.add(Activation('relu'))\n",
    "model.add(Conv2D(32, (3, 3)))\n",
    "model.add(Activation('relu'))\n",
    "model.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "model.add(Dropout(0.25))\n",
    "\n",
    "model.add(Conv2D(64, (3, 3), padding='same'))\n",
    "model.add(GaussianNoise(0.1))\n",
    "model.add(Activation('relu'))\n",
    "model.add(Conv2D(64, (3, 3)))\n",
    "model.add(Activation('relu'))\n",
    "model.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "model.add(Dropout(0.25))\n",
    "\n",
    "model.add(Flatten())\n",
    "model.add(Dense(512))\n",
    "model.add(Activation('relu'))\n",
    "model.add(Dropout(0.5))\n",
    "model.add(Dense(2))\n",
    "model.add(Activation('softmax'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 722,
   "metadata": {},
   "outputs": [],
   "source": [
    "# initiate RMSprop optimizer\n",
    "opt = keras.optimizers.RMSprop(learning_rate=0.0001, decay=1e-6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 723,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's train the model using RMSprop\n",
    "model.compile(loss='sparse_categorical_crossentropy',optimizer=opt,metrics=['accuracy'])\n",
    "es = EarlyStopping(monitor='val_accuracy',patience=5, verbose=1, mode='max')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 724,
   "metadata": {},
   "outputs": [],
   "source": [
    "#normalising image \n",
    "X_train_array = X_train_array.astype('float32')\n",
    "X_val_array = X_val_array.astype('float32')\n",
    "X_train_array /= 255\n",
    "X_val_array /= 255"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 660,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 1401 samples, validate on 351 samples\n",
      "Epoch 1/10\n",
      "1401/1401 [==============================] - 127s 91ms/step - loss: 1.1027 - accuracy: 0.5739 - val_loss: 0.6512 - val_accuracy: 0.6068\n",
      "Epoch 2/10\n",
      "1401/1401 [==============================] - 127s 90ms/step - loss: 0.6228 - accuracy: 0.6481 - val_loss: 0.5582 - val_accuracy: 0.6895\n",
      "Epoch 3/10\n",
      "1401/1401 [==============================] - 128s 91ms/step - loss: 0.4558 - accuracy: 0.7687 - val_loss: 0.5197 - val_accuracy: 0.6895\n",
      "Epoch 4/10\n",
      "1401/1401 [==============================] - 127s 91ms/step - loss: 0.3529 - accuracy: 0.8301 - val_loss: 0.4329 - val_accuracy: 0.7578\n",
      "Epoch 5/10\n",
      "1401/1401 [==============================] - 127s 91ms/step - loss: 0.2812 - accuracy: 0.8580 - val_loss: 0.4779 - val_accuracy: 0.7692\n",
      "Epoch 6/10\n",
      "1401/1401 [==============================] - 125s 89ms/step - loss: 0.2212 - accuracy: 0.8979 - val_loss: 0.2464 - val_accuracy: 0.8889\n",
      "Epoch 7/10\n",
      "1401/1401 [==============================] - 127s 91ms/step - loss: 0.1688 - accuracy: 0.9293 - val_loss: 0.2305 - val_accuracy: 0.9088\n",
      "Epoch 8/10\n",
      "1401/1401 [==============================] - 125s 89ms/step - loss: 0.1328 - accuracy: 0.9443 - val_loss: 0.2322 - val_accuracy: 0.9117\n",
      "Epoch 9/10\n",
      "1401/1401 [==============================] - 124s 89ms/step - loss: 0.0964 - accuracy: 0.9615 - val_loss: 0.2820 - val_accuracy: 0.8917\n",
      "Epoch 10/10\n",
      "1401/1401 [==============================] - 123s 88ms/step - loss: 0.0747 - accuracy: 0.9679 - val_loss: 0.2746 - val_accuracy: 0.9088\n"
     ]
    }
   ],
   "source": [
    "#fitting model\n",
    "Model1=model.fit(X_train_array, y_train_new_array,\n",
    "              batch_size=32,\n",
    "              epochs=10,\n",
    "              validation_data=(X_val_array, y_val_new_array),\n",
    "              shuffle=True,callbacks=[es])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 711,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Learning curves\n",
    "plt.plot(Model1.history['accuracy'])\n",
    "plt.plot(Model1.history['val_accuracy'])\n",
    "plt.title('Model accuracy')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend(['Train', 'Val'], loc='upper left')\n",
    "plt.show()\n",
    "\n",
    "# Plot training & validation loss values\n",
    "plt.plot(Model1.history['loss'])\n",
    "plt.plot(Model1.history['val_loss'])\n",
    "plt.title('Model loss')\n",
    "plt.ylabel('Loss')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend(['Train', 'Val'], loc='upper left')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### From the above Learning Curve we can see that with increase in epochs the model accuracy has increased and loss has decreased. Our test and Validation accuracy of the model are  0.96  and 0.90 respectively."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# model evaluation on test set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 585,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_test_set=test_set[\"Images\"]\n",
    "Y_test_set=test_set[\"Type\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 586,
   "metadata": {},
   "outputs": [],
   "source": [
    "Y_test_set_list=[0]*len(Y_test_set)\n",
    "for i in range (0,len(Y_test_set)):\n",
    "    if Y_test_set.iloc[i] == 'Stripe':\n",
    "        Y_test_set_list[i]=[1];\n",
    "    elif Y_test_set.iloc[i] == 'Solid':\n",
    "        Y_test_set_list[i]=[0];\n",
    "Y_test_set_array=np.array(Y_test_set_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 587,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_test_set_list =[0] * len(X_test_set) \n",
    "for i in range(0,len(X_test_set)):\n",
    "    X_test_set_list[i] = np.reshape((X_test_set.iloc[i]),(120,160,3))\n",
    "\n",
    "X_test_set_array = np.asarray(X_test_set_list)\n",
    "\n",
    "X_test_set_array = X_test_set_array.astype('float32')\n",
    "X_test_set_array /= 255"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 588,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "439/439 [==============================] - 6s 13ms/step\n",
      "Test loss: 0.09597241651937195\n",
      "Test accuracy: 0.9567198157310486\n"
     ]
    }
   ],
   "source": [
    "#Evaluating model\n",
    "scores = model.evaluate(X_test_set_array, Y_test_set_array, verbose=1)\n",
    "print('Test loss:', scores[0])\n",
    "print('Test accuracy:', scores[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our model has tried to achieve 95% test accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 589,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions=model.predict_classes(X_test_set_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 590,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[270,   0],\n",
       "       [ 19, 150]], dtype=int64)"
      ]
     },
     "execution_count": 590,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Confusion matrix\n",
    "confusion_matrix(Y_test_set_array, predictions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 591,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Precision score of 1st level classifier:1.00\n",
      "Recall score of 1st level classifier:0.89\n"
     ]
    }
   ],
   "source": [
    "#Precision and recall\n",
    "print('Precision score of 1st level classifier:%.2f'%precision_score(Y_test_set_array, predictions))\n",
    "print('Recall score of 1st level classifier:%.2f'%recall_score(Y_test_set_array, predictions))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 592,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "F1 score of first MLP classifier:0.94\n"
     ]
    }
   ],
   "source": [
    "print('F1 score of first MLP classifier:%.2f'%f1_score(y_test_new2_array, predictions))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our model's F1 score is 0.94 and it is on par with the accuracy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# With data generator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 725,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.preprocessing.image import ImageDataGenerator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 726,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      "44/44 [==============================] - 90s 2s/step - loss: 1.1792 - accuracy: 0.5460 - val_loss: 0.6867 - val_accuracy: 0.6068\n",
      "Epoch 2/20\n",
      "44/44 [==============================] - 94s 2s/step - loss: 0.6885 - accuracy: 0.5882 - val_loss: 0.6803 - val_accuracy: 0.6068\n",
      "Epoch 3/20\n",
      "44/44 [==============================] - 94s 2s/step - loss: 0.6728 - accuracy: 0.6146 - val_loss: 0.6766 - val_accuracy: 0.6068\n",
      "Epoch 4/20\n",
      "44/44 [==============================] - 95s 2s/step - loss: 0.6618 - accuracy: 0.6196 - val_loss: 0.6737 - val_accuracy: 0.6068\n",
      "Epoch 5/20\n",
      "44/44 [==============================] - 94s 2s/step - loss: 0.6412 - accuracy: 0.6203 - val_loss: 0.6400 - val_accuracy: 0.6268\n",
      "Epoch 6/20\n",
      "44/44 [==============================] - 104s 2s/step - loss: 0.5922 - accuracy: 0.6902 - val_loss: 0.6203 - val_accuracy: 0.7151\n",
      "Epoch 7/20\n",
      "44/44 [==============================] - 98s 2s/step - loss: 0.5431 - accuracy: 0.7238 - val_loss: 0.5383 - val_accuracy: 0.7123\n",
      "Epoch 8/20\n",
      "44/44 [==============================] - 109s 2s/step - loss: 0.4887 - accuracy: 0.7645 - val_loss: 0.5556 - val_accuracy: 0.7009\n",
      "Epoch 9/20\n",
      "44/44 [==============================] - 125s 3s/step - loss: 0.4744 - accuracy: 0.7787 - val_loss: 0.5067 - val_accuracy: 0.7350\n",
      "Epoch 10/20\n",
      "44/44 [==============================] - 213s 5s/step - loss: 0.4367 - accuracy: 0.8016 - val_loss: 0.5232 - val_accuracy: 0.7094\n",
      "Epoch 11/20\n",
      "44/44 [==============================] - 174s 4s/step - loss: 0.4096 - accuracy: 0.8094 - val_loss: 0.5144 - val_accuracy: 0.7322\n",
      "Epoch 12/20\n",
      "44/44 [==============================] - 126s 3s/step - loss: 0.3895 - accuracy: 0.8330 - val_loss: 0.4952 - val_accuracy: 0.7407\n",
      "Epoch 13/20\n",
      "44/44 [==============================] - 93s 2s/step - loss: 0.3837 - accuracy: 0.8187 - val_loss: 0.4069 - val_accuracy: 0.8063\n",
      "Epoch 14/20\n",
      "44/44 [==============================] - 94s 2s/step - loss: 0.3866 - accuracy: 0.8223 - val_loss: 0.3906 - val_accuracy: 0.8091\n",
      "Epoch 15/20\n",
      "44/44 [==============================] - 94s 2s/step - loss: 0.3883 - accuracy: 0.8258 - val_loss: 0.4087 - val_accuracy: 0.8006\n",
      "Epoch 16/20\n",
      "44/44 [==============================] - 108s 2s/step - loss: 0.3369 - accuracy: 0.8537 - val_loss: 0.3160 - val_accuracy: 0.8462\n",
      "Epoch 17/20\n",
      "44/44 [==============================] - 94s 2s/step - loss: 0.3255 - accuracy: 0.8630 - val_loss: 0.2971 - val_accuracy: 0.8632\n",
      "Epoch 18/20\n",
      "44/44 [==============================] - 109s 2s/step - loss: 0.3317 - accuracy: 0.8622 - val_loss: 0.4280 - val_accuracy: 0.7607\n",
      "Epoch 19/20\n",
      "44/44 [==============================] - 110s 2s/step - loss: 0.2960 - accuracy: 0.8744 - val_loss: 0.2659 - val_accuracy: 0.8889\n",
      "Epoch 20/20\n",
      "44/44 [==============================] - 110s 3s/step - loss: 0.2942 - accuracy: 0.8687 - val_loss: 0.3539 - val_accuracy: 0.8262\n"
     ]
    }
   ],
   "source": [
    "datagen = ImageDataGenerator(\n",
    "        featurewise_center=False,  # set input mean to 0 over the dataset\n",
    "        samplewise_center=False,  # set each sample mean to 0\n",
    "        featurewise_std_normalization=False,  # divide inputs by std of the dataset\n",
    "        samplewise_std_normalization=False,  # divide each input by its std\n",
    "        zca_whitening=False,  # apply ZCA whitening\n",
    "        zca_epsilon=1e-06,  # epsilon for ZCA whitening\n",
    "        rotation_range=0,  # randomly rotate images in the range (degrees, 0 to 180)\n",
    "        # randomly shift images horizontally (fraction of total width)\n",
    "        width_shift_range=0.1,\n",
    "        # randomly shift images vertically (fraction of total height)\n",
    "        height_shift_range=0.1,\n",
    "        shear_range=0.3,  \n",
    "        zoom_range=0.3,  \n",
    "        channel_shift_range=0.2,  \n",
    "        fill_mode='nearest',\n",
    "        cval=0.2,  \n",
    "        horizontal_flip=True,  # randomly flip images\n",
    "        vertical_flip=True,  # randomly flip images\n",
    "        rescale=None,\n",
    "        preprocessing_function=None,\n",
    "        data_format=None,\n",
    "        validation_split=0.2)\n",
    "datagen.fit(X_train_array)\n",
    "Model2=model.fit_generator(datagen.flow(X_train_array, y_train_new_array,\n",
    "                                     batch_size=32),\n",
    "                        epochs=20,\n",
    "                        validation_data=(X_val_array, y_val_new_array),\n",
    "                        workers=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 727,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Learning curves\n",
    "plt.plot(Model2.history['accuracy'])\n",
    "plt.plot(Model2.history['val_accuracy'])\n",
    "plt.title('Model accuracy')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend(['Train', 'Val'], loc='upper left')\n",
    "plt.show()\n",
    "\n",
    "# Plot training & validation loss values\n",
    "plt.plot(Model2.history['loss'])\n",
    "plt.plot(Model2.history['val_loss'])\n",
    "plt.title('Model loss')\n",
    "plt.ylabel('Loss')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend(['Train', 'Val'], loc='upper left')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 728,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "439/439 [==============================] - 4s 9ms/step\n",
      "Test loss: 0.28581935123186175\n",
      "Test accuracy: 0.8656036257743835\n"
     ]
    }
   ],
   "source": [
    "scores = model.evaluate(X_test_set_array, Y_test_set_array, verbose=1)\n",
    "print('Test loss:', scores[0])\n",
    "print('Test accuracy:', scores[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 729,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions=model.predict_classes(X_test_set_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 730,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[220,  50],\n",
       "       [  9, 160]], dtype=int64)"
      ]
     },
     "execution_count": 730,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Confusion matrix\n",
    "confusion_matrix(Y_test_set_array, predictions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 731,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "F1 score of first version of classifier:0.84\n"
     ]
    }
   ],
   "source": [
    "print('F1 score of first version of classifier:%.2f'%f1_score(y_test_new2_array, predictions))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "F1 score has been decreased from 0.94 to 0.88. but model generalised more"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}