Traffic Sign Recognition.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5824f096",
   "metadata": {},
   "source": [
    "## Import the packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3193c2ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "import warnings\n",
    "from tensorflow.keras.preprocessing.image import load_img\n",
    "import os\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import accuracy_score\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd3f433e",
   "metadata": {},
   "source": [
    "## Load the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "68f18c28",
   "metadata": {},
   "outputs": [],
   "source": [
    "curr_dir = os.getcwd()\n",
    "curr_dir"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "bab02e5c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# get the location of the data folder\n",
    "\n",
    "data_dir = os.path.join(curr_dir,'Data')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "4ffb31ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_csv = pd.read_csv(data_dir+'/'+'Test.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "0406dc8d",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_dir = os.path.join(data_dir,'Train')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "622f7614",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_dir = os.path.join(data_dir,'Test')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "3cd15892",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Image collection and Preprocessing\n",
    "#collect all the training images\n",
    "\n",
    "classIds = 43\n",
    "datalist = []\n",
    "labels = []\n",
    "for i in range(43):\n",
    "    folder = os.path.join(train_dir,str(i))\n",
    "    for image in os.listdir(folder):\n",
    "        image = load_img(folder+\"/\"+image)\n",
    "        image = image.resize((50,50)) # resizing all the images to same size\n",
    "        img = np.array(image)  #convert all images to arrays\n",
    "        datalist.append(img)\n",
    "        labels.append(i)\n",
    "data = np.array(datalist)\n",
    "labels = np.array(labels)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59b24f3b",
   "metadata": {},
   "source": [
    "## Training,Cross-validation and model tuning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "bd97a035",
   "metadata": {},
   "outputs": [],
   "source": [
    "# split the data into train and validation sets\n",
    "\n",
    "x_train,x_val,y_train,y_val = train_test_split(data,labels,test_size=0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "5c0a7c93",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(31367, 50, 50, 3)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "ab42d5cd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(31367,)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "700bbadf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(7842, 50, 50, 3)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_val.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "7274619f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(7842,)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_val.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94b068ce",
   "metadata": {},
   "source": [
    "Since we are dealing with classification problem we have to perform one hot encoding on our labels. It is optional though instead of that we can just leave it and use appropriate loss function during compilation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "56dd9918",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Perform one-hot encoding on the labels\n",
    "\n",
    "y_train = tf.one_hot(y_train,43)\n",
    "y_val = tf.one_hot(y_val,43)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83b2da12",
   "metadata": {},
   "source": [
    "### Build the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "3b98e142",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Architecture of the model\n",
    "\n",
    "model = tf.keras.Sequential()\n",
    "model.add(tf.keras.layers.Conv2D(16,(3,3),activation='relu',input_shape = (50,50,3),padding='same'))\n",
    "model.add(tf.keras.layers.MaxPooling2D((2,2)))\n",
    "\n",
    "model.add(tf.keras.layers.Conv2D(32,(3,3),padding='same',activation='relu'))\n",
    "model.add(tf.keras.layers.MaxPooling2D((2,2)))\n",
    "\n",
    "model.add(tf.keras.layers.Dropout(0.25))\n",
    "\n",
    "model.add(tf.keras.layers.Conv2D(64,(3,3),padding='same',activation='relu'))\n",
    "model.add(tf.keras.layers.MaxPooling2D((2,2)))\n",
    "\n",
    "model.add(tf.keras.layers.Conv2D(128,(3,3),padding='same',activation='relu'))\n",
    "model.add(tf.keras.layers.MaxPooling2D((2,2)))\n",
    "\n",
    "model.add(tf.keras.layers.Dropout(0.25))\n",
    "\n",
    "model.add(tf.keras.layers.Conv2D(128,(3,3),padding='same',activation='relu'))\n",
    "model.add(tf.keras.layers.MaxPooling2D((2,2)))\n",
    "\n",
    "model.add(tf.keras.layers.Flatten()) # flatten the output of previous layer to 1D array in order to feed into fully connected layer\n",
    "\n",
    "model.add(tf.keras.layers.Dropout(0.25))\n",
    "\n",
    "model.add(tf.keras.layers.Dense(512,activation='relu'))\n",
    "model.add(tf.keras.layers.Dense(512,activation='relu'))\n",
    "\n",
    "model.add(tf.keras.layers.Dense(43,activation='softmax'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "fe47ae1b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Specify batch size and no of epochs\n",
    "\n",
    "batch_size = 64\n",
    "epochs = 20"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd64de71",
   "metadata": {},
   "source": [
    "### Compile the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "75fbc3f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compile the model\n",
    "\n",
    "model.compile(optimizer='adam',loss=\"categorical_crossentropy\",metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "a4dc705a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " conv2d (Conv2D)             (None, 50, 50, 16)        448       \n",
      "                                                                 \n",
      " max_pooling2d (MaxPooling2D  (None, 25, 25, 16)       0         \n",
      " )                                                               \n",
      "                                                                 \n",
      " conv2d_1 (Conv2D)           (None, 25, 25, 32)        4640      \n",
      "                                                                 \n",
      " max_pooling2d_1 (MaxPooling  (None, 12, 12, 32)       0         \n",
      " 2D)                                                             \n",
      "                                                                 \n",
      " dropout (Dropout)           (None, 12, 12, 32)        0         \n",
      "                                                                 \n",
      " conv2d_2 (Conv2D)           (None, 12, 12, 64)        18496     \n",
      "                                                                 \n",
      " max_pooling2d_2 (MaxPooling  (None, 6, 6, 64)         0         \n",
      " 2D)                                                             \n",
      "                                                                 \n",
      " conv2d_3 (Conv2D)           (None, 6, 6, 128)         73856     \n",
      "                                                                 \n",
      " max_pooling2d_3 (MaxPooling  (None, 3, 3, 128)        0         \n",
      " 2D)                                                             \n",
      "                                                                 \n",
      " dropout_1 (Dropout)         (None, 3, 3, 128)         0         \n",
      "                                                                 \n",
      " conv2d_4 (Conv2D)           (None, 3, 3, 128)         147584    \n",
      "                                                                 \n",
      " max_pooling2d_4 (MaxPooling  (None, 1, 1, 128)        0         \n",
      " 2D)                                                             \n",
      "                                                                 \n",
      " flatten (Flatten)           (None, 128)               0         \n",
      "                                                                 \n",
      " dropout_2 (Dropout)         (None, 128)               0         \n",
      "                                                                 \n",
      " dense (Dense)               (None, 512)               66048     \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 512)               262656    \n",
      "                                                                 \n",
      " dense_2 (Dense)             (None, 43)                22059     \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 595,787\n",
      "Trainable params: 595,787\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "# summary of the model\n",
    "\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7443ed3",
   "metadata": {},
   "source": [
    "We have a total of around 6,00,000 trainable paramaters in our model which gets updated during the training process according to the training loss."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "02661412",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      "491/491 [==============================] - 7s 11ms/step - loss: 2.5591 - accuracy: 0.2823 - val_loss: 1.3271 - val_accuracy: 0.5333\n",
      "Epoch 2/20\n",
      "491/491 [==============================] - 5s 11ms/step - loss: 1.0360 - accuracy: 0.6604 - val_loss: 0.4178 - val_accuracy: 0.8623\n",
      "Epoch 3/20\n",
      "491/491 [==============================] - 5s 11ms/step - loss: 0.5546 - accuracy: 0.8197 - val_loss: 0.2143 - val_accuracy: 0.9323\n",
      "Epoch 4/20\n",
      "491/491 [==============================] - 5s 11ms/step - loss: 0.3806 - accuracy: 0.8798 - val_loss: 0.1654 - val_accuracy: 0.9467\n",
      "Epoch 5/20\n",
      "491/491 [==============================] - 5s 11ms/step - loss: 0.2862 - accuracy: 0.9113 - val_loss: 0.1035 - val_accuracy: 0.9707\n",
      "Epoch 6/20\n",
      "491/491 [==============================] - 5s 11ms/step - loss: 0.2457 - accuracy: 0.9254 - val_loss: 0.0681 - val_accuracy: 0.9818\n",
      "Epoch 7/20\n",
      "491/491 [==============================] - 6s 12ms/step - loss: 0.2080 - accuracy: 0.9377 - val_loss: 0.0572 - val_accuracy: 0.9834\n",
      "Epoch 8/20\n",
      "491/491 [==============================] - 5s 11ms/step - loss: 0.1831 - accuracy: 0.9454 - val_loss: 0.0893 - val_accuracy: 0.9767\n",
      "Epoch 9/20\n",
      "491/491 [==============================] - 5s 11ms/step - loss: 0.1761 - accuracy: 0.9493 - val_loss: 0.0700 - val_accuracy: 0.9815\n",
      "Epoch 10/20\n",
      "491/491 [==============================] - 5s 11ms/step - loss: 0.1889 - accuracy: 0.9470 - val_loss: 0.0656 - val_accuracy: 0.9809\n",
      "Epoch 11/20\n",
      "491/491 [==============================] - 5s 11ms/step - loss: 0.1616 - accuracy: 0.9542 - val_loss: 0.0434 - val_accuracy: 0.9883\n",
      "Epoch 12/20\n",
      "491/491 [==============================] - 5s 11ms/step - loss: 0.1406 - accuracy: 0.9596 - val_loss: 0.0311 - val_accuracy: 0.9907\n",
      "Epoch 13/20\n",
      "491/491 [==============================] - 5s 11ms/step - loss: 0.1353 - accuracy: 0.9616 - val_loss: 0.0401 - val_accuracy: 0.9883\n",
      "Epoch 14/20\n",
      "491/491 [==============================] - 5s 11ms/step - loss: 0.1430 - accuracy: 0.9602 - val_loss: 0.0523 - val_accuracy: 0.9858\n",
      "Epoch 15/20\n",
      "491/491 [==============================] - 5s 11ms/step - loss: 0.1323 - accuracy: 0.9637 - val_loss: 0.0341 - val_accuracy: 0.9912\n",
      "Epoch 16/20\n",
      "491/491 [==============================] - 5s 11ms/step - loss: 0.1264 - accuracy: 0.9665 - val_loss: 0.0297 - val_accuracy: 0.9926\n",
      "Epoch 17/20\n",
      "491/491 [==============================] - 5s 11ms/step - loss: 0.1286 - accuracy: 0.9652 - val_loss: 0.0503 - val_accuracy: 0.9851\n",
      "Epoch 18/20\n",
      "491/491 [==============================] - 5s 11ms/step - loss: 0.1130 - accuracy: 0.9701 - val_loss: 0.0280 - val_accuracy: 0.9926\n",
      "Epoch 19/20\n",
      "491/491 [==============================] - 5s 11ms/step - loss: 0.1456 - accuracy: 0.9626 - val_loss: 0.0580 - val_accuracy: 0.9830\n",
      "Epoch 20/20\n",
      "491/491 [==============================] - 5s 11ms/step - loss: 0.1233 - accuracy: 0.9677 - val_loss: 0.0423 - val_accuracy: 0.9878\n"
     ]
    }
   ],
   "source": [
    "# Train the model\n",
    "\n",
    "history = model.fit(x_train,y_train,\n",
    "                   epochs=epochs,batch_size=batch_size,validation_data=(x_val,y_val))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "cbf733d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# get the fit method results\n",
    "\n",
    "loss= history.history['loss']\n",
    "train_acc = history.history['accuracy']\n",
    "\n",
    "val_loss = history.history['val_loss']\n",
    "val_acc = history.history['val_accuracy']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "a15f6e31",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1008x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot the loss vs epochs \n",
    "\n",
    "plt.figure(figsize=(14,10))\n",
    "iterations = range(epochs)\n",
    "plt.plot(iterations,loss,label='Training_loss',color='red')\n",
    "plt.plot(iterations,val_loss,label='validation_loss',color='blue')\n",
    "plt.xlabel('no of iterations')\n",
    "plt.ylabel('loss')\n",
    "plt.title('Loss vs No of iterations')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "33153851",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(14,10))\n",
    "iterations = range(epochs)\n",
    "plt.plot(iterations,train_acc,label='Training_accuracy',color='red')\n",
    "plt.plot(iterations,val_acc,label='validation_accuracy',color='blue')\n",
    "plt.xlabel('no of iterations')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.title('Accuracy vs No of iterations')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70105543",
   "metadata": {},
   "source": [
    "- Observations:\n",
    "    - Train accuracy and validation accuracy remains almost same after 10 epochs. so it's probably better to keep epochs to 10.\n",
    "    - Model seems to perform very well on both training and validation sets  \n",
    "    - Model seems to perform well on validation set more than on training set. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4da3e935",
   "metadata": {},
   "source": [
    "## Predictions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f08a4ff",
   "metadata": {},
   "source": [
    "Before we make predictions we have to collect our test images from test folder in our base directory. Then we will test our model on this set to see how well it generalizes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "c6e5bb19",
   "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>Width</th>\n",
       "      <th>Height</th>\n",
       "      <th>Roi.X1</th>\n",
       "      <th>Roi.Y1</th>\n",
       "      <th>Roi.X2</th>\n",
       "      <th>Roi.Y2</th>\n",
       "      <th>ClassId</th>\n",
       "      <th>Path</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>53</td>\n",
       "      <td>54</td>\n",
       "      <td>6</td>\n",
       "      <td>5</td>\n",
       "      <td>48</td>\n",
       "      <td>49</td>\n",
       "      <td>16</td>\n",
       "      <td>Test/00000.png</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>42</td>\n",
       "      <td>45</td>\n",
       "      <td>5</td>\n",
       "      <td>5</td>\n",
       "      <td>36</td>\n",
       "      <td>40</td>\n",
       "      <td>1</td>\n",
       "      <td>Test/00001.png</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>48</td>\n",
       "      <td>52</td>\n",
       "      <td>6</td>\n",
       "      <td>6</td>\n",
       "      <td>43</td>\n",
       "      <td>47</td>\n",
       "      <td>38</td>\n",
       "      <td>Test/00002.png</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>27</td>\n",
       "      <td>29</td>\n",
       "      <td>5</td>\n",
       "      <td>5</td>\n",
       "      <td>22</td>\n",
       "      <td>24</td>\n",
       "      <td>33</td>\n",
       "      <td>Test/00003.png</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>60</td>\n",
       "      <td>57</td>\n",
       "      <td>5</td>\n",
       "      <td>5</td>\n",
       "      <td>55</td>\n",
       "      <td>52</td>\n",
       "      <td>11</td>\n",
       "      <td>Test/00004.png</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Width  Height  Roi.X1  Roi.Y1  Roi.X2  Roi.Y2  ClassId            Path\n",
       "0     53      54       6       5      48      49       16  Test/00000.png\n",
       "1     42      45       5       5      36      40        1  Test/00001.png\n",
       "2     48      52       6       6      43      47       38  Test/00002.png\n",
       "3     27      29       5       5      22      24       33  Test/00003.png\n",
       "4     60      57       5       5      55      52       11  Test/00004.png"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_csv.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "8763695b",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_labels = test_csv['ClassId'].values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "024287bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the test images, resize them and convert them into numpy arrays.\n",
    "\n",
    "image_paths = test_csv['Path'].values\n",
    "test_images = []\n",
    "\n",
    "for img_path in image_paths:\n",
    "    image = load_img(data_dir+'/'+img_path)\n",
    "    image = image.resize((50,50))\n",
    "    img = np.array(image)\n",
    "    test_images.append(img)\n",
    "\n",
    "test_images = np.array(test_images)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "4707c317",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "395/395 [==============================] - 1s 3ms/step\n"
     ]
    }
   ],
   "source": [
    "# make predictions\n",
    "\n",
    "predictions = model.predict(test_images)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "0e4e53e0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12630"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(predictions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "1d81421c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the id of each test image and store it in a list\n",
    "\n",
    "pred_labels = []\n",
    "\n",
    "for i,arr in enumerate(predictions):\n",
    "    y_pred = np.argmax(arr)\n",
    "    pred_labels.append(y_pred)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "e683464f",
   "metadata": {},
   "outputs": [],
   "source": [
    "pred_labels = np.array(pred_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "bbad6a8f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.9642913697545527\n"
     ]
    }
   ],
   "source": [
    "# Calculate the accuracy of model on test images.\n",
    "\n",
    "print('Accuracy: ',accuracy_score(test_labels,pred_labels))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d330661",
   "metadata": {},
   "source": [
    "After so many trial and error, I have managed to increase the accuracy of my model from 91 % to 96.4 % using popular overfitting remedy called dropout."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bd5831b",
   "metadata": {},
   "source": [
    "### Save the model for deployment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9cec3f62",
   "metadata": {},
   "outputs": [],
   "source": [
    "# save the model for future purposes\n",
    "\n",
    "model.save('my_model')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.12"
  },
  "vscode": {
   "interpreter": {
    "hash": "09fd5e14ca5ef89fb8e101525347d1592dbe686e091b6080b74fcfad67235427"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}