CNN_NumberClassification_Notebook_GH.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/NishadKhudabux/ANN-and-CNN-model-for-number-classification/blob/main/CNN_NumberClassification_Notebook_GH.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q91KqmCRu64D"
      },
      "source": [
        "# **Convolutional Neural Networks: Street View Housing Number Digit Recognition**\n",
        "\n",
        "Classification of Street View Housing Numbers (SVHN) image dataset using Convolutional Neural Networks.\n",
        "\n",
        "--------------\n",
        "## **Context** \n",
        "--------------\n",
        "The SVHN dataset contains over 600,000 labeled digits cropped from street-level photos. It is one of the most popular image recognition datasets. It has been used in neural networks created by Google to improve the map quality by automatically transcribing the address numbers from a patch of pixels. The transcribed number with a known street address helps pinpoint the location of the building it represents. \n",
        "\n",
        "----------------\n",
        "## **Objective**\n",
        "----------------\n",
        "\n",
        "To build a CNN model that can recognize the digits in the images.\n",
        "\n",
        "-------------\n",
        "## **Dataset**\n",
        "-------------\n",
        "Here, we will use a subset of the original data to save some computation time. The dataset is provided as a .h5 file. The basic preprocessing steps have been applied on the dataset."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8z2Z7-OAs8QG"
      },
      "source": [
        "## **Mount the drive**\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "03lDyQUuef7z",
        "outputId": "e23a8362-447e-4364-8a0e-1983efc593a5"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ],
      "source": [
        "from google.colab import drive\n",
        "\n",
        "drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C8U3DUa3eNsT"
      },
      "source": [
        "## **Importing the necessary libraries**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-dVzeuF3eQx1"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "\n",
        "import pandas as pd\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "#Data Visualization\n",
        "\n",
        "import seaborn as sns\n",
        "\n",
        "# Model Building\n",
        "\n",
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "from sklearn.preprocessing import MinMaxScaler\n",
        "\n",
        "import tensorflow as tf\n",
        "\n",
        "from tensorflow.keras.models import Sequential\n",
        "\n",
        "from tensorflow.keras.layers import Dense, Conv2D, MaxPool2D, BatchNormalization, Dropout, Flatten, LeakyReLU\n",
        "\n",
        "from tensorflow.keras.losses import categorical_crossentropy\n",
        "\n",
        "from tensorflow.keras.optimizers import Adam\n",
        "\n",
        "from tensorflow.keras.utils import to_categorical"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ucnevGLoyKf_"
      },
      "source": [
        "**Let us check the version of tensorflow.**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "W5as47YxyJVk",
        "outputId": "affc9285-8334-4afc-ce90-8264c620c182"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2.8.2\n"
          ]
        }
      ],
      "source": [
        "print(tf.__version__)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8lsux2ZwyTTR"
      },
      "source": [
        "## **Load the dataset**\n",
        "\n",
        "- Load the dataset that is available as a .h5 file.\n",
        "- Split the data into the train and the test dataset."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BApX9qgNsqV0",
        "scrolled": true
      },
      "outputs": [],
      "source": [
        "import h5py\n",
        "\n",
        "# Open the file as read only\n",
        "# User can make changes in the path as required\n",
        "\n",
        "h5f = h5py.File('/content/drive/MyDrive/Colab Notebooks/MIT-Deep Learning/Elective Project/SVHN_single_grey1.h5', 'r') #change for my drive folders\n",
        "\n",
        "# Load the the train and the test dataset\n",
        "\n",
        "X_train = h5f['X_train'][:]\n",
        "\n",
        "y_train = h5f['y_train'][:]\n",
        "\n",
        "X_test = h5f['X_test'][:]\n",
        "\n",
        "y_test = h5f['y_test'][:]\n",
        "\n",
        "\n",
        "# Close this file\n",
        "\n",
        "h5f.close()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hVe0CYpUgj7w"
      },
      "source": [
        "Let's check the number of images in the training and the testing dataset."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "y3lwKpOefkpA",
        "outputId": "94477c66-545a-4473-bd8e-1a32ec4512a8"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(42000, 18000)"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ],
      "source": [
        "len(X_train), len(X_test)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "akTUOfLlgwoM"
      },
      "source": [
        "**Observation:**\n",
        "- There are 42,000 images in the training data and 18,000 images in the testing data. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kxODV6HKykuc"
      },
      "source": [
        "## **Visualizing images**\n",
        "\n",
        "- Use X_train to visualize the first 10 images.\n",
        "- Use Y_train to print the first 10 labels."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 95
        },
        "id": "Bvsc8ytHsqWD",
        "outputId": "c9fc06bb-625d-4ead-b7d4-518f530485ac"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x72 with 10 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "label for each of the above image: [2 6 7 4 4 0 3 0 7 3]\n"
          ]
        }
      ],
      "source": [
        "# Visualizing the first 10 images in the dataset and printing their labels\n",
        "\n",
        "%matplotlib inline\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "plt.figure(figsize = (10, 1))\n",
        "\n",
        "for i in range(10):\n",
        "\n",
        "    plt.subplot(1, 10, i+1)\n",
        "    \n",
        "    plt.imshow(X_train[i], cmap = \"gray\")  # Write the function to visualize images\n",
        "\n",
        "    plt.axis('off')\n",
        "\n",
        "plt.show()\n",
        "\n",
        "print('label for each of the above image: %s' % (y_train[0:10]))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kzoyeXHOy80N"
      },
      "source": [
        "*italicized text*## **Data preparation**\n",
        "\n",
        "- Print the shape and the array of pixels for the first image in the training dataset.\n",
        "- Reshape the train and the test dataset because we always have to give a 4D array as input to CNNs.\n",
        "- Normalize the train and the test dataset by dividing by 255.\n",
        "- Print the new shapes of the train and the test dataset.\n",
        "- One-hot encode the target variable."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NqndzQXng9rL",
        "outputId": "93f7475b-d035-4a24-d001-7d802b9bab09"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Shape: (32, 32)\n",
            "\n",
            "First image:\n",
            " [[ 33.0704  30.2601  26.852  ...  71.4471  58.2204  42.9939]\n",
            " [ 25.2283  25.5533  29.9765 ... 113.0209 103.3639  84.2949]\n",
            " [ 26.2775  22.6137  40.4763 ... 113.3028 121.775  115.4228]\n",
            " ...\n",
            " [ 28.5502  36.212   45.0801 ...  24.1359  25.0927  26.0603]\n",
            " [ 38.4352  26.4733  23.2717 ...  28.1094  29.4683  30.0661]\n",
            " [ 50.2984  26.0773  24.0389 ...  49.6682  50.853   53.0377]]\n"
          ]
        }
      ],
      "source": [
        "# Shape and the array of pixels for the first image\n",
        "\n",
        "print(\"Shape:\", X_train[0].shape)\n",
        "\n",
        "print()\n",
        "\n",
        "print(\"First image:\\n\", X_train[0])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "D9YPwf9ysqWU"
      },
      "outputs": [],
      "source": [
        "# Reshaping the dataset to be able to pass them to CNNs. Remember that we always have to give a 4D array as input to CNNs\n",
        "\n",
        "X_train = X_train.reshape(X_train.shape[0], 32, 32, 1)\n",
        "\n",
        "X_test = X_test.reshape(X_test.shape[0], 32, 32, 1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "q_yUUTp_mUzB"
      },
      "outputs": [],
      "source": [
        "# Normalize inputs from 0-255 to 0-1\n",
        "\n",
        "X_train = X_train / 255.0\n",
        "\n",
        "X_test = X_test / 255.0"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "t7FSqOpamWkH",
        "outputId": "11c4801d-2bf4-4b96-8736-3ef4cd0040e8"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training set: (42000, 32, 32, 1) (42000,)\n",
            "Test set: (18000, 32, 32, 1) (18000,)\n"
          ]
        }
      ],
      "source": [
        "# New shape \n",
        "\n",
        "print('Training set:', X_train.shape, y_train.shape)\n",
        "\n",
        "print('Test set:', X_test.shape, y_test.shape)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "10QaOV-xR7Jn"
      },
      "source": [
        "### **One-hot encode the labels in the target variable y_train and y_test.**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zL0lYER4sqWw",
        "outputId": "2716f0cd-5aa5-4ec6-ef8b-267a8a82b242"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0., 1., 0., ..., 0., 0., 0.],\n",
              "       [0., 0., 0., ..., 1., 0., 0.],\n",
              "       [0., 0., 1., ..., 0., 0., 0.],\n",
              "       ...,\n",
              "       [0., 0., 0., ..., 1., 0., 0.],\n",
              "       [0., 0., 0., ..., 0., 0., 1.],\n",
              "       [0., 0., 1., ..., 0., 0., 0.]], dtype=float32)"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ],
      "source": [
        "# Write the function and appropriate variable name to one-hot encode the output\n",
        "\n",
        "y_train = to_categorical(y_train)\n",
        "\n",
        "y_test = to_categorical(y_test)\n",
        "\n",
        "# test labels\n",
        "\n",
        "y_test"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ViqPOTquCF76"
      },
      "source": [
        "**Observation:**\n",
        "- Each entry of the target variable is a one-hot encoded vector instead of a single label."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yH-gVrzuByNA"
      },
      "source": [
        "## **Model Building**\n",
        "\n",
        "Now that we have done data preprocessing, let's build a CNN model."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZY5pyF4-KDNt"
      },
      "outputs": [],
      "source": [
        "# Fixing the seed for random number generators\n",
        "\n",
        "np.random.seed(42)\n",
        "\n",
        "import random\n",
        "\n",
        "random.seed(42)\n",
        "\n",
        "tf.random.set_seed(42)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UJDUoaEj1d6e"
      },
      "source": [
        "### **Model Architecture**\n",
        "- **Write a function** that returns a sequential model with the following architecture:\n",
        " - First Convolutional layer with **16 filters and the kernel size of 3x3**. Use the **'same' padding** and provide the **input shape = (32, 32, 1)**\n",
        " - Add a **LeakyRelu layer** with the **slope equal to 0.1**\n",
        " - Second Convolutional layer with **32 filters and the kernel size of 3x3 with 'same' padding**\n",
        " - Another **LeakyRelu** with the **slope equal to 0.1**\n",
        " - A **max-pooling layer** with a **pool size of 2x2**\n",
        " - **Flatten** the output from the previous layer\n",
        " - Add a **dense layer with 32 nodes**\n",
        " - Add a **LeakyRelu layer with the slope equal to 0.1**\n",
        " - Add the final **output layer with nodes equal to the number of classes, i.e., 10** and **'softmax' as the activation function**\n",
        " - Compile the model with the **loss equal to categorical_crossentropy, optimizer equal to Adam(learning_rate = 0.001), and metric equal to 'accuracy'**. Do not fit the model here, just return the compiled model.\n",
        "- Call the function cnn_model_1 and store the output in a new variable.\n",
        "- Print the summary of the model.\n",
        "- Fit the model on the training data with a **validation split of 0.2, batch size = 32, verbose = 1, and epochs = 20**. Store the model building history to use later for visualization."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JWsAd45JKDNu"
      },
      "source": [
        "### **Build and train a CNN model as per the above mentioned architecture.**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Cmi81Gr5sqW-"
      },
      "outputs": [],
      "source": [
        "# Define the model\n",
        "\n",
        "def cnn_model_1():\n",
        "\n",
        "    model = Sequential() \n",
        "    \n",
        "    # Add layers as per the architecture mentioned above in the same sequence\n",
        "\n",
        "    # First Convolutional layer with 16 filters and the kernel size of 3x3. Use the 'same' padding and provide the input shape = (32, 32, 1)\n",
        "    model.add(Conv2D(16, (3,3), padding = \"same\", input_shape = (32,32,1)))\n",
        "\n",
        "    #LeakyRelu layer with the slope equal to 0.1 (LeakyRelu: allows for small negative values when less than 0 to prevent gradient death)\n",
        "    model.add(LeakyReLU(0.1))\n",
        "\n",
        "    #Second Convolutional layer with 32 filters and the kernel size of 3x3 with 'same' padding\n",
        "    model.add(Conv2D(32, (3,3), padding = \"same\"))\n",
        "\n",
        "    #LeakyRelu with the slope equal to 0.1\n",
        "    model.add(LeakyReLU(0.1))\n",
        "\n",
        "    #max-pooling layer with a pool size of 2x2\n",
        "    model.add(MaxPool2D(2,2))\n",
        "\n",
        "    #Flatten \n",
        "    model.add(Flatten())\n",
        "\n",
        "    #dense layer with 32 nodes\n",
        "    model.add(Dense(32))\n",
        "\n",
        "    #LeakyRelu layer with the slope equal to 0.1\n",
        "    model.add(LeakyReLU(0.1))\n",
        "\n",
        "    #output layer with nodes equal to the number of classes, i.e., 10 and 'softmax' as the activation function\n",
        "    model.add(Dense(10, activation='softmax'))\n",
        "    \n",
        "    # Compile the model\n",
        "    #  loss equal to categorical_crossentropy, optimizer equal to Adam(learning_rate = 0.001), and metric equal to 'accuracy'\n",
        "    model.compile(optimizer = Adam(learning_rate =0.001), loss = 'categorical_crossentropy', metrics = ['accuracy'])\n",
        "    \n",
        "    return model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "bGCUI_xsImnH"
      },
      "outputs": [],
      "source": [
        "# Build the model\n",
        "\n",
        "model_1 = cnn_model_1()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ckJsLdmdQadZ",
        "outputId": "783dd717-2a1a-4184-f14e-0c25ca649fb8"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " conv2d (Conv2D)             (None, 32, 32, 16)        160       \n",
            "                                                                 \n",
            " leaky_re_lu (LeakyReLU)     (None, 32, 32, 16)        0         \n",
            "                                                                 \n",
            " conv2d_1 (Conv2D)           (None, 32, 32, 32)        4640      \n",
            "                                                                 \n",
            " leaky_re_lu_1 (LeakyReLU)   (None, 32, 32, 32)        0         \n",
            "                                                                 \n",
            " max_pooling2d (MaxPooling2D  (None, 16, 16, 32)       0         \n",
            " )                                                               \n",
            "                                                                 \n",
            " flatten (Flatten)           (None, 8192)              0         \n",
            "                                                                 \n",
            " dense (Dense)               (None, 32)                262176    \n",
            "                                                                 \n",
            " leaky_re_lu_2 (LeakyReLU)   (None, 32)                0         \n",
            "                                                                 \n",
            " dense_1 (Dense)             (None, 10)                330       \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 267,306\n",
            "Trainable params: 267,306\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "# Print the model summary\n",
        "\n",
        "model_1.summary()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3Fy3Dif_zcCk",
        "outputId": "cebaca30-b1a4-4f6a-efb9-411f90c482ed"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/20\n",
            "1050/1050 [==============================] - 16s 4ms/step - loss: 1.2073 - accuracy: 0.5993 - val_loss: 0.6444 - val_accuracy: 0.8129\n",
            "Epoch 2/20\n",
            "1050/1050 [==============================] - 4s 4ms/step - loss: 0.5316 - accuracy: 0.8473 - val_loss: 0.5168 - val_accuracy: 0.8551\n",
            "Epoch 3/20\n",
            "1050/1050 [==============================] - 6s 5ms/step - loss: 0.4376 - accuracy: 0.8724 - val_loss: 0.4977 - val_accuracy: 0.8599\n",
            "Epoch 4/20\n",
            "1050/1050 [==============================] - 4s 4ms/step - loss: 0.3801 - accuracy: 0.8887 - val_loss: 0.4459 - val_accuracy: 0.8769\n",
            "Epoch 5/20\n",
            "1050/1050 [==============================] - 5s 5ms/step - loss: 0.3381 - accuracy: 0.8985 - val_loss: 0.4701 - val_accuracy: 0.8715\n",
            "Epoch 6/20\n",
            "1050/1050 [==============================] - 4s 4ms/step - loss: 0.2965 - accuracy: 0.9122 - val_loss: 0.4617 - val_accuracy: 0.8752\n",
            "Epoch 7/20\n",
            "1050/1050 [==============================] - 4s 4ms/step - loss: 0.2702 - accuracy: 0.9193 - val_loss: 0.4500 - val_accuracy: 0.8795\n",
            "Epoch 8/20\n",
            "1050/1050 [==============================] - 4s 4ms/step - loss: 0.2374 - accuracy: 0.9275 - val_loss: 0.4931 - val_accuracy: 0.8692\n",
            "Epoch 9/20\n",
            "1050/1050 [==============================] - 4s 4ms/step - loss: 0.2149 - accuracy: 0.9344 - val_loss: 0.4899 - val_accuracy: 0.8764\n",
            "Epoch 10/20\n",
            "1050/1050 [==============================] - 4s 4ms/step - loss: 0.1905 - accuracy: 0.9402 - val_loss: 0.5054 - val_accuracy: 0.8793\n",
            "Epoch 11/20\n",
            "1050/1050 [==============================] - 4s 4ms/step - loss: 0.1729 - accuracy: 0.9461 - val_loss: 0.5650 - val_accuracy: 0.8699\n",
            "Epoch 12/20\n",
            "1050/1050 [==============================] - 4s 4ms/step - loss: 0.1520 - accuracy: 0.9518 - val_loss: 0.5970 - val_accuracy: 0.8663\n",
            "Epoch 13/20\n",
            "1050/1050 [==============================] - 4s 4ms/step - loss: 0.1396 - accuracy: 0.9563 - val_loss: 0.6082 - val_accuracy: 0.8662\n",
            "Epoch 14/20\n",
            "1050/1050 [==============================] - 4s 4ms/step - loss: 0.1282 - accuracy: 0.9600 - val_loss: 0.6289 - val_accuracy: 0.8676\n",
            "Epoch 15/20\n",
            "1050/1050 [==============================] - 4s 4ms/step - loss: 0.1126 - accuracy: 0.9648 - val_loss: 0.6613 - val_accuracy: 0.8689\n",
            "Epoch 16/20\n",
            "1050/1050 [==============================] - 4s 4ms/step - loss: 0.1015 - accuracy: 0.9674 - val_loss: 0.6883 - val_accuracy: 0.8696\n",
            "Epoch 17/20\n",
            "1050/1050 [==============================] - 4s 4ms/step - loss: 0.0905 - accuracy: 0.9711 - val_loss: 0.7399 - val_accuracy: 0.8701\n",
            "Epoch 18/20\n",
            "1050/1050 [==============================] - 4s 4ms/step - loss: 0.0912 - accuracy: 0.9704 - val_loss: 0.7538 - val_accuracy: 0.8695\n",
            "Epoch 19/20\n",
            "1050/1050 [==============================] - 4s 4ms/step - loss: 0.0775 - accuracy: 0.9743 - val_loss: 0.7848 - val_accuracy: 0.8680\n",
            "Epoch 20/20\n",
            "1050/1050 [==============================] - 4s 4ms/step - loss: 0.0677 - accuracy: 0.9778 - val_loss: 0.8533 - val_accuracy: 0.8664\n"
          ]
        }
      ],
      "source": [
        "# Fit the model\n",
        "# validation split of 0.2, batch size = 32, verbose = 1, and epochs = 20\n",
        "\n",
        "history_model_1 = model_1.fit(X_train, y_train, validation_split= 0.20 , epochs = 20, batch_size = 32, verbose = 1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tKOckG-KPyLg"
      },
      "source": [
        "### **Plotting the validation and training accuracies**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 497
        },
        "id": "lt77zgGMP4yw",
        "outputId": "c506a37e-1c9f-436e-8671-89c9c7214ea2"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 576x576 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "# Plotting the accuracies\n",
        "\n",
        "dict_hist = history_model_1.history\n",
        "\n",
        "list_ep = [i for i in range(1, 21)]\n",
        "\n",
        "plt.figure(figsize = (8, 8))\n",
        "\n",
        "plt.plot(list_ep, dict_hist['accuracy'], ls = '--', label = 'accuracy')\n",
        "\n",
        "plt.plot(list_ep, dict_hist['val_accuracy'], ls = '--', label = 'val_accuracy')\n",
        "\n",
        "plt.ylabel('Accuracy')\n",
        "\n",
        "plt.xlabel('Epochs')\n",
        "\n",
        "plt.legend()\n",
        "\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pGBbQpLONX7k"
      },
      "source": [
        "**Observations:**\n",
        "- As seen on the above plot the model did **poorly on the validation data** and very well on the training data. This indicates the model is **highly overfitted**. \n",
        "- Validation accuracy became more or less **stagnant after 4 epochs**. \n",
        "- Need to reduce overfitting with some form of **regularization** (dropout layers, L1 & L2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z0qgLMBZm5-K"
      },
      "source": [
        "Let's build another model and see if we can get a better model with generalized performance.\n",
        "\n",
        "First, we need to clear the previous model's history from the Keras backend. Also, let's fix the seed again after clearing the backend."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "y98BpLxsok_H"
      },
      "outputs": [],
      "source": [
        "# Clearing backend\n",
        "\n",
        "from tensorflow.keras import backend\n",
        "\n",
        "backend.clear_session()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "HbKi93HTolGW"
      },
      "outputs": [],
      "source": [
        "# Fixing the seed for random number generators\n",
        "\n",
        "np.random.seed(42)\n",
        "\n",
        "import random\n",
        "\n",
        "random.seed(42)\n",
        "\n",
        "tf.random.set_seed(42)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lT6o3TIKuCtk"
      },
      "source": [
        "### **Second Model Architecture**\n",
        "\n",
        "- Write a function that returns a sequential model with the following architecture:\n",
        " - First Convolutional layer with **16 filters and the kernel size of 3x3**. Use the **'same' padding** and provide the **input shape = (32, 32, 1)**\n",
        " - Add a **LeakyRelu layer** with the **slope equal to 0.1**\n",
        " - Second Convolutional layer with **32 filters and the kernel size of 3x3 with 'same' padding**\n",
        " - Add **LeakyRelu** with the **slope equal to 0.1**\n",
        " - Add a **max-pooling layer** with a **pool size of 2x2**\n",
        " - Add a **BatchNormalization layer**\n",
        " - Third Convolutional layer with **32 filters and the kernel size of 3x3 with 'same' padding**\n",
        " - Add a **LeakyRelu layer with the slope equal to 0.1**\n",
        " - Fourth Convolutional layer **64 filters and the kernel size of 3x3 with 'same' padding** \n",
        " - Add a **LeakyRelu layer with the slope equal to 0.1**\n",
        " - Add a **max-pooling layer** with a **pool size of 2x2**\n",
        " - Add a **BatchNormalization layer**\n",
        " - **Flatten** the output from the previous layer\n",
        " - Add a **dense layer with 32 nodes**\n",
        " - Add a **LeakyRelu layer with the slope equal to 0.1**\n",
        " - Add a **dropout layer with the rate equal to 0.5**\n",
        " - Add the final **output layer with nodes equal to the number of classes, i.e., 10** and **'softmax' as the activation function**\n",
        " - Compile the model with the **categorical_crossentropy loss, adam optimizers (learning_rate = 0.001), and metric equal to 'accuracy'**. Do not fit the model here, just return the compiled model.\n",
        "- Call the function cnn_model_2 and store the model in a new variable.\n",
        "- Print the summary of the model.\n",
        "- Fit the model on the train data with a **validation split of 0.2, batch size = 128, verbose = 1, and epochs = 30**. Store the model building history to use later for visualization."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y5IBLS1eKDNy"
      },
      "source": [
        "### **Build and train the second CNN model as per the above mentioned architecture.**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "EEPYLFIPnSDP"
      },
      "outputs": [],
      "source": [
        "# Define the model\n",
        "\n",
        "def cnn_model_2():\n",
        "    \n",
        "    model = Sequential()\n",
        "    \n",
        "    # Add layers as per the architecture mentioned above in the same sequence\n",
        "    #First Convolutional layer with 16 filters and the kernel size of 3x3. Use the 'same' padding and provide the input shape = (32, 32, 1)\n",
        "    model.add(Conv2D(16, (3,3), padding = \"same\", input_shape = (32,32,1)))\n",
        "\n",
        "    #Add a LeakyRelu layer with the slope equal to 0.1\n",
        "    model.add(LeakyReLU(0.1))\n",
        "\n",
        "    #Second Convolutional layer with 32 filters and the kernel size of 3x3 with 'same' padding\n",
        "    model.add(Conv2D(32, (3,3), padding = \"same\"))\n",
        "\n",
        "    #Add LeakyRelu with the slope equal to 0.1\n",
        "    model.add(LeakyReLU(0.1))\n",
        "\n",
        "    #Add a max-pooling layer with a pool size of 2x2\n",
        "    model.add(MaxPool2D(2,2))\n",
        "\n",
        "    #Add a BatchNormalization layer\n",
        "    model.add(BatchNormalization())\n",
        "\n",
        "    #Third Convolutional layer with 32 filters and the kernel size of 3x3 with 'same' padding\n",
        "    model.add(Conv2D(32, (3,3), padding = \"same\"))\n",
        "\n",
        "    #Add a LeakyRelu layer with the slope equal to 0.1\n",
        "    model.add(LeakyReLU(0.1))\n",
        "\n",
        "    #Fourth Convolutional layer 64 filters and the kernel size of 3x3 with 'same' padding\n",
        "    model.add(Conv2D(64, (3,3), padding = \"same\"))\n",
        "\n",
        "    #Add a LeakyRelu layer with the slope equal to 0.1\n",
        "    model.add(LeakyReLU(0.1))\n",
        "\n",
        "    #Add a max-pooling layer with a pool size of 2x2\n",
        "    model.add(MaxPool2D(2,2))\n",
        "\n",
        "    #Add a BatchNormalization layer\n",
        "    model.add(BatchNormalization())\n",
        "\n",
        "    #Flatten the output from the previous layer\n",
        "    model.add(Flatten())\n",
        "\n",
        "    #Add a dense layer with 32 nodes\n",
        "    model.add(Dense(32))\n",
        "\n",
        "    #Add a LeakyRelu layer with the slope equal to 0.1\n",
        "    model.add(LeakyReLU(0.1))\n",
        "\n",
        "    #Add a dropout layer with the rate equal to 0.5\n",
        "    model.add(Dropout(0.5))\n",
        "\n",
        "    #Add the final output layer with nodes equal to the number of classes, i.e., 10 and 'softmax' as the activation function\n",
        "    model.add(Dense(10, activation='softmax'))\n",
        "\n",
        "    # Compile the model\n",
        "    # categorical_crossentropy loss, adam optimizers (learning_rate = 0.001), and metric equal to 'accuracy'\n",
        "    model.compile(optimizer = Adam(learning_rate =0.001), loss = 'categorical_crossentropy', metrics = ['accuracy'])\n",
        "    \n",
        "    return model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "AKjDY4plnSFl"
      },
      "outputs": [],
      "source": [
        "# Build the model\n",
        "\n",
        "model_2 = cnn_model_2()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gz_6SVrU2swZ",
        "outputId": "3fd65d52-e23d-47cb-8c52-6acb17ec9ffc"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " conv2d (Conv2D)             (None, 32, 32, 16)        160       \n",
            "                                                                 \n",
            " leaky_re_lu (LeakyReLU)     (None, 32, 32, 16)        0         \n",
            "                                                                 \n",
            " conv2d_1 (Conv2D)           (None, 32, 32, 32)        4640      \n",
            "                                                                 \n",
            " leaky_re_lu_1 (LeakyReLU)   (None, 32, 32, 32)        0         \n",
            "                                                                 \n",
            " max_pooling2d (MaxPooling2D  (None, 16, 16, 32)       0         \n",
            " )                                                               \n",
            "                                                                 \n",
            " batch_normalization (BatchN  (None, 16, 16, 32)       128       \n",
            " ormalization)                                                   \n",
            "                                                                 \n",
            " conv2d_2 (Conv2D)           (None, 16, 16, 32)        9248      \n",
            "                                                                 \n",
            " leaky_re_lu_2 (LeakyReLU)   (None, 16, 16, 32)        0         \n",
            "                                                                 \n",
            " conv2d_3 (Conv2D)           (None, 16, 16, 64)        18496     \n",
            "                                                                 \n",
            " leaky_re_lu_3 (LeakyReLU)   (None, 16, 16, 64)        0         \n",
            "                                                                 \n",
            " max_pooling2d_1 (MaxPooling  (None, 8, 8, 64)         0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " batch_normalization_1 (Batc  (None, 8, 8, 64)         256       \n",
            " hNormalization)                                                 \n",
            "                                                                 \n",
            " flatten (Flatten)           (None, 4096)              0         \n",
            "                                                                 \n",
            " dense (Dense)               (None, 32)                131104    \n",
            "                                                                 \n",
            " leaky_re_lu_4 (LeakyReLU)   (None, 32)                0         \n",
            "                                                                 \n",
            " dropout (Dropout)           (None, 32)                0         \n",
            "                                                                 \n",
            " dense_1 (Dense)             (None, 10)                330       \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 164,362\n",
            "Trainable params: 164,170\n",
            "Non-trainable params: 192\n",
            "_________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "# Print the summary\n",
        "\n",
        "model_2.summary()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IQ0Sc4R-y-uu",
        "outputId": "08f2de99-8f09-48b2-ed21-95bcb72a0a72"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/30\n",
            "263/263 [==============================] - 4s 11ms/step - loss: 1.4630 - accuracy: 0.5044 - val_loss: 2.3726 - val_accuracy: 0.1625\n",
            "Epoch 2/30\n",
            "263/263 [==============================] - 3s 10ms/step - loss: 0.6910 - accuracy: 0.7857 - val_loss: 0.6267 - val_accuracy: 0.8218\n",
            "Epoch 3/30\n",
            "263/263 [==============================] - 3s 10ms/step - loss: 0.5591 - accuracy: 0.8278 - val_loss: 0.7236 - val_accuracy: 0.7675\n",
            "Epoch 4/30\n",
            "263/263 [==============================] - 3s 9ms/step - loss: 0.4980 - accuracy: 0.8483 - val_loss: 0.4173 - val_accuracy: 0.8813\n",
            "Epoch 5/30\n",
            "263/263 [==============================] - 2s 9ms/step - loss: 0.4478 - accuracy: 0.8644 - val_loss: 0.4095 - val_accuracy: 0.8823\n",
            "Epoch 6/30\n",
            "263/263 [==============================] - 3s 10ms/step - loss: 0.4100 - accuracy: 0.8732 - val_loss: 0.4364 - val_accuracy: 0.8752\n",
            "Epoch 7/30\n",
            "263/263 [==============================] - 3s 10ms/step - loss: 0.3776 - accuracy: 0.8835 - val_loss: 0.4300 - val_accuracy: 0.8823\n",
            "Epoch 8/30\n",
            "263/263 [==============================] - 3s 10ms/step - loss: 0.3562 - accuracy: 0.8890 - val_loss: 0.3834 - val_accuracy: 0.8912\n",
            "Epoch 9/30\n",
            "263/263 [==============================] - 3s 10ms/step - loss: 0.3306 - accuracy: 0.8957 - val_loss: 0.3385 - val_accuracy: 0.9070\n",
            "Epoch 10/30\n",
            "263/263 [==============================] - 3s 10ms/step - loss: 0.3117 - accuracy: 0.9010 - val_loss: 0.3608 - val_accuracy: 0.8994\n",
            "Epoch 11/30\n",
            "263/263 [==============================] - 3s 10ms/step - loss: 0.2967 - accuracy: 0.9063 - val_loss: 0.3879 - val_accuracy: 0.9052\n",
            "Epoch 12/30\n",
            "263/263 [==============================] - 3s 10ms/step - loss: 0.2805 - accuracy: 0.9106 - val_loss: 0.4183 - val_accuracy: 0.9002\n",
            "Epoch 13/30\n",
            "263/263 [==============================] - 3s 10ms/step - loss: 0.2636 - accuracy: 0.9166 - val_loss: 0.3781 - val_accuracy: 0.9058\n",
            "Epoch 14/30\n",
            "263/263 [==============================] - 3s 10ms/step - loss: 0.2616 - accuracy: 0.9171 - val_loss: 0.3742 - val_accuracy: 0.9044\n",
            "Epoch 15/30\n",
            "263/263 [==============================] - 3s 10ms/step - loss: 0.2437 - accuracy: 0.9228 - val_loss: 0.3785 - val_accuracy: 0.9064\n",
            "Epoch 16/30\n",
            "263/263 [==============================] - 3s 10ms/step - loss: 0.2383 - accuracy: 0.9240 - val_loss: 0.3825 - val_accuracy: 0.9017\n",
            "Epoch 17/30\n",
            "263/263 [==============================] - 3s 10ms/step - loss: 0.2260 - accuracy: 0.9270 - val_loss: 0.3981 - val_accuracy: 0.9118\n",
            "Epoch 18/30\n",
            "263/263 [==============================] - 3s 10ms/step - loss: 0.2124 - accuracy: 0.9297 - val_loss: 0.4184 - val_accuracy: 0.8989\n",
            "Epoch 19/30\n",
            "263/263 [==============================] - 3s 10ms/step - loss: 0.2163 - accuracy: 0.9293 - val_loss: 0.3776 - val_accuracy: 0.9112\n",
            "Epoch 20/30\n",
            "263/263 [==============================] - 3s 10ms/step - loss: 0.2029 - accuracy: 0.9349 - val_loss: 0.3914 - val_accuracy: 0.9112\n",
            "Epoch 21/30\n",
            "263/263 [==============================] - 2s 9ms/step - loss: 0.1955 - accuracy: 0.9365 - val_loss: 0.4059 - val_accuracy: 0.9027\n",
            "Epoch 22/30\n",
            "263/263 [==============================] - 3s 10ms/step - loss: 0.1820 - accuracy: 0.9391 - val_loss: 0.4071 - val_accuracy: 0.9121\n",
            "Epoch 23/30\n",
            "263/263 [==============================] - 2s 9ms/step - loss: 0.1873 - accuracy: 0.9382 - val_loss: 0.3904 - val_accuracy: 0.9130\n",
            "Epoch 24/30\n",
            "263/263 [==============================] - 3s 10ms/step - loss: 0.1775 - accuracy: 0.9416 - val_loss: 0.4355 - val_accuracy: 0.9073\n",
            "Epoch 25/30\n",
            "263/263 [==============================] - 2s 9ms/step - loss: 0.1726 - accuracy: 0.9435 - val_loss: 0.4897 - val_accuracy: 0.9074\n",
            "Epoch 26/30\n",
            "263/263 [==============================] - 3s 10ms/step - loss: 0.1682 - accuracy: 0.9446 - val_loss: 0.4398 - val_accuracy: 0.9074\n",
            "Epoch 27/30\n",
            "263/263 [==============================] - 3s 10ms/step - loss: 0.1656 - accuracy: 0.9451 - val_loss: 0.5447 - val_accuracy: 0.8896\n",
            "Epoch 28/30\n",
            "263/263 [==============================] - 3s 10ms/step - loss: 0.1594 - accuracy: 0.9484 - val_loss: 0.4374 - val_accuracy: 0.9131\n",
            "Epoch 29/30\n",
            "263/263 [==============================] - 3s 12ms/step - loss: 0.1554 - accuracy: 0.9482 - val_loss: 0.4281 - val_accuracy: 0.9108\n",
            "Epoch 30/30\n",
            "263/263 [==============================] - 3s 13ms/step - loss: 0.1553 - accuracy: 0.9494 - val_loss: 0.4393 - val_accuracy: 0.9121\n"
          ]
        }
      ],
      "source": [
        "# Fit the model\n",
        "# validation split of 0.2, batch size = 128, verbose = 1, and epochs = 30\n",
        "\n",
        "history_model_2 = model_2.fit(X_train, y_train, validation_split= 0.20 , epochs = 30, batch_size = 128, verbose = 1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zKCdy59GKDN1"
      },
      "source": [
        "### **Plotting the validation and training accuracies**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 497
        },
        "id": "01ig6BrF1KVy",
        "outputId": "808a4cd0-f21e-4328-a929-cc1c6294e6ca"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 576x576 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "# Plotting the accuracies\n",
        "\n",
        "dict_hist = history_model_2.history\n",
        "\n",
        "list_ep = [i for i in range(1, 31)]\n",
        "\n",
        "plt.figure(figsize = (8, 8))\n",
        "\n",
        "plt.plot(list_ep, dict_hist['accuracy'], ls = '--', label = 'accuracy')\n",
        "\n",
        "plt.plot(list_ep, dict_hist['val_accuracy'], ls = '--', label = 'val_accuracy')\n",
        "\n",
        "plt.ylabel('Accuracy')\n",
        "\n",
        "plt.xlabel('Epochs')\n",
        "\n",
        "plt.legend()\n",
        "\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VPW1LlD61RDn"
      },
      "source": [
        "**Observations:**\n",
        "- Model 2 does much better on the validation accuracy **we can say the model is giving a generalized performance**\n",
        "- Accuracy on validation data is nearly identical to the the training data (with the testing accuracy being slightly higher), this indicates it is a **good model** and giving a **generalized performance**.\n",
        "- Between model_1 and model_2 validation **accuracy has increased from 86.64% to 91.21%**\n",
        "  - Even though that is only a small increase the main goal was to **reduce overfitting which was successfull**\n",
        "  - This would indicate the **Dropout layer was succesfull in reducing overfitting**\n",
        "  - Would be interesting to see if we could keep the droupout layer that while reducing the overall complexity of this model, potentially decreasing overfitting in the later epochs while maintaining accuracy\n",
        "- Model begins to start **slightly overfitting after epoch 9** (train_accuracy: 89.57%, val_accuracy: 90.70%). However, there are a few models at at higher epochs with slightly higher validation accuracies but the training accuracies also increase and therefore the overfitting is slightly higher at those points aswell.  \n",
        "  - epoch 17 (train_accuracy: 92.70%, val_accuracy: 91.18%) \n",
        "  - epoch 22 (train_accuracy: 93.91%, val_accuracy: 91.21%)\n",
        "  - epoch 23 (train_accuracy: 93.82%, val_accuracy: 91.30%)\n",
        "  - epoch 28 (train_accuracy: 94.84%, val_accuracy: 91.31%)\n",
        "  - **epoch 28 being the highest point of validation accuracy in the model**\n",
        "  - **However those minor improvements would indicate the validation accuracy more or less stagnated after epoch 9**\n",
        "- The validation accuracy begins to show signs of early fluctuation and is taken over by the training accuracy, this suggest the model would not improve with more epochs"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8kuXx9Bvu00f"
      },
      "source": [
        "## **Predictions on the test data**\n",
        "\n",
        "- Make predictions on the test set using the second model.\n",
        "- Print the obtained results using the classification report and the confusion matrix.\n",
        "- Final observations on the obtained results."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xbWMEtTj5Ad0"
      },
      "outputs": [],
      "source": [
        "# Make prediction on the test data using model_2 \n",
        "\n",
        "test_pred = model_2.predict(X_test)\n",
        "\n",
        "test_pred = np.argmax(test_pred, axis = -1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i3li8Ib08yts"
      },
      "source": [
        "**Note:** Earlier, we noticed that each entry of the target variable is a one-hot encoded vector, but to print the classification report and confusion matrix, we must convert each entry of y_test to a single label."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NByu7uAQ8x9P"
      },
      "outputs": [],
      "source": [
        "# Converting each entry to single label from one-hot encoded vector\n",
        "\n",
        "y_test = np.argmax(y_test, axis = -1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 629
        },
        "id": "xRddeJ-3EHT1",
        "outputId": "fc2e3b11-98fd-4009-b0ed-76bcde45af17"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.93      0.93      0.93      1814\n",
            "           1       0.89      0.92      0.91      1828\n",
            "           2       0.95      0.92      0.93      1803\n",
            "           3       0.93      0.87      0.90      1719\n",
            "           4       0.92      0.93      0.92      1812\n",
            "           5       0.92      0.91      0.91      1768\n",
            "           6       0.89      0.91      0.90      1832\n",
            "           7       0.94      0.93      0.93      1808\n",
            "           8       0.87      0.91      0.89      1812\n",
            "           9       0.91      0.91      0.91      1804\n",
            "\n",
            "    accuracy                           0.91     18000\n",
            "   macro avg       0.91      0.91      0.91     18000\n",
            "weighted avg       0.91      0.91      0.91     18000\n",
            "\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 576x360 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "# Importing required functions\n",
        "\n",
        "from sklearn.metrics import classification_report\n",
        "\n",
        "from sklearn.metrics import confusion_matrix\n",
        "\n",
        "# Printing the classification report\n",
        "\n",
        "print(classification_report(y_test, test_pred))\n",
        "\n",
        "# Plotting the heatmap using confusion matrix\n",
        "\n",
        "cm = confusion_matrix(y_test, test_pred)\n",
        "\n",
        "plt.figure(figsize = (8, 5))\n",
        "\n",
        "sns.heatmap(cm, annot = True,  fmt = '.0f')\n",
        "\n",
        "plt.ylabel('Actual')\n",
        "\n",
        "plt.xlabel('Predicted')\n",
        "\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DjErl4GA2u9s"
      },
      "source": [
        "**Final Observations:**\n",
        "- The model is giving about **91% accuracy** on the test data which is in line to the accuracy of the validation data. This implies that the model is giving a **generalized performance**.\n",
        "  - This is an significant increase (**+13%**) compaired to our **ANN model (78% accuracy)**\n",
        "- The model was also much more consistent across the different number cathegories, some highlights include:\n",
        "  - Model did well prediciting 2 (95% accuracy)\n",
        "  - Model struggled predicting 8 (87% accuracy)\n",
        "  - Variance from best to worst number went from 17% (ANN) 10% (CNN)\n",
        "  - Slight onfusion between predicting 3 as 5 and 3 as 8\n",
        "      - Likely because they are of similar shape\n",
        "  - Slight confusion predicting 7 as 1 and 6 as 8 \n",
        "      - Likely because both pairs are similar in shape\n",
        "- To improve the model futher we could:\n",
        "  - Strategically decrease complexity and tune some of the hyperparameters to reduce the slight overfiting later in the epochs\n",
        "  - Apply some form of transfer learning to improve accuracy\n",
        "  - Some form of Data Augmentation "
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Dj7o6c4ZyRmN"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "collapsed_sections": [],
      "provenance": [],
      "include_colab_link": true
    },
    "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.7"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}