CONV_mnist.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "mnist_conv.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/nrjcs/foundation_aiml/blob/master/CONV_mnist.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_kjTsII0qfuL"
      },
      "source": [
        "# Import necessary Packages\n",
        " \n",
        "from keras.models import Sequential\n",
        "from keras.layers import Dense, Dropout, Flatten\n",
        "from keras.layers import Conv2D, MaxPooling2D\n",
        "from keras.datasets import mnist\n",
        "import matplotlib.pyplot as plt\n",
        "import keras.utils\n",
        "\n"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c8IIJncGiQ2M",
        "outputId": "43b3bbbe-dfb2-4b4d-e094-164b1c159ae1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Get the dataset\n",
        "\n",
        "(X_train, Y_train), (X_test, Y_test) = mnist.load_data() \t#Keras function\n",
        "\n",
        "print (\"mnist data downloaded...\")\n"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "mnist data downloaded...\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3CwHiVn9sonK",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 268
        },
        "outputId": "c400d1b0-5c7c-4554-eaac-b3dd68052c15"
      },
      "source": [
        "# This code cell is for visualization of data only...may be skipped\n",
        "\n",
        "# plot images...subplot function is being used...nice documentation is available on the official webpage of matplotlib\n",
        "# arguments to subplot functions are number of rows, number of columns and \n",
        "# number of subplots in the plot...comma is mandatory if values are less than 10\n",
        "\n",
        "plt.subplot(221)\t\n",
        "plt.imshow(X_train[0], cmap=plt.get_cmap('gray')) # ploting first image of training data set\n",
        "plt.subplot(222)\n",
        "plt.imshow(X_train[134], cmap=plt.get_cmap('gray'))\t# ploting 135th image in training data set\n",
        "plt.subplot(223)\n",
        "plt.imshow(X_test[244], cmap=plt.get_cmap('gray'))\t# ploting 244rth image of test date set\n",
        "plt.subplot(224)\n",
        "plt.imshow(X_test[3], cmap=plt.get_cmap('gray'))\t# ploting 4th image of test data set\n",
        "\n",
        "# show the plot\n",
        "plt.show()\n"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 4 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1PetdwiQsDjq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "91ef3762-ede7-4acd-943d-1a6d414b8a7b"
      },
      "source": [
        "# Print shape of dataset..it will print three tuples, namely the no. of images in dataset, height and width(60000, 28, 28)\n",
        "\n",
        "print (X_train.shape)"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(60000, 28, 28)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8yMtIFlycEVH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bfe07785-771e-4f5b-b73f-94cd20304a53"
      },
      "source": [
        "print (Y_train.shape)"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(60000,)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2xwxGQy2sFIc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "af3bfb0b-1cde-4071-e5a9-4890936d80ba"
      },
      "source": [
        "# Do basic preprocessing of the training data\n",
        "\n",
        "# reshaping the data \n",
        "X_train = X_train.reshape(60000,28,28,1)\n",
        "X_test = X_test.reshape(10000,28,28,1)\n",
        "\n",
        "for_final_test = X_test # we will use this for running predictions\n",
        "\n",
        "# Change the data type from int to float\n",
        "X_train = X_train.astype('float32')\n",
        "X_test = X_test.astype('float32')\n",
        "\n",
        "# Normalize the images\n",
        "X_train /= 255\n",
        "X_test /= 255\n",
        "\n",
        "print('X_train shape:', X_train.shape)\n",
        "print('X_test shape:', X_test.shape)\n",
        "print(X_train.shape[0], 'training samples')\n",
        "print(X_test.shape[0], 'test samples')\n"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "X_train shape: (60000, 28, 28, 1)\n",
            "X_test shape: (10000, 28, 28, 1)\n",
            "60000 training samples\n",
            "10000 test samples\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SJITEAxsjwWp",
        "outputId": "960412a3-39d1-41bc-eb0d-29eca779bdec",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Convert the class labels to one hot encoded matrix\n",
        "\n",
        "num_classes = 10 # number of classess for classification \n",
        "\n",
        "Y_train = keras.utils.to_categorical(Y_train, num_classes)\n",
        "Y_test = keras.utils.to_categorical(Y_test, num_classes)\n",
        "\n",
        "print (Y_train.shape)\n"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(60000, 10)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FtPgp5lStzjk",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5df71081-f083-43a1-a822-1424d261ccc5"
      },
      "source": [
        "# Define model architecture\n",
        "\n",
        "rows, cols = 28,28\n",
        "input_shape = (rows, cols, 1)\n",
        "model = Sequential()\n",
        "\n",
        "#arch 1\n",
        "model.add(Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=input_shape))\n",
        "model.add(Conv2D(64, (3, 3), activation='relu'))\n",
        "model.add(MaxPooling2D(pool_size=(2, 2)))\n",
        "model.add(Flatten()) #Flattens the input, Why ? because we need to connect it to Dense layer\n",
        "model.add(Dense(num_classes, activation='softmax'))\n",
        "\n",
        "# another architecture...you may experiment with the following architecture\n",
        "#arch 2\n",
        "#model.add(Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=input_shape))\n",
        "#model.add(Conv2D(64, (3, 3), activation='relu'))\n",
        "#model.add(MaxPooling2D(pool_size=(2, 2)))\n",
        "#model.add(Dropout(0.25))\n",
        "#model.add(Flatten()) # Flattens the input\n",
        "#model.add(Dense(128, activation='relu'))\n",
        "#model.add(Dropout(0.5))\n",
        "#model.add(Dense(num_classes, activation='softmax'))\n",
        "\n",
        "print (\"keep going...\")"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "keep going...\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kl0RQYZyuHE1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cb593f77-c096-40dc-8f4b-ae2b9fcfc9be"
      },
      "source": [
        "# compiling model\n",
        "\n",
        "model.compile(loss='categorical_crossentropy', optimizer='Adadelta', metrics=['accuracy'])\n",
        "\n",
        "print (\"compile successful...\")"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "compile successful...\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "npPQMD752vA9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b592e035-4d18-4d0d-ee43-584820f5120d"
      },
      "source": [
        "# print model summary\n",
        "print(model.summary())"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "conv2d (Conv2D)              (None, 26, 26, 32)        320       \n",
            "_________________________________________________________________\n",
            "conv2d_1 (Conv2D)            (None, 24, 24, 64)        18496     \n",
            "_________________________________________________________________\n",
            "max_pooling2d (MaxPooling2D) (None, 12, 12, 64)        0         \n",
            "_________________________________________________________________\n",
            "flatten (Flatten)            (None, 9216)              0         \n",
            "_________________________________________________________________\n",
            "dense (Dense)                (None, 10)                92170     \n",
            "=================================================================\n",
            "Total params: 110,986\n",
            "Trainable params: 110,986\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n",
            "None\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dRCZOEUmuKCD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f5e83cb4-05c6-4f76-8bcc-8f54560866c5"
      },
      "source": [
        "# Now we train the model\n",
        "\n",
        "batch_size = 128\n",
        "epochs = 2\n",
        "\n",
        "# start the training\n",
        "\n",
        "history=model.fit(X_train, Y_train, batch_size=batch_size, epochs=epochs, verbose=1, validation_split=0.2)\n",
        "\n",
        "print (\"training done...\")\n"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/2\n",
            "375/375 [==============================] - 103s 276ms/step - loss: 2.2915 - accuracy: 0.0834 - val_loss: 2.2769 - val_accuracy: 0.0972\n",
            "Epoch 2/2\n",
            "375/375 [==============================] - 104s 277ms/step - loss: 2.2608 - accuracy: 0.1510 - val_loss: 2.2429 - val_accuracy: 0.2311\n",
            "training done...\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lEmU2ZbBuT5M",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2e52f92e-f7e1-4196-93e0-740f80b92d3e"
      },
      "source": [
        "# Evaluate the model\n",
        "\n",
        "score = model.evaluate(X_test, Y_test, verbose=1)\n",
        "print('loss:', score[0])\n",
        "print('accuracy:', score[1])"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "313/313 [==============================] - 7s 22ms/step - loss: 2.2445 - accuracy: 0.2086\n",
            "loss: 2.244516372680664\n",
            "accuracy: 0.2085999995470047\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RYlwMsBkoQRm",
        "outputId": "aeeb7106-e3d3-44eb-f115-4c1443fb2dfb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "sample = for_final_test[0,:,:,:]\n",
        "sample = sample.reshape(1,28,28,1)\n",
        "sample.shape\n",
        "print(Y_test[0])\n",
        "model.predict_classes(sample)"
      ],
      "execution_count": 59,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0. 0. 0. 0. 0. 0. 0. 1. 0. 0.]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([5])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 59
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Mrs155-xiIDI",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c44a489d-d8ed-46c6-f5f6-4e3f964a2d5e"
      },
      "source": [
        "#printing metrices\n",
        "print (model.metrics_names)\n",
        "\n",
        "# list all data in history\n",
        "print(history.history.keys())\n"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['loss', 'accuracy']\n",
            "dict_keys(['loss', 'accuracy', 'val_loss', 'val_accuracy'])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LdB0OsTOeDga",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 313
        },
        "outputId": "88bf5437-2e04-442a-fbe1-7f8050b0a42e"
      },
      "source": [
        "# to visualize the performance with plots...plot loss and accuracy in training and validation \n",
        "\n",
        "# Plot for accuracy\n",
        "plt.plot(history.history['accuracy'])\n",
        "plt.plot(history.history['val_accuracy'])\n",
        "plt.title('model accuracy')\n",
        "plt.ylabel('accuracy')\n",
        "plt.xlabel('epoch')\n",
        "plt.legend(['training', 'validation'], loc='center right')\n",
        "plt.show()"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "dict_keys(['loss', 'accuracy', 'val_loss', 'val_accuracy'])\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Dmw7_XWZn6mC",
        "outputId": "00fc0317-adc4-41c4-83cb-cc13c92cf299",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        }
      },
      "source": [
        "# summarize history for loss\n",
        "\n",
        "plt.plot(history.history['loss'])\n",
        "plt.plot(history.history['val_loss'])\n",
        "plt.title('model loss')\n",
        "plt.ylabel('loss')\n",
        "plt.xlabel('epoch')\n",
        "plt.legend(['training', 'validation'], loc='upper right')\n",
        "plt.show()"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}