MNIST_Train_Task1.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/shreyasrajesh0308/ECE188DeepLearning/blob/main/MNIST_Train_Task1.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Project 2- ECE 188, Spring 2022 - Deadline: June 10th, 2022. Please upload a link to your Github on Gradescope.\n",
        "# Train a Deep Learning model on the MNIST dataset and evaluate it on a test set.\n",
        "\n",
        "The first part in this notebook will take you though the training of the [MNIST Dataset](http://yann.lecun.com/exdb/mnist/) which is a collection of handwritten digits. \n",
        "\n",
        "We will build a Deep Learning based system that can recognise handwritten digits using [Keras](https://keras.io/) and [Tensorflow](https://www.tensorflow.org/). \n",
        "\n",
        "Note that the entire project will be done on a Google Colab. A tutorial to some basic colab instructions can be found [here](https://colab.research.google.com/?utm_source=scs-index#scrollTo=GJBs_flRovLc). \n",
        "\n",
        "Note that all the code needed is provided until Task 1, **you will only have to write code after the task 1 header**"
      ],
      "metadata": {
        "id": "a-utSW-VUF2y"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Import Necessary Packages\n",
        "\n",
        "We import Keras and Tensorflow to train our network and numpy to work with our data. \n",
        "\n",
        "We also import matplotlib to view our images. "
      ],
      "metadata": {
        "id": "fgnHUBjoUTcy"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "aDvD8R1TbbOi"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import tensorflow as tf\n",
        "from tensorflow import keras\n",
        "from keras import layers\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib as mpl\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "mpl.rcParams['figure.figsize'] = (8, 8)\n",
        "mpl.rcParams['axes.grid'] = False\n"
      ],
      "metadata": {
        "id": "OdYVH66MUciD"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Load the Data\n",
        "\n",
        "We perform some data preprocessing. Feel free to skip over this and use the train and test data as x_train and x_test"
      ],
      "metadata": {
        "id": "yuFHL78kUez_"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "id": "2iKGDDuDbhRM",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b7c112ab-b9c3-476f-f4b1-854fca72f772"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "x_train shape: (60000, 28, 28, 1)\n",
            "60000 train samples\n",
            "10000 test samples\n"
          ]
        }
      ],
      "source": [
        "# Model / data parameters\n",
        "num_classes = 10\n",
        "input_shape = (28, 28, 1)\n",
        "\n",
        "# the data, split between train and test sets\n",
        "(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()\n",
        "\n",
        "# Scale images to the [0, 1] range\n",
        "x_train = x_train.astype(\"float32\") / 255\n",
        "x_test = x_test.astype(\"float32\") / 255\n",
        "# Make sure images have shape (28, 28, 1)\n",
        "x_train = np.expand_dims(x_train, -1)\n",
        "x_test = np.expand_dims(x_test, -1)\n",
        "print(\"x_train shape:\", x_train.shape)\n",
        "print(x_train.shape[0], \"train samples\")\n",
        "print(x_test.shape[0], \"test samples\")\n",
        "\n",
        "\n",
        "# convert class vectors to binary class matrices\n",
        "y_train = keras.utils.to_categorical(y_train, num_classes)\n",
        "y_test = keras.utils.to_categorical(y_test, num_classes)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Define a model in keras.\n",
        "\n",
        "\n",
        " We define a simple simple network with 2 hidden layers. One fully connected dense layer with 8 neurons and onr flatten layer that flattens the model into 1D structure which is then fed into a softmax output.\n",
        "\n",
        "This is a barebones keras structure. In task 1 you will be tasked with improving this model. "
      ],
      "metadata": {
        "id": "tEDsgxIcuv0B"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model = keras.Sequential(\n",
        "    [\n",
        "        keras.Input(shape=input_shape),\n",
        "        layers.Dense(8,activation=\"relu\"),\n",
        "        layers.Flatten(),\n",
        "        layers.Dense(num_classes, activation=\"softmax\"),\n",
        "    ]\n",
        ")\n",
        "\n",
        "model.summary()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Kb3ONTl8Odrq",
        "outputId": "8b4d333d-efc8-49cc-a4bd-e50cfeaf4258"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_6\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " dense_9 (Dense)             (None, 28, 28, 8)         16        \n",
            "                                                                 \n",
            " flatten_5 (Flatten)         (None, 6272)              0         \n",
            "                                                                 \n",
            " dense_10 (Dense)            (None, 10)                62730     \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 62,746\n",
            "Trainable params: 62,746\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Compile and train the model \n",
        "\n",
        "We know train our model. Before we do that we need to set some parameters to train the model. Hence we define the loss and optimizer to be used as well as batch size. The number of epochs refers to the number of training iterations. "
      ],
      "metadata": {
        "id": "7qepS8u7VJXF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "batch_size = 128\n",
        "epochs = 15\n",
        "\n",
        "model.compile(loss=\"categorical_crossentropy\", optimizer=\"adam\", metrics=[\"accuracy\"])\n",
        "\n",
        "model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, validation_split=0.1)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3cwCRnA2OgPY",
        "outputId": "d84a3e2e-5a03-4287-f92a-0ef2170c40ab"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/15\n",
            "422/422 [==============================] - 3s 5ms/step - loss: 0.4782 - accuracy: 0.8729 - val_loss: 0.2634 - val_accuracy: 0.9270\n",
            "Epoch 2/15\n",
            "422/422 [==============================] - 2s 4ms/step - loss: 0.3012 - accuracy: 0.9147 - val_loss: 0.2413 - val_accuracy: 0.9300\n",
            "Epoch 3/15\n",
            "422/422 [==============================] - 2s 4ms/step - loss: 0.2844 - accuracy: 0.9200 - val_loss: 0.2409 - val_accuracy: 0.9303\n",
            "Epoch 4/15\n",
            "422/422 [==============================] - 2s 4ms/step - loss: 0.2760 - accuracy: 0.9227 - val_loss: 0.2273 - val_accuracy: 0.9377\n",
            "Epoch 5/15\n",
            "422/422 [==============================] - 2s 4ms/step - loss: 0.2698 - accuracy: 0.9238 - val_loss: 0.2299 - val_accuracy: 0.9373\n",
            "Epoch 6/15\n",
            "422/422 [==============================] - 2s 4ms/step - loss: 0.2651 - accuracy: 0.9262 - val_loss: 0.2307 - val_accuracy: 0.9375\n",
            "Epoch 7/15\n",
            "422/422 [==============================] - 2s 4ms/step - loss: 0.2627 - accuracy: 0.9264 - val_loss: 0.2257 - val_accuracy: 0.9373\n",
            "Epoch 8/15\n",
            "422/422 [==============================] - 2s 4ms/step - loss: 0.2600 - accuracy: 0.9270 - val_loss: 0.2286 - val_accuracy: 0.9380\n",
            "Epoch 9/15\n",
            "422/422 [==============================] - 2s 4ms/step - loss: 0.2575 - accuracy: 0.9277 - val_loss: 0.2363 - val_accuracy: 0.9338\n",
            "Epoch 10/15\n",
            "422/422 [==============================] - 2s 4ms/step - loss: 0.2555 - accuracy: 0.9289 - val_loss: 0.2324 - val_accuracy: 0.9365\n",
            "Epoch 11/15\n",
            "422/422 [==============================] - 2s 4ms/step - loss: 0.2538 - accuracy: 0.9284 - val_loss: 0.2296 - val_accuracy: 0.9372\n",
            "Epoch 12/15\n",
            "422/422 [==============================] - 2s 4ms/step - loss: 0.2529 - accuracy: 0.9292 - val_loss: 0.2299 - val_accuracy: 0.9385\n",
            "Epoch 13/15\n",
            "422/422 [==============================] - 2s 4ms/step - loss: 0.2510 - accuracy: 0.9297 - val_loss: 0.2347 - val_accuracy: 0.9360\n",
            "Epoch 14/15\n",
            "422/422 [==============================] - 2s 4ms/step - loss: 0.2516 - accuracy: 0.9300 - val_loss: 0.2282 - val_accuracy: 0.9393\n",
            "Epoch 15/15\n",
            "422/422 [==============================] - 2s 4ms/step - loss: 0.2494 - accuracy: 0.9300 - val_loss: 0.2286 - val_accuracy: 0.9393\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<keras.callbacks.History at 0x7f35ec5296d0>"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Evaluate the model "
      ],
      "metadata": {
        "id": "2IscBu-nVLw3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "score = model.evaluate(x_test, y_test, verbose=0)\n",
        "print(\"Test loss:\", score[0])\n",
        "print(\"Test accuracy:\", score[1])\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SCRqjgb_OiN7",
        "outputId": "a98092c1-d98d-4766-f81d-d63fc925b0c0"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test loss: 0.27312034368515015\n",
            "Test accuracy: 0.9258999824523926\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We achieve an accuracy on the test set of 92% but can we do better?"
      ],
      "metadata": {
        "id": "nSdY-BY5vKZb"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Looking at a prediction.\n",
        "\n",
        "Lets look at the prediction for a particular image in our model. We will look at one corect and one incorrect prediction and see if we can improve on the incorrect prediction. "
      ],
      "metadata": {
        "id": "y9a6QtAJ4Xby"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def get_mnist_label(image_probs):\n",
        "\n",
        "  return np.argmax(image_probs), np.max(image_probs)"
      ],
      "metadata": {
        "id": "g3uyTJ6253Jv"
      },
      "execution_count": 27,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "preds = model.predict(x_test)\n",
        "\n",
        "image = x_test[0].reshape(input_shape[0], input_shape[1])\n",
        "label = np.argmax(y_test[0])\n",
        "image_probs = preds[0]"
      ],
      "metadata": {
        "id": "sZP5HsZO5OyY"
      },
      "execution_count": 28,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plt.figure()\n",
        "plt.imshow(image*0.5 + 0.5)  # To change [-1, 1] to [0,1]\n",
        "image_class, class_confidence = get_mnist_label(image_probs)\n",
        "plt.title('{} : {:.2f}% Confidence'.format(image_class, class_confidence*100))\n",
        "plt.show()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 499
        },
        "id": "AdIoM5GX5ygg",
        "outputId": "f2536a58-6f12-4877-9feb-b2de3c815949"
      },
      "execution_count": 29,
      "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"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Store the incorrect prediction index here\n",
        "incorrect_index = 0\n",
        "\n",
        "for i in range(preds.shape[0]):\n",
        "\n",
        "  if np.argmax(preds[i]) != np.argmax(y_test[i]):\n",
        "\n",
        "    incorrect_index = i\n",
        "\n",
        "image_incorrect = x_test[incorrect_index].reshape(input_shape[0], input_shape[1])"
      ],
      "metadata": {
        "id": "qmmsBM_E6DUc"
      },
      "execution_count": 34,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plt.figure()\n",
        "plt.imshow(image_incorrect*0.5 + 0.5)  # To change [-1, 1] to [0,1]\n",
        "image_class, class_confidence = get_mnist_label(preds[i])\n",
        "plt.title('{} : {:.2f}% Confidence'.format(image_class, class_confidence*100))\n",
        "plt.show()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 499
        },
        "id": "HKsiOalv7Bsj",
        "outputId": "9f420f87-e24b-46d6-dd7a-5c19b5c1060d"
      },
      "execution_count": 36,
      "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"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We see that a 3 has been predicted with high confidence as a 6 does this change with our improved model below?"
      ],
      "metadata": {
        "id": "VfSIJAF57dhy"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        " # TASK 1: Improve the accuracy of the model \n",
        "\n",
        "Your goal in task one is to improve the accuracy of the model on the test set. "
      ],
      "metadata": {
        "id": "LifPv5WJvSMu"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "For image recogniton tasks convolutional neural networks work better than most other type of architectures. Your goal is to push the test accuracy above 99% percent. \n",
        "\n",
        "The following steps will get you there. \n",
        "\n",
        "1. Convert the 1st hidden Dense layer to a conv layer with 32 filters, a filter size of 3x3 and with relu activation. (I've done this step)\n",
        "2. Add a Maxpooling layer of size 2x2. \n",
        "3. Add another Conv layer with 64 filters, with a filter size of 3x3 with relu activation. \n",
        "4. Add a Maxpooling layer of size 2x2. \n",
        "5. Add Dropout to the layer after the Flatten layer. "
      ],
      "metadata": {
        "id": "nq8pen8-wdsh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "improved_model = keras.Sequential(\n",
        "    [\n",
        "        keras.Input(shape=input_shape),\n",
        "        layers.Conv2D(32, kernel_size=(3, 3), activation=\"relu\"),\n",
        "        # Add Maxpooling layer here\n",
        "        # Add Conv2d layer here\n",
        "        layers.Flatten(),\n",
        "        # Add dropout of 0.5 here\n",
        "        layers.Dense(num_classes, activation=\"softmax\"),\n",
        "    ]\n",
        ")\n",
        "\n",
        "improved_model.summary()\n"
      ],
      "metadata": {
        "id": "LeDUJgK2wb4l"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Complile and train the improved model. "
      ],
      "metadata": {
        "id": "ffzFzyOZ0UG8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "batch_size = 128\n",
        "epochs = 15\n",
        "\n",
        "improved_model.compile(loss=\"categorical_crossentropy\", optimizer=\"adam\", metrics=[\"accuracy\"])\n",
        "\n",
        "improved_model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, validation_split=0.1)\n"
      ],
      "metadata": {
        "id": "aPBhYQml1OuH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Evaluate the Improved model. \n",
        "\n",
        "You should achieve a test accuracy of greater than 99%!\n",
        "\n",
        "If not the code will throw an assertion error. "
      ],
      "metadata": {
        "id": "7a7EZNcv1r9J"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "score = improved_model.evaluate(x_test, y_test, verbose=0)\n",
        "print(\"Improved Test loss:\", score[0])\n",
        "print(\"Improved Test accuracy:\", score[1])\n",
        "\n",
        "assert score[1] > 0.99"
      ],
      "metadata": {
        "id": "lYKx0TKH2P6G"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Looking at a prediction.\n",
        "\n",
        "Lets look at the prediction for a particular image in our model. We will look at one corect and one incorrect prediction and see if we can improve on the incorrect prediction. \n",
        "\n",
        "Check the predictions on the improved model, do you see improvements on the incorrect sample. "
      ],
      "metadata": {
        "id": "aD885MO57xoV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "improved_preds = improved_model.predict(x_test)\n",
        "\n",
        "image = x_test[0].reshape(input_shape[0], input_shape[1])\n",
        "label = np.argmax(y_test[0])\n"
      ],
      "metadata": {
        "id": "0ozaLxNg7xoW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plt.figure()\n",
        "plt.imshow(image*0.5 + 0.5)  # To change [-1, 1] to [0,1]\n",
        "image_class, class_confidence = get_mnist_label(improved_preds[0])\n",
        "plt.title('{} : {:.2f}% Confidence'.format(image_class, class_confidence*100))\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "y0qsS5jY7xoW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plt.figure()\n",
        "plt.imshow(image_incorrect*0.5 + 0.5)  # To change [-1, 1] to [0,1]\n",
        "image_class, class_confidence = get_mnist_label(improved_preds[i])\n",
        "plt.title('{} : {:.2f}% Confidence'.format(image_class, class_confidence*100))\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "Dyj5CbQD7xoW"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "colab": {
      "name": "MNIST_Train_Task1.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyPTn3x0KPYskaHLEwVZ8Xse",
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "nbformat": 4,
  "nbformat_minor": 0
}