mnist_cnn.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Importing all necessary libraries\n",
    "like numpy, matplotlit.pyplot, tensorflow,confusion matrix, time, datetime, math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "from sklearn.metrics import confusion_matrix\n",
    "import time\n",
    "from datetime import timedelta\n",
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tensorflow version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.7.0'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.__version__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Configuration of neural network\n",
    "(28,28)------>(14,14)-------->(7,7)----->128----->10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convolutional Layer 1.\n",
    "filter_size1 = 5          # Convolution filters are 5 x 5 pixels.\n",
    "num_filters1 = 16         # There are 16 of these filters.\n",
    "\n",
    "# Convolutional Layer 2.\n",
    "filter_size2 = 5          # Convolution filters are 5 x 5 pixels.\n",
    "num_filters2 = 36         # There are 36 of these filters.\n",
    "\n",
    "# Fully-connected layer.\n",
    "fc_size = 128             # Number of neurons in fully-connected layer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Read data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /home/rajendra/.local/lib/python3.5/site-packages/tensorflow/contrib/learn/python/learn/datasets/base.py:198: retry (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use the retry module or similar alternatives.\n",
      "WARNING:tensorflow:From <ipython-input-4-37adf088ce13>:2: read_data_sets (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",
      "WARNING:tensorflow:From /home/rajendra/.local/lib/python3.5/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:260: maybe_download (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please write your own downloading logic.\n",
      "WARNING:tensorflow:From /home/rajendra/.local/lib/python3.5/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/MNIST/train-images-idx3-ubyte.gz\n",
      "WARNING:tensorflow:From /home/rajendra/.local/lib/python3.5/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/MNIST/train-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From /home/rajendra/.local/lib/python3.5/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",
      "Extracting data/MNIST/t10k-images-idx3-ubyte.gz\n",
      "Extracting data/MNIST/t10k-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From /home/rajendra/.local/lib/python3.5/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": [
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "data = input_data.read_data_sets('data/MNIST/', one_hot=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Size of:\n",
      "- Training-set:\t\t55000\n",
      "- Test-set:\t\t10000\n",
      "- Validation-set:\t5000\n"
     ]
    }
   ],
   "source": [
    "print(\"Size of:\")\n",
    "print(\"- Training-set:\\t\\t{}\".format(len(data.train.labels)))\n",
    "print(\"- Test-set:\\t\\t{}\".format(len(data.test.labels)))\n",
    "print(\"- Validation-set:\\t{}\".format(len(data.validation.labels)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# getting labels out from one hot matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "data.test.cls = np.argmax(data.test.labels, axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Declaring known variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We know that MNIST images are 28 pixels in each dimension.\n",
    "img_size = 28\n",
    "\n",
    "# Images are stored in one-dimensional arrays of this length.\n",
    "img_size_flat = img_size * img_size\n",
    "\n",
    "# Tuple with height and width of images used to reshape arrays.\n",
    "img_shape = (img_size, img_size)\n",
    "\n",
    "# Number of colour channels for the images: 1 channel for gray-scale.\n",
    "num_channels = 1\n",
    "\n",
    "# Number of classes, one class for each of 10 digits.\n",
    "num_classes = 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Helper-function for plotting images\n",
    "Function used to plot 9 images in a 3x3 grid, and writing the true and predicted classes below each image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_images(images, cls_true, cls_pred=None):\n",
    "    assert len(images) == len(cls_true) == 9\n",
    "    \n",
    "    # Create figure with 3x3 sub-plots.\n",
    "    fig, axes = plt.subplots(3, 3)\n",
    "    fig.subplots_adjust(hspace=0.3, wspace=0.3)\n",
    "\n",
    "    for i, ax in enumerate(axes.flat):\n",
    "        # Plot image.\n",
    "        ax.imshow(images[i].reshape(img_shape), cmap='binary')\n",
    "\n",
    "        # Show true and predicted classes.\n",
    "        if cls_pred is None:\n",
    "            xlabel = \"True: {0}\".format(cls_true[i])\n",
    "        else:\n",
    "            xlabel = \"True: {0}, Pred: {1}\".format(cls_true[i], cls_pred[i])\n",
    "\n",
    "        # Show the classes as the label on the x-axis.\n",
    "        ax.set_xlabel(xlabel)\n",
    "        \n",
    "        # Remove ticks from the plot.\n",
    "        ax.set_xticks([])\n",
    "        ax.set_yticks([])\n",
    "    \n",
    "    # Ensure the plot is shown correctly with multiple plots\n",
    "    # in a single Notebook cell.\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot a few images to see if data is correct"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Get the first images from the test-set.\n",
    "images = data.test.images[0:9]\n",
    "\n",
    "# Get the true classes for those images.\n",
    "cls_true = data.test.cls[0:9]\n",
    "\n",
    "# Plot the images and labels using our helper-function above.\n",
    "plot_images(images=images, cls_true=cls_true)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A TensorFlow graph consists of the following parts which will be detailed below:\n",
    "\n",
    "-Placeholder variables used for inputting data to the graph.\n",
    "\n",
    "-Variables that are going to be optimized so as to make the convolutional network perform better.\n",
    "\n",
    "-The mathematical formulas for the convolutional network.\n",
    "\n",
    "-A cost measure that can be used to guide the optimization of the variables.\n",
    "\n",
    "-An optimization method which updates the variables.\n",
    "\n",
    "-In addition, the TensorFlow graph may also contain various debugging statements e.g. for logging data to be displayed using TensorBoard.\n",
    "\n",
    "# Helper-functions for creating new variables\n",
    "Functions for creating new TensorFlow variables in the given shape and initializing them with random values. Note that the initialization is not actually done at this point, it is merely being defined in the TensorFlow graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def new_weights(shape):#takes the shape of weight matrix and initialise randon weight matrix\n",
    "    return tf.Variable(tf.truncated_normal(shape, stddev=0.05))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def new_biases(length):#genrate random baised vector of 'length'\n",
    "    return tf.Variable(tf.constant(0.05, shape=[length]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def new_conv_layer(input,              # The previous layer.\n",
    "                   num_input_channels, # Num. channels in prev. layer.\n",
    "                   filter_size,        # Width and height of each filter.\n",
    "                   num_filters,        # Number of filters.\n",
    "                   use_pooling=True):  # Use 2x2 max-pooling.\n",
    "\n",
    "    # Shape of the filter-weights for the convolution.\n",
    "    # This format is determined by the TensorFlow API.\n",
    "    shape = [filter_size, filter_size, num_input_channels, num_filters]\n",
    "\n",
    "    # Create new weights aka. filters with the given shape.\n",
    "    weights = new_weights(shape=shape)\n",
    "\n",
    "    # Create new biases, one for each filter.\n",
    "    biases = new_biases(length=num_filters)\n",
    "\n",
    "    # Create the TensorFlow operation for convolution.\n",
    "    # Note the strides are set to 1 in all dimensions.\n",
    "    # The first and last stride must always be 1,\n",
    "    # because the first is for the image-number and\n",
    "    # the last is for the input-channel.\n",
    "    # But e.g. strides=[1, 2, 2, 1] would mean that the filter\n",
    "    # is moved 2 pixels across the x- and y-axis of the image.\n",
    "    # The padding is set to 'SAME' which means the input image\n",
    "    # is padded with zeroes so the size of the output is the same.\n",
    "    layer = tf.nn.conv2d(input=input,\n",
    "                         filter=weights,\n",
    "                         strides=[1, 1, 1, 1],#strides in x and y both = 1\n",
    "                         padding='SAME')#padding with zeroes\n",
    "\n",
    "    # Add the biases to the results of the convolution.\n",
    "    # A bias-value is added to each filter-channel.\n",
    "    layer += biases\n",
    "\n",
    "    # Use pooling to down-sample the image resolution?\n",
    "    if use_pooling:\n",
    "        # This is 2x2 max-pooling, which means that we\n",
    "        # consider 2x2 windows and select the largest value\n",
    "        # in each window. Then we move 2 pixels to the next window.\n",
    "        layer = tf.nn.max_pool(value=layer,\n",
    "                               ksize=[1, 2, 2, 1], #window size\n",
    "                               strides=[1, 2, 2, 1],\n",
    "                               padding='SAME')\n",
    "\n",
    "    # Rectified Linear Unit (ReLU).\n",
    "    # It calculates max(x, 0) for each input pixel x.\n",
    "    # This adds some non-linearity to the formula and allows us\n",
    "    # to learn more complicated functions.\n",
    "    layer = tf.nn.relu(layer)\n",
    "\n",
    "    # Note that ReLU is normally executed before the pooling,\n",
    "    # but since relu(max_pool(x)) == max_pool(relu(x)) we can\n",
    "    # save 75% of the relu-operations by max-pooling first.\n",
    "\n",
    "    # We return both the resulting layer and the filter-weights\n",
    "    # because we will plot the weights later.\n",
    "    return layer, weights"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Helper-function for flattening a layer\n",
    "A convolutional layer produces an output tensor with 4 dimensions. We will add fully-connected layers after the convolution layers, so we need to reduce the 4-dim tensor to 2-dim which can be used as input to the fully-connected layer.\n",
    "### The shape of the input layer is assumed to be:\n",
    "# layer_shape == [num_images, img_height, img_width, num_channels]\n",
    "### The shape of the flattened layer is now:\n",
    "# [num_images, img_height x img_width x num_channels]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def flatten_layer(layer):\n",
    "    # Get the shape of the input layer.\n",
    "    layer_shape = layer.get_shape()\n",
    "\n",
    "    # The shape of the input layer is assumed to be:\n",
    "    # layer_shape == [num_images, img_height, img_width, num_channels]\n",
    "\n",
    "    # The number of features is: img_height * img_width * num_channels\n",
    "    # We can use a function from TensorFlow to calculate this.\n",
    "    num_features = layer_shape[1:4].num_elements()\n",
    "    \n",
    "    # Reshape the layer to [num_images, num_features].\n",
    "    # Note that we just set the size of the second dimension\n",
    "    # to num_features and the size of the first dimension to -1\n",
    "    # which means the size in that dimension is calculated\n",
    "    # so the total size of the tensor is unchanged from the reshaping.\n",
    "    layer_flat = tf.reshape(layer, [-1, num_features])\n",
    "\n",
    "    # The shape of the flattened layer is now:\n",
    "    # [num_images, img_height * img_width * num_channels]\n",
    "\n",
    "    # Return both the flattened layer and the number of features.\n",
    "    return layer_flat, num_features"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# FC = Relu[( input * weights) + biases]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def new_fc_layer(input,          # The previous 2d layer.\n",
    "                 num_inputs,     # Num. inputs from prev. layer.\n",
    "                 num_outputs,    # Num. outputs.\n",
    "                 use_relu=True): # Use Rectified Linear Unit (ReLU)?\n",
    "\n",
    "    # Create new weights and biases.\n",
    "    weights = new_weights(shape=[num_inputs, num_outputs])\n",
    "    biases = new_biases(length=num_outputs)\n",
    "\n",
    "    # Calculate the layer as the matrix multiplication of\n",
    "    # the input and weights, and then add the bias-values.\n",
    "    layer = tf.matmul(input, weights) + biases\n",
    "\n",
    "    # Use ReLU?\n",
    "    if use_relu:\n",
    "        layer = tf.nn.relu(layer)\n",
    "\n",
    "    return layer #2d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Placeholder variables\n",
    "Convert input to tensor\n",
    "\n",
    "The data-type is set to float32 and the shape is set to [None, img_size_flat], where None means that the tensor may hold an arbitrary number of images with each image being a vector of length img_size_flat."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = tf.placeholder(tf.float32, shape=[None, img_size_flat], name='x')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "converting tensor to 4d as CL takes input as 4d layer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_image = tf.reshape(x, [-1, img_size, img_size, num_channels])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### placeholder variable for the true labels and it is one hot matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_true = tf.placeholder(tf.float32, shape=[None, num_classes], name='y_true')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### calling argmax on one hot of y_true"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_true_cls = tf.argmax(y_true, axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CL1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "layer_conv1, weights_conv1 = \\\n",
    "    new_conv_layer(input=x_image,\n",
    "                   num_input_channels=num_channels,\n",
    "                   filter_size=filter_size1,\n",
    "                   num_filters=num_filters1,\n",
    "                   use_pooling=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'Relu:0' shape=(?, 14, 14, 16) dtype=float32>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "layer_conv1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CL2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "layer_conv2, weights_conv2 = \\\n",
    "    new_conv_layer(input=layer_conv1,\n",
    "                   num_input_channels=num_filters1, #here 1, as grayscale\n",
    "                   filter_size=filter_size2,  #5x5\n",
    "                   num_filters=num_filters2,#16\n",
    "                   use_pooling=True)#yes 2x2 pooling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'Relu_1:0' shape=(?, 7, 7, 36) dtype=float32>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "layer_conv2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Flatten layers : 4d----->2d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "layer_flat, num_features = flatten_layer(layer_conv2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'Reshape_1:0' shape=(?, 1764) dtype=float32>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "layer_flat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num_features"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# FC1\n",
    "and Relu = true"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "layer_fc1 = new_fc_layer(input=layer_flat,\n",
    "                         num_inputs=num_features,\n",
    "                         num_outputs=fc_size,\n",
    "                         use_relu=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'Relu_2:0' shape=(?, 128) dtype=float32>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "layer_fc1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# FC2\n",
    "and Relu = false"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "layer_fc2 = new_fc_layer(input=layer_fc1,\n",
    "                         num_inputs=fc_size,\n",
    "                         num_outputs=num_classes,\n",
    "                         use_relu=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'add_3:0' shape=(?, 10) dtype=float32>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "layer_fc2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# called softmax \n",
    "on FC2 layer output with gives the output between (0,1) or called probability with sum to 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = tf.nn.softmax(layer_fc2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# argmax gives the Predicted Class!!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_cls = tf.argmax(y_pred, axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Error or cross_entropy between FC2 output and y_true"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-32-2dd067a7547b>:2: softmax_cross_entropy_with_logits (from tensorflow.python.ops.nn_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "\n",
      "Future major versions of TensorFlow will allow gradients to flow\n",
      "into the labels input on backprop by default.\n",
      "\n",
      "See tf.nn.softmax_cross_entropy_with_logits_v2.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits=layer_fc2,\n",
    "                                                        labels=y_true)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "cost = tf.reduce_mean(cross_entropy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Gradient Descent \n",
    "### or Tensorflow Optimizer called"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = tf.train.AdamOptimizer(learning_rate=1e-4).minimize(cost)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Accuracy on input data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "correct_prediction = tf.equal(y_pred_cls, y_true_cls)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tensorflow Run\n",
    "## Create TensorFlow session\n",
    "Since TensorFlow graph has been created, we will now create session which execute the graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "session = tf.Session()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Initialise all variable of graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "session.run(tf.global_variables_initializer())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### We will feed small part of training images in each iteration of the optimizer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_batch_size = 64"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Counter for total number of iterations performed so far.\n",
    "total_iterations = 0\n",
    "\n",
    "def optimize(num_iterations):\n",
    "    # Ensure we update the global variable rather than a local copy.\n",
    "    global total_iterations\n",
    "\n",
    "    # Start-time used for printing time-usage below.\n",
    "    start_time = time.time()\n",
    "\n",
    "    for i in range(total_iterations,\n",
    "                   total_iterations + num_iterations):\n",
    "\n",
    "        # Get a batch of training examples.\n",
    "        # x_batch now holds a batch of images and\n",
    "        # y_true_batch are the true labels for those images.\n",
    "        x_batch, y_true_batch = data.train.next_batch(train_batch_size)\n",
    "\n",
    "        # Put the batch into a dict with the proper names\n",
    "        # for placeholder variables in the TensorFlow graph.\n",
    "        feed_dict_train = {x: x_batch,\n",
    "                           y_true: y_true_batch}\n",
    "\n",
    "        # Run the optimizer using this batch of training data.\n",
    "        # TensorFlow assigns the variables in feed_dict_train\n",
    "        # to the placeholder variables and then runs the optimizer.\n",
    "        session.run(optimizer, feed_dict=feed_dict_train)\n",
    "\n",
    "        # Print status every 100 iterations.\n",
    "        if i % 100 == 0:\n",
    "            # Calculate the accuracy on the training-set.\n",
    "            acc = session.run(accuracy, feed_dict=feed_dict_train)\n",
    "\n",
    "            # Message for printing.\n",
    "            msg = \"Optimization Iteration: {0:>6}, Training Accuracy: {1:>6.1%}\"\n",
    "\n",
    "            # Print it.\n",
    "            print(msg.format(i + 1, acc))\n",
    "\n",
    "    # Update the total number of iterations performed.\n",
    "    total_iterations += num_iterations\n",
    "\n",
    "    # Ending time.\n",
    "    end_time = time.time()\n",
    "\n",
    "    # Difference between start and end-times.\n",
    "    time_dif = end_time - start_time\n",
    "\n",
    "    # Print the time-usage.\n",
    "    print(\"Time usage: \" + str(timedelta(seconds=int(round(time_dif)))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Function defined for  Plot mis-classified image from test-set and will be called inside print_test_accuracy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_example_errors(cls_pred, correct):\n",
    "    # This function is called from print_test_accuracy() below.\n",
    "\n",
    "    # cls_pred is an array of the predicted class-number for\n",
    "    # all images in the test-set.\n",
    "\n",
    "    # correct is a boolean array whether the predicted class\n",
    "    # is equal to the true class for each image in the test-set.\n",
    "\n",
    "    # Negate the boolean array.\n",
    "    incorrect = (correct == False)\n",
    "    \n",
    "    # Get the images from the test-set that have been\n",
    "    # incorrectly classified.\n",
    "    images = data.test.images[incorrect]\n",
    "    \n",
    "    # Get the predicted classes for those images.\n",
    "    cls_pred = cls_pred[incorrect]\n",
    "\n",
    "    # Get the true classes for those images.\n",
    "    cls_true = data.test.cls[incorrect]\n",
    "    \n",
    "    # Plot the first 9 images.\n",
    "    plot_images(images=images[0:9],\n",
    "                cls_true=cls_true[0:9],\n",
    "                cls_pred=cls_pred[0:9])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# plot_confusion_matrix func. defined and will be called inside print_test_accuracy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_confusion_matrix(cls_pred):\n",
    "    # This is called from print_test_accuracy() below.\n",
    "\n",
    "    # cls_pred is an array of the predicted class-number for\n",
    "    # all images in the test-set.\n",
    "\n",
    "    # Get the true classifications for the test-set.\n",
    "    cls_true = data.test.cls\n",
    "    \n",
    "    # Get the confusion matrix using sklearn.\n",
    "    cm = confusion_matrix(y_true=cls_true,\n",
    "                          y_pred=cls_pred)\n",
    "\n",
    "    # Print the confusion matrix as text.\n",
    "    print(cm)\n",
    "\n",
    "    # Plot the confusion matrix as an image.\n",
    "    plt.matshow(cm)\n",
    "\n",
    "    # Make various adjustments to the plot.\n",
    "    plt.colorbar()\n",
    "    tick_marks = np.arange(num_classes)\n",
    "    plt.xticks(tick_marks, range(num_classes))\n",
    "    plt.yticks(tick_marks, range(num_classes))\n",
    "    plt.xlabel('Predicted')\n",
    "    plt.ylabel('True')\n",
    "\n",
    "    # Ensure the plot is shown correctly with multiple plots\n",
    "    # in a single Notebook cell.\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Printing Performance on test-set\n",
    "# i.e Test-set Accuracy \n",
    "## and if desired then also mis-classified image and confusion matrixs\n",
    "Function for printing the classification accuracy on the test-set.\n",
    "It takes a while to compute the classification for all the images in the test-set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Split the test-set into smaller batches of this size.\n",
    "test_batch_size = 256\n",
    "\n",
    "def print_test_accuracy(show_example_errors=False,\n",
    "                        show_confusion_matrix=False):\n",
    "\n",
    "    # Number of images in the test-set.\n",
    "    num_test = len(data.test.images)\n",
    "\n",
    "    # Allocate an array for the predicted classes which\n",
    "    # will be calculated in batches and filled into this array.\n",
    "    cls_pred = np.zeros(shape=num_test, dtype=np.int)\n",
    "\n",
    "    # Now calculate the predicted classes for the batches.\n",
    "    # We will just iterate through all the batches.\n",
    "    # There might be a more clever and Pythonic way of doing this.\n",
    "\n",
    "    # The starting index for the next batch is denoted i.\n",
    "    i = 0\n",
    "\n",
    "    while i < num_test:\n",
    "        # The ending index for the next batch is denoted j.\n",
    "        j = min(i + test_batch_size, num_test)\n",
    "\n",
    "        # Get the images from the test-set between index i and j.\n",
    "        images = data.test.images[i:j, :]\n",
    "\n",
    "        # Get the associated labels.\n",
    "        labels = data.test.labels[i:j, :]\n",
    "\n",
    "        # Create a feed-dict with these images and labels.\n",
    "        feed_dict = {x: images,\n",
    "                     y_true: labels}\n",
    "\n",
    "        # Calculate the predicted class using TensorFlow.\n",
    "        cls_pred[i:j] = session.run(y_pred_cls, feed_dict=feed_dict)\n",
    "\n",
    "        # Set the start-index for the next batch to the\n",
    "        # end-index of the current batch.\n",
    "        i = j\n",
    "\n",
    "    # Convenience variable for the true class-numbers of the test-set.\n",
    "    cls_true = data.test.cls\n",
    "\n",
    "    # Create a boolean array whether each image is correctly classified.\n",
    "    correct = (cls_true == cls_pred)\n",
    "\n",
    "    # Calculate the number of correctly classified images.\n",
    "    # When summing a boolean array, False means 0 and True means 1.\n",
    "    correct_sum = correct.sum()\n",
    "\n",
    "    # Classification accuracy is the number of correctly classified\n",
    "    # images divided by the total number of images in the test-set.\n",
    "    acc = float(correct_sum) / num_test\n",
    "\n",
    "    # Print the accuracy.\n",
    "    msg = \"Accuracy on Test-Set: {0:.1%} ({1} / {2})\"\n",
    "    print(msg.format(acc, correct_sum, num_test))\n",
    "\n",
    "    # Plot some examples of mis-classifications, if desired.\n",
    "    if show_example_errors:\n",
    "        print(\"Mis-classified image on test-set:\")\n",
    "        plot_example_errors(cls_pred=cls_pred, correct=correct)\n",
    "\n",
    "    # Plot the confusion matrix, if desired.\n",
    "    if show_confusion_matrix:\n",
    "        print(\"Confusion Matrix:\")\n",
    "        plot_confusion_matrix(cls_pred=cls_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test accuracy before any optimation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on Test-Set: 9.1% (913 / 10000)\n"
     ]
    }
   ],
   "source": [
    "print_test_accuracy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1st optimization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimization Iteration:      1, Training Accuracy:   3.1%\n",
      "Time usage: 0:00:01\n"
     ]
    }
   ],
   "source": [
    "optimize(num_iterations=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on Test-Set: 6.3% (626 / 10000)\n"
     ]
    }
   ],
   "source": [
    "print_test_accuracy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Next 99 optimiztion, so total=100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time usage: 0:00:12\n"
     ]
    }
   ],
   "source": [
    "optimize(num_iterations=99) # We already performed 1 iteration above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on Test-Set: 63.3% (6333 / 10000)\n",
      "Example errors:\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print_test_accuracy(show_example_errors=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Next 900 optimiztion, so total=1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimization Iteration:    101, Training Accuracy:  68.8%\n",
      "Optimization Iteration:    201, Training Accuracy:  76.6%\n",
      "Optimization Iteration:    301, Training Accuracy:  81.2%\n",
      "Optimization Iteration:    401, Training Accuracy:  92.2%\n",
      "Optimization Iteration:    501, Training Accuracy:  87.5%\n",
      "Optimization Iteration:    601, Training Accuracy:  92.2%\n",
      "Optimization Iteration:    701, Training Accuracy:  89.1%\n",
      "Optimization Iteration:    801, Training Accuracy:  90.6%\n",
      "Optimization Iteration:    901, Training Accuracy:  92.2%\n",
      "Time usage: 0:01:48\n"
     ]
    }
   ],
   "source": [
    "optimize(num_iterations=900) # We performed 100 iterations above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on Test-Set: 93.9% (9392 / 10000)\n",
      "Example errors:\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print_test_accuracy(show_example_errors=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Next 9000 optimiztion, so total=10000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimization Iteration:   1001, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   1101, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   1201, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   1301, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   1401, Training Accuracy:  90.6%\n",
      "Optimization Iteration:   1501, Training Accuracy:  92.2%\n",
      "Optimization Iteration:   1601, Training Accuracy:  95.3%\n",
      "Optimization Iteration:   1701, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   1801, Training Accuracy:  95.3%\n",
      "Optimization Iteration:   1901, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   2001, Training Accuracy:  93.8%\n",
      "Optimization Iteration:   2101, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   2201, Training Accuracy:  92.2%\n",
      "Optimization Iteration:   2301, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   2401, Training Accuracy:  93.8%\n",
      "Optimization Iteration:   2501, Training Accuracy:  93.8%\n",
      "Optimization Iteration:   2601, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   2701, Training Accuracy:  95.3%\n",
      "Optimization Iteration:   2801, Training Accuracy:  95.3%\n",
      "Optimization Iteration:   2901, Training Accuracy:  95.3%\n",
      "Optimization Iteration:   3001, Training Accuracy:  95.3%\n",
      "Optimization Iteration:   3101, Training Accuracy:  95.3%\n",
      "Optimization Iteration:   3201, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   3301, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   3401, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   3501, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   3601, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   3701, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   3801, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   3901, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   4001, Training Accuracy:  92.2%\n",
      "Optimization Iteration:   4101, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   4201, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   4301, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   4401, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   4501, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   4601, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   4701, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   4801, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   4901, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   5001, Training Accuracy:  95.3%\n",
      "Optimization Iteration:   5101, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   5201, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   5301, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   5401, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   5501, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   5601, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   5701, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   5801, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   5901, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   6001, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   6101, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   6201, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   6301, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   6401, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   6501, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   6601, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   6701, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   6801, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   6901, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   7001, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   7101, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   7201, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   7301, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   7401, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   7501, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   7601, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   7701, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   7801, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   7901, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   8001, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   8101, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   8201, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   8301, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   8401, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   8501, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   8601, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   8701, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   8801, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   8901, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   9001, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   9101, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   9201, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   9301, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   9401, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   9501, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   9601, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   9701, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   9801, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   9901, Training Accuracy: 100.0%\n",
      "Time usage: 0:19:18\n"
     ]
    }
   ],
   "source": [
    "optimize(num_iterations=9000) # We performed 1000 iterations above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on Test-Set: 98.7% (9868 / 10000)\n",
      "Example errors:\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion Matrix:\n",
      "[[ 970    0    1    0    0    2    2    0    3    2]\n",
      " [   0 1127    1    0    0    0    2    1    4    0]\n",
      " [   0    0 1021    1    1    0    0    3    5    1]\n",
      " [   0    0    2 1002    0    2    0    0    1    3]\n",
      " [   0    0    2    0  967    0    0    0    1   12]\n",
      " [   2    0    0    5    0  878    1    0    2    4]\n",
      " [   4    2    0    1    1    7  942    0    1    0]\n",
      " [   0    1    7    1    0    0    0 1007    2   10]\n",
      " [   3    0    3    4    1    1    0    2  955    5]\n",
      " [   0    2    0    3    2    1    0    1    1  999]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print_test_accuracy(show_example_errors=True,\n",
    "                    show_confusion_matrix=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualization of Weights and Layers\n",
    "In trying to understand why the convolutional neural network can recognize handwritten digits, we will now visualize the weights of the convolutional filters and the resulting output images.\n",
    "\n",
    "### Plot_conv_weights function defined¶"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_conv_weights(weights, input_channel=0):\n",
    "    # Assume weights are TensorFlow ops for 4-dim variables\n",
    "    # e.g. weights_conv1 or weights_conv2.\n",
    "    \n",
    "    # Retrieve the values of the weight-variables from TensorFlow.\n",
    "    # A feed-dict is not necessary because nothing is calculated.\n",
    "    w = session.run(weights)\n",
    "\n",
    "    # Get the lowest and highest values for the weights.\n",
    "    # This is used to correct the colour intensity across\n",
    "    # the images so they can be compared with each other.\n",
    "    w_min = np.min(w)\n",
    "    w_max = np.max(w)\n",
    "\n",
    "    # Number of filters used in the conv. layer.\n",
    "    num_filters = w.shape[3]\n",
    "\n",
    "    # Number of grids to plot.\n",
    "    # Rounded-up, square-root of the number of filters.\n",
    "    num_grids = math.ceil(math.sqrt(num_filters))\n",
    "    \n",
    "    # Create figure with a grid of sub-plots.\n",
    "    fig, axes = plt.subplots(num_grids, num_grids)\n",
    "\n",
    "    # Plot all the filter-weights.\n",
    "    for i, ax in enumerate(axes.flat):\n",
    "        # Only plot the valid filter-weights.\n",
    "        if i<num_filters:\n",
    "            # Get the weights for the i'th filter of the input channel.\n",
    "            # See new_conv_layer() for details on the format\n",
    "            # of this 4-dim tensor.\n",
    "            img = w[:, :, input_channel, i]\n",
    "\n",
    "            # Plot image.\n",
    "            ax.imshow(img, vmin=w_min, vmax=w_max,\n",
    "                      interpolation='nearest', cmap='seismic')\n",
    "        \n",
    "        # Remove ticks from the plot.\n",
    "        ax.set_xticks([])\n",
    "        ax.set_yticks([])\n",
    "    \n",
    "    # Ensure the plot is shown correctly with multiple plots\n",
    "    # in a single Notebook cell.\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot_conv_layer function defined"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_conv_layer(layer, image):\n",
    "    # Assume layer is a TensorFlow op that outputs a 4-dim tensor\n",
    "    # which is the output of a convolutional layer,\n",
    "    # e.g. layer_conv1 or layer_conv2.\n",
    "\n",
    "    # Create a feed-dict containing just one image.\n",
    "    # Note that we don't need to feed y_true because it is\n",
    "    # not used in this calculation.\n",
    "    feed_dict = {x: [image]}\n",
    "\n",
    "    # Calculate and retrieve the output values of the layer\n",
    "    # when inputting that image.\n",
    "    values = session.run(layer, feed_dict=feed_dict)\n",
    "\n",
    "    # Number of filters used in the conv. layer.\n",
    "    num_filters = values.shape[3]\n",
    "\n",
    "    # Number of grids to plot.\n",
    "    # Rounded-up, square-root of the number of filters.\n",
    "    num_grids = math.ceil(math.sqrt(num_filters))\n",
    "    \n",
    "    # Create figure with a grid of sub-plots.\n",
    "    fig, axes = plt.subplots(num_grids, num_grids)\n",
    "\n",
    "    # Plot the output images of all the filters.\n",
    "    for i, ax in enumerate(axes.flat):\n",
    "        # Only plot the images for valid filters.\n",
    "        if i<num_filters:\n",
    "            # Get the output image of using the i'th filter.\n",
    "            # See new_conv_layer() for details on the format\n",
    "            # of this 4-dim tensor.\n",
    "            img = values[0, :, :, i]\n",
    "\n",
    "            # Plot image.\n",
    "            ax.imshow(img, interpolation='nearest', cmap='binary')\n",
    "        \n",
    "        # Remove ticks from the plot.\n",
    "        ax.set_xticks([])\n",
    "        ax.set_yticks([])\n",
    "    \n",
    "    # Ensure the plot is shown correctly with multiple plots\n",
    "    # in a single Notebook cell.\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot_image function defined"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_image(image):\n",
    "    plt.imshow(image.reshape(img_shape),\n",
    "               interpolation='nearest',\n",
    "               cmap='binary')\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# plot_image called 1st test image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "image1 = data.test.images[0]\n",
    "plot_image(image1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# plot_image called 2nd test image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "image2 = data.test.images[13]\n",
    "plot_image(image2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# plot_conv_weights called of layer1 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_conv_weights(weights=weights_conv1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# plot_conv_layer called on 1st image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_conv_layer(layer=layer_conv1, image=image1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# plot_conv_layer called on 2nd image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_conv_layer(layer=layer_conv1, image=image2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# plot_conv_weights called of layer2 \n",
    "### Here only showed 2 input channels out of 16"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 36 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_conv_weights(weights=weights_conv2, input_channel=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 36 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_conv_weights(weights=weights_conv2, input_channel=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# plot_conv_layer called for 1st image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 36 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_conv_layer(layer=layer_conv2, image=image1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# plot_conv_layer called for 2nd image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAVMAAADuCAYAAACEaORrAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJztnXl4VdX1/tcJCRACKOTigHLvBUfEAVQqKiqKiqI41HkGK1Ur+tTZVm2rUq04VW3FR1tnxSIUpSKK1VYEASFEEVEZlAwMQhJAZLwk5/eH3z9c79om99zse2J/vp//3v3sfXP2GVbOWXvttYIwDIUQQkjzKGjpAyCEkP8foDElhBAP0JgSQogHaEwJIcQDNKaEEOIBGlNCCPEAjSkhhHiAxpQQQjxAY0oIIR4ojNI5kUiE6XRatW3atEnprVu3mnHFxcVKt27d2vRpaGhoVFdVVUltbW0Q5XhzwTXHXHCdBzxX7dq1U7qqqkrq6up+FHPE8y8iUlDg539vWVlZTRiGXbz8WCMkEokwlUo12icImj7deN1EROrr65XGa1lZWSk1NTV5v5alpaVhMplUbTgn17XMZDJKu3ZC4nPaqlUrpSsqKmKZo8h31xLnieR6f+K1xPNXUVGRle2JZEzT6bTMmTNHtc2fP1/pyspKM26fffYxv4Ns2LBB6c2bNys9cODAKIeaM+l0WmbPnq3asnngENd5wHN14IEHKj1o0KDIfycX0um0zJo1S7Xhg4LXQ8QajFzOy/+Nq8hpYERSqZTMnDlTteGD07ZtWzMODcu8efNMn2+++Ubpgw46SOn+/ftHOtZcSSaT8t5776k2vC74LImIrFixQmmXwe3atavS2223ndKHHXZYpGNtDslkUt5//33VhvPE+zNb8Fri7x511FFZ/Q4/8wkhxAM0poQQ4oFIn/kNDQ2yceNG1Xb//fcrjZ+uIiKDBw9Wes2aNaZPp06dlK6trTV/Oy7wMy+bz9kJEyYofcwxx5g+y5cvVxo/o9CPlS/CMDRzRPfNpEmTzLjf//73kf9WnNcNCcPQfOIWFRUpPWPGDDPunXfeUfrUU081fb799lul8Z5Gd0K+CIJACgv1Y4yfux06dDDjunSJ7rLGa5mrmycXgiAwPly8lq+//roZh23HHXec6dO3b1+lczk3InwzJYQQL9CYEkKIB2hMCSHEA5F8plu2bJFFixapti+//FLpZ555xoxD38pOO+1k+mCoBvqk4vS9NRWvduONN5o29B274vYWLlyoNPrVXOFI+SAIAhMKdd999yndr18/M66srExp9DWJiAlF+tnPfpbrYXoB7z0MhXKF9/zmN79R2hVahKFl+++/f66H2GxwjsuWLVMafcAiIqNHj1ba5Ve98847lXbdE3ERBEGTz+WoUaNMG4ZTXXbZZaZPt27dlMYY8Wx9w3wzJYQQD9CYEkKIB2hMCSHEAzSmhBDigcgLUF999ZVq+/rrr5sc17NnT6WzKS+dTSKGlmLMmDGmDTcduMAA4osuukjpuAK9RZrevz106FAzZty4cUq7rgkuErg2aMSFK6B927ZtSu+yyy5mHC6s4Z50EZHx48crff311yuNC3z5wrWYWFdXp3SPHj3MuOHDhyvtClQ/+OCDPRyhP3CeS5YsUbpPnz5mzMSJE5Wurq42fZ5++mmlL730UqW5AEUIITFCY0oIIR6gMSWEEA9E8pm2atXK+AazCcrGXI/l5eWmDwa0f/rpp0q7EvTmg0wmY4Ke0a/mSpYwYMCAJn8b/YeY19WVNDsuLrzwQqVdPmBM3nLllVeaPuhnw00ecYM+3KqqKqWHDBlixhx55JFKDxs2zPRZvHix0pgAPa4kIBs2bDAbCND37ro38Z7Ge15EZO3atY3qLVu2RDnUZrF161ZZunSpasMNQ66NE9tvv73SDz74oOmD9gh9ptnCN1NCCPEAjSkhhHiAxpQQQjxAY0oIIR6ItABVXFws++23n2o777zzmhx39dVXK+1atELHMGbsx6za+SIMQ+PAX79+vdIY5CsiUlNTo/QHH3xg+uDCFZ67Bx54INKx5kpDQ4NZ0Ntjjz2UnjJlihl3yCGHKI1ZhUTswgwuWsRJGIYmSH/nnXdW2pVFCIP0XZVm//rXvyod54aL79PQ0GCyjeFiLi66idgAeFflz7lz5yqN90jc4GJiNtU4nnvuOaVx05HId4UXfcA3U0II8QCNKSGEeIDGlBBCPBDJZ1pYWCidO3dWbej/dPkt9t13X6VdVQTR53j44Ycr3b59+yiHmjOFhYWSSCRU2zfffKO0K1gZfVClpaWmz6OPPqp0S1XuDMPQ+AEx6Bz9xCIiTz75pNKuygAY7O+q0hon6MtEX7HLFz916lSlR4wYYfr06tVL6TgrdX6fdu3amU0xK1euVNqVaf/ZZ59VGoPbRWzFAfSZYxKZfFJUVGT83QcccIDSmFVfxCa26d27t+mDSWpyTarEN1NCCPEAjSkhhHiAxpQQQjxAY0oIIR4IojhbgyBYLSIV+TucRkmFYWjTgXuGc4yFn8I8OUeP/C/MM5IxJYQQ4oaf+YQQ4gEaU0II8QCNKSGEeIDGlBBCPBBpP1hpaWmIqbqw3rprQQu3nbVt29b0yWQySuP2vKqqKqmtrc37nr1EIhFibSbEtQ0Ut/Bh7XKR77b+fR88l3HO0ZVy7fvgdRXJbismXltXn7lz59bEsQqcSCRCTK+G22hxq7CI3YLapk0b0wfv6ZKSEqUrKyulpqamRe5XfAZdKQTx+cqm/hj+bkVFRSxzFHHfs/gcurb04jbvbMh1npGMaTKZlHfffVe1Yf5K1771Ll30c7PXXnuZPsuXL1caL+6xxx4b5VBzJp1Oy5w5cxrt8+2335o2zEX6wgsvmD5YbA736sc1x2QyKdOnT1dtaEA+//xzM27+/PlK415pEbtnHfMciIgUFxfHEuKSSqVk5syZqq2iQv9p1751NLDdu3c3fXBemKOif//+kY41V1z3KxrPyspKMw7/GTT1AiFi/8Fi/ox8kkwmzd77bP65Y27abMAXu379+mU1jp/5hBDiARpTQgjxQKTPfFdJD3yN3nPPPc24iRMnKu36zO/atavSWGO+pVKciYiUlZUp7Sp18dFHHynt8rPhHD788EOlXSnt8kEQBMaXhLXX77jjDjPus88+U/rrr782fYYPH660q7RJXLhKepx//vlKo+tFRGTXXXdV+swzzzR9MLUbpixsyc0wo0aNUho/W0VETjnlFKWxvIeIyO9+97tGfyfOOTY0NBgX4saNG5W+/PLLzbh///vfSmOKSBGbWvLUU09VOlvbwzdTQgjxAI0pIYR4gMaUEEI8EMlnGgSBCanAEKaHH37YjPv1r3+t9FlnnWX6vPjii0pjvGJcPtNt27bJqlWrVNsjjzyitMsfumzZMqXRBywiMmPGDKXR/5xLTFwu1NfXm/CupUuXKj148GAz7tJLL1V60qRJzt/+PuhnjZM1a9bIuHHjVNvs2bOVxhIlIu44aAT9ktdee63SLenjHz9+vNJ4bCK2dNAf/vAH0wd9phhL7fLF5ov6+noTu11eXq60q4T85MmTlXaVvUb/d67wzZQQQjxAY0oIIR6gMSWEEA/QmBJCiAciLUDV19eb4GTc9+uqt37FFVco7aop/9JLLyl92mmnKR1XgPD69evNHmAM9MX93iI2aL+6utr0wX3rX331ldJxLUCFYWj2NWPwumtjBTrqBw4caPosWLBAaVyQipP169ebXBJYH37MmDFmXOfOnZXG6yQiMm3aNKV/+9vfKl1QEM97SiaTMYufmADk4osvNuPwHnedB2TJkiVKu/Jw5IswDM2CV3FxsdKujSZIt27dmuyDNsyV2MgF30wJIcQDNKaEEOIBGlNCCPFAJJ/phg0bTOA5+vlOPvlkMw79neivExF54403lMZku3H5oMIwNL4gzGe5bt06M+6mm25SGn1zIjahwm677aa0azNAvsCgcjy/zz//vBmDPirXxoTdd99d6S+//DLXQ2w2hYWFJu/o22+/rTRuVhCxwepDhw41ffBcYA7RuHz8QRCYY9lll12aHIfXJZt7D+/7uP3haGvwHKPvWMQmD3IlYkIwbyt9poQQEiM0poQQ4gEaU0II8QCNKSGEeCBypn0M3H7zzTeVXr16tRl3ySWXKN2xY0fTB3+3pZzdHTp0MMHo6MR2FenKJgv9E088oTRmboprjkVFRWbxCLUriBsDvTFrvYi9tq5idHHRpUsXueqqq1QbbkZwZdrv06eP0rhQKGIzMWGlAswCny8KCwvNJoP99ttPacw2L2IX0N577z3TBytM4LWNa1FY5LsFsh49eqg2XEz64osvzLi9995baddi4ujRo5XGBadsFxP5ZkoIIR6gMSWEEA/QmBJCiAci+Uw7duwogwYNUm2Y6OTVV1814zBRxIgRI0yfM844Qx8YZPSPK3N5UVGR7LjjjpHHuTJ4I+hPxoBynHNLctdddzXZx+XjxYDnlpxT27ZtswrSRlw+UuRf//qX0uiDbMkEL/fee6/Sy5cvN33Qz+qqLoDnAX3JrrWDfNKU79KVnCeXzRN4LoqKirIaxzdTQgjxAI0pIYR4gMaUEEI8QGNKCCEeCKI4aIMgWC0iFfk7nEZJhWHYJd9/hHOMhZ/CPDlHj/wvzDOSMSWEEOKGn/mEEOIBGlNCCPEAjSkhhHiAxpQQQjwQaa9fIpEIk8lko318peXChbGKigqpqanJ+57SRCIRplIp1ZbNVlasG+WqKY5bK3ELYpxzTKfTqg1TxmG9HZHsttVhWkFXusWysrKaOFaBXdfym2++UdpVNwiv0w477GD64PnBGkrV1dVSV1fXIvcrppBzXUsEa1i52nCbZVVVldTW1sayzzub59JVW27NmjVKd+jQwfRp166d0mjDsn0uIxnTZDIp06ZNa7QPHli24F5mzG962GGH5fS7UUmlUjJz5kzVlk2egCVLlii9ePFi0wf3/Pfq1Uvpfv36RTrWXEmn0zJnzhzVNnfuXKVd+64x56lr/zkWXDzuuONMnyAIYglxSaVS8sEHH6i2KVOmKH3rrbeacZgz4ZprrjF9sGAiFhIcPHhwpGPNlVQqZc45/mN0FXdEMMeGyHdG5Pvg3vfjjz8+28NsNq5rif/cFyxYYMaNHTtW6QEDBpg+Bx10kNL4TyNb28PPfEII8QCNKSGEeCDSZ34QBNK6dWvVhmnlXJ/5N954o9JHHnmk6TNkyBClWyqFWRAETX7Wu45/5513Vvr+++83ffB30ZcVV5rBbdu2SW1trWqrrq5W+sADDzTjMM2gqz47lo7o2bNnrofZbDKZjKxatUq1TZgwwfRBzjnnHKVdKfmwrAvOG8vuxAl+1rs+f59//nmlhw0bZvqg62f9+vVKYzmffBIEgfFLl5eXK33ppZeacVjCBf2uIk2nEsz2ueSbKSGEeIDGlBBCPEBjSgghHojkM926daspQYK+N/Qdilj/YV1dnemDPlP0zcblT3T9LQx7wpLHItYH5Sr1jOFIV1xxRa6H2CwymYysWLFCtWE86Omnn27GYcjYgw8+aPq88sorSpeWluZ6mM2moaHBxB4ee+yxSj/11FNN/o6r7AfGImLJc4xnzRcuHz9y5plnmjYsTe6KpUUf6ccff6y0K64zTp588kmlP/roI9MH/ap4f4rYsLCjjz46p+PhmykhhHiAxpQQQjxAY0oIIR6gMSWEEA9EXoDKJnAbmTp1qtLZ1NvGhS3cqx8nH374odIHH3yw6XPhhRcq/cQTT5g+b731ltIttQDl2nyB+49dTnhc6OjSxeYqwSD5tWvX5nqYzaZVq1ZmYe2UU05RGhOziNh5uRZajjrqKKWnT5+udJz3Ky6G4YLKrrvuasbg/vNDDz3U9LnjjjuUxvseE6rkk/r6erMRYvLkyUpjfgQX+CyLiOyxxx5KcwGKEEJaEBpTQgjxAI0pIYR4IJLPNJPJmGB09IfecsstZtwRRxyhtKsiKvoy0NfVkj5TTI4wcuTIJsfcc889pg3zl7YUbdu2Nf4lvCYnnniiGddUALyIDf5Gf1ScFBUVyU477dRon9dff920bd68WWmXbxADxNFvGecmEwSP15UnFxOTu4LZsQ/mM0W/az6pr683iZ733ntvpS+66CIzDn3448aNM32uv/56pTFhuCsZjgu+mRJCiAdoTAkhxAM0poQQ4gEaU0II8UCkBaiOHTvKoEGDVBsGol9++eVmHGaSclUwxSJgDz30kNJxOrsRXKxxVXLEBQmXM/zOO+/0e2A5Ul9fb4LVcU5XX321GdetWzelFy1aZPpgULwrY3+cYMUGrG6ARQ5FRB5++GGlXfcrzv3www9XGrMy5YswDM0CCRZzHDhwoBmHC3P/+Mc/TB8M0seNHSUlJZGOtTkUFBSYKh5YwQOvgYjN5uXKoDVixAils6nU6zzGrHoRQghpFBpTQgjxAI0pIYR4IJLPtLCw0FQ+vO2225SePXu2GZdIJJTGqocituInVj6MM6kC0qlTJ6UxqFfEBjj/WPyjLlx+NgyIdiXHmDVrltIdOnQwffbdd1+lO3funOtheqEpf1ffvn2bbHMFbeP9ihsYXnvttWwPsVkEQSBFRUWqDdcXsIKwiK0EgJUuRGxiG9y8gtVC80mrVq3Mc7j//vsrjedBRCSdTivdu3dv0wdtDfqCXT5zF3wzJYQQD9CYEkKIB2hMCSHEAzSmhBDigcCVwekHOwfBahGpyN/hNEoqDEOb2t0znGMs/BTmyTl65H9hnpGMKSGEEDf8zCeEEA/QmBJCiAdoTAkhxAM0poQQ4gEaU0II8UCkvfmJRCLE/bkI7vkVscXwcB+7iJhchcjSpUulpqYm71XKEolEiPt5MSema68u5gPdsmWL6YNtuNe4qqpKamtr8z7H0tLSMJlMqjaM6nDNEa9j69atm/xbrpwK5eXlNXGE1Lju12wK3WFBvWxy6eK5ietauu5XBOcjYnN2ugpWdumiLxGeu7ieSRH3tcScCTgnEXtf47MsItK+fXulMZ9DVVWV1NXVNTnPSMY0lUrJ9OnT9Q9AMgRMxioiUlNTo/QBBxxg+vTp00dpnPQhhxwS5VBzJp1Om0qp69atU9qV4KOqqkppTNArYhMKn3322Uq7qn3mg2QyKf/5z39UG55v1z83vI6YLNqF6wYvKSmJJV4wlUqZ5Cz4oLiMKyZ27tmzZ5N/q66uTuljjjkm28NsFul0WubMmdNoH1ei6rKyMqUx0Y2IyJVXXqk0PuuYPDqfpFIpmTFjhmpbsWKF0h9//LEZh/9I1q9fb/r0799faTSugwcPzuoY+ZlPCCEeoDElhBAPRPrMD8PQ+MAee+wxpe+77z4z7uabb1YaP+ldZFt3xTeu+khLly5VGmtaiYhMnDhRaVcNpXnz5imNn1quT+J8gT5R/Ex97rnnzJjRo0cr7fI/XXDBBUq3ZF7XIAjMp+mmTZuUfvnll804vD//9re/mT74HOCnYJz5d9EviK4LlxsA6yVVV1ebPpWVlUr36NEj10NsNq4cvKWlpUpj/TEXjz/+uGnba6+9lMZzke0uUb6ZEkKIB2hMCSHEAzSmhBDigUg+0/r6ehNHiv5QV0zbySefrPTkyZNNnxNPPDHKoeSNTCYjy5cvV20VFTqSZ4cddjDjMAQHfckidt7oQ43Lz5bJZExYCcbADhgwwIw766yzlHb5kr7++uvmH2AeKS8vV9pV6wp9phgPLCLyi1/8QumFCxcq7YozzhfoI0VfPPq6RUQOPfRQpbFOm4jI1KlTlW5Jn6nL/401qD755BMzDp9dDPcSERkzZozSkyZNUhr/7g/BN1NCCPEAjSkhhHiAxpQQQjxAY0oIIR6ItAC1efNm+eKLL/QPgHP2gQceMOMw+Pepp54yfX4sC1CuRTbcZ3/88cebcbifFxckRKwDH4P00aGeLzKZjCxbtky1rV69Wunu3bs3+TuuHAW4kLF27docjjB/dOzYUekpU6aYPieddJLSN9xwg+mzYMECpTGfw4YNG3I9xGYzbtw4pXFPu4jI7rvvrrRrUfjdd99VeujQoc0/uBwJgsA8Hzgv16JvSUmJ0oMGDTJ9cPMJPsuupD8u+GZKCCEeoDElhBAP0JgSQogHIvlMt23bZnxrGMh93XXXmXFjx45Veu7cuVH+bKwUFBSY5NXoX3Tl+sRkCa4EH7W1tUrvu+++SruSZueDhoYGs7ni888/Vxrz1orY5BiufJa77LKL0j+2UuKrVq1SGhOfiIj8/Oc/V3r+/PmmD54v9LthsvA4Oeigg5TGa+Ligw8+MG2Y8KclCcPQ3LP4HLoSukybNk3pjz76yPSZMGGChyPkmykhhHiBxpQQQjxAY0oIIR6gMSWEEA9EWoBq1aqVbLfddqoNA9ExG5GILdZ18cUXR/mzsdK6dWvBKogYxO9aXMLieJ9++qnpk232mXzTvn17kzUIA/BHjhxpxj366KNK77nnnqbP7bffrvS5556b62HmBayS4CrUiFnD+vXrZ/pghv7hw4cr7SosmQ/CMDQZqs4888xGtYuuXbuatmHDhjXv4Dzi2kyDFVWvuuoqMw77jB8/3vTZfvvtlcbMZ5jh/4fgmykhhHiAxpQQQjxAY0oIIR6I5MQrLi6W/fbbT7Whf8mV7RqrBmJVQRctFexdUFAgbdu2VW2Y+AIzkIvYYGAMyBcRWblypdKYhCGuObuylu+9995Kv/XWW17+VpxVOl3gOe3Zs6fSuAlFxPpVXX423MBw3nnnKf3II49EOs5cCcPQbBBAH6rLV48B764M9D8mwjA01xKvHW6KEbEJlNavX2/6DBkyRGncyMHqpIQQEiM0poQQ4gEaU0II8QCNKSGEeCCIsugRBMFqEalosmN+SIVh2CXff4RzjIWfwjw5R4/8L8wzkjElhBDihp/5hBDiARpTQgjxAI0pIYR4gMaUEEI8EGk7aSKRCNPpdKN9XDV1cAuXK6VVp06dlMZ6SBUVFVJTUxNkeag545ojpvFyHT9um8QtfSJ2WxqmM6yqqpLa2tpY5phMJlUb1jByXUc8D7jtVsRuU3RtJy0vL6+JYxU4kUiEmE4RCYKmT/fatWtNW+vWrZXGc1FRURHbtcT7FVPVYe0kETE16LFWvMh3KTcbY+nSpbE8kyLua4nXDu9PEVuLy7WdFM8FpqOsrKzM6lpGMqbpdFpmz57daJ958+aZtvfee09pLGomInLGGWcojXuocS90vkin06YwV11dndLV1dVmHBqfJUuWmD5osAYPHqz0wIEDIx1rriSTSVNoDHPOuvKx4nnA/fwiIr1791Z648aNpk9JSUksIS6pVMoUiiso0B9jRUVFTf7Oq6++6vzt77P77rsrfdRRR2V7mM3C9UxOmTJF6YULF5px3bt3V9r1fOELDt6/rlyw+SKVSsmsWbNUG17LmpoaM66qqkrp//73v6bPbrvtpvQxxxyjdLbXkp/5hBDiARpTQgjxQOQ6GugD+8tf/qK065MIfRnokxAR+dWvftXo34lrc0EYhsYnOm7cOKW7detmxmXzefvYY48pjXNct25dpGPNlTAMzTXBVIou/xP6Dn/5y1+aPljaBFM2xokr1SD6Ae+++24zDudwySWXmD7Z1KKPgy1btshXX32l2lC7rsGAAQOa/G30L6L/0XWP5AvXtURuu+020/b3v/9daZcPH9cPXnvtNaVd6x8u+GZKCCEeoDElhBAP0JgSQogHIvlMM5mMKYN68803K92liw0fxPAEV2gRlppF/0w28YA+2Lp1qzleDK+55ZZbzDg8D48//rjpM2rUKKUnTpyotCueMV+g72jDhg1KY/lbERt64gqTGzt2rNJxhs8gYRiaeb7++utK33rrrWYczv1Pf/qT6YM+cdRxlWtxlUDGkjn9+/c34zA21VVm58UXX1Qa708MlYqbCRMmKI2lg0RE+vbtqzSW5BYRKSsrU/qLL75Qmj5TQgiJERpTQgjxAI0pIYR4gMaUEEI8EGkBatu2bWYRAp2zN910U5O/gwH6InYxBhNJxLUAtWnTJvnkk09UW2VlpdKuPem4WQF/Q8TW537//feVjisI2hUAvWjRIqVdCygY6O2qDe9KAtNSZDIZsxkBFxNdwetPP/200s8++6zpg+Nwj39cm0xatWplNsHgBhIXFRU6PcJll11m+mAiHlyowUXiuMHn5eKLLzZ9RowYofTSpUtNH5xnrraHb6aEEOIBGlNCCPEAjSkhhHggks/UFQTdp08fpV3+0JdffllpV3DtjwVXohMM4p4/f74Zh0khFi9ebPocfPDBSn/22WdKZ5Nb0wcFBQUm+fbKlSuVfuaZZ8y4E044Qeljjz3W9MHfWb16dY5H2Xw2b95szvGuu+6q9LBhw8y48vJypT/++GPTp6SkRGl8DuIK2m/Tpo3Jx4mgr1PE+u9x04mIyIIFC5SePHmy0nEl5vkhMAcr5tsVsZtIXEmw99hjD6XRF4s+1B+Cb6aEEOIBGlNCCPEAjSkhhHiAxpQQQjwQaQGquLjYBKyfffbZSmP2IRG7YBOXcz4XiouLpVevXqrtgAMOUNqVYef0009vVIuIfPvtt0pjQb2mihX6IgxDk/Fn6NChSr/xxhtm3PPPP6+0q1LtsmXLlMZzGSdBEJiqoXjv4eKDiMgLL7yg9Jtvvmn6XHPNNUpjNrW4NmBkMhlzzjGIH+9fEbtJxsXo0aOVxoxwTVUvzTeYac61gIvX0lXM8/bbb1caM+9jxd0fgm+mhBDiARpTQgjxAI0pIYR4IHJ1UvSTnHvuuUrX1taaMSNHjmxU/5ho27at9OzZU7Wdf/75TY775z//2WSfmTNnKr3XXnsp7UocEhc77bST0i+99JLpg8Hrs2bNMn3QB9mSfjWX/xuDtl2JL0pLS5UeM2aM6bNmzRqlW3IdAM8xVrLAZC8i9l50Bbyjj//qq69WGgPiWxpXlY9BgwYp7fLzd+/eXWn0d2ebtIZvpoQQ4gEaU0II8QCNKSGEeIDGlBBCPBBEyQgeBMFqEalosmN+SIVhaD3MnuEcY+GnME/O0SP/C/OMZEwJIYS44Wc+IYR4gMaUEEJjKg6uAAAGSklEQVQ8QGNKCCEeoDElhBAPRNpOmkgkwlQq1WifbGpMb9q0ybThQhimTqusrJSamprsClg3g0QiEeKWM0xXh9vsXG2dO3c2fbDuEs65oqKixeaIuGqiY3pFV22cNm3aKF1YaG+xsrKymjhWgROJRIjp1AoK/Lw/YM0vvF+rq6ultrY2lmuJc8TtkF9++aUZh9cSa2OJ2O2ZeL9WVlbGMkcRt+3ZuHGj0q57Fo/Zdc9iG6byy/a5jGRMU6mUzJgxQ7XhweLD5OKTTz4xbWiw9txzT6X79++f7WE2i3Q6bfKK4oMzdepUMw73Op9zzjmmD+ZBxZu+X79+kY41V9LptNlXj/u7KypsFArO0WWQcW++659KEASxhLgkk0lzrTA3Za7G9Z133lEar+3xxx+f0+9GJZlMyvTp01Ub5sc466yzzDi8ltddd53pM3z4cKXxfj366KMjHWtzSKVS5pjnzp2rtOueRbvSrVs30wf/GWGeikMPPTSrY+RnPiGEeIDGlBBCPBDpMz8IAvM5iNqVug3bjjjiCNOnU6dOSmOt+rjKQLiYM2eO0pMmTTJ9MIXZDTfcYPpcdtllSuPnVzb+Zh+4ypagDw3TrYmI9O3bV2mXK+PHBn7GZ/NZf++99yrtqilfWVmpNH5au/zq+QKfjWnTpintSk33xz/+UWksRyRi1zbw/oxzw4+rPAumT3S5GE877bTIfwvnzRR8hBASIzSmhBDiARpTQgjxQOSyJeg3Qd/bBRdcYMZgDB6WDBYR+fTTT5VGnxP+nXwRhqGJVyspKVH6+uuvN+N23HFHpTt27Gj6YJkSV8hKHDQ0NJgYvYceekjpd99914zLpjzwjw0sJ7Jo0SKlXaWeb7nlFqVdflYMhbrvvvuUXr16daTjzJWGhgZzv+6zzz5Ku2LD77jjDqWXLFli+qCvFUu1xOXjF/kuhhT91FjSGkuni9iSJK4yNQsXLlQa74lsw+f4ZkoIIR6gMSWEEA/QmBJCiAdoTAkhxAORF6DQGTt+/HilXft1cTHDVaN71apVSqPj2JUwIx8EQWCCfw855BClsS65iHWGuxZwysrKPBxh83EtsmG+BAzid3HTTTeZNkyYcc011+RwhH7YvHmzWVxYvHix0j169DDj8Hp//vnnps+NN96o9LXXXqu0K+lGPmhoaDDXat26dUrjphMRmwcCnz8Ru1iDe9Rxw04+KSgoMHkVjjzySKVfffVVM66mpkZp1+YEXCDPFb6ZEkKIB2hMCSHEAzSmhBDigciOSAyCxnyVI0eObPI3Ro0aZdp23nlnpYcMGaJ0XD5TF2+88YbSL7zwgumDyVww0F/EBlNXVVUpHZefLQgC4yfCxDKujRXIK6+8YtqGDRvWvIPzyNatW41/+89//rPSZ599thmHuUjR7yZic9pioPfKlSsjHWuuFBQUmHsNE4J07drVjEO/8Nq1a00fbMONM3EmOmnTpo05x5lMRulevXqZcbiZAv2sIjZ/KeZFzfa55JspIYR4gMaUEEI8QGNKCCEeoDElhBAPRFrV2bZtmwm4x4UjV5G1J598Uum33nrL9MFMTFghMM4MNQg668eOHWv6jBs3TumTTjrJ9MHMWLhw4KtyZlMUFBSYjQmYWb9Pnz5N/s6tt95q2rCaQEvSrl076d27t2pbsWKF0m+//bYZh0HuuEDhAs9FXAtxmzZtknnz5qk2XHDC+1fEFhbE4nQiduHthBNOUDrOBSjX33v55ZeVbt++vRlzxRVXNPm7WCQUKxdwAYoQQmKExpQQQjxAY0oIIR6I5DN1JRtAP4UrwHnLli1K33XXXabPySefHOVQYqW0tFTpZ555pskx77zzjmkrLi5uVMflM3WRjY8U+TH5R10UFRUZ/+Hdd9+tNAZoi9gNGK4+mCAFN7P4Sp7RFIWFhSYjPiYo2X///c043HDhCuy/5557lI6z4iriSs6DFY3nz59vxmHiHZd9wkrC5557rtLZJnThmykhhHiAxpQQQjxAY0oIIR6gMSWEEA8EUQJvgyBYLSLWGx8PqTAMuzTdrXlwjrHwU5gn5+iR/4V5RjKmhBBC3PAznxBCPEBjSgghHqAxJYQQD9CYEkKIB2hMCSHEAzSmhBDiARpTQgjxAI0pIYR4gMaUEEI88P8AWBG4j/rxrxAAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 36 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_conv_layer(layer=layer_conv2, image=image2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This has been commented out in case you want to modify and experiment\n",
    "# with the Notebook without having to restart it.\n",
    "# session.close()"
   ]
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}