CNN.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imports\n",
    "%matplotlib inline\n",
    "from datetime import timedelta\n",
    "from sklearn.externals import joblib\n",
    "from sklearn.metrics import confusion_matrix\n",
    "import gzip\n",
    "import itertools\n",
    "import math\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import os\n",
    "import tensorflow as tf\n",
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dimensions of the data\n",
    "\n",
    "# We know that images are 48 pixels in each dimension\n",
    "in_height = 48\n",
    "in_width = 48\n",
    "\n",
    "# Images are stored in one-dimensional arrays of this length\n",
    "image_size_flat = in_height * in_width\n",
    "\n",
    "# Tuple with height and width of images used to reshape arrays\n",
    "image_shape = (in_height, in_width)\n",
    "\n",
    "# Classes info\n",
    "classes = ['Angry', 'Disgust', 'Fear', 'Happy', 'Sad', 'Surprise', 'Neutral',]\n",
    "\n",
    "# Number of classes\n",
    "num_classes = len(classes)\n",
    "\n",
    "# Number of colour channels for the images: 1 channel for gray-scale\n",
    "# Channels mean number of primary colors\n",
    "num_channels = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-3-80a70f8fd7e1>:24: calling argmax (from tensorflow.python.ops.math_ops) with dimension is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use the `axis` argument instead\n"
     ]
    }
   ],
   "source": [
    "# Parameters\n",
    "\n",
    "# TensorBoard logs path\n",
    "logs_path = '/tmp/tensorflow_logs/example/'\n",
    "\n",
    "# Placeholder variables\n",
    "\n",
    "with tf.name_scope('Input'):\n",
    "    # Placeholder variable for the input images\n",
    "    x = tf.placeholder(tf.float32, shape=[None, image_size_flat], name='Input-Data')\n",
    "\n",
    "    # Placeholder variable for the true labels associated with the images\n",
    "    y_true = tf.placeholder(tf.float32, shape=[None, num_classes], name='Label-Data')\n",
    "\n",
    "with tf.name_scope('Input-Reshape'):\n",
    "    # Reshape 'x'\n",
    "    x_image = tf.reshape(x, shape=[-1, in_height, in_width, num_channels])\n",
    "    \n",
    "    # Create a summary image to monitor x_image tensor\n",
    "    tf.summary.image('Input', x_image, 3)\n",
    "\n",
    "# We could also have a placeholder variable for the class-number,\n",
    "# but we will instead calculate it using argmax\n",
    "y_true_cls = tf.argmax(y_true, dimension=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load Dataset\n",
    "def load_dataset(filename):\n",
    "    upload_file = gzip.open(filename, 'rb')\n",
    "    images_set, labels_set = joblib.load(upload_file)\n",
    "    upload_file.close()\n",
    "\n",
    "    return images_set, labels_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Returns the values of the function for images_set, labels_set on train-set\n",
    "data_train_images, data_train_labels = load_dataset('Datasets/Extended-CK+/Extended-CK+-with-DA-training-set.pkl.gz')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Returns the values of the function for images_set, labels_set on test-set\n",
    "data_test_images, data_test_labels = load_dataset('Datasets/Extended-CK+/Extended-CK+-test-set.pkl.gz')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Class labels are One-Hot coded, meaning that each label is a vector with 10 elements,\n",
    "# all of which are zero except one element\n",
    "def dense_to_one_hot(labels_dense, num_classes):\n",
    "    num_labels = labels_dense.shape[0]\n",
    "    index_offset = np.arange(num_labels) * num_classes\n",
    "    labels_one_hot = np.zeros((num_labels, num_classes))\n",
    "    labels_one_hot.flat[index_offset + labels_dense.ravel()] = 1\n",
    "    \n",
    "    return labels_one_hot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Call function dense_to_one_hot()\n",
    "data_train_labels  = dense_to_one_hot(labels_dense=data_train_labels, num_classes=num_classes)\n",
    "data_test_labels  = dense_to_one_hot(labels_dense=data_test_labels, num_classes=num_classes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Size of:\n",
      "- Training-set:\t\t66089\n",
      "- Test-set:\t\t565\n"
     ]
    }
   ],
   "source": [
    "print(\"Size of:\")\n",
    "print(\"- Training-set:\\t\\t{}\".format(len(data_train_images)))\n",
    "print(\"- Test-set:\\t\\t{}\".format(len(data_test_images)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_test_cls = np.argmax(data_test_labels, axis=1)\n",
    "# print data_test_cls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Helper-function for catch the class\n",
    "# number and print its corresponding name\n",
    "def get_emotion(num_class):\n",
    "    if num_class == 0:\n",
    "        return 'Angry'\n",
    "    elif num_class == 1:\n",
    "        return 'Disgust'\n",
    "    elif num_class == 2:\n",
    "        return 'Fear'\n",
    "    elif num_class == 3:\n",
    "        return 'Happy'\n",
    "    elif num_class == 4:\n",
    "        return 'Sad'\n",
    "    elif num_class == 5:\n",
    "        return 'Surprise'\n",
    "    elif num_class == 6:\n",
    "        return 'Neutral'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Helper-function for plotting images\n",
    "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(image_shape), cmap='gray')\n",
    "\n",
    "        # Show true and predicted classes\n",
    "        # T = True, and P = Predicted\n",
    "        if cls_pred is None:\n",
    "            xlabel = \"T: {0}\".format(get_emotion(cls_true[i]))\n",
    "        else:\n",
    "            xlabel = \"T: {0}, P: {1}\".format(get_emotion(cls_true[i]), get_emotion(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",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f6a29650e80>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot a few images to see if data is correct\n",
    "\n",
    "# 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": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convolutional Layer 1\n",
    "\n",
    "# Convolution filters are 3 x 3 pixels\n",
    "filter_height_1 = 3\n",
    "filter_width_1 = 3\n",
    "\n",
    "# There are 8 of these filters\n",
    "num_filters_1 = 8\n",
    "\n",
    "# Convolutional Layer 2\n",
    "\n",
    "# Convolution filters are 3 x 3 pixels\n",
    "filter_height_2 = 3\n",
    "filter_width_2 = 3\n",
    "\n",
    "# There are 16 of these filters\n",
    "num_filters_2 = 16\n",
    "\n",
    "# Convolutional Layer 3\n",
    "\n",
    "# Convolution filters are 3 x 3 pixels\n",
    "filter_height_3 = 3\n",
    "filter_width_3 = 3\n",
    "\n",
    "# There are 32 of these filters\n",
    "num_filters_3 = 32\n",
    "\n",
    "# Convolutional Layer 4\n",
    "\n",
    "# Convolution filters are 3 x 3 pixels\n",
    "filter_height_4 = 3\n",
    "filter_width_4 = 3\n",
    "\n",
    "# There are 64 of these filters\n",
    "num_filters_4 = 64\n",
    "\n",
    "# Convolutional Layer 5\n",
    "\n",
    "# Convolution filters are 3 x 3 pixels\n",
    "filter_height_5 = 3\n",
    "filter_width_5 = 3\n",
    "\n",
    "# There are 128 of these filters\n",
    "num_filters_5 = 128\n",
    "\n",
    "# Fully-connected layer\n",
    "# Number of neurons in fully-connected layer\n",
    "fc_size = 128"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def new_weights(shape):\n",
    "    return tf.Variable(tf.truncated_normal(shape, stddev=np.sqrt(2.0 / shape[0])), name='Weights')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def new_biases(length):\n",
    "    # Equivalent to y intercept\n",
    "    # Constant value carried over across matrix math\n",
    "    return tf.Variable(tf.constant(0.1, shape=[length]), name='Biases')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Helper-function used to summarize the information of the\n",
    "# Weights and Biases in the first fully connected layer\n",
    "def variable_summaries(variable):\n",
    "    with tf.name_scope('Summaries'):\n",
    "        mean = tf.reduce_mean(variable)\n",
    "\n",
    "        tf.summary.scalar('Mean', mean)\n",
    "      \n",
    "        with tf.name_scope('Stddev'):\n",
    "            stddev = tf.sqrt(tf.reduce_mean(tf.square(variable - mean)))\n",
    "        \n",
    "        tf.summary.scalar('stddev', stddev)\n",
    "        tf.summary.scalar('max', tf.reduce_max(variable))\n",
    "        tf.summary.scalar('min', tf.reduce_min(variable))\n",
    "        tf.summary.histogram('Histogram', variable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Has ReLU and pooling built in. So think of it as one block\n",
    "# Usually CNNs have 3 blocks repeated (Conv. layer -> ReLU -> Pooling)\n",
    "\n",
    "def new_conv_layer(input,              # The previous layer\n",
    "                   filter_height,      # Height of each filter\n",
    "                   filter_width,       # Width of each filter\n",
    "                   in_channels,        # Num. channels in prev. layer\n",
    "                   out_channels,       # # Number of filters\n",
    "                   use_pooling=True):  # Use 2x2 max-pooling\n",
    "    \n",
    "    # The out_channels of the previous layer are the in_channels of the next layer\n",
    "\n",
    "    # Shape of the filter-weights for the convolution\n",
    "    # This format is determined by the TensorFlow API\n",
    "    shape = [filter_height, filter_width, in_channels, out_channels]\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=out_channels)\n",
    "\n",
    "    # Create the TensorFlow operation for convolution\n",
    "    # Note the strides are set to 1 in all dimensions\n",
    "    \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",
    "    \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",
    "    \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",
    "    # Rectified Linear Unit (ReLU)\n",
    "    # It calculates max(x, 0) for each input pixel x\n",
    "    \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",
    "    # 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",
    "    # 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": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope(\"Convolutional-layer-1\"):\n",
    "    # Convolutional layer 1\n",
    "    feature_maps_conv_1, weights_conv_1 = new_conv_layer(input=x_image,\n",
    "                                                         filter_height=filter_height_1,\n",
    "                                                         filter_width=filter_width_1,\n",
    "                                                         in_channels=num_channels,\n",
    "                                                         out_channels=num_filters_1,\n",
    "                                                         use_pooling=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'Convolutional-layer-1/Relu:0' shape=(?, 48, 48, 8) dtype=float32>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "feature_maps_conv_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Variable 'Convolutional-layer-1/Weights:0' shape=(3, 3, 1, 8) dtype=float32_ref>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "weights_conv_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope(\"Convolutional-layer-2\"):\n",
    "    # Convolutional layer 2\n",
    "    feature_maps_conv_2, weights_conv_2 = new_conv_layer(input=feature_maps_conv_1,\n",
    "                                                         filter_height=filter_height_2,\n",
    "                                                         filter_width=filter_width_2,\n",
    "                                                         in_channels=num_filters_1,\n",
    "                                                         out_channels=num_filters_2,\n",
    "                                                         use_pooling=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'Convolutional-layer-2/Relu:0' shape=(?, 48, 48, 16) dtype=float32>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "feature_maps_conv_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Variable 'Convolutional-layer-2/Weights:0' shape=(3, 3, 8, 16) dtype=float32_ref>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "weights_conv_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope(\"Convolutional-layer-3\"):\n",
    "    # Convolutional layer 3\n",
    "    feature_maps_conv_3, weights_conv_3 = new_conv_layer(input=feature_maps_conv_2,\n",
    "                                                         filter_height=filter_height_3,\n",
    "                                                         filter_width=filter_width_3,\n",
    "                                                         in_channels=num_filters_2,\n",
    "                                                         out_channels=num_filters_3,\n",
    "                                                         use_pooling=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'Convolutional-layer-3/Relu:0' shape=(?, 48, 48, 32) dtype=float32>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "feature_maps_conv_3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Variable 'Convolutional-layer-3/Weights:0' shape=(3, 3, 16, 32) dtype=float32_ref>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "weights_conv_3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope(\"Convolutional-layer-4\"):\n",
    "    # Convolutional layer 4\n",
    "    feature_maps_conv_4, weights_conv_4 = new_conv_layer(input=feature_maps_conv_3,\n",
    "                                                         filter_height=filter_height_4,\n",
    "                                                         filter_width=filter_width_4,\n",
    "                                                         in_channels=num_filters_3,\n",
    "                                                         out_channels=num_filters_4,\n",
    "                                                         use_pooling=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'Convolutional-layer-4/Relu:0' shape=(?, 48, 48, 64) dtype=float32>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "feature_maps_conv_4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Variable 'Convolutional-layer-4/Weights:0' shape=(3, 3, 32, 64) dtype=float32_ref>"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "weights_conv_4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope(\"Convolutional-layer-5\"):\n",
    "    # Convolutional layer 5\n",
    "    feature_maps_conv_5, weights_conv_5 = new_conv_layer(input=feature_maps_conv_4,\n",
    "                                                         filter_height=filter_height_5,\n",
    "                                                         filter_width=filter_width_5,\n",
    "                                                         in_channels=num_filters_4,\n",
    "                                                         out_channels=num_filters_5,\n",
    "                                                         use_pooling=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'Convolutional-layer-5/MaxPool:0' shape=(?, 24, 24, 128) dtype=float32>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "feature_maps_conv_5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Variable 'Convolutional-layer-5/Weights:0' shape=(3, 3, 64, 128) dtype=float32_ref>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "weights_conv_5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "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, image_height, image_width, num_channels]\n",
    "\n",
    "    # The number of features is: image_height * image_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, image_height * image_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": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "layer_flat, num_features = flatten_layer(feature_maps_conv_5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'Reshape:0' shape=(?, 73728) dtype=float32>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "layer_flat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "73728"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num_features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "def new_fc_layer(input,                # The previous layer\n",
    "                 name,                 # Fully connected layer name\n",
    "                 num_inputs,           # Num. inputs from prev. layer\n",
    "                 num_outputs,          # Num. outputs\n",
    "                 use_summaries=True,  # Use Summaries?\n",
    "                 use_relu=True):       # Use Rectified Linear Unit (ReLU)?\n",
    "    \n",
    "    # Use Summaries?\n",
    "    if use_summaries:\n",
    "        with tf.name_scope(name):\n",
    "            with tf.name_scope('Weights'):\n",
    "                # Create new weights\n",
    "                weights = new_weights(shape=[num_inputs, num_outputs])\n",
    "                variable_summaries(weights)\n",
    "        \n",
    "        with tf.name_scope(name):\n",
    "            with tf.name_scope('Biases'):\n",
    "                # Create new biases\n",
    "                biases = new_biases(length=num_outputs)\n",
    "                variable_summaries(biases)\n",
    "    \n",
    "    # Create new weights and biases without summarize\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": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fully-Connected Layer 1\n",
    "layer_fc_1 = new_fc_layer(input=layer_flat,\n",
    "                          name='Fully-Connected-Layer-1',\n",
    "                          num_inputs=num_features,\n",
    "                          num_outputs=fc_size,\n",
    "                          use_summaries=True,\n",
    "                          use_relu=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'Relu:0' shape=(?, 128) dtype=float32>"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "layer_fc_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fully-Connected Layer 2 (Classes)\n",
    "layer_fc_2 = new_fc_layer(input=layer_fc_1,\n",
    "                          name='Fully-Connected-Layer-2',\n",
    "                          num_inputs=fc_size,\n",
    "                          num_outputs=num_classes,\n",
    "                          use_summaries=False,\n",
    "                          use_relu=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'add_1:0' shape=(?, 7) dtype=float32>"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "layer_fc_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Construct model and encapsulating all ops into scopes, making\n",
    "# Tensorboard's Graph visualization more convenient\n",
    "\n",
    "with tf.name_scope('Model'):\n",
    "    # Normalization of class-number output\n",
    "    y_pred = tf.nn.softmax(layer_fc_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The class-number is the index of the largest element\n",
    "y_pred_cls = tf.argmax(y_pred, dimension=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-45-4ea564f06a7d>:3: softmax_cross_entropy_with_logits (from tensorflow.python.ops.nn_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "\n",
      "Future major versions of TensorFlow will allow gradients to flow\n",
      "into the labels input on backprop by default.\n",
      "\n",
      "See tf.nn.softmax_cross_entropy_with_logits_v2.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Cross-entropy \n",
    "cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits=layer_fc_2,\n",
    "                                                        labels=y_true)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope('Loss'):\n",
    "    # Average of the cross-entropy\n",
    "    loss = tf.reduce_mean(cross_entropy)\n",
    "    \n",
    "    # Create a summary scalar to monitor cost tensor\n",
    "    tf.summary.scalar(\"Loss\", loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope('AdamOptimizer'):\n",
    "    # Optimization method\n",
    "    optimizer = tf.train.AdamOptimizer(learning_rate=1e-3).minimize(loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope('Accuracy'):\n",
    "    # Measures of performance\n",
    "    correct_prediction = tf.equal(y_pred_cls, y_true_cls)\n",
    "\n",
    "    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))\n",
    "    \n",
    "    # Create a summary scalar to monitor accuracy tensor\n",
    "    tf.summary.scalar(\"Accuracy\", accuracy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Total number of learning parameters in the network model: 18973767\n"
     ]
    }
   ],
   "source": [
    "# Calculates the total number of learning parameters\n",
    "total_parameters = 0\n",
    "\n",
    "for variable in tf.trainable_variables():\n",
    "    variable_parameters = 1\n",
    "    \n",
    "    for i in variable.get_shape():\n",
    "        variable_parameters *= i.value\n",
    "        \n",
    "    total_parameters += variable_parameters\n",
    "\n",
    "print(\"\\nTotal number of learning parameters in the network model: %d\" % total_parameters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Saver-object which is used for storing and retrieving\n",
    "# all the variables of the TensorFlow graph\n",
    "saver = tf.train.Saver()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "epochs_completed = 0\n",
    "index_in_epoch = 0\n",
    "num_examples = data_train_images.shape[0]\n",
    "\n",
    "# Serve data by batches\n",
    "def next_batch(batch_size):\n",
    "    \n",
    "    global data_train_images\n",
    "    global data_train_labels \n",
    "    global index_in_epoch\n",
    "    global epochs_completed\n",
    "    \n",
    "    start = index_in_epoch\n",
    "    index_in_epoch += train_batch_size\n",
    "    \n",
    "    # When all trainig data have been already used, it is reorder randomly    \n",
    "    if index_in_epoch > num_examples:\n",
    "        # Finished epoch\n",
    "        epochs_completed += 1\n",
    "        \n",
    "        # Shuffle the data\n",
    "        perm = np.arange(num_examples)\n",
    "        np.random.shuffle(perm)\n",
    "        \n",
    "        data_train_images = data_train_images[perm]\n",
    "        data_train_labels = data_train_labels [perm]\n",
    "        \n",
    "        # Start next epoch\n",
    "        start = 0\n",
    "        index_in_epoch = train_batch_size\n",
    "        \n",
    "        assert train_batch_size <= num_examples\n",
    "    end = index_in_epoch\n",
    "    \n",
    "    return data_train_images[start:end], data_train_labels[start:end]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TensorFlow session\n",
    "# Verify your GPU - Find out which device is use\n",
    "session = tf.Session(config=tf.ConfigProto(log_device_placement=True))\n",
    "\n",
    "# Merge all summaries into a single op\n",
    "merged_summary_op = tf.summary.merge_all()\n",
    "\n",
    "# op to write logs to Tensorboard\n",
    "summary_writer = tf.summary.FileWriter(logs_path, session.graph)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Trying to restore last checkpoint...\n",
      "\n",
      "\n",
      "Failed to restore checkpoint. Initializing variables instead.\n"
     ]
    }
   ],
   "source": [
    "# Restore or initialize variables\n",
    "\n",
    "# We therefore save checkpoints during training so we can continue training at\n",
    "# another time (e.g. during the night), and also for performing analysis later\n",
    "# without having to train the neural network every time we want to use it\n",
    "\n",
    "# If you want to restart the training of the neural network, you have to delete\n",
    "# the checkpoints first\n",
    "\n",
    "# Directory used for the checkpoints\n",
    "save_dir = 'Checkpoints/Extended-CK+/'\n",
    "\n",
    "# Create the directory if it does not exist\n",
    "if not os.path.exists(save_dir):\n",
    "    os.makedirs(save_dir)\n",
    "    \n",
    "# Base-filename for the checkpoints\n",
    "save_path = os.path.join(save_dir, 'Extended-CK+')\n",
    "\n",
    "# First try to restore the latest checkpoint. This may fail and raise an exception e.g.\n",
    "# if such a checkpoint does not exist, or if you have changed the TensorFlow graph\n",
    "\n",
    "try:\n",
    "    print(\"Trying to restore last checkpoint...\\n\")\n",
    "\n",
    "    # Find the latest checkpoint - if any\n",
    "    last_checkpoint_path = tf.train.latest_checkpoint(checkpoint_dir=save_dir)\n",
    "\n",
    "    # Try and load the data in the checkpoint\n",
    "    saver.restore(session, save_path=last_checkpoint_path)\n",
    "\n",
    "    # If we get to this point, the checkpoint was successfully loaded\n",
    "    print(\"\\nRestored checkpoint from\" + last_checkpoint_path)\n",
    "\n",
    "except:\n",
    "    # If the above failed for some reason, simply\n",
    "    # initialize all the variables for the TensorFlow graph\n",
    "    print(\"\\nFailed to restore checkpoint. Initializing variables instead.\")\n",
    "    session.run(tf.global_variables_initializer())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Split the training-set into smaller batches of this size\n",
    "train_batch_size = 128"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Counter for total number of iterations performed so far\n",
    "total_iterations = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Helper-function for performing a number of optimization iterations so as to gradually\n",
    "# improve the variables of the network layers\n",
    "\n",
    "# In each iteration, a new batch of data is selected from the training-set and then\n",
    "# TensorFlow executes the optimizer using those training samples\n",
    "\n",
    "# The progress is printed every 100 iterations\n",
    "def training(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 = 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",
    "        \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 events file\n",
    "            summary_str = session.run(merged_summary_op, feed_dict=feed_dict_train)\n",
    "            summary_writer.add_summary(summary_str, global_step=i)\n",
    "            summary_writer.flush()\n",
    "\n",
    "        # Save a checkpoint to disk every 1000 iterations\n",
    "        if i % 1000 == 0:\n",
    "            # Save all variables of the TensorFlow graph to a checkpoint\n",
    "            # Append the global_step counter to the filename so we save\n",
    "            # the last several checkpoints\n",
    "            saver.save(session, save_path=save_path, global_step=i)\n",
    "\n",
    "            print(\"Saved checkpoint.\")\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": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Helper-function to plot example errors\n",
    "def plot_example_errors(cls_pred, correct):\n",
    "    # This function is called from test() 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": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Helper-function to plot confusion matrix\n",
    "def plot_confusion_matrix(cls_pred):\n",
    "    # This is called from test() 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",
    "    thresh = cm.max() / 2.\n",
    "    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n",
    "        plt.text(j,\n",
    "                 i,\n",
    "                 cm[i, j],\n",
    "                 horizontalalignment='center',\n",
    "                 color='white' if cm[i, j] > thresh else 'black')\n",
    "   \n",
    "    # Make various adjustments to the plot\n",
    "    plt.imshow(cm, interpolation='nearest', cmap='Greys')\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.title('Confusion Matrix')\n",
    "    plt.xlabel('Predicted Label')\n",
    "    plt.ylabel('True Label')\n",
    "    \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Split the test-set into smaller batches of this size\n",
    "test_batch_size = 32"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Helper-function for showing the performance\n",
    "def test(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",
    "\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(\"\\nExample 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": 61,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimization Iteration:      1, Training Accuracy:  20.3%\n",
      "Saved checkpoint.\n",
      "Optimization Iteration:    101, Training Accuracy:  18.0%\n",
      "Optimization Iteration:    201, Training Accuracy:  19.5%\n",
      "Optimization Iteration:    301, Training Accuracy:  26.6%\n",
      "Optimization Iteration:    401, Training Accuracy:  30.5%\n",
      "Optimization Iteration:    501, Training Accuracy:  21.1%\n",
      "Optimization Iteration:    601, Training Accuracy:  35.2%\n",
      "Optimization Iteration:    701, Training Accuracy:  34.4%\n",
      "Optimization Iteration:    801, Training Accuracy:  25.0%\n",
      "Optimization Iteration:    901, Training Accuracy:  25.0%\n",
      "Optimization Iteration:   1001, Training Accuracy:  25.0%\n",
      "Saved checkpoint.\n",
      "Optimization Iteration:   1101, Training Accuracy:  25.8%\n",
      "Optimization Iteration:   1201, Training Accuracy:  34.4%\n",
      "Optimization Iteration:   1301, Training Accuracy:  30.5%\n",
      "Optimization Iteration:   1401, Training Accuracy:  28.1%\n",
      "Optimization Iteration:   1501, Training Accuracy:  32.8%\n",
      "Optimization Iteration:   1601, Training Accuracy:  38.3%\n",
      "Optimization Iteration:   1701, Training Accuracy:  40.6%\n",
      "Optimization Iteration:   1801, Training Accuracy:  38.3%\n",
      "Optimization Iteration:   1901, Training Accuracy:  30.5%\n",
      "Optimization Iteration:   2001, Training Accuracy:  33.6%\n",
      "Saved checkpoint.\n",
      "Optimization Iteration:   2101, Training Accuracy:  43.8%\n",
      "Optimization Iteration:   2201, Training Accuracy:  45.3%\n",
      "Optimization Iteration:   2301, Training Accuracy:  46.9%\n",
      "Optimization Iteration:   2401, Training Accuracy:  43.8%\n",
      "Optimization Iteration:   2501, Training Accuracy:  46.1%\n",
      "Optimization Iteration:   2601, Training Accuracy:  51.6%\n",
      "Optimization Iteration:   2701, Training Accuracy:  54.7%\n",
      "Optimization Iteration:   2801, Training Accuracy:  46.1%\n",
      "Optimization Iteration:   2901, Training Accuracy:  45.3%\n",
      "Optimization Iteration:   3001, Training Accuracy:  48.4%\n",
      "Saved checkpoint.\n",
      "Optimization Iteration:   3101, Training Accuracy:  61.7%\n",
      "Optimization Iteration:   3201, Training Accuracy:  61.7%\n",
      "Optimization Iteration:   3301, Training Accuracy:  55.5%\n",
      "Optimization Iteration:   3401, Training Accuracy:  65.6%\n",
      "Optimization Iteration:   3501, Training Accuracy:  48.4%\n",
      "Optimization Iteration:   3601, Training Accuracy:  48.4%\n",
      "Optimization Iteration:   3701, Training Accuracy:  67.2%\n",
      "Optimization Iteration:   3801, Training Accuracy:  65.6%\n",
      "Optimization Iteration:   3901, Training Accuracy:  66.4%\n",
      "Optimization Iteration:   4001, Training Accuracy:  57.0%\n",
      "Saved checkpoint.\n",
      "Optimization Iteration:   4101, Training Accuracy:  51.6%\n",
      "Optimization Iteration:   4201, Training Accuracy:  68.0%\n",
      "Optimization Iteration:   4301, Training Accuracy:  65.6%\n",
      "Optimization Iteration:   4401, Training Accuracy:  64.8%\n",
      "Optimization Iteration:   4501, Training Accuracy:  60.2%\n",
      "Optimization Iteration:   4601, Training Accuracy:  53.9%\n",
      "Optimization Iteration:   4701, Training Accuracy:  71.1%\n",
      "Optimization Iteration:   4801, Training Accuracy:  68.8%\n",
      "Optimization Iteration:   4901, Training Accuracy:  68.0%\n",
      "Optimization Iteration:   5001, Training Accuracy:  68.8%\n",
      "Saved checkpoint.\n",
      "Optimization Iteration:   5101, Training Accuracy:  57.8%\n",
      "Optimization Iteration:   5201, Training Accuracy:  83.6%\n",
      "Optimization Iteration:   5301, Training Accuracy:  80.5%\n",
      "Optimization Iteration:   5401, Training Accuracy:  70.3%\n",
      "Optimization Iteration:   5501, Training Accuracy:  69.5%\n",
      "Optimization Iteration:   5601, Training Accuracy:  66.4%\n",
      "Optimization Iteration:   5701, Training Accuracy:  70.3%\n",
      "Optimization Iteration:   5801, Training Accuracy:  79.7%\n",
      "Optimization Iteration:   5901, Training Accuracy:  76.6%\n",
      "Optimization Iteration:   6001, Training Accuracy:  72.7%\n",
      "Saved checkpoint.\n",
      "Optimization Iteration:   6101, Training Accuracy:  72.7%\n",
      "Optimization Iteration:   6201, Training Accuracy:  83.6%\n",
      "Optimization Iteration:   6301, Training Accuracy:  84.4%\n",
      "Optimization Iteration:   6401, Training Accuracy:  79.7%\n",
      "Optimization Iteration:   6501, Training Accuracy:  76.6%\n",
      "Optimization Iteration:   6601, Training Accuracy:  76.6%\n",
      "Optimization Iteration:   6701, Training Accuracy:  70.3%\n",
      "Optimization Iteration:   6801, Training Accuracy:  82.8%\n",
      "Optimization Iteration:   6901, Training Accuracy:  85.9%\n",
      "Optimization Iteration:   7001, Training Accuracy:  85.2%\n",
      "Saved checkpoint.\n",
      "Optimization Iteration:   7101, Training Accuracy:  72.7%\n",
      "Optimization Iteration:   7201, Training Accuracy:  74.2%\n",
      "Optimization Iteration:   7301, Training Accuracy:  86.7%\n",
      "Optimization Iteration:   7401, Training Accuracy:  82.8%\n",
      "Optimization Iteration:   7501, Training Accuracy:  86.7%\n",
      "Optimization Iteration:   7601, Training Accuracy:  80.5%\n",
      "Optimization Iteration:   7701, Training Accuracy:  81.2%\n",
      "Optimization Iteration:   7801, Training Accuracy:  85.9%\n",
      "Optimization Iteration:   7901, Training Accuracy:  87.5%\n",
      "Optimization Iteration:   8001, Training Accuracy:  85.2%\n",
      "Saved checkpoint.\n",
      "Optimization Iteration:   8101, Training Accuracy:  87.5%\n",
      "Optimization Iteration:   8201, Training Accuracy:  82.0%\n",
      "Optimization Iteration:   8301, Training Accuracy:  92.2%\n",
      "Optimization Iteration:   8401, Training Accuracy:  87.5%\n",
      "Optimization Iteration:   8501, Training Accuracy:  93.8%\n",
      "Optimization Iteration:   8601, Training Accuracy:  90.6%\n",
      "Optimization Iteration:   8701, Training Accuracy:  86.7%\n",
      "Optimization Iteration:   8801, Training Accuracy:  90.6%\n",
      "Optimization Iteration:   8901, Training Accuracy:  97.7%\n",
      "Optimization Iteration:   9001, Training Accuracy:  91.4%\n",
      "Saved checkpoint.\n",
      "Optimization Iteration:   9101, Training Accuracy:  90.6%\n",
      "Optimization Iteration:   9201, Training Accuracy:  86.7%\n",
      "Optimization Iteration:   9301, Training Accuracy:  93.0%\n",
      "Optimization Iteration:   9401, Training Accuracy:  96.1%\n",
      "Optimization Iteration:   9501, Training Accuracy:  91.4%\n",
      "Optimization Iteration:   9601, Training Accuracy:  91.4%\n",
      "Optimization Iteration:   9701, Training Accuracy:  90.6%\n",
      "Optimization Iteration:   9801, Training Accuracy:  87.5%\n",
      "Optimization Iteration:   9901, Training Accuracy:  98.4%\n",
      "Optimization Iteration:  10001, Training Accuracy:  96.1%\n",
      "Saved checkpoint.\n",
      "Optimization Iteration:  10101, Training Accuracy:  90.6%\n",
      "Optimization Iteration:  10201, Training Accuracy:  93.8%\n",
      "Optimization Iteration:  10301, Training Accuracy:  92.2%\n",
      "Optimization Iteration:  10401, Training Accuracy:  94.5%\n",
      "Optimization Iteration:  10501, Training Accuracy:  95.3%\n",
      "Optimization Iteration:  10601, Training Accuracy:  94.5%\n",
      "Optimization Iteration:  10701, Training Accuracy:  93.0%\n",
      "Optimization Iteration:  10801, Training Accuracy:  93.0%\n",
      "Optimization Iteration:  10901, Training Accuracy:  97.7%\n",
      "Optimization Iteration:  11001, Training Accuracy:  95.3%\n",
      "Saved checkpoint.\n",
      "Optimization Iteration:  11101, Training Accuracy:  97.7%\n",
      "Optimization Iteration:  11201, Training Accuracy:  93.8%\n",
      "Optimization Iteration:  11301, Training Accuracy:  94.5%\n",
      "Optimization Iteration:  11401, Training Accuracy:  96.9%\n",
      "Optimization Iteration:  11501, Training Accuracy:  97.7%\n",
      "Optimization Iteration:  11601, Training Accuracy:  96.9%\n",
      "Optimization Iteration:  11701, Training Accuracy:  92.2%\n",
      "Optimization Iteration:  11801, Training Accuracy:  94.5%\n",
      "Optimization Iteration:  11901, Training Accuracy:  96.1%\n",
      "Optimization Iteration:  12001, Training Accuracy:  98.4%\n",
      "Saved checkpoint.\n",
      "Optimization Iteration:  12101, Training Accuracy:  97.7%\n",
      "Optimization Iteration:  12201, Training Accuracy:  98.4%\n",
      "Optimization Iteration:  12301, Training Accuracy:  96.1%\n",
      "Optimization Iteration:  12401, Training Accuracy:  98.4%\n",
      "Optimization Iteration:  12501, Training Accuracy:  97.7%\n",
      "Optimization Iteration:  12601, Training Accuracy:  96.9%\n",
      "Optimization Iteration:  12701, Training Accuracy:  96.1%\n",
      "Optimization Iteration:  12801, Training Accuracy:  96.9%\n",
      "Optimization Iteration:  12901, Training Accuracy:  98.4%\n",
      "Optimization Iteration:  13001, Training Accuracy:  95.3%\n",
      "Saved checkpoint.\n",
      "Optimization Iteration:  13101, Training Accuracy:  96.1%\n",
      "Optimization Iteration:  13201, Training Accuracy:  96.9%\n",
      "Optimization Iteration:  13301, Training Accuracy:  95.3%\n",
      "Optimization Iteration:  13401, Training Accuracy:  93.8%\n",
      "Optimization Iteration:  13501, Training Accuracy:  97.7%\n",
      "Optimization Iteration:  13601, Training Accuracy:  96.9%\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimization Iteration:  13701, Training Accuracy:  96.9%\n",
      "Optimization Iteration:  13801, Training Accuracy:  99.2%\n",
      "Optimization Iteration:  13901, Training Accuracy:  96.9%\n",
      "Optimization Iteration:  14001, Training Accuracy:  96.9%\n",
      "Saved checkpoint.\n",
      "Optimization Iteration:  14101, Training Accuracy:  95.3%\n",
      "Optimization Iteration:  14201, Training Accuracy: 100.0%\n",
      "Optimization Iteration:  14301, Training Accuracy:  98.4%\n",
      "Optimization Iteration:  14401, Training Accuracy:  96.9%\n",
      "Optimization Iteration:  14501, Training Accuracy: 100.0%\n",
      "Optimization Iteration:  14601, Training Accuracy:  99.2%\n",
      "Optimization Iteration:  14701, Training Accuracy:  99.2%\n",
      "Optimization Iteration:  14801, Training Accuracy:  98.4%\n",
      "Optimization Iteration:  14901, Training Accuracy:  98.4%\n",
      "Optimization Iteration:  15001, Training Accuracy:  98.4%\n",
      "Saved checkpoint.\n",
      "Optimization Iteration:  15101, Training Accuracy:  98.4%\n",
      "Optimization Iteration:  15201, Training Accuracy: 100.0%\n",
      "Optimization Iteration:  15301, Training Accuracy: 100.0%\n",
      "Optimization Iteration:  15401, Training Accuracy: 100.0%\n",
      "Optimization Iteration:  15501, Training Accuracy:  99.2%\n",
      "Optimization Iteration:  15601, Training Accuracy:  97.7%\n",
      "Optimization Iteration:  15701, Training Accuracy:  97.7%\n",
      "Optimization Iteration:  15801, Training Accuracy: 100.0%\n",
      "Optimization Iteration:  15901, Training Accuracy:  99.2%\n",
      "Optimization Iteration:  16001, Training Accuracy:  99.2%\n",
      "Saved checkpoint.\n",
      "Optimization Iteration:  16101, Training Accuracy:  98.4%\n",
      "Optimization Iteration:  16201, Training Accuracy:  99.2%\n",
      "Optimization Iteration:  16301, Training Accuracy:  98.4%\n",
      "Optimization Iteration:  16401, Training Accuracy:  98.4%\n",
      "Optimization Iteration:  16501, Training Accuracy: 100.0%\n",
      "Optimization Iteration:  16601, Training Accuracy:  98.4%\n",
      "Optimization Iteration:  16701, Training Accuracy: 100.0%\n",
      "Optimization Iteration:  16801, Training Accuracy:  99.2%\n",
      "Optimization Iteration:  16901, Training Accuracy:  99.2%\n",
      "Optimization Iteration:  17001, Training Accuracy:  98.4%\n",
      "Saved checkpoint.\n",
      "Optimization Iteration:  17101, Training Accuracy:  98.4%\n",
      "Optimization Iteration:  17201, Training Accuracy: 100.0%\n",
      "Optimization Iteration:  17301, Training Accuracy: 100.0%\n",
      "Optimization Iteration:  17401, Training Accuracy:  99.2%\n",
      "Optimization Iteration:  17501, Training Accuracy: 100.0%\n",
      "Optimization Iteration:  17601, Training Accuracy: 100.0%\n",
      "Optimization Iteration:  17701, Training Accuracy: 100.0%\n",
      "Optimization Iteration:  17801, Training Accuracy: 100.0%\n",
      "Optimization Iteration:  17901, Training Accuracy:  99.2%\n",
      "Optimization Iteration:  18001, Training Accuracy: 100.0%\n",
      "Saved checkpoint.\n",
      "Optimization Iteration:  18101, Training Accuracy:  99.2%\n",
      "Optimization Iteration:  18201, Training Accuracy: 100.0%\n",
      "Optimization Iteration:  18301, Training Accuracy:  99.2%\n",
      "Optimization Iteration:  18401, Training Accuracy:  98.4%\n",
      "Optimization Iteration:  18501, Training Accuracy:  97.7%\n",
      "Optimization Iteration:  18601, Training Accuracy:  99.2%\n",
      "Optimization Iteration:  18701, Training Accuracy:  99.2%\n",
      "Optimization Iteration:  18801, Training Accuracy:  98.4%\n",
      "Optimization Iteration:  18901, Training Accuracy: 100.0%\n",
      "Optimization Iteration:  19001, Training Accuracy: 100.0%\n",
      "Saved checkpoint.\n",
      "Optimization Iteration:  19101, Training Accuracy: 100.0%\n",
      "Optimization Iteration:  19201, Training Accuracy: 100.0%\n",
      "Optimization Iteration:  19301, Training Accuracy: 100.0%\n",
      "Optimization Iteration:  19401, Training Accuracy: 100.0%\n",
      "Optimization Iteration:  19501, Training Accuracy:  96.9%\n",
      "Optimization Iteration:  19601, Training Accuracy:  98.4%\n",
      "Optimization Iteration:  19701, Training Accuracy:  99.2%\n",
      "Optimization Iteration:  19801, Training Accuracy:  99.2%\n",
      "Optimization Iteration:  19901, Training Accuracy:  99.2%\n",
      "Time usage: 0:47:07\n"
     ]
    }
   ],
   "source": [
    "# Performance after 20000 optimization iterations\n",
    "training(num_iterations=20000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on Test-Set: 78.4% (443 / 565)\n",
      "\n",
      "Example errors:\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f6a29654470>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion Matrix:\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f69d0dc9080>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "test(show_example_errors=True,\n",
    "     show_confusion_matrix=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Helper-function for plotting convolutional weights\n",
    "def plot_conv_weights(weights, input_channel=0):\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",
    "    \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",
    "    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(4, 2)\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",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f6a293caf98>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# It is possible to change the visualization of the filter-weights\n",
    "# according to the desired convolutional layer, in this case we\n",
    "# are visualizing the filter-weights of the Convolutional Layer 1\n",
    "plot_conv_weights(weights=weights_conv_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run the command line on Terminal:\n",
    "# tensorboard --logdir=/tmp/tensorflow_logs\n",
    "# Then open http://0.0.0.0:6006/ into your web browser"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Close session\n",
    "session.close()"
   ]
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}