MNIST-Hand.Written.Digit.Recognition-CNN.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import tensorflow as tf\n",
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /Users/sumitsaha/anaconda/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/base.py:252: _internal_retry.<locals>.wrap.<locals>.wrapped_fn (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use urllib or similar directly.\n",
      "Successfully downloaded train-images-idx3-ubyte.gz 9912422 bytes.\n",
      "WARNING:tensorflow:From /Users/sumitsaha/anaconda/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:262: extract_images (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting ./data/fashion/train-images-idx3-ubyte.gz\n",
      "Successfully downloaded train-labels-idx1-ubyte.gz 28881 bytes.\n",
      "WARNING:tensorflow:From /Users/sumitsaha/anaconda/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:267: extract_labels (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting ./data/fashion/train-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From /Users/sumitsaha/anaconda/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:110: dense_to_one_hot (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.one_hot on tensors.\n",
      "Successfully downloaded t10k-images-idx3-ubyte.gz 1648877 bytes.\n",
      "Extracting ./data/fashion/t10k-images-idx3-ubyte.gz\n",
      "Successfully downloaded t10k-labels-idx1-ubyte.gz 4542 bytes.\n",
      "Extracting ./data/fashion/t10k-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From /Users/sumitsaha/anaconda/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:290: DataSet.__init__ (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n"
     ]
    }
   ],
   "source": [
    "data = input_data.read_data_sets(\"./data/mnist\", one_hot = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training set images shape: (55000, 784)\n",
      "Training set labels shape: (55000, 10)\n",
      "Test set images shape: (10000, 784)\n",
      "Test set labels shape: (10000, 10)\n"
     ]
    }
   ],
   "source": [
    "print(\"Training set images shape: {}\".format(data.train.images.shape))\n",
    "print(\"Training set labels shape: {}\".format(data.train.labels.shape))\n",
    "print(\"Test set images shape: {}\".format(data.test.images.shape))\n",
    "print(\"Test set labels shape: {}\".format(data.test.labels.shape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x131d5e208>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x131bfd780>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "img = np.reshape(data.train.images[2], (28,28))\n",
    "plt.imshow(img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Max Value: 1.0\n",
      "Min Value: 0.0\n"
     ]
    }
   ],
   "source": [
    "print(\"Max Value: {}\\nMin Value: {}\".format(np.max(img), np.min(img)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Shape: (55000, 28, 28, 1)\n",
      "Test Shape: (10000, 28, 28, 1)\n"
     ]
    }
   ],
   "source": [
    "train_X = data.train.images.reshape(-1, 28, 28, 1)\n",
    "test_X = data.test.images.reshape(-1, 28, 28, 1)\n",
    "print(\"Train Shape: {}\\nTest Shape: {}\".format(train_X.shape, test_X.shape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_y = data.train.labels\n",
    "test_y = data.test.labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "epochs = 10\n",
    "learning_rate = 0.001\n",
    "batch_size = 128"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_input = 28\n",
    "n_classes = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = tf.placeholder(\"float\", [None, 28, 28, 1])\n",
    "y = tf.placeholder(\"float\", [None, n_classes])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "def conv2d(x, W, b, stride = 1):\n",
    "    x = tf.nn.conv2d(x, W, strides = [1, stride, stride, 1], padding = \"SAME\")\n",
    "    x = tf.nn.bias_add(x, b)\n",
    "    return tf.nn.relu(x)\n",
    "\n",
    "def maxpool2d(x, k = 2):\n",
    "    return tf.nn.max_pool(x, ksize = [1, k , k , 1], strides = [1, k , k, 1], padding = \"SAME\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "weights = {\n",
    "    'wc1' : tf.get_variable('W0', shape = (3, 3, 1, 32), initializer = tf.contrib.layers.xavier_initializer()),\n",
    "    'wc2' : tf.get_variable('W1', shape = (3, 3, 32, 64), initializer = tf.contrib.layers.xavier_initializer()),\n",
    "    'wc3' : tf.get_variable('W2', shape = (3, 3, 64, 128), initializer = tf.contrib.layers.xavier_initializer()),\n",
    "    'wd1' : tf.get_variable('W3', shape = (4 * 4 * 128, 128), initializer = tf.contrib.layers.xavier_initializer()),\n",
    "    'out' : tf.get_variable('W4', shape = (128, n_classes), initializer = tf.contrib.layers.xavier_initializer())\n",
    "}\n",
    "\n",
    "biases = {\n",
    "    'bc1': tf.get_variable('B0', shape = (32), initializer = tf.contrib.layers.xavier_initializer()),\n",
    "    'bc2': tf.get_variable('B1', shape = (64), initializer = tf.contrib.layers.xavier_initializer()),\n",
    "    'bc3': tf.get_variable('B2', shape = (128), initializer = tf.contrib.layers.xavier_initializer()),\n",
    "    'bd1': tf.get_variable('B3', shape = (128), initializer = tf.contrib.layers.xavier_initializer()),\n",
    "    'out': tf.get_variable('B4', shape = (10), initializer = tf.contrib.layers.xavier_initializer()),\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "def conv_net(x, weights, biases):\n",
    "    conv1 = conv2d(x, weights['wc1'], biases['bc1'])\n",
    "    conv1 = maxpool2d(conv1, k = 2)\n",
    "    conv2 = conv2d(conv1, weights['wc2'], biases['bc2'])\n",
    "    conv2 = maxpool2d(conv2, k = 2)\n",
    "    conv3 = conv2d(conv2, weights['wc3'], biases['bc3'])\n",
    "    conv3 = maxpool2d(conv3, k = 2)\n",
    "    fc1 = tf.reshape(conv3, [-1, weights['wd1'].get_shape().as_list()[0]])\n",
    "    fc1 = tf.add(tf.matmul(fc1, weights['wd1']), biases['bd1'])\n",
    "    fc1 = tf.nn.relu(fc1)\n",
    "    out = tf.add(tf.matmul(fc1, weights['out']), biases['out'])\n",
    "    return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "pred = conv_net(x, weights, biases)\n",
    "cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = pred, labels = y))\n",
    "optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "init = tf.global_variables_initializer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iter 0, Loss= 0.017856, Training Accuracy= 1.00000\n",
      "Optimization Finished!\n",
      "Testing Accuracy: 0.97040\n",
      "Iter 1, Loss= 0.007680, Training Accuracy= 1.00000\n",
      "Optimization Finished!\n",
      "Testing Accuracy: 0.98530\n",
      "Iter 2, Loss= 0.002753, Training Accuracy= 1.00000\n",
      "Optimization Finished!\n",
      "Testing Accuracy: 0.98720\n",
      "Iter 3, Loss= 0.001578, Training Accuracy= 1.00000\n",
      "Optimization Finished!\n",
      "Testing Accuracy: 0.98840\n",
      "Iter 4, Loss= 0.001109, Training Accuracy= 1.00000\n",
      "Optimization Finished!\n",
      "Testing Accuracy: 0.98910\n",
      "Iter 5, Loss= 0.000578, Training Accuracy= 1.00000\n",
      "Optimization Finished!\n",
      "Testing Accuracy: 0.99010\n",
      "Iter 6, Loss= 0.000345, Training Accuracy= 1.00000\n",
      "Optimization Finished!\n",
      "Testing Accuracy: 0.99040\n",
      "Iter 7, Loss= 0.000277, Training Accuracy= 1.00000\n",
      "Optimization Finished!\n",
      "Testing Accuracy: 0.98930\n",
      "Iter 8, Loss= 0.000386, Training Accuracy= 1.00000\n",
      "Optimization Finished!\n",
      "Testing Accuracy: 0.99140\n",
      "Iter 9, Loss= 0.000063, Training Accuracy= 1.00000\n",
      "Optimization Finished!\n",
      "Testing Accuracy: 0.98830\n"
     ]
    }
   ],
   "source": [
    "with tf.Session() as sess:\n",
    "    sess.run(init) \n",
    "    train_loss = []\n",
    "    test_loss = []\n",
    "    train_accuracy = []\n",
    "    test_accuracy = []\n",
    "    summary_writer = tf.summary.FileWriter('./Output', sess.graph)\n",
    "    for i in range(epochs):\n",
    "        for batch in range(len(train_X)//batch_size):\n",
    "            batch_x = train_X[batch*batch_size:min((batch+1)*batch_size,len(train_X))]\n",
    "            batch_y = train_y[batch*batch_size:min((batch+1)*batch_size,len(train_y))]    \n",
    "            opt = sess.run(optimizer, feed_dict={x: batch_x,\n",
    "                                                              y: batch_y})\n",
    "            loss, acc = sess.run([cost, accuracy], feed_dict={x: batch_x,\n",
    "                                                              y: batch_y})\n",
    "        print(\"Iter \" + str(i) + \", Loss= \" + \\\n",
    "                      \"{:.6f}\".format(loss) + \", Training Accuracy= \" + \\\n",
    "                      \"{:.5f}\".format(acc))\n",
    "        print(\"Optimization Finished!\")\n",
    "\n",
    "\n",
    "        test_acc,valid_loss = sess.run([accuracy,cost], feed_dict={x: test_X,y : test_y})\n",
    "        train_loss.append(loss)\n",
    "        test_loss.append(valid_loss)\n",
    "        train_accuracy.append(acc)\n",
    "        test_accuracy.append(test_acc)\n",
    "        print(\"Testing Accuracy:\",\"{:.5f}\".format(test_acc))\n",
    "    summary_writer.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1122d8b00>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1289de4a8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(range(len(train_loss)), train_loss, 'b', label='Training loss')\n",
    "plt.plot(range(len(train_loss)), test_loss, 'r', label='Test loss')\n",
    "plt.title('Training and Test loss')\n",
    "plt.xlabel('Epochs ',fontsize=16)\n",
    "plt.ylabel('Loss',fontsize=16)\n",
    "plt.legend()\n",
    "plt.figure()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1289895f8>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1289243c8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(range(len(train_loss)), train_accuracy, 'b', label='Training Accuracy')\n",
    "plt.plot(range(len(train_loss)), test_accuracy, 'r', label='Test Accuracy')\n",
    "plt.title('Training and Test Accuracy')\n",
    "plt.xlabel('Epochs ',fontsize=16)\n",
    "plt.ylabel('Loss',fontsize=16)\n",
    "plt.legend()\n",
    "plt.figure()\n",
    "plt.show()"
   ]
  }
 ],
 "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.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}