13B_Visual_Analysis_MNIST.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TensorFlow Tutorial #13-B\n",
    "# Visual Analysis (MNIST)\n",
    "\n",
    "by [Magnus Erik Hvass Pedersen](http://www.hvass-labs.org/)\n",
    "/ [GitHub](https://github.com/Hvass-Labs/TensorFlow-Tutorials) / [Videos on YouTube](https://www.youtube.com/playlist?list=PL9Hr9sNUjfsmEu1ZniY0XpHSzl5uihcXZ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "\n",
    "Tutorial #13 showed how to find input images that maximized the response of individual neurons inside the Inception model, so as to find the images that the neuron *liked to see*. But because the Inception model is so large and complex the images were just complex wavy patterns.\n",
    "\n",
    "This tutorial uses a much simpler Convolutional Neural Network with the MNIST data-set for recognizing hand-written digits. The code is spliced together from Tutorial #03-B for constructing the neural network and Tutorial #13 for finding input images that maximize individual neuron responses inside the neural network, so a lot of this code may look familiar to you."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Flowchart"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following chart shows roughly how the data flows in the Convolutional Neural Network that is implemented below. Note that there are two separate optimization loops here:\n",
    "\n",
    "First the weights of the neural network are optimized by inputting images and their true classes to the network so as to improve the classification accuracy.\n",
    "\n",
    "Afterwards a second optimization is performed which finds the input image that maximizes a given feature or neuron inside the network. This finds an image that the network *likes to see*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Flowchart](images/13b_visual_analysis_flowchart.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TensorFlow 2\n",
    "\n",
    "This tutorial was developed using TensorFlow v.1 back in the year 2016. There have been significant API changes in TensorFlow v.2. This tutorial uses TF2 in \"v.1 compatibility mode\", which is still useful for learning how TensorFlow works, but you would have to implement it slightly differently in TF2 (see Tutorial 03C on the Keras API). It would be too big a job for me to keep updating these tutorials every time Google's engineers update the TensorFlow API, so this tutorial may eventually stop working."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from sklearn.metrics import confusion_matrix\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /home/magnus/anaconda3/envs/tf2/lib/python3.6/site-packages/tensorflow_core/python/compat/v2_compat.py:88: disable_resource_variables (from tensorflow.python.ops.variable_scope) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "non-resource variables are not supported in the long term\n"
     ]
    }
   ],
   "source": [
    "# Use TensorFlow v.2 with this old v.1 code.\n",
    "# E.g. placeholder variables and sessions have changed in TF2.\n",
    "import tensorflow.compat.v1 as tf\n",
    "tf.disable_v2_behavior()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This was developed using Python 3.6 (Anaconda) and TensorFlow version:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2.1.0'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.__version__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The MNIST data-set is about 12 MB and will be downloaded automatically if it is not located in the given path."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mnist import MNIST\n",
    "data = MNIST(data_dir=\"data/MNIST/\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The MNIST data-set has now been loaded and consists of 70.000 images and class-numbers for the images. The data-set is split into 3 mutually exclusive sub-sets. We will only use the training and test-sets in this tutorial."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Size of:\n",
      "- Training-set:\t\t55000\n",
      "- Validation-set:\t5000\n",
      "- Test-set:\t\t10000\n"
     ]
    }
   ],
   "source": [
    "print(\"Size of:\")\n",
    "print(\"- Training-set:\\t\\t{}\".format(data.num_train))\n",
    "print(\"- Validation-set:\\t{}\".format(data.num_val))\n",
    "print(\"- Test-set:\\t\\t{}\".format(data.num_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Copy some of the data-dimensions for convenience."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The number of pixels in each dimension of an image.\n",
    "img_size = data.img_size\n",
    "\n",
    "# The images are stored in one-dimensional arrays of this length.\n",
    "img_size_flat = data.img_size_flat\n",
    "\n",
    "# Tuple with height and width of images used to reshape arrays.\n",
    "img_shape = data.img_shape\n",
    "\n",
    "# Number of classes, one class for each of 10 digits.\n",
    "num_classes = data.num_classes\n",
    "\n",
    "# Number of colour channels for the images: 1 channel for gray-scale.\n",
    "num_channels = data.num_channels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Helper-functions for plotting images"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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": 7,
   "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": [
    "Function used to plot 10 images in a 2x5 grid."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_images10(images, smooth=True):\n",
    "    # Interpolation type.\n",
    "    if smooth:\n",
    "        interpolation = 'spline16'\n",
    "    else:\n",
    "        interpolation = 'nearest'\n",
    "\n",
    "    # Create figure with sub-plots.\n",
    "    fig, axes = plt.subplots(2, 5)\n",
    "\n",
    "    # Adjust vertical spacing.\n",
    "    fig.subplots_adjust(hspace=0.1, wspace=0.1)\n",
    "\n",
    "    # For each entry in the grid.\n",
    "    for i, ax in enumerate(axes.flat):\n",
    "        # Get the i'th image and only use the desired pixels.\n",
    "        img = images[i, :, :]\n",
    "        \n",
    "        # Plot the image.\n",
    "        ax.imshow(img, interpolation=interpolation, cmap='binary')\n",
    "\n",
    "        # Remove ticks.\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": [
    "Function used to plot a single image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_image(image):\n",
    "    plt.imshow(image, interpolation='nearest', cmap='binary')\n",
    "    plt.xticks([])\n",
    "    plt.yticks([])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot a few images to see if data is correct"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "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.x_test[0:9]\n",
    "\n",
    "# Get the true classes for those images.\n",
    "cls_true = data.y_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": [
    "## TensorFlow Graph\n",
    "\n",
    "The neural network is constructed as a computational graph in TensorFlow using the `tf.layers` API, which is described in detail in Tutorial #03-B."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Placeholder variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Placeholder variables serve as the input to the TensorFlow computational graph that we may change each time we execute the graph.\n",
    "\n",
    "First we define the placeholder variable for the input images. This allows us to change the images that are input to the TensorFlow graph. This is a so-called tensor, which just means that it is a multi-dimensional array. 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": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = tf.placeholder(tf.float32, shape=[None, img_size_flat], name='x')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The convolutional layers expect `x` to be encoded as a 4-rank tensor so we have to reshape it so its shape is instead `[num_images, img_height, img_width, num_channels]`. Note that `img_height == img_width == img_size` and `num_images` can be inferred automatically by using -1 for the size of the first dimension. So the reshape operation is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_image = tf.reshape(x, [-1, img_size, img_size, num_channels])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we have the placeholder variable for the true labels associated with the images that were input in the placeholder variable `x`. The shape of this placeholder variable is `[None, num_classes]` which means it may hold an arbitrary number of labels and each label is a vector of length `num_classes` which is 10 in this case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_true = tf.placeholder(tf.float32, shape=[None, num_classes], name='y_true')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could also have a placeholder variable for the class-number, but we will instead calculate it using argmax. Note that this is a TensorFlow operator so nothing is calculated at this point."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_true_cls = tf.argmax(y_true, axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Neural Network\n",
    "\n",
    "We now implement the Convolutional Neural Network using the Layers API. We use the `net`-variable to refer to the last layer while building the neural network. This makes it easy to add or remove layers in the code if you want to experiment. First we set the `net`-variable to the reshaped input image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = x_image"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The input image is then input to the first convolutional layer, which has 16 filters each of size 5x5 pixels. The activation-function is the Rectified Linear Unit (ReLU) described in more detail in Tutorial #02."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-16-df6771052e21>:2: conv2d (from tensorflow.python.layers.convolutional) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use `tf.keras.layers.Conv2D` instead.\n",
      "WARNING:tensorflow:From /home/magnus/anaconda3/envs/tf2/lib/python3.6/site-packages/tensorflow_core/python/layers/convolutional.py:424: Layer.apply (from tensorflow.python.keras.engine.base_layer) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use `layer.__call__` method instead.\n"
     ]
    }
   ],
   "source": [
    "net = tf.layers.conv2d(inputs=net, name='layer_conv1', padding='same',\n",
    "                       filters=16, kernel_size=5, activation=tf.nn.relu)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After the convolution we do a max-pooling which is also described in Tutorial #02."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-17-b75c98dafe2c>:1: max_pooling2d (from tensorflow.python.layers.pooling) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use keras.layers.MaxPooling2D instead.\n"
     ]
    }
   ],
   "source": [
    "net = tf.layers.max_pooling2d(inputs=net, pool_size=2, strides=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we make a second convolutional layer, also with max-pooling."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = tf.layers.conv2d(inputs=net, name='layer_conv2', padding='same',\n",
    "                       filters=36, kernel_size=5, activation=tf.nn.relu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = tf.layers.max_pooling2d(inputs=net, pool_size=2, strides=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The output then needs to be flattened so it can be used in fully-connected (aka. dense) layers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-20-f3e227e0e1ce>:1: flatten (from tensorflow.python.layers.core) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use keras.layers.Flatten instead.\n"
     ]
    }
   ],
   "source": [
    "net = tf.layers.flatten(net)\n",
    "\n",
    "# This should eventually be replaced by:\n",
    "# net = tf.layers.flatten(net)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now add fully-connected (or dense) layers to the neural network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-21-33fd5057adca>:2: dense (from tensorflow.python.layers.core) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use keras.layers.Dense instead.\n"
     ]
    }
   ],
   "source": [
    "net = tf.layers.dense(inputs=net, name='layer_fc1',\n",
    "                      units=128, activation=tf.nn.relu)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We need the neural network to classify the input images into 10 different classes. So the final fully-connected layer has `num_classes=10` output neurons."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = tf.layers.dense(inputs=net, name='layer_fc_out',\n",
    "                      units=num_classes, activation=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The outputs of the final fully-connected layer are sometimes called logits, so we have a convenience variable with that name which we will also use further below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "logits = net"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use the softmax function to 'squash' the outputs so they are between zero and one, and so they sum to one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = tf.nn.softmax(logits=logits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This tells us how likely the neural network thinks the input image is of each possible class. The one that has the highest value is considered the most likely so its index is taken to be the class-number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_cls = tf.argmax(y_pred, axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loss-Function to be Optimized"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To make the model better at classifying the input images, we must somehow change the variables of the neural network.\n",
    "\n",
    "The cross-entropy is a performance measure used in classification. The cross-entropy is a continuous function that is always positive and if the predicted output of the model exactly matches the desired output then the cross-entropy equals zero. The goal of optimization is therefore to minimize the cross-entropy so it gets as close to zero as possible by changing the variables of the model.\n",
    "\n",
    "TensorFlow has a function for calculating the cross-entropy, which uses the values of the `logits`-layer because it also calculates the softmax internally, so as to to improve numerical stability."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "cross_entropy = tf.nn.softmax_cross_entropy_with_logits_v2(labels=y_true, logits=logits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have now calculated the cross-entropy for each of the image classifications so we have a measure of how well the model performs on each image individually. But in order to use the cross-entropy to guide the optimization of the model's variables we need a single scalar value, so we simply take the average of the cross-entropy for all the image classifications."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss = tf.reduce_mean(cross_entropy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Optimization Method\n",
    "\n",
    "Now that we have a cost measure that must be minimized, we can then create an optimizer. In this case it is the Adam optimizer with a learning-rate of 1e-4.\n",
    "\n",
    "Note that optimization is not performed at this point. In fact, nothing is calculated at all, we just add the optimizer-object to the TensorFlow graph for later execution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = tf.train.AdamOptimizer(learning_rate=1e-4).minimize(loss)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classification Accuracy\n",
    "\n",
    "We need to calculate the classification accuracy so we can report progress to the user.\n",
    "\n",
    "First we create a vector of booleans telling us whether the predicted class equals the true class of each image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "correct_prediction = tf.equal(y_pred_cls, y_true_cls)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The classification accuracy is calculated by first type-casting the vector of booleans to floats, so that False becomes 0 and True becomes 1, and then taking the average of these numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Optimize the Neural Network"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create TensorFlow session\n",
    "\n",
    "Once the TensorFlow graph has been created, we have to create a TensorFlow session which is used to execute the graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "session = tf.Session()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initialize variables\n",
    "\n",
    "The variables for the TensorFlow graph must be initialized before we start optimizing them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "session.run(tf.global_variables_initializer())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Helper-function to perform optimization iterations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are 55,000 images in the training-set. It takes a long time to calculate the gradient of the model using all these images. We therefore only use a small batch of images in each iteration of the optimizer.\n",
    "\n",
    "If your computer crashes or becomes very slow because you run out of RAM, then you may try and lower this number, but you may then need to do more optimization iterations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_batch_size = 64"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This function performs a number of optimization iterations so as to gradually improve the variables of the neural network layers. In each iteration, a new batch of data is selected from the training-set and then TensorFlow executes the optimizer using those training samples.  The progress is printed every 100 iterations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "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",
    "    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.random_batch(batch_size=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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Helper-function to plot example errors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Function for plotting examples of images from the test-set that have been mis-classified."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "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.x_test[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.y_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": [
    "### Helper-function to plot confusion matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "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.y_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": [
    "### Helper-function for showing the performance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below is a function for printing the classification accuracy on the test-set.\n",
    "\n",
    "It takes a while to compute the classification for all the images in the test-set, that's why the results are re-used by calling the above functions directly from this function, so the classifications don't have to be recalculated by each function.\n",
    "\n",
    "Note that this function can use a lot of computer memory, which is why the test-set is split into smaller batches. If you have little RAM in your computer and it crashes, then you can try and lower the batch-size."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "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 = data.num_test\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.x_test[i:j, :]\n",
    "\n",
    "        # Get the associated labels.\n",
    "        labels = data.y_test[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.y_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": "markdown",
   "metadata": {},
   "source": [
    "### Performance before any optimization\n",
    "\n",
    "The accuracy on the test-set is very low because the variables for the neural network have only been initialized and not optimized at all, so it just classifies the images randomly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on Test-Set: 8.7% (871 / 10000)\n"
     ]
    }
   ],
   "source": [
    "print_test_accuracy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Performance after 10,000 optimization iterations\n",
    "\n",
    "After 10,000 optimization iterations, the model has a classification accuracy on the test-set of about 99%."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimization Iteration:      1, Training Accuracy:  10.9%\n",
      "Optimization Iteration:    101, Training Accuracy:  82.8%\n",
      "Optimization Iteration:    201, Training Accuracy:  89.1%\n",
      "Optimization Iteration:    301, Training Accuracy:  90.6%\n",
      "Optimization Iteration:    401, Training Accuracy:  89.1%\n",
      "Optimization Iteration:    501, Training Accuracy:  93.8%\n",
      "Optimization Iteration:    601, Training Accuracy:  87.5%\n",
      "Optimization Iteration:    701, Training Accuracy:  92.2%\n",
      "Optimization Iteration:    801, Training Accuracy:  95.3%\n",
      "Optimization Iteration:    901, Training Accuracy:  95.3%\n",
      "Optimization Iteration:   1001, Training Accuracy:  95.3%\n",
      "Optimization Iteration:   1101, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   1201, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   1301, Training Accuracy:  93.8%\n",
      "Optimization Iteration:   1401, Training Accuracy:  95.3%\n",
      "Optimization Iteration:   1501, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   1601, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   1701, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   1801, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   1901, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   2001, Training Accuracy:  95.3%\n",
      "Optimization Iteration:   2101, Training Accuracy:  95.3%\n",
      "Optimization Iteration:   2201, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   2301, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   2401, Training Accuracy:  95.3%\n",
      "Optimization Iteration:   2501, Training Accuracy:  95.3%\n",
      "Optimization Iteration:   2601, Training Accuracy:  95.3%\n",
      "Optimization Iteration:   2701, Training Accuracy:  92.2%\n",
      "Optimization Iteration:   2801, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   2901, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   3001, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   3101, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   3201, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   3301, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   3401, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   3501, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   3601, Training Accuracy:  95.3%\n",
      "Optimization Iteration:   3701, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   3801, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   3901, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   4001, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   4101, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   4201, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   4301, Training Accuracy:  95.3%\n",
      "Optimization Iteration:   4401, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   4501, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   4601, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   4701, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   4801, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   4901, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   5001, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   5101, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   5201, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   5301, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   5401, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   5501, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   5601, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   5701, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   5801, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   5901, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   6001, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   6101, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   6201, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   6301, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   6401, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   6501, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   6601, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   6701, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   6801, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   6901, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   7001, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   7101, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   7201, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   7301, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   7401, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   7501, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   7601, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   7701, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   7801, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   7901, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   8001, Training Accuracy:  98.4%\n",
      "Optimization Iteration:   8101, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   8201, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   8301, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   8401, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   8501, Training Accuracy:  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: 100.0%\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:  98.4%\n",
      "Optimization Iteration:   9701, Training Accuracy: 100.0%\n",
      "Optimization Iteration:   9801, Training Accuracy:  96.9%\n",
      "Optimization Iteration:   9901, Training Accuracy:  98.4%\n",
      "CPU times: user 25.6 s, sys: 2.81 s, total: 28.4 s\n",
      "Wall time: 24.7 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "optimize(num_iterations=10000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on Test-Set: 98.8% (9881 / 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",
      "[[ 977    0    1    0    0    0    0    1    1    0]\n",
      " [   0 1125    4    0    0    1    1    3    1    0]\n",
      " [   1    0 1029    0    0    0    0    2    0    0]\n",
      " [   0    0    3 1000    0    4    0    0    2    1]\n",
      " [   0    0    3    0  973    0    1    1    0    4]\n",
      " [   2    1    0    3    0  883    3    0    0    0]\n",
      " [   6    2    0    1    1    4  943    0    1    0]\n",
      " [   1    0    8    1    0    0    0 1016    1    1]\n",
      " [   5    0   11    2    1    4    1    2  945    3]\n",
      " [   3    3    1    0    4    4    0    3    1  990]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print_test_accuracy(show_example_errors=True,\n",
    "                    show_confusion_matrix=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Optimizing the Input Images\n",
    "\n",
    "Now that the neural network has been optimized so it can recognize hand-written digits with about 99% accuracy, we will then find the input images that maximize certain features inside the neural network. This will show us what images the neural network *likes to see* the most.\n",
    "\n",
    "We will do this by creating another form of optimization for the neural network, and we need several helper functions for doing this."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Helper-function for getting the names of convolutional layers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Function for getting the names of all the convolutional layers in the neural network. We could have made this list manually, but for larger neural networks it is easier to do this with a function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_conv_layer_names():\n",
    "    graph = tf.get_default_graph()\n",
    "    \n",
    "    # Create a list of names for the operations in the graph\n",
    "    # for the Inception model where the operator-type is 'Conv2D'.\n",
    "    names = [op.name for op in graph.get_operations() if op.type=='Conv2D']\n",
    "\n",
    "    return names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "conv_names = get_conv_layer_names()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['layer_conv1/Conv2D', 'layer_conv2/Conv2D']"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conv_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(conv_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Helper-function for finding the input image"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This function finds the input image that maximizes a given feature in the network. It essentially just performs optimization with gradient ascent. The image is initialized with small random values and is then iteratively updated using the gradient for the given feature with regard to the image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "def optimize_image(conv_id=None, feature=0,\n",
    "                   num_iterations=30, show_progress=True):\n",
    "    \"\"\"\n",
    "    Find an image that maximizes the feature\n",
    "    given by the conv_id and feature number.\n",
    "\n",
    "    Parameters:\n",
    "    conv_id: Integer identifying the convolutional layer to\n",
    "             maximize. It is an index into conv_names.\n",
    "             If None then use the last fully-connected layer\n",
    "             before the softmax output.\n",
    "    feature: Index into the layer for the feature to maximize.\n",
    "    num_iteration: Number of optimization iterations to perform.\n",
    "    show_progress: Boolean whether to show the progress.\n",
    "    \"\"\"\n",
    "\n",
    "    # Create the loss-function that must be maximized.\n",
    "    if conv_id is None:\n",
    "        # If we want to maximize a feature on the last layer,\n",
    "        # then we use the fully-connected layer prior to the\n",
    "        # softmax-classifier. The feature no. is the class-number\n",
    "        # and must be an integer between 1 and 1000.\n",
    "        # The loss-function is just the value of that feature.\n",
    "        loss = tf.reduce_mean(logits[:, feature])\n",
    "    else:\n",
    "        # If instead we want to maximize a feature of a\n",
    "        # convolutional layer inside the neural network.\n",
    "\n",
    "        # Get the name of the convolutional operator.\n",
    "        conv_name = conv_names[conv_id]\n",
    "        \n",
    "        # Get the default TensorFlow graph.\n",
    "        graph = tf.get_default_graph()\n",
    "        \n",
    "        # Get a reference to the tensor that is output by the\n",
    "        # operator. Note that \":0\" is added to the name for this.\n",
    "        tensor = graph.get_tensor_by_name(conv_name + \":0\")\n",
    "\n",
    "        # The loss-function is the average of all the\n",
    "        # tensor-values for the given feature. This\n",
    "        # ensures that we generate the whole input image.\n",
    "        # You can try and modify this so it only uses\n",
    "        # a part of the tensor.\n",
    "        loss = tf.reduce_mean(tensor[:,:,:,feature])\n",
    "\n",
    "    # Get the gradient for the loss-function with regard to\n",
    "    # the input image. This creates a mathematical\n",
    "    # function for calculating the gradient.\n",
    "    gradient = tf.gradients(loss, x_image)\n",
    "\n",
    "    # Generate a random image of the same size as the raw input.\n",
    "    # Each pixel is a small random value between 0.45 and 0.55,\n",
    "    # which is the middle of the valid range between 0 and 1.\n",
    "    image = 0.1 * np.random.uniform(size=img_shape) + 0.45\n",
    "\n",
    "    # Perform a number of optimization iterations to find\n",
    "    # the image that maximizes the loss-function.\n",
    "    for i in range(num_iterations):\n",
    "        # Reshape the array so it is a 4-rank tensor.\n",
    "        img_reshaped = image[np.newaxis,:,:,np.newaxis]\n",
    "\n",
    "        # Create a feed-dict for inputting the image to the graph.\n",
    "        feed_dict = {x_image: img_reshaped}\n",
    "\n",
    "        # Calculate the predicted class-scores,\n",
    "        # as well as the gradient and the loss-value.\n",
    "        pred, grad, loss_value = session.run([y_pred, gradient, loss],\n",
    "                                             feed_dict=feed_dict)\n",
    "        \n",
    "        # Squeeze the dimensionality for the gradient-array.\n",
    "        grad = np.array(grad).squeeze()\n",
    "\n",
    "        # The gradient now tells us how much we need to change the\n",
    "        # input image in order to maximize the given feature.\n",
    "\n",
    "        # Calculate the step-size for updating the image.\n",
    "        # This step-size was found to give fast convergence.\n",
    "        # The addition of 1e-8 is to protect from div-by-zero.\n",
    "        step_size = 1.0 / (grad.std() + 1e-8)\n",
    "\n",
    "        # Update the image by adding the scaled gradient\n",
    "        # This is called gradient ascent.\n",
    "        image += step_size * grad\n",
    "\n",
    "        # Ensure all pixel-values in the image are between 0 and 1.\n",
    "        image = np.clip(image, 0.0, 1.0)\n",
    "\n",
    "        if show_progress:\n",
    "            print(\"Iteration:\", i)\n",
    "\n",
    "            # Convert the predicted class-scores to a one-dim array.\n",
    "            pred = np.squeeze(pred)\n",
    "\n",
    "            # The predicted class for the Inception model.\n",
    "            pred_cls = np.argmax(pred)\n",
    "\n",
    "            # The score (probability) for the predicted class.\n",
    "            cls_score = pred[pred_cls]\n",
    "\n",
    "            # Print the predicted score etc.\n",
    "            msg = \"Predicted class: {0}, score: {1:>7.2%}\"\n",
    "            print(msg.format(pred_cls, cls_score))\n",
    "\n",
    "            # Print statistics for the gradient.\n",
    "            msg = \"Gradient min: {0:>9.6f}, max: {1:>9.6f}, stepsize: {2:>9.2f}\"\n",
    "            print(msg.format(grad.min(), grad.max(), step_size))\n",
    "\n",
    "            # Print the loss-value.\n",
    "            print(\"Loss:\", loss_value)\n",
    "\n",
    "            # Newline.\n",
    "            print()\n",
    "\n",
    "    return image.squeeze()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This next function finds the images that maximize the first 10 features of a layer, by calling the above function 10 times."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "def optimize_images(conv_id=None, num_iterations=30):\n",
    "    \"\"\"\n",
    "    Find 10 images that maximize the 10 first features in the layer\n",
    "    given by the conv_id.\n",
    "    \n",
    "    Parameters:\n",
    "    conv_id: Integer identifying the convolutional layer to\n",
    "             maximize. It is an index into conv_names.\n",
    "             If None then use the last layer before the softmax output.\n",
    "    num_iterations: Number of optimization iterations to perform.\n",
    "    \"\"\"\n",
    "\n",
    "    # Which layer are we using?\n",
    "    if conv_id is None:\n",
    "        print(\"Final fully-connected layer before softmax.\")\n",
    "    else:\n",
    "        print(\"Layer:\", conv_names[conv_id])\n",
    "\n",
    "    # Initialize the array of images.\n",
    "    images = []\n",
    "\n",
    "    # For each feature do the following.\n",
    "    for feature in range(0,10):\n",
    "        print(\"Optimizing image for feature no.\", feature)\n",
    "        \n",
    "        # Find the image that maximizes the given feature\n",
    "        # for the network layer identified by conv_id (or None).\n",
    "        image = optimize_image(conv_id=conv_id, feature=feature,\n",
    "                               show_progress=False,\n",
    "                               num_iterations=num_iterations)\n",
    "\n",
    "        # Squeeze the dim of the array.\n",
    "        image = image.squeeze()\n",
    "\n",
    "        # Append to the list of images.\n",
    "        images.append(image)\n",
    "\n",
    "    # Convert to numpy-array so we can index all dimensions easily.\n",
    "    images = np.array(images)\n",
    "\n",
    "    # Plot the images.\n",
    "    plot_images10(images=images)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### First Convolutional Layer\n",
    "\n",
    "These are the input images that maximize the features in the first convolutional layer, so these are the images that it *likes to see*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Layer: layer_conv1/Conv2D\n",
      "Optimizing image for feature no. 0\n",
      "Optimizing image for feature no. 1\n",
      "Optimizing image for feature no. 2\n",
      "Optimizing image for feature no. 3\n",
      "Optimizing image for feature no. 4\n",
      "Optimizing image for feature no. 5\n",
      "Optimizing image for feature no. 6\n",
      "Optimizing image for feature no. 7\n",
      "Optimizing image for feature no. 8\n",
      "Optimizing image for feature no. 9\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "optimize_images(conv_id=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note how these are very simple shapes such as lines and angles. Some of these images may be completely white, which suggests that those features of the neural network are perhaps unused, so the number of features could be reduced in this layer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Second Convolutional Layer\n",
    "\n",
    "This shows the images that maximize the features or neurons in the second convolutional layer, so these are the input images it *likes to see*. Note how these are more complex lines and patterns compared to the first convolutional layer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Layer: layer_conv2/Conv2D\n",
      "Optimizing image for feature no. 0\n",
      "Optimizing image for feature no. 1\n",
      "Optimizing image for feature no. 2\n",
      "Optimizing image for feature no. 3\n",
      "Optimizing image for feature no. 4\n",
      "Optimizing image for feature no. 5\n",
      "Optimizing image for feature no. 6\n",
      "Optimizing image for feature no. 7\n",
      "Optimizing image for feature no. 8\n",
      "Optimizing image for feature no. 9\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "optimize_images(conv_id=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Final output layer\n",
    "\n",
    "Now find the image for the 2nd feature of the final output of the neural network. That is, we want to find an image that makes the neural network classify that image as the digit 2. This is the image that the neural network *likes to see the most* for the digit 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration: 0\n",
      "Predicted class: 8, score:  89.26%\n",
      "Gradient min: -0.846559, max:  0.558144, stepsize:      5.45\n",
      "Loss: 0.3713841\n",
      "\n",
      "Iteration: 1\n",
      "Predicted class: 2, score: 100.00%\n",
      "Gradient min: -0.535254, max:  0.621156, stepsize:      5.34\n",
      "Loss: 34.539898\n",
      "\n",
      "Iteration: 2\n",
      "Predicted class: 2, score: 100.00%\n",
      "Gradient min: -0.664117, max:  0.673569, stepsize:      5.53\n",
      "Loss: 45.18827\n",
      "\n",
      "Iteration: 3\n",
      "Predicted class: 2, score: 100.00%\n",
      "Gradient min: -0.549961, max:  0.498956, stepsize:      5.67\n",
      "Loss: 48.934826\n",
      "\n",
      "Iteration: 4\n",
      "Predicted class: 2, score: 100.00%\n",
      "Gradient min: -0.540532, max:  0.564252, stepsize:      5.45\n",
      "Loss: 50.952587\n",
      "\n",
      "Iteration: 5\n",
      "Predicted class: 2, score: 100.00%\n",
      "Gradient min: -0.581356, max:  0.486933, stepsize:      5.69\n",
      "Loss: 51.000446\n",
      "\n",
      "Iteration: 6\n",
      "Predicted class: 2, score: 100.00%\n",
      "Gradient min: -0.578246, max:  0.520858, stepsize:      5.55\n",
      "Loss: 51.367252\n",
      "\n",
      "Iteration: 7\n",
      "Predicted class: 2, score: 100.00%\n",
      "Gradient min: -0.592440, max:  0.511202, stepsize:      5.60\n",
      "Loss: 51.47485\n",
      "\n",
      "Iteration: 8\n",
      "Predicted class: 2, score: 100.00%\n",
      "Gradient min: -0.589151, max:  0.507705, stepsize:      5.53\n",
      "Loss: 51.796883\n",
      "\n",
      "Iteration: 9\n",
      "Predicted class: 2, score: 100.00%\n",
      "Gradient min: -0.614109, max:  0.527479, stepsize:      5.59\n",
      "Loss: 51.947083\n",
      "\n"
     ]
    }
   ],
   "source": [
    "image = optimize_image(conv_id=None, feature=2,\n",
    "                       num_iterations=10, show_progress=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note how the predicted class indeed becomes 2 already within the first few iterations so the optimization is working as intended. Also note how the loss-measure is increasing rapidly until it apparently converges. This is because the loss-measure is actually just the value of the feature or neuron that we are trying to maximize. Because this is the logits-layer prior to the softmax, these values can potentially be infinitely high, but they are limited because we limit the image-values between 0 and 1.\n",
    "\n",
    "Now plot the image that was found. This is the image that the neural network believes looks most like the digit 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_image(image)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Although some of the curves do hint somewhat at the digit 2, it is hard for a human to see why the neural network believes this is the *optimal* image for the digit 2. This can only be understood when the optimal images for the remaining digits are also shown."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Final fully-connected layer before softmax.\n",
      "Optimizing image for feature no. 0\n",
      "Optimizing image for feature no. 1\n",
      "Optimizing image for feature no. 2\n",
      "Optimizing image for feature no. 3\n",
      "Optimizing image for feature no. 4\n",
      "Optimizing image for feature no. 5\n",
      "Optimizing image for feature no. 6\n",
      "Optimizing image for feature no. 7\n",
      "Optimizing image for feature no. 8\n",
      "Optimizing image for feature no. 9\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "optimize_images(conv_id=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These images may vary each time you run the optimization. Some of the images can be seen to somewhat resemble the hand-written digits. But the other images are often impossible to recognize and it is hard to understand why the neural network thinks these are the *optimal* input images for those digits.\n",
    "\n",
    "The reason is perhaps that the neural network tries to recognize all digits simultaneously, and it has found that certain pixels often determine whether the image shows one digit or another. So the neural network has learned to differentiate those pixels that it has found to be important, but not the underlying curves and shapes of the digits, in the same way that a human recognizes the digits.\n",
    "\n",
    "Another possibility is that the data-set contains mis-classified digits which may confuse the neural network during training. We have previously seen how some of the digits in the data-set are very hard to read even for humans, and this may cause the neural network to become distorted and trying to recognize strange artifacts in the images.\n",
    "\n",
    "Yet another possibility is that the optimization process has stagnated in a local optimum. One way to test this, would be to run the optimization 50 times for the digits that are unclear, and see if some of the resulting images become more clear."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Close TensorFlow Session"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are now done using TensorFlow, so we close the session to release its resources."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "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": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion\n",
    "\n",
    "This tutorial showed how to find the input images that maximize certain features inside a neural network. These are the images that the neural network *likes to see the most* in order to activate a certain feature or neuron inside the network.\n",
    "\n",
    "This was tested on a simple convolutional neural network using the MNIST data-set. The neural network had clearly learned to recognize the general shape of some of the digits, while it was impossible to see how it recognized other digits."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises\n",
    "\n",
    "These are a few suggestions for exercises that may help improve your skills with TensorFlow. It is important to get hands-on experience with TensorFlow in order to learn how to use it properly.\n",
    "\n",
    "You may want to backup this Notebook before making any changes.\n",
    "\n",
    "* Plot the images for all features in each convolutional layer instead of just the first 10 features. How many of them appear to be unused or redundant? What happens if you lower the number of features in that layer and train the network again, does it still perform just as well?\n",
    "\n",
    "* Try adding more convolutional layers and find the input images that maximize their features. What do the images show? Do you think it is useful to add more convolutional layers than two?\n",
    "\n",
    "* Try adding more fully-connected layers and modify the code so it can find input images that maximize the features of the fully-connected / dense layers as well. Currently the code can only maximize the features of the convolutional layers and the final fully-connected layer.\n",
    "\n",
    "* For the input images that are unclear, run the optimization e.g. 50 times for each of those digits, to see if it produces more clear input images. It is possible that the optimization has simply become stuck in a local optimum.\n",
    "\n",
    "* Explain to a friend how the program works."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## License (MIT)\n",
    "\n",
    "Copyright (c) 2016-2017 by [Magnus Erik Hvass Pedersen](http://www.hvass-labs.org/)\n",
    "\n",
    "Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n",
    "\n",
    "The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.\n",
    "\n",
    "THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE."
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}