{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "TPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eoNiO909Cywc"
      },
      "source": [
        "## Lab Introduction\n",
        "This lab will introduce you to using [TensorFlow](https://www.tensorflow.org/) for building multi-layer perceptrons and convolutional neural networks. This is loosely based on the tutorials [here](https://www.tensorflow.org/guide/keras/training_with_built_in_methods). TensorFlow has [excellent documentation](https://www.tensorflow.org/api_docs/python/tf/keras). If you're running this in Colab, you can improve the speed of execution by selecting : Runtime | Change Runtime Type and selecting GPU (graphics processing unit) or [TPU](https://en.wikipedia.org/wiki/Tensor_Processing_Unit)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Qy0u8f9ZIHaQ"
      },
      "source": [
        "## Imports\n",
        "We need to import tensorflow, commonly named as tf.\n",
        "We also use tf.keras and tf.keras.layers a lot as well, so we rename those.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YkbiGFbfaoIH"
      },
      "source": [
        "import tensorflow as tf\n",
        "keras = tf.keras\n",
        "layers = tf.keras.layers\n",
        "# Include numpy for basic stuff\n",
        "import numpy as np\n",
        "# matplotlib allows us to visualise our data.\n",
        "import matplotlib.pyplot as plt\n",
        "# Import a library for displaying models\n",
        "from IPython.display import Image"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lADpUL33aqzB"
      },
      "source": [
        "## Let's get some data\n",
        "For this lab we're going to look at the [MNIST handwritten digit dataset](http://yann.lecun.com/exdb/mnist/). This dataset has been explored for a wide variety of models and serves as a standard benchmark for comparing things. Today we're going to be looking at a digit classification task.\n",
        "1. Look at the size and shape of the data elements. How large are the images? How are the labels stored?\n",
        "2. Use [plt.imshow](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.imshow.html?highlight=imshow#matplotlib.pyplot.imshow) to visualise some examples from the data. Check what the corresponding label for each example is."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 319
        },
        "id": "qESOAFEUbBjs",
        "outputId": "74aaa35d-1505-48f6-9c51-b32d2b48390b"
      },
      "source": [
        "(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()\n",
        "# Print the shapes of the array and the unique label\n",
        "print(x_train.shape, y_train.shape, np.unique(y_test))\n",
        "\n",
        "# Pick an example index\n",
        "example_idx = 0\n",
        "plt.imshow(x_train[example_idx,...],cmap='gray')\n",
        "# Print the label\n",
        "plt.show()\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz\n",
            "11490434/11490434 [==============================] - 0s 0us/step\n",
            "(60000, 28, 28) (60000,) [0 1 2 3 4 5 6 7 8 9]\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZWFV7px3hGTy"
      },
      "source": [
        "## Preparing the data for training\n",
        "To get the data ready for training, it's best to squash the input pixel values to being in the range 0-1. Image data is normally stored using unsigned 8bit integers, so takes value between 0 and 255. We can simply convert to floats and divide by 255.\n",
        "\n",
        "We also hold some data from the test set out for validation, and shuffle the training data (in case the data order could cause some bias).\n",
        "\n",
        "Trace through the code below to understand what's going on.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4eZPB72Hhckz"
      },
      "source": [
        "# Divide the image data to put it in the right range and convert to floating point numbers\n",
        "x_train = x_train.astype(\"float32\") / 255\n",
        "x_test = x_test.astype(\"float32\") / 255\n",
        "# Convert the labels to floating point\n",
        "y_train = y_train.astype(\"float32\")\n",
        "y_test = y_test.astype(\"float32\")\n",
        "\n",
        "# Reserve the last 10,000 samples for validation. We can use these to optimise our hyper-parameters.\n",
        "x_val = x_train[-10000:]\n",
        "y_val = y_train[-10000:]\n",
        "x_train = x_train[:-10000]\n",
        "y_train = y_train[:-10000]\n",
        "\n",
        "# Prepare the training dataset into batches and shuffle the examples\n",
        "train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))\n",
        "train_dataset = train_dataset.shuffle(buffer_size=1024).batch(64)\n",
        "\n",
        "# Prepare the validation dataset into batches\n",
        "val_dataset = tf.data.Dataset.from_tensor_slices((x_val, y_val))\n",
        "val_dataset = val_dataset.batch(64)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UHMkka1BcAc-"
      },
      "source": [
        "## Define an MLP model\n",
        "Firstly, let's try and define a simple MLP model. In TensorFlow, we refer to fully-connected layers as [Dense](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Dense).\n",
        "\n",
        "In this section, we will use the simple [sequential model definition approach](https://www.tensorflow.org/guide/keras/sequential_model). This assumes we have a single input and output array, and we successively apply the model layers (building blocks).\n",
        "\n",
        "Fill in the ? in the section below to create an MLP model and draw a picture of the model."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2n4oyvOublI4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 275
        },
        "outputId": "0d1fb4db-eca0-4a8a-db98-14f35393911a"
      },
      "source": [
        "def build_mlp_model():\n",
        "  # Create an MLP model using the sequential model API\n",
        "  # Note that the Input size relates to the size of each instance, so each image has size 28,28\n",
        "  layers_list = [keras.Input(shape=(28,28), name=\"image\"),\n",
        "                 # First flatten out the spatial component, to make one long vector\n",
        "                 layers.Flatten(),\n",
        "                 # Next add a dense layer with a suitable activation function\n",
        "                 layers.Dense(100, activation='relu'),\n",
        "                 layers.Dense(60, activation='relu'),\n",
        "                 # Finally, add another dense layer which has the same number of units as the number of classes\n",
        "                 # This layer should use a softmax activation, which converts the numbers into class probabilities\n",
        "                 layers.Dense(10, activation='softmax')]\n",
        "\n",
        "  # Create a model based on the layer list\n",
        "  model = keras.Sequential(layers_list)\n",
        "  return model\n",
        "\n",
        "# Create the model\n",
        "mlp_model = build_mlp_model()\n",
        "# Draw a picture of the MLP model details\n",
        "keras.utils.plot_model(mlp_model, \"mlp_model.png\", show_shapes=True)\n",
        "Image(retina=True, filename='mlp_model.png')\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {
            "image/png": {
              "width": 164,
              "height": 258
            }
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Qw4YC1qxKO6p"
      },
      "source": [
        "## Training the model\n",
        "In order to train the model, we need to [compile](https://www.tensorflow.org/api_docs/python/tf/keras/Model#compile) it for training. This involves specifying the loss functions we will use, any \"metrics\" to calculate on the data and the optimizer to use it.\n",
        "\n",
        "1. Read this [section of the tutorial](https://keras.io/api/losses) on building models to identify some suitable losses and metrics to compile the model. Investigate the optimizer choices, and the \"learning_rate\" hyper-parameter.\n",
        "2. Call the model's [fit](https://www.tensorflow.org/api_docs/python/tf/keras/Model#fit) method. To understand what happens in fit and how you can change it, see this [tutorial](https://www.tensorflow.org/guide/keras/customizing_what_happens_in_fit/). Remember an epoch, is the number of times we train the model with every item in the training dataset."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UWf2AHi0c6VY",
        "outputId": "193bdfd8-303b-4b97-87c4-d5a8d00ca7ae"
      },
      "source": [
        "mlp_model.compile(optimizer=keras.optimizers.Adam(learning_rate=0.001), loss=\"sparse_categorical_crossentropy\", metrics=[\"sparse_categorical_accuracy\"])\n",
        "mlp_model.fit(train_dataset, epochs=20, validation_data=val_dataset)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/20\n",
            "782/782 [==============================] - 14s 15ms/step - loss: 0.3271 - sparse_categorical_accuracy: 0.9078 - val_loss: 0.1765 - val_sparse_categorical_accuracy: 0.9496\n",
            "Epoch 2/20\n",
            "782/782 [==============================] - 7s 9ms/step - loss: 0.1424 - sparse_categorical_accuracy: 0.9574 - val_loss: 0.1175 - val_sparse_categorical_accuracy: 0.9667\n",
            "Epoch 3/20\n",
            "782/782 [==============================] - 9s 12ms/step - loss: 0.0972 - sparse_categorical_accuracy: 0.9710 - val_loss: 0.1019 - val_sparse_categorical_accuracy: 0.9700\n",
            "Epoch 4/20\n",
            "782/782 [==============================] - 4s 5ms/step - loss: 0.0749 - sparse_categorical_accuracy: 0.9771 - val_loss: 0.0932 - val_sparse_categorical_accuracy: 0.9727\n",
            "Epoch 5/20\n",
            "782/782 [==============================] - 4s 5ms/step - loss: 0.0586 - sparse_categorical_accuracy: 0.9820 - val_loss: 0.0906 - val_sparse_categorical_accuracy: 0.9744\n",
            "Epoch 6/20\n",
            "782/782 [==============================] - 5s 7ms/step - loss: 0.0473 - sparse_categorical_accuracy: 0.9854 - val_loss: 0.0944 - val_sparse_categorical_accuracy: 0.9740\n",
            "Epoch 7/20\n",
            "782/782 [==============================] - 4s 5ms/step - loss: 0.0378 - sparse_categorical_accuracy: 0.9879 - val_loss: 0.0921 - val_sparse_categorical_accuracy: 0.9748\n",
            "Epoch 8/20\n",
            "782/782 [==============================] - 4s 5ms/step - loss: 0.0300 - sparse_categorical_accuracy: 0.9906 - val_loss: 0.0935 - val_sparse_categorical_accuracy: 0.9755\n",
            "Epoch 9/20\n",
            "782/782 [==============================] - 5s 7ms/step - loss: 0.0249 - sparse_categorical_accuracy: 0.9920 - val_loss: 0.0980 - val_sparse_categorical_accuracy: 0.9752\n",
            "Epoch 10/20\n",
            "782/782 [==============================] - 4s 5ms/step - loss: 0.0238 - sparse_categorical_accuracy: 0.9921 - val_loss: 0.1001 - val_sparse_categorical_accuracy: 0.9756\n",
            "Epoch 11/20\n",
            "782/782 [==============================] - 6s 8ms/step - loss: 0.0188 - sparse_categorical_accuracy: 0.9939 - val_loss: 0.1070 - val_sparse_categorical_accuracy: 0.9755\n",
            "Epoch 12/20\n",
            "782/782 [==============================] - 4s 5ms/step - loss: 0.0165 - sparse_categorical_accuracy: 0.9944 - val_loss: 0.0983 - val_sparse_categorical_accuracy: 0.9766\n",
            "Epoch 13/20\n",
            "782/782 [==============================] - 4s 5ms/step - loss: 0.0158 - sparse_categorical_accuracy: 0.9946 - val_loss: 0.1041 - val_sparse_categorical_accuracy: 0.9756\n",
            "Epoch 14/20\n",
            "782/782 [==============================] - 6s 7ms/step - loss: 0.0131 - sparse_categorical_accuracy: 0.9956 - val_loss: 0.1121 - val_sparse_categorical_accuracy: 0.9766\n",
            "Epoch 15/20\n",
            "782/782 [==============================] - 4s 5ms/step - loss: 0.0111 - sparse_categorical_accuracy: 0.9963 - val_loss: 0.1159 - val_sparse_categorical_accuracy: 0.9738\n",
            "Epoch 16/20\n",
            "782/782 [==============================] - 5s 7ms/step - loss: 0.0129 - sparse_categorical_accuracy: 0.9957 - val_loss: 0.1196 - val_sparse_categorical_accuracy: 0.9759\n",
            "Epoch 17/20\n",
            "782/782 [==============================] - 4s 5ms/step - loss: 0.0095 - sparse_categorical_accuracy: 0.9968 - val_loss: 0.1219 - val_sparse_categorical_accuracy: 0.9753\n",
            "Epoch 18/20\n",
            "782/782 [==============================] - 5s 6ms/step - loss: 0.0097 - sparse_categorical_accuracy: 0.9969 - val_loss: 0.1260 - val_sparse_categorical_accuracy: 0.9763\n",
            "Epoch 19/20\n",
            "782/782 [==============================] - 4s 5ms/step - loss: 0.0093 - sparse_categorical_accuracy: 0.9969 - val_loss: 0.1354 - val_sparse_categorical_accuracy: 0.9736\n",
            "Epoch 20/20\n",
            "782/782 [==============================] - 5s 6ms/step - loss: 0.0120 - sparse_categorical_accuracy: 0.9958 - val_loss: 0.1254 - val_sparse_categorical_accuracy: 0.9763\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<keras.callbacks.History at 0x7f64a795a640>"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uTNm1Vp2dzfM"
      },
      "source": [
        "## Define a convolutional neural network model\n",
        "Let's follow the same procss, but build a convolutional neural network model. We'll also try out the [Functional API](https://www.tensorflow.org/guide/keras/functional). This offers more flexibility than the Sequential API, and makes it easier to use the existing components to make residual blocks.\n",
        "\n",
        "The key layers to use are:\n",
        "+ [layers.Conv2D](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Conv2D)\n",
        "+ [layers.MaxPool2D](https://www.tensorflow.org/api_docs/python/tf/keras/layers/MaxPool2D)\n",
        "\n",
        "Build a suitable convolutional model (don't add too many filters, and stick with a kernel_size of 3 to keep it quick). Remember you'll still want a Dense layer with a softmax activation for the final classification.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 496
        },
        "id": "S-OWWFvbbNXY",
        "outputId": "4c509626-9401-422d-ba28-8e01b3f5bcd6"
      },
      "source": [
        "def build_conv_model():\n",
        "  # Return a convolutional model using the functional API\n",
        "  # Note that the Input size relates to the size of each instance\n",
        "  inputs = keras.Input(shape=(28,28), name=\"image\")\n",
        "  net = inputs\n",
        "  # We need to reshape the data before convolution such that it's grayscale image with 1 channel\n",
        "  # Note we create the object, and then call it\n",
        "  net = layers.Reshape((28,28,1))(net)\n",
        "\n",
        "  # We can also define the layer object, and store it in a Python variable and call it later\n",
        "  # We're more likely to want to do this for layers that contain model weights\n",
        "  conv1 = layers.Conv2D(filters=4, kernel_size=3, padding='same', activation='relu')\n",
        "  net = conv1(net)\n",
        "  net = layers.MaxPool2D()(net)\n",
        "\n",
        "  conv2 = layers.Conv2D(filters=8, kernel_size=3, padding='same', activation='relu')\n",
        "  net = conv2(net)\n",
        "  net = layers.MaxPool2D()(net)\n",
        "\n",
        "  dense1 = layers.Dense(units=84, activation='relu')\n",
        "  # We need to flatten the spatial dimensions before putting it through the dense layers\n",
        "  net = layers.Flatten()(net)\n",
        "  net = dense1(net)\n",
        "  dense2 = layers.Dense(units=10, activation='softmax')\n",
        "  net = dense2(net)\n",
        "\n",
        "  return keras.Model(inputs=inputs, outputs=net)\n",
        "\n",
        "conv_model = build_conv_model()\n",
        "\n",
        "# Draw the network diagram\n",
        "keras.utils.plot_model(conv_model, \"conv_model.png\", show_shapes=True)\n",
        "Image(retina=True, filename='conv_model.png')\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {
            "image/png": {
              "width": 193,
              "height": 479
            }
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u7nHeLJtM0AA"
      },
      "source": [
        "## Train the model\n",
        "Compile and fit the convolutional model, the same way you did with the MLP.\n",
        "1. Experiment with the model architecture and learning rates. See what gives you the best performance on the validation metrics"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iU_IkfMsBUrV",
        "outputId": "24edd887-7d4b-480e-b015-7aac07c9cb6e"
      },
      "source": [
        "conv_model.compile(optimizer=keras.optimizers.Adam(learning_rate=0.001), loss=\"sparse_categorical_crossentropy\", metrics=[\"sparse_categorical_accuracy\"])\n",
        "conv_model.fit(train_dataset, batch_size=64, epochs=20, validation_data=val_dataset)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/20\n",
            "782/782 [==============================] - 25s 30ms/step - loss: 0.4111 - sparse_categorical_accuracy: 0.8782 - val_loss: 0.1566 - val_sparse_categorical_accuracy: 0.9553\n",
            "Epoch 2/20\n",
            "782/782 [==============================] - 24s 31ms/step - loss: 0.1348 - sparse_categorical_accuracy: 0.9590 - val_loss: 0.1085 - val_sparse_categorical_accuracy: 0.9690\n",
            "Epoch 3/20\n",
            "782/782 [==============================] - 24s 31ms/step - loss: 0.0922 - sparse_categorical_accuracy: 0.9715 - val_loss: 0.0852 - val_sparse_categorical_accuracy: 0.9764\n",
            "Epoch 4/20\n",
            "782/782 [==============================] - 22s 29ms/step - loss: 0.0739 - sparse_categorical_accuracy: 0.9774 - val_loss: 0.0724 - val_sparse_categorical_accuracy: 0.9796\n",
            "Epoch 5/20\n",
            "782/782 [==============================] - 24s 31ms/step - loss: 0.0618 - sparse_categorical_accuracy: 0.9815 - val_loss: 0.0646 - val_sparse_categorical_accuracy: 0.9812\n",
            "Epoch 6/20\n",
            "782/782 [==============================] - 24s 30ms/step - loss: 0.0517 - sparse_categorical_accuracy: 0.9839 - val_loss: 0.0615 - val_sparse_categorical_accuracy: 0.9826\n",
            "Epoch 7/20\n",
            "782/782 [==============================] - 25s 32ms/step - loss: 0.0450 - sparse_categorical_accuracy: 0.9858 - val_loss: 0.0617 - val_sparse_categorical_accuracy: 0.9815\n",
            "Epoch 8/20\n",
            "782/782 [==============================] - 27s 35ms/step - loss: 0.0393 - sparse_categorical_accuracy: 0.9877 - val_loss: 0.0633 - val_sparse_categorical_accuracy: 0.9820\n",
            "Epoch 9/20\n",
            "782/782 [==============================] - 24s 30ms/step - loss: 0.0338 - sparse_categorical_accuracy: 0.9892 - val_loss: 0.0596 - val_sparse_categorical_accuracy: 0.9832\n",
            "Epoch 10/20\n",
            "782/782 [==============================] - 23s 29ms/step - loss: 0.0301 - sparse_categorical_accuracy: 0.9909 - val_loss: 0.0573 - val_sparse_categorical_accuracy: 0.9847\n",
            "Epoch 11/20\n",
            "782/782 [==============================] - 25s 32ms/step - loss: 0.0258 - sparse_categorical_accuracy: 0.9918 - val_loss: 0.0587 - val_sparse_categorical_accuracy: 0.9849\n",
            "Epoch 12/20\n",
            "782/782 [==============================] - 24s 31ms/step - loss: 0.0218 - sparse_categorical_accuracy: 0.9932 - val_loss: 0.0605 - val_sparse_categorical_accuracy: 0.9854\n",
            "Epoch 13/20\n",
            "782/782 [==============================] - 24s 31ms/step - loss: 0.0206 - sparse_categorical_accuracy: 0.9934 - val_loss: 0.0619 - val_sparse_categorical_accuracy: 0.9841\n",
            "Epoch 14/20\n",
            "782/782 [==============================] - 23s 30ms/step - loss: 0.0179 - sparse_categorical_accuracy: 0.9945 - val_loss: 0.0671 - val_sparse_categorical_accuracy: 0.9834\n",
            "Epoch 15/20\n",
            "782/782 [==============================] - 24s 31ms/step - loss: 0.0167 - sparse_categorical_accuracy: 0.9946 - val_loss: 0.0662 - val_sparse_categorical_accuracy: 0.9829\n",
            "Epoch 16/20\n",
            "782/782 [==============================] - 24s 31ms/step - loss: 0.0138 - sparse_categorical_accuracy: 0.9956 - val_loss: 0.0583 - val_sparse_categorical_accuracy: 0.9866\n",
            "Epoch 17/20\n",
            "782/782 [==============================] - 25s 32ms/step - loss: 0.0129 - sparse_categorical_accuracy: 0.9956 - val_loss: 0.0617 - val_sparse_categorical_accuracy: 0.9854\n",
            "Epoch 18/20\n",
            "782/782 [==============================] - 26s 33ms/step - loss: 0.0101 - sparse_categorical_accuracy: 0.9966 - val_loss: 0.0621 - val_sparse_categorical_accuracy: 0.9862\n",
            "Epoch 19/20\n",
            "782/782 [==============================] - 25s 32ms/step - loss: 0.0110 - sparse_categorical_accuracy: 0.9963 - val_loss: 0.0728 - val_sparse_categorical_accuracy: 0.9844\n",
            "Epoch 20/20\n",
            "782/782 [==============================] - 26s 33ms/step - loss: 0.0094 - sparse_categorical_accuracy: 0.9968 - val_loss: 0.0811 - val_sparse_categorical_accuracy: 0.9833\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<keras.callbacks.History at 0x7f64a763a370>"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YbvtjpYoA3wu"
      },
      "source": [
        "## Evaluate the models\n",
        "Once we've experimented with various models and tuned our architectures/hyper-parameters on the validation set, we can look at the test data.\n",
        "\n",
        "1. Use the [model.evaluate](https://www.tensorflow.org/api_docs/python/tf/keras/Model#evaluate) method to compare metrics between the models on the test set. See an example  in the section [API overview: a first end-to-end example](https://keras.io/guides/training_with_built_in_methods/). Which models works best on the test data?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hso2RBZvB20-",
        "outputId": "fb5ea9cd-5953-4de3-9856-ca6a3945d04b"
      },
      "source": [
        "# Evaluate the model on the test data using `evaluate`\n",
        "print(\"Evaluate on test data\")\n",
        "results = conv_model.evaluate(x_test, y_test, batch_size=128)\n",
        "print(\"Conv model test loss, test acc:\", results)\n",
        "results = mlp_model.evaluate(x_test, y_test, batch_size=128)\n",
        "print(\"MLP model test loss, test acc:\", results)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Evaluate on test data\n",
            "79/79 [==============================] - 2s 21ms/step - loss: 0.0622 - sparse_categorical_accuracy: 0.9841\n",
            "Conv model test loss, test acc: [0.06215307116508484, 0.9840999841690063]\n",
            "79/79 [==============================] - 0s 3ms/step - loss: 0.1214 - sparse_categorical_accuracy: 0.9743\n",
            "MLP model test loss, test acc: [0.12144602090120316, 0.9743000268936157]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ynvtcZftFTMK"
      },
      "source": [
        "## Switch to a tougher dataset\n",
        "[FashionMNIST](https://www.tensorflow.org/api_docs/python/tf/keras/datasets/fashion_mnist) is similar to MNIST, but contains grayscale images of fashion items. It's a bit tougher, but the images are the same size. Make sure you do the same preprocessing on this dataset.\n",
        "1. Have a go at running your MLP and convolutional models on this dataset. Do they work similarly well on this dataset?\n",
        "2. What changes can you make to get a classification on the validation set above 90%?\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 408
        },
        "id": "nw0zYBR8FV9N",
        "outputId": "3878351c-29c2-4c39-d44b-003570460de8"
      },
      "source": [
        "(x_train, y_train), (x_test, y_test) = keras.datasets.fashion_mnist.load_data()\n",
        "\n",
        "plt.imshow(x_train[0,...],cmap='gray')\n",
        "plt.show()\n",
        "\n",
        "# Divide the image data to put it in the right range and convert to floating point numbers\n",
        "x_train = x_train.astype(\"float32\") / 255\n",
        "x_test = x_test.astype(\"float32\") / 255\n",
        "# Convert the labels to floating point\n",
        "y_train = y_train.astype(\"float32\")\n",
        "y_test = y_test.astype(\"float32\")\n",
        "\n",
        "# Reserve the last 10,000 samples for validation. We can use these to optimise our hyper-parameters.\n",
        "x_val = x_train[-10000:]\n",
        "y_val = y_train[-10000:]\n",
        "x_train = x_train[:-10000]\n",
        "y_train = y_train[:-10000]\n",
        "\n",
        "# Prepare the training dataset\n",
        "train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))\n",
        "train_dataset = train_dataset.shuffle(buffer_size=1024).batch(64)\n",
        "\n",
        "# Prepare the validation dataset\n",
        "val_dataset = tf.data.Dataset.from_tensor_slices((x_val, y_val))\n",
        "val_dataset = val_dataset.batch(64)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-labels-idx1-ubyte.gz\n",
            "29515/29515 [==============================] - 0s 0us/step\n",
            "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-images-idx3-ubyte.gz\n",
            "26421880/26421880 [==============================] - 0s 0us/step\n",
            "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-labels-idx1-ubyte.gz\n",
            "5148/5148 [==============================] - 0s 0us/step\n",
            "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-images-idx3-ubyte.gz\n",
            "4422102/4422102 [==============================] - 0s 0us/step\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mjH72fYTo3sh",
        "outputId": "9ad482cc-3859-41c9-9cc3-da4f79f5330e"
      },
      "source": [
        "\n",
        "# Remember to build a fresh model, the old weights won't be relevant\n",
        "conv_model = build_conv_model()\n",
        "\n",
        "# Fit the model parameters\n",
        "\n",
        "conv_model.compile(optimizer=keras.optimizers.Adam(learning_rate=0.001), loss=\"sparse_categorical_crossentropy\", metrics=[\"sparse_categorical_accuracy\"])\n",
        "conv_model.fit(train_dataset, batch_size=64, epochs=20, validation_data=val_dataset)\n",
        "\n",
        "results = conv_model.evaluate(x_test, y_test, batch_size=128)\n",
        "print(\"Conv model test loss, test acc:\", results)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/20\n",
            "782/782 [==============================] - 27s 33ms/step - loss: 0.5765 - sparse_categorical_accuracy: 0.7967 - val_loss: 0.4383 - val_sparse_categorical_accuracy: 0.8418\n",
            "Epoch 2/20\n",
            "782/782 [==============================] - 26s 34ms/step - loss: 0.3934 - sparse_categorical_accuracy: 0.8602 - val_loss: 0.4248 - val_sparse_categorical_accuracy: 0.8455\n",
            "Epoch 3/20\n",
            "782/782 [==============================] - 25s 32ms/step - loss: 0.3515 - sparse_categorical_accuracy: 0.8731 - val_loss: 0.3482 - val_sparse_categorical_accuracy: 0.8735\n",
            "Epoch 4/20\n",
            "782/782 [==============================] - 27s 35ms/step - loss: 0.3286 - sparse_categorical_accuracy: 0.8808 - val_loss: 0.3342 - val_sparse_categorical_accuracy: 0.8787\n",
            "Epoch 5/20\n",
            "782/782 [==============================] - 24s 30ms/step - loss: 0.3099 - sparse_categorical_accuracy: 0.8873 - val_loss: 0.3277 - val_sparse_categorical_accuracy: 0.8806\n",
            "Epoch 6/20\n",
            "782/782 [==============================] - 25s 33ms/step - loss: 0.2967 - sparse_categorical_accuracy: 0.8911 - val_loss: 0.3141 - val_sparse_categorical_accuracy: 0.8876\n",
            "Epoch 7/20\n",
            "782/782 [==============================] - 25s 32ms/step - loss: 0.2830 - sparse_categorical_accuracy: 0.8975 - val_loss: 0.3010 - val_sparse_categorical_accuracy: 0.8900\n",
            "Epoch 8/20\n",
            "782/782 [==============================] - 25s 32ms/step - loss: 0.2709 - sparse_categorical_accuracy: 0.9014 - val_loss: 0.3135 - val_sparse_categorical_accuracy: 0.8847\n",
            "Epoch 9/20\n",
            "782/782 [==============================] - 25s 32ms/step - loss: 0.2612 - sparse_categorical_accuracy: 0.9047 - val_loss: 0.2979 - val_sparse_categorical_accuracy: 0.8933\n",
            "Epoch 10/20\n",
            "782/782 [==============================] - 25s 32ms/step - loss: 0.2513 - sparse_categorical_accuracy: 0.9078 - val_loss: 0.2895 - val_sparse_categorical_accuracy: 0.8972\n",
            "Epoch 11/20\n",
            "782/782 [==============================] - 27s 35ms/step - loss: 0.2426 - sparse_categorical_accuracy: 0.9116 - val_loss: 0.3101 - val_sparse_categorical_accuracy: 0.8868\n",
            "Epoch 12/20\n",
            "782/782 [==============================] - 27s 34ms/step - loss: 0.2352 - sparse_categorical_accuracy: 0.9139 - val_loss: 0.2873 - val_sparse_categorical_accuracy: 0.8978\n",
            "Epoch 13/20\n",
            "782/782 [==============================] - 24s 31ms/step - loss: 0.2281 - sparse_categorical_accuracy: 0.9150 - val_loss: 0.2898 - val_sparse_categorical_accuracy: 0.8960\n",
            "Epoch 14/20\n",
            "782/782 [==============================] - 25s 32ms/step - loss: 0.2209 - sparse_categorical_accuracy: 0.9183 - val_loss: 0.2959 - val_sparse_categorical_accuracy: 0.8974\n",
            "Epoch 15/20\n",
            "782/782 [==============================] - 23s 29ms/step - loss: 0.2135 - sparse_categorical_accuracy: 0.9212 - val_loss: 0.3009 - val_sparse_categorical_accuracy: 0.8935\n",
            "Epoch 16/20\n",
            "782/782 [==============================] - 26s 33ms/step - loss: 0.2093 - sparse_categorical_accuracy: 0.9222 - val_loss: 0.2926 - val_sparse_categorical_accuracy: 0.8963\n",
            "Epoch 17/20\n",
            "782/782 [==============================] - 25s 32ms/step - loss: 0.2015 - sparse_categorical_accuracy: 0.9258 - val_loss: 0.2932 - val_sparse_categorical_accuracy: 0.8987\n",
            "Epoch 18/20\n",
            "782/782 [==============================] - 23s 30ms/step - loss: 0.1966 - sparse_categorical_accuracy: 0.9267 - val_loss: 0.2948 - val_sparse_categorical_accuracy: 0.8991\n",
            "Epoch 19/20\n",
            "782/782 [==============================] - 28s 36ms/step - loss: 0.1891 - sparse_categorical_accuracy: 0.9300 - val_loss: 0.3059 - val_sparse_categorical_accuracy: 0.8951\n",
            "Epoch 20/20\n",
            "782/782 [==============================] - 27s 35ms/step - loss: 0.1838 - sparse_categorical_accuracy: 0.9316 - val_loss: 0.2951 - val_sparse_categorical_accuracy: 0.9001\n",
            "79/79 [==============================] - 2s 21ms/step - loss: 0.3045 - sparse_categorical_accuracy: 0.8970\n",
            "Conv model test loss, test acc: [0.30447232723236084, 0.8970000147819519]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7lavD5hPDZJT"
      },
      "source": [
        "## Extension Tasks\n",
        "You don't need to do these extensions, but you'll certainly learn something by giving them a go.\n",
        "1. Find some validation/test examples where your model performs poorly. Visualise those examples. Can you think of a reason why it doesn't work well for those ones? Is it ambiguous?\n",
        "1. Look at a more complex (but still low-resolution) image dataset. [CIFAR 10](https://www.tensorflow.org/api_docs/python/tf/keras/datasets/cifar10) or [CIFAR 100](https://www.tensorflow.org/api_docs/python/tf/keras/datasets/cifar100).\n",
        "3. Try including [BatchNorm](https://www.tensorflow.org/api_docs/python/tf/keras/layers/BatchNormalization) or [Dropout](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Dropout)\n",
        "3. Implement a residual block, you could try sub-classing the [Layer base class](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Layer)\n",
        "4. Learn how to use [Tensorboard](https://www.tensorflow.org/tensorboard), an excellent tool for visualising your model training, which you can either run from [Colab](https://colab.research.google.com/github/tensorflow/tensorboard/blob/master/docs/tensorboard_in_notebooks.ipynb) or install on your local machine\n"
      ]
    }
  ]
}