digit_recognition.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "digit_recognition.ipynb",
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyM1RTu4xwlxvxjp/A5k8P96",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/tripathivenkteshwar/digit-recognizer/blob/master/digit_recognition.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Yth-SH1ckWHi",
        "colab_type": "text"
      },
      "source": [
        "# **Digit recognition**\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Uho86bYHkmkX",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        },
        "outputId": "86cec57f-ab46-4e80-9640-6e8ab36484bb"
      },
      "source": [
        "%tensorflow_version 1.x\n",
        "import tensorflow as tf\n",
        "from tensorflow.contrib.layers.python.layers.layers import batch_norm\n",
        "from tensorflow.keras.datasets import mnist\n",
        "import numpy as np\n",
        "from keras.utils import to_categorical\n",
        "import matplotlib.pyplot as plt\n",
        "import math\n",
        "from tensorflow.python.framework import ops\n",
        "ops.reset_default_graph()"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "TensorFlow 1.x selected.\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "Using TensorFlow backend.\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xW5nkbfWlLLQ",
        "colab_type": "text"
      },
      "source": [
        "### **Processing data**\n",
        "\n",
        "**Data split into training/test data*\n",
        "\n",
        "**image dimension \"NHW\" (N: sample size; H: height; W: width)*\n",
        "\n",
        "**Reshape image dimension \"NHWC\" (N: sample size; H: height; W: width; C: channel)*\n",
        "\n",
        "**Normalize both tain/test (data/255)*\n",
        "\n",
        "**one hot encoding of train output/test output*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "woQjiqz5lJ1w",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 90
        },
        "outputId": "27124d65-9d56-4875-ebe5-039f79b3608b"
      },
      "source": [
        "(x_train, y_train), (x_test, y_test) = mnist.load_data()\n",
        "x_train = x_train/255\n",
        "x_test = x_test/255\n",
        "print(x_train.shape, y_train.shape, x_test.shape, y_test.shape)\n",
        "x_train = x_train.reshape(x_train.shape[0], 28,28,1)\n",
        "x_train=x_train.astype(np.float32)\n",
        "x_test = x_test.reshape(x_test.shape[0], 28,28,1) \n",
        "x_test=x_test.astype(np.float32)\n",
        "y_train = to_categorical(y_train, num_classes = 10)\n",
        "y_test = to_categorical(y_test)\n",
        "print(\"y train\", y_train.shape, \"y test\", y_test.shape)"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz\n",
            "11493376/11490434 [==============================] - 0s 0us/step\n",
            "(60000, 28, 28) (60000,) (10000, 28, 28) (10000,)\n",
            "y train (60000, 10) y test (10000, 10)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GBp4MrcAov4L",
        "colab_type": "text"
      },
      "source": [
        "****Weight/bias initialization using xavier***"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q07scuPzouD-",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 162
        },
        "outputId": "eac11a70-3041-4e0e-da8c-bd35d66b7f15"
      },
      "source": [
        "# Number of class\n",
        "n_classes=10\n",
        "\n",
        "weights = {\n",
        "    # Convolution Layers\n",
        "    'c1': tf.get_variable('W1', shape=(3,3,1,16), \\\n",
        "            initializer=tf.contrib.layers.xavier_initializer()), \n",
        "    'c2': tf.get_variable('W2', shape=(3,3,16,16), \\\n",
        "            initializer=tf.contrib.layers.xavier_initializer()),\n",
        "    'c3': tf.get_variable('W3', shape=(3,3,16,32), \\\n",
        "            initializer=tf.contrib.layers.xavier_initializer()),\n",
        "    'c4': tf.get_variable('W4', shape=(3,3,32,32), \\\n",
        "            initializer=tf.contrib.layers.xavier_initializer()),\n",
        "    \n",
        "    # Dense Layers\n",
        "    'd1': tf.get_variable('W5', shape=(7*7*32,128), \n",
        "            initializer=tf.contrib.layers.xavier_initializer()),\n",
        "    'out': tf.get_variable('W6', shape=(128,n_classes), \n",
        "            initializer=tf.contrib.layers.xavier_initializer()),\n",
        "}\n",
        "biases = {\n",
        "    # Convolution Layers\n",
        "    'c1': tf.get_variable('B1', shape=(16), initializer=tf.zeros_initializer()),\n",
        "    'c2': tf.get_variable('B2', shape=(16), initializer=tf.zeros_initializer()),\n",
        "    'c3': tf.get_variable('B3', shape=(32), initializer=tf.zeros_initializer()),\n",
        "    'c4': tf.get_variable('B4', shape=(32), initializer=tf.zeros_initializer()),\n",
        "    \n",
        "    # Dense Layers\n",
        "    'd1': tf.get_variable('B5', shape=(128), initializer=tf.zeros_initializer()),\n",
        "    'out': tf.get_variable('B6', shape=(n_classes), initializer=tf.zeros_initializer()),\n",
        "}\n",
        "\n"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "WARNING:tensorflow:\n",
            "The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
            "For more information, please see:\n",
            "  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
            "  * https://github.com/tensorflow/addons\n",
            "  * https://github.com/tensorflow/io (for I/O related ops)\n",
            "If you depend on functionality not listed there, please file an issue.\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GgdBMJOspRR5",
        "colab_type": "text"
      },
      "source": [
        "****Batch Noramlization***\n",
        "\n",
        "\n",
        "![alt text](https://miro.medium.com/max/506/1*Hiq-rLFGDpESpr8QNsJ1jg.png)\n",
        "\n",
        "\n",
        "[From the original batch-norm paper](https://arxiv.org/pdf/1502.03167v3.pdf)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8-wI8yJ-pQa2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def batch_noramlization(x, train_phase, scope_bn):\n",
        "    if train_phase:\n",
        "      bn_train = batch_norm(x, decay=0.999, epsilon=1e-3, center=True, scale=True,\n",
        "              updates_collections=None,\n",
        "              is_training=True,\n",
        "              reuse=None, # is this right?\n",
        "              trainable=True,\n",
        "              scope=scope_bn)\n",
        "      return bn_train\n",
        "    else:\n",
        "      bn_inference = batch_norm(x, decay=0.999, epsilon=1e-3, center=True, scale=True,\n",
        "              updates_collections=None,\n",
        "              is_training=False,\n",
        "              reuse=True, # is this right?\n",
        "              trainable=True,\n",
        "              scope=scope_bn)\n",
        "      #z = tf.cond(train_phase, lambda: bn_train, lambda: bn_inference)\n",
        "      return bn_inference\n"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wr6EQb0vqf3l",
        "colab_type": "text"
      },
      "source": [
        "****ConvNet/CNN***\n",
        "\n",
        "**CNNs in this kernel follow LeNet-5 Architecture with some improvements:*\n",
        "\n",
        "**Two stacked 3x3 filters replace the single 5x5 filters.*\n",
        "\n",
        "**Max pooling layers inplaces of Average pooling layers.*\n",
        "\n",
        "**ReLU activation replaces sigmoid.*\n",
        "\n",
        "**Batch normalization is added*\n",
        "\n",
        "**Dropout is added*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NUgXZc_ey0C9",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "def conv2d(x, W, b, strides=1, normalize=False, train_phase=False, scope_bn=None):\n",
        "    x = tf.nn.conv2d(x, W, strides=[1,1,1,1], padding='SAME')\n",
        "    x = tf.nn.bias_add(x, b)\n",
        "    #if batch_norm:\n",
        "    #  x=batch_normalization(x)\n",
        "    if normalize:\n",
        "      x=batch_noramlization(x, train_phase, scope_bn)\n",
        "    return tf.nn.relu(x)\n",
        "\n",
        "def conv_forward_prop(data, weight, biase, training=False):\n",
        "    # Convolution layers\n",
        "    conv1 = conv2d(data, weights['c1'], biases['c1'], normalize=True, train_phase=training, scope_bn='bn1') # [28,28,16]\n",
        "    conv2 = conv2d(conv1, weights['c2'], biases['c2'], normalize=True, train_phase=training, scope_bn='bn2') # [28,28,16]\n",
        "    pool1 = tf.nn.max_pool(conv2, ksize=[1,2,2,1], strides=[1,2,2,1], padding='SAME') \n",
        "    # [14,14,16]\n",
        "\n",
        "    conv3 = conv2d(pool1, weights['c3'], biases['c3'], normalize=True, train_phase=training, scope_bn='bn3') # [14,14,32]\n",
        "    conv4 = conv2d(conv3, weights['c4'], biases['c4'], normalize=True, train_phase=training, scope_bn='bn4') # [14,14,32]\n",
        "    pool2 = tf.nn.max_pool(conv4, ksize=[1,2,2,1], strides=[1,2,2,1], padding='SAME') \n",
        "    # [7,7,32]\n",
        "\n",
        "    # Flatten\n",
        "    flat = tf.reshape(pool2, [-1, weights['d1'].get_shape().as_list()[0]]) \n",
        "    # [7*7*32] = [1568]\n",
        "\n",
        "    # Fully connected layer\n",
        "    fc1 = tf.add(tf.matmul(flat, weights['d1']), biases['d1']) # [128]\n",
        "    fc1 = tf.nn.relu(fc1) # [128]\n",
        "\n",
        "    # Dropout\n",
        "    if training:\n",
        "        fc1 = tf.nn.dropout(fc1, rate=0.2)\n",
        "\n",
        "    # Output\n",
        "    out = tf.add(tf.matmul(fc1, weights['out']), biases['out']) # [10]\n",
        "    return out"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "onb_LQOrzLxz",
        "colab_type": "text"
      },
      "source": [
        "****Cost function***"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4gi21-Gky9fG",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def compute_cost(Z3, Y):\n",
        "  cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=Z3, labels=Y))\n",
        "  return cost"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "My3ibq0g1xff",
        "colab_type": "text"
      },
      "source": [
        "****Placeholder for input(X)/output(Y)***"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DBYYvnB5zA2F",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def create_placeholders(n_H0, n_W0, n_C0, n_y):\n",
        "    X = tf.placeholder(tf.float32, shape=[None, n_H0, n_W0, n_C0])\n",
        "    Y = tf.placeholder(tf.float32, shape=[None, n_y])\n",
        "\n",
        "    return X, Y"
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y2o3Edkm19Hl",
        "colab_type": "text"
      },
      "source": [
        "****Mini batch of shuffled data***"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v4GgAYnezE5N",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "def random_mini_batches(X, Y, mini_batch_size = 64, seed = 0):\n",
        "    \n",
        "    m = X.shape[0]                  # number of training examples\n",
        "    mini_batches = []\n",
        "    np.random.seed(seed)\n",
        "    \n",
        "    # Step 1: Shuffle (X, Y)\n",
        "    permutation = list(np.random.permutation(m))\n",
        "    shuffled_X = X[permutation,:,:,:]\n",
        "    shuffled_Y = Y[permutation,:]\n",
        "\n",
        "    # Step 2: Partition (shuffled_X, shuffled_Y). Minus the end case.\n",
        "    num_complete_minibatches = math.floor(m/mini_batch_size) # number of mini batches of size mini_batch_size in your partitionning\n",
        "    for k in range(0, num_complete_minibatches):\n",
        "        mini_batch_X = shuffled_X[k * mini_batch_size : k * mini_batch_size + mini_batch_size,:,:,:]\n",
        "        mini_batch_Y = shuffled_Y[k * mini_batch_size : k * mini_batch_size + mini_batch_size,:]\n",
        "        mini_batch = (mini_batch_X, mini_batch_Y)\n",
        "        mini_batches.append(mini_batch)\n",
        "    \n",
        "    # Handling the end case (last mini-batch < mini_batch_size)\n",
        "    \n",
        "    if m % mini_batch_size != 0:\n",
        "        mini_batch_X = shuffled_X[num_complete_minibatches * mini_batch_size : m,:,:,:]\n",
        "        mini_batch_Y = shuffled_Y[num_complete_minibatches * mini_batch_size : m,:]\n",
        "        mini_batch = (mini_batch_X, mini_batch_Y)\n",
        "        mini_batches.append(mini_batch)\n",
        "    \n",
        "    return mini_batches"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PCV_MdEX2O3R",
        "colab_type": "text"
      },
      "source": [
        "****Final model:***\n",
        "\n",
        "**Create placeholder for data feeding/output*\n",
        "\n",
        "**Foraward pass*\n",
        "\n",
        "**Cost calculation*\n",
        "\n",
        "**Adam Optimizer on cost*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zBs3MqEAhthH",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def model(X_train, Y_train, X_test, Y_test, \n",
        "          learning_rate = 0.009,\n",
        "          num_epochs = 50, minibatch_size = 64,\n",
        "          print_cost = True, training=False):\n",
        "\n",
        "    (m, n_H0, n_W0, n_C0) = X_train.shape\n",
        "    n_y = Y_train.shape[1]\n",
        "\n",
        "    X, Y = create_placeholders(n_H0, n_W0, n_C0, n_y)\n",
        "  \n",
        "    Z3 = conv_forward_prop(X, weights, biases, training=training)\n",
        "    #with tf.GradientTape() as tape:\n",
        "    cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=Z3, labels=Y))\n",
        "\n",
        "    #cost = compute_cost(Z3, Y)\n",
        "\t  \n",
        "    optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)\n",
        "    costs=[]\n",
        "    with tf.Session() as sess:\n",
        "      #writer=tf.summary.FileWriter(\"./log\", sess.graph)\n",
        "      sess.run(tf.global_variables_initializer())\n",
        "      sess.run(tf.local_variables_initializer())\n",
        "      \n",
        "      for epoch in range(num_epochs):\n",
        "              \n",
        "              minibatch_cost = 0.\n",
        "              \n",
        "              num_minibatches = int(m / minibatch_size) # number of minibatches of size minibatch_size in the train set\n",
        "              \n",
        "              minibatches = random_mini_batches(X_train, Y_train, mini_batch_size=minibatch_size)\n",
        "\n",
        "              for minibatch in minibatches:\n",
        "                \n",
        "                (minibatch_X, minibatch_Y) = minibatch\n",
        "\n",
        "                _ , temp_cost = sess.run([optimizer, cost], feed_dict={X:minibatch_X, Y:minibatch_Y})\n",
        "                \n",
        "\n",
        "                minibatch_cost += temp_cost / num_minibatches\n",
        "\n",
        "              # Print the cost every epoch\n",
        "              if print_cost == True and epoch % 5 == 0:\n",
        "                  print (\"Cost after epoch %i: %f\" % (epoch, minibatch_cost))\n",
        "              if print_cost == True and epoch % 1 == 0:\n",
        "                  costs.append(minibatch_cost)\n",
        "      #writer.close()\n",
        "\n",
        "      plt.plot(np.squeeze(costs))\n",
        "      plt.ylabel('cost')\n",
        "      plt.xlabel('iterations (per tens)')\n",
        "      plt.title(\"Learning rate =\" + str(learning_rate))\n",
        "      plt.show()\n",
        "      predict_op = tf.argmax(Z3, 1)\n",
        "      correct_prediction = tf.equal(predict_op, tf.argmax(Y, 1))\n",
        "\n",
        "      accuracy = tf.reduce_mean(tf.cast(correct_prediction, \"float\"))\n",
        "      print(\"accuracy\", accuracy)\n",
        "      train_accuracy = accuracy.eval({X: X_train, Y: Y_train})\n",
        "      test_accuracy = accuracy.eval({X: X_test, Y: Y_test})\n",
        "      print(\"Train Accuracy:\", train_accuracy)\n",
        "      print(\"Test Accuracy:\", test_accuracy)\n",
        "      \n",
        "      predictions = sess.run(tf.argmax(conv_forward_prop(X_test[:25,:,:,:], weights, biases), axis=1))\n",
        "      f, axarr = plt.subplots(2, 5, figsize=(15,5))\n",
        "      for idx in range(10):\n",
        "          axarr[int(idx/5), idx%5].imshow(np.squeeze(X_test[idx]), cmap='gray')\n",
        "          axarr[int(idx/5), idx%5].set_title(str(predictions[idx]),fontsize=20)\n",
        "      if training:\n",
        "          saver = tf.train.Saver() \n",
        "          saver.save(sess, 'my_test_model.ckpt')"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-kmtLFtAinRM",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 855
        },
        "outputId": "70055b27-5de4-4d51-b8e1-0e5b8f122954"
      },
      "source": [
        "model(x_train[:,:,:,:], y_train[:,:], x_test[:,:,:,:], y_test[:,:], training=True)"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Cost after epoch 0: 0.602881\n",
            "Cost after epoch 5: 0.072185\n",
            "Cost after epoch 10: 0.041337\n",
            "Cost after epoch 15: 0.032591\n",
            "Cost after epoch 20: 0.028220\n",
            "Cost after epoch 25: 0.024652\n",
            "Cost after epoch 30: 0.026933\n",
            "Cost after epoch 35: 0.022816\n",
            "Cost after epoch 40: 0.020905\n",
            "Cost after epoch 45: 0.024450\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"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "accuracy Tensor(\"Mean_1:0\", shape=(), dtype=float32)\n",
            "Train Accuracy: 0.99525\n",
            "Test Accuracy: 0.9894\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1080x360 with 10 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mdvvG04JiyNo",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 331
        },
        "outputId": "b1fa9855-54e9-45d6-dabc-fc320f03095f"
      },
      "source": [
        "#testing\n",
        "sess = tf.Session()\n",
        "saver = tf.train.Saver()\n",
        "saver.restore(sess, tf.train.latest_checkpoint('./'))\n",
        "\n",
        "predictions = sess.run(tf.argmax(conv_forward_prop(x_test[:,:,:,:], weights, biases), axis=1))\n",
        "#predictions = np.argmax(np.squeeze(onehot_predictions), axis=1)\n",
        "idx = 35\n",
        "f, axarr = plt.subplots(2, 5, figsize=(10,5))\n",
        "for i in range(2):\n",
        "    for j in range(5):\n",
        "        axarr[i,j].imshow(np.squeeze(x_test[idx]), cmap='gray')\n",
        "        axarr[i,j].set_title(str(predictions[idx]),fontsize=20)\n",
        "        idx += 23"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Restoring parameters from ./my_test_model.ckpt\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x360 with 10 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FYQNf8kDjufk",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}