Neural3-Copy1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 66,
   "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": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.7.0'"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "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": "code",
   "execution_count": 69,
   "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": 70,
   "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": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "data.test.cls = np.argmax(data.test.labels, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "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": "code",
   "execution_count": 73,
   "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": "code",
   "execution_count": 74,
   "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": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "def new_weights(shape):\n",
    "    return tf.Variable(tf.truncated_normal(shape, stddev=0.05))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "def new_biases(length):\n",
    "    return tf.Variable(tf.constant(0.05, shape=[length]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "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],\n",
    "                         padding='SAME')\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],\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": "code",
   "execution_count": 78,
   "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": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "def new_fc_layer(input,          # The previous 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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = tf.placeholder(tf.float32, shape=[None, img_size_flat], name='x')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_image = tf.reshape(x, [-1, img_size, img_size, num_channels])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_true = tf.placeholder(tf.float32, shape=[None, num_classes], name='y_true')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_true_cls = tf.argmax(y_true, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "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": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'Relu_3:0' shape=(?, 14, 14, 16) dtype=float32>"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "layer_conv1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "layer_conv2, weights_conv2 = \\\n",
    "    new_conv_layer(input=layer_conv1,\n",
    "                   num_input_channels=num_filters1,\n",
    "                   filter_size=filter_size2,\n",
    "                   num_filters=num_filters2,\n",
    "                   use_pooling=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'Relu_4:0' shape=(?, 7, 7, 36) dtype=float32>"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "layer_conv2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "layer_flat, num_features = flatten_layer(layer_conv2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'Reshape_3:0' shape=(?, 1764) dtype=float32>"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "layer_flat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num_features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "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": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'Relu_5:0' shape=(?, 128) dtype=float32>"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "layer_fc1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "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": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'add_7:0' shape=(?, 10) dtype=float32>"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "layer_fc2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = tf.nn.softmax(layer_fc2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_cls = tf.argmax(y_pred, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits=layer_fc2,\n",
    "                                                        labels=y_true)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "cost = tf.reduce_mean(cross_entropy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = tf.train.AdamOptimizer(learning_rate=1e-4).minimize(cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "correct_prediction = tf.equal(y_pred_cls, y_true_cls)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "session = tf.Session()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "session.run(tf.global_variables_initializer())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_batch_size = 64"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "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": "code",
   "execution_count": 106,
   "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": "code",
   "execution_count": 107,
   "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": "code",
   "execution_count": 108,
   "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(\"Example errors:\")\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": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on Test-Set: 7.4% (742 / 10000)\n"
     ]
    }
   ],
   "source": [
    "print_test_accuracy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimization Iteration:      1, Training Accuracy:   9.4%\n",
      "Time usage: 0:00:01\n"
     ]
    }
   ],
   "source": [
    "optimize(num_iterations=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on Test-Set: 8.3% (835 / 10000)\n"
     ]
    }
   ],
   "source": [
    "print_test_accuracy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time usage: 0:00:13\n"
     ]
    }
   ],
   "source": [
    "optimize(num_iterations=99) # We already performed 1 iteration above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on Test-Set: 62.6% (6265 / 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": "code",
   "execution_count": 114,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimization Iteration:    101, Training Accuracy:  65.6%\n",
      "Optimization Iteration:    201, Training Accuracy:  79.7%\n",
      "Optimization Iteration:    301, Training Accuracy:  95.3%\n",
      "Optimization Iteration:    401, Training Accuracy:  93.8%\n",
      "Optimization Iteration:    501, Training Accuracy:  82.8%\n",
      "Optimization Iteration:    601, Training Accuracy:  93.8%\n",
      "Optimization Iteration:    701, Training Accuracy:  87.5%\n",
      "Optimization Iteration:    801, Training Accuracy:  87.5%\n",
      "Optimization Iteration:    901, Training Accuracy:  90.6%\n",
      "Time usage: 0:02:10\n"
     ]
    }
   ],
   "source": [
    "optimize(num_iterations=900) # We performed 100 iterations above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on Test-Set: 93.2% (9317 / 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": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimization Iteration:   1001, Training Accuracy:  87.5%\n",
      "Optimization Iteration:   1101, Training Accuracy:  89.1%\n",
      "Optimization Iteration:   1201, Training Accuracy:  93.8%\n",
      "Optimization Iteration:   1301, Training Accuracy:  93.8%\n",
      "Optimization Iteration:   1401, Training Accuracy:  93.8%\n",
      "Optimization Iteration:   1501, Training Accuracy:  93.8%\n",
      "Optimization Iteration:   1601, Training Accuracy:  93.8%\n",
      "Optimization Iteration:   1701, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   1801, Training Accuracy:  95.3%\n",
      "Optimization Iteration:   1901, Training Accuracy:  95.3%\n",
      "Optimization Iteration:   2001, Training Accuracy:  95.3%\n",
      "Optimization Iteration:   2101, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   2201, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   2301, Training Accuracy:  93.8%\n",
      "Optimization Iteration:   2401, Training Accuracy:  95.3%\n",
      "Optimization Iteration:   2501, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   2601, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   2701, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   2801, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   2901, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   3001, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   3101, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   3201, Training Accuracy:  93.8%\n",
      "Optimization Iteration:   3301, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   3401, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   3501, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   3601, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   3701, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   3801, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   3901, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   4001, Training Accuracy:  93.8%\n",
      "Optimization Iteration:   4101, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   4201, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   4301, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   4401, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   4501, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   4601, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   4701, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   4801, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   4901, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   5001, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   5101, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   5201, Training Accuracy:  95.3%\n",
      "Optimization Iteration:   5301, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   5401, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   5501, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   5601, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   5701, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   5801, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   5901, Training Accuracy:  95.3%\n",
      "Optimization Iteration:   6001, Training Accuracy:  95.3%\n",
      "Optimization Iteration:   6101, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   6201, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   6301, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   6401, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   6501, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   6601, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   6701, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   6801, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   6901, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   7001, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   7101, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   7201, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   7301, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   7401, Training Accuracy:  95.3%\n",
      "Optimization Iteration:   7501, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   7601, Training Accuracy:  98.4%\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:  98.4%\n",
      "Optimization Iteration:   8101, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   8201, Training Accuracy:  95.3%\n",
      "Optimization Iteration:   8301, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   8401, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   8501, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   8601, Training Accuracy: 100.0%\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:  96.9%\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:  98.4%\n",
      "Optimization Iteration:   9501, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   9601, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   9701, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   9801, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   9901, Training Accuracy:  98.4%\n",
      "Time usage: 0:20:49\n"
     ]
    }
   ],
   "source": [
    "optimize(num_iterations=9000) # We performed 1000 iterations above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on Test-Set: 98.7% (9873 / 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",
      "[[ 973    0    1    0    0    0    2    1    3    0]\n",
      " [   0 1130    1    0    0    0    1    2    1    0]\n",
      " [   2    3 1006    6    0    0    0    5   10    0]\n",
      " [   1    0    0 1003    0    1    0    3    2    0]\n",
      " [   0    0    1    0  972    0    1    1    3    4]\n",
      " [   1    0    0    7    0  877    1    1    2    3]\n",
      " [   6    2    0    0    2    4  944    0    0    0]\n",
      " [   0    1    3    2    0    0    0 1019    1    2]\n",
      " [   3    0    1    2    0    1    0    2  963    2]\n",
      " [   1    3    0    6    5    2    0    4    2  986]]\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": "code",
   "execution_count": 118,
   "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": "code",
   "execution_count": 119,
   "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": "code",
   "execution_count": 120,
   "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": "code",
   "execution_count": 121,
   "metadata": {},
   "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": "code",
   "execution_count": 122,
   "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": "code",
   "execution_count": 123,
   "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": "code",
   "execution_count": 124,
   "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_layer(layer=layer_conv1, image=image1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "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_layer(layer=layer_conv1, image=image2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "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_weights(weights=weights_conv2, input_channel=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "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_weights(weights=weights_conv2, input_channel=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "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=image1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "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": 130,
   "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()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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
}