LeNet_MNIST.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.8.2"
    },
    "colab": {
      "name": "LeNet MNIST.ipynb",
      "provenance": []
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Sn33nW0sG1Hv"
      },
      "source": [
        "# LeNet"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GTPqo3BmGru1"
      },
      "source": [
        "The LeNet architecture is a seminal work in the deep learning community, first introduced by\n",
        "LeCun et al. in their 1998 paper, Gradient-Based Learning Applied to Document Recognition. As the name of the paper suggests, the authors’ motivation behind implementing LeNet was\n",
        "primarily for Optical Character Recognition (OCR).\n",
        "\n",
        "The LeNet architecture is straightforward and small (in terms of memory footprint), making it\n",
        "perfect for teaching the basics of CNNs.\n",
        "\n",
        "In this chapter, we’ll seek to replicate experiments similar to LeCun’s in their 1998 paper. We’ll\n",
        "start by reviewing the LeNet architecture and then implement the network using Keras. Finally,\n",
        "we’ll evaluate LeNet on the MNIST dataset for handwritten digit recognition."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XkaYOYkYE9vS"
      },
      "source": [
        "## Import necessary librarires"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nx3JOJqHDHUN"
      },
      "source": [
        "from sklearn.preprocessing import LabelBinarizer\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.metrics import classification_report\n",
        "from sklearn import datasets\n",
        "from tensorflow.keras import backend as K\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "from tensorflow.keras.models import Sequential\n",
        "from tensorflow.keras.layers import Conv2D, MaxPooling2D, Dense, Flatten, Activation\n",
        "from tensorflow.keras.optimizers import SGD"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QBAwpNhnE6XN"
      },
      "source": [
        "## Define the model architecture"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3XRVvNG9DHUO"
      },
      "source": [
        "class LeNet:\n",
        "    @staticmethod\n",
        "    def build(width, height, depth, classes):\n",
        "        # initialize the model\n",
        "        model = Sequential()\n",
        "        inputShape = (height, width, depth)\n",
        "\n",
        "        # if we are using \"channels first\", update the input shape\n",
        "        if K.image_data_format() == \"channels_first\":\n",
        "            inputShape = (depth, height, width)\n",
        "            \n",
        "        # first set of CONV => RELU => POOL layers\n",
        "        model.add(Conv2D(20, (5, 5), padding=\"same\", input_shape=inputShape))\n",
        "        model.add(Activation(\"relu\"))\n",
        "        model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))\n",
        "        \n",
        "        \n",
        "        # Second set of CONV => RELU => POOL layers\n",
        "        model.add(Conv2D(50, (5, 5), padding=\"same\"))\n",
        "        model.add(Activation(\"relu\"))\n",
        "        model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))\n",
        "        \n",
        "        # first (and only) set of FC => RELU layers\n",
        "        model.add(Flatten())\n",
        "        model.add(Dense(500))\n",
        "        model.add(Activation(\"relu\"))\n",
        "        \n",
        "        # softmax classifier\n",
        "        model.add(Dense(classes))\n",
        "        model.add(Activation(\"softmax\"))\n",
        "\n",
        "        # return the constructed network architecture\n",
        "        return model"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QUdpAh_TDHUP",
        "outputId": "1532ed74-144b-4140-b027-3123bea04f5b"
      },
      "source": [
        "# grab the MNIST dataset (if this is your first time using this\n",
        "# dataset then the 55MB download may take a minute)\n",
        "print(\"[INFO] accessing MNIST...\")\n",
        "dataset = datasets.fetch_openml('mnist_784')\n",
        "data = dataset.data"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[INFO] accessing MNIST...\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mkXKE30iDHUQ"
      },
      "source": [
        "# if we are using \"channels first\" ordering, then reshape the\n",
        "# design matrix such that the matrix is:\n",
        "# num_samples x depth x rows x columns\n",
        "if K.image_data_format() == \"channels_first\":\n",
        "    data = data.reshape(data.shape[0], 1, 28, 28)\n",
        "\n",
        "# otherwise, we are using \"channels last\" ordering, so the design\n",
        "# matrix shape should be: num_samples x rows x columns x depth\n",
        "else:\n",
        "    data = data.reshape(data.shape[0], 28, 28, 1)"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "y07Ov8puDHUR",
        "outputId": "b801a682-3b29-4e27-9bf0-3a38c56cbfb7"
      },
      "source": [
        "data.shape"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(70000, 28, 28, 1)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9MpL3hFKEwq5"
      },
      "source": [
        "## Preprocess data and spilt into train/test"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yFLzBLy6DHUR"
      },
      "source": [
        "# scale the input data to the range [0, 1] and perform a train/test split\n",
        "(trainX, testX, trainY, testY) = train_test_split(data / 255.0,\n",
        "                                                  dataset.target.astype(\"int\"), test_size=0.25, random_state=42)\n",
        "\n",
        "# convert the labels from integers to vectors\n",
        "le = LabelBinarizer()\n",
        "trainY = le.fit_transform(trainY)\n",
        "testY = le.transform(testY)"
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XBabXSOzEsTq"
      },
      "source": [
        "## Compile and train the network"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ypEcZDBjDHUS",
        "outputId": "8213a851-da23-4ea3-ed62-79eacfcbeb54"
      },
      "source": [
        "# initialize the optimizer and model\n",
        "print(\"[INFO] compiling model...\") \n",
        "model = LeNet.build(width=28, height=28, depth=1, classes=10)\n",
        "model.compile(loss=\"categorical_crossentropy\", optimizer=SGD(lr=0.01), metrics=[\"accuracy\"])\n",
        "\n",
        "# train the network\n",
        "print(\"[INFO] training network...\")\n",
        "H = model.fit(trainX, trainY, validation_data=(testX, testY), batch_size=128, epochs=20, verbose=1)"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[INFO] compiling model...\n",
            "[INFO] training network...\n",
            "Epoch 1/20\n",
            "411/411 [==============================] - 35s 7ms/step - loss: 1.6613 - accuracy: 0.5047 - val_loss: 0.4552 - val_accuracy: 0.8404\n",
            "Epoch 2/20\n",
            "411/411 [==============================] - 2s 6ms/step - loss: 0.3089 - accuracy: 0.9061 - val_loss: 0.6462 - val_accuracy: 0.8463\n",
            "Epoch 3/20\n",
            "411/411 [==============================] - 2s 6ms/step - loss: 0.2137 - accuracy: 0.9356 - val_loss: 0.1740 - val_accuracy: 0.9491\n",
            "Epoch 4/20\n",
            "411/411 [==============================] - 2s 6ms/step - loss: 0.1526 - accuracy: 0.9537 - val_loss: 0.3250 - val_accuracy: 0.8922\n",
            "Epoch 5/20\n",
            "411/411 [==============================] - 3s 6ms/step - loss: 0.1290 - accuracy: 0.9611 - val_loss: 0.1213 - val_accuracy: 0.9631\n",
            "Epoch 6/20\n",
            "411/411 [==============================] - 2s 6ms/step - loss: 0.1069 - accuracy: 0.9682 - val_loss: 0.1831 - val_accuracy: 0.9440\n",
            "Epoch 7/20\n",
            "411/411 [==============================] - 2s 6ms/step - loss: 0.0961 - accuracy: 0.9718 - val_loss: 0.0987 - val_accuracy: 0.9689\n",
            "Epoch 8/20\n",
            "411/411 [==============================] - 2s 6ms/step - loss: 0.0872 - accuracy: 0.9745 - val_loss: 0.1099 - val_accuracy: 0.9657\n",
            "Epoch 9/20\n",
            "411/411 [==============================] - 2s 6ms/step - loss: 0.0754 - accuracy: 0.9771 - val_loss: 0.1127 - val_accuracy: 0.9642\n",
            "Epoch 10/20\n",
            "411/411 [==============================] - 2s 6ms/step - loss: 0.0694 - accuracy: 0.9794 - val_loss: 0.1141 - val_accuracy: 0.9646\n",
            "Epoch 11/20\n",
            "411/411 [==============================] - 2s 6ms/step - loss: 0.0670 - accuracy: 0.9803 - val_loss: 0.0880 - val_accuracy: 0.9733\n",
            "Epoch 12/20\n",
            "411/411 [==============================] - 3s 6ms/step - loss: 0.0621 - accuracy: 0.9819 - val_loss: 0.0714 - val_accuracy: 0.9779\n",
            "Epoch 13/20\n",
            "411/411 [==============================] - 2s 6ms/step - loss: 0.0583 - accuracy: 0.9823 - val_loss: 0.3685 - val_accuracy: 0.8873\n",
            "Epoch 14/20\n",
            "411/411 [==============================] - 2s 6ms/step - loss: 0.0582 - accuracy: 0.9820 - val_loss: 0.1235 - val_accuracy: 0.9628\n",
            "Epoch 15/20\n",
            "411/411 [==============================] - 2s 6ms/step - loss: 0.0524 - accuracy: 0.9849 - val_loss: 0.0735 - val_accuracy: 0.9767\n",
            "Epoch 16/20\n",
            "411/411 [==============================] - 2s 6ms/step - loss: 0.0501 - accuracy: 0.9850 - val_loss: 0.0685 - val_accuracy: 0.9787\n",
            "Epoch 17/20\n",
            "411/411 [==============================] - 2s 6ms/step - loss: 0.0454 - accuracy: 0.9864 - val_loss: 0.1144 - val_accuracy: 0.9643\n",
            "Epoch 18/20\n",
            "411/411 [==============================] - 2s 6ms/step - loss: 0.0456 - accuracy: 0.9858 - val_loss: 0.0928 - val_accuracy: 0.9693\n",
            "Epoch 19/20\n",
            "411/411 [==============================] - 2s 6ms/step - loss: 0.0432 - accuracy: 0.9872 - val_loss: 0.1109 - val_accuracy: 0.9671\n",
            "Epoch 20/20\n",
            "411/411 [==============================] - 2s 6ms/step - loss: 0.0419 - accuracy: 0.9874 - val_loss: 0.0545 - val_accuracy: 0.9826\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3m-rvR4iEoWj"
      },
      "source": [
        "## Evaluate the network"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aSaNsA5eDHUT",
        "outputId": "8d6547bd-40a8-47d0-b3ce-df4d0907d788"
      },
      "source": [
        "print(\"[INFO] evaluating network...\")\n",
        "predictions = model.predict(testX, batch_size=128)\n",
        "print(classification_report(testY.argmax(axis=1),\n",
        "                            predictions.argmax(axis=1), \n",
        "                            target_names=[str(x) for x in le.classes_]))"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[INFO] evaluating network...\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.99      0.99      0.99      1714\n",
            "           1       0.99      0.99      0.99      1977\n",
            "           2       0.97      0.99      0.98      1761\n",
            "           3       0.99      0.97      0.98      1806\n",
            "           4       0.98      0.99      0.98      1587\n",
            "           5       0.99      0.98      0.98      1607\n",
            "           6       1.00      0.98      0.99      1761\n",
            "           7       0.99      0.98      0.98      1878\n",
            "           8       0.98      0.97      0.98      1657\n",
            "           9       0.97      0.98      0.97      1752\n",
            "\n",
            "    accuracy                           0.98     17500\n",
            "   macro avg       0.98      0.98      0.98     17500\n",
            "weighted avg       0.98      0.98      0.98     17500\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FbZYlwl-Ejss"
      },
      "source": [
        "## Plot the training/val loss and accuracy"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 299
        },
        "id": "UaH1Wdp8DHUT",
        "outputId": "34a20e02-203c-467e-d797-cf785c3b5aad"
      },
      "source": [
        "plt.style.use(\"ggplot\")\n",
        "plt.figure()\n",
        "plt.plot(np.arange(0, 20), H.history[\"loss\"], label=\"train_loss\")\n",
        "plt.plot(np.arange(0, 20), H.history[\"val_loss\"], label=\"val_loss\")\n",
        "plt.plot(np.arange(0, 20), H.history[\"accuracy\"], label=\"train_acc\")\n",
        "plt.plot(np.arange(0, 20), H.history[\"val_accuracy\"], label=\"val_acc\")\n",
        "plt.title(\"Loss and Accuracy\")\n",
        "plt.xlabel(\"Epoch #\")\n",
        "plt.ylabel(\"Loss/Accuracy\")\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LKmneMTkEJCm"
      },
      "source": [
        "## With the help of LeNet Architecture we are able to get very good (~98%) accuracy with generalized model."
      ]
    }
  ]
}