Full Code of Hvass-Labs/TensorFlow-Tutorials for AI

Repository: Hvass-Labs/TensorFlow-Tutorials
Branch: master
Commit: d5f33973570f
Files: 47
Total size: 46.3 MB

Directory structure:
gitextract__divsyn1/

├── .github/
│   └── ISSUE_TEMPLATE.md
├── .gitignore
├── 01_Simple_Linear_Model.ipynb
├── 02_Convolutional_Neural_Network.ipynb
├── 03B_Layers_API.ipynb
├── 03C_Keras_API.ipynb
├── 03_PrettyTensor.ipynb
├── 04_Save_Restore.ipynb
├── 05_Ensemble_Learning.ipynb
├── 06_CIFAR-10.ipynb
├── 07_Inception_Model.ipynb
├── 08_Transfer_Learning.ipynb
├── 09_Video_Data.ipynb
├── 10_Fine-Tuning.ipynb
├── 11_Adversarial_Examples.ipynb
├── 12_Adversarial_Noise_MNIST.ipynb
├── 13B_Visual_Analysis_MNIST.ipynb
├── 13_Visual_Analysis.ipynb
├── 14_DeepDream.ipynb
├── 15_Style_Transfer.ipynb
├── 16_Reinforcement_Learning.ipynb
├── 17_Estimator_API.ipynb
├── 18_TFRecords_Dataset_API.ipynb
├── 19_Hyper-Parameters.ipynb
├── 20_Natural_Language_Processing.ipynb
├── 21_Machine_Translation.ipynb
├── 22_Image_Captioning.ipynb
├── 23_Time-Series-Prediction.ipynb
├── LICENSE
├── README.md
├── cache.py
├── cifar10.py
├── coco.py
├── convert.py
├── dataset.py
├── download.py
├── europarl.py
├── forks.md
├── imdb.py
├── inception.py
├── inception5h.py
├── knifey.py
├── mnist.py
├── reinforcement_learning.py
├── requirements.txt
├── vgg16.py
└── weather.py

================================================
FILE CONTENTS
================================================

================================================
FILE: .github/ISSUE_TEMPLATE.md
================================================
# STOP!

**Please don't waste my time!**

