C2W3_Assignment.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Horse or Human? In-graph training loop Assignment\n",
    "\n",
    "This assignment lets you practice how to train a Keras model on the [horses_or_humans](https://www.tensorflow.org/datasets/catalog/horses_or_humans) dataset with the entire training process performed in graph mode.  These steps include:\n",
    "- loading batches\n",
    "- calculating gradients\n",
    "- updating parameters\n",
    "- calculating validation accuracy\n",
    "- repeating the loop until convergence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "n4EKOpw9mObL"
   },
   "source": [
    "## Setup\n",
    "\n",
    "Import TensorFlow 2.0:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "V9oECvVSI1Kj"
   },
   "outputs": [],
   "source": [
    "from __future__ import absolute_import, division, print_function, unicode_literals\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "mT7meGqrZTz9"
   },
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import tensorflow_datasets as tfds\n",
    "import tensorflow_hub as hub\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Em5dzSUOtLRP"
   },
   "source": [
    "### Prepare the dataset\n",
    "\n",
    "Load the horses to human dataset, splitting 80% for the training set and 20% for the test set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "splits, info = tfds.load('horses_or_humans', as_supervised=True, with_info=True\n",
    "                         , split=['train[:80%]', 'train[80%:]', 'test'], data_dir='./data')\n",
    "\n",
    "(train_examples, validation_examples, test_examples) = splits\n",
    "\n",
    "num_examples = info.splits['train'].num_examples\n",
    "num_classes = info.features['label'].num_classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "cJdruxxGhBi5"
   },
   "outputs": [],
   "source": [
    "BATCH_SIZE = 32\n",
    "IMAGE_SIZE = 224"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pre-process an image (please complete this section)\n",
    "\n",
    "You'll define a mapping function that resizes the image to a height of 224 by 224, and normalizes the pixels to the range of 0 to 1.  Note that pixels range from 0 to 255.\n",
    "\n",
    "- You'll use the following function: [tf.image.resize](https://www.tensorflow.org/api_docs/python/tf/image/resize) and pass in the (height,width) as a tuple (or list).\n",
    "- To normalize, divide by a floating value so that the pixel range changes from [0,255] to [0,1]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "qpQi4Jo9cFq0"
   },
   "outputs": [],
   "source": [
    "# Create a autograph pre-processing function to resize and normalize an image\n",
    "### START CODE HERE ###\n",
    "@tf.function\n",
    "def map_fn(img, label):\n",
    "    image_height = 224\n",
    "    image_width = 224\n",
    "### START CODE HERE ###\n",
    "    # resize the image\n",
    "    img = tf.image.resize(images = img, size = (image_height, image_width) )\n",
    "    # normalize the image\n",
    "    img /= 255.0\n",
    "### END CODE HERE\n",
    "    return img, label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(224, 224, 3)\n",
      "()\n"
     ]
    }
   ],
   "source": [
    "## TEST CODE:\n",
    "\n",
    "test_image, test_label = list(train_examples)[0]\n",
    "\n",
    "test_result = map_fn(test_image, test_label)\n",
    "\n",
    "print(test_result[0].shape)\n",
    "print(test_result[1].shape)\n",
    "\n",
    "del test_image, test_label, test_result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output:**\n",
    "\n",
    "```\n",
    "(224, 224, 3)\n",
    "()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Apply pre-processing to the datasets (please complete this section)\n",
    "\n",
    "Apply the following steps to the training_examples:\n",
    "- Apply the `map_fn` to the training_examples\n",
    "- Shuffle the training data using `.shuffle(buffer_size=)` and set the buffer size to the number of examples.\n",
    "- Group these into batches using `.batch()` and set the batch size given by the parameter.\n",
    "\n",
    "Hint: You can look at how validation_examples and test_examples are pre-processed to get a sense of how to chain together multiple function calls."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "sv5bEYhaeUUO"
   },
   "outputs": [],
   "source": [
    "# Prepare train dataset by using preprocessing with map_fn, shuffling and batching\n",
    "def prepare_dataset(train_examples, validation_examples, test_examples, num_examples, map_fn, batch_size):\n",
    "    ### START CODE HERE ###\n",
    "    train_ds = train_examples.map(map_fn).shuffle(buffer_size=num_examples).batch(batch_size)\n",
    "    ### END CODE HERE ###\n",
    "    valid_ds = validation_examples.map(map_fn).batch(batch_size)\n",
    "    test_ds = test_examples.map(map_fn).batch(batch_size)\n",
    "    \n",
    "    return train_ds, valid_ds, test_ds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_ds, valid_ds, test_ds = prepare_dataset(train_examples, validation_examples, test_examples, num_examples, map_fn, BATCH_SIZE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "26\n",
      "(32, 224, 224, 3)\n"
     ]
    }
   ],
   "source": [
    "## TEST CODE:\n",
    "\n",
    "test_train_ds = list(train_ds)\n",
    "print(len(test_train_ds))\n",
    "print(test_train_ds[0][0].shape)\n",
    "\n",
    "del test_train_ds"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output:**\n",
    "\n",
    "```\n",
    "26\n",
    "(32, 224, 224, 3)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "znmy4l8ntMvW"
   },
   "source": [
    "### Define the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ltxyJVWTqNAO"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_1\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "keras_layer_1 (KerasLayer)   (None, 2048)              23561152  \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 2)                 4098      \n",
      "=================================================================\n",
      "Total params: 23,565,250\n",
      "Trainable params: 4,098\n",
      "Non-trainable params: 23,561,152\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "MODULE_HANDLE = 'data/resnet_50_feature_vector'\n",
    "model = tf.keras.Sequential([\n",
    "    hub.KerasLayer(MODULE_HANDLE, input_shape=(IMAGE_SIZE, IMAGE_SIZE, 3)),\n",
    "    tf.keras.layers.Dense(num_classes, activation='softmax')\n",
    "])\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Ikb79EzkjpPk"
   },
   "source": [
    "## Define optimizer: (please complete these sections)\n",
    "Define the [Adam optimizer](https://www.tensorflow.org/api_docs/python/tf/keras/optimizers/Adam) that is in the tf.keras.optimizers module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def set_adam_optimizer():\n",
    "    ### START CODE HERE ###\n",
    "    # Define the adam optimizer\n",
    "    optimizer = tf.keras.optimizers.Adam()\n",
    "    ### END CODE HERE ###\n",
    "    return optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tensorflow.python.keras.optimizer_v2.adam.Adam'>\n"
     ]
    }
   ],
   "source": [
    "## TEST CODE:\n",
    "\n",
    "test_optimizer = set_adam_optimizer()\n",
    "\n",
    "print(type(test_optimizer))\n",
    "\n",
    "del test_optimizer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output:**\n",
    "```\n",
    "<class 'tensorflow.python.keras.optimizer_v2.adam.Adam'>\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define the loss function (please complete this section)\n",
    "\n",
    "Define the loss function as the [sparse categorical cross entropy](https://www.tensorflow.org/api_docs/python/tf/keras/losses/SparseCategoricalCrossentropy) that's in the tf.keras.losses module.  Use the same function for both training and validation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def set_sparse_cat_crossentropy_loss():\n",
    "    ### START CODE HERE ###\n",
    "    # Define object oriented metric of Sparse categorical crossentropy for train and val loss\n",
    "    train_loss = tf.keras.losses.SparseCategoricalCrossentropy()\n",
    "    val_loss = tf.keras.losses.SparseCategoricalCrossentropy()\n",
    "    ### END CODE HERE ###\n",
    "    return train_loss, val_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tensorflow.python.keras.losses.SparseCategoricalCrossentropy'>\n",
      "<class 'tensorflow.python.keras.losses.SparseCategoricalCrossentropy'>\n"
     ]
    }
   ],
   "source": [
    "## TEST CODE:\n",
    "\n",
    "test_train_loss, test_val_loss = set_sparse_cat_crossentropy_loss()\n",
    "\n",
    "print(type(test_train_loss))\n",
    "print(type(test_val_loss))\n",
    "\n",
    "del test_train_loss, test_val_loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output:**\n",
    "```\n",
    "<class 'tensorflow.python.keras.losses.SparseCategoricalCrossentropy'>\n",
    "<class 'tensorflow.python.keras.losses.SparseCategoricalCrossentropy'>\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define the acccuracy function (please complete this section)\n",
    "Define the accuracy function as the [spare categorical accuracy](https://www.tensorflow.org/api_docs/python/tf/keras/metrics/SparseCategoricalAccuracy) that's contained in the tf.keras.metrics module.   Use the same function for both training and validation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def set_sparse_cat_crossentropy_accuracy():\n",
    "    ### START CODE HERE ###\n",
    "    # Define object oriented metric of Sparse categorical accuracy for train and val accuracy\n",
    "    train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy()\n",
    "    val_accuracy = tf.keras.metrics.SparseCategoricalAccuracy()\n",
    "    ### END CODE HERE ###\n",
    "    return train_accuracy, val_accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tensorflow.python.keras.metrics.SparseCategoricalAccuracy'>\n",
      "<class 'tensorflow.python.keras.metrics.SparseCategoricalAccuracy'>\n"
     ]
    }
   ],
   "source": [
    "## TEST CODE:\n",
    "\n",
    "test_train_accuracy, test_val_accuracy = set_sparse_cat_crossentropy_accuracy()\n",
    "\n",
    "print(type(test_train_accuracy))\n",
    "print(type(test_val_accuracy))\n",
    "\n",
    "del test_train_accuracy, test_val_accuracy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output:**\n",
    "```\n",
    "<class 'tensorflow.python.keras.metrics.SparseCategoricalAccuracy'>\n",
    "<class 'tensorflow.python.keras.metrics.SparseCategoricalAccuracy'>\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Call the three functions that you defined to set the optimizer, loss and accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "j92oDYGCjnBh"
   },
   "outputs": [],
   "source": [
    "optimizer = set_adam_optimizer()\n",
    "train_loss, val_loss = set_sparse_cat_crossentropy_loss()\n",
    "train_accuracy, val_accuracy = set_sparse_cat_crossentropy_accuracy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "oeYV6mKnJGMr"
   },
   "source": [
    "### Define the training loop (please complete this section)\n",
    "\n",
    "In the training loop:\n",
    "- Get the model predictions: use the model, passing in the input `x`\n",
    "- Get the training loss: Call `train_loss`, passing in the true `y` and the predicted `y`.\n",
    "- Calculate the gradient of the loss with respect to the model's variables: use `tape.gradient` and pass in the loss and the model's `trainable_variables`.\n",
    "- Optimize the model variables using the gradients: call `optimizer.apply_gradients` and pass in a `zip()` of the two lists: the gradients and the model's `trainable_variables`.\n",
    "- Calculate accuracy: Call `train_accuracy`, passing in the true `y` and the predicted `y`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "3xtg_MMhJETd"
   },
   "outputs": [],
   "source": [
    "# this code uses the GPU if available, otherwise uses a CPU\n",
    "device = '/gpu:0' if tf.config.list_physical_devices('GPU') else '/cpu:0'\n",
    "EPOCHS = 2\n",
    "\n",
    "# Custom training step\n",
    "def train_one_step(model, optimizer, x, y, train_loss, train_accuracy):\n",
    "    '''\n",
    "    Trains on a batch of images for one step.\n",
    "    \n",
    "    Args:\n",
    "        model (keras Model) -- image classifier\n",
    "        optimizer (keras Optimizer) -- optimizer to use during training\n",
    "        x (Tensor) -- training images\n",
    "        y (Tensor) -- training labels\n",
    "        train_loss (keras Loss) -- loss object for training\n",
    "        train_accuracy (keras Metric) -- accuracy metric for training\n",
    "    '''\n",
    "    with tf.GradientTape() as tape:\n",
    "    ### START CODE HERE ###\n",
    "        # Run the model on input x to get predictions\n",
    "        predictions = model(x)\n",
    "        # Compute the training loss using `train_loss`, passing in the true y and the predicted y\n",
    "        loss = train_loss(y, predictions)\n",
    "\n",
    "    # Using the tape and loss, compute the gradients on model variables using tape.gradient\n",
    "    grads = tape.gradient( loss, model.trainable_weights)\n",
    "    \n",
    "    # Zip the gradients and model variables, and then apply the result on the optimizer\n",
    "    optimizer.apply_gradients(zip(grads,  model.trainable_weights) )\n",
    "\n",
    "    # Call the train accuracy object on ground truth and predictions\n",
    "    train_accuracy( y, predictions)\n",
    "    ### END CODE HERE\n",
    "    return loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(0.6931472, shape=(), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "## TEST CODE:\n",
    "\n",
    "def base_model():\n",
    "    inputs = tf.keras.layers.Input(shape=(2))\n",
    "    x = tf.keras.layers.Dense(64, activation='relu')(inputs)\n",
    "    outputs = tf.keras.layers.Dense(1, activation='sigmoid')(x)\n",
    "    model = tf.keras.Model(inputs=inputs, outputs=outputs)\n",
    "    return model\n",
    "\n",
    "test_model = base_model()\n",
    "\n",
    "test_optimizer = set_adam_optimizer()\n",
    "test_image = tf.ones((2,2))\n",
    "test_label = tf.ones((1,))\n",
    "test_train_loss, _ = set_sparse_cat_crossentropy_loss()\n",
    "test_train_accuracy, _ = set_sparse_cat_crossentropy_accuracy()\n",
    "\n",
    "test_result = train_one_step(test_model, test_optimizer, test_image, test_label, test_train_loss, test_train_accuracy)\n",
    "print(test_result)\n",
    "\n",
    "del test_result, test_model, test_optimizer, test_image, test_label, test_train_loss, test_train_accuracy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output:**\n",
    "\n",
    "You will see a Tensor with the same shape and dtype. The value might be different.\n",
    "\n",
    "```\n",
    "tf.Tensor(0.6931472, shape=(), dtype=float32)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define the 'train' function (please complete this section)\n",
    "\n",
    "You'll first loop through the training batches to train the model. (Please complete these sections)\n",
    "- The `train` function will use a for loop to iteratively call the `train_one_step` function that you just defined.\n",
    "- You'll use `tf.print` to print the step number, loss, and train_accuracy.result() at each step.  Remember to use tf.print when you plan to generate autograph code.\n",
    "\n",
    "Next, you'll loop through the batches of the validation set to calculation the validation loss and validation accuracy. (This code is provided for you).  At each iteration of the loop:\n",
    "- Use the model to predict on x, where x is the input from the validation set.\n",
    "- Use val_loss to calculate the validation loss between the true validation 'y' and predicted y.\n",
    "- Use val_accuracy to calculate the accuracy of the predicted y compared to the true y.\n",
    "\n",
    "Finally, you'll print the validation loss and accuracy using tf.print. (Please complete this section)\n",
    "- print the final `loss`, which is the validation loss calculated by the last loop through the validation dataset.\n",
    "- Also print the val_accuracy.result().\n",
    "\n",
    "**HINT**\n",
    "If you submit your assignment and see this error for your stderr output: \n",
    "```\n",
    "Cannot convert 1e-07 to EagerTensor of dtype int64\n",
    "```\n",
    "Please check your calls to train_accuracy and val_accuracy to make sure that you pass in the true and predicted values in the correct order (check the documentation to verify the order of parameters)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Decorate this function with tf.function to enable autograph on the training loop\n",
    "@tf.function\n",
    "def train(model, optimizer, epochs, device, train_ds, train_loss, train_accuracy, valid_ds, val_loss, val_accuracy):\n",
    "    '''\n",
    "    Performs the entire training loop. Prints the loss and accuracy per step and epoch.\n",
    "    \n",
    "    Args:\n",
    "        model (keras Model) -- image classifier\n",
    "        optimizer (keras Optimizer) -- optimizer to use during training\n",
    "        epochs (int) -- number of epochs\n",
    "        train_ds (tf Dataset) -- the train set containing image-label pairs\n",
    "        train_loss (keras Loss) -- loss function for training\n",
    "        train_accuracy (keras Metric) -- accuracy metric for training\n",
    "        valid_ds (Tensor) -- the val set containing image-label pairs\n",
    "        val_loss (keras Loss) -- loss object for validation\n",
    "        val_accuracy (keras Metric) -- accuracy metric for validation\n",
    "    '''\n",
    "    step = 0\n",
    "    loss = 0.0\n",
    "    for epoch in range(epochs):\n",
    "        for x, y in train_ds:\n",
    "            # training step number increments at each iteration\n",
    "            step += 1\n",
    "            with tf.device(device_name=device):\n",
    "                ### START CODE HERE ###\n",
    "                # Run one training step by passing appropriate model parameters\n",
    "                # required by the function and finally get the loss to report the results\n",
    "                loss = train_one_step(model, optimizer, x, y, train_loss, train_accuracy)\n",
    "                ### END CODE HERE ###\n",
    "            # Use tf.print to report your results.\n",
    "            # Print the training step number, loss and accuracy\n",
    "            tf.print('Step', step, \n",
    "                   ': train loss', loss, \n",
    "                   '; train accuracy', train_accuracy.result())\n",
    "\n",
    "        with tf.device(device_name=device):\n",
    "            for x, y in valid_ds:\n",
    "                # Call the model on the batches of inputs x and get the predictions\n",
    "                y_pred = model(x)\n",
    "                loss = val_loss(y, y_pred)\n",
    "                val_accuracy(y, y_pred)\n",
    "        \n",
    "        # Print the validation loss and accuracy\n",
    "        ### START CODE HERE ###\n",
    "        tf.print('val loss', loss, '; val accuracy', val_accuracy)\n",
    "        ### END CODE HERE ###"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run the `train` function to train your model! You should see the loss generally decreasing and the accuracy increasing.\n",
    "\n",
    "**Note**: **Please let the training finish before submitting** and **do not** modify the next cell. It is required for grading. This will take around 5 minutes to run. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "graded": true,
    "id": "6iDWgg977wb9",
    "name": "train"
   },
   "outputs": [],
   "source": [
    "train(model, optimizer, EPOCHS, device, train_ds, train_loss, train_accuracy, valid_ds, val_loss, val_accuracy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "N8m3iJgx7SV1"
   },
   "source": [
    "# Evaluation\n",
    "\n",
    "You can now see how your model performs on test images. First, let's load the test dataset and generate predictions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "HwFx4Nbh25p5"
   },
   "outputs": [],
   "source": [
    "test_imgs = []\n",
    "test_labels = []\n",
    "\n",
    "predictions = []\n",
    "with tf.device(device_name=device):\n",
    "    for images, labels in test_ds:\n",
    "        preds = model(images)\n",
    "        preds = preds.numpy()\n",
    "        predictions.extend(preds)\n",
    "\n",
    "        test_imgs.extend(images.numpy())\n",
    "        test_labels.extend(labels.numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's define a utility function for plotting an image and its prediction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cellView": "form",
    "colab": {},
    "colab_type": "code",
    "id": "IiutdErSpRH_"
   },
   "outputs": [],
   "source": [
    "# Utilities for plotting\n",
    "\n",
    "class_names = ['horse', 'human']\n",
    "\n",
    "def plot_image(i, predictions_array, true_label, img):\n",
    "    predictions_array, true_label, img = predictions_array[i], true_label[i], img[i]\n",
    "    plt.grid(False)\n",
    "    plt.xticks([])\n",
    "    plt.yticks([])\n",
    "\n",
    "    img = np.squeeze(img)\n",
    "\n",
    "    plt.imshow(img, cmap=plt.cm.binary)\n",
    "\n",
    "    predicted_label = np.argmax(predictions_array)\n",
    "    \n",
    "    # green-colored annotations will mark correct predictions. red otherwise.\n",
    "    if predicted_label == true_label:\n",
    "        color = 'green'\n",
    "    else:\n",
    "        color = 'red'\n",
    "    \n",
    "    # print the true label first\n",
    "    print(true_label)\n",
    "  \n",
    "    # show the image and overlay the prediction\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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot the result of a single image\n",
    "\n",
    "Choose an index and display the model's prediction for that image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cellView": "form",
    "colab": {},
    "colab_type": "code",
    "id": "aVknjW4A11uz"
   },
   "outputs": [],
   "source": [
    "# Visualize the outputs \n",
    "\n",
    "# you can modify the index value here from 0 to 255 to test different images\n",
    "index = 8 \n",
    "plt.figure(figsize=(6,3))\n",
    "plt.subplot(1,2,1)\n",
    "plot_image(index, predictions, test_labels, test_imgs)\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "coursera": {
   "schema_names": [
    "TF3C2W3-1",
    "TF3C2W3-2",
    "TF3C2W3-3",
    "TF3C2W3-4",
    "TF3C2W3-5",
    "TF3C2W3-6",
    "TF3C2W3-7"
   ]
  },
  "jupytext": {
   "encoding": "# -*- coding: utf-8 -*-"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}