Mnist_cnn_tensorflow_DL_assignment2.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": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!sudo pip2 install -U scikit-learn scipy matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "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": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sklearn, scipy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.1.0\n"
     ]
    }
   ],
   "source": [
    "print(scipy.__version__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "#from sklearn.metrics import confusion_matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tensorflow version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.8.0'"
      ]
     },
     "execution_count": 48,
     "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": 49,
   "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": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting data/MNIST/train-images-idx3-ubyte.gz\n",
      "Extracting data/MNIST/train-labels-idx1-ubyte.gz\n",
      "Extracting data/MNIST/t10k-images-idx3-ubyte.gz\n",
      "Extracting data/MNIST/t10k-labels-idx1-ubyte.gz\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": 51,
   "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": 53,
   "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": 54,
   "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": 55,
   "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": 58,
   "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": 59,
   "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": 60,
   "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": 61,
   "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": 62,
   "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": 63,
   "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": 64,
   "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": 65,
   "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": 66,
   "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": 68,
   "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": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'Relu:0' shape=(?, 14, 14, 16) dtype=float32>"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "layer_conv1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CL2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "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": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'Relu_1:0' shape=(?, 7, 7, 36) dtype=float32>"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "layer_conv2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Flatten layers : 4d----->2d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "layer_flat, num_features = flatten_layer(layer_conv2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'Reshape_1:0' shape=(?, 1764) dtype=float32>"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "layer_flat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num_features"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# FC1\n",
    "and Relu = true"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "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": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'Relu_2:0' shape=(?, 128) dtype=float32>"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "layer_fc1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# FC2\n",
    "and Relu = false"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "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": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'add_3:0' shape=(?, 10) dtype=float32>"
      ]
     },
     "execution_count": 78,
     "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": 79,
   "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": 80,
   "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": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-81-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": 82,
   "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": 83,
   "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": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "correct_prediction = tf.equal(y_pred_cls, y_true_cls)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "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": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "session = tf.Session()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Initialise all variable of graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "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": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_batch_size = 64"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "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": 90,
   "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": 91,
   "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": 92,
   "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": 93,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on Test-Set: 10.1% (1010 / 10000)\n"
     ]
    }
   ],
   "source": [
    "print_test_accuracy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1st optimization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimization Iteration:      1, Training Accuracy:  15.6%\n",
      "Time usage: 0:00:01\n"
     ]
    }
   ],
   "source": [
    "optimize(num_iterations=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on Test-Set: 10.8% (1079 / 10000)\n"
     ]
    }
   ],
   "source": [
    "print_test_accuracy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Next 99 optimiztion, so total=100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time usage: 0:00:14\n"
     ]
    }
   ],
   "source": [
    "optimize(num_iterations=99) # We already performed 1 iteration above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on Test-Set: 67.1% (6713 / 10000)\n",
      "Mis-classified image on test-set:\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAU0AAAD5CAYAAACj3GcTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3Xm8XePd9/HPLw23CEEGRCQ5FEnQxxRJEAlKUNWa4xaqKqaoNobcfWp43TFEVSsJHhJKza0hEVNLTAkqQXIIjYSiJYJE0goSrfF6/tjrt9c6497r7Onsc77v1yuvs/baa7hOrrOv/buGdV0WQkBERPLTodIJEBGpJio0RURSUKEpIpKCCk0RkRRUaIqIpKBCU0QkBRWaIiIpqNAUEUlBhaaISAodCzm5e/fuoaampkhJqQ61tbUrQwg9Kp2OclEet33K43QKKjRramqYP39+IZeoOmb2TqXTUE7K47ZPeZyOquciIimo0BQRSUGFpohICio0RURSUKEpIpJCQb3nIi31+eefA7D77rsD8NJLLwHwgx/8AID77ruvMgkTyUGRpohICm0u0vzoo48AWLJkSZPH9O3bF4BJkyYBsP322wOwzTbbALDDDjuUMontmkeYZ555JgALFiwAwMwA2GWXXSqTMCm52tpaAGbMmAHA9OnTs++9/vrrAPjyO/X/HgYMGJA99pe//GWDfeWkSFNEJIWqjzQfeughAB588EEAZs+eDcAbb7zR5Dn9+vUD4O233wbi6Md98803RU6luKuuugqA6667DoDvfve7AFx00UUADBkypDIJk4Jcf/312e3XXnsNgGeeeabOMR5pehSZXNTR951yyikAHHrooQCMGDGiRCluOUWaIiIpVEWk+dZbbwFwzTXXAHW/1f79738Ddb+1cvH2Eym/Dz74oM7rfffdF1CEWe08QoQ4alx33XWBuO1x7NixAPTv3x+A7t27Z8857LDDypLOYlCkKSKSQlVEmkuXLgVg8uTJBV3Hv+G8t1zKb/Xq1QCsvfbaQBxpSnVLRoo+xtYjzHnz5lUkTaWiSFNEJIWKR5orV67MbnskOXToUAAOOOAAII5KNthgAwDWW2+97Dkeuey///5AHEUOHjwYgJ122il7bKdOnQDo3LlzkX8Lac7777+f3b7hhhuA+EmgnXfeuSJpkuKaOnVqdvvFF18E4J13MlNW+pjpPn36lD9hJaBIU0QkBRWaIiIpVKx6vmbNGgD222+/7L6XX34ZaDhZw2677QbEkzok1zPx0H/zzTcHoEMHfQ+0NpdccklJrjt37lwg7ihM8kdh/dFYKa0ePeLldk466SQAzj//fCBuglP1XESkHSp7pPnFF18AcMwxxwBxdAlw7rnnAk0PQ2lsxby28u3Vlv3pT39qsG/06NGpr3PaaafVuZ5PzvLZZ581OLZLly4AnHXWWQBccMEFqe8nLeOPIfsDJ4sWLarzujE+PMkHxLdmijRFRFIoW6TpQ4MuvfRSIJ5gI9kWMm7cOKA6vm0kN48Av/zyy+w+b3v+8Y9/3Og5X331FRAPWwE45JBDAFi2bBkQRyz+t5Osmfh53tbtE4P86Ec/AuJpAaW4VqxYkd2+8cYbgfhxyuOPPx5oOO1bMvL0CTpGjRoFtO7HKhVpioikULZI03vEL7vsMiD+xk9OH+WD16Vt8IHsy5cvz+5LTuyQ5APgfTKWiy++uMExvXr1AuC4444DYMyYMUAcvSb5shne/ukThSjSLC6PMIcNG5bd54Pa608g7A+tuN/97nfZba8h3HvvvUAcjfojmMkJhytdE1WkKSKSQtkizTlz5tR57Y83NhYlSNvg42qTtt5660aP9bGc/jieRxoQT1Q8ceJEIL8JV7baaqt0iZUW8QmHk9MtHn744QDcc889zZ578sknZ7d9LOftt98OxDXTXXfdFYBtt902e6xfV8tdiIhUgbJFmtOmTavz+uGHHwbgwgsvzO7zdqjkJBtSvZITdTTlb3/7GwB33nlnnf3JKOTKK68E4olb0vB2NU0MUhp77rknUPgSMT4hsU9U7D+9jTvZ/jl8+HAgLkPKvRifIk0RkRRUaIqIpFC26rkPTfAGfl8BMlk9986AU089FYjnxHz33XeBuHF/u+22a3D9V199FYgn91AHU+V98sknQN1BzPUfpbv66qsBWLVqFRAPbp4yZUpB9/aHKTp2zPyJt6RqL5XnzTTJwe4+vOmggw4C4Nprr21wTCkp0hQRSaFskeY555wDwBVXXNHkMV9//TUQrzrpP9PYeOONAdhrr72Ahh0MUj5eq0gOH0puQ9xZ5Pvz6Txqjp/vA+t9+ItUt+TKlT4s7eyzzwbimqk/OuudSKWiSFNEJIWyRZr++ORRRx0FxG1XyckcfDJZjzhb4sMPPwTiAbDJgdA+Kaq0Hj6kxB9+8J8+sQvEj15269Yt5/W8XcsftfNoRNoOb9P0IUf+2vNakaaISCtStkjzW9/6FhA/FuWDmpOeeOIJII4+x48fD8ALL7yQ+n7eS1tbW5v6XCmMtyv6JBnN8ejRJ2zwBxySkwbPnDkTgIceegiA9ddfv87r5HIa/uim1yqGDBnSwt9CWjtv5/QB9v5IZ6kp0hQRSaHi654n+cQMbsGCBUAcaa611loAnHDCCdljfBGnSZMmAfCHP/yh5OmU5m222WZAvKiZTxUG8OSTTwJxO6W3Pfbs2ROIpwLzKBLiiRl8LKe3XXkPeXKqMI8wtbxF27d48WIgntwjOalHKSnSFBFJQYWmiEgKrap6Xt+IESOAeJVK7yDyYSoAb7zxBgCzZ89u9Bo+27eUn68V44+7QTyTuuetrxbp1XP3/PPPZ7d9+JHv806+fv361Xkf4rVmpLy8eQzitZuOPfbYktzLm3vOO+88ANasWQPAU089VZL71adIU0QkhVYdaXoHwMiRIwG46667Ghwza9asOq99ggaPbn7961+XMonSDJ805ZFHHsnu23vvvQGYO3cuAEceeWSdc+qvWNgY7wi8/PLLgfwGvUtp+Jo+yYcIvJOvJZGmT+wzY8aMOvuTr314mke0t912GwD9+/dPfb+WUKQpIpJCq440O3XqBMDkyZMB+PTTT4G6A9Z9pcOamhogXt/aB8ZL5SXbK5977jkgrjW8+eabQDwz94knnghAhw4Nv8/9vXJFFJK/5JR/vtb89OnTgfjRVj/GB6Enawg+bKiptdGT6wH5I9je15GczKMcFGmKiKRg9SeFTWPgwIFh/vz5RUxOfrwNA+K2MY8sfWq4UjGz2hDCwJLepBWpVB5XkvI4PX/UFeKo0Xl7pE+m44PQkxGiR5K+r/4oiGTtohjrnheSx4o0RURSqMpIs5IUhbR9yuO2T5GmiEiZqNAUEUlBhaaISAoqNEVEUlChKSKSggpNEZEUVGiKiKSgQlNEJIWCBreb2QrgnZwHti19Qwg9Kp2IclEet33K43QKKjRFRNobVc9FRFJQoSkikkKzhaaZdTOzBdG/ZWb2XuL12qVKlJktNbO/Rvd5Po/jR5vZiuj4xWb2kwLvf7uZHZLjGDOza83sTTN7xcx2LOSelVLBPO5qZvea2WtRng3KcbzyuIX0OW72mMOivF1gZvPMbPdc12125vYQwj+BHaOLjwdWhxB+W++mRqZt9JtcN0tpzxDCqhTH3xFCGGtmmwILzeyBEMLKRDo7hhC+KmL6DgZ6hxC2MrOhwDXAHkW8fllUMI+vBh4IIRwWfXA75XGO8rgF9Dlu1qPAjBBCMLOdgVuB7Zs7oUXVczPbyswWmdkdwKtAbzNblXj/aDO7IdreJIoo5pvZC2Y2pCX3zFcIYRnwNtDHzC4xs1vN7FngZjPraGYTo3S8YmajozR2iCKK18zsMSCf+fN/SOY/mBDCX4BNzazN9LiWMo/NrCswOIRwM0AI4YsQwsf5pk15XBz6HEMIYXWIe8M7Azl7xgtp0+wPTAohbAu818xxVwGXR3PXHQV4Jgw2s6lNnBOAJ82s1sxOTJMoM9sK6Av8PZHO74YQjgVOBj4MIQwCdgVON7M+wBHAFsC2wAnA7onrTTCz7zVyq17Au4nXS6N9bUmp8nhLYEX0QXjJzK43s7yn41YeF1V7/xxjZkeY2evAfcDoXGkrZGG1t0II+cxcui/Qz+IlWTcys04hhOeBpto5hoQQ3otC9MfMbHEIYU6O+4wys72Az4HRIYRV0T3vDyH8JzpmBDDAzI6OXm8AbA0MA/4YVU2Wmtlsv2gI4bw8fse2qlR53BEYCJwB1JKpqo8DLsxxH+Vx8bX7z3EIYRowzcz2Bi6Ort+kQgrNNYntb4DkQtXrJLYNGBRC+CLfC4cQ3ot+LjOz+4FBQK7/7DtCCGNzpNOAMSGEJ5IHmFndBUny8x7QG3guer05zX9TV6NS5fFSYIl/WM1sOtBY3tWnPC6+9v45TqZ3lpndYmYbNtcOW5QhR1HJ/pGZbW1mHYBk4h8HTvcXlqMH0szWM7P1ou3OwH7Awuj1z83s1AKSOhMYY2Ydo+v1M7NOwNPAyKhNpBcwPI9rPQD8KLrOUGB5CGFFAWlr1YqZxyGEpcDyqAoG8F1gUXSu8rhC2uPnOGrXtWh7IJnOsGY7roo5TvMXZH6ZOWQiCXc6sEfUYLsIOClKYFNtIT2BZ83sZeAFMj1bj0fvDQD+WUAarwPeABaY2UJgCploexqwhMwH9yZgrp/QTFvIg8B7ZvZWdJ3TGzmmrSlWHkOman6Xmb0CbAdcFu1XHldWe/scH0Wml34BmXbbkbluXlWPUZrZn4AfFnnIgbQiyuO2r9rzuKoKTRGRStNjlCIiKajQFBFJQYWmiEgKKjRFRFIoZHA73bt3DzU1NUVKSnWora1d2Z5m9VYet33K43QKKjRramqYPz+fJ7DaDjNrV8sCKI/bPuVxOqqei4ikoEJTRCQFFZoiIimo0BQRSaFVFZoTJ05k4sSJmBlmxty5c5k7d27uE0VEyqRVFZoiIq1dQUOOim3y5MmVToKUyapVmSkLu3TpAkCHDvr+bi9efPFFAC677LLsvnvuuQeAZ555BoChQ4eWP2F50l+qiEgKFY8033333QbbV1xxBQC77bZbRdIkpXfkkUcC0LlzZwBGj86sZ/X973+/JPf78MMPAejatSsAHTtW/E+/3XjzzTcBOOmkkwB4/vnMkkL//ve/Gxzrn31FmiIibUTFv269LSNp8803r0BKpJx23nlnAC6//HIAhg/PZ8melvP28i+//BKA3/zmNyW9X3v29ddfA/DEE5l1z4444ggAPv30UwC6d88sR77++utnz/GawOeff162dLaUIk0RkRRaZaSptsy2r3fv3mW5z2OPPQZkxgBDHMko0iyu5cuXZ7ePP/54AGbOnAnAeuutB8ANN9wAwAEHHADA9OnTs+f8/Oc/L0s6i0GRpohIChWLNL2n/Lnnnsvu8+ijXFGIVM61115blvvMmjULiCNMb0uV4li5ciUABx54YHbf4sWLAbjxxhuBOLLcbLPNcl6vGub1VKQpIpKCCk0RkRQqVj2fNGlSg30+NKElfGKP5GB5qFv99wHV6miqnIULFwLw/vvvl+V+jz/+eJ3X//u//1uW+7YXXj0/+eSTs/v8c+xDi9IYN25ccRJWQoo0RURSqFikuXTp0gb7hgwZkvo6HmGOHDkSaBhpJnl0O2fOHEARZyV4fn388cd19vvjlMXiHT8+mL1Tp04ADBs2rKj3ae/69+9f52dL9eiRWeNsiy22KDhNpaZIU0QkhYoPbi+UR4/1I8zGJv3waPSss84C0ATHZbJ69erstueLO/TQQ4G6bWLFcP/99wOwYMGCOtffcMMNi3ofSe/tt98GYMqUKdl9hfRnlJsiTRGRFKoy0kxGiPUfw7zrrrsAOOqooxqc522mjT26KaVz5plnZrdff/31Ou+Vqjf797//fUmuK4W7/vrrAdhggw2y+y699NJKJSc1RZoiIilUZaTZ2BjP5iLMptx9992pz5H8PfDAA0Djkb0/LtevX7+i3tN75ZMTSEjr4GM6b7rpJiDuY4DqamtWpCkikkLFIs3GJhpubOxmkveQJyMXb6dUtNh6fPLJJwBcfPHFQMMxmQAzZswAYJ111inqvf/xj38Aca+5O/HEE4t6H0nvoosuAuLJiH0ij2qjSFNEJAUVmiIiKVSseu7DUJKdOmeffTYQDz6vz99P8kk48uHVe5+vU1X60vD1XubPn9/gPR/M/p3vfKesaerWrVtZ7ycxX+PeV6EcO3YsoOq5iEi7ULFI06O95CQdPo2br+fSVMSZlGvlSh9WlLx+/Uf5pDh8TZhzzz23zv6tt946u33NNdcA8K1vfQuAEAIAa9asafK6a621FhBPvuF8kg8za/Jcj2y33HLL3L+AlMRPf/pTAD744AMgXv+8UP43c+WVVwIwbdo0IB7StMMOOxTlPvUp0hQRSaHig9uTj9j5YFdvu/TI0I9Js3KlR5jnnHNOdp9Ht2naQSV/PknGiy++WGd/ci3rCRMm1HnP18ieOnVqk9fdaaedAHjppZfq7L/jjjsAOPjgg7P7Hn300TrH+KDp5qJRKQ3/e/B88kdm+/btm/payWFrvsLo+eefD8Df//53AMaMGQPAt7/97RamOD+KNEVEUqh4pJnswfbB7ZMnTwbiyLK5CTZ88g7/6e0ajZ3jkw9rtcvSSK5jnbRkyZLstrdppuFTy/Xp0weALl26ADBq1CgABg4cmD12xYoVdc497bTTUt9PCuM1i/HjxwPQq1cvIM6vfPgjl7/97W8BuO6667LveW+8X9cjz+HDhxeQ6vwp0hQRSaHikWaS95Z7m6OP4Wxsgg6XfOg/yXvlk73nijBL64ILLgDgjDPOqLM/2Ya1ySabAA2Xt9hnn30A2HXXXRtcd9CgQQB89tlnQLxg19NPPw3A1VdfnT3Wx4buuOOOAGyzzTYt+VWkAB5h+qOsTzzxBFB3FEV98+bNA+AXv/gFEK9X75J9Fz4iolKLsCnSFBFJQYWmiEgKrap67rwa7YPc/ad3BDS24qQPS9KsR5Vz6qmnAjB48OA6+3v27Jnd7tq1KwDrrrtu6utvtNFGdV7vt99+QDy0Jcmrc8nZwaV0kh1wN998MwAHHnggEDe9+NpA3nGT7Dj06rj/XXz/+98H4PDDDwfg2GOPzR7bsWNliy1FmiIiKbTKSLMpvmJdYx1DPlzJhxx5tKq1zcvHI4DGOnNKKbnOkNc4ktGtlF5yKNmyZcuAOEr0jiF/gMFn1U9GjB6Nemfi0KFDS5vgAijSFBFJoaoiTW/bTPLI0nmbZq6JPKTt6NGjR6PbUnpfffUVALfeemuD90aPHt3oOT4IPTmxy4gRI0qQutJQpCkikkJVRZouGXE2Fn2KSHnU1tYC8dpMSd5O6X0RW2yxBQB77rkn0PABh2qhSFNEJIWqjDRFpHXwMbk+mXR7oEhTRCQFFZoiIimo0BQRSUGFpohICio0RURSUKEpIpKCCk0RkRRUaIqIpGCFDEo1sxXAO8VLTlXoG0JoN7NCKI/bPuVxOgUVmiIi7Y2q5yIiKajQFBFJQYWmiEgKzRaaZtbNzBZE/5aZ2XuJ12uXKlFm1tXM7jWz18xssZkNynH8aDNbEaVrsZn9pMD7325mh+R57G5m9nW+x7c2lcrj6N4dzewVM7svj2MvSaTtr2Z2UIH3/ouZ7ZjjmHXMbJqZvWlmc82sTyH3rJRK5LGZ9TWz2Wa2yMxeNbOf5nFO2T/HZnZY9De4wMzmmdnuua7b7NRwIYR/AjtGFx8PrA4h/LbeTY1Mh9I3uW6WwtXAAyGEw6JM7ZTHOXeEEMaa2abAQjN7IISwMpHOjiGEr4qYRsysI3Ap8Fgxr1tOFcxjgLOAhUC+6/n+JoQw2cy2B2aZ2cYh0ZNZgjw+GVgWQtjKzI4FfgWMKuL1y6JCefwlMDaEsMDMugAvmdmjIYS/5Tiv3J/jR4EZIYRgZjsDtwLbN3dCi6rnZrZV9A1yB/Aq0NvMViXeP9rMboi2N4mixvlm9oKZDclx7a7A4BDCzQAhhC9CCB/nm7YQwjLgbaBPFJ3cambPAjdHkc3EKB2vmNno6J4dzOzaKLJ9DOie5+3GAncCK3MdWG1KmcfROX2B/YCb0qYthLAQMGCjKJqYYmYvAJea2XpmdnOUjpfM7ODofuua2T1RBDMdWCePW/0QuCXavhvYP21aW7NS5nEI4f0QwoJo+xPgNaBXvmkr1+c4hLA68cXbGcg5nKiQSYj7Az8KIcyPIq6mXAVcHkJ4zsxqgIeA7c1sMHBCCOHUesdvCawws1uB7wDzyHxjfZZPosxsK6Av8PdEOoeFEP5jZmOAD0MIg8zsv4DnzOxRYAiwBbAtsBmwCJgaXW8C8GwI4c/17tMHOAj4LrBnPmmrQqXKY4DJwDjy/4LKiqpQ/wkh/CsTINETGBJC+MbMLgceCSH82Mw2Ap6PPkA/BT4KIQwws52A+Ynr3QRc6R/yhF7Au5D58jazNWa2YQhhFW1HKfMYADPbkkz0Ni/fRJXrcxy9dwQwgczf4vdypa2QQvOtEML83IexL9Av+uOGTHTQKYTwPPB8E2kaCJwB1JKpqo8DLsxxn1FmthfwOTA6hLAquuf9IYT/RMeMAAaY2dHR6w2ArYFhwB+jqslSM5vtFw0hnNfE/SYD/xN9UHMkrWqVJI8t0870blR12zdFesaZ2Y+BT4GRif33JKqVI4ADzez/Rq/XAfqQyePLAUIIL5nZq35yCOGEFGloa0r1OQYgqppPB84IIazO4z7l/hwTQpgGTDOzvYGLo+s3qZBCc01i+xsy1SWXrPoYMCiE8EWe110KLPGMjKpSY/M4744QQmPHJdNpwJgQwhPJA8zs0DzTljQQuCfK0O7ACDP7OoTwYAuu1VqVKo93Bw4zsx9E1+liZreEEI7Pcd5vQgiTc6TTgENCCG8lD2jhF9t7QG9gmWXa1ju3sSgTSpfHRP9n9wI3hRAeyPO0cn+Os0IIs8zslly1iaIMOYpK9o/MbGsz6wAkE/84cLq/sBw9liGEpcDyKDyHTPV3UXTuz82syWpAHmYCY7waYmb9zKwT8DQwMmoT6QUMz3WhEEKfEEJNCKEGuA84uY0VmHUUOY//J4SwefR/dyzwqBeYZna5t0O20EwytRRPy07R5tPAMdG+HYDt8rjWA4AX5EeR6TRos4qZx5b5lroZWBBCuKree63mcxy161q0PZBMZ1izX4zFHKf5CzK/zBwy0aI7HdgjarBdBJwUJXCwmU1t4lpnAHeZ2Stk/rgvi/YPAP5ZQBqvA94AFpjZQmAKmWh7GrCETOF8EzDXTzCzCWaWs52jnShmHjfl/wDLCkjjhUBnywxLehUYH+3/f0A3M1sMXAC85CeY2U1NFALXAz3N7E0ybaLnFpCualGsPB4O/Dewn8XDm7wjrTV9jo8i00u/gEy77chGjqmjqp49N7M/AT8s9tAhaR2ib/yHQwgHVDotUjrV/jmuqkJTRKTS9BiliEgKKjRFRFJQoSkikkIh4zTp3r17qKmpKVJSqkNtbe3K9jSrt/K47VMep1NQoVlTU8P8+fk8TNB2mFm7WhZAedz2KY/TUfVcRCQFFZoiIimo0BQRSUGFpohICio0RURSUKEpIpKCCk0RkRQKGqdZKYsXL85uP/PMM3XeO/nkk8udHBFpxGmnnQbAddddB8DIkZlZ137/+98D0KlTPusltj6KNEVEUqj6SHPSpEkAvP7660Aced52223lT5i02HHHHQfAkiVLABgwYED2vaFDhzbY15Tu3TPrtPXt27fYSZQ8ffDBBwA88sgjQLzUyN133w3ASSedBMA+++xTgdQVTpGmiEgKVRlpHnbYYdntXXbZBYDBgwcD8Je//AWAlSszS5F75CGt04oVK4A439555506rwGuv/56II5YfOLs+q8Bhg0bBsDPfvYzoO7fipRHz549Adh0002BuPbgfvWrXwGw6667Zvetv/76ZUpd4RRpioikUJWRZpK3XfXu3RuI2zsVaVYHj0I8wpw6NbNGV3IUhEejM2bMAKB///4AvPbaaw2u5+2el156KQDbbrttnXOkfHbffXcAXnjhhTr7n3zySQAefDBevPWYY44pX8IKpEhTRCSFqo80PbL0qMPbsBRZVBdvn2xMjx6ZuWLrj8H19svGnHtuZrVd/R1Uzv77Z1bsveaaawD48ssv67yfnMNTkaaISBulQlNEJIWqr557B8KaNWsA+OUvf1nJ5EgLJYcNFcOee+5Z1OtJeiNGjAAaDgd0d955Z3b7lFNOAaBfv35lSl3LKdIUEUmhKiPN5GOUxx9/PBAPLcnnUTtpPTwvm+sIkup2/vnnA3DAAQfU2b98+fLs9hFHHAHAX//61/IlrIUUaYqIpFBVkaa3W5533nnZfT691OzZsyuRJCnQvffeCxS/TVNajz322AOArl27AvCvf/2rwTEff/wxAJ988gkAXbp0KVPq0lOkKSKSQlVFmv6g//3335/dN2rUKECPS1ar++67D4jbND2Pf/e73zV5jo+Q0GQc1WHdddcF4KyzzgLiNs6kpUuXAvDUU08BcPDBB5cpdekp0hQRSaEqIk2fsGHChAkADB8+PPverbfeWpE0SWEuueQSoGFbZnNtmz4Jy+GHHw7Ek9z643rSup199tkA/PnPfwZgzpw5DY7xvwuf7KNbt25lSl3+FGmKiKTQqiNNjzC/973vAbDxxhsDMHHixIqlSQrj4zJ//etfA3Fbprdz+eTBjbVRe6Tpfwc+RnfWrFnZYzROt/Vae+216/xM1ip8e968eUC8ZIYiTRGRKqdCU0QkhVZdPb/yyisBqK2tBeJZvXfeeefsMT5hh1fd6nv66aez2/XXlPEVLL0q6HMw+hAJKT7PU39QwTtxLrroopzn1s8nn53dVyAFVc+rga+20Nijs77PZ3Xffvvty5ewPCnSFBFJoVVGmv5onUcSzQ189jVmPNJsbqXCXKsZ+izfxx57bFF/H4n5mtf+f3/xxRenvsahhx4KxH8PUl0OOeQQAG655ZYmj5k5cyYA48aNA6Bjx9ZTVCnSFBFJoWLFt7dpJVcU9MHr/mhd/YHOb7/9NhCwr1KeAAAGiUlEQVRP0gENI5X668jk47jjjgPi9jZFmqXTp08fAKZMmdLia3g7tSb5qE4+hDDZ/rxo0aI6x3g79eTJkwE455xzypS63BRpioikUPZI0x+T+sMf/gDEPdjQsK3RVxv0NixfwiC5wmAxerpvu+02oPF1tKVw3kYNcXv0ww8/3OLr1Z/kQ6qLt096+zbAmWee2eixDz30EKBIU0SkapUt0vRpvOq3VyajBW/v8okYyr1mtdbILo1kL3chU/j5Y7Xepul/O1pErTrls4jayy+/DMTjsSEe51kpijRFRFJQoSkikkLZqudNNd4nZ3FuboYbqT5enU4+4pps/E97HR+qUn9mJD06WZ2Sq1MOGjQIiGc5cr5m0FVXXZXdd8UVV5QhdU1TpCkikkLZIk2fbMN5472ihLarR48eQLwKIcCHH36Y17nJte199VGfuGWXXXYB4pqJVL+DDjoIaBhpurlz55YzOc1SpCkikkLZIs2WPN4obcN2222X3b7xxhuBePZ1f3BhxowZQPz4nLeBQ/zIra8N5I9gqu277fBVZcePH9/o+61p5VFFmiIiKbSe+ZakzfJ1yiF+cOHUU08F4JRTTgEaTtOXjCw8CmlN0YYUV+/evQGYNGkSEE/e89lnnwGwzz77VCZhjVCkKSKSgiJNKbnkCIn58+cD8cQd3oZZ6klZpHVba621gHhERGseGaFIU0QkBUWaUlY+KUtLlrkQaQ0UaYqIpKBCU0QkBRWaIiIpqNAUEUlBhaaISAoqNEVEUrBC1o42sxXAOzkPbFv6hhB6VDoR5aI8bvuUx+kUVGiKiLQ3qp6LiKSgQlNEJIVmC00z62ZmC6J/y8zsvcTrtUuRIDPra2azzWyRmb1qZj/N45zRZrYiStdiM/tJgWm43cwOyXHMdmY218w+N7OxhdyvkiqRx9F9l5rZX6P7PJ/H8ZXI48PM7JXonvPMbPdC7lkpFczjWzzP8jy+OvI4hJDXP2A8cE4j+w3okO918rjPZsCO0XYX4C1gmxznjAYmR9ubAiuB7vWO6ZgiDbcDh+Q4ZhNgIHAZMLZYv38l/5Urj6NrLgU2THF8JfJ4PeJ2/52BhZXOoyrL4+HAIGBBW8rjFlXPzWyrKBK8A3gV6G1mqxLvH21mN0Tbm5jZvWY238xeMLMhzV07hPB+CGFBtP0J8BrQK9+0hRCWAW8DfczsEjO71cyeBW42s45mNjFKxytmNjpKYwczu9bMXjOzx4Cc6yiEEJaHEOYDX+WbtmpSyjwuVBnzeHWIPk1AZ6BN9ZqWOo9DCE8B/2pJ2lpzHhcyy1F/4EchhPlm1tx1rgIuDyE8Z2Y1wEPA9mY2GDghhHBqUyea2ZbA9kDjS9Q1fs5WQF/g74l0Dgsh/MfMxgAfhhAGmdl/Ac+Z2aPAEGALYFsyke4iYGp0vQnAsyGEP+ebhjaklHkcgCfNLADXhhBuzDdR5cxjMzsCmEDmA/i9fNNYRUr+OW6J1pzHhRSab0WRVi77Av0sWs4A2MjMOoUQngeabMsysy7AdOCMEMLqPO4zysz2Aj4HRocQVkX3vD+E8J/omBHAADM7Onq9AbA1MAz4YwjhG2Cpmc32i4YQzsvj3m1VKfN4SAjhPTPbFHjMzBaHEObkuE/Z8ziEMA2YZmZ7AxdH129LSvo5boFWn8eFFJprEtvfkGkTcesktg0YFEL4It8LW6Zx+l7gphDCA3medkcIobEOmWQ6DRgTQnii3v0OzTdt7UzJ8jiE8F70c5mZ3U+m7StXoVmxPA4hzLJMx8aGIYRVuc+oGiXL4xZq9XlclCFHUcn+kZltbWYdgGTiHwdO9xdmtmNz17LM18rNZBqPr6r33s/NrJBqwExgjFdDzKyfmXUCngZGRm0ivcg0YEtCkfN4PTNbL9ruDOwHLIxet5o8jtr8LNoeSKbDoC0VmHUUM4+bU+15XMxxmr8g88vMIdMz6k4H9ogabBcBJ0UJHGxmUxu5znDgv4H9LB4WsX/03gDgnwWk8TrgDWCBmS0EppCJtqcBS8i0gdwEzPUTzGyCmTVo5zCzzc1sKfAzYLxlhtC09cVsipXHPYFnzexl4AVgRgjh8ei9VpPHwFHAQssMmbkKGFlAuqpFsfIYM7sHeAbYNvp8/Dh6q6rzuKoeozSzPwE/DCG0yR5rUR63B9Wex1VVaIqIVJoeoxQRSUGFpohICio0RURSUKEpIpKCCk0RkRRUaIqIpKBCU0Qkhf8PzDYpsEiRqN8AAAAASUVORK5CYII=\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": 98,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimization Iteration:    101, Training Accuracy:  56.2%\n",
      "Optimization Iteration:    201, Training Accuracy:  81.2%\n",
      "Optimization Iteration:    301, Training Accuracy:  90.6%\n",
      "Optimization Iteration:    401, Training Accuracy:  90.6%\n",
      "Optimization Iteration:    501, Training Accuracy:  92.2%\n",
      "Optimization Iteration:    601, Training Accuracy:  93.8%\n",
      "Optimization Iteration:    701, Training Accuracy:  89.1%\n",
      "Optimization Iteration:    801, Training Accuracy:  90.6%\n",
      "Optimization Iteration:    901, Training Accuracy:  90.6%\n",
      "Time usage: 0:02:43\n"
     ]
    }
   ],
   "source": [
    "optimize(num_iterations=900) # We performed 100 iterations above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on Test-Set: 93.6% (9358 / 10000)\n",
      "Mis-classified image on test-set:\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": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimization Iteration:   1001, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   1101, Training Accuracy:  95.3%\n",
      "Optimization Iteration:   1201, Training Accuracy:  95.3%\n",
      "Optimization Iteration:   1301, Training Accuracy:  92.2%\n",
      "Optimization Iteration:   1401, Training Accuracy:  90.6%\n",
      "Optimization Iteration:   1501, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   1601, Training Accuracy:  90.6%\n",
      "Optimization Iteration:   1701, Training Accuracy:  95.3%\n",
      "Optimization Iteration:   1801, Training Accuracy:  92.2%\n",
      "Optimization Iteration:   1901, Training Accuracy:  93.8%\n",
      "Optimization Iteration:   2001, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   2101, Training Accuracy:  95.3%\n",
      "Optimization Iteration:   2201, Training Accuracy:  93.8%\n",
      "Optimization Iteration:   2301, Training Accuracy:  93.8%\n",
      "Optimization Iteration:   2401, Training Accuracy:  93.8%\n",
      "Optimization Iteration:   2501, Training Accuracy:  95.3%\n",
      "Optimization Iteration:   2601, Training Accuracy:  93.8%\n",
      "Optimization Iteration:   2701, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   2801, Training Accuracy:  93.8%\n",
      "Optimization Iteration:   2901, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   3001, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   3101, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   3201, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   3301, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   3401, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   3501, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   3601, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   3701, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   3801, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   3901, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   4001, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   4101, Training Accuracy:  93.8%\n",
      "Optimization Iteration:   4201, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   4301, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   4401, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   4501, Training Accuracy:  98.4%\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:  95.3%\n",
      "Optimization Iteration:   5001, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   5101, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   5201, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   5301, Training Accuracy:  92.2%\n",
      "Optimization Iteration:   5401, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   5501, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   5601, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   5701, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   5801, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   5901, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   6001, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   6101, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   6201, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   6301, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   6401, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   6501, Training Accuracy:  93.8%\n",
      "Optimization Iteration:   6601, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   6701, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   6801, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   6901, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   7001, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   7101, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   7201, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   7301, Training Accuracy: 100.0%\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:  98.4%\n",
      "Optimization Iteration:   7801, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   7901, Training Accuracy:  98.4%\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:  98.4%\n",
      "Optimization Iteration:   8401, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   8501, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   8601, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   8701, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   8801, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   8901, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   9001, Training Accuracy:  95.3%\n",
      "Optimization Iteration:   9101, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   9201, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   9301, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   9401, Training Accuracy:  95.3%\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: 100.0%\n",
      "Optimization Iteration:   9901, Training Accuracy: 100.0%\n",
      "Time usage: 0:31:24\n"
     ]
    }
   ],
   "source": [
    "optimize(num_iterations=9000) # We performed 1000 iterations above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on Test-Set: 98.6% (9860 / 10000)\n",
      "Mis-classified image on test-set:\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"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "global name 'confusion_matrix' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m\u001b[0m",
      "\u001b[0;31mNameError\u001b[0mTraceback (most recent call last)",
      "\u001b[0;32m<ipython-input-102-7cd77c68739c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m print_test_accuracy(show_example_errors=True,\n\u001b[0;32m----> 2\u001b[0;31m                     show_confusion_matrix=True)\n\u001b[0m",
      "\u001b[0;32m<ipython-input-92-22e71baf3141>\u001b[0m in \u001b[0;36mprint_test_accuracy\u001b[0;34m(show_example_errors, show_confusion_matrix)\u001b[0m\n\u001b[1;32m     66\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mshow_confusion_matrix\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     67\u001b[0m         \u001b[0;32mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Confusion Matrix:\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 68\u001b[0;31m         \u001b[0mplot_confusion_matrix\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcls_pred\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcls_pred\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-91-a791398150d1>\u001b[0m in \u001b[0;36mplot_confusion_matrix\u001b[0;34m(cls_pred)\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m     \u001b[0;31m# Get the confusion matrix using sklearn.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m     cm = confusion_matrix(y_true=cls_true,\n\u001b[0m\u001b[1;32m     12\u001b[0m                           y_pred=cls_pred)\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: global name 'confusion_matrix' is not defined"
     ]
    }
   ],
   "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": "iVBORw0KGgoAAAANSUhEUgAAAVMAAADuCAYAAACEaORrAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAH/1JREFUeJzt3X18VeWVL/B18h4S8noIIZBki4BU0KKJQpEyiFTRUopIFYWx1EFEy4i1VlEYRUoZRtByvVYpIkXLRel1BKmjjMUOVUR0EqSCEBDhECAJcAIJeSVve/6A+PHTtdY+OXWdcz9ef98/f9vFfnbOyfLk7Gc/j891XQIAgK8m5v/1AAAA/n+AZgoAYADNFADAAJopAIABNFMAAANopgAABtBMAQAMoJkCABhAMwUAMBAXzn+ckeF3e/VyWB4fr9fU1cl5U5Nec/x4s5AeI9c97fMcoAF/drbrFBSwvOyzWLVmYOpR+UCcx49XOBaorqZgXV3ErzHT53N7C7nHy0hnlbxbSopepLwxSmtqgq7r9vA4nYlMn8/NE3Kv64xLTpYPZGToRT17sihQXk7B6uqIv5bdu/vd7GyH5drvHRFRe7uc5+bqNVVVPGtsDFBLSzDi10hE5Pf7xd9LamhQa0r3J4p5Xl6CWlNRITWmii71nrCaaa9eDq1eXSLkes2WLXK+e7des2TJHiG92XNsVpyCAir5y19YPnxsmlqzbcSD8gG/Xz+RcKx4wYKQ47PQm4heE/Icj5oDSl58ySV6kfLG8K1ff9jjVGbyiGidkHv0DPL36ycfmDBBL3rgARYV/8M/eA3NTHa2Q48+yn8nN2/Wa+rr5XzOHL1m8WKevftucYjR2XEKCqhk61Z+YPt2tcZ3zQAxv+uuPmrNY4/9VUhvCzU8IsKf+QAAJtBMAQAMoJkCABgI6zvTlNYaGnqMf9vWeMlEteb2LXfIB6ZPV2uWLDktpNotEFt79sXSpSP496OtrXrNuqInxPz4cb1m1jQhfPZZ78EZSYqJoQHSjaNgUK0pnjVLzFueWaHWzJunHYnKPQtKICLhlgWlvfCCWtM4WX6/dgtI3+OfN2YMz/bv9x6ckczDpTTpn/jPc5xHTU7//mIeuOoztWZjUhLLis9G53eSiGjvvhi6clQ3lk+fPlqtcc+2iPkdM/XzuP/+OcuKH+zadeKTKQCAATRTAAADaKYAAAbQTAEADKCZAgAYQDMFADAQ1tSots8/p1M33cTyrA8/VGs6Vq4S89hYj6kmJE1piE7fb2pqoV27+NOOt95aqNb86Edy7vXIbExsdKYHSer7X0bvruCPIFau12t6TJanQK3WZ7hJT1kSEdGSJV6jsxObkUFpV1/ND3g8GqrMAKMxYy5Wa0Zt+IhlrddH51HLGDo3BexvbfSomao8uO/k56s1nxw5wjKP5TXM9e9PtGkTz7Nmejxm/js+ZiKiVceO6TVTV/MsVl+X48vwyRQAwACaKQCAATRTAAADaKYAAAbQTAEADIR1Nz8uJ4eybrmF5ZdOv1Kt0RacffJJ/e7omjX8WFlZ99ADNJCbm0A/+Qm/c790qV4zdmz457n0jTd4eN994f9Df4fWVqLKSp57Lczy/vtyvnq1XuN1LBoqu11IC4bwhXmWOnqNtqDNqmVn1BpfurTau8fKOIbOElG5kE998UW9qKZGzj2W579UWNQkeeVK78EZqqwkmj+f509Lq1Z3EmYeERHRv/6rXiO9aT0WAPoyfDIFADCAZgoAYADNFADAAJopAIABNFMAAANopgAABsKaGlURm0+PZjzNcq/9tqdMeUfMFy++Rq1pElZQcN2QwzPR3k50WtiC6hp9uHT0qJyPGOFxolxhH57ERM+xWcn01dAt8XzK0Kmp+l5eQ4bI+eDB+nm8jkVDU5O82MzOnXpN39QT8oH6NrXG58tjmevGhxqeifaBRXR6NV+05jWPtTwylG3jy8r0Gml2UKXvzRCjs5Pfq42enn+KH5gwTa1pU17ouEBAP5Ew9ZM++MB7cOfhkykAgAE0UwAAA2imAAAG0EwBAAygmQIAGPC5Ydwm9/l8J4mI7+kRHYWu6/aI9ElwjVHxTbhOXKOhr8N1htVMAQBAhj/zAQAMoJkCABhAMwUAMIBmCgBgIKxn87N8Pld6rDehqEgvOiY/JNzRq7da0tjIs6qqANXUBH0hhviV+bt1c52MDJY3SPt8nJcSJ/8Yzw78tlqze3eFkNaQ6zZG/BoTEvxuUpLD8kK+W8sXmpvlPP2I8PB7p5wcMS49ciQYjbvAmZl+Ny/PYXlyh7TNyDmlZfL6CNnZ+q9KSwvPmpsD1NIShfdrdrbr5OezvLFFH29Cgpzv26efR6ppaorONRIRxcT43dhYh+XfztF/L8W9eYi83+iCQDBIwbq6kNcZVjPtQ0TCzkVU8NFHetG8eWLcOG+RWlLC122gGTOKvQdnxMnIoJLp01m+/Ze/VGuGZWaK+cHXhQs578IL/0VIXwg5PgtJSQ4VF/OxeW3poy2CccN9A/SiWbPE2Dd7dlSmuOTlOfTyy/w6L23W36++oY6Yjx8v/4+BiEhaN6OkJErv1/x8Knn7bZbvOKqP13Hk/KqrPM4j1GzbFp1rJCKKjXUoM5O/liX3/EovWrhQzh9/PKxzFz/2WJf+O/yZDwBgAM0UAMAAmikAgIGwvjNNKCqiPh8J3wPOeVAveuUV+d/y2Lt6pLBJeyrVhxyficpK6hC+Hx32ve+pJTk7+XdWREQnL3zZ40SThIwv2BwJeXnyHuSTpCGdp7yMNHHwfrXmGe3fmz1bP5GhhAT5uz5fepZa06uX/F3j5s36eSZP5tmePSEGZ6S8Io7ufoyP+bnBv1FrKnJ/KuZlZfrNnLIy6a6VvmC2tba2Jjp5chfLF/nmqjVzm0eK+cwPvqvW3Hgjz87E8wXxJfhkCgBgAM0UAMAAmikAgAE0UwAAA2imAAAG0EwBAAyENTWqpUXZI37WE2pNQW6ufGJtrg0R0U038UzauDsSBg2imD/8gcUbD1yslpQoe8oXJF2j1iQX8uksZ88mhx6fgdTAbho5nT8GuqNfP7VmP8l7pL/m3K/WfBJ8KvzBGYqtq6G0LRtZPnPm+LD/reXL9blO27fz90aD/vi/qYKkE+I0qJY75elPRER5AXk62zvv6I8GS7+u69eH1T6+kgsuSKaFCy9h+W3ONrUm6Ul5CtT9ifq0MXqllEVppwIhx0eET6YAACbQTAEADKCZAgAYQDMFADCAZgoAYCC8hU7iXSrIFZYVHzdOL5JW1CAi+vnP1RJpUfeobUhdW0u0aROL2xz9br6wMP85uw+oNTfeyO/m/+d/hhydjY4Oeel8bTFdIvJfJC80Lt/jP+eGt94Kc2C2Sj+PJd8P01juNghbOZw3cWo3Mf/Zz/TX/6GHeHbttaHHZ6KxkaiU34EO6Ovy0Jo18l37BfOE3+3zRu99nmU7Np0IPT4jcYdKKWcKfw8u86i5Xcm9lhOaeP31PGxt9RraF/DJFADAAJopAIABNFMAAANopgAABtBMAQAMoJkCABgIa2pU7RkfvbmZ7wWzZYi8BxIR0RMfy4sKXHmFPtlJmjVV80h09uiuOnqUnhAGcAfpU7nSfvtbMd82eIZas/bAlSwrbt7bhREa6NuXaNUqnq9Zo5ZkrVsn5je8+qp+nqVL5byw0Gt0hhKJ6AKWPrVcnv5ERDR2rJx7/Gjo+HGetUVpe6T2fIfOLOOv5YD6CrVmzpw8+UBNjX6i6mrh5O2hhmcmLTubxoznC9SMkTbgOq/5uuvEfPA+vfdsLONZzf6u9R58MgUAMIBmCgBgAM0UAMAAmikAgAE0UwAAAz7X7foSIj6f7yQRHY7ccDwVuq7bI9InwTVGxTfhOnGNhr4O1xlWMwUAABn+zAcAMIBmCgBgAM0UAMAAmikAgIGwns33Z2W5Tu/e/ECjvg0ExceL8efHU9US6RTHjgXo9OmgvHeGoYwMv5uX57C8W7BcL6qvF+Pj2fpWF8nJwn9/PEC1tZG/Rn/37q7j9/MD3burNa0+viYDEVF8zUn9RKdOiXFpfX0wGneB09L8bk6Ow/KMduE5806xsWLcnKTtTSM/h19VFaCamsi/lomJfjc11WH5BclVelFSkhgfa9CvsbaWZy0tAWpri/w1EhH5fNkuUT7LL7pIb2Gp3TrEvPRjfeGEmBj+Pu/oCJDrhr7OsJqp07s3lbz+Oj9QUqIX5eaK8cRlI9USaSuim2+OzkIneXkOrVnDr+fylffoRR98IMZP/aP+cxk8mGezZkXnGh2/n0oef5wfGDVKrTmeWCDmPV9foZ9IWR3E9957UZnikpPj0FNP8ddgfM1LepGyodf+gXyRjU7BIM/uuCM6r2VqqkPXXcevce2QJ/SigQPF+JHt+jUK26JRWVl0rvGcfCJ6h6UrVmSrFSOL5Q95vhT9A0BKCl+Ep6EBC50AAEQNmikAgAE0UwAAA2F9Z1rTlEiv7ezL8rHjeNapqEjOpe2pO0lrCld5fJ9uqVvZDrr8KuHu0JAhepH0PTIRjZXvSxER0c6dPIvWgsJHGrPp/p18V/H7Ruk1BUN6yQeURaOJyHux4ShoapJ/zhmjtB3V1a9M6a31+nke2vAdlqUeFVYZjoA+fZQ1uNen6EXjxonxoqCwYHjnsTn8hnHxw6dDDc9M0bdaqGSN8FX7QOF3tVNzs3KgQS2R7tdoa5z/LXwyBQAwgGYKAGAAzRQAwACaKQCAATRTAAADaKYAAAbCmhqVcWQXTfw534ecxn6q1uxtV6YUHfWYarR8OYuKd0Rn3lDrJZfT8bf543nv8CfZvpCxW85vOPQbtabtuz9lmfS8fiT06EE0cybPCwsPeVTtE1N31+/VisvjPlGOROVxbqqoaKDHHvtvlu/bd4Vac9FFR8XcbVf2mici35zNQvrdkOOzsHcv0bBhPC9/5TK15t2t8meokZMmqTUbt6SxrMbn8ciqsbN799JBYZ7l1hf1xe3LyrqJ+cMPZ6k1EybwbOXK0OMjwidTAAATaKYAAAbQTAEADKCZAgAYQDMFADAQ1t18t6WFWgIBljen6IsqpL3xhnzg7Fm1ZmE2X/C1MuTobHzyiUu5ua0sP3xY3jGASF0DmW4Yo981vjT3BMuS46MzY+HgQSLpxq37aZNaM3Imv5tLRLQins9K6JSqb6YQFXl5KXTXXfw1WL3aq0rYgYCI9pTpnzteeIG//xcsiM7nlLY2eRGge18ZHva/NTJJX5xl1KgrWeaxMYO5YG4RrfwJn2UjL3N9jrZAybJlNmP6W/hkCgBgAM0UAMAAmikAgAE0UwAAA2imAAAG0EwBAAyENTWq9ZIiqnqDT08o8Mv7UxMRlQflxQYKMs6oNfOEfYU2PPxwF0ZooZmI9rC0vv7basXkyXJ+9xI+naTTc/9SwUNXX7TB0sX9W6nkLX7+ibMuVmvee48vGEJEtGmTPv1r61bt3/Ien5XmZqIyYbbPq6/qNe7nwutCpM9/I6KLhY2jnu3gU98iIT+f6KGHeK797ImI1m7OkQ/ETVVrZgX5e7m8PNTo7NTWEm3axPNF0/arNdcdGSDmPT/cqNaU0/iwx9YJn0wBAAygmQIAGEAzBQAwgGYKAGAAzRQAwIDPDeMOss/nO0lEhyM3HE+Fruv2iPRJcI1R8U24Tlyjoa/DdYbVTAEAQIY/8wEADKCZAgAYQDMFADCAZgoAYADNFADAQFgLnaSm+t3sbIflPY7sUGvOKrMFEn0+/UT5+SwKVFdTsL7eo8hGus/n9hTytBj9/zstHR1i7g4uUmsST/FdrQI1NRRsaIj4NcbF+d2EBIflffqE/2+lHfqrfrB/fzEu3bs3GI0pNYmJfjclxWF5erpek914RD4gLGbSqS2Zb4Z05EiAqquDEX8t/amprpOVxQ9I2Xm1DfKvfXprUD9RHK8JnDhBwTNnIn6NRET+2FjXiY3lB4Rxdepokvc085q/FDuAL44SqKqiYG1tyOsMq5lmZzs0dy5fNWrG7GS15kBzs5j3S0zUTzR3LouKf/Wr0AM00JOInhXyMR6bBgbq6sS843X+s+rUd80ClhX/9rehhmciIcGhfv342LQNyLxcO1VZgYhIXWnJV1QUlfmCKSkOjRnDr3PcOL3m9p33ywc8ik4NGc2y0aOLQ47PgpOVRSXSslG33qrWvLldbrQ3VK3ST+TnGw0W36/8rCLAiY2lktxcfkDYfLNT/c6dYu61bWXGc8+xrPjuu0MNj4jwZz4AgAk0UwAAA2imAAAGwvrOtEdmG82YdIof2HS9WtPvrbfkA/PmqTXlY2ewrOWZFSHHZyHtW9+iMcJ3fc1F+s2kFiUfsPc/1JrxJY+y7ECDvgK4pcxMeXeAqfpC6zRihJyPqdJXlI+ZfkeYI7PV1kZUUxNmkVYgfV93nrSqfX19mOf9O52Ky6G1mT9leWC5XjN3bquYu+84as1Bh38vfDaZf+8fMTk5RLNm8fzoUbUk9Te/kQ9s2KCfZ+VKngU9bsx9CT6ZAgAYQDMFADCAZgoAYADNFADAAJopAIABNFMAAANhTY2ikyeJhMetaPduteTeO+XnYwdm6qe5Z+m9LEs4rjwzbaw82I3ufv5ylrffqT/RuyI4UT4waZJas/HYMZYVj/Z60M1OTkUp3TOXP2r8yC9+oRctXCjnBwJ6zdixcv673+k1hgakHKO3ix9h+du5i/SiwYPlvE1/bUaN4ll3/rh+RGR1a6bbhuxhuW+Kx6Oh9EM59pgyVDONT41qbw81OkPZ2eLcvW2BPLVk+MfK1ChpXmAn6Vn/v3qsP/El+GQKAGAAzRQAwACaKQCAATRTAAADaKYAAAbCu5vfsyfRz37G4uSFfDHnTu3KggstNY36eV4ZwrON0VkEpCD5JD13mbCoitcqIDsfkHOPBYUXLecL9FaeDO/l+Hu5RCTtDbBhyRK1ZoJyZ77lmmvUmoowx2UuKYlo4EAWeyzOTgcnyAseb9+u1zjCoibKIu/mSj9tIt+gXSzv319f6fuzzw6Jue9/64sPPc7Xhqba2tDjM3P2LNGBAywePt/j91JboESYSfOFpCSedXG1HHwyBQAwgGYKAGAAzRQAwACaKQCAATRTAAADaKYAAAbCmotz5FgM3T+vG8u9tpX+9a+rxfzB+fp+17m5fO+g4+3SbvYR0L27vOHRtGlqyYLBfxDzrVuHqzWpqTxr9JgtZikuI4Oyrr6a5RO0/bqIiKZMEWOvCWt8uZgoq6sj2rKFxSOW366WlJTIufR6ddq0iWdnzoQYm5HExEwqKLiF5e+9p9f07N5TzIeP4b/bnSZM4Nm6dSGHZ6e6mkjYm40WL9ZrysrEeP8w/fV3HJ65r3dtWiY+mQIAGEAzBQAwgGYKAGAAzRQAwACaKQCAAZ/r6ttxsP/Y5ztJRIcjNxxPha7r9oj0SXCNUfFNuE5co6Gvw3WG1UwBAECGP/MBAAygmQIAGEAzBQAwgGYKAGAgrGfz/XFxrpOYyA/06hX2iVu6ZajHdu2SHlKvINet8YV9ojD509NdJyeH5dVt6WpNdkKdfCA+Xq05Wce3R6iuDlB9fTDy15ia6jpZfNuUw038ujsV9mmXDxzWb7DWZPUV888/Lw1G4y6wPznZdbp35wfOntWLlPfymQ794XzpHu6JEwGqrY38a+nz+V2iQpYXFOin7hEvb8PREK//TqZUl7MsUFdHwaamiF8jEZE/NtZ1hN8n1+O19PWQ32KV8QVqTVUVzzo6AuS6oV/LsJqpk5hIJYMG8QPz9L1jNOVDxqvHCgt3CKnHXi+GnJwcKlm2jOUvVX9frbm9z5/lA336qDXPbh7Asn/7t+LQAzTgZGVRyQN836oZu+9Va1YsVVbumD5drXltsrwAzE03+aIyxcXp3p1KJk3iBwIBvWjOHDF+u3mkWtLWxrPZs6PzWp5rpHyDqrlz9f+Rz/C/JuYf9p6o1gx98R6WFb/6aujhGXHi46mkgDfBls8+U2sSpNeeiBbk6osmLRW2zmpo6NpriT/zAQAMoJkCABhAMwUAMBDeRu3t7eIe0gcH699/9j3wtphL3010GjuWLyu8bZu+cK2p9HSi669n8ZDdHjWDR4lxTJz+/6oxY3h2+nSIsVk5dYro5ZdZPPlX+nem4jfzRJ4v5FXCvcqoam8nqueb2q/78ZtqyRXK19zXKu9jIqJnA9eyrKUl9PAsFPWqpJLpv2T5wbt49sUxJR/6ox/pJ5K+SxYW3o4YxyFasYLFs9bo32U385eeiIheqrlfrXk0yBebLv5O154SxSdTAAADaKYAAAbQTAEADKCZAgAYQDMFADCAZgoAYCCsqVG1+YPpzWV8Y/GiFL1m4nI+bYSIaKrH06HNzTxLSAg1OhsVFUSPzuf/j9ntMTVq/XptHozyPDsRTZrEf2j79oUanRG/n+jOO1k8uk2f/kNx/eTcY2pU8sKnwx2ZqSNxF9C9GS+xfFymXuP3Kwfue0atuWdcgGWr6GSI0RlJTycaN47FfaU1NDppbzSPR4Ppgw94Jkw7i5hDh4h+/GMWt119SC0ZOFA5kH6hWvPhx7zRNDR2bfkBfDIFADCAZgoAYADNFADAAJopAIABNFMAAANh3c2PjyfKzeW513oH2s3eTZv0muefrxTSVq+hmcmLO0EL/PwudN+d+iIg77/PV80nIgoG9fMkCSVeN2BNJSWJtzrfveoqtWTkiy/KB6ZNU2tmzgx3YLaysoimTOH50HX6QhfUb5YYPzhwo1ryxOabeVin7L5grbGRaOdOnv/iF2rJ6LHy1Ji4hfpp/vSnfCFdHmJwhpTms2oYX/yk06LgDPmAx4IuQ7fwBc1TWrq2AhE+mQIAGEAzBQAwgGYKAGAAzRQAwACaKQCAATRTAAADYU2NStxbSn2L+EP/lz/+uF70A74/OxFRRoa+p1NpaS+WTZ2q7wNuynXFjdCldR465ebuEfMnn7xYrZEWYXC7ttXMV1ZZl0oLNg9nubxj/Dl7hEUmiIguVleTIFr7+utiLmw/FREp1eXifu+00GMOkLLXldcaINQ8j2effuo9OCM18T1oYy6fArTGYyGh//ovYSUhIrriCnmKHxFRQ8MFLBsxIoqbfCmL83hRp+Zt2aoXjRjBs9TULp0Pn0wBAAygmQIAGEAzBQAwgGYKAGAAzRQAwIDPDeMWss/nO0lEhyM3HE+Fruv2iPRJcI1R8U24Tlyjoa/DdYbVTAEAQIY/8wEADKCZAgAYQDMFADCAZgoAYCCsZ/P9aWmuk5PDDwjPsnc6VOcX8wsc/cZX6Q4pPUyuG+QLAxjLzva7+fkOy48f12t6p9fLBw4d0ouEn2Pg1CkKNjRE/BqTk/1uWprD8nxpZ4rzSku1I/prn54uv71qa0uD0bgLnJDgd5OTHZbXKy8XEdFll8n5aY+dK9LTeVZeHqBgMArvV5/PLRDy472K1Jq83A75gNfN6CNHWBSor6dgc3PEr5GIyJ+U5DopKfzAqVN6kU8eWpPHdSb7eb8K1NV16TrDaqZOTg6VPPEEP1BTo9bctvkOMV+7ukWt8SVK4x4Wangm8vMd+vOfS1iu7WVFRLRo7LvyAWVxECIi+ud/ZlHxr38dangm0tIcmjIlvGuMjW1Xjuiv/ciR2WL+xz/6ojLFJTnZoeHD+XW+/75eU/KR3GjW/V/9j7gf/IBnI0YUhxyfhQIi+ouQL53Or7vTgjmN8gGPD0V0330sKt6o74tlzUlJoZLvf58f+P3v9SJlU7XdzfJCL0REg2+8kWXF69eHHB8R/swHADCBZgoAYADNFADAQFjfmdbHZdC23Iks3x7QaxxHzsur5L27iYgqiX9nel2IsVmJiyPKyuDfmy3q/Zxas2jrT8V8bmClWvN/cq9h2an4tV0Y4VeXl0c0fz7P9e9FiYjKxTQzky8a3GnZMjn/4x89TmOopYUoEOD5pEl6zcGA/PmiF1+v/AspKZVC2uo5Niutg4qo6jX+/WjcKx5Fu3fL+S236DUZGTxrVL57jYTmZqKyMp7H64vGVynfjQa9ziMtDv2nP3mP7Tx8MgUAMIBmCgBgAM0UAMAAmikAgAE0UwAAA2imAAAGwpoatW8f0VVX8ekzPXrEqjUnFq+SD0z3mLvRvTuL4hsaQo7PxKefEg0axHPpmcHzHhn2mpjPpZ5qjTRlLEGfLWaqoYFo+3ae33qr/jq+/PJnYn76tP6g+zPPXBL22Cw1N3dQWRl/35SVvaPWLFw4XsxH9qtQa9zvTmZZ8ccHuzDCry6pfD8NmHUty+e88bZeVPhDMf5wgzTF65yhtcK/N2tWyPGZaWoi2rWL55s2qSWBa/j0QyKiUQsXqjUx025nmes+HXp8hE+mAAAm0EwBAAygmQIAGEAzBQAwgGYKAGAgrLv5Rd32Usmg7/ADGzboRQ9slvPZs9WSD3/J7xw2TIvOYruUlkb0ve+xeM80YVHs83Jz5Vy6Y95p6HG+sG5qm77QsqWDB4km8xvQdPr0y2rN++/fKubamhlERMXKSxalNbApOTmGBg7kq7PvWNlHrflEWQUj75n5+onmzeNZtO50x8eLb8CE+Y+oJSP7y3ft3/3WGf08rx7lWYu+wLu1jiGXU+NWvqCLx415GvEf8or6t63xOM8m3nuKZ3n8XL4En0wBAAygmQIAGEAzBQAwgGYKAGAAzRQAwACaKQCAgbCmRpHPRxTLF8NY916eWnKLMndh9PS+as2fF3/EshSKzkInu2ryqe8bfGGD+/rpNfeO2CHmQ/+Xx0b0c+bwTNnn21r//kSrV/N82LDBao20BRARUT+Pn8uQIeGNy1pBgbIPlcegL/XLq81UtOp7OuU8/zzL5Ek59g66F9DNzS+xvChdr3njPb7HGhHRWo+aHCHr2oQhGzExRN2S+N5s06frnwdfUdZSWrtY3s+MiGjkVL5ozL7KtNADJHwyBQAwgWYKAGAAzRQAwACaKQCAATRTAAADPtft+n1Hn893kogOR244ngpd1+0R6ZPgGqPim3CduEZDX4frDKuZAgCADH/mAwAYQDMFADCAZgoAYADNFADAAJopAIABNFMAAANopgAABtBMAQAMoJkCABj4H9JtUsDMDGF+AAAAAElFTkSuQmCC\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": "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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=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": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}