Most of the problems people are having are already described in the [installation instructions](https://github.com/Hvass-Labs/TensorFlow-Tutorials/blob/master/README.md).

You should first make a serious attempt to solve your problem.
If you ask a question that has already been answered elsewhere, or if you do not
give enough details about your problem, then your issue may be closed immediately. 

## Python 3

These tutorials were developed in **Python 3.5** (and higher) and may give strange errors in Python 2.7

## Missing Files

You need to **download the whole repository**, either using `git clone` or as a zip-file. See the [installation instructions](https://github.com/Hvass-Labs/TensorFlow-Tutorials/blob/master/README.md).

## Questions about TensorFlow

General questions about TensorFlow should either be asked on [StackOverflow](http://stackoverflow.com/questions/tagged/tensorflow) or the [official TensorFlow repository](https://github.com/tensorflow/tensorflow/issues).

## Modifications

Questions about modifications or how to use these tutorials on your own data-set should also be asked on [StackOverflow](http://stackoverflow.com/questions/tagged/tensorflow).

Thousands of people are using these tutorials. It is impossible for me to give individual support for your project.

## Suggestions for Changes

The tutorials cannot change too much because it would make the [YouTube videos](https://www.youtube.com/playlist?list=PL9Hr9sNUjfsmEu1ZniY0XpHSzl5uihcXZ) too different from the source-code.

## Requests for New Tutorials

These tutorials were made by a single person on his own time. It took a very long time to
research and produce the tutorials. If a topic is not covered then the best thing is to make
a new tutorial by yourself. All you need is a decent microphone, a screen-grabbing tool, and a
video editor. I used the free version of [DaVinci Resolve](https://www.blackmagicdesign.com/products/davinciresolve).

## Other Issues?

Please carefully read the [installation instructions](https://github.com/Hvass-Labs/TensorFlow-Tutorials/blob/master/README.md) and only open an issue if you are still having problems.


================================================
FILE: .gitignore
================================================
# Various
sandbox*.py

# Data for TensorFlow
data/
inception/
vgg16/
checkpoints/
checkpoints*
logs/
summary/

# PyCharm
.idea/


# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class

# C extensions
*.so

# Distribution / packaging
.Python
env/
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
*.egg-info/
.installed.cfg
*.egg

# PyInstaller
#  Usually these files are written by a python script from a template
#  before PyInstaller builds the exe, so as to inject date/other infos into it.
*.manifest
*.spec

# Installer logs
pip-log.txt
pip-delete-this-directory.txt

# Unit test / coverage reports
htmlcov/
.tox/
.coverage
.coverage.*
.cache
nosetests.xml
coverage.xml
*,cover
.hypothesis/

# Translations
*.mo
*.pot

# Django stuff:
*.log
local_settings.py

# Flask stuff:
instance/
.webassets-cache

# Scrapy stuff:
.scrapy

# Sphinx documentation
docs/_build/

# PyBuilder
target/

# IPython Notebook
.ipynb_checkpoints

# pyenv
.python-version

# celery beat schedule file
celerybeat-schedule

# dotenv
.env

# virtualenv
venv/
ENV/

# Spyder project settings
.spyderproject

# Rope project settings
.ropeproject


================================================
FILE: 01_Simple_Linear_Model.ipynb
================================================
{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TensorFlow Tutorial #01\n",
    "# Simple Linear Model\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",
    "This tutorial demonstrates the basic workflow of using TensorFlow with a simple linear model. After loading the so-called MNIST data-set with images of hand-written digits, we define and optimize a simple mathematical model in TensorFlow. The results are then plotted and discussed.\n",
    "\n",
    "You should be familiar with basic linear algebra, Python and the Jupyter Notebook editor. It also helps if you have a basic understanding of Machine Learning and classification."
   ]
  },
  {
   "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"
   ]
  },
  {
   "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 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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### One-Hot Encoding"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The output-data is loaded as both integer class-numbers and so-called One-Hot encoded arrays. This means the class-numbers have been converted from a single integer to a vector whose length equals the number of possible classes. All elements of the vector are zero except for the $i$'th element which is 1 and means the class is $i$. For example, the One-Hot encoded labels for the first 5 images in the test-set are:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],\n",
       "       [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.y_test[0:5, :]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We also need the classes as integers for various comparisons and performance measures. These can be found from the One-Hot encoded arrays by taking the index of the highest element using the `np.argmax()` function. But this has already been done for us when the data-set was loaded, so we can see the class-number for the first five images in the test-set. Compare these to the One-Hot encoded arrays above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([7, 2, 1, 0, 4])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.y_test_cls[0:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Helper-function 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": 9,
   "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",
    "        ax.set_xlabel(xlabel)\n",
    "        \n",
    "        # Remove ticks from the plot.\n",
    "        ax.set_xticks([])\n",
    "        ax.set_yticks([])\n",
    "        \n",
    "    # Ensure the plot is shown correctly with multiple plots\n",
    "    # in a single Notebook cell.\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot a few images to see if data is correct"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 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 entire purpose of TensorFlow is to have a so-called computational graph that can be executed much more efficiently than if the same calculations were to be performed directly in Python. TensorFlow can be more efficient than NumPy because TensorFlow knows the entire computation graph that must be executed, while NumPy only knows the computation of a single mathematical operation at a time.\n",
    "\n",
    "TensorFlow can also automatically calculate the gradients that are needed to optimize the variables of the graph so as to make the model perform better. This is because the graph is a combination of simple mathematical expressions so the gradient of the entire graph can be calculated using the chain-rule for derivatives.\n",
    "\n",
    "TensorFlow can also take advantage of multi-core CPUs as well as GPUs - and Google has even built special chips just for TensorFlow which are called TPUs (Tensor Processing Units) that are even faster than GPUs.\n",
    "\n",
    "A TensorFlow graph consists of the following parts which will be detailed below:\n",
    "\n",
    "* Placeholder variables used to feed input into the graph.\n",
    "* Model variables that are going to be optimized so as to make the model perform better.\n",
    "* The model which is essentially just a mathematical function that calculates some output given the input in the placeholder variables and the model variables.\n",
    "* A cost measure that can be used to guide the optimization of the variables.\n",
    "* An optimization method which updates the variables of the model.\n",
    "\n",
    "In addition, the TensorFlow graph may also contain various debugging statements e.g. for logging data to be displayed using TensorBoard, which is not covered in this tutorial."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Placeholder variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Placeholder variables serve as the input to the graph that we may change each time we execute the graph. We call this feeding the placeholder variables and it is demonstrated further below.\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 vector or matrix. 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, [None, img_size_flat])"
   ]
  },
  {
   "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": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_true = tf.placeholder(tf.float32, [None, num_classes])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally we have the placeholder variable for the true class of each image in the placeholder variable `x`. These are integers and the dimensionality of this placeholder variable is set to `[None]` which means the placeholder variable is a one-dimensional vector of arbitrary length."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_true_cls = tf.placeholder(tf.int64, [None])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variables to be optimized"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Apart from the placeholder variables that were defined above and which serve as feeding input data into the model, there are also some model variables that must be changed by TensorFlow so as to make the model perform better on the training data.\n",
    "\n",
    "The first variable that must be optimized is called `weights` and is defined here as a TensorFlow variable that must be initialized with zeros and whose shape is `[img_size_flat, num_classes]`, so it is a 2-dimensional tensor (or matrix) with `img_size_flat` rows and `num_classes` columns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "weights = tf.Variable(tf.zeros([img_size_flat, num_classes]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The second variable that must be optimized is called `biases` and is defined as a 1-dimensional tensor (or vector) of length `num_classes`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "biases = tf.Variable(tf.zeros([num_classes]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This simple mathematical model multiplies the images in the placeholder variable `x` with the `weights` and then adds the `biases`.\n",
    "\n",
    "The result is a matrix of shape `[num_images, num_classes]` because `x` has shape `[num_images, img_size_flat]` and `weights` has shape `[img_size_flat, num_classes]`, so the multiplication of those two matrices is a matrix with shape `[num_images, num_classes]` and then the `biases` vector is added to each row of that matrix.\n",
    "\n",
    "Note that the name `logits` is typical TensorFlow terminology, but other people may call the variable something else."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "logits = tf.matmul(x, weights) + biases"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now `logits` is a matrix with `num_images` rows and `num_classes` columns, where the element of the $i$'th row and $j$'th column is an estimate of how likely the $i$'th input image is to be of the $j$'th class.\n",
    "\n",
    "However, these estimates are a bit rough and difficult to interpret because the numbers may be very small or large, so we want to normalize them so that each row of the `logits` matrix sums to one, and each element is limited between zero and one. This is calculated using the so-called softmax function and the result is stored in `y_pred`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = tf.nn.softmax(logits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The predicted class can be calculated from the `y_pred` matrix by taking the index of the largest element in each row."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_cls = tf.argmax(y_pred, axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cost-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 for `weights` and `biases`. To do this we first need to know how well the model currently performs by comparing the predicted output of the model `y_pred` to the desired output `y_true`.\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 `weights` and `biases` of the model.\n",
    "\n",
    "TensorFlow has a built-in function for calculating the cross-entropy. Note that it uses the values of the `logits` because it also calculates the softmax internally."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "cross_entropy = tf.nn.softmax_cross_entropy_with_logits_v2(logits=logits,\n",
    "                                                           labels=y_true)"
   ]
  },
  {
   "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": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "cost = tf.reduce_mean(cross_entropy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Optimization method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have a cost measure that must be minimized, we can then create an optimizer. In this case it is the basic form of Gradient Descent where the step-size is set to 0.5.\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": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.5).minimize(cost)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Performance measures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We need a few more performance measures to display the progress to the user.\n",
    "\n",
    "This is a vector of booleans whether the predicted class equals the true class of each image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "correct_prediction = tf.equal(y_pred_cls, y_true_cls)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This calculates the classification accuracy by first type-casting the vector of booleans to floats, so that False becomes 0 and True becomes 1, and then calculating the average of these numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TensorFlow Run"
   ]
  },
  {
   "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": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "session = tf.Session()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initialize variables\n",
    "\n",
    "The variables for `weights` and `biases` must be initialized before we start optimizing them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "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 use Stochastic Gradient Descent which only uses a small batch of images in each iteration of the optimizer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Function for performing a number of optimization iterations so as to gradually improve the `weights` and `biases` of the model. In each iteration, a new batch of data is selected from the training-set and then TensorFlow executes the optimizer using those training samples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def optimize(num_iterations):\n",
    "    for i in range(num_iterations):\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=batch_size)\n",
    "        \n",
    "        # Put the batch into a dict with the proper names\n",
    "        # for placeholder variables in the TensorFlow graph.\n",
    "        # Note that the placeholder for y_true_cls is not set\n",
    "        # because it is not used during training.\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)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Helper-functions to show performance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dict with the test-set data to be used as input to the TensorFlow graph. Note that we must use the correct names for the placeholder variables in the TensorFlow graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "feed_dict_test = {x: data.x_test,\n",
    "                  y_true: data.y_test,\n",
    "                  y_true_cls: data.y_test_cls}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Function for printing the classification accuracy on the test-set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_accuracy():\n",
    "    # Use TensorFlow to compute the accuracy.\n",
    "    acc = session.run(accuracy, feed_dict=feed_dict_test)\n",
    "    \n",
    "    # Print the accuracy.\n",
    "    print(\"Accuracy on test-set: {0:.1%}\".format(acc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Function for printing and plotting the confusion matrix using scikit-learn."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_confusion_matrix():\n",
    "    # Get the true classifications for the test-set.\n",
    "    cls_true = data.y_test_cls\n",
    "    \n",
    "    # Get the predicted classifications for the test-set.\n",
    "    cls_pred = session.run(y_pred_cls, feed_dict=feed_dict_test)\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.imshow(cm, interpolation='nearest', cmap=plt.cm.Blues)\n",
    "\n",
    "    # Make various adjustments to the plot.\n",
    "    plt.tight_layout()\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": [
    "Function for plotting examples of images from the test-set that have been mis-classified."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_example_errors():\n",
    "    # Use TensorFlow to get a list of boolean values\n",
    "    # whether each test-image has been correctly classified,\n",
    "    # and a list for the predicted class of each image.\n",
    "    correct, cls_pred = session.run([correct_prediction, y_pred_cls],\n",
    "                                    feed_dict=feed_dict_test)\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 the model weights"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Function for plotting the `weights` of the model. 10 images are plotted, one for each digit that the model is trained to recognize."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_weights():\n",
    "    # Get the values for the weights from the TensorFlow variable.\n",
    "    w = session.run(weights)\n",
    "    \n",
    "    # Get the lowest and highest values for the weights.\n",
    "    # This is used to correct the colour intensity across\n",
    "    # the images so they can be compared with each other.\n",
    "    w_min = np.min(w)\n",
    "    w_max = np.max(w)\n",
    "\n",
    "    # Create figure with 3x4 sub-plots,\n",
    "    # where the last 2 sub-plots are unused.\n",
    "    fig, axes = plt.subplots(3, 4)\n",
    "    fig.subplots_adjust(hspace=0.3, wspace=0.3)\n",
    "\n",
    "    for i, ax in enumerate(axes.flat):\n",
    "        # Only use the weights for the first 10 sub-plots.\n",
    "        if i<10:\n",
    "            # Get the weights for the i'th digit and reshape it.\n",
    "            # Note that w.shape == (img_size_flat, 10)\n",
    "            image = w[:, i].reshape(img_shape)\n",
    "\n",
    "            # Set the label for the sub-plot.\n",
    "            ax.set_xlabel(\"Weights: {0}\".format(i))\n",
    "\n",
    "            # Plot the image.\n",
    "            ax.imshow(image, vmin=w_min, vmax=w_max, cmap='seismic')\n",
    "\n",
    "        # Remove ticks from each sub-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": [
    "## Performance before any optimization\n",
    "\n",
    "The accuracy on the test-set is 9.8%. This is because the model has only been initialized and not optimized at all, so it always predicts that the image shows a zero digit, as demonstrated in the plot below, and it turns out that 9.8% of the images in the test-set happens to be zero digits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on test-set: 9.8%\n"
     ]
    }
   ],
   "source": [
    "print_accuracy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_example_errors()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Performance after 1 optimization iteration\n",
    "\n",
    "Already after a single optimization iteration, the model has increased its accuracy on the test-set significantly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimize(num_iterations=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on test-set: 22.2%\n"
     ]
    }
   ],
   "source": [
    "print_accuracy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_example_errors()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The weights can also be plotted as shown below. Positive weights are red and negative weights are blue. These weights can be intuitively understood as image-filters.\n",
    "\n",
    "For example, the weights used to determine if an image shows a zero-digit have a positive reaction (red) to an image of a circle, and  have a negative reaction (blue) to images with content in the centre of the circle.\n",
    "\n",
    "Similarly, the weights used to determine if an image shows a one-digit react positively (red) to a vertical line in the centre of the image, and react negatively (blue) to images with content surrounding that line.\n",
    "\n",
    "Note that the weights mostly look like the digits they're supposed to recognize. This is because only one optimization iteration has been performed so the weights are only trained on 100 images. After training on several thousand images, the weights become more difficult to interpret because they have to recognize many variations of how digits can be written."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 12 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_weights()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Performance after 10 optimization iterations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We have already performed 1 iteration.\n",
    "optimize(num_iterations=9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on test-set: 77.6%\n"
     ]
    }
   ],
   "source": [
    "print_accuracy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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