l04c01_image_classification_with_cnns (1).ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "_ckMIh7O7s6D"
      },
      "outputs": [],
      "source": [
        "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n",
        "# you may not use this file except in compliance with the License.\n",
        "# You may obtain a copy of the License at\n",
        "#\n",
        "# https://www.apache.org/licenses/LICENSE-2.0\n",
        "#\n",
        "# Unless required by applicable law or agreed to in writing, software\n",
        "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
        "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
        "# See the License for the specific language governing permissions and\n",
        "# limitations under the License."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "vasWnqRgy1H4"
      },
      "outputs": [],
      "source": [
        "#@title MIT License\n",
        "#\n",
        "# Copyright (c) 2017 François Chollet\n",
        "#\n",
        "# Permission is hereby granted, free of charge, to any person obtaining a\n",
        "# copy of this software and associated documentation files (the \"Software\"),\n",
        "# to deal in the Software without restriction, including without limitation\n",
        "# the rights to use, copy, modify, merge, publish, distribute, sublicense,\n",
        "# and/or sell copies of the Software, and to permit persons to whom the\n",
        "# Software is furnished to do so, subject to the following conditions:\n",
        "#\n",
        "# The above copyright notice and this permission notice shall be included in\n",
        "# all copies or substantial portions of the Software.\n",
        "#\n",
        "# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n",
        "# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n",
        "# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL\n",
        "# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n",
        "# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n",
        "# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n",
        "# DEALINGS IN THE SOFTWARE."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6uQP3ZbC8J5o"
      },
      "source": [
        "##### Copyright 2018 The TensorFlow Authors."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jYysdyb-CaWM"
      },
      "source": [
        "# Image Classification with Convolutional Neural Networks"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S5Uhzt6vVIB2"
      },
      "source": [
        "<table class=\"tfo-notebook-buttons\" align=\"left\">\n",
        "  <td>\n",
        "    <a target=\"_blank\" href=\"https://colab.research.google.com/github/tensorflow/examples/blob/master/courses/udacity_intro_to_tensorflow_for_deep_learning/l04c01_image_classification_with_cnns.ipynb\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" />Run in Google Colab</a>\n",
        "  </td>\n",
        "  <td>\n",
        "    <a target=\"_blank\" href=\"https://github.com/tensorflow/examples/blob/master/courses/udacity_intro_to_tensorflow_for_deep_learning/l04c01_image_classification_with_cnns.ipynb\"><img src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\" />View source on GitHub</a>\n",
        "  </td>\n",
        "</table>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FbVhjPpzn6BM"
      },
      "source": [
        "In this tutorial, we'll build and train a neural network to classify images of clothing, like sneakers and shirts.\n",
        "\n",
        "It's okay if you don't understand everything. This is a fast-paced overview of a complete TensorFlow program, with explanations along the way. The goal is to get the general sense of a TensorFlow project, not to catch every detail.\n",
        "\n",
        "This guide uses [tf.keras](https://www.tensorflow.org/guide/keras), a high-level API to build and train models in TensorFlow."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H0tMfX2vR0uD"
      },
      "source": [
        "## Install and import dependencies\n",
        "\n",
        "We'll need [TensorFlow Datasets](https://www.tensorflow.org/datasets/), an API that simplifies downloading and accessing datasets, and provides several sample datasets to work with. We're also using a few helper libraries."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5HDhfftMGc_i"
      },
      "outputs": [],
      "source": [
        "import tensorflow as tf"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "uusvhUp9Gg37"
      },
      "outputs": [],
      "source": [
        "# Import TensorFlow Datasets\n",
        "import tensorflow_datasets as tfds\n",
        "tfds.disable_progress_bar()\n",
        "\n",
        "# Helper libraries\n",
        "import math\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UXZ44qIaG0Ru"
      },
      "outputs": [],
      "source": [
        "import logging\n",
        "logger = tf.get_logger()\n",
        "logger.setLevel(logging.ERROR)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yR0EdgrLCaWR"
      },
      "source": [
        "## Import the Fashion MNIST dataset"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DLdCchMdCaWQ"
      },
      "source": [
        "This guide uses the [Fashion MNIST](https://github.com/zalandoresearch/fashion-mnist) dataset, which contains 70,000 grayscale images in 10 categories. The images show individual articles of clothing at low resolution (28 $\\times$ 28 pixels), as seen here:\n",
        "\n",
        "<table>\n",
        "  <tr><td>\n",
        "    <img src=\"https://tensorflow.org/images/fashion-mnist-sprite.png\"\n",
        "         alt=\"Fashion MNIST sprite\" width=\"600\">\n",
        "  </td></tr>\n",
        "  <tr><td align=\"center\">\n",
        "    <b>Figure 1.</b> <a href=\"https://github.com/zalandoresearch/fashion-mnist\">Fashion-MNIST samples</a> (by Zalando, MIT License).<br/>&nbsp;\n",
        "  </td></tr>\n",
        "</table>\n",
        "\n",
        "Fashion MNIST is intended as a drop-in replacement for the classic [MNIST](http://yann.lecun.com/exdb/mnist/) dataset—often used as the \"Hello, World\" of machine learning programs for computer vision. The MNIST dataset contains images of handwritten digits (0, 1, 2, etc) in an identical format to the articles of clothing we'll use here.\n",
        "\n",
        "This guide uses Fashion MNIST for variety, and because it's a slightly more challenging problem than regular MNIST. Both datasets are relatively small and are used to verify that an algorithm works as expected. They're good starting points to test and debug code.\n",
        "\n",
        "We will use 60,000 images to train the network and 10,000 images to evaluate how accurately the network learned to classify images. You can access the Fashion MNIST directly from TensorFlow, using the [Datasets](https://www.tensorflow.org/datasets) API:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7MqDQO0KCaWS",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "322d8ae5-dd51-4ec4-f846-6f8cd522c2a4"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[1mDownloading and preparing dataset 29.45 MiB (download: 29.45 MiB, generated: 36.42 MiB, total: 65.87 MiB) to ~/tensorflow_datasets/fashion_mnist/3.0.1...\u001b[0m\n",
            "\u001b[1mDataset fashion_mnist downloaded and prepared to ~/tensorflow_datasets/fashion_mnist/3.0.1. Subsequent calls will reuse this data.\u001b[0m\n"
          ]
        }
      ],
      "source": [
        "dataset, metadata = tfds.load('fashion_mnist', as_supervised=True, with_info=True)\n",
        "train_dataset, test_dataset = dataset['train'], dataset['test']"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t9FDsUlxCaWW"
      },
      "source": [
        "Loading the dataset returns metadata as well as a *training dataset* and *test dataset*.\n",
        "\n",
        "* The model is trained using `train_dataset`.\n",
        "* The model is tested against `test_dataset`.\n",
        "\n",
        "The images are 28 $\\times$ 28 arrays, with pixel values in the range `[0, 255]`. The *labels* are an array of integers, in the range `[0, 9]`. These correspond to the *class* of clothing the image represents:\n",
        "\n",
        "<table>\n",
        "  <tr>\n",
        "    <th>Label</th>\n",
        "    <th>Class</th>\n",
        "  </tr>\n",
        "  <tr>\n",
        "    <td>0</td>\n",
        "    <td>T-shirt/top</td>\n",
        "  </tr>\n",
        "  <tr>\n",
        "    <td>1</td>\n",
        "    <td>Trouser</td>\n",
        "  </tr>\n",
        "    <tr>\n",
        "    <td>2</td>\n",
        "    <td>Pullover</td>\n",
        "  </tr>\n",
        "    <tr>\n",
        "    <td>3</td>\n",
        "    <td>Dress</td>\n",
        "  </tr>\n",
        "    <tr>\n",
        "    <td>4</td>\n",
        "    <td>Coat</td>\n",
        "  </tr>\n",
        "    <tr>\n",
        "    <td>5</td>\n",
        "    <td>Sandal</td>\n",
        "  </tr>\n",
        "    <tr>\n",
        "    <td>6</td>\n",
        "    <td>Shirt</td>\n",
        "  </tr>\n",
        "    <tr>\n",
        "    <td>7</td>\n",
        "    <td>Sneaker</td>\n",
        "  </tr>\n",
        "    <tr>\n",
        "    <td>8</td>\n",
        "    <td>Bag</td>\n",
        "  </tr>\n",
        "    <tr>\n",
        "    <td>9</td>\n",
        "    <td>Ankle boot</td>\n",
        "  </tr>\n",
        "</table>\n",
        "\n",
        "Each image is mapped to a single label. Since the *class names* are not included with the dataset, store them here to use later when plotting the images:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "IjnLH5S2CaWx"
      },
      "outputs": [],
      "source": [
        "class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',\n",
        "               'Sandal',      'Shirt',   'Sneaker',  'Bag',   'Ankle boot']"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Brm0b_KACaWX"
      },
      "source": [
        "### Explore the data\n",
        "\n",
        "Let's explore the format of the dataset before training the model. The following shows there are 60,000 images in the training set, and 10000 images in the test set:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MaOTZxFzi48X",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c42f82b1-98a3-4d66-d7f5-46da7ecfb829"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Number of training examples: 60000\n",
            "Number of test examples:     10000\n"
          ]
        }
      ],
      "source": [
        "num_train_examples = metadata.splits['train'].num_examples\n",
        "num_test_examples = metadata.splits['test'].num_examples\n",
        "print(\"Number of training examples: {}\".format(num_train_examples))\n",
        "print(\"Number of test examples:     {}\".format(num_test_examples))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ES6uQoLKCaWr"
      },
      "source": [
        "## Preprocess the data\n",
        "\n",
        "The value of each pixel in the image data is an integer in the range `[0,255]`. For the model to work properly, these values need to be normalized to the range `[0,1]`. So here we create a normalization function, and then apply it to each image in the test and train datasets."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nAsH3Zm-76pB"
      },
      "outputs": [],
      "source": [
        "def normalize(images, labels):\n",
        "  images = tf.cast(images, tf.float32)\n",
        "  images /= 255\n",
        "  return images, labels\n",
        "\n",
        "# The map function applies the normalize function to each element in the train\n",
        "# and test datasets\n",
        "train_dataset =  train_dataset.map(normalize)\n",
        "test_dataset  =  test_dataset.map(normalize)\n",
        "\n",
        "# The first time you use the dataset, the images will be loaded from disk\n",
        "# Caching will keep them in memory, making training faster\n",
        "train_dataset =  train_dataset.cache()\n",
        "test_dataset  =  test_dataset.cache()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lIQbEiJGXM-q"
      },
      "source": [
        "### Explore the processed data\n",
        "\n",
        "Let's plot an image to see what it looks like."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "oSzE9l7PjHx0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 269
        },
        "outputId": "bdb378e3-2f84-4476-9f10-bf5b833bbb7f"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAS4AAAD8CAYAAADJwUnTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAa40lEQVR4nO3df5BdZZ3n8fc3CSHkBxFoNuTn5gcRNxPWiF2BVWSgZKxAqdGaKYpQ46LDTKzSWOOOu7XobimytSUzO+q6VRS77ZgiTqkMOyCmmEgmMhnZ0QXSYfiRHzDE2Jl0yE8TSEhIYpLv/nFPuzfdfb/P7b637z1P83lVdeXe+73PuU+f7v7mnOd8z/OYuyMikpMx7e6AiMhQKXGJSHaUuEQkO0pcIpIdJS4RyY4Sl4hkR4lLREaMma02swNmtqVG3Mzsf5jZDjN70cyuqWe7SlwiMpIeBJYF8VuAhcXXSuCBejaqxCUiI8bdnwIOB29ZDnzXK54G3mFm01PbHdesDtajo6PD586d28qPHBWOHj0axg8ePFgzNmnSpGZ35zzHjx8P4xdddFHN2IwZM5rdnbe9np4eDh06ZI1sw8yGcjvNVuBk1fMud+8aQvuZwO6q573Fa3ujRg0lLjNbBnwLGAv8hbvfF71/7ty5dHd3N/KRWTp79mwYHzt2bBhfv359GO/qqv170tnZGbYdN66x/7t+/vOfh/Grr766Zuzee+9t6LNTt6uZNfT3m6XUz3sEnHT3ln/osE8VzWwscD+Vc9RFwAozW9SsjolI+5hZXV9NsAeYXfV8VvFaqJExrqXADnff6e6ngYeonK+KSObGjBlT11cTrAX+bXF18TrgDXcPTxOhsVPFwc5Nr+3/JjNbSeVqAXPmzGng40SkVZp1mm1mPwBuBDrMrBf4CnABgLv/T2AdcCuwAzgBfKqe7Y744HwxUNcF0NnZqTl0REquiaeBuPuKRNyBzw51u40krmGdm4pI+ZX9wkYjJ6mbgIVmNs/MxgO3UzlfFZHMtXBwfliGfcTl7mfMbBWwnko5xGp339q0npVMdOk99QNMlTukrFmzJoxHtXFRHRXA2rXx/zUTJ04M4wsWLAjjO3furBl78803w7aTJ08O46n9PpKz+5b9iKRRZf/+Ghrjcvd1VAbXRGSUMLNmXTEcMS2tnBeRPIzqIy4RGZ2UuEQkO0pcIpIdJS4RyYoG50UkSzriGiUa+UE+/vjjYTw1Ncyvf/3rMH7kyJGasRtuuCFse9NNNzUU37hxYxjfsmXQGXsB+NznPhe2veOOO8L4zTffHMYb+Zm93Vd4V+ISkewocYlIVtp9O089lLhEZAAlLhHJjq4qikh2dMQlIlnRGFcLjfSKL4899ljN2LPPPhu2TS3hlZo6JrVyy+HDtZete+mll8K2P/nJT8L4W2+9Fcb37dsXxq+//vqasdTqR48++mgYf+KJJ8J4NC3OV7/61bBto1PmlP0PP6Xs/R81iUtEmkeJS0Syo8F5EcmKxrhEJEtKXCKSHSUuEcmOEpeIZEeJq0XOnTsXxlNLhG3fvj2MR/VOV1xxRdi2o6MjjKfquFLLeM2aNatmbMqUKWHbK6+8Moynri4tXbo0jJ88eTKMR6ZOndrQtn/5y1/WjH3ta18L237xi18M46OZJhIUkSzpiEtEsqPEJSLZUeISkayoAFVEsqTEJSLZ0VVFEcmOjrhaJFWnlfLII4+E8UmTJg172ydOnAjjqeXHUjVqjbSdO3duGJ8wYUIYT9VSnTp1qmYsNR9X6mea+t6i+rbUPGKN9i1no36My8x6gGPAWeCMu8cz3olIFsqeuJpxInuTuy9R0hIZPfqOulJfdW5rmZm9YmY7zOzuQeJzzGyjmf2jmb1oZremtjlqThVFpHmaNThvZmOB+4HfAXqBTWa21t23Vb3tPwMPu/sDZrYIWAfMDfvXYL8c+Fsz22xmK2t0fKWZdZtZ98GDBxv8OBEZafUebdV5xLUU2OHuO939NPAQsLzfexy4uHg8FXgttdFGj7iud/c9ZvYvgA1m9rK7P3Vej9y7gC6Azs7OeIUBESmFIYxxdZhZd9XzruJvvs9MYHfV817g2n7buIfKAdDngEnAzakPbShxufue4t8DZvZDKtn1qbiViJTdEBLXoSaMb68AHnT3r5vZvwH+0swWu3vNy8bDPlU0s0lmNqXvMfAhYMtwtyci5dHEU8U9wOyq57OK16rdBTwM4O7/F5gAhHNBNXLENQ34YdH5ccD33T1e6K7Ejh49GsajH9KxY8ca+uxo/b/UZ0O8xl9q/b9ULVTqs1PrLkafn9pvUQ0YwOnTp8N4VHuXaptaj3LJkiVhPPd1F5vYv03AQjObRyVh3Q7c0e89/wx8EHjQzP4VlcQVDogPO3G5+07g3cNtLyLl1MyJBN39jJmtAtYDY4HV7r7VzO4Fut19LfAF4Ntm9u+oDNR/0hOZX+UQIjJAM48I3X0dlRKH6te+XPV4G/D+oWxTiUtEBij7qawSl4gMoMQlIlkZ9TdZi8jopMRVEgcOHAjje/fuDePz58+vGUtNgbJr164wPm/evDDeyJQ6qWlpUiUH48bFvyIXXnhhGI+m7Entt9SUOcePHw/jjUw9s2HDhjCeKoco+x9+iiYSFJHslD3xKnGJyHk0xiUiWVLiEpHsKHGJSHY0OC8iWdEYl4hkSYmrJDZu3BjGUzVBEydOrBnr6ekJ2zYy/UrqsyGuVxrpOq7UKUVUx5XqW2q/7N+/P4y/+eabNWOXXXZZ2Pbll18O46OdEpeIZEeJS0Syo8QlIllp5kSCI0WJS0QG0BGXiGRHiUtEsqPEJSJZUQFqiWzbti2Mv+Md7wjjV1xxRc1YaomvZ599Noxfe23/hX3Pl6o5iuq4UnVYqSXCUkunXXzxxWE8quNKDQCn6uNef/31MP6+972vZiy1rFpq24cOHQrjHR3hsoClp8QlItnRVUURyYpOFUUkS0pcIpIdJS4RyY4Sl4hkRbf8iEiWdMRVEkeOHAnjqR9UVI909OjRsO327dvDeG9vbxifMmVKGI/quFJzWqXWHkzVqKVE+y2aLwvgueeeC+ObNm0K41F9XNQvSNd5/exnPwvjy5cvD+NlV/bElTweNLPVZnbAzLZUvXapmW0ws1eLfy8Z2W6KSCv1lUSkvtqlnhPZB4Fl/V67G3jS3RcCTxbPRWSUyD5xuftTwOF+Ly8H1hSP1wAfa3K/RKRN6k1a7Uxcwx3jmubue4vH+4Bptd5oZiuBlQBz5swZ5seJSCuV/apiw71zdwc8iHe5e6e7d15++eWNfpyItEDZj7iGm7j2m9l0gOLfA83rkoi0WzMTl5ktM7NXzGyHmQ06Hm5mt5nZNjPbambfT21zuIlrLXBn8fhO4EfD3I6IlEwzx7jMbCxwP3ALsAhYYWaL+r1nIfBF4P3u/lvA51PbTY5xmdkPgBuBDjPrBb4C3Ac8bGZ3AbuA25LfQZul1k2cOXNmGJ86dWrNWGruplRN0K5du8L4/Pnzw/jJkydrxlL1SpUz/drOnj0bxg8ciA+2Dx48GMYj0fcF6XnKrrvuupqx1H5Jfd+pdRdVx/UbS4Ed7r6z2O5DVC7uVU+Q90fA/e5+BMDdk2dwycTl7itqhD6YaisieRrC4HyHmXVXPe9y966q5zOB3VXPe4H+lcHvBDCznwFjgXvc/YnoQ982lfMiUr8hHHEdcvfOBj9uHLCQypndLOApM7va3WueypT7mqeItFyT67j2ALOrns8qXqvWC6x191+7+y+Bf6KSyGpS4hKRAZqYuDYBC81snpmNB26ncnGv2mNUjrYwsw4qp447o43qVFFEBmjW4Ly7nzGzVcB6KuNXq919q5ndC3S7+9oi9iEz2wacBf6Du/8q2q4Sl4gM0MziUndfB6zr99qXqx478CfFV13eNokrNa1N6nak6LJ+aomvxYsXh/HU1DGnT58O4xMnTqwZmzBhQtg2VaqRKhtILesWfW+pcodU31MlLps3b64ZS03nk+pbqoQlZ5pIUESyVPb5uJS4RGQAJS4RyY4Sl4hkR4lLRLLS7ilr6qHEJSID6KqiiGRHR1wtsnv37jCeWqZr0aJFYXz//v01Y6lapsmTJ4fxVB1Xql7pxIkTNWOpOqzUZ6dq1FL1UNGUP2+88UbY9vDh/ksdnO/qq68O49HyZ+9+97vDtqnvK/UzyZ0Sl4hkRWNcIpIlJS4RyY4G50UkOzriEpGsaIxLRLKkxCUi2VHiapFUHVeq7iZVr7Rp06aasQ9/+MNh21S9UlSHBelfomjptFQ9Ump5sgsvvDCMT5kyJYxHdVypecZSA8Q33XRTGI/quLZt21YzVo9Gll3LgRKXiGRFEwmKSJZ0xCUi2VHiEpHsKHGJSHaUuEQkKypAFZEs6apii6TqalLzcV1++eVhPKqHuu6668K2GzZsCOON/pJEc25dcMEFw25bT/uzZ88Ou31q26nautmzZ4fxqI4rtc7m+PHjw3iqfe7KfsSV/Isxs9VmdsDMtlS9do+Z7TGz54uvW0e2myLSSn2ni6mvdqnnv/oHgWWDvP5Nd19SfK0bJC4iGao3abUzcSVPFd39KTObO/JdEZGyyP5UMbDKzF4sTiUvqfUmM1tpZt1m1j3a7+8SGS3GjBlT11fb+jfMdg8AC4AlwF7g67Xe6O5d7t7p7p2pAXARKYfsTxUH4+6/WfLGzL4NPN60HolIW7U7KdVjWEdcZja96unHgS213isi+cn+iMvMfgDcCHSYWS/wFeBGM1sCONADfHoE+1iXVF3NoUOHwnhqzqxINOcUxGsyAnR2dobx1LqN0Vxjp06dCtum6rguuuiihtpHdV6XXFJzaBSAq666Koy/8MILYXzBggU1Y6+99lrYNlUjlvq+c1f2I656riquGOTl74xAX0SkJLJPXCLy9pLDRILl7p2ItEUzx7jMbJmZvWJmO8zs7uB9v2tmbmbx2AlKXCIyiGYlLjMbC9wP3AIsAlaY2aJB3jcF+GPgmXr6p8QlIgM08YhrKbDD3Xe6+2ngIWD5IO/7L8CfAifr2agSl4gMMITE1dF3Z0zxtbLfpmYC1Utw9RavVX/WNcBsd/+bevs3agbnoylMAObMmRPGUyUHs2bNqhn71a9+FbZNLcOVmnIntURYtMTYhAkTwrYnT9b1H1xNqWltou8tNW1N6meWKjOJpKbUede73hXGf/zjH4fxM2fOhPFx48r7pzfEGq1D7p4ckwo+awzwDeCTQ2lX3r0nIm3TxKuKe4DqorhZxWt9pgCLgb8vkuUVwFoz+6i7d9faqBKXiAzQxDquTcBCM5tHJWHdDtzRF3T3N4COqs/9e+DfR0kLNMYlIoNo1uC8u58BVgHrge3Aw+6+1czuNbOPDrd/OuISkfM0+z7EYqLRdf1e+3KN995YzzaVuERkAN3yIyLZKfstP0pcInKedk9ZU49Rk7hS09qk6mqef/75YbffuXNn2PbcuXNhPLUU1okTJ8J4NMVKarqe1P+sqXqjaEqd1Oen9ktqxtyXX345jEc/l9Q+7+npCeNHjx4N46lpb8pcxwU6VRSRDClxiUh2lLhEJDtKXCKSlRwmElTiEpEBdMQlItlR4hKR7ChxtUhqR8+dOzeMp5bC2r17d83Y008/HbZdvHhxGE8tbzZjxowwHs25laqVOnDgQBhP1YFNnTo1jEfLm0XziEF6SbnUHGqvvPJKzdgNN9wQtp02bVoYT82hdvjw4TA+c+bMMN5OKkAVkSxpcF5EsqMjLhHJjhKXiGRFY1wikiUlLhHJjhKXiGQn+6uKZjYb+C4wDXCgy92/ZWaXAn8FzAV6gNvcPZ4UawS9+uqrYfyyyy4L41GdFsT1TL29vWHbVB1X6pcktW5jtEZgat6p1LxRqTUdx44dG8ajdRtTtU4TJ04M46m1Effs2VMzdvDgwbBt6vcl9TNJzQ+nOq7G1JNWzwBfcPdFwHXAZ81sEXA38KS7LwSeLJ6LyCjQrFV+Rkoycbn7Xnd/rnh8jMoSQzOB5cCa4m1rgI+NVCdFpLXKnriGNMZlZnOB9wDPANPcfW8R2kflVFJERoGynyrWnbjMbDLwCPB5dz9a/Y25u5vZoDeemdlKYCXAnDlzGuutiLRE2RNXXZcOzOwCKknre+7+aPHyfjObXsSnA4PerevuXe7e6e6dqcUPRKT9+iYSrOerXZKfbJXU+x1gu7t/oyq0FrizeHwn8KPmd09E2mE0jHG9H/gE8JKZ9a3h9SXgPuBhM7sL2AXcNjJdrE8q+8+aNSuMv/Od7wzj0dQ1qUvnqaWoUiUJF198cRiPlso6depU2Da19NmxY8fCeOqyfzR1TTTlDaRLFlL7df78+TVjqTKP1JQ5s2fPDuOp/VJ2ZT9VTCYud/8HoNZ38cHmdkdEyiD7xCUiby/tPg2shxKXiAyQ/S0/IvL2oyMuEcmOEpeIZEVjXCKSJSWuFklNkZKqVzp+/HgYf+aZZ2rGUnVWUT0RwObNm8P4woULw3hHR0fN2JkzZ8K2v/jFL8J4avmx1PcW1ZFF9WcA+/btC+OpWqxo6pkdO3aEbRcsWDDsbQPs2rUrjH/gAx8I4+3WzMRlZsuAbwFjgb9w9/v6xf8E+EMqM9EcBP7A3cMdWO5LByLSFs265cfMxgL3A7cAi4AVxbRY1f4R6HT3fw38NfBnyf4N+TsSkVGt3tt96jwqWwrscPed7n4aeIjKlFi/4e4b3b3vlOhpIL7NhVF0qigizTOEU8UOM+uuet7l7l1Vz2cC1dML9wLXBtu7C/hx6kOVuERkgCEkrkPu3tmkz/x9oBP47dR7lbhEZIAmDs7vAarvSJ9VvNb/824G/hPw2+4ezwyAEpeIDKKJiWsTsNDM5lFJWLcDd/T7rPcA/wtY5u6DzuvXnxKXiJynbyLBZnD3M2a2ClhPpRxitbtvNbN7gW53Xwv8N2Ay8L+LhPnP7v7RaLujJnG9/vrrYXzy5MlhPDW3UxRP1Uql6pVSM8Nu2bIljEfzWqX+50wtL5aqf3vhhRfC+NmzZ2vGzp07F7adMmVKGE/NFRYtX5badmrps9R8XW+99VYYL7tm1nG5+zpgXb/Xvlz1+OahbnPUJC4RaR5VzotIdpS4RCQruslaRLKkiQRFJDs64hKR7ChxiUhWNMbVQqk6rNQafnv37g3jUT3TRz7ykbBtqg4rZcaMGWE8qsVK7ZfXXnttWH3qc+mll4bxqG+pGrHt27eH8dRamO9973trxp588smw7c03x6VFqT/s1PdWdkpcIpIdJS4RyY6uKopIVjTGJSJZUuISkewocYlIdpS4RCQ72ScuM5sNfBeYBjiVyfC/ZWb3AH9EZR00gC8V8+60xcSJE8N4an6l1JxZV155Zc3YZz7zmbBtyu7du8P4G2+8EcaPHDlSMzZp0qSw7auvvhrGU1eXUvNajR8/vmZs+vTpYduZM2eG8dR6lpGf/vSnYTxV35bar6l1F8usmRMJjpR6jrjOAF9w9+fMbAqw2cw2FLFvuvufj1z3RKQdsj/icve9wN7i8TEz205lySERGaXKnriGdDxoZnOB9wB969GvMrMXzWy1mV1So81KM+s2s+6DBw8O9hYRKZkmLgg7IupOXGY2GXgE+Ly7HwUeABYAS6gckX19sHbu3uXune7emZpbXUTar8krWY+Iuq4qmtkFVJLW99z9UQB3318V/zbw+Ij0UERaruyD88neWSWtfgfY7u7fqHq9+pLQx4HGpkAQkdIYDUdc7wc+AbxkZs8Xr30JWGFmS6iUSPQAnx6RHtapp6cnjEfLZAHs2rUrjJ8+fXqoXarb7NmzG4o34pprrhmxbZdZqjwmtdxdyqlTycWYS63sg/P1XFX8B2Cw76JtNVsiMnLafTRVD1XOi8gASlwikh0lLhHJymi55UdE3mZ0xCUi2VHiEpHsKHG1yK233hrGe3t7w3iqrudTn/rUkPvUx92H3RbSNWiRaHmweqR+gc+cOTNi226075GrrroqjO/fvz+Mp8aAUsublZ0Sl4hkRXVcIpIlXVUUkezoiEtEslP2xFXu40ERablmz8dlZsvM7BUz22Fmdw8Sv9DM/qqIP1NMWBpS4hKRAZqVuMxsLHA/cAuwiMqsMov6ve0u4Ii7Xwl8E/jT1HaVuERkgDFjxtT1VYelwA533+nup4GHgOX93rMcWFM8/mvgg5bIitZojdFQmNlBoHriqw7gUMs6MDRl7VtZ+wXq23A1s2//0t0bmiPdzJ6g0qd6TABOVj3vcveuqm39HrDM3f+weP4J4Fp3X1X1ni3Fe3qL578o3lNzn7R0cL7/DjWzbnfvbGUf6lXWvpW1X6C+DVfZ+ubuy9rdhxSdKorISNoDVE/hO6t4bdD3mNk4YCoQrqirxCUiI2kTsNDM5pnZeOB2YG2/96wF7iwe/x7wd54Yw2p3HVdX+i1tU9a+lbVfoL4NV5n71hB3P2Nmq4D1wFhgtbtvNbN7gW53X0tlMZ6/NLMdwGEqyS3U0sF5EZFm0KmiiGRHiUtEstOWxJW6BaCdzKzHzF4ys+fNrLvNfVltZgeKOpe+1y41sw1m9mrx7yUl6ts9Zran2HfPm1k8SdrI9W22mW00s21mttXM/rh4va37LuhXKfZbTlo+xlXcAvBPwO8AvVSuOqxw920t7UgNZtYDdEbFby3syw3Am8B33X1x8dqfAYfd/b4i6V/i7v+xJH27B3jT3f+81f3p17fpwHR3f87MpgCbgY8Bn6SN+y7o122UYL/lpB1HXPXcAiCAuz9F5SpLterbI9ZQ+cVvuRp9KwV33+vuzxWPjwHbgZm0ed8F/ZIhakfimgnsrnreS7l+eA78rZltNrOV7e7MIKa5+97i8T5gWjs7M4hVZvZicSrZltPYasVMA+8BnqFE+65fv6Bk+63sNDg/0PXufg2Vu9k/W5wSlVJRpFemepYHgAXAEmAv8PV2dsbMJgOPAJ9396PVsXbuu0H6Var9loN2JK56bgFoG3ffU/x7APghlVPbMtlfjJX0jZkcaHN/fsPd97v7WXc/B3ybNu47M7uASnL4nrs/Wrzc9n03WL/KtN9y0Y7EVc8tAG1hZpOKQVPMbBLwIWBL3Krlqm+PuBP4URv7cp6+pFD4OG3ad8WUKN8Btrv7N6pCbd13tfpVlv2Wk7ZUzheXe/87//8WgP/a8k4MwszmUznKgsrtUN9vZ9/M7AfAjVSmGNkPfAV4DHgYmENliqDb3L3lg+Q1+nYjldMdB3qAT1eNKbWyb9cD/wd4CThXvPwlKuNJbdt3Qb9WUIL9lhPd8iMi2dHgvIhkR4lLRLKjxCUi2VHiEpHsKHGJSHaUuEQkO0pcIpKd/wd1HmZizou7cQAAAABJRU5ErkJggg==\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "# Take a single image, and remove the color dimension by reshaping\n",
        "for image, label in test_dataset.take(1):\n",
        "  break\n",
        "image = image.numpy().reshape((28,28))\n",
        "\n",
        "# Plot the image - voila a piece of fashion clothing\n",
        "plt.figure()\n",
        "plt.imshow(image, cmap=plt.cm.binary)\n",
        "plt.colorbar()\n",
        "plt.grid(False)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ee638AlnCaWz"
      },
      "source": [
        "Display the first 25 images from the *training set* and display the class name below each image. Verify that the data is in the correct format and we're ready to build and train the network."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "oZTImqg_CaW1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 589
        },
        "outputId": "86065e19-16c9-49b9-a0e2-fcd35284d31f"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x720 with 25 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "plt.figure(figsize=(10,10))\n",
        "i = 0\n",
        "for (image, label) in test_dataset.take(25):\n",
        "    image = image.numpy().reshape((28,28))\n",
        "    plt.subplot(5,5,i+1)\n",
        "    plt.xticks([])\n",
        "    plt.yticks([])\n",
        "    plt.grid(False)\n",
        "    plt.imshow(image, cmap=plt.cm.binary)\n",
        "    plt.xlabel(class_names[label])\n",
        "    i += 1\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "59veuiEZCaW4"
      },
      "source": [
        "## Build the model\n",
        "\n",
        "Building the neural network requires configuring the layers of the model, then compiling the model."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Gxg1XGm0eOBy"
      },
      "source": [
        "### Setup the layers\n",
        "\n",
        "The basic building block of a neural network is the *layer*. A layer extracts a representation from the data fed into it. Hopefully, a series of connected layers results in a representation that is meaningful for the problem at hand.\n",
        "\n",
        "Much of deep learning consists of chaining together simple layers. Most layers, like `tf.keras.layers.Dense`, have internal parameters which are adjusted (\"learned\") during training."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9ODch-OFCaW4"
      },
      "outputs": [],
      "source": [
        "model = tf.keras.Sequential([\n",
        "    tf.keras.layers.Conv2D(32, (3,3), padding='same', activation=tf.nn.relu,\n",
        "                           input_shape=(28, 28, 1)),\n",
        "    tf.keras.layers.MaxPooling2D((2, 2), strides=2),\n",
        "    tf.keras.layers.Conv2D(64, (3,3), padding='same', activation=tf.nn.relu),\n",
        "    tf.keras.layers.MaxPooling2D((2, 2), strides=2),\n",
        "    tf.keras.layers.Flatten(),\n",
        "    tf.keras.layers.Dense(128, activation=tf.nn.relu),\n",
        "    tf.keras.layers.Dense(10, activation=tf.nn.softmax)\n",
        "])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gut8A_7rCaW6"
      },
      "source": [
        "This network layers are:\n",
        "\n",
        "* **\"convolutions\"** `tf.keras.layers.Conv2D and MaxPooling2D`— Network start with two pairs of Conv/MaxPool. The first layer is a Conv2D filters (3,3) being applied to the input image, retaining the original image size by using padding, and creating 32 output (convoluted) images (so this layer creates 32 convoluted images of the same size as input). After that, the 32 outputs are reduced in size using a MaxPooling2D (2,2) with a stride of 2. The next Conv2D also has a (3,3) kernel, takes the 32 images as input and creates 64 outputs which are again reduced in size by a MaxPooling2D layer. So far in the course, we have described what a Convolution does, but we haven't yet covered how you chain multiples of these together. We will get back to this in lesson 4 when we use color images. At this point, it's enough if you understand the kind of operation a convolutional filter performs\n",
        "\n",
        "* **output** `tf.keras.layers.Dense` — A 128-neuron, followed by 10-node *softmax* layer. Each node represents a class of clothing. As in the previous layer, the final layer takes input from the 128 nodes in the layer before it, and outputs a value in the range `[0, 1]`, representing the probability that the image belongs to that class. The sum of all 10 node values is 1.\n",
        "\n",
        "> Note: Using `softmax` activation and `SparseCategoricalCrossentropy()` has issues and which are patched by the `tf.keras` model. A safer approach, in general, is to use a linear output (no activation function) with `SparseCategoricalCrossentropy(from_logits=True)`.\n",
        "\n",
        "\n",
        "### Compile the model\n",
        "\n",
        "Before the model is ready for training, it needs a few more settings. These are added during the model's *compile* step:\n",
        "\n",
        "\n",
        "* *Loss function* — An algorithm for measuring how far the model's outputs are from the desired output. The goal of training is this measures loss.\n",
        "* *Optimizer* —An algorithm for adjusting the inner parameters of the model in order to minimize loss.\n",
        "* *Metrics* —Used to monitor the training and testing steps. The following example uses *accuracy*, the fraction of the images that are correctly classified."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Lhan11blCaW7"
      },
      "outputs": [],
      "source": [
        "model.compile(optimizer='adam',\n",
        "              loss=tf.keras.losses.SparseCategoricalCrossentropy(),\n",
        "              metrics=['accuracy'])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qKF6uW-BCaW-"
      },
      "source": [
        "## Train the model\n",
        "\n",
        "First, we define the iteration behavior for the train dataset:\n",
        "1. Repeat forever by specifying `dataset.repeat()` (the `epochs` parameter described below limits how long we perform training).\n",
        "2. The `dataset.shuffle(60000)` randomizes the order so our model cannot learn anything from the order of the examples.\n",
        "3. And `dataset.batch(32)` tells `model.fit` to use batches of 32 images and labels when updating the model variables.\n",
        "\n",
        "Training is performed by calling the `model.fit` method:\n",
        "1. Feed the training data to the model using `train_dataset`.\n",
        "2. The model learns to associate images and labels.\n",
        "3. The `epochs=5` parameter limits training to 5 full iterations of the training dataset, so a total of 5 * 60000 = 300000 examples.\n",
        "\n",
        "(Don't worry about `steps_per_epoch`, the requirement to have this flag will soon be removed.)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "o_Dp8971McQ1"
      },
      "outputs": [],
      "source": [
        "BATCH_SIZE = 32\n",
        "train_dataset = train_dataset.cache().repeat().shuffle(num_train_examples).batch(BATCH_SIZE)\n",
        "test_dataset = test_dataset.cache().batch(BATCH_SIZE)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xvwvpA64CaW_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a26462e4-0ccc-4182-f368-d97e224c4898"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/10\n",
            "1875/1875 [==============================] - 23s 4ms/step - loss: 0.3887 - accuracy: 0.8584\n",
            "Epoch 2/10\n",
            "1875/1875 [==============================] - 6s 3ms/step - loss: 0.2560 - accuracy: 0.9068\n",
            "Epoch 3/10\n",
            "1875/1875 [==============================] - 6s 3ms/step - loss: 0.2076 - accuracy: 0.9233\n",
            "Epoch 4/10\n",
            "1875/1875 [==============================] - 6s 3ms/step - loss: 0.1732 - accuracy: 0.9354\n",
            "Epoch 5/10\n",
            "1875/1875 [==============================] - 6s 3ms/step - loss: 0.1502 - accuracy: 0.9449\n",
            "Epoch 6/10\n",
            "1875/1875 [==============================] - 6s 3ms/step - loss: 0.1307 - accuracy: 0.9515\n",
            "Epoch 7/10\n",
            "1875/1875 [==============================] - 6s 3ms/step - loss: 0.1074 - accuracy: 0.9598\n",
            "Epoch 8/10\n",
            "1875/1875 [==============================] - 6s 3ms/step - loss: 0.0875 - accuracy: 0.9681\n",
            "Epoch 9/10\n",
            "1875/1875 [==============================] - 6s 3ms/step - loss: 0.0771 - accuracy: 0.9717\n",
            "Epoch 10/10\n",
            "1875/1875 [==============================] - 6s 3ms/step - loss: 0.0632 - accuracy: 0.9769\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<keras.callbacks.History at 0x7feff02074d0>"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ],
      "source": [
        "model.fit(train_dataset, epochs=10, steps_per_epoch=math.ceil(num_train_examples/BATCH_SIZE))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W3ZVOhugCaXA"
      },
      "source": [
        "As the model trains, the loss and accuracy metrics are displayed. This model reaches an accuracy of about 0.97 (or 97%) on the training data."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oEw4bZgGCaXB"
      },
      "source": [
        "## Evaluate accuracy\n",
        "\n",
        "Next, compare how the model performs on the test dataset. Use all examples we have in the test dataset to assess accuracy."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "VflXLEeECaXC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "97019562-6fb5-43e2-aa1e-c067047dc0e4"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "313/313 [==============================] - 2s 5ms/step - loss: 0.3551 - accuracy: 0.9158\n",
            "Accuracy on test dataset: 0.9157999753952026\n"
          ]
        }
      ],
      "source": [
        "test_loss, test_accuracy = model.evaluate(test_dataset, steps=math.ceil(num_test_examples/32))\n",
        "print('Accuracy on test dataset:', test_accuracy)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yWfgsmVXCaXG"
      },
      "source": [
        "As it turns out, the accuracy on the test dataset is smaller than the accuracy on the training dataset. This is completely normal, since the model was trained on the `train_dataset`. When the model sees images it has never seen during training, (that is, from the `test_dataset`), we can expect performance to go down. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xsoS7CPDCaXH"
      },
      "source": [
        "## Make predictions and explore\n",
        "\n",
        "With the model trained, we can use it to make predictions about some images."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Ccoz4conNCpl"
      },
      "outputs": [],
      "source": [
        "for test_images, test_labels in test_dataset.take(1):\n",
        "  test_images = test_images.numpy()\n",
        "  test_labels = test_labels.numpy()\n",
        "  predictions = model.predict(test_images)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Gl91RPhdCaXI",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9151242e-c3cd-4ce7-fd1e-3af33305a238"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(32, 10)"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ],
      "source": [
        "predictions.shape\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x9Kk1voUCaXJ"
      },
      "source": [
        "Here, the model has predicted the probability of each label for each image in the testing set. Let's take a look at the first prediction:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3DmJEUinCaXK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d7d36d58-d65a-40e5-a751-de8b6263cbed"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([2.8862412e-09, 6.1620604e-11, 6.2223371e-05, 5.7749081e-09,\n",
              "       8.4125258e-02, 2.9207520e-10, 9.1581231e-01, 7.8049553e-14,\n",
              "       1.3710189e-07, 3.2694814e-08], dtype=float32)"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ],
      "source": [
        "predictions[0]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-hw1hgeSCaXN"
      },
      "source": [
        "A prediction is an array of 10 numbers. These describe the \"confidence\" of the model that the image corresponds to each of the 10 different articles of clothing. We can see which label has the highest confidence value:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qsqenuPnCaXO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a0a7e0fa-7dae-4da1-b2b2-0b4fcee80373"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ],
      "source": [
        "np.argmax(predictions[0])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E51yS7iCCaXO"
      },
      "source": [
        "So the model is usually most confident that this image is a Shirt, or `class_names[6]`. Let's check the label:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Sd7Pgsu6CaXP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3aaafa60-18fa-45d4-e49f-e433c9e42f9c"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ],
      "source": [
        "test_labels[0]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ygh2yYC972ne"
      },
      "source": [
        "We can graph this to look at the full set of 10 class predictions"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DvYmmrpIy6Y1"
      },
      "outputs": [],
      "source": [
        "def plot_image(i, predictions_array, true_labels, images):\n",
        "  predictions_array, true_label, img = predictions_array[i], true_labels[i], images[i]\n",
        "  plt.grid(False)\n",
        "  plt.xticks([])\n",
        "  plt.yticks([])\n",
        "  \n",
        "  plt.imshow(img[...,0], cmap=plt.cm.binary)\n",
        "\n",
        "  predicted_label = np.argmax(predictions_array)\n",
        "  if predicted_label == true_label:\n",
        "    color = 'blue'\n",
        "  else:\n",
        "    color = 'red'\n",
        "  \n",
        "  plt.xlabel(\"{} {:2.0f}% ({})\".format(class_names[predicted_label],\n",
        "                                100*np.max(predictions_array),\n",
        "                                class_names[true_label]),\n",
        "                                color=color)\n",
        "\n",
        "def plot_value_array(i, predictions_array, true_label):\n",
        "  predictions_array, true_label = predictions_array[i], true_label[i]\n",
        "  plt.grid(False)\n",
        "  plt.xticks([])\n",
        "  plt.yticks([])\n",
        "  thisplot = plt.bar(range(10), predictions_array, color=\"#777777\")\n",
        "  plt.ylim([0, 1])\n",
        "  predicted_label = np.argmax(predictions_array)\n",
        "  \n",
        "  thisplot[predicted_label].set_color('red')\n",
        "  thisplot[true_label].set_color('blue')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d4Ov9OFDMmOD"
      },
      "source": [
        "Let's look at the 0th image, predictions, and prediction array. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "HV5jw-5HwSmO"
      },
      "outputs": [],
      "source": [
        "i = 0\n",
        "plt.figure(figsize=(6,3))\n",
        "plt.subplot(1,2,1)\n",
        "plot_image(i, predictions, test_labels, test_images)\n",
        "plt.subplot(1,2,2)\n",
        "plot_value_array(i, predictions, test_labels)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Ko-uzOufSCSe"
      },
      "outputs": [],
      "source": [
        "i = 12\n",
        "plt.figure(figsize=(6,3))\n",
        "plt.subplot(1,2,1)\n",
        "plot_image(i, predictions, test_labels, test_images)\n",
        "plt.subplot(1,2,2)\n",
        "plot_value_array(i, predictions, test_labels)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kgdvGD52CaXR"
      },
      "source": [
        "Let's plot several images with their predictions. Correct prediction labels are blue and incorrect prediction labels are red. The number gives the percent (out of 100) for the predicted label. Note that it can be wrong even when very confident. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hQlnbqaw2Qu_"
      },
      "outputs": [],
      "source": [
        "# Plot the first X test images, their predicted label, and the true label\n",
        "# Color correct predictions in blue, incorrect predictions in red\n",
        "num_rows = 5\n",
        "num_cols = 3\n",
        "num_images = num_rows*num_cols\n",
        "plt.figure(figsize=(2*2*num_cols, 2*num_rows))\n",
        "for i in range(num_images):\n",
        "  plt.subplot(num_rows, 2*num_cols, 2*i+1)\n",
        "  plot_image(i, predictions, test_labels, test_images)\n",
        "  plt.subplot(num_rows, 2*num_cols, 2*i+2)\n",
        "  plot_value_array(i, predictions, test_labels)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R32zteKHCaXT"
      },
      "source": [
        "Finally, use the trained model to make a prediction about a single image. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yRJ7JU7JCaXT"
      },
      "outputs": [],
      "source": [
        "# Grab an image from the test dataset\n",
        "img = test_images[0]\n",
        "\n",
        "print(img.shape)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vz3bVp21CaXV"
      },
      "source": [
        "`tf.keras` models are optimized to make predictions on a *batch*, or collection, of examples at once. So even though we're using a single image, we need to add it to a list:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lDFh5yF_CaXW"
      },
      "outputs": [],
      "source": [
        "# Add the image to a batch where it's the only member.\n",
        "img = np.array([img])\n",
        "\n",
        "print(img.shape)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EQ5wLTkcCaXY"
      },
      "source": [
        "Now predict the image:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "o_rzNSdrCaXY"
      },
      "outputs": [],
      "source": [
        "predictions_single = model.predict(img)\n",
        "\n",
        "print(predictions_single)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6Ai-cpLjO-3A"
      },
      "outputs": [],
      "source": [
        "plot_value_array(0, predictions_single, test_labels)\n",
        "_ = plt.xticks(range(10), class_names, rotation=45)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cU1Y2OAMCaXb"
      },
      "source": [
        "`model.predict` returns a list of lists, one for each image in the batch of data. Grab the predictions for our (only) image in the batch:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2tRmdq_8CaXb"
      },
      "outputs": [],
      "source": [
        "np.argmax(predictions_single[0])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YFc2HbEVCaXd"
      },
      "source": [
        "And, as before, the model predicts a label of 6 (shirt)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-KtnHECKZni_"
      },
      "source": [
        "# Exercises\n",
        "\n",
        "Experiment with different models and see how the accuracy results differ. In particular change the following parameters:\n",
        "*   Set training epochs set to 1\n",
        "*   Number of neurons in the Dense layer following the Flatten one. For example, go really low (e.g. 10) in ranges up to 512 and see how accuracy changes\n",
        "*   Add additional Dense layers between the Flatten and the final Dense(10), experiment with different units in these layers\n",
        "*   Don't normalize the pixel values, and see the effect that has\n",
        "\n",
        "\n",
        "Remember to enable GPU to make everything run faster (Runtime -> Change runtime type -> Hardware accelerator -> GPU).\n",
        "Also, if you run into trouble, simply reset the entire environment and start from the beginning:\n",
        "*   Edit -> Clear all outputs\n",
        "*   Runtime -> Reset all runtimes"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "collapsed_sections": [],
      "toc_visible": true,
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}