07_food_vision_milestone_project_1.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/mrdbourke/tensorflow-deep-learning/blob/main/07_food_vision_milestone_project_1.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z2PPYrQIztfX"
      },
      "source": [
        "# 07. Milestone Project 1: 🍔👁 Food Vision Big™\n",
        "\n",
        "In the previous notebook ([transfer learning part 3: scaling up](https://github.com/mrdbourke/tensorflow-deep-learning/blob/main/06_transfer_learning_in_tensorflow_part_3_scaling_up.ipynb)) we built Food Vision mini: a transfer learning model which beat the original results of the [Food101 paper](https://data.vision.ee.ethz.ch/cvl/datasets_extra/food-101/) with only 10% of the data.\n",
        "\n",
        "But you might be wondering, what would happen if we used all the data?\n",
        "\n",
        "Well, that's what we're going to find out in this notebook!\n",
        "\n",
        "We're going to be building Food Vision Big™, using all of the data from the Food101 dataset.\n",
        "\n",
        "Yep. All 75,750 training images and 25,250 testing images.\n",
        "\n",
        "And guess what...\n",
        "\n",
        "This time **we've got the goal of beating [DeepFood](https://www.researchgate.net/publication/304163308_DeepFood_Deep_Learning-Based_Food_Image_Recognition_for_Computer-Aided_Dietary_Assessment)**, a 2016 paper which used a Convolutional Neural Network trained for 2-3 days to achieve 77.4% top-1 accuracy.\n",
        "\n",
        "> 🔑 **Note:** **Top-1 accuracy** means \"accuracy for the top softmax activation value output by the model\" (because softmax ouputs a value for every class, but top-1 means only the highest one is evaluated). **Top-5 accuracy** means \"accuracy for the top 5 softmax activation values output by the model\", in other words, did the true label appear in the top 5 activation values? Top-5 accuracy scores are usually noticeably higher than top-1.\n",
        "\n",
        "|  | 🍔👁 Food Vision Big™ | 🍔👁 Food Vision mini |\n",
        "|-----|-----|-----|\n",
        "| Dataset source | TensorFlow Datasets | Preprocessed download from Kaggle | \n",
        "| Train data | 75,750 images | 7,575 images | \n",
        "| Test data | 25,250 images | 25,250 images | \n",
        "| Mixed precision | Yes | No |\n",
        "| Data loading | Performanant tf.data API | TensorFlow pre-built function |  \n",
        "| Target results | 77.4% top-1 accuracy (beat [DeepFood paper](https://arxiv.org/abs/1606.05675)) | 50.76% top-1 accuracy (beat [Food101 paper](https://data.vision.ee.ethz.ch/cvl/datasets_extra/food-101/static/bossard_eccv14_food-101.pdf)) | \n",
        "\n",
        "*Table comparing difference between Food Vision Big (this notebook) versus Food Vision mini (previous notebook).*\n",
        "\n",
        "Alongside attempting to beat the DeepFood paper, we're going to learn about two methods to significantly improve the speed of our model training:\n",
        "1. Prefetching\n",
        "2. Mixed precision training\n",
        "\n",
        "But more on these later.\n",
        "\n",
        "## What we're going to cover\n",
        "\n",
        "* Using TensorFlow Datasets to download and explore data\n",
        "* Creating preprocessing function for our data\n",
        "* Batching & preparing datasets for modelling (**making our datasets run fast**)\n",
        "* Creating modelling callbacks\n",
        "* Setting up **mixed precision training**\n",
        "* Building a feature extraction model (see [transfer learning part 1: feature extraction](https://github.com/mrdbourke/tensorflow-deep-learning/blob/main/04_transfer_learning_in_tensorflow_part_1_feature_extraction.ipynb))\n",
        "* Fine-tuning the feature extraction model (see [transfer learning part 2: fine-tuning](https://github.com/mrdbourke/tensorflow-deep-learning/blob/main/05_transfer_learning_in_tensorflow_part_2_fine_tuning.ipynb))\n",
        "* Viewing training results on TensorBoard\n",
        "\n",
        "## How you should approach this notebook\n",
        "\n",
        "You can read through the descriptions and the code (it should all run, except for the cells which error on purpose), but there's a better option.\n",
        "\n",
        "Write all of the code yourself.\n",
        "\n",
        "Yes. I'm serious. Create a new notebook, and rewrite each line by yourself. Investigate it, see if you can break it, why does it break?\n",
        "\n",
        "You don't have to write the text descriptions but writing the code yourself is a great way to get hands-on experience.\n",
        "\n",
        "Don't worry if you make mistakes, we all do. The way to get better and make less mistakes is to write more code.\n",
        "\n",
        "> 📖 **Resource:** See the full set of course materials on GitHub: https://github.com/mrdbourke/tensorflow-deep-learning"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rLaDq25mykWN"
      },
      "source": [
        "## Check GPU\n",
        "\n",
        "For this notebook, we're going to be doing something different.\n",
        "\n",
        "We're going to be using mixed precision training.\n",
        "\n",
        "Mixed precision training was introduced in [TensorFlow 2.4.0](https://blog.tensorflow.org/2020/12/whats-new-in-tensorflow-24.html) (a very new feature at the time of writing).\n",
        "\n",
        "What does **mixed precision training** do?\n",
        "\n",
        "Mixed precision training uses a combination of single precision (float32) and half-preicison (float16) data types to speed up model training (up 3x on modern GPUs).\n",
        "\n",
        "We'll talk about this more later on but in the meantime you can read the [TensorFlow documentation on mixed precision](https://www.tensorflow.org/guide/mixed_precision) for more details.\n",
        "\n",
        "For now, before we can move forward if we want to use mixed precision training, we need to make sure the GPU powering our Google Colab instance (if you're using Google Colab) is compataible. \n",
        "\n",
        "For mixed precision training to work, you need access to a GPU with a compute compability score of 7.0+. \n",
        "\n",
        "Google Colab offers P100, K80 and T4 GPUs, however, **the P100 and K80 aren't compatible with mixed precision training**.\n",
        "\n",
        "Therefore before we proceed we need to make sure we have **access to a Tesla T4 GPU in our Google Colab instance**.\n",
        "\n",
        "If you're not using Google Colab, you can find a list of various [Nvidia GPU compute capabilities on Nvidia's developer website](https://developer.nvidia.com/cuda-gpus#compute).\n",
        "\n",
        "> 🔑 **Note:** If you run the cell below and see a P100 or K80, try going to to Runtime -> Factory Reset Runtime (note: this will remove any saved variables and data from your Colab instance) and then retry to get a T4.\n",
        ">\n",
        "> **You can still run the code *without* a GPU capable of mixed precision** (it'll just be a little slower). "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VAC_5rYJicZ4",
        "outputId": "7c6def0d-e61f-4361-e18a-ff3589d2b978"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "GPU 0: NVIDIA TITAN RTX (UUID: GPU-64b1678c-cec3-56bb-af0c-8ae69de44cbd)\r\n"
          ]
        }
      ],
      "source": [
        "# If using Google Colab, this should output \"Tesla T4\" otherwise, \n",
        "# you won't be able to use mixed precision training\n",
        "!nvidia-smi -L"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oWgb38BYKhS_"
      },
      "source": [
        "Since mixed precision training was introduced in TensorFlow 2.4.0, make sure you've got at least TensorFlow 2.4.0+."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8LpEDWLxKg46",
        "outputId": "aef28f24-4395-46f6-8129-6cbf84caa68a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2.6.2\n"
          ]
        }
      ],
      "source": [
        "# Hide warning logs (see: https://stackoverflow.com/a/38645250/7900723)\n",
        "import os\n",
        "os.environ[\"TF_CPP_MIN_LOG_LEVEL\"] = \"3\"\n",
        "\n",
        "# Check TensorFlow version (should be 2.4.0+)\n",
        "import tensorflow as tf\n",
        "print(tf.__version__)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pPwSfuFDzT5v"
      },
      "source": [
        "## Get helper functions\n",
        "\n",
        "We've created a series of helper functions throughout the previous notebooks in the course. Instead of rewriting them (tedious), we'll import the [`helper_functions.py`](https://github.com/mrdbourke/tensorflow-deep-learning/blob/main/extras/helper_functions.py) file from the GitHub repo."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iC2R6bOZzhQd",
        "outputId": "cfbe9a9f-fe5d-4497-c1de-6ac93013dfc0"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Helper functions file already exists, skipping download...\n"
          ]
        }
      ],
      "source": [
        "# Get helper functions file\n",
        "if not os.path.exists(\"helper_functions.py\"):\n",
        "    print(\"Downloading helper functions...\")\n",
        "    !wget https://raw.githubusercontent.com/mrdbourke/tensorflow-deep-learning/main/extras/helper_functions.py\n",
        "else:\n",
        "    print(\"Helper functions file already exists, skipping download...\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZqKKuFt7zYvf"
      },
      "outputs": [],
      "source": [
        "# Import series of helper functions for the notebook (we've created/used these in previous notebooks)\n",
        "from helper_functions import create_tensorboard_callback, plot_loss_curves, compare_historys"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w5BE7WYl9b_8"
      },
      "source": [
        "## Use TensorFlow Datasets to Download Data\n",
        "\n",
        "In previous notebooks, we've downloaded our food images (from the [Food101 dataset](https://www.kaggle.com/dansbecker/food-101/home)) from Google Storage.\n",
        "\n",
        "And this is a typical workflow you'd use if you're working on your own datasets.\n",
        "\n",
        "However, there's another way to get datasets ready to use with TensorFlow.\n",
        "\n",
        "For many of the most popular datasets in the machine learning world (often referred to and used as benchmarks), you can access them through [TensorFlow Datasets (TFDS)](https://www.tensorflow.org/datasets/overview).\n",
        "\n",
        "What is **TensorFlow Datasets**?\n",
        "\n",
        "A place for prepared and ready-to-use machine learning datasets.\n",
        "\n",
        "Why use TensorFlow Datasets?\n",
        "\n",
        "* Load data already in Tensors\n",
        "* Practice on well established datasets\n",
        "* Experiment with differet data loading techniques (like we're going to use in this notebook)\n",
        "* Experiment with new TensorFlow features quickly (such as mixed precision training)\n",
        "\n",
        "Why *not* use TensorFlow Datasets?\n",
        "\n",
        "* The datasets are static (they don't change, like your real-world datasets would)\n",
        "* Might not be suited for your particular problem (but great for experimenting)\n",
        "\n",
        "To begin using TensorFlow Datasets we can import it under the alias `tfds`.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YDMExkAG8ztE"
      },
      "outputs": [],
      "source": [
        "# Get TensorFlow Datasets\n",
        "import tensorflow_datasets as tfds"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-TRPTGvpNuJm"
      },
      "source": [
        "To find all of the available datasets in TensorFlow Datasets, you can use the `list_builders()` method.\n",
        "\n",
        "After doing so, we can check to see if the one we're after (`\"food101\"`) is present."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gXA8b2619s0X",
        "outputId": "8f0c8971-4a0a-4aec-f371-701022832a76"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "True\n"
          ]
        }
      ],
      "source": [
        "# List available datasets\n",
        "datasets_list = tfds.list_builders() # get all available datasets in TFDS\n",
        "print(\"food101\" in datasets_list) # is the dataset we're after available?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bUK_zulYNfVY"
      },
      "source": [
        "Beautiful! It looks like the dataset we're after is available (note there are plenty more available but we're on Food101).\n",
        "\n",
        "To get access to the Food101 dataset from the TFDS, we can use the [`tfds.load()`](https://www.tensorflow.org/datasets/api_docs/python/tfds/load) method.\n",
        "\n",
        "In particular, we'll have to pass it a few parameters to let it know what we're after:\n",
        "* `name` (str) : the target dataset (e.g. `\"food101\"`)\n",
        "* `split` (list, optional) : what splits of the dataset we're after (e.g. `[\"train\", \"validation\"]`)\n",
        "  * the `split` parameter is quite tricky. See [the documentation for more](https://github.com/tensorflow/datasets/blob/master/docs/splits.md).\n",
        "* `shuffle_files` (bool) : whether or not to shuffle the files on download, defaults to `False` \n",
        "* `as_supervised` (bool) : `True` to download data samples in tuple format (`(data, label)`) or `False` for dictionary format \n",
        "* `with_info` (bool) : `True` to download dataset metadata (labels, number of samples, etc)\n",
        "\n",
        "> 🔑 **Note:** Calling the `tfds.load()` method will start to download a target dataset to disk if the `download=True` parameter is set (default). This dataset could be 100GB+, so make sure you have space."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ClXZDWng-s8F"
      },
      "outputs": [],
      "source": [
        "# Load in the data (takes about 5-6 minutes in Google Colab)\n",
        "(train_data, test_data), ds_info = tfds.load(name=\"food101\", # target dataset to get from TFDS\n",
        "                                             split=[\"train\", \"validation\"], # what splits of data should we get? note: not all datasets have train, valid, test\n",
        "                                             shuffle_files=True, # shuffle files on download?\n",
        "                                             as_supervised=True, # download data in tuple format (sample, label), e.g. (image, label)\n",
        "                                             with_info=True) # include dataset metadata? if so, tfds.load() returns tuple (data, ds_info)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pSxo6soUwTQl"
      },
      "source": [
        "Wonderful! After a few minutes of downloading, we've now got access to entire Food101 dataset (in tensor format) ready for modelling.\n",
        "\n",
        "Now let's get a little information from our dataset, starting with the class names.\n",
        "\n",
        "Getting class names from a TensorFlow Datasets dataset requires downloading the \"`dataset_info`\" variable (by using the `as_supervised=True` parameter in the `tfds.load()` method, **note:** this will only work for supervised datasets in TFDS).\n",
        "\n",
        "We can access the class names of a particular dataset using the `dataset_info.features` attribute and accessing `names` attribute of the the `\"label\"` key."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Zoy8Tu7VR2ji",
        "outputId": "e572e94c-d6d3-43bc-e049-ed4d73c84c96"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "FeaturesDict({\n",
              "    'image': Image(shape=(None, None, 3), dtype=tf.uint8),\n",
              "    'label': ClassLabel(shape=(), dtype=tf.int64, num_classes=101),\n",
              "})"
            ]
          },
          "execution_count": 44,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Features of Food101 TFDS\n",
        "ds_info.features"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "g2UkCaLsDXaR",
        "outputId": "8ac531a8-f951-48d1-f9a1-dfdeabf6ac1b"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "['apple_pie',\n",
              " 'baby_back_ribs',\n",
              " 'baklava',\n",
              " 'beef_carpaccio',\n",
              " 'beef_tartare',\n",
              " 'beet_salad',\n",
              " 'beignets',\n",
              " 'bibimbap',\n",
              " 'bread_pudding',\n",
              " 'breakfast_burrito']"
            ]
          },
          "execution_count": 45,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Get class names\n",
        "class_names = ds_info.features[\"label\"].names\n",
        "class_names[:10]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TwsBAkGKwh08"
      },
      "source": [
        "### Exploring the Food101 data from TensorFlow Datasets\n",
        "\n",
        "Now we've downloaded the Food101 dataset from TensorFlow Datasets, how about we do what any good data explorer should?\n",
        "\n",
        "In other words, \"visualize, visualize, visualize\". \n",
        "\n",
        "Let's find out a few details about our dataset:\n",
        "* The shape of our input data (image tensors)\n",
        "* The datatype of our input data\n",
        "* What the labels of our input data look like (e.g. one-hot encoded versus label-encoded)\n",
        "* Do the labels match up with the class names?\n",
        "\n",
        "To do, let's take one sample off the training data (using the [`.take()` method](https://www.tensorflow.org/api_docs/python/tf/data/Dataset#take)) and explore it. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5eO2qVy3A-CC"
      },
      "outputs": [],
      "source": [
        "# Take one sample off the training data\n",
        "train_one_sample = train_data.take(1) # samples are in format (image_tensor, label)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hsZj4K3ETdvB"
      },
      "source": [
        "Because we used the `as_supervised=True` parameter in our `tfds.load()` method above, data samples come in the tuple format structure `(data, label)` or in our case `(image_tensor, label)`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m--0wDNDTU8S",
        "outputId": "27eaedbd-df55-4773-8a14-b35c40c8a4d0"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<TakeDataset shapes: ((None, None, 3), ()), types: (tf.uint8, tf.int64)>"
            ]
          },
          "execution_count": 47,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# What does one sample of our training data look like?\n",
        "train_one_sample"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bP1MeznpTsbM"
      },
      "source": [
        "Let's loop through our single training sample and get some info from the `image_tensor` and `label`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Zjz4goiHBMO7",
        "outputId": "880b2873-15a9-4805-cfef-9e390c9f038f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "  Image shape: (512, 289, 3)\n",
            "  Image dtype: <dtype: 'uint8'>\n",
            "  Target class from Food101 (tensor form): 45\n",
            "  Class name (str form): frozen_yogurt\n",
            "        \n"
          ]
        }
      ],
      "source": [
        "# Output info about our training sample\n",
        "for image, label in train_one_sample:\n",
        "  print(f\"\"\"\n",
        "  Image shape: {image.shape}\n",
        "  Image dtype: {image.dtype}\n",
        "  Target class from Food101 (tensor form): {label}\n",
        "  Class name (str form): {class_names[label.numpy()]}\n",
        "        \"\"\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i4_od8dUUSHE"
      },
      "source": [
        "Because we set the `shuffle_files=True` parameter in our `tfds.load()` method above, running the cell above a few times will give a different result each time.\n",
        "\n",
        "Checking these you might notice some of the images have different shapes, for example `(512, 342, 3)` and `(512, 512, 3)` (height, width, color_channels).\n",
        "\n",
        "Let's see what one of the image tensors from TFDS's Food101 dataset looks like."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FuZmVEH-WS4b",
        "outputId": "74ab49f2-d531-49a3-b0aa-13a0902846bf"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(512, 289, 3), dtype=uint8, numpy=\n",
              "array([[[145, 151, 125],\n",
              "        [157, 163, 137],\n",
              "        [159, 165, 139],\n",
              "        ...,\n",
              "        [197, 209, 199],\n",
              "        [197, 209, 199],\n",
              "        [197, 207, 198]],\n",
              "\n",
              "       [[146, 152, 126],\n",
              "        [156, 162, 136],\n",
              "        [158, 164, 138],\n",
              "        ...,\n",
              "        [197, 209, 199],\n",
              "        [197, 209, 199],\n",
              "        [199, 209, 200]],\n",
              "\n",
              "       [[150, 156, 130],\n",
              "        [155, 161, 135],\n",
              "        [157, 163, 137],\n",
              "        ...,\n",
              "        [197, 209, 199],\n",
              "        [197, 209, 199],\n",
              "        [199, 209, 198]],\n",
              "\n",
              "       ...,\n",
              "\n",
              "       [[173, 186, 177],\n",
              "        [174, 187, 178],\n",
              "        [176, 189, 180],\n",
              "        ...,\n",
              "        [181, 197, 187],\n",
              "        [181, 197, 187],\n",
              "        [178, 195, 187]],\n",
              "\n",
              "       [[176, 187, 179],\n",
              "        [176, 187, 179],\n",
              "        [176, 189, 180],\n",
              "        ...,\n",
              "        [182, 198, 188],\n",
              "        [182, 198, 188],\n",
              "        [180, 197, 189]],\n",
              "\n",
              "       [[178, 189, 181],\n",
              "        [177, 188, 180],\n",
              "        [175, 188, 179],\n",
              "        ...,\n",
              "        [179, 195, 185],\n",
              "        [179, 195, 185],\n",
              "        [179, 196, 190]]], dtype=uint8)>"
            ]
          },
          "execution_count": 49,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# What does an image tensor from TFDS's Food101 look like?\n",
        "image"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3jJF7njRVKh6",
        "outputId": "5a10af78-6592-4499-f22b-eba95937ffb7"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(<tf.Tensor: shape=(), dtype=uint8, numpy=0>,\n",
              " <tf.Tensor: shape=(), dtype=uint8, numpy=255>)"
            ]
          },
          "execution_count": 50,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# What are the min and max values?\n",
        "tf.reduce_min(image), tf.reduce_max(image)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P2GvO7HjVF5i"
      },
      "source": [
        "Alright looks like our image tensors have values of between 0 & 255 (standard red, green, blue colour values) and the values are of data type `unit8`.\n",
        "\n",
        "We might have to preprocess these before passing them to a neural network. But we'll handle this later.\n",
        "\n",
        "In the meantime, let's see if we can plot an image sample."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "llQyIBfJWc5x"
      },
      "source": [
        "### Plot an image from TensorFlow Datasets\n",
        "\n",
        "We've seen our image tensors in tensor format, now let's really adhere to our motto.\n",
        "\n",
        "\"Visualize, visualize, visualize!\"\n",
        "\n",
        "Let's plot one of the image samples using [`matplotlib.pyplot.imshow()`](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.imshow.html) and set the title to target class name."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 264
        },
        "id": "pK581hgPWyLm",
        "outputId": "f82b5267-3c9c-4d19-a3b8-6cf4998d4110"
      },
      "outputs": [
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIkAAAD3CAYAAAApDHd4AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAACZ1klEQVR4nOz9WbBlTXbfh/1WZu7hnHOHmr956BmNBtCNkcRMgiRImiZNUqJtmbYjrKBDNh1hhR8kWwo6wi+yJT84QrJEyy8SZYmUHSHaokiRokESADGQGBtooLvR6OEb+pur6o5n2ENmLj9k7n32OfdW1Yf+EAAU7qy4de/ZZw+5M1eu9V9jiqryzfbN9rhmfr878M32B799k0i+2Z7Yvkkk32xPbN8kkm+2J7ZvEsk32xPbN4nkm+2J7fecSETkEyLyWRG5FJH/9e/187/Zfuft94OT/OvAT6nqoar+e78Pz/9vXRORnxKRv/L79fzfDyJ5Cfj8dV+IiP097ssf6Cap/f5DAlX9PfsB/gkQgAZYAn8L+L8Bfx9YAX8c+CTwU8AZiZj+XL722XzN8LNO3R/v/S8DXwROgX8IvDT5ToH/BfDl/P1/AMhj+lkBJ8C3T47dAzbA3fz5fw58JZ/3XwHPTs79ceBLwDnw14GfBv5K/u7/APxnk3Nfzv1z+fNPAf8W8HP5eX9zb8z+/d/LOVPV31simQzCMGB/Iw/kD5K42mEe+H8TKIEfAy6BT1xzn78J/Of57z+fr/sk4IC/Bvz8HpH8PeAG8CJwH/hTT+jnXwf+ncnnfxX4u/nvHwMeAN+VCer/CvzT/N0d4AL4i7kv/yrQ/w6J5HXgU/n6Yjpmvx8/v/+sDP6Oqv6cqkbgM8AB8G+raqeq/4Q0uf/S9AIR+d8C30LiHgD/CvB/UtUvqqoH/o/AZ0Tkpcll/7aqnqnq68BP5mc9rv0nwP9owu7/J8B/mv/+y8B/pKq/qqot8G8A3y8iLwP/HeDzqvr/zn3594B3fgfjAfA3VPXzqupVtf8dXvu73v4gEMnXJ38/C3w9E8zQXgOeGz6IyJ8mrc4/r6qbfPgl4N8VkTMROSOJAJlex+5ErUnE+Mimqr9AEoE/KiLfAnyUJFaGfr42OXcJPMzPe3b6TprYwxuPe9Y17etPPuX3rrnf7w6QWO3Q3gJeEBEzIZQXgd+GpD6TVvhfVNXpQH4d+LdU9W/+LvftPwH+xyQC+y9UtZn0c+RSIrIAbgNvAm8Dz0++k+lnEuHNJ5+fvua5+67531dX/R8ETjJtw+r910WkEJE/AvxZ4P8pIkfA3wH+mqr+7N51/yHwb4jIpwBE5FhE/tLvQn/+U+AvkAjl/zE5/reA/5mIfEZEKpJ4+wVVfRX4r4FvF5E/LyIO+F+xSwi/BvyIiLwoIsckUfWk9i7w4Q/6Mt9o+wNFJKraAX8O+NMkYPjXgf+pqv4WCSR+Avi/iMhy+MnX/X+Af4dETBfAb+Z7fND+vAH8Kmkl/8zk+D8G/vfA3yZxjo8A/8P83QPgLwH/Z5II+lbgl4E2f/8TwP8L+BzwKyTM9aT27wL/ooicisjvuW1JMqL+ZntEE5H/CHhLVf/aN3i9IWGSv6yqP/m72rnfo/YHAZP8gW1ZW/mLwHf+Dq/7kyTRuQH+NRKI/ue/2/37vWr/f00kIvIfkvDGfvvPSLaU/w1JtX7ld3jr7yfhlhL4Arua2H/r2jfFzTfbE9sfKOD6zfYHsz1W3Pzf/+N/S8uqwhUVH/rwhzm+dRNVkoRFETFI+gAYjDHp+/GYIBhEBFUQFIySTAcgYkEkWwGm9GoAIcaYzjVTbqfAYNLWdM89M8JgiRejqAqo5D4ZUEFRlHRvzc8QTXeJpP7J5HEak8lGhfwuOv4e/ga2/YXB5I4RIYYAgLWWGLd2wvwmk55L9pUIqtvxGJ4xfWY6T1ENoMM45JGQ7fOH30Iah0gcxyuqjOPzA5/+fuER7bFEYowBVeazmoODBaJKVMWISZM77cTYse1xmTxWZEs649tcOZDfkOGeaWBitqtNB2p7Lnt/TwZdt/fZEmG6PhF0/h11nGCRfF1+FgJCOlfM1XEc+mNMWiTbd5fxxYfj02v2z9OB1jNBi0CM6b4ij3guimTykHwTlWvO24MU+8eeBDkeD1xjeomjoyMAvPcgBq8Ba02mZhAxmMkA7j5UiTG9hhHNgw67FDSeOl4v46qNO+dc/0L7xDIMm00Dt3tzQAkhjkSHsDMRms8b3s9cwyn2CXbKIYbv99vVyUq8cPs3I2dWlXGIdIfYJ9wsdXxnBPYfOxJiduZytVtXrtlvT+AkUJclx0eHoBHFIJlNp0ERBCHGkBffsGqmrHIy6XkCB1aJyOTUCWuRrciYvkGaJEYCki3TGQckvfQweTKZLBkYSxaTQFSigBGDmGEQU992iGYUHSaJqmsIdSS43M/pOTL5fpeYZDKJkid9OzT7M7ovQqbPnlx09TuSWJNB6k64tohBiVeum7bHEomIcHCwwFmDxoiKgiQiUFGMsXssU8dB2A7ahK2xHTCAEEIaHDHj5O831a3UHghDNU5Wx/alh3Eax1BJYmNkX2mgIjDw5US4WaKLADFN1DCeE9E34BVIongghilWmHKbK+9xzeTmu433GGhoOnaPEg+qylQCZkE1jtfO83QrovJNBx7GPjHut8cSiTWGg4OD9LAY0AFEqhIHyp/IimtZscoOEWmM48SlTk/eY4Jvtq+9vd9U/OgENwxjYcywMtmCVZX0ZwRE8yANHG9v0qYPH0DpXv+mHOO6tv/dsCj2F9P2ptuVPmCRK+dc84wBuO/gn8edK7IlovxeURWRpIA8rj2WSOq6xjlH3/dY5xBjkvzWtNSixhGUyeQnaQ4mydUrCDVzgHyykDSMYUkMbHbCP9L5w4Ds3W+6QmVgR+PqHkZ8+G8i7oZPcTJ5kAdMMygcnzJ+J2JG+S6YRHiqIxe7DihO2/Xf6FYrlO07TRfb9L7b/g5js8tBxpGeLFom78y4sHQ7NI9pjyeS2ZwYIkGyCudsmksVDDZRYX4BY8BkgBFlOxHTKd12SEa4MQzsCKyMZArfkp0w4M3tiiB/E9SPAxF3BlHGVbO72gSDJL1AQCXuDFJidJYBEkzBnplIz0xuGEkrUtVnIr2KGyTpztsxGbnsgCOGSY+A2RGv07ZPgCKSuLsqEUHGvuq150oMkN99IPqYFf/HtceLG+vofQAxiYsERTVirKRj00fq8II6Tuh2Ye9O0tCuvMRAAMO5eVIGbWO4ZgrGYPe+29WXztj9Ol839GkKbIf7x4jY7fEp3hivn/QhxvSeCaOE0f4yvsKwYkcokLjFSNQ6jBcDI0mfJwRyLXfaOTZwz10QukNkMSYtU3bvPR27R7XHEon3Hu/9aARSJlhgNHBpxgkCMoDbNLsDhxhX5H7HJ21fMxmvHalk99wtIUw4xI49YmKmGrHPdlBVk01BTMZWw4DHXdyww7Inx0eNZ2JvQTQTzVasDWJgR2TsEN7k9SZcavqe143VvigS2bnT1SaSMNs1YulJ7X0TCSK4YkDgChKxE+0mjoQyavo7gOm6l5yujtEQNTkHGay6V7lOPmlnETxKNR3FUP5PdYtfoiaROe3XtE21tf377hJ2RDKhDqr6o9qgBSmJSLdiNIvhURvbnn/t+0++z6T8WHU24cQ9sD7Roh7VHkskISSVLP0oMWSAZJL8izFixG6pOvUYjVukLgJizLjihpfaf9mtxXOiDXF14qfsf4pb8qPZjm6ygYwMaXsD2F9NU5wj+wOm42U60dTGb/c0nq2moOMvmWgtMYP0gUinAF6mmuCUE17TBrC6lU+77QomYXueiMAoGXgSjTyeSKa6/+6Npgax6UQOK3YqT9Px61bkdSv3SSrd9r4TYHvdPScsf68z46Q8SmvYEsYVHsgUl0x/J2JMKv6gng5ahUyI0JgETKNGVMjWaIPJoulRE/YoNVpEkkEyAqo7i/EK9zNJtQg6KtyJFJ8w3I+3uFozsuthVY+sUgQLO6rpOHG6nQ/NkGK7kq6u1O2EkyBItqUM3Gg0fE1FBYOGMBBGHoh8jynCv2rbyJqPZGApw7HdOdL80F1NbRc7bc/dHh/FT+YUcQTfwz2HpwlGyNpPGqz9864D91H3RYoki3Ec0K+MTsmpaqk6wAHFDFokW3H8qPZ4TmLISpkQ84+gGCJg80MUY0gqpdld4QMrixKzo2rrZNuCOBL22I7e5PuBpe4C0inpm4EQpvccRmdg9desUBnl+AgJxjbQ8Vb8ZULUML1D/m5w6sXxOBNQuX3K8G5he+/h2ZPvE0FtRdW188LOEGRusFWHjTE71uH8VvnkPF7GwM77PLo9nkhIrvMI+BARExBrRwBkVEcVMImU5O8ZBjWZjVNHk0fzOvGS3ngKTncGWHVcldNrd1XTLWvdkemPAnt6PRBW3cUBV0TfwMp2+PNgBTbTC2FQS2H0C6nGfRrfedbwRRJJU66iI5eL19xjO167FuKr4Dr1YbjvcNzINR2atCeY5R3Jwzu4qwdxMsj77QvumHbHid9O3HbVTVb6VL2VrcldJux/uP7KgFzDhoe+jE+Xq9fv3+fqF9fjlaHHjM+ZvuyW800ne1g8Qty5ZhCJ1zEK2XZ6y2Ym547vN4io3EbMx0Q87ozTZDy2R5K4eQJyfbzR3hiMtYk+JenYUTXdVAaOMuCMREAx5kAftoM5cIvU4ewg3BnM6W/JjrN4hRD2/x4mcgBrO4MzYbeDI+5RhHXdsSkxDkB0wGXTtl0oefGooJH8I/ld03XGmORxnhDR7rtfdQLuY6QkptIdDIJowlXD38P7T38PV++TwtSP87j2hFABGSdu9FtkDqKjtzNzmQGd7rDC/euvsukRewgZVE1W6Qg8r/ZtX10ejm0HKA3McHxoA9iNewP5OI1qBMDXqpqTZ0kyWKWFstUaRsyRJ2TAWmOki04JZjD0ydbiscfRdhBaPj4NeLrWtjOIUhlEuI4cLXwQ4GqMHYljHIgx7sEg2UYyDsW1z9q+OJlFbgd2FwtMGXsaSGXfAPRooth9uEy6sy+KhgG7jptc17aEtF0kY7912qe4B4ITG5UJcQxvPQjFQYLvP0unFu69994uJr163URM7qjMuw/eGbsPhEmclMmRN7AyFVKdGYPJKwNltBoakzyj4+DrsFoy2yYiJAQ/tR0kUTbEXibkO3iRdfIS102oTkY+5tU7hBlqHDSJ7KmWyQofJ3N3QEUHoo55/rZ+5yFccErkI5cxjCt0mI8RVw1BH5rPGWdrO4bbOI8tM5ZhnKZELluxsm0TTik69nt85ghod3HMdOwe1x4PXLGJSLLF1Npi/IaBeDKoVQZnl6ab5pffERlZpLBH4duJyIOexVjiwbt92tc4ZDgny/Q4PIapmNoFcpOr83fTVWhyP8zuWeNkTo8OfZh8zPhjsLoM/0YL6+Rdkmou7HqOdfrtzpOuA9uDyJ++33D1OE5Dn6Z0w4RIHi9tnhDjaiwM9o1J8PPotMpkrzIVQRPNYGJ+lgm4vM7KmTgQmZVOzNbvAzMMwzgEbifXfWQw8F0ZWAaxJ4/0zbyftr33hPNMxgimwFZ3Juq65Ttgu6lh7loN7JEdYvSnTS14+yL5ekJ7dHsCkZD8DDZxkqCKtRY1gjUTsTJpIzh6jLy//uW3xKKTVTDI5UcN2MBJhvMGrDFM0z4eMcaMgG16j+G8EIYQhz0cw/5gDoB7GiDF9hk6Xampj0Pk3JR7XQHVoxje3n+/H49rMcZdLjLY0NItt3/r1cj6R7XHqsAyWMZEkjpsTJavW4wgQ2TacB4JGwz4YHRmDfeccJpdeQsp12R7f33ENUPbVVGvTuj0O7ND1NuBn2oF+1xr4DLXAcQrYzUQZn5unKjwCX+ZLehntw/T51+3rnaCp3dEHlfuM5wUY8ye5i1Y33kn3j8BPpZIVAxiLDqIGrMVO6OKlo/rRKwMkzE+evj7MexzGEQdgSMZXL4Pcp/c8rrJftwF12pFe5rBFW45ecb0djuEuX15RjPBjiqzNb5N73fVt3X9e1zL4XSAvNPjMnZjnAMGXvZ4T/PQnpycNTzHDFrHLtqersbcMxi0jOmqZwBz29OmHClDrS20H6/Znjfea7pCd4ArOYQvY44p6p9MhgxaxbVtf5CvB8tpgreXTC2dU83tyrnAYLGe3s9MCGy4Zho+8bjVrpOOqIbdedIR4TCa5NninvdDJo9PqXCJ/W9FygBiJSnB+bcZQxlNViFTp4bYTmTE3yBbBXCbDqCkNI09Vi9DrsvVAdmfwJEIYG+Cdg1H26lO/vUrGW/jkttt14m7QaXeQSrDhEp6y8EJOn3C+CRRtvGlkWxnYFiZEwmeOzF82OeEAytjAGdciYDfwTuZiwwOvg8SLT/12xhjJ50f1ETJq2D6EBmJJensAlFRM10525d/lEDYMdKxy/r3V9UwKfuq3Y77/sqztoa6HULZE13X4aBtP3av27n/yKy2sRvT67fvNqzw/J7jOYM9Zs95ONxJdtXaoeuDhnflWYPmpOH9ifBJe19BR0mcyJjvOjWYDdgjcfxtykFiedPBGPo63GOX5e5P4eNeZDpxU1C3c8esSu6opNMBzTEru7wng1m5CmYfNTb7x67tt+6y9aktY6fD14it4c12ueTVPo3XmH0H6PZZifNNr0oj9iTg+kRMkjiJnRCFzY9OqyCqYIZgltGWMkxICg4eE63zIMTMokdzsG6X4aMA4xUcMrymDCkY7Bwb1IBRHEzF0/amW2108FDrVTi3Y5Hd42SP0hC23Ox6brnDKcegI4ExHSXuXLljGBv6fs39Qo4iHDjSYLUd1OmtOGSEj09qT0ipKCbiJnlvB3VuwIvTrPeBTaZj6R3FGKLGROFkb2V6qxHKyliyYnu//Ym5Orjbz2YKXKfn6VYU7V4EVhj7o8OAihkzFPcnfRoWOG3XEcw+Ie0TylbtTt8mDjyozcI+B7lyh0docMMC2MPF23RUO/G1CSPhPFrop/bEXGCRwYNrJwQyPEgYfS0TjDIQyzBCCUTlng8BS4NXeFjtexrT/grdJ5a9nm7PGa7Jg2TzwGjYiiWTOUZizYO1OA+W7lpgp30ZCOW6vu1qJo9fnlNtZOC2On6+ynsGYhqiyqb9uzoUg29nG1u7td1Mr93yyw8kbgaMMSLlUVuZsMpRzDAZ6OFVt6vUDIQE2TezK4Kue+nr7BPXjMnIhXbsFMKOWsnO5A7ZeIlYY9YIptFsj1qp0++ni2L/uh2xyXD/SaeHjuRRUd0jlP1X3QPJ14nn8epBrI+VHyb3fcxtH9WeYJY32aCWDWgKKjGlc+Z5jrK1+w4mbzPgsW2UcU6/MCOh5KFJA21SdNS1wG+AN+Pq2L5eitMc8gYzcmeg49wJVXQoBsNwPK9KAJMjd8c6KIOwHoYgcUHVIdhq5NPXYoN0aCIqx6VyzbyLjsSz9QInbq2538MkD3cYeMBWVOw9cyQKdhbF8CyG64E4GiY+UOmJvco9w+Dn39uEqu3qSeqkjJMvImNQi7BVl0VkO5nDUMj0xQb0xeT8PESqiQCzejgar2QbTDTlHEM/hmOqk77q1gI5bdNksXTplhPsiLXJsetFwR6BPFJiykjY20Ds6W2Gg+m/HczzCK637cFELKKMeXTXvPd17X1ikq042P887ZxMXhR21a1keLvGIajXjcjOGVfEyfSZUyKaaiVT8Hf11sJQkmwqrnS8z/49JhzoUb18AqidEuIWXMognRNxRB05tlwDnnfeYAf/Pb4f2z4M0WlbQhfIUT6Pbk82y086ND12XYcH9prR6g7xWGuRuD1/6Pb7aiOH2R8YmaRUZCkwyvTch71+7txvimfGdMutFIc9jPGYHj9K+9nlAPnQlL734EfM2MjmfjyJW12rSUk20O13Z8JN06IduvgBiOQ6dXP/76uAc8vuR0KZTM4jnyO7J+zcN0ObwcI4iJ2BGKYDZSTFmIqR/HxSDRJ2B3RE9lnj2j7zEYa0KQgd3m84fg1xjMHZ+dzt8/b/31pu4/BeuiX8fa1v+Ht//HVCjFOOsfMdySmrMY7jZpAn8JH3WRF6ij/2B+J6u4WMfpiETSZq7xO7dOXhEyCWfm81CzC6rWciTAOcQTWOqvZUXEyUA0B23PrTbx+tcl9t+9oNTKzBw9zvcVjdYslcomsLYqNqiqy5pg/XqedjGS65KnJGDSz/LQOIz6xUPggnQYdJn0ScQQpnzA8brJ1bNXYLRM2gGg+d3cMH03e5whmnV+1VrkrPiePADyBScrBPHKPErln5k49be87gJ9l98iPN7PuDNDl/h+sN3w5cYEIsiRhky4lk2yclGflGkH5Nf65T1afg+gpWGX7HOM6hhrw4PoiDz44GtJzlJbueDmViclfNuR86cg4y90gXJdvm/kuNbPMRwl4GsAGMgTtGB9iTVbt0/5TYLlhxgBJj2CkuvB1YEDFZxRyfNEq8R+EOyRcPGtIQfSYiWwcu298DXQzccLSeiuRoeJNDLYf3mXC8CQCajtWjgOnIUUZRk+61TdoCo0kJ0KkKBTuA/7r2BLP8ZAfWTB1mgjN0gsxBxrC9odPDSz2q2O3+5E1X7RQ0J5d2MtqN5w7UqooYO+a6mMG3NAFoV9vA8fTKuVOn4P4Vw6tuTeWT4VG99j32h1/3kOp04qeVG82EK0/Pe6R2uPe8a4H0QIhMcM51ndxr7wu4joNo9iZ31GSyKMmf9wHuo0zZ1z1rfJ89VM/AmtOXQFq9Q2krGNzku9fsm/Wvt9pO+jZZwVfPnLD4fOp1BPUoMSWydW7GgRVNNLYBlCdmErccdAq4HzF+4zOGP4aApeHYNYQ5cK0PxEl2VqPsdmzEywM43XvOdBVfxyH2J29/AndRff48svHBKLdfH2yY4UHWX/9eUz/TlbqrOiHG9LAp6tgBzejkPa4Zu52xGruzDfu8ulDM9n33scY1nOoKwctUrR3E/cR1EOKVcR5G5HHtfRnT8vN3mjFmFDdmGDFhLwBp2/YJYIfgrlndj14xO8KagXPpyDcHP9NV7rV9/rYfw/fj4E3Y8cixhnuMq3x7fPe+16Rv5DGaLqrt7636ex1jeBxovpYjMi4RRi4qW1G4L4LG+39QcbPFE3tyeBy0HAKQg4nIfpL9fJbp7ynn2F8hj55YM8mk32okU5a/Ly7eT9vnbNetqi0G2QWPQ98fp9brdtZ2RjDFom2RbrrlZMze5zvs4CnVqbsMBm2L7bBdP74fQNwMMSBXsIkMlfxGWhk7tE8Mg2qXjk26tM8+B00lv80QExGJ2AxGkSkNDOJla1kcp2oQBTvTlzqSfERme/akTwNw1Z37aOYek3fda1eDvNPfWzvJNVxnHIjJXfbHY+COsnPatW1n8sdhfLwY0SsDd317LJFEGIkhhSVmeS2TqMtB0sjWRJ7mYesgu2qr2eKGkeglptWlMubqpDGSrPqS5XrWBHQYxS0+SMahbcUhHfGFZvzABD/pFrTld9pWaZyivPxL0v13AOSUA7KryY3AcBRRDP+BCJbk+X5kKarc7y2D2/rFRvE3jN0eR97e4vEq86O+22/vG5MMn2GU0tu/Ze/cHSR95dD2Prr9LGJyMFDiAPsL6Grnhv+2yQHj4Um7zpQ9ls3IRBomqQaPe+ajgfVVI9b+JA7X7E/Ljq1oj2M/ru1jukcZ197P9R+oZpqVqUqZuEnMFrvpaO4XkdlpI4veYoihk9NhkNHoIkic7mA1Mcuzz211i9SypmIyp9DtksvEoEmtHKSUDjEVQ/8mQT9PWGD7mOFRGELGF94NhnqUGj4F0IPF9uqJU660e/0+ztvHKzvPnSzsRzxpbI/3Au9T86hSTQaB/ZfO0zoCqF3uM2oH+/gl44Wh7rph+t1VMtEJB5memyZ+WIkDO0pni9kSkhEhTIZnive2r3uVcwzHZf/4KFP2uIluxe3QJ52cMyWO67Wj68aYK+dcx02mi3dcNCJbS7MZRPojbw08CZMMK9OYK6tY5OrADR0bJnXLwnc/54M71wlCyAYkmWwzoprxj2Zgmx8eY8IwdjhTddvfceCnoHkg0vx9VAZVYAhbTMHqV8Xr/iqccsEd7Ywns/ndMchOyb0dud4vVpiO3+5td99hUNl1BGaPrnR9XXt8EZupWR6uTMB1eGUq3Kd4JX21O6DT63TQOka5vdWsBm/lFsRpKneh+e/88jshigCTTQmZ8oxx6zJFx7JyW3A76R0DM95b39t77R9R3ftm+PZ6u+Z+wvo4vmlwxvN27UZ7QncPwzzajHDNcR1G+tHtiTXTpi8wPGjfnrH78InTD0Z2P/w5TDwyzQVhR/zsE1IQMEQkJkKKKhg6MJEoBhuFZMeMuZapzRdHrEaEAAoRS0TwMG46GcWi4kDBaEBpUGNQqZAINnpsbDEm4GNAZYbXmmAElUAhglNDxCAENEYiBSoWxKd+aTaaDXY+MpFLClMIMeaxzq6PAZ8NkWuqyCTO5Spcv9quEAgD/kpcehD7Yaxj8uj2hHiS65D3wBp32dRUrm6/2n36sEvC9ludIP60jKdiYTgnLW5NJa/FoOQNl4RU4TAk3BJMTBOh4DRAOINuRWhWiCmxB3dQe0RQg6HDapfr1DqMgFUPqnit6LzHGQ+bt9hcvo6wZrNpqWbPUBy9jM5v48VickpGCg9vMRISMUqRMXIg5neUYc0OscPsBjRPcPZIWILsbNw0iN1xZCXnS0+40DAfO23L6pgGWmsc2ecj2xODjp6kjm13ZZCdn8eZfwdWKjBmmI1Yd+9ZiSGk1aWkDZp8HkSn4ELAqCUaQzQFSk8pLbK5z/q936A5fZNmeUqvM8pb38Izn/hBDBbTn+BX72DiCsUTYqDrN4jeojx4huPFAvoz3v76P+fsnc/TNScclEesimOOX/gMRy//ICHewVOA6XC6woZzNDYYswCOMRQJSBuf3y8RODpojQMHlJGTJrC7O4ZXx3+rPGy1zz1gvT8HiTQYrJQyOfrIOI3c3ldk2rQT+3YHERkToKbHh2uuA3xblrltj1ShSbt0Qcy0kiImLD0udtjYoOJQqYnqMFisevqzd3j7cz/J8v5XWV88oDc1xZ1XePrZZzFFwTtf/VXW730ZEy4IsaOoSorC4kPJsnc8/fxL1E45+cov8/DNr3B5+pCbi9sU8zn9uuHG4fMcH80JgIkndKevcXnxdfrQ0Bd3eOql7yfoDZQSIz5JDybcJL31ziLeLraBiK6fvOvGbn8chxTdHXU6qVWJRDRzbraKxaPa+woVuI6qd/T5iRo3dPRR3GQEZMNXgzb2OFvLEBOQ5AtOe8q4Qtfv0rcPiarYxW3m9T2id1TiaS4e8NYXP0d38TZGO1oE1wUefPWnqGY1D77yS5TdBXQbLpYrimrGbFZxubzgZLmhefASt24csX7vVdbvvUO/bHnvdENRW05OH9Csez76rT+A2I77X/8C52+8irUNvXVcli9w++63wPwmSokNJrsclEjaOCqQYmQG3duI5CSxgQquDzJK4nk6roOIumpnGeZiHOZxzLca5ajxPKY9kUimomTadjDINe064hmoVvIHnXZat8R35V7kXSvU4og4bbl8+wts3vsim7PXOT+/j5qKp57/dp594ZNE7XjjSz9Dv7lILvcApYWwOuONz/00N2/d4OFXv4ALPaKWPlqOb8y4vDjjvXffZePh+adewvY9xnfUhSUWglpLVZWUTmhPvsJv/cJrrJf3CctTdJlEVl9WxDvC8vyExeJFjBjKsEERfAQdcVniFqLb6D0zTOqoYemVBXqdDWS/XRePPE7A9D4jZv0AnOTaiZ78Hr6bRpE9fqftgXKv+f6qZjc5KaAYRB1WFelWvPfKr3Hx2i9y8eZX0f4cRNm89ps8uPU89UFBWD/k8LhifRHpmx4NirTK6auvUK7vYlc9JycXRFtTLo5QNlw8fA+/7igXM87eO2V1fkG77Gkai9hjTOUQuyB0Fc1SwKyIDbSXBeIDfVDWnYdZhzMGazwxrBB/n94r6ubY8hi0JlKS9uvzw2jvTKAMK2kyF/tzc53Yno7pdN6mdpFkNpGRY13dGmW3PWErk210e7bBjIYr1WF7kl2V+DpdXDNkTz45GeBbYg7jhtSpSE5Kt/SIBNB0ps/Kq5WCqAXWVsT2krM3f5t4coIIlIsZLkb86oROHaH3KHO8CB0dIXroPbJpeHP9JrUrIAjdpqFZeU4VYt8zLwW6nubkIWd9Rx8CtqgpqwPA0PaKMwGjka5v0WhoWke/iRChLyzP3P0ot28/S98/5Pytz7J68EXeuX+Cmd3mY9/xoxQHH6LhFj7H/ZqYsZZ4ku7hxgGfhEzv/M57XCcFQK4Z7+k8jp+31RvSXSZuim+USNjZfjQJSzPKxHiFIK6AVNkNxFUGT2YcPqFjL322BUgmoXSVqKWQDhsuEP8OCDhZgd/gmw4RCGohVhhv0T7ilx1d6+kaUApsaVFt8UHxHWzalrhQrLGgPaHviQrOpUCq3veszs7pfMBVNYvDBRhH1/T0XUsb+7wQc7hEjAQK+jZQVhW3bywo9SHvfO1zvP4bP0m9vs/FasVGC0pdMb/3rdS3Psrs3kfp4hyGuNy8WDSW2Zrjt/M3Koh7do33bZ29Hl+mhfoBouV3bj8AqvHmuzk3+8B2X3YCeQ/hwaDDaD9I14UE1tSlqPsYgD6RUXPCw9d/lX75GmI6HGDah1TljNV6CcZQWEdUWC5XeN/RNh2xF8Q4rKswUkAMtBvwDZQuYp2lrAvoE5gUY1FNO6mHqPgeYvC0RUPXr7k8v6TrPSJKWRq8V4rC4sqSSIWi+Cbw+hf/Gffuer72pc+yfPctDoua1XqJlo6zNz9P111SXLzG3TJQ3PhUMhISkagETWEQyWe1BaVbPj6Yxa7ilHG+9pSK7bHdc4bf+xBhvz3RmGYmvEh2iGAbtzFF2FPANSUW2JZ7SOfa0fYBECkBoVCwYUlo3ia298GvaZfvsHrjN2nOXuXy/D5WLAWGovDYsqSsFogt6HrPZtMQfc/qck3XelQMzlZYCtpNS7PqEWDTRg7KkrqqmFlD7wNd79PmlKpoAI3CpvFs1g9xhWNwUlZ1QVE5YtPR+kCnHR2Ko8b5iF68xyu/9I+ImyV61vKQDX0I3H36DmG15rR7lebNt8DOefnbKjRC6FrwkbK6gVZ38MyT1XayOoehfD/+lnEG9whoUEQeaXS7pj1eu1F2I+Sznp18Mnanw2Y0xV9P1embIRDHMEAuyZvDKAYToWBDe/ZlTt74JaR5m275gFVzTr+6YP3gIWfvvUdRCEUlNJsOjQ7UEL1yfn7Jer2BGHAWKmdwZY2RkrOzNetlhwWKMjstnaOoSkxh0c4TxRJ7g+86oo+pOnQeyL732MqCMwQDVVVSu5Kg0LY9zWUDXU8lkcpBIw2h6xEKesCYiraxnC/XnKxOsfMDnrr3Gq/+87dQAyZ4/DoQixvc+vBnOHrpB+g53Fui49RfO8GPJx69VjI92j61bU8OOtp7UEqOyhbSR7C5/U4M3yU7wRDkErGiGAKOntidYfyKQpecvPfLrN79DeLyPn69xpue5cWG0weXrM97bh5WdF2HqhK7iNpI0zW0m46qqNDYIxpwpcU6R7Pp6doeUSgrS1EaTGGwzqQypAJdH1K0G0VSZX0g+sT9FocVXd8TCNS1AyNY6xBjWS8bzs9b+k3EmoitwRlH6C2ND/QaafqAhsD5yX2icdx59nl+4I/9MVbnb/GlX/6nRAlY30GrrOMBb7zxNt/3F74VFgfbxZmHPw3m9UD1OtvUlmNchQKPM2FM2xPSPLf5o4PZeOvZzb1l9+FbX0xqZoeT5M0eB+LTiJUev3nI5Ru/QFy/g/glD9/+Cg/efIUyOkxwBPX0rXC57Ok75fKixYpiXQEhcr46ow0GHxRnLM6WGAI293G53OB7xRowJm3HHjVFpPkQWC0bVquOspwTguI948/RUcXx7WN6v+Hs4SXqPUVVE7rA5eWay8sGjbAoDEUdKUrACl0E7wxN2xNaCF1AjKGeG24e1rzz2m9zef9twsmaJjSUMWK90nQ9l7yJhJA5r5kYwpTdVMFdYhj2yLlO1A9zqEzU598VIhlSJIdUSs0q62gSy3/n5wz1NSa6cs4xydeqo9CIiz2RgmAcxPs8ePWfsHnjl2jP36NZntNtlqxOTjnvIr4FvIA6/EVH6IR1J1gDZa1Yl55vQ8R3kaZfI4XBlY6iLIi90DSp/66EcgbGKNamCLvL84azi5beB8ReYKxgMXiNmAKObsyZLyzNBpwx9N7QbGBzsiSEwGFliCFgrSBFRTGfEStDI4lzWRuJNiAO6tJS15HN2dtcnLyDRIvGCvWeRj3WOYx11Kxwm3eRwxsEWRDjDIID0xPZbAkjDkuPSShopqU8SyN9kTWjuA1DEKYE+I0SCdvdI1Mu8FVtxkzCAvbsZrtASwAixICKEkl7+8Vmzde/+Gtsvv7raHNJs17h+4jFcHhwBE44uX9G2zaoz9qzM9jSYUqLmjR5EOhDQ8yWy3bT0XeeGDqiV4xAVRhmlaWoLF3XEWNP1wb6NsmVoeCej0qIYB0oAe97QvREUdou0LSeGOFgUXLjRs16eUlEcbMKV82QMqvFfcT77KI3aSZ933N5fo5xM6ytUhUmWxCD0EcwpaGynq/8wt/lpc88pLr1HMXsabA32aglWIfEiB1LLOpowxooYuTyg1jSaaD0xAkbh+8/AJFcsZZeY3mdEszgVxjk335AjYoSLQkgIslB11ywfPM1+gcnCD2FKYjR0zYBGxPGOJiXONMiElFxuLLEVQW2cKhYYh8J/QYPWAv1rMB2PU0T6buIEygclE4prGKtohLpfUvfDztkgXOCWEvfpWTzroem7zkyFW3XgwHjFOPBWKhn0IU1ptRkJLQyiuQYoOuUtsvGsgDRCr6P+BiZzQ3VrMRVQlwqGh1934EEJLS891s/x+W7n2d29znuffjT3Hj+M5Q3P06vN3L03BagSNYa941ij7JfIZNUmWwY/YaJZGjTHNvhQfuOpH2r677cSymMJltqPWW8pIpnbE6/jG3epZgV9L3FFCUGjyXSeGG5WjKzHmct85nBlDVSlEQsYh0BS/A96hxSpHqoIpGqTFuut5kwjSEBVmuoyoI+9IQAhTM0RKzZpkgWzuJdKtLnfWTT9tiiYH5YYJynrJUYIkUlzBc1y+Uy1dp3Qgie1brhcrmidEJpS/quIfbQacC6NC7L5YqeQH/ZEzsoTZmS3UPPZnlBIZHYXnB5+jbN+Tuc33+H57/dMr/7aTrswChINeOGqBtlu6XdVUA7zlsmrGFHjFQS/gMQyfgAtkRwncp0HQDa9/ukDduUMpxz/sZvcvLeb/H2F/4pB7NIKOfEFgKpMoEz0K1bNu2aEALWBaq5QyWJjhgjsQ95OFK0WtBkI7bWMqsKzLHl8mKDNRUhBlxhEBexRU2t0HWB1vQZTivOJG+tqQxdnzZ+qus5iMMWBq8eVxqMiWgIzBc1RWWxrcGoo+88F+crur7HWAhR8E7wHkIPohGbCdbHwHK5pukjhRE67XDWUM8EYqALsFx1zA8C592rrC87PLf4xA9+CFPdzFbpSNSYt5HKgd6P2DT8WoA6WI0/KCaZ3O+xD7waxrh/XEE8JZecv/6LvPYLf4fVG5/H0FHOZwQ1uNISPQz8udssCU2gy4dsbSgRuq5ntelBHU3b4wpHUEVsSjNt246ytNjCcnTrkBAMISbVXQwEBWtmiDTE4BOXjCkkKErSfpyFuq4pihoRS4h9gohGgB6R1A+xINah3tCsWtpVT1ULziUsEH3Ad+n1jQFrBWMTDgge1IOthKoUfAj4kOJ8215RD84KlYv45oIH91/jY9okLs1Q7nQalP1+Z/Nxs3u1PZ5IdlSkR4emTIlmKIGt2fA2bJgcVbHS0m/e4vSNX2Xz7ucIZ+8g1YLeHUK0hK7j/HRJ0/SoV7qLFdopWINYoW0DYiNYS7fpWTctqopzHcYI1qbNrmPMAUpO0JhM85I3co5E1AcsFt9BDBFj0+S5wkIhhAhGHHVd07b5OaSqQClyP9mhuz5iSxAp8F2k3fQUlsTFTESMpWk8IUJVCIuDktlc6PqG6BPHcxaKwjA/LAjBs248IUCM4DvoXARTYgtLWRvEtgg9A0YEtjhwFDTbNjGtsLXeTnwsO39/A0SiAgGwAxEM2spw62t17Jzjkk9Mke55Xxy/4eL+qzTrE9rY06jhwNRID8vLM05Pzlk1HbYoqVxFZ5P2Wwj4EIgdRDpcURJ6haCITSLG5R80WVkDjqAOxNF3kc26R0OkWW8oLCxmM1brBrVQzlItfOMKqtrRtZ6IYXO5omkCIaYNlp1AXSeNxBVl4iJa4dsNy8se72E+A2N6jC2IWNreIxYObxpc2WJsfilRjAkUNVQLQ7Uo6TpJqnwT0ZCIwNaG46fuYQ8OqCvP+tWfxR9/gtmdj6D2iKjZY8zgZZ+Cx11iEYYk9eQO2fpzPghwzc4fURnTKWSoby7DKYNZftBkJsXkcpe2eSU1kdvMjz+Omb2BN6/iZY73kdV6TdN1lKXDWIt1Nll2Tc7/IZtrgsejFEVS4frs6xIRfFDExOQANCUaaromcPrwgmbV4fuEJZwVVkVPJHJwMMsbMClCgfdC30eaVcvqMmSuklTYXsG3HjFQlAVVXdLbgsvzhvW6oyqhrAxGUqpG1/eEGDiYOw7mDmsg+Ih6xailMBbnDHVZEzqlXQdiZzGhIISIMz1VUfD03VucrpesT1/njd/ecNr/Jp/87j/Fjee+i1aOCRQgLdDlKX0EZxiqYE+K58g4S98gkYjkYjEDMs6Qet9mkohja82R1B/QXBLSJCKZVze4+9Hv482u4Uv+cwS3ptWWzfohHqWc1Vhrsa5IUfCSw4SThME5S1Vnmd32BJuIRDWZ+q01CamLIQZDs4ycPTzn4nSFDhtTAX1QvA9YC+uLBuPAOIMvIm0baDc9sY1UzjC4IBXGsYgxon1Pp0l0NesEVMvaDWExCELbeQoLh4cVhRU0c8PQRdouIC6bBXwHCn2ndK3Sdck6enBoOFrUrM5OWK/OuGg73MP7nJ0H5l65+cdu4Y4+TDBzAKwawuhk3fXLbAGqDkabJ5lH3h+RqCbELHEiWhIpXusj2Pp6Uod0CKoBZqVj4YTXvvAl/tE//Me89sVXeeF2RVkGutBTVjV17YgxYMUSfMRZi5JiPdImE5EQlaIwFE7wPgHMQfcXW2CdI8TI5cUlbaNslg0EcAKuEGxhswEwMqsdxkLbd0QCXd+wXCfL7a2DGSXQ930KHVAhBMUQsYUQNRA10LU58NgJRT2jrizeZwMenrouECKrZYfESPRC9JYYPCKR23dnHB4sODm5QH1PNCBFsscsFhDDmvtvX9KFQO9hFTz9MnJWfZ4v/OLf4bnv+VO4O9+CxjmoQ0zYGtGmczlAAGSEIRr1MbDhfRLJwD1kfKhMErKvnrvTqVyz1aDURcFB6Xjrt3+Dn/wH/wVf+sKv0202/Pbrp3z4hRtgDgltQ2yXaEjYwWLJDmI6nzSSIkJpLUVZJrZuOlynWe47ynqOKxwaI6vlmk3TEINSV1A6sM5gyxLB0LUNse8onMMZpddEEF0PBGibLidTCbYsAcP6Yo0lcnRosRbaLhB9IhpTlpT1DOMMBkPXbZjVFVVZ4UOHBiV0KQQhqmIcHBwZjo4KysKQovGUooCyFLBK1EDbBqIVOq+EWNB1QlnNIXQ8fPMLrOeHfOsPv0jQBWiJ6iaRxLWqjow/OriApna5b4RIrhLM1owrO+b4qRVWR3YrYiiM4bAsePjW1/m5f/z/5be/8Ots2jW9Gi4ay+mXTrlzo+ReITjvMTGgIeJDQvnOGIKLiAVbFRR1RVFXOOOwtiaeL2l7jysqxBZgDKKKD5HeK4UTjo9maOgJGqnnNaGD5rKj8R5DjzgZqx2qBjSC7z1l5eiDR7ylx9J0EScpWGmxKHF9jzYR30FR1hhTsN5s8H2P7yKlWDQKqo7ed0nkYfHRszhyzA8rVAwXqzUYiy3AuhzthiFEpW2UXhSvEA2otbgbC1r16Oklx6HAaIExSojNiAmvEIkORDKIocHZ92QqeR+B0NO/MzEMSI4ETbK2mz4P2owkY9SiLmlXp/zCz/wkv/4rv8Rms6ILgU0UNqHi9a+d4JueP/rpQ77t5Tv0yzO69ZoYk2pYVY6K5L0tyoTgoxq6IBhbUVRAE+haD8ZjKAkBfEj9tAZ67xFV+qjopgHvaJsUczIYCUUM6gUriicSYkpxiKp0TUsbBR8is7mgovShQ6yhXtQEB20TeevNdwkhpBhehSaCsxswQuEEZywhRtSAFA5b1KxWHSEKxta4MiIYYkxcLcZAlxdNFOi0hxLa9WWKwq9nvPzcC5T9Gi1LgjGI2lGE7KS2yJZpDI7BkWiu2Yv4fRPJaK6RSbJ4yOkNo+adfyczBKKCxESpZeWweL74xc/yK7/401xePiTEnj72rNtA0xecrz0mWp7+8Ec4vNPTOo91ynrVICh1CWU5I8YOciZc7w0XF2uajWez6dPq156y8WyKgvniEGsqjElpnK3vcJLq2y4v10Rv8CFNVjCKMWkxGFKRYAXUCBiDQbBRkV5xRqgqS8QTEJSCqI6u7bg8TSmexwtHYVIaatCQ7DIq+D5QVo5Aeq5KQR9KvNpcrlMwBYQQEhcVQ4gdhIgFvEJZF1SLBS9+8lPIbEbnG7qLL3L/i2+zePH7kNufQMPO/I9t8KtN1V/ylvXXp7K/TyK51ooq2Zcku+dtt6dPzNJZYVYazu+/zS//85/n/jtvEVRpg9D0Bu9hs2np+sBHX77Ft37yWezl65SzGuk8aIEPHqymgSXFkfsmsF5fcvJwTQyZZxooS4NGT9ukwGYVEKNjt4wRnBiswMon171X6ILFmSHGFUwhqFdCjLR9jzVpYL1XCpPuKTbB8aiGvk9GNPWB+YFNam5UrHEYA84IMQSMJlM8kizDpnDJ8msdxihN07Jeb2jbFGRtrSF0ChGMg6oWTAnzueXWLLBs79Ntlnzl117DzO5gH6z4lh+6A+UdhkpR03nbd86KyFiyLDzKlv9+iGTXkppzbCa2u/x0hqDd5PkVwFNXBu1W/NZv/hpf/uLnCb6n18A69my6SNMI999b4vvkAxHtKKwQjcWKo3AF2JBWE+DKEoOwXvVcnm2IrZI3taIqDFVdYGwKXO7ankAmZpt+h5jEjzOCtRGvinphs1FKBFuQU0jTu/UBJCrOASJoUFyZVHFrHRhL3wnLy4ZmE6gKKGzioFU9w3tYrzY4p8zLNNERpYtgrKEoK0DZrNes1xv63o/jGHzAUhO9hejB5eqWInTthi/9+q9SzQowsFmv6e0Zupzz0rc/ZHb3djKZDUQxYRJjLScZMhnenxL8xP1urkuTkMGltAeOkv0kYp1QWOH0nXf43Gd/kfOzh6jCJrSsfUMbDA9PWx4+XIEKX3/jASdLi540NA/O0LZDTQFFgarNPheh7zyrZUvfJa+ts4PLvqCoSrq+xftIVVl8UKKPGOPoe0+UtB2qQcBCDElUtl2S97UBsYr3KWqNkDQqYrpOYwo3KKoUw9L1sFz1tE3ECMzqNFapkkPqb4hQaPquD5E27RCPNYb1uqFZr4itz64FizEpTqbvPMErXRsonWDEEvqILS1dm1Rv7yWp2kFZxZZ7L97k8PAurW7napy3/F/Cjrt+tTRvvxspFfvRRJIGQmVbhSgZ3hIwcc5gCLz6tS/zyte+QheS5XHTK21nuLjoeOONE3wvxGj4+tsr/v3/+Kf5w5+8xUtHNdqu6fs1Io6yLCgrh6jBd4GuC2O0XFHZ5CPJCV6dV/pWEVXqqsSHjr4P+ChEa/FRIUb6oIRADsJO3IFMEAabvLVAVaaoMx9gXlrqGoxNzrWghk3T0/eRwppsIU6caN00aEjYrK4MB0c1y01D8ErolabpWK976tJSFhbNnmtjXHq30uJ9jyuUWWWwNpXa6dueYj4DtfQRut4QfYBqzsc++Z2Y+nDUVqaOv6SV5qnLZSqGTRzT9H0ATDLkY1xncNneWMaIxUxROGtpmwte+dpXOL84o1dl1Xbcf9hzftZw8vCMpvGoJutpUPjCa0sePljxF37kae7VJRI6YpcjxxqhccmHpHHABeDKNBC993Ta5GBm6LqIlYgzjrbr8Rj8MEgZqJWFS0QmPXWdIvAUBxoQTarz0WGBRqXtImVpKMpUKKfrIsu1p2kCMYcA9B6KKu0M2jQ90SvHC8vhgUUl4KqEfboQCb1SGKE0DvAjcVhj8D7gu57FQljcrYm9x/eeoBAINM062UptUpFVhaqqmC3maa/Dkdsz7qLBaGmdqrsymcvHt/eHSQYzvG4LyiBgoiUV1gwgYXQeWVPw8OSSN159i67t6ftAt4mc3V/y7nvnBK9YUmE7jKIGbOXwlfDFr1+y+NgN5jNLYdcQApa0QbT3If3OmlQXAnWR+Gi7afE+vXEbhK4PeDVcbGDVBuYHNVWpOOmQANYoaiLzhcPZQAiGrkvWO2PS5tKlS1Fs9YzUzwFXdMp6qbRtihPBFLQqhB66tiN0UJWCFBaPsOx7irLGKmhssTZSugJjHbYsMWIIwdM0LULk+KhksTDUtaXdKOu1p+3SvEYfUAOxV2IwECMa17z2pV/iMy9+HFu/iLeWgMcZxagimlTjEacxNV08vv7ME4lkSihbA90g9BTBIdGAzRWGiHl7s46H777N/XfeRvsev1nTXWz45IeO+dEf+ARf/fJ7fPbXvkaHgHO4maGcFaDCV9/yXJ495I9+z7Mc1RbTX1KIUBYVTecJdJgAPkSiNXgjWInMbRJdq3Vg3SX5f9ko677g7LLHXHQ8dafmxrzCxJ62D0gbiNZwfFhiHGjfpmpMURGTivYNWYdqU+kt31maZY/fAJmwxBnCKsXvFgbqUihnDjcviZVBXEUbJKVsSKSqoChKJKFgmr5ns2ogeu4c1xh62mUgtIbeR0JIo953Kfa2msFmAwQLBGhWvPvFf8bXb97mue/9C2h9E28Kggome3g1U8V+RD0iH6yO65RQdkBqrtKcIEhIVk5ToVFTeHO/5v67X2S9fI3QnUO/5l/88z/M937X8/TdmldffZl5EfnCV+9zsu7YrALtKlLYirWPtMued04981s1M/UEK/Smojcdbj7Dt55u02JJ4ZAuA+zOe4Iz9CZysQk83AhFPaezhvW6ZfP2hhefWXAwc2Bb1HveO4us256jQ4dzDrxP+xpHCEFxkp4RekO0B6zXHevLDotj5iw9Lb7pCEGZ1Y6DoxnzhaUowVUG4xyiBU3b0DYt7aZFEGLvEWOwhaPre3wfIMLlRUdpU0Q/TcA4m1Q0ga7vsFZSsrgmEWkUaCMsT3n9cz8Dh0d86NN/nE1/D5U5Kh3RtCg9RLez8GHgKh/QdwNbFLyNY02J3GJAY0CxJAuRUgrQnXHnhue/+6e/l3ffPmNWlXznd7xIt36ASMuLz8Nf/Ve+n1fe3PD3/+EX+IVffoVV62n6QBRDo5HPvfouLz71LKvmghBnbC57Ts4uk7W1D7RdYFYXHB8VVNYQoycEi+LwzqFlhD6wCZ5V17PpUj7Nw8seV5VJFXYlfddzfpliT+eznOLJUIErBUYHr8RguVhHLs46+haqImIkcHQAUhjqw5K6rqjqEpvnNaL0jbK+WLG6XGFNpK4thU3GNd952rbHOIMzDt/3rNaRUBhcYXLBvYgrUhpqCMl+EoNSlAWrTZ9yiRRC19Osznjr7Td44Vs9uVbgQAbJziRD0PPUjbJNtf2GiORaA4wkk3yCRj7ZJkj+EqMb6C+5vP8VDosN1fNHvPjsPaKP9O05bRdYN4pqR2ECz9z0/KU//a08e8Pw3/z0V7i/igQcHuXNk45X3mm4IQVvvPOQdZOAlytAKdk0HfHCc77SJP9jIIRIWQkRS9OmSLJms6YsBLtIXnzvPZtN4HCeTPHWmeShXlRAA9YTjIKztJIBrbX4IKw2PZcrTylgTaSsoFhYbGlwNVir2CIN6+qyYbVKnAMfKAphVhUpnDHElERWJOykIaR9A7PtomkjLkLOPSNklTiBUYMPAYqceYBAUVAd3sTcepEPffsfp69u5bimDRJDCrvAbS2tOwsezAfaqPFxBDRmkqXA5dJ4wuZtHjz8EuHiTYxP5SGUkCxJIcl9rx4nCypnWPv7HFQrvv97boMp+Hv/5MucrCBqyfKi4Tc/f8KLty3rzlDNZxhX4IqKTdMhsaQwhiZ4fBswGHzfsulzkbxsVS1K4Wi2IASP73piF1hvoHQWdQntF4s5UtdorOi6FcEpMpvTOwg0aFQuVh1nl0l7ms2hqqCaG4qDAinMuCll27aslyuWFw19EzAIi4WjKAQhZi4SaVrPrBZmJVmdVVxhk68GKCuYzyz1bI5gOD9fEnwkBk8MaYE6qwQpOXrmY3zoO7+fD3/XD2JufJxOagJKYfqEVLVgiKqfzOAj/v4GiWQoVrM1vqQdFpJKadLGiH7F2f2vsHnwBUq/xKqFqDT9JUV5gMYaDcK89ATf4vsNtjB0weDKik9/6i5t2/BTP/8K6yby8vO3+d5vfQG/OuHth6dU8zkiBmMLFlVF0fmkLjZtCkiyIRmwQqD3HjWWoIKPgYMy+VNiLYS+o7YFXlP6Zz0zHBjHaSt0rWG1LNEAITo2faB0Bb7vuLxUfICqJDkda4OrbMrgMg5iweXlisvLNb5XJEDtBieloShSbI0gaBCapmdWCmWV4nUGcYCk6LaDA4OzyiwnxhsNyT8WIeZcHlsa7j39DH/kz/z3mX34u1nVR5jQU0SLM1VOvvJESQlxdowPmHjs2XWxfANEYpDRGjfUJEkPGkw2KkKUiFWI3uJb6JaX2CgUdZ3sGH1Pacu0oaImW8Jqs6ZtE+AjCgUbPvWRI5659UneeOMhd24eUxc9D843zGcFSsTaMgl7LKoeV1gkWqwoVWkobC6Os2nog+WyUZYbj5QdZSGY2FNIMoa1vWG5sjw8izw4vaBpI8tVGD2i1gizCm4eWg5mlllR48qGwkZcaVHjUC0x3tJcblgtl4ToMVGZ5+i0oigp6hJbO6wYfNsS2g6JSmFTjZSiSNuaiKTMQWOgLC1FUaCxZ9O09H1IDsiYUk2KUhCnzA8Mt48Cb3zln3LUP2BtaubzY45f+kN0uGScEDu4t0YMktd3Uoc/qAosk82D9p16WZqlQnGSjDq3b79A+/A11vE+zWqFaXuKgzlIoOsuESrEFcTQU5QLmk3PZr3EYHHWMquEuzctN+a3uTzf8O7b7xCi4cbNmzStAgVt59ls1gQi86omxEDlBEKH7zq8T2Kl8ZamgeVKacKGo4MyAVwryXbTKut1MoKdnHcpltUJxuQoCBHWvbJ611NZz+2bBbePYV6l4Oq2Vc7OV0gMVFaZlUJVJfAZFXwEZzQV1Fk1qFckKpZUmuL2MyVFBX1MFZ4cQuwis9pQVyX9EO6QxzYak8JAjVDOLGUtuCLguwe89co5r772Oez8JqF+hm87+iiLu7chdkRjUSwS07WjlpqMJDlm+fGs4v2VnrjO9ZyTg5JNIXGViMWroVdD0wc255foxTmLoyNmZU3hJBl2SFFXh4eHyZDkA++99zAF5pC8rNWs5Nbd27zy6ls4W2NsTdemVeVDz2xWptVYOgipAA04okZiNHRdMqeXlVBUJSoVjY9crnrE93lXDEPrA0FS7ouI4CTFylZ1Rd95vPb0EU4ve8rSUBmBtsN3nrq03L4xo9CGwimKZ1FZVIRN61Hr8SoUomn1i1BYx2JeMJtZuhhxUtH3AaMBGwJFUWKMzSXNizTuVtOWtlFRa4gmmenFpkoKXd/Ti6Xplhy+sODw6A4+GlIKScpeiBJzPdzt3A6r/8puJL8TIhndPmMG36BQCRjJe+Ll6ElxRONIML+ii0l9jBp5+PABVoW6OuDo+HZ2clk0BKq6whhH03Xcv3+frusIAbqoNP2GKMrDszMODm4QeyH4iO87QhFxM4u1lt57YhRcUSO2YtNeoNqlMAGU4APBCQ8ebOjawFEtzKpUZK5Pbh+ipNol88pQuuRGb/qAqQQCeJR1F1m5ZCV2mrzGKQcmEEVxhcE4QSwsZgXqHGCQKBjnkitDI94ENqpIWaLq0NjT+j7nJbegXQruRnPlUsWIQoDoIz4m52PEYkPEFTO0h149Tz/9IuJKYt7pTBlSXHY3f9ip3vhBgo62oDerTUO8SCYWk92LEVJxNlNxePM2y1NDUdXMDufYuqDrO1bnl5w8OGW9aZnPa8rS5Qi3VIT/xs1bzBZzLi+XnJyccXrxHkECL33kabrgeO3VdyGWWFNxdHCAtQHRRDBiLAdHxzRdz/piybrx+JASrmoDfQj4tiP0AWtSARtTQt9FJI+ASlqRdSlU85rVpsUUmlaaTXEhajX9DKnRhaFViDng2yFU1lJWiQOItcRoEYpk8TRCJCbxqx4XbPKOb3qWa09hBKPZqq2a850MPnp6n6Ldkpc5daDrPK4wlFVP0yqmtHRdz5Bdk8RJUjyMxivxQUPc8r6U+B0RyVD4Pu0wMmxFvzXnGkzebSFV/e+jpCz/ELh9+zZVYSgXM8QIzc0NVfkOr736KhcXkYODBcfHN6jqGSEo/aYFUpDzvafvYsuSGCEEeO/th5S2y1hgA7FEKsPycokJkcXRDTZ94Gy54fRiSe8z+ES3OTN+w6LMQciSLJlWBTvupZhWXdsrZ5ctmzZSFKlc+VDN2RlwNqm6UQRv56zVUJmIqKcIID5pOylprECVHH0WUvyLEXxIgUlt7GnWDW3bJzHnHM4kl7QMgVbWYtXSt8lpqDEmf00QxCWTeu9bQohYcbz33lu8HLok/FORuuyv2c5dGPYFGub5g5jlR1mVvYiSKVsVJDKUME6DFkGNpazmOQi55+6de4izeKAMcPv2Hfqm4fU3XuPi4gIUjm+YVJnI2uSMMhYRZXE4Y7la0zZrKtfz0Zef4p231zTrlst1y6ZrsSayqIXLtkNNxcn5kqbzue9JGzAGZqVQRyiApk0e3rqydJKSr2JIqzeRuuXicrIpAKmatCstdfY6i3GsN577ZysMwuFcOKwipYXStBijOGuwrhhjWjUnpacFl6sAKGgOSzDW4oqSwtm0q5e2Y43bGBTfCz0R5xzORKoSjm4dMDuoOLs4w7YRVys3biywEogSR7+TSU4UIpIXSQINMW9Ctd2B8BsgEh1GiaTpxBjHkLfkLzIpDnTgNraE6ibVzeeJ3QmpTGoKjTOFoVpUPPfcczzz9D2++uUvc3FxgRPD/PCIsqxS1Jeb0zQthS0oXUljWj70sQ+xXvZsund4cLZmdlBT6ozl+pLLviM0a4yk2q3ENOBGkjpZ1QWzukA0cBSTKXy5idB3VA7MHHoPXUeKD/WRyqb3LlziRHXhmBUFTdsxLxyai9wsNwHvoe+F2Q3HYlZQ4qmsEqInZBd/IjmhKgrERwpnKApL13k2fSQaMIVLJTVMitj3PuX4xOiJPuYY25SPE6yAUYoYqCVw5+acVd8jRU1hV5y8+VluvPg9qD2EIJgc+DpUqYq6Tc4KEj8YJ4kaMZN6rVMlJ5WaNjnoKElBYx2bUHJw42Xe+up73Fx01CbnyZQOihLmC/q24UMf+hAPHz6k9UmlVZOy+F1MLnRXVvigHBwqriw4OCp46pkbrDc9D082OGqWmw1tl0o2qKaaaMkeFbNNx3KwOOLgcIaGDvUNoW2oSuWy6RLWKCXl8xSCz3kxNiUBJl9LKSxqQ+h6uk3AHaXkLy+R+sBigJIUvOyDUpqYKxwkW4t1ghoLUTBq8J1H+wQYLcrcGdoQ0a5neXGJlaRm14UhBk9RGqSAvox0QYkExFoUw+n5irbfMLtRoTHgw4r7X/0NHl7Cd9/9CLJYgDhC1DF3KjGP/VppvwsOvqvHQcxQZnNQlYWiKPDBUsyeIphD1q1SHxicBd/3KNA2LRo9prAcHB9y5Bzv3X9I22yYzWqME2Kf3JzVrEJFaTYbFrMZBweW5547Yrlcsd603Dw8pi5cso2ESNdtsI6s1sGsXjCbHVIUjqKeEbqCVi3GpVjTpm+Z12WS/ZVNiS3GpDABK1gTOFpU1E6IfUe/dFiUlY9EW2KtUImnJmCs0ovH2xzpRsJTSoqgEyf41mOcTbXXQsD4wKxKGlobI+pTBehIQIzFSqo94gpDWTsK72n7wert6HykX0ZaNpS1Sf6s5QOK8nwMv0yYcSiDKtlHRJam6V76QXw3+1UVhzZGOw0e4UwkxtgUYGwqitktLtbvMi8j0feA0jaBtvfEGFJStSSv662bN1GU+WKeotS7DlWhcJZYFHRdy/LijL69hNhx7/aCV145RYxwMF9wdnHBctUSI9gcoT6fz5nPD1FJ5vnSFtTzI6pyRrPZsGlbVpuWZt2nrDkHdeUoZjXGGcqySAVntEe7FYKnriouL1runwRaFcracHthsNYSjRKcomUqXyEaMar4PtKue9RnkwdQVAU2JOOxuuR0s6Qq1MGnCgadjynHSIQQBWsFNYaySiGaPqRIfxHF9EoxmxGKkljd4ePf/iOYxV16SlKFyyS2VLMpmByruWOi/waJZL8U+IR6rj0/xoBxgldhcXiXV3/zS4SNsihbCqP0HVwu10SNHB0fsGnaJLAUxAjL4BNabxuMcVRlQeh7gkDn++Qsqyoe9ksIXULsuqAsS6xt8SFSGMOsLjlYHODKKvudTAJtpJze88sV63WyRfg+qYnie/y6ZyHC/PAglejMKZ8SS0IXaZYN62XPeg3LzmPXEBpDPID5PLv7jaWXSGEViVBKwKkme4sqfRPQvsdZwVUGLZMn10dN3DlG+kja0MBCZQyFK3CaXBEhdMQ+0PkeHw1GFVVLZ28wf+YTPPupH+b57/hhOntIxOJirlEv5KAngLiTwfe76gUe3cwjNe62vvfJ9AvUsztsmjmvvf4mH33pgKIWfLdheX5B6xti7NhsNkQPi3qBKx1d6GjWLUVZ4rVPFQJ88mSq1+xVrXjm3l2sFLz1zkPWbQrjm83KEUNVZU1dVnQaQWVMfgoauVytuVitUwVFoLQGI0kEoIHz0yXLlQcpUm35qPiuoywyVnGWeh5QJ7QhsuoiXMKijwRNQUTYBO4Lm/1dpJDIWW2RQ59sF5KSvLzJQcqtJ2rCMSbXmdUAoVesSzG6vk/5O4ZUEsTmdDIRx4e/44f58A/9C/T1PYJdIGIoNWCNEtTlGN8UO6KSxmUQMx9oK5OhtKbkrVij6pBDndVF0v+aEnxC8DjraFSo65vcu/cx/t7f/knu3fpOiIHY99w8PsYUt2i7hr7zvPX1t5hXC+49ew9EaZo1F5cXLOYHgBB9REPk5OScd964T+nmCJYQPbOZYbXxbDaRLm43cGybljDz2MISYyD4yGbjid5zdn5G23VZ6xBsUVNVFfPCgO+xoWfZeM4uNjRt0npChHktHNwQDipDWRtMIVifC8cI+KhcrnpC7DmcGw5qy0Fd4owhiiKk+qJVZamKAisGiQWmT3vxWCJd66lLR10ayhxPu2p7NherlDeEcjC3KW+nMIgaXEwqeSiOiPN7BC2TWh07bN4NJOKIkjIYGB3BqZDwsCffN0wkagb/IaOIiUIyEYvkBZMsg23v8V7RtDUASsvNu8fce+FFztct+HOai4dYU+OKRQqWCYa6WnB2tmR2tKCoDEVlwMDl+pS6PMB3kdALs7JmcXDAgwcbkJrWN3S+J3hDCHB22VHWJTdv32BmlPV6yezAIQLdumO9SbtXbJombVCE4KqKo5t3WJQW1zegPYUxOLHUVrjcBFZrZb1R+l5ZnQvFsWU+C8yqgPNK71O02LxylC6Vm2iakGq9OZjPSso6lSt1VYERh0gBYiidp283NG1IsbICooHSQlUqUdI+HR6D75Nq3AWltgXWGoQ+BVdL4O133uKl0IOtMWLRqGnjyqx5FgRCjKNjdjLLyPTj75RIEm1kKJzpZIhD2JbgBFTx3qdaZVExxhJCoJzVfNt3fJr24mu0ovRBuVxe4GxLWdX0PtUlmS9SMbyDoxuslhd477k4OUcOLYKlb1usUw6PF6w2YIsFZShYN5cE9SxPekyRIsfeePuEuQNrAlXTcrBY4ApH07UpNMHnjFirzGcV8zqFPxLAFqkqQS0OH5TbNxxNl7jJctVzutywXvccLJJmY0zAmEgfIl30zMqCWVHhYo/xEUJHs+lou1RoT0SxtqTLQcmbPtCuY7LPIDgneI2sfaAVSZNqhNIq+JBU9qHoTVESxFHP5vR2zt1nnk8pGTFmbUYIqahLjlOZ1Cf5HbbHEkmIETsp2DuY6A27cQMxxu2GADHmRCCDsSXHt57is1/+LOE4Yn2qxrxpNriqwLmCGOD45hFBU4TZ22/eh5jURRs3zOo5UZXWR1aNZ915fLNCrCFSUB0UzPqCou1p+kDbpdJZBwtLOS+oFnW2AEe6PiVvG0l5LwezgoO6oDAQYknTtnRti7HJYls4mDno1w3zwuDu1Kw3HetlizlwOGdxDqJE2j6yXHVURzXOOmx2MBZWcFVJCJG2ySETknSLENMuHZVJAUpo8gu1KKFNyK8ukx/HFSYFUtnkiFwHC7Ob1M+9wIc+9Ele+swPEdRlDLRXxSinw1xXoPkDE0nMrGq37mL2K06eEUIghJAJJBfNF4MpZiyO73J063l+67d/kY8+f4vl6pRbN+cpoGazpqznGCuUZsbp6ZK33jzFSgVROD8/x/cPcPMar4433rqk7YWub+k7jzXC/PCId945YbUBHyzzWcXhoaUoIjfv3cVgOH33AavG47u0jpxN0f7JmZ42LXj34RkX55eYEsQoTpTCpM0Fek8qIVpZbt6YsboMrJaexcJiipT/HKNwcRnRruOpGxVzW2Csxzi4eesG63XDxcUKY5MdpqgclSvwXYeoR4wS1W8DgpJRgSgGLR12dpvy+DamKijEY82M2e0X+cinvptnXv4kvTvCSzWmbA6e3VTLbhtRODj+dvKoPojFNd+Hrd9mIJNdG8pW1MStRc9YMI7F0V0+/Inv5Nd/5Vf5wpfu8y0fvcN6c87RvEIQYgz0oWM+OwIt6LqCZhPZbALnF6cEVcrFggcnPW/fb1KsqChWwYrFVeecXwaaLuAqx917T+H7FQ/PTtl0b2KM4+J8Q7NK8tiK0PWRsrR0beS9d97lYDFn3QbO1ynCrqoslU1+DVWhmM0oTMF8cZBiY/uO9bplufRUc5NUVm+IHt67CNjQ8szdmrq21DNLHwOXqw2tjxzND6jnjmrmsNbQbHIhPJFkJvAbum6T0k2rkoPnnuOZD38Ks3iG5z76rVCWdKtzjo5vY+e3icUxG6nwkjaqJobRupoCq3PRwGySHwhigKtPhq1P4iQAmkzcRlIW3QBlx3rx+0QychmTPMIYbtx+ju/+Qz/C3/nP/xbPP3OXowPLyekZz9x7nk3X0jRLrE0hiienPQ8etlyuA00fqRcl/SbyxjtNcv/3yvGBJfYp6lyKyJ27C9bNBrGGk9MH9JueejFn3XaAJ2iqRxJDqi0fPDzwHfglNw4dXdtTzGZE1xK9pyoZdwwpnKGsKpQSZ2oKZ7hx4wh4SNMpm3XEK6gJ2CSL8RikLCkPDMZFNl2bktBw9DFQiMXVQj2rsQcLHl60LI7uMFscMPcbzh+8hbUFh/ee5jv/6I9z++VvY+VnFNUCEZjfTdkJSEGIBSpl5vgR1ZjSZ8cFrZkw0s91+xF9oNry+4IGGCPVIjrmmvqJqBlKLUUVjHGEnOL4kY9/ik988jv55c/+Jn/yT3yE1q84O78AZ5jPZ2iE1159i7ffXrLukkfZlI5lE3hw1tEGwYhDxacwQwyFOEwRmC2S21wVujZQ1zPEFCBK33qiCrODis2yzWU8IUbh7Kxjveyoa+HGbcezzz1D7NdULuLUo6FLoYh9n7LtMBhTUFUznCuYGQek5C6P5o0dDXaw3FawaS+Z1TP62GLLFHeieKyrcbOKoDW+caztAdXsDnePF9x74WPUBwfMbt3F3HqJrrpFG0FMDaFHpcAALqMP0ZDrPIS0r+FoBDXZQrH1um0VD0bC+WAWV1KJTgEkO4lszruJkMo0+TBW50FJaYRK9uukIhUaI0e37vJ9P/LH+Vt/4yv82hff5lMfv81y06CbwCIWXK5Pef3Vt5jNDKZUooRkIQ2GXh3+xBM1lbUiRozN9y8LzpZrZnWB75PZv2laiqpEKostLVFTVl41M8kvRKqzEr1h4yObpbLqzpmftTz71DGHB8ccHx3kFRhZbdY0TYdKoAtC4WoWB7e4OD2hFIVCuAyaignaksaDLcq0iaRX5jNDPXcQIlVVYV3aF3C56jnbeLrGMT+ocK6C2TF2fohbzDGzBUZm1KbgortE6jnRVrkMq6bcXiKqnsG7G9kuVmTrVwNQDROC0J2Z/oaJJAGbfUob6rSmnRqCT0Yqp5IIJKaidiqgBigtfZuitJ750D3+0A//Yf6b/+rvcjS/wfNPH9CHU95+6z1WZy3Rd2mrkSIRYe8jtiooD0s0rlmvhb7vUzF/o6gJlKYkBMXams16TdsN5acidVUSfaAqSmIIFGUBhVJYoW89tq4onWPTronec7lqeOX1ntW65W6rvP3OAw4OCu7cusHxjZu0m1QkPoaQNJuywEdPWTjKPmBMwfKyJ3jYNC0SGiobCSEwn88xQD2rMcay3LScNh0P11DNbmOKGeIKxBYYW4BJv8XkDSKzxBjiUAaEO+xOMVhPp8WX9znEdUWJtrjzGySSQbtRTYa5ZOuPqEnWV43JcZR4ssdG8G1DVTj6GPGk7cvUGnzwlIuK7/ie7+bLX3qVv/cPfpnv+84X+Z7PPEPTtDjbcTgvQFJidkTpeqEoHJWL6L2akxPl7Exp20CwYF2k8lAWMy4vWi4uWrpOU515TUa0xXyOc45gAk2zSYV5RDk4qmk2gdlhzeI4ld5qNz3ry5a37y95eN5w4+Yh7zxYcv/hJXdvH/LM3dtApG02qR59aSkoCBqoxCU/kKR4hYiltJa2a9hsLLNZlRLMipKziw3nly1rrVj24A4XBFumrb2Mw9gC6wqsK7G5+sBQM3/cQ3gys6oDoWTdU3VCBLtq77XO2ie0J3KSqCnQaHAIRUByXIPGmILsNFcT8B1vfOWr3Lx5k4ObN1PEGjCwFaXixt2n+NEf/zFef+0NfupnvsZiNuNDLy1oiyW3bi4oqkBRJ0/s2dky7ShlIsXNpC76vuByqQSNzOsSwdE2nrPzDU2bBsoYcM5RuZJ203O6XqYcqoznvAn0TQsYvG85OKzoVg1VXdG0cH6xITQNJ5ueOzcPWSxKzpdLus3XOVjMmM/rNGHWIi6JEQmB4FMZrW7l2bSe2aIkdOtUXyQEjHMs1y3nq55O56x6iylnSLFAihpTVhhXIK7AFhW2rDA2EUnMxQq3mgtb7YVcXHnC+a/DGcYYQgiT6X1/tpLHG2QHU3zWXJKKO8j0rb8maDL5tm1LWTjW52f4doPE5C43ERwGYoF1NS985AX+2J/+E9SHR/zSr71GE+YUVY0t4PCo4s6dQ2YzYTFP26EdVCU35o7nnjnCmR5IhOsjLJdrTk+X2aydVMk+KKtNy8npJReXa/re02w8vk0/oVVCmxyGZ6fnrFdLDhZzfOhZdx2bGFlFWHaBN+9f8O7JkrYHcSUn5xe8c/8hq02qohQjGOMocj38dRPoPKzWHdYWKdwwJQjTdh2rtkOKAy4bQ+cLXDGnrOYU9SzVobU58UssxpbpWC7bOSbrs7shVZ7yvfWtV37GokR7AdEfcPPoTCtsb6iARlLZ7BAIKAFN25VFz9GNI+rCcrK8QOoaN5vltIA0gT4I9eyYz3zvd/Lu22/yT/7BP+JXf+1dvucTC6pZS1DDbFEwWxwm62dV0/dCjwcDt+/MOF9e0nUp3zfnUWGNQWxB2/cJ1GUtSzSthMKSyp+Ts9lSQVgwqU7rbFZTFgVdWNJr2p0DsahGHpyt6WuDaI/GQBGU/uScWV1yuJjR9xuKwlKVlrpS1k3L2cUSf6/k6OiYxayinCUzblHN2GwKNm1EqhJnC6qyonCp5LkpirR7mKuwrkxW6ZjibiRvCTO6VkdCSYaJx2kp+6ruI8NArmmP5STqM+eYUGwksfqoSohJ9U1/R8QagoA6i/ctpxfv4aUh2ACDpiQFIZQsjm7yI3/iR/n0932az//22zSxpqjnHBzWzGvHYjZjNquxJbjCMK8tlQvcvXuEKSxdyMQqqdQmzqXNiRACScx5hCDZKWkFVxisJZ+TiFYj9G1IZb19CkEMDIQllM4iApsusmwjXhxeC6rZISEKp+cXqKQKRzbXrFeBoJa+j1RVTVkvaLqWLnQUdcGqbdCiwhuLKYq06WTuv7EO6wwm71dcOJdERMjJNmGoh5Y83qqD9pJ2xhh2WdgloF1VdyqOPjAmcTkgINlGtuUrB9NxyiqDlASUNh9qfESXGyorrPs1Ia4QO8dplco3IamQLsqdey/y43/mz3B6esaXXj3je7/jaayeUTjom8CsKGlthykMvkn+k1llqRcl601DjJrsBwJGfdrdKiabgOYUiaHUqxrBVinOtO8jfZ/yWNSDw+GkxHctMb+bA1zwKYUipy6cbyKyDlg86xZuHJX4fkO0JAtyiPg+mQKCOi5XDXeOK9rgWW0anFpm9TH3T8/Rao4UJVKVmKrAlQVFUVEUFdbZtEmTszjnWK42WLFIJG8wNYgNIEfAp7SeXLhXppO/VXm/Ud/NYzlJjEleDX6Z8UcjYcAoCTGhmjhJDBGHxakgvfLgnfdShcCsriUqHtwHlmefe4E/9+f/LG/f3/DqG0vqwzu0vacPDfN5waKumJUG0ZRWWTrl+KBK3CuPQcq9jVvqFU1aEkpZWW7cnHN8Y8HiYE49r1LMaClYRzKsaUA0IBJwkkMMLamqokkxRFWZSoWmSgWwXPe8/e4FFyvlYulZbZJjKO3Xk6ypTefxRJq+Q02Njws2TcVqnbGFMVhbYU2JtSVlUeNshTUFhUsJ9mIMq9Uaa22Odh9W6lVRoQOy5er3u/X/dzHLByKSgQj3wc/W/J5sBoPmE1CMNRiF9nKDeDDB0DYdXpVIJGoKUUzZbFBUFS+8/GH+7F/8F/jSK2e8e+IpD24SRVkuz/FtiyHinAECNw5qbh1VaTv5usI5lzZuzl1OKzAF5Tx174jnnr3N7TtH1LOSxcGcw4MF9aygqtN2ZdVMwAiXqyUaPXUpiVAkVZEuCsusLlPsbGmo5wXlrCCQdrZYt9D0hlWjBIT5QQnGcLneUM7nRLG03hOpOTmz/MqvvkHnHVENzhUUZU1RzijKGdZViHEYU2RVN8W9LlcrXFmM5u5h7Pd/0sKOO5+n3w+LfUo4xphxQ6tHtSdn8JktoYzHh4dPtJ2U4AzFrGZzesF8tqCkoj+s0HqGhhT4HHKRFiVpBWiknC144aOf4Ed+/E/x8z/19/mh732J0s1p+zPU92DalO+jyvHcceeooK6ElgITUtBR33uMNdy7dyuzacviYM756QnLZcOt4yOsTRF2RVESYkvpUgnOEAKdj3SdhyhjHfrOp4KBxoJIpK7T5GlIu0lE3+N9pPUpT9iVSlFVHBwql6uWh6eRp+8dAYEQS77yyrt8/Z0LDu/c4uCOUJQldT2nrmcUrsQYl8ZEbMLUYmk2HV3vsdaNKu44D9f4YcTs4o1HYY8x9GNixv+GiCRqROKWIqcJfeOWGTEyGAEjiqsrTtu015yxyQxuaouKQbXP4CqJm5gJRWzJ4objE9/xGQB+6ed/gm/7+A20mOPDhmazpprNOJjPKZ3nqRsltVNOL1epqEtUrIODgwrnhKh9KlZ31rLZrIk+cLm8pLIFq+UyZRuidG0PucjoQa6dgiZPdpAUrBPaABKZzwp876lqS4iBcubS5tReQQytFy7Xns2mwQMHByXrLtIHR9d7Ts7OuX+2BldwuW5Yty13q4qyKrHO5S3oJzlOMaHB84sLTE4oCjHu4I3rMMaYmnsNcewTz/vVcN5HtPxAJHFUcqZEEuPgpUnHvUZuP/MUb3/py2zWK5775MfSzlchbPELw9582b9gLIGeYj7n45/6HpwRvvz5n+bO0RwvPbauKWazVMkgdsxLw1N3F7x9eUGS7eklnXP40KPqOTw4wBqH5OL6zlgIKQwxBUULQRybTY8AIbTUZeJKKqn+u5I0IrFK0/UJkPYtRelS0FCfgrKKoqIsC4wITdfgVXGF8NStI9re8vBkzemF53Ld0atQlw4E6tmMelZTVgWusFiXvMhBPVELwHJy8oDDo+OkJJBcH48ylpHx3tU5vJ4QHnmfvfY+KkInbUGGIJUMjoZwpBB99uUM9hRL7wz3Pv4Ruv6cs+YtnDmgtHeyuTqg0Y5q0uA1RgtEoFzM+Minvo2qjvziz/wj7t28w+G8J3RL2s0StQ4vc27dvkHx6hKspe89VeU4PFrgQ5eK8a7XlNZhjcGKobCOclawWq/oui4hVpP2rItBMT5vaeIMpUsakEjabKDtO5y11GWBaKRZd6meWVmmPXWcsGnWLBaLZAboAk3veevkHLVC5WpOLk5QMTRtoNTI4cEhs3pGVdYpxdUZrM3lQANgLJ33rJuG2/eeZtxBJi/JccGq5k0fdgMTNW9TMn7mKrG8XzX4CZxkADmDSTjbFjJS1cwhElxINngR6CRgSkNrOr7+1pdZ1Ac8dafEmCoJe7Yu7FS0XzAxud2j9bh5zQsf+zbK8oBf/NmfwjihMjWtX3O5bll2wmojKTUzi47FosY5s1V5SeKysDbFhzrH+cUZXd+lrDZSGYiQh68N4IJydDxHrOPB/XNcURJDpO/T/ncxwGLmODyoqIoq4RjfEbzHFULbtUTR5KEWaHzgZLnhxkFJHwUfI0VpCVGZzRfM5nOKoszgO0X2e5/qrBVlyYOHD6mrGmuTk29aeWo7yXvWUt3+njpnVfeoaEocT2Amjzem5ZD8JGoGrpJ+ombxgSGECUcgYMQTo6fZ9CCW6rDkdPU6QVJiVggxGfbVEmOKPYnZQKcIahxS1Dzz0kf44T/xZ1jFQ946ibRyg9O15etvL/ny197D+5STcnBQUlaO9XpJ1zTM6mocra7rMdayXq/YbDZAotOmC4hxieglccLWK5u2p2nakXWHkFLvrLW0nU+7cNqCVdNxudywWresGk/Xp/1x8jpCRChckWqzXp7hbPJsl7OSW3fvcnjjFvVsTlVXFEXa2zfkXUadK0GFy4slxzduoBqJMUw0lZDnYxrD8ySVdqudXjnng3iBpw8dnEnTYrGqiR03mz5pDmh6maioGur6Bk899SFOL99i05wkp1U4pi7K0egVcxjO8FtVUGwKrCkKbj79Ij/84/89Pv+5X+GV3/48X3vjbU7PGpaNEsXRNS31rOD84pyysLjCslouKV3BxbKha3yqc6aR3ie/inUm1Uxp+mzyTu9rjbBpuqwFpckIMabNCgpLE5WisKxWa2Ic4jdSmfFSQKPksIVUzLdrwJZC5z2zxTGHETo13HvmWY6Ob+KKMu3oIYL3qWRGXS84WBxzenKGSCqXPl20SgLUiavbEYOMhXv3osyu4xbvB4dM2xM4yZaLbLkJmbIHKk4FakPIn6MhBgfB4WTB0fw5jhfPMq+OuH//LS7XD1BJATw61fkzzkm7jSip8IJJaQNHT/E9P/Qn+SN/5n/Acx/7Tnq7IDpHIAUpx5jqmpRVneRw1FzZEW7fPkZMLtxiTMqQE4PvI8EHMlZMZvuqRLMrvq4dYqCuLIUT+q7HJQ0622xy5luusaZqcgpDHrNIqoVmUuWjzvfUBzOeeeE5nn/xBcq6SrVIELzvCT4iWI4Ojlldrnn33fscH9/cc8QFUjWRwU4VJmku2yqZO8Sx1watZsfm9QQH3xPScnZ18h1vcNZ2RNKGzX3nM1bJXkoUDQK+4Li+x+2DZ2ibFfNDJbBGrE/phgKIEMXkfe0S79eBa0lKmlZT8fSLH+Uv/5W/yr/0L/8V7j7/HF2MBIXV2ucAbFKJB3HEaEAcRVkky2tdpPLcZZGi+WPaYKAwQl3lYn8xUpQlYlMFp6JwzGYFdZXCBS0KvkNDquIsWfevqgJjLF22LAN5pwtD2/R4NZgibQn77HPPcfPmMfO6oHCp3Ln36Wc+W6AK7777AGscR0dHO/Vgtj4YSFhkSzBpjrY4clrBexqdNp3P99veV8L4dX8P8Q2oYExBiA0h73mbApJSFBdBMcZRmwOeuXeH9x68jvoLnr/3MayU2VprRm0JTWkOMvFaBk1Vfnp1lGXJ9//wj/Lxb/kk/+Xf/i/5+Z/+WdbLVao533pKa1mvGtouUBSWs7OLZDDLSdIxQuh76iI50Nouh0LmCdts0obPi4M5VWFpNhtiSNH1+IAzgvcpXdLYpCr3vafvhkWTtEBnB7eb4WLVcnN+xOGNGxzfPE7iyxpUA5vGUxQFzz77LPP5nPvvPaDvPC9/+EPJgBaTw9AYMzjSR9PEuAGSpMW61X4eQQyPkDJPIpcniJvhztMfRs0GlW3Emhhanwu4jJ01eYtWi9gFi4Pn6H0yh797+irerAimIdqOKGkVCpFUpyEkFh5LCBETPBI83WZD33bcuXOP/+Vf/av87/7Nf41v+/QnmS1myXckClapa0PoPcvzFt8bQihSdHvT0YeYtRCTTO/OMqsLjBE6VS42HaeXG7pgKKoDxJZU9YxoDR2CFo5yUVHOipQ41uSKy27rYAsCvUR6k2rJrZuOo4MFR/MZRSasi4sVvodn7jzD8eyY0/dOWC2XPPXsU9QHiyR681ykCtxbu1VapImbpPJaCcwOgmfIaJi28fJk6CIn9g2O40e2J8aT7KPmrV1jK9vECNY61ps1VeEQSWpt0oKGGxkMx7z03LfTh3NeefVLzA+F1TJytHiKwh4gUfJGBpJAYH4fMwyM9yCGrmnwnWc2n/Htn/k0n/jkJ/iVX/oF/vFP/ASvv/Yq88M5RmFeKavVBu+FdZO8xrY0GElaUVmUhNBkPh05PJwTLtd0fWS16jCyTtur9T0aU0GZWZ2j8H1PnzcFKIsC69J0+i7hhKK0qElpm4VzrDcbHjx4wMsf/hBd1xFVOTq+wcsvf4jjg0NOH5yyulzy3PPPceP2TVJRuqT2GpurNo4Tv7+2dWQHO8xiz+E3HNtN3f2gZvls3buqYmVwlOW4ohRFgW0tXe9Hi6JmkbT18dQ4MXi/onBC05zy5lvvYV6w3DwsUxJ5FFKxlWFHrm4UbZoNcAiEEPEXHZvSUZclP/gjf4Rv//Rn+Omf/En+2c//HO+9/S593+A1+XV8SARru8isGiyNSlUW9D4FNlsrzGvLwaKibTzNZkPvI3lvgVQDvkmaXNvFvGVrqg3vJFt1bdpmRKxhuWlYHC6S99gHNk1H13nmc8PNmzd5+UMf4mCx4L0H91lfLnnqmae4dedm3n5WSHhyiF3dtjHRiu2iHcxpO4FFE6J4lOV1P+b1GyKSYUfP6UNGdKy5cp+k+A1XlqyWl6nagGouAzkExpjM7iyVvclLz34br3z9C1QzQzlb4+MZxswwRYEGh/Ym+XkI2YAHqRJhAmtjqGIT6PuetuuYz+b82b/wF/mRP/pj/NzP/Aw/8V//BG+88QZBfPL/x1TOu/NpK9e29xTWUtVVMoR1yauNwqwuKQvh/GJFVM1aUZoM77MjTVMSvBgoIqmkp0Q2TZ9sK66gbT1iBessd+7cZXFwyAsvvsgLL7yAAu++9x7tZpM4yM2bDAaGEHye9FRigizCJY/FYEhLOCvXiMtEMRKDbt2BjzLBp9Kkj2/yOFbzc5//JZ0SxUA4MZPuwCmGle59YL1aEkJHYdPu3MS0/UayogSCajKgiWfVvsfGv8O7D76KM7e4fesZ+iZwfPA8EuZZg2jTYGVb3pDjOpqlM7EMQTdVVTGfz5hVM9aXK371V36Ff/QTP8HXvvo1Li5WBJ84nwFmlWVWpf2G++Bpe4+SzOJlUeBD2nRRDCltQtKD+5B2Cwsxe4qRlFxeOdqmT/aN2qEmGdBsYfnwhz/Mj/3RP8KnPvWt3Lx5g+XykpPTUxDhxRde4PDoKI2xkXFRiEmao6T4TLaYUFJly5xHkwBstspqGNMpBiViZ6+iyUKfFkz8gU//wCPZyROL2Fxn0RPZlrSOmRX6qKikStDdZZLzpUvlLAcTcSASxl0zC2blTcoCTnnIweEx77z7Nbq+ZbY4pJCKlLhjRraZXijJnTHVI4PriBJF6PuO1WpFXVfMZ3P+0A/+Ib73D38XX/3KV/m1z/4Gv/LLn+XNN9/i4mLFuotE7anrElzSOHzwaN4xou9SUhea8ZBJMSaLWZHygmISe31UOg8hJidgUQoxpdixWBzwvd/3/fyxH/sxnn/+Wfq24Z1332G9WnN4dMC9p56irCuCprCENJkD7hucqhYNu679JIqG+dnWERhq7w4+NuHRXOT9muUfy0l+9jd/UQej2VTsKGQgJdnEDtGDqhBCR9usaTYbCpMKxhkFiHiNKcMsVzBT9YTY4X1LzzlfeuVXWBzVFOY2txYfp+SQJHRCriacsE3eFiZxrxhGm42qYtx2n7mElVJlobqqmM8OaDaer7/xFr/xG7/J53/jN/jaV77GZr0EkrbTZ8OW71Py+CBiqlKoJNk/ggq2LOiDslx39CGVDjcmYZTj4wOee+FZPv1d38F3f8/38szTL9I1DcvlBevVBcYKT997ioPDBdY5xJrk4c4BQMO7kcujitgMQBM3SZW588YP2TZF2hAFI3HLSdjiyn1OMhBJMmTCD33mhx5JKo8lkn/6uZ9V1YE1pQ5uzfMwmuEzNYeQVlaIgc16Rd+sKQuXBzpkZ5zkFZL8EWkBBHoueXD6KlHWdF2Hbx3PPf0JiDUmmlFl0xBypHsyePXqiRoY0NsohgCVMIYwGLEUrqKq5tRVRVkk1/7F+SVvvfkWX/vaV3n9tdd5/bU3OD05ZblcggY09AiRwgkuKkXehNqVZa6rajGu4Oj2bV5++WU+9vGP8i3f8gmefvYprDWsLi9plitWq0ucsxwdH3Hr1s3k9XWWrQYzFE5O4mWoXz9gr+n4W+xk9UvOi8qZ2xqzTUWyppt2s0AnFb4nbQhk+qHv/OFvTNxAqr2RZJ5k7KFjiYmh5vxu2Yk0S4Ur6EVou47SmawWJwcekxA7yWqyaMXNo+dZbe5zcfY6Ig1vv/dFCjfj6OAOzhwgcYZhjmpAY4vi0TxAg0VB8/YqMWteMlRf1EjfbVivG0SgKkvKsqQsKz78kQ/ziW/5BM5aYlDW6xXnZ2eslpecn53SNBu6Lu3+CeDKkmo2Z3F4yNHxTQ4OD1ksFhiTCvSuN2vOHjxg02zou5bKOW7dvMHR8RGuyMFFRrJiMGTkZbxl4tbbK8NOyxNtVrfJ+nmKEkDNpgghZ1dmzOFjoHQ2b/GyFT1pJuSJouaJRDKoV1s0ffXz9FzJ26NqXtXVbMZmuaTt+rRzAzCYkxNbyOb9GIlRMLJgUQkvPbfAh0u+8soXMVZ5ePE2t2+8wI3Fi8SYTOhIKj2Z9pdLo6VZHUeSxRZVovcZ+ZsJhoG171ityCzaYIzDGZO2vDeG2UHF4fGCZ59/lsKmIKMoOmzNQYjJm932Het2w+r+KX3TEULOjbaWsig4vnFMNaspimLclGjAFGb4nBB52t5lpJjBmjo47gZykaELSczHmDm1jPlNwz2H2Rmz/LIWmu+8Ndd/oNITusUhInESRDvItKkvJ8+Apg6LCNZYqtmM9WpJ0+Q9bSXV0YDsIBuvT7BDmCHiKGzFc09/nJOzd1j1DQ/P36GqSvCOQmZYSRWcUxZ9BriaTN2qfjJEaTSjhrHvu6ZqQ4whxXJEZbNJoQExLxAjec8ahEDEmOSQG+xRvk+RbU7S7ufOJOttXVVU2Q9kLGA0i0VABSuDKyIFDYkIIYbxb7LZfVB5yS4LJBUDTvSQovIG/w46sXsMthHJGw0MZbLyHI4YM7/dN0wkKSss6Q7DlqSDdW8/KHcQR5l6EHKCnLGUVcV6vSZETVWW8xUhpp0Uktd3kKm5fDcFR/Oayt3moj3B2J7XXv8tRJV5fYO7N5+ncIdo9Dk2NRng0h5/abUYZbAokdFQ7nPOcSazfPJE6AANyTYGAQ05z0UgJs91ISAx2XBs9Mkia9MmAkXe/ECHFDGx2d6TV3Mm6hBjEjsD0ZpMdRlwCjJyvq2bY/jZHfnR6CnJcGnH5PLhkqzlMAGvE6J7Unu8MS1kdVdTZHx+h+yh3dYpn1pit8A2G3WMxZUVZVTazSpFcTk3sRDmAcizpLlumALqDYU55HhWELXh1pHn4KCm2Wx4/c2v4lzF4eKYxfwGQoWQCv5q5hpbi2Uc7QaJQJRh63WNqcAdpMQnNNlQhkEeVnuMyQ2JRoKmMLWuWaExW2ulwkSTNtM2hqCRnoglYjXmbUNSBecIaZuRQURnohSTt0OLMS+kQa5sMcp2VvcCjPJhMbJd0GaL5DWz6pFIhv34nmRJexKRJFV9SKAdqvToONgJAG2zybbEslVJyWDKOYdWNZvVitCmmh5A3k59ALyD02pLdDGHO4rOuXP8EaL2rMK71LM5N28tOHn4Hm+9+wovPPcRrKnRaHDWoWqSFjBYEGJKcM/yMMWgDEalzFGUOA7aYFFGBoNhynomBkLfsl5doLFnNqsQqRLHzYawwQLtI5nodPvPyO7CksH2M4zFsMPGIELMONaTWRmBKoNqK8JgjxpCNQbOIZhxb5sBuBpjdmHCN0okAT9hR1tTfBJBE6cfuY8SGUwakG0V2VspaMpKWxg2mxXrTYNzZsyfNZlbxUlhuByHlaoqDbtOquXm4VPcPLrNpj1l2VxiK8+6f4f33jnhxtFTVMUxm1XLYjZjPj+G6BAd3YR5UZpxgGL2nqK5MA/JdvD/a+/qemPbbeuitMd2blIgLdoCfez//10FWrRJk5Nc+9gzW+wDuUhKez7cuG+1Ls71eLw/JIoiFymSUsuMh+yKpgOiZ7z+9Qd+/OkP5n95ebGJhXiONA9WMnwk6IAaw0Jb4gQMT5Mw+jQeM+fRzrI1x5J2nK7Vq9Poo4htflJlKNRyhAXGyOKu/EHQC+uLF2lmP7gwH7WHJ2cNHcUV7g9dPbF0uzq3iGQ5AzK5FY8B2jDiNgCvr79CRHE6bZYQ5SGNF6+hQUvFMAuy7KTveTd9wi9Pf4/391f8+7/9N/7ud7/HP/3Dv+Dy0dDVqiZTsUdknXh0klifLSWk4ize4r6XccGmwPn9J/70x//A269/wfPTCVuz6onSNnd2Fbe544DAD4VW6RHlCN27OtKSGWP4I1oswrWFXKEUCEeZn3aOxI9Cp5wWkDo8ZufG82t7WMSmxhoQaRvHz9aD+orUgQCwrTXs41IeZ6umacPp+RkvUPx8e8X7+xk7E5M0CQggCuXwHVCramBHdDzhn3//rxjjAv3HHb1twOh4ag3bywlDLibJxg7Gy8GDeCgl4KA0PMluLlrg0wV6OePHjx/40x/+E7r/xPPzhq1btn/v3ZLL2gki3XN3e0yKi9yJSbh4eMhlRp4JrHCfOQkX42zCH9yUS0bhVYZBrNx7MaGF5TY4WflgAfDgkIr/fWTaVTEl6W9QT8BW5c+MgzCVlC7+p+cXAMDPnz/x9v5uYrW5RuXBhkrfTInYj4AbAcYLugct4zxCTFNH585givogulIC+4rad6+UYOD3/fWv+PHH/8Lbr3/xMMcNJ08htXRKkyCKFk47+D8eXklgzjIRDvBAhhi7WSOq4vkzZOfM09Uxn8RpoJqSwyWTz4cIz7ShFLfwgaGCPO3GuaJZX75UopOikXY5V7KZt2XDTylCXfVAXax79wlGR3mOt356wkvraNsT3l5/NX9Ks4ONxj7CMoHXKBV/xxhqsScxcJiVqTQHR2Aaz5kMgMh9IPh9Y7fthbEP7PsFHz9/4vXHn/Hrjz8D44KX5yecTh1t65CtewG8DWgdIt3rrmzOGFQRFOVlzYfPg7TyviutEN/tpsPOsx4l7p1rjFRVc3sDbw9pok4DO/dG/Ofqyji2T0kSLaZT9Y9MGWCKEKVh8YBSQGOwk+hV43wVxXZ6xi+/bXjvb/h4f8XP958eTEwz0GNLXKVBu6F2XJJ5xdagxWKY2LVYWdvDwTBPZ0T/+wplFcnzxwfe3v6CX3/8GfvHO162E55/82IlIp5OQN/sPL3ePft/86189+j6jnWR5tDwd7jKHK4O3IXQfArCukPu3KYFNDsAW2vLtBqDZcQZpVhKoO73UNAy1ME8tV+pKkBLZvKFkArOKGovGpQWxBJaScWeAfADAOxbWhq28qUbqN22hv38hPefdhCjeBxnJxEs78KV7DDfBJnXGUAA6EVg+zz2OzcULTdoj5r4+/mCt9dXvL2+4XJ5xdPW8NtffoOtd2ytQ7ZmlYjayRLhtw3oTyZJvIaInd3XwnwlLrHCMrZqmyKkjcAtnhomotQiLpELcxhOKZIECbRDlrqKFUmwSpVHhqUq1nhhmaK/jUlGHIdRvgXgcahFOtA5FE60GKB4hwcwopAThgBd1AvIjPzXBNgsRaFtTzh9fOD94xUf7+/4uFys6LBaOkRz85nZhFRrw/NgdUi43E1ymSS6nD+wX844f7zj4/0D548zVAdO2wlPT7/zQxp9277Tr9DhvGCM0Tdo2zxk3sGmnyBqUXgN3ZlBpWGIJaKZUw/pw/AVngcFDDQ0l8WpWmrwkKnWMflI1MfdpE9zYPR3bUY3vzsZDcwyF+VvZBIgffzWrxKMS7N4vSF6xF/LaohhwwFpWkFm+bQImSQws7KVHS/Pv+D88YHzzzdcPj7w9uH5LwTHXI1wp5FaeOE+eILGBZfLGR8fZ4z9DOyXeOfzywt668YUzQGjeLSbj6G1Zmfc9G5lM72+qhRpYhKlWDVpqh3avRANp9ztP1EF+Wdq5GC8glHyPXLAg8VIv9uT+5FpQw+/m8k2m3bxd7GJOTwnPHzF/OKqUKo1mRgl7zXROUTRT0/orWM874Yhzmdczu/283L2hGv3nF526OXiW+R7EqVZdYCYfLRwDIaacK+oqVLzbfTWPM/GmaR5La3WrRheP0G6x4LQgnXpss63lLEPNeUzhmURsmBezDySPoFTFpCaaup6kFFao3OFRlY4esSwD+NJ0mAytWEWSjLJOvg1ZbCazvxJMzM6KjIVoZ2vN/RvNcPEieo6t3WcTk94UavrdrmcLfxwuOraeXrGHm5phSYje3wM1GrNt3LWsflRzTHYXC0YTxiTSGelZpMmythUMlrfgGZhByiTNi0sH486I1LUcoUfZkOorjTALWeJW3iQ452U1MQ7+UD73LevlsMK02lMKqKmE84nVNBrWUzkII4NqTWx83oZelj8AHUvgfqX8RMC8VprttLBcAFGiwtiB1SHHRXembfsGfhjuKudmM3fF6u1WqywCFuqn75ZYPKqZjSYqEF6c8zSo1oBTx+7SuMCRuuio0RgKCLpDCBOTLXwlsoULqlvmsMIuk4m9JdM4EFrxSZljNBskxeQL6U0OHgHg7no+PG/wf0tSGKNxdy2tAxE/nETrowRco6eXMCdXMN3sFncZdCp55t2+6huHIor7y9yGavFvjR3dYeHtSeztNZT+ixiHqADraz6yW2ggJR6rNK8KsGRqSaVU7oYdKals/RhpWedlzHoyPuCM810c5ssHIqtJrYdHlvqyppeZuopUuoExnATXjzew6RKjyiydBylJJIm2ADsZgj78zRmWDx1w/R4R1PxBHPzZsKxhsP7iF3xw3qKhea6HJSe2ZdOc5KmbnfHGn+XZH6meKgHKhNT2cTQ3qWC8LhV5MJhIDRovjrNm4PimOZF4vnk2B3UyXUuRZCOybrbPr7GJIHQo8pw4coxc/aAejiBTx5ssgaxRlmiBKshXTQlDtWbiVqXQu7FtbPuXC0Zp5o+3xr2Cyc+g4b71kv2IIGopXXAD2PkQcx+pKZhmehLrldxczj8IWHReCR78/BBXwgMaqKgMhIw0s+Iy+0vaQXsKrf4Mw/Yl5wLHluEjRKDBBV3NWD9joyVWxl1fFbz5IsmcHWgHXRZNWPVoJ5WImMJFXT2P2KVYvVMgpTeRw+kHlw+7ruA5cgKCjhrMltHjBx3U4LH0hsRTUx7GpkD7z19Py1IDvo02paOMpFukrAJ0FtIXmMGxGfeX9sYw0AwioXHvBtnEi64HLV/t+ibVEW4CS+48NiXOgfQLzDJvtsKtuiptDYy4stPoAq/nyL5xzh3ytcpzHDYaxCJkygzzKD6Ahpa0+gT72HcZhwC5GY78VGKbiO3CCUNV5blyiCYAUWa2auIbVovGXWSVkvzM2KrxxXV0ykEyRz3BHyQDjFflMJ7NU4ui0bhWyZ2SsgqV097O7y2zUxr2OSaLZXtE4dHt5jcJmZJdPoyHPw0EewEfnGf6dzG2JIxR30dBuJ3878YiOZTBYmFErt4HwtjdfdX7PteRDICYHLyRNNRKLTW2hZAeGVkK9hoKqb1zZ7RfSfYJWejm4BWiW8CqjB21eVWBEJXTOG/uI5q5fVq4fVBk2T4O5bMJDlsnlaPuG0d3GeD+8AVHlnGvjunjsIQk97GKu1mNz0EUTarlqq2zy3yjDMKjVZMBXcRGeLb/FzuM4KPFeP/9n1H75bjMobHpDgohQunwAtSx5EqqnXDQq3ZwQBDKyjtaGLB2PbeFv8GrbQSRJQGlPmMDNt4j4veENWoFtnLRtxE9wlDUaUHSb7cHuzdOImV0IfiaU89RtOLehGzZTMNhM6bmKzEL2xUG6EuRCAqsXKqlLD+NFdrNJ8BTkHzUuMCKwSs+5gIGUysnsSFo5kIIAKDVCxNJIAzCkMWfwb9G06gVFFHCiOYQklLNZ8UcnGJakjqiDEJ66/NC4SM9AkGSWyy373ugSRRj6pG6Po1FiN3IuvQfftZR3Azc2skMtbUPnMliQtf38CTbkV4e/Nd1JGEILPYpp2al9NFi0mZEf2aJqf7qu4tk7d0+HGulXhMMktiBgBuDfBq0TSJVaREtzMqLfGJhpXhzOvSiP2z96inoBgUbwp0NM/q4/thzkQuSKfN7pJUgDB9je88MMuuAAE/6QhQfd7jgocmsIJlwcN88kEOB4wVFMWkEbGjSgiqKZcc5GIYMOR2f5H94L4oASLfEc67saOJ55hgoPtnY5jc0IqJkCIddiN+l5lB0vnUgsED7MbmXQvMQYnRWvPa8Dz1waSw8p2S1xNoVsCa0trUcvX8hhx3A4Kqu/pnEr7NktDUGabswdVKfSR0HqdUGEqipktrSRAvjQFHx5bnaFU/VZSmpTKQk0nVQcfbHpFlQEVzUryZ6mF4IgL0zaLY9xHWCn0sZEAspzmkW97iPARG2NAIkLinuspJ5HrEap2IwCHqiVr+U8RAeAJQp0643l39VfCqvrtdJry6EkTEq2iRu3xPSBDxKeucEHDfa5848tUYpe4uQu3o+aqDYxDwTvrLh3tljSimy+mSpmwKK0TE4kvgK9S9oy0I7RFthZDcXzKGMxVnOcEI/MK9pZg0VyWmmuz5Qeziy4GLdDIiAI8rYYZ/c4zg/V38Iol/fGJge0xj7Ght89RTiZgVddAubl6Hgw1cCMDK2LVvhQOCPmy5yScLExPa/41MkjpTQywKmEA072qyw1Qh6iCs4oeamOxKyRlLAwekCx0xwRBYbdWdzNYj1cNWuwfzOnBjqaoMLmYyFt/dQnSHNVMwjDgz5GT7RBRfiP3N93CkgOCYVg0wT1f76qOwzwjwL0iaDqpMSmbvZ92LWUE/6d9boY/wJUdmunb/tfaw0hHltS3Aomswi2n+zr+SQ0UKLnCCBO6ATuEWqjlJxphIwCbOoKwcAJ+wAQADIh08oAki3JrxSTJJkxPAfQtE/2JkoTZSBdiwUrVUlQOYxO1BKsm+C811hh2gLAAg9omS4uButnJype653JijvNsk9M7j5nOM8GfW61Pd3G+fCoSm2jH/AVdk9f9XkYoCZgU1pQIK3/wr/xThta06nmqtiWBfwFh9HqTFSvYMGoTDaaRE4ipmaOPcjJEsU64vGAoRrUYmqJgkpQNi5ROocjBmihtjmpQLSiEXHEKihQRxIHaNQWbfSHmU4vj9lXun+x8IkwfJWQNAQ68qZ9GD+buVNxTiGP+fQmx3mIAR9jH2daICgCIRUOpgCxIyKnY0K8ynwzPnADscxsMFfAmGA04YRtAmV3+X7jvWGvc1EciwM28AhJkJsag013OFQcg0hk/S9lskjXDDjlkvYkWJYZufp83UWmbdAUPESnJcrFp0X0x00l1Vp78lbvRoegfcKrjKcKTNlzb4BAorvUA0kuCO+IGg0HJ4CT7nlR8qpMTLJjF7AFfq5vWainfsWdxAE7i+gYu56COZMAHnDNwYxb4jPbqcZIsyy70ZE1gpJazfxYrTBLgzLsHUl/VQROKeAHv1TjcOTqenVBnxJ45rXqhl4g6fr8GCz7aH6iaKtFXrhqPSZAJuvM6ieiZY9ppYprqZWYBmvj68sn6roKErqw/m5qMyRiVWN4C26FwyYmWW1qwknSIqL1dg+Jl/hxEuon4C9eVzbykFcqWTboLn59+A0ifwGvfSUC2TCkyvM0Dgpyl+mPddvSXaA+CaHebnMRjXMW/YEYVzMPYdlsENsO5aXk8OnwN4a/geCwqLSrm/mZ9EJPT9NUJNE6Y6qZGmaknsZBKuTMl7K+6gSX1rAkzyzHgh/vPP9HxRuubzktlUGfI4+0KujYlSJr9LsVSlcJUilc6faZ+KJ6kDZyAQ1EQ4D/OhAOAU2eByVeZ5fnUCeQdMEkjl7rQSqAgiEV3EvIjxbNihjF6egdHxDNupMbjTGbgS5ESY7B7IFMtLEFiE4yaDT5jRzTSRtOjiHSExqdSk/O7Pc/wQeCJ61lydmWuggnHOTwgTrplqSFxRLdXf9Blm+UQG3+x8YY20m8G9cvxl5ehWPIa33sdJMctK551n5AQp5s20eG8sWgeZ9oK4jJ5GT4dN8OYP7m12RAlvl3wmx8OAETIIoFi9srkY+ExZaFXvLwClCIiqnquamT+nOov+lefzb3XBRBmzG+0uk9iBxVm1aH54qoSqWqo4ZafJ7XQN856FRYwQUVqQVo7LEZdiAoly5cQkBNCsWAiUgrgkGxlV87uhGuEGrTdgt+cag9ZJ8wlqNYaD77blm9LTcU44EA0gV6A5T+rn200Pa14ABeZYGJEJplTGvWpGX2kPC+vBLZmqPiiaTSxTvbA8Zof43od6PKlVSNx9B9gINADb0RzM3W1W4mtYsM1Qj3pTpmHbhAXXCyWLmcBR78OfM1iTRFLIK+UFi+BU+gIIj5gb41y9goqfMjcnLB9RCHIDz+hF1UEamURsgIcOWD/WRCu/vCy865Kh3jW85kouKKru2CINVVSfEc++zwSfcaZRnCuAlubqlSbECkjxbd/ZcyoII5r3iw4H81RT1bw1SbgYNb+Dp1QopYyGNECQoQLwQE7lGlpHUroluf8hsF5ISjuqM4WppwDaBS/BVVk642qfpqFMM08pVtXW5CFdYEDVTZEqW/Ef0rKpmXt1V/pW+wSTEHym93RWM7nC0xIZ0b0GC9ShKIwCbyuNdH2v/62qmCBEKJFcdUAAzoj5jP8LhHU4uH8UQBGA+BEpi4qx62xma050qg9A2uz7qeJbpGIV8+qivGNVuNUZt87DzBDlu3CmXcce+fvCaNNzvpJ3Iylm63criKW0IZHt7bxPPabTyeAidKCsCgLIQvwpak1olkohbCGkP098pTtbQNBNzIdqGgWbjLJLmhtIddd5soQqYyyAdNXztTWPQzFrQrPeChLAh3lc7qd0WC2yajrXOiWGq1bpQvJUX3a+4/8kFzjDATFx27WH2oT6JEAtOYlVDVy3R9iAM1VU8uGg3KyszFZXW7WSoi/2h2A2Shb72vdM3ISRCDDifhInBGhtAxTYZXedIIEXxDFU9glRyPBIg2XFo2iTRRJwIdUVz8+VMW55SydGgGIqO3roXC7C1WfS5Ial6u1+OaxYASP9I8tgUhXltnvRBuyfddDLZQeu8ag3usghRwYUiNV0DwvVr63vd84yBmGfmsNEriFiEA/pky2BYQQoGyNFyOaEYeKVjlU4GT2A/ToxVDf8bBva1To6qpVqFa5/q8+ldbg6x3JRLwtZc8FVV4N98QVMkuZzTkTwQYhtLEzhPo3JJ1H0ZWtR0mLbLC1hjMQwSi6r4LbiFYob4sl8jTNIpYoijrAszANohl66qFeolYyKtLoU7WNkfi6ZDUUKGaaf93hQVGxKE3cbOPDtZBghUya4pspcW5VQ6gNWwGNrlgTyuqiDJkeJ9yU/iXXEJsSiSL2Tqu5TWMCjSxPb0DTJEURHy9KYPnxRFslNMGiTkMHSduLEsGK7rcXkDFUPJ0SknA4ZqDwiUsIUJkvmqPslAp/pSDciiwi6WHKEeuFd+55jN8xU6uFFXTIpPxmRFwcGlIlJi08iXbRm9lnyGIelUDWLR91Pw3VkC87is31wSNSSQD5SdINOX2GSKpZkMZ0WxF/vIfEP7rIirhtm/bsyc+pN+Eq3X6IPgKmnMbuXp2K6VYItQA5SSjnYBVcB3wwcJawZruTm9079Ks/kd7I8s2Inu6aqCmDXETRSRYY7DN8YXfGNix+ehZPAlz3QkPhhUg+lWsC99rBEZ1g4zn37vofjiq3GkFZc0Rysssm0tBCTrBMZUa6fGSlEbNoCgOhNlH5gjNIOVgPfV4BzBBwLXEXMIPPae+QKs9WXCG6A27hefD4TY1Ci0NfiA7hRVqIoN2lFkuiBHlJ+3msPK0KHl3FcQoKEHuZLFqujhQ6sj3KxrG4GcrJ99Q/Nyan32CDMk8otguZFagdgRWxb9+J5MF3HRRP9XwDi0q91UqUtEgXuwu8Z98pXSTD9deC6MqdFqSVGgeb7mOccEtrp0t0TzDhdjq1hliZkbJF8N7MHsz8jMEh/YNWwPVY3Tqb0fxgHM1+FYjBWkFq2WUxuIVR6A+IFaK3kEZcBT2g+jcjJ2hBBRLrPf7s+YXXlDXFmU2RQlfAteU/9FyELzAws4P3Raqw0bZFQrtPYEJMrKWyLZDbXvkz9M0lXFxbBdaFP9TkVdUOp9iU/SSuTXPBxJB7XF8TvoKqRSDAPdC0mAqPYvuMWOyZkTYYqgU44rkg2aRKFPAjGKJ6n64q0yDhThG6vaiSuXSVQkRbTzwdEXp/Bw6+L7ALAmq9pRdHvQYayUEXujMtM++hTnZME06pZ2olvtuS29rD/D6ybxM30lzCmMmyW6q72znehZeQu+Hwg8RXUzU7TQu3qhCAGTkddQSPUeYp0jfuEMcKNgiXUTvH1BCjkszhprTJ0gsLqY4ifwTSzpEv/SAGMktiDIDyttRRhk+RghL8P9bLzACYP1vYYHcbb8kz2XBCKC8tylFmLxa3u9HwgBh8wyShMVr1+ec264VfFLxcjpUK1OBSeW1IEqJZnVNWz65jiZkFCqOOZauYJ7DRunc1h08/OaEsJTIIsQr4pIVsyqHkvwdRhHSgZIeNgbFQajMJsPDIUMcXMPUZYDbHoGM4PauI7L2PAioNRrdo7Gm1AZTl2l4gO+GOOhNJXp+Ste+1BLnCK0gP4E1broWXhszHdz639MolXUDjfReJdwxOrxOLzJxCNErTEOiEi4CZlvQ+uxjCJ6vmd/FnVaqjfK2pnBruJyda/Z7/oG1olJ+9PmpEB7dQKesPtyvpWG15+w0U8AGziC2D4Phdx3ANteV+SuLwWTT1YxYi0FqdVzN1EuaZs0hVdqTCnT55YuXpVlueUCeC+D81z/j0Pk4Sv7BHXVCum9ne4NQFh7Mr8zgPztCyYw74UipW+lpVc3s2iPxL9m9MlEqRmfbOjWU0pN91p13Pt8UQuhR8+YM/lbj0CUx4XyNruyhsrKjPS+mgm2kM/w4V0FQjFqUQGGqpFVAMsMzF0QJFn4qyr9Jp5Gu+hJEAOsqZNCLIOikhD79uCH6wzlUGig8BhcigPb5FzTRiPFtjhWK05F8eCFbzPqxq/Z4moloCsihG5KHSO9Y2Fg1xot9qDDb427TVQ5O37njigikf/XEtwDRIhF0GKYD6zWymLRPP5fr7XXnXcZJSkyXINGSLVnW/XOKdmfxQzAK+tMl3ty/r3ESAyHpuTVe8rEnPdmzmo9CuqlwYEhGGKdTHV6/hMjjFpMkZJZANwX4Z/Yu+Gb7Z4UHXQNw+oHkxwbdWTQIMGntYVl1StnM+fNfPu2jP5iFVdUc3Mfpycnkg/ravfmSHVQVmRFNHl7yzfNaV6ZgdTKsGwgRWMaXcxQFg+Mi+KQ0xJOPz08AB+L/lA60+ruCzHXXNxrrUHFaFdx5ssQ3gzRSzDv+54OqfqULRZ2qLx0FMW46uRUB7nOtwMbr1NB0OKIoKKc1ULIsiZksU9OTZpVBmUOkYoozMZhEtMcz9GPXgpkrsKMZiuyUFpRtHnVOU2BmlhDjjWCXHGt8chFXOqQdKKfqmri64hlb4UiVQWWtK/YEgUh6IW2j2wch56XDlRAVoVuTEUeq1YNwS4TsxwW0MwKIHcFB377hZgAtudCd0crCBqzwPFw1qKsjSI4yUAbjIyTLISukqpcAgS50aU1wizs9ZFsY2BKgXSeiFYrAsm0x8GIpxzkjo0AlJl+GL3MbJCwpV5gUIdH4oiiu0QZ9z0oGoEYkzz+6ge1ifCF2edXGRGEnCdhBjM+jxzR3PyOTG0fuL+5hKJZSeAqQ/ESfXdo0w4nU8Hs7SuqtLXCloNI90mWsVTuUhSdK8rWZASJMBiAZMHCyXiWea+Xvtc3/nIjOW1Qa8SFC1fZRI+PHGq+IHJLiRXExHHQeRnZxSv7aqDHvV0+FAUTs+gaFWe+m3fn89nnLbNtG8BaHzH2pfDmOyLoi6A1i3doYJokXlc2UcqGfbz2OwyW79CsHiFgbNvae3U7s90zG2NdYSrZbh+v/p97Nr71RfvslDl0gA3MREzsa/Z85MDSTPoh86kKnopcusADyCLnfb7Tk9PQJE2zrXFnpnbOjG1nzHmAVjNNHeZq/0OrICzYKFqsUzj1QknTExBWhlUjnszx+m4L7b2GwsjrNdeu38FqpTq99rnTvNcmaJaFOuEYharxyx2QVQCAFUQYgJWYFV3KlfmS+Al6dSLa7Iu6zWzNT4DVxkn2zyx018kubNKo4OpHkigel0RR9LaHptCNQsBmho+vmud+JV+lTZ115v3rIs4c3Rut4eShB24Z47Vz4p5EuhKJoPwEIGomMziLQShLXcl7Xm+zSiU2sYQgwwhKb6nfksSeZVylGLVHK3Tfwv8VcBnz52x0oFuQEykElhODJNlwCstL5fzdclRfjfwfd2PNArQr9ffBLVfkST0DdiGGaU5nU4EoQgCxLk4RfyrcgfVXcPN/BXc02nIgr3B6ZauB/4n2hGxrTtTBNPcnMAkJFdhSB+C3KTKCEzBrTGmld6qT1aIG9ITaH6uDb+fBu/zHxaZdcqZVKbFR/WmOnC5AKem6C3d6HH2IWAGU5mP7F36f4Arqi+6uUrWK8Mt7VOYRH3CcmXPYDQ7dBTVJs6t5rqKbXtfxsBl7C4dxBgHVVpJqDOuUwO6LsmEpbPZCVLp2oqr+SvZJ/aP32s5RLIStYJp9Um2EAdTD1RznLR8hpngdOatKq6e0K6FuVSB0/YUBW4EwVvxr5H7nLmHjrAEJ1VM3eW9nrBbnWd8wZlWgVEUf1lAUV5K/AIqege5At0TgNplqYJIbAW9mF7blNgM6eFc27RSUJA7/AgQMtqEmXDAD9PP8OtcwScMQE5QBsBzlRWBtfINsyXD0MWcwNI/pE9JXCIosi69krAikf1oYZseX9w40e6CYJ0VDthV+lRyfJSMxjvt4SkVFXzW1EyK0Guiq4zHfF6+re3own5q8Y6KAQ77L7PrsjpSVj26qVcraAViskKcL5bFYaThEcuDD+ZLclXSMrHFmZYGaUaGFfHRSBYcXuuWjBL3YsLYJMLwfRUeCE01BbWgrlAwC10YcHU6nSYMedXqCVrdbw/CF+cDikTELMGSTlgnIFXTRLfyM/X0bBJmkT47jQoh0iuovadbxVcJCpAkgxPBp0ndpj2bivotkez6EWtcAALEKeF83ySRKmh2lRAgGxSyc7wJ+1Jxlqpgvwyg+8FLJbSRKqsyPIObbHc9F+clqkwRaCcjMxzkXnuYC1zzSeqBi+vG2zyB+Z1NTkJK1eCSUu88CSySgUpklLVsON9Za7MGhoDjHD2We6qMXVdPlvAMcDO1eKeUvqu70ZHw166FS5qjSov7/PP0bL6LY1CY1OhW06ViqzD3XapTshGWtdaNgco5iVWqDrUTSpPBvsAkNYFKAewe46oLEGMjUBwcCNTEZuzRz0SrvhSCym3rGOMCMw/n4n1VXPP9h11iQoqCn3g/xzFdH/0mIzXkxuCsrwMbU/KgMGaRDFG6S8TAenhEamktZ0jT3bEfFmjG6620Zpubu5dEZfR7HVcC1WTWa63u1k/33rzD6fMItHy37/a5SNjv9v+6fTPJd3vYvpnkuz1s30zy3R62byb5bg/bN5N8t4ftfwBqf1W5oUoKwQAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Plot an image tensor\n",
        "import matplotlib.pyplot as plt\n",
        "plt.imshow(image)\n",
        "plt.title(class_names[label.numpy()]) # add title to image by indexing on class_names list\n",
        "plt.axis(False);"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4mBAtGnPWQHy"
      },
      "source": [
        "Delicious!\n",
        "\n",
        "Okay, looks like the Food101 data we've got from TFDS is similar to the datasets we've been using in previous notebooks.\n",
        "\n",
        "Now let's preprocess it and get it ready for use with a neural network."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UeRJnQMIYLcy"
      },
      "source": [
        "## Create preprocessing functions for our data\n",
        "\n",
        "In previous notebooks, when our images were in folder format we used the method [`tf.keras.preprocessing.image_dataset_from_directory()`](https://www.tensorflow.org/api_docs/python/tf/keras/preprocessing/image_dataset_from_directory) to load them in.\n",
        "\n",
        "Doing this meant our data was loaded into a format ready to be used with our models.\n",
        "\n",
        "However, since we've downloaded the data from TensorFlow Datasets, there are a couple of preprocessing steps we have to take before it's ready to model. \n",
        "\n",
        "More specifically, our data is currently:\n",
        "\n",
        "* In `uint8` data type\n",
        "* Comprised of all differnet sized tensors (different sized images)\n",
        "* Not scaled (the pixel values are between 0 & 255)\n",
        "\n",
        "Whereas, models like data to be:\n",
        "\n",
        "* In `float32` data type\n",
        "* Have all of the same size tensors (batches require all tensors have the same shape, e.g. `(224, 224, 3)`)\n",
        "* Scaled (values between 0 & 1), also called normalized\n",
        "\n",
        "To take care of these, we'll create a `preprocess_img()` function which:\n",
        "\n",
        "* Resizes an input image tensor to a specified size using [`tf.image.resize()`](https://www.tensorflow.org/api_docs/python/tf/image/resize)\n",
        "* Converts an input image tensor's current datatype to `tf.float32` using [`tf.cast()`](https://www.tensorflow.org/api_docs/python/tf/cast)\n",
        "\n",
        "> 🔑 **Note:** Pretrained EfficientNetBX models in [`tf.keras.applications.efficientnet`](https://www.tensorflow.org/api_docs/python/tf/keras/applications/efficientnet) (what we're going to be using) have rescaling built-in. But for many other model architectures you'll want to rescale your data (e.g. get its values between 0 & 1). This could be incorporated inside your \"`preprocess_img()`\" function (like the one below) or within your model as a [`tf.keras.layers.experimental.preprocessing.Rescaling`](https://www.tensorflow.org/api_docs/python/tf/keras/layers/experimental/preprocessing/Rescaling) layer."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NKuwdjm0CWc1"
      },
      "outputs": [],
      "source": [
        "# Make a function for preprocessing images\n",
        "def preprocess_img(image, label, img_shape=224):\n",
        "  \"\"\"\n",
        "  Converts image datatype from 'uint8' -> 'float32' and reshapes image to\n",
        "  [img_shape, img_shape, color_channels]\n",
        "  \"\"\"\n",
        "  image = tf.image.resize(image, [img_shape, img_shape]) # reshape to img_shape\n",
        "  return tf.cast(image, tf.float32), label # return (float32_image, label) tuple"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m6kGGFa1Z3Nz"
      },
      "source": [
        "Our `preprocess_img()` function above takes image and label as input (even though it does nothing to the label) because our dataset is currently in the tuple structure `(image, label)`.\n",
        "\n",
        "Let's try our function out on a target image."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BqPDUGCvHI4K",
        "outputId": "84cccb6f-5ace-4903-e33d-73dfa867c6ee"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Image before preprocessing:\n",
            " [[[145 151 125]\n",
            "  [157 163 137]\n",
            "  [159 165 139]\n",
            "  ...\n",
            "  [197 209 199]\n",
            "  [197 209 199]\n",
            "  [197 207 198]]\n",
            "\n",
            " [[146 152 126]\n",
            "  [156 162 136]\n",
            "  [158 164 138]\n",
            "  ...\n",
            "  [197 209 199]\n",
            "  [197 209 199]\n",
            "  [199 209 200]]]...,\n",
            "Shape: (512, 289, 3),\n",
            "Datatype: <dtype: 'uint8'>\n",
            "\n",
            "Image after preprocessing:\n",
            " [[[147.19739 153.19739 127.19739]\n",
            "  [157.22768 163.22768 137.22768]\n",
            "  [158.09805 164.09805 138.09805]\n",
            "  ...\n",
            "  [197.      209.      197.54907]\n",
            "  [197.      209.      199.     ]\n",
            "  [198.09914 208.38936 199.24425]]\n",
            "\n",
            " [[154.69467 160.69467 134.69467]\n",
            "  [155.87053 161.87053 135.87053]\n",
            "  [158.39908 164.39908 138.39908]\n",
            "  ...\n",
            "  [197.      209.      197.54907]\n",
            "  [197.      209.      199.     ]\n",
            "  [196.32831 206.61853 195.76364]]]...,\n",
            "Shape: (224, 224, 3),\n",
            "Datatype: <dtype: 'float32'>\n"
          ]
        }
      ],
      "source": [
        "# Preprocess a single sample image and check the outputs\n",
        "preprocessed_img = preprocess_img(image, label)[0]\n",
        "print(f\"Image before preprocessing:\\n {image[:2]}...,\\nShape: {image.shape},\\nDatatype: {image.dtype}\\n\")\n",
        "print(f\"Image after preprocessing:\\n {preprocessed_img[:2]}...,\\nShape: {preprocessed_img.shape},\\nDatatype: {preprocessed_img.dtype}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uhIIvprqaHEZ"
      },
      "source": [
        "Excellent! Looks like our `preprocess_img()` function is working as expected.\n",
        "\n",
        "The input image gets converted from `uint8` to `float32` and gets reshaped from its current shape to `(224, 224, 3)`.\n",
        "\n",
        "How does it look?"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 264
        },
        "id": "wYtMxQzZY0F7",
        "outputId": "2dd69f3d-bfb0-4318-efb3-a40e98a558a2"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "# We can still plot our preprocessed image as long as we \n",
        "# divide by 255 (for matplotlib capatibility)\n",
        "plt.imshow(preprocessed_img/255.)\n",
        "plt.title(class_names[label])\n",
        "plt.axis(False);"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gsIaJZEU7y_M"
      },
      "source": [
        "All this food visualization is making me hungry. How about we start preparing to model it?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t2rd4_3CjdGE"
      },
      "source": [
        "## Batch & prepare datasets\n",
        "\n",
        "Before we can model our data, we have to turn it into batches.\n",
        "\n",
        "Why?\n",
        "\n",
        "Because computing on batches is memory efficient.\n",
        "\n",
        "We turn our data from 101,000 image tensors and labels (train and test combined) into batches of 32 image and label pairs, thus enabling it to fit into the memory of our GPU.\n",
        "\n",
        "To do this in effective way, we're going to be leveraging a number of methods from the [`tf.data` API](https://www.tensorflow.org/api_docs/python/tf/data).\n",
        "\n",
        "> 📖 **Resource:** For loading data in the most performant way possible, see the TensorFlow docuemntation on [Better performance with the tf.data API](https://www.tensorflow.org/guide/data_performance).\n",
        "\n",
        "Specifically, we're going to be using:\n",
        "\n",
        "* [`map()`](https://www.tensorflow.org/api_docs/python/tf/data/Dataset#map) - maps a predefined function to a target dataset (e.g. `preprocess_img()` to our image tensors)\n",
        "* [`shuffle()`](https://www.tensorflow.org/api_docs/python/tf/data/Dataset#shuffle) - randomly shuffles the elements of a target dataset up `buffer_size` (ideally, the `buffer_size` is equal to the size of the dataset, however, this may have implications on memory)\n",
        "* [`batch()`](https://www.tensorflow.org/api_docs/python/tf/data/Dataset#batch) - turns elements of a target dataset into batches (size defined by parameter `batch_size`)\n",
        "* [`prefetch()`](https://www.tensorflow.org/api_docs/python/tf/data/Dataset#prefetch) - prepares subsequent batches of data whilst other batches of data are being computed on (improves data loading speed but costs memory)\n",
        "* Extra: [`cache()`](https://www.tensorflow.org/api_docs/python/tf/data/Dataset#cache) - caches (saves them for later) elements in a target dataset, saving loading time (will only work if your dataset is small enough to fit in memory, standard Colab instances only have 12GB of memory) \n",
        "\n",
        "Things to note:\n",
        "- Can't batch tensors of different shapes (e.g. different image sizes, need to reshape images first, hence our `preprocess_img()` function)\n",
        "- `shuffle()` keeps a buffer of the number you pass it images shuffled, ideally this number would be all of the samples in your training set, however, if your training set is large, this buffer might not fit in memory (a fairly large number like 1000 or 10000 is usually suffice for shuffling)\n",
        "- For methods with the `num_parallel_calls` parameter available (such as `map()`), setting it to`num_parallel_calls=tf.data.AUTOTUNE` will parallelize preprocessing and significantly improve speed\n",
        "- Can't use `cache()` unless your dataset can fit in memory\n",
        "\n",
        "Woah, the above is alot. But once we've coded below, it'll start to make sense.\n",
        "\n",
        "We're going to through things in the following order:\n",
        "\n",
        "```\n",
        "Original dataset (e.g. train_data) -> map() -> shuffle() -> batch() -> prefetch() -> PrefetchDataset\n",
        "```\n",
        "\n",
        "This is like saying, \n",
        "\n",
        "> \"Hey, map this preprocessing function across our training dataset, then shuffle a number of elements before batching them together and make sure you prepare new batches (prefetch) whilst the model is looking through the current batch\".\n",
        "\n",
        "![](https://raw.githubusercontent.com/mrdbourke/tensorflow-deep-learning/main/images/07-prefetching-from-hands-on-ml.png)\n",
        "\n",
        "*What happens when you use prefetching (faster) versus what happens when you don't use prefetching (slower). **Source:** Page 422 of [Hands-On Machine Learning with Scikit-Learn, Keras & TensorFlow Book by Aurélien Géron](https://www.oreilly.com/library/view/hands-on-machine-learning/9781492032632/).*\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "VhA4gq-pI2W3"
      },
      "outputs": [],
      "source": [
        "# Map preprocessing function to training data (and paralellize)\n",
        "train_data = train_data.map(map_func=preprocess_img, num_parallel_calls=tf.data.AUTOTUNE)\n",
        "# Shuffle train_data and turn it into batches and prefetch it (load it faster)\n",
        "train_data = train_data.shuffle(buffer_size=1000).batch(batch_size=32).prefetch(buffer_size=tf.data.AUTOTUNE)\n",
        "\n",
        "# Map prepreprocessing function to test data\n",
        "test_data = test_data.map(preprocess_img, num_parallel_calls=tf.data.AUTOTUNE)\n",
        "# Turn test data into batches (don't need to shuffle)\n",
        "test_data = test_data.batch(32).prefetch(tf.data.AUTOTUNE)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rnTPWyAhlKO3"
      },
      "source": [
        "And now let's check out what our prepared datasets look like."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5_fBkGqfJFxT",
        "outputId": "176eab2e-d62a-433e-f7c1-32f111719e07"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(<PrefetchDataset shapes: ((None, 224, 224, 3), (None,)), types: (tf.float32, tf.int64)>,\n",
              " <PrefetchDataset shapes: ((None, 224, 224, 3), (None,)), types: (tf.float32, tf.int64)>)"
            ]
          },
          "execution_count": 56,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "train_data, test_data"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X1fxgyWnlQNU"
      },
      "source": [
        "Excellent! Looks like our data is now in tutples of `(image, label)` with datatypes of `(tf.float32, tf.int64)`, just what our model is after.\n",
        "\n",
        "> 🔑 **Note:** You can get away without calling the `prefetch()` method on the end of your datasets, however, you'd probably see significantly slower data loading speeds when building a model. So most of your dataset input pipelines should end with a call to [`prefecth()`](https://www.tensorflow.org/api_docs/python/tf/data/Dataset#prefetch).\n",
        "\n",
        "Onward."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Qj3umnpMvSw8"
      },
      "source": [
        "## Create modelling callbacks\n",
        "\n",
        "Since we're going to be training on a large amount of data and training could take a long time, it's a good idea to set up some modelling callbacks so we be sure of things like our model's training logs being tracked and our model being checkpointed (saved) after various training milestones.\n",
        "\n",
        "To do each of these we'll use the following callbacks:\n",
        "* [`tf.keras.callbacks.TensorBoard()`](https://www.tensorflow.org/api_docs/python/tf/keras/callbacks/TensorBoard) - allows us to keep track of our model's training history so we can inspect it later (**note:** we've created this callback before have imported it from `helper_functions.py` as `create_tensorboard_callback()`)\n",
        "* [`tf.keras.callbacks.ModelCheckpoint()`](https://www.tensorflow.org/api_docs/python/tf/keras/callbacks/ModelCheckpoint) - saves our model's progress at various intervals so we can load it and resuse it later without having to retrain it\n",
        "  * Checkpointing is also helpful so we can start fine-tuning our model at a particular epoch and revert back to a previous state if fine-tuning offers no benefits"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wyYmxPnlXOwd"
      },
      "outputs": [],
      "source": [
        "# Create TensorBoard callback (already have \"create_tensorboard_callback()\" from a previous notebook)\n",
        "from helper_functions import create_tensorboard_callback\n",
        "\n",
        "# Create ModelCheckpoint callback to save model's progress\n",
        "checkpoint_path = \"model_checkpoints/cp.ckpt\" # saving weights requires \".ckpt\" extension\n",
        "model_checkpoint = tf.keras.callbacks.ModelCheckpoint(checkpoint_path,\n",
        "                                                      montior=\"val_accuracy\", # save the model weights with best validation accuracy\n",
        "                                                      save_best_only=True, # only save the best weights\n",
        "                                                      save_weights_only=True, # only save model weights (not whole model)\n",
        "                                                      verbose=1) # don't print out whether or not model is being saved "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DyXlCU50UElG"
      },
      "source": [
        "## Setup mixed precision training\n",
        "\n",
        "We touched on mixed precision training above.\n",
        "\n",
        "However, we didn't quite explain it.\n",
        "\n",
        "Normally, tensors in TensorFlow default to the float32 datatype (unless otherwise specified).\n",
        "\n",
        "In computer science, float32 is also known as [single-precision floating-point format](https://en.wikipedia.org/wiki/Single-precision_floating-point_format). The 32 means it usually occupies 32 bits in computer memory.\n",
        "\n",
        "Your GPU has a limited memory, therefore it can only handle a number of float32 tensors at the same time.\n",
        "\n",
        "This is where mixed precision training comes in.\n",
        "\n",
        "Mixed precision training involves using a mix of float16 and float32 tensors to make better use of your GPU's memory.\n",
        "\n",
        "Can you guess what float16 means?\n",
        "\n",
        "Well, if you thought since float32 meant single-precision floating-point, you might've guessed float16 means [half-precision floating-point format](https://en.wikipedia.org/wiki/Half-precision_floating-point_format). And if you did, you're right! And if not, no trouble, now you know.\n",
        "\n",
        "For tensors in float16 format, each element occupies 16 bits in computer memory.\n",
        "\n",
        "So, where does this leave us?\n",
        "\n",
        "As mentioned before, when using mixed precision training, your model will make use of float32 and float16 data types to use less memory where possible and in turn run faster (using less memory per tensor means more tensors can be computed on simultaneously).\n",
        "\n",
        "As a result, using mixed precision training can improve your performance on modern GPUs (those with a compute capability score of 7.0+) by up to 3x.\n",
        "\n",
        "For a more detailed explanation, I encourage you to read through the [TensorFlow mixed precision guide](https://www.tensorflow.org/guide/mixed_precision) (I'd highly recommend at least checking out the summary).\n",
        "\n",
        "![](https://raw.githubusercontent.com/mrdbourke/tensorflow-deep-learning/main/images/07-mixed-precision-speedup-equals-3x-gpu.png)\n",
        "*Because mixed precision training uses a combination of float32 and float16 data types, you may see up to a 3x speedup on modern GPUs.*\n",
        "\n",
        "> 🔑 **Note:** If your GPU doesn't have a score of over 7.0+ (e.g. P100 in Colab), mixed precision won't work (see: [\"Supported Hardware\"](https://www.tensorflow.org/guide/mixed_precision#supported_hardware) in the mixed precision guide for more).\n",
        "\n",
        "> 📖 **Resource:** If you'd like to learn more about precision in computer science (the detail to which a numerical quantity is expressed by a computer), see the [Wikipedia page](https://en.wikipedia.org/wiki/Precision_(computer_science)) (and accompanying resources). \n",
        "\n",
        "Okay, enough talk, let's see how we can turn on mixed precision training in TensorFlow.\n",
        "\n",
        "The beautiful thing is, the [`tensorflow.keras.mixed_precision`](https://www.tensorflow.org/api_docs/python/tf/keras/mixed_precision/) API has made it very easy for us to get started.\n",
        "\n",
        "First, we'll import the API and then use the [`set_global_policy()`](https://www.tensorflow.org/api_docs/python/tf/keras/mixed_precision/set_global_policy) method to set the *dtype policy* to `\"mixed_float16\"`.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5BuEjmlybR7V"
      },
      "outputs": [],
      "source": [
        "# Turn on mixed precision training\n",
        "from tensorflow.keras import mixed_precision\n",
        "mixed_precision.set_global_policy(policy=\"mixed_float16\") # set global policy to mixed precision "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OLxlu7VyYoQm"
      },
      "source": [
        "Nice! As long as the GPU you're using has a compute capability of 7.0+ the cell above should run without error.\n",
        "\n",
        "Now we can check the global dtype policy (the policy which will be used by layers in our model) using the [`mixed_precision.global_policy()`](https://www.tensorflow.org/api_docs/python/tf/keras/mixed_precision/global_policy) method."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qzSWJP8KkKae",
        "outputId": "90ae40e6-e28f-4c16-b565-0114cff046e2"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Policy \"mixed_float16\">"
            ]
          },
          "execution_count": 59,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "mixed_precision.global_policy() # should output \"mixed_float16\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gpnAW2ltXCpE"
      },
      "source": [
        "Great, since the global dtype policy is now `\"mixed_float16\"` our model will automatically take advantage of float16 variables where possible and in turn speed up training."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rA8FBJwwvVoG"
      },
      "source": [
        "## Build feature extraction model\n",
        "\n",
        "Callbacks: ready to roll.\n",
        "\n",
        "Mixed precision: turned on.\n",
        "\n",
        "Let's build a model.\n",
        "\n",
        "Because our dataset is quite large, we're going to move towards fine-tuning an existing pretrained model (EfficienetNetB0).\n",
        "\n",
        "But before we get into fine-tuning, let's set up a feature-extraction model.\n",
        "\n",
        "Recall, the typical order for using transfer learning is:\n",
        "\n",
        "1. Build a feature extraction model (replace the top few layers of a pretrained model) \n",
        "2. Train for a few epochs with lower layers frozen\n",
        "3. Fine-tune if necessary with multiple layers unfrozen\n",
        "\n",
        "![](https://raw.githubusercontent.com/mrdbourke/tensorflow-deep-learning/main/images/07-feature-extraction-then-fine-tune.png)\n",
        "*Before fine-tuning, it's best practice to train a feature extraction model with custom top layers.*\n",
        "\n",
        "To build the feature extraction model (covered in [Transfer Learning in TensorFlow Part 1: Feature extraction](https://github.com/mrdbourke/tensorflow-deep-learning/blob/main/04_transfer_learning_in_tensorflow_part_1_feature_extraction.ipynb)), we'll:\n",
        "* Use `EfficientNetB0` from [`tf.keras.applications`](https://www.tensorflow.org/api_docs/python/tf/keras/applications) pre-trained on ImageNet as our base model\n",
        "  * We'll download this without the top layers using `include_top=False` parameter so we can create our own output layers\n",
        "* Freeze the base model layers so we can use the pre-learned patterns the base model has found on ImageNet\n",
        "* Put together the input, base model, pooling and output layers in a [Functional model](https://keras.io/guides/functional_api/)\n",
        "* Compile the Functional model using the Adam optimizer and [sparse categorical crossentropy](https://www.tensorflow.org/api_docs/python/tf/keras/losses/SparseCategoricalCrossentropy) as the loss function (since our labels **aren't** one-hot encoded)\n",
        "* Fit the model for 3 epochs using the TensorBoard and ModelCheckpoint callbacks\n",
        "\n",
        "> 🔑 **Note:** Since we're using mixed precision training, our model needs a separate output layer with a hard-coded `dtype=float32`, for example, `layers.Activation(\"softmax\", dtype=tf.float32)`. This ensures the outputs of our model are returned back to the float32 data type which is more numerically stable than the float16 datatype (important for loss calculations). See the [\"Building the model\"](https://www.tensorflow.org/guide/mixed_precision#building_the_model) section in the TensorFlow mixed precision guide for more.\n",
        "\n",
        "![](https://raw.githubusercontent.com/mrdbourke/tensorflow-deep-learning/main/images/07-mixed-precision-code-before-and-after.png)\n",
        "*Turning mixed precision on in TensorFlow with 3 lines of code.*"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GrkWpCzfXKE7"
      },
      "outputs": [],
      "source": [
        "from tensorflow.keras import layers\n",
        "from tensorflow.keras.layers.experimental import preprocessing\n",
        "\n",
        "# Create base model\n",
        "input_shape = (224, 224, 3)\n",
        "base_model = tf.keras.applications.EfficientNetB0(include_top=False)\n",
        "base_model.trainable = False # freeze base model layers\n",
        "\n",
        "# Create Functional model \n",
        "inputs = layers.Input(shape=input_shape, name=\"input_layer\", dtype=tf.float16)\n",
        "# Note: EfficientNetBX models have rescaling built-in but if your model didn't you could have a layer like below\n",
        "# x = preprocessing.Rescaling(1./255)(x)\n",
        "x = base_model(inputs, training=False) # set base_model to inference mode only\n",
        "x = layers.GlobalAveragePooling2D(name=\"pooling_layer\")(x)\n",
        "x = layers.Dense(len(class_names))(x) # want one output neuron per class \n",
        "# Separate activation of output layer so we can output float32 activations\n",
        "outputs = layers.Activation(\"softmax\", dtype=tf.float32, name=\"softmax_float32\")(x) \n",
        "model = tf.keras.Model(inputs, outputs)\n",
        "\n",
        "# Compile the model\n",
        "model.compile(loss=\"sparse_categorical_crossentropy\", # Use sparse_categorical_crossentropy when labels are *not* one-hot\n",
        "              optimizer=tf.keras.optimizers.Adam(),\n",
        "              metrics=[\"accuracy\"])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wfEG8ud_jsNY",
        "outputId": "82b20036-498f-4efa-9ae1-d9e9e5c728e8"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Model: \"model_1\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "input_layer (InputLayer)     [(None, 224, 224, 3)]     0         \n",
            "_________________________________________________________________\n",
            "efficientnetb0 (Functional)  (None, None, None, 1280)  4049571   \n",
            "_________________________________________________________________\n",
            "pooling_layer (GlobalAverage (None, 1280)              0         \n",
            "_________________________________________________________________\n",
            "dense_1 (Dense)              (None, 101)               129381    \n",
            "_________________________________________________________________\n",
            "softmax_float32 (Activation) (None, 101)               0         \n",
            "=================================================================\n",
            "Total params: 4,178,952\n",
            "Trainable params: 129,381\n",
            "Non-trainable params: 4,049,571\n",
            "_________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "# Check out our model\n",
        "model.summary()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lIXkEdnNGpKi"
      },
      "source": [
        "## Checking layer dtype policies (are we using mixed precision?)\n",
        "\n",
        "Model ready to go!\n",
        "\n",
        "Before we said the mixed precision API will automatically change our layers' dtype policy's to whatever the global dtype policy is (in our case it's `\"mixed_float16\"`).\n",
        "\n",
        "We can check this by iterating through our model's layers and printing layer attributes such as `dtype` and `dtype_policy`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Zk__ebBLHC-Q",
        "outputId": "e94ff2a5-6adb-4745-fcd0-8cb2f2d5a083"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "input_layer True float16 <Policy \"float16\">\n",
            "efficientnetb0 False float32 <Policy \"mixed_float16\">\n",
            "pooling_layer True float32 <Policy \"mixed_float16\">\n",
            "dense_1 True float32 <Policy \"mixed_float16\">\n",
            "softmax_float32 True float32 <Policy \"float32\">\n"
          ]
        }
      ],
      "source": [
        "# Check the dtype_policy attributes of layers in our model\n",
        "for layer in model.layers:\n",
        "  print(layer.name, layer.trainable, layer.dtype, layer.dtype_policy) # Check the dtype policy of layers"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7w6Gv6ySfpNY"
      },
      "source": [
        "Going through the above we see:\n",
        "* `layer.name` (str) : a layer's human-readable name, can be defined by the `name` parameter on construction\n",
        "* `layer.trainable` (bool) : whether or not a layer is trainable (all of our layers are trainable except the efficientnetb0 layer since we set it's `trainable` attribute to `False`\n",
        "* `layer.dtype` : the data type a layer stores its variables in\n",
        "* `layer.dtype_policy` : the data type a layer computes in\n",
        "\n",
        "> 🔑 **Note:** A layer can have a dtype of `float32` and a dtype policy of `\"mixed_float16\"` because it stores its variables (weights & biases) in `float32` (more numerically stable), however it computes in `float16` (faster).\n",
        "\n",
        "We can also check the same details for our model's base model.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eL_THJCYGenQ",
        "outputId": "5339f5f1-0179-4b56-b65a-80ec350aee45"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "input_2 False float32 <Policy \"float32\">\n",
            "rescaling_1 False float32 <Policy \"mixed_float16\">\n",
            "normalization_1 False float32 <Policy \"mixed_float16\">\n",
            "stem_conv_pad False float32 <Policy \"mixed_float16\">\n",
            "stem_conv False float32 <Policy \"mixed_float16\">\n",
            "stem_bn False float32 <Policy \"mixed_float16\">\n",
            "stem_activation False float32 <Policy \"mixed_float16\">\n",
            "block1a_dwconv False float32 <Policy \"mixed_float16\">\n",
            "block1a_bn False float32 <Policy \"mixed_float16\">\n",
            "block1a_activation False float32 <Policy \"mixed_float16\">\n",
            "block1a_se_squeeze False float32 <Policy \"mixed_float16\">\n",
            "block1a_se_reshape False float32 <Policy \"mixed_float16\">\n",
            "block1a_se_reduce False float32 <Policy \"mixed_float16\">\n",
            "block1a_se_expand False float32 <Policy \"mixed_float16\">\n",
            "block1a_se_excite False float32 <Policy \"mixed_float16\">\n",
            "block1a_project_conv False float32 <Policy \"mixed_float16\">\n",
            "block1a_project_bn False float32 <Policy \"mixed_float16\">\n",
            "block2a_expand_conv False float32 <Policy \"mixed_float16\">\n",
            "block2a_expand_bn False float32 <Policy \"mixed_float16\">\n",
            "block2a_expand_activation False float32 <Policy \"mixed_float16\">\n"
          ]
        }
      ],
      "source": [
        "# Check the layers in the base model and see what dtype policy they're using\n",
        "for layer in model.layers[1].layers[:20]: # only check the first 20 layers to save output space\n",
        "  print(layer.name, layer.trainable, layer.dtype, layer.dtype_policy)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GerkBr7GiDIj"
      },
      "source": [
        "> 🔑 **Note:** The mixed precision API automatically causes layers which can benefit from using the `\"mixed_float16\"` dtype policy to use it. It also prevents layers which shouldn't use it from using it (e.g. the normalization layer at the start of the base model)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NJz5S66ojyUS"
      },
      "source": [
        "## Fit the feature extraction model\n",
        "\n",
        "Now that's one good looking model. Let's fit it to our data shall we?\n",
        "\n",
        "Three epochs should be enough for our top layers to adjust their weights enough to our food image data.\n",
        "\n",
        "To save time per epoch, we'll also only validate on 15% of the test data."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4v7rXZG-ZkNJ",
        "outputId": "e7f6f934-538b-42e1-f732-0bfd3b0ff13b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Saving TensorBoard log files to: training_logs/efficientnetb0_101_classes_all_data_feature_extract/20211215-112338\n",
            "Epoch 1/3\n",
            "2368/2368 [==============================] - 55s 22ms/step - loss: 1.8217 - accuracy: 0.5565 - val_loss: 1.2271 - val_accuracy: 0.6774\n",
            "\n",
            "Epoch 00001: val_loss improved from inf to 1.22710, saving model to model_checkpoints/cp.ckpt\n",
            "Epoch 2/3\n",
            "2368/2368 [==============================] - 51s 21ms/step - loss: 1.2942 - accuracy: 0.6655 - val_loss: 1.1317 - val_accuracy: 0.6989\n",
            "\n",
            "Epoch 00002: val_loss improved from 1.22710 to 1.13174, saving model to model_checkpoints/cp.ckpt\n",
            "Epoch 3/3\n",
            "2368/2368 [==============================] - 51s 22ms/step - loss: 1.1446 - accuracy: 0.7017 - val_loss: 1.0912 - val_accuracy: 0.7058\n",
            "\n",
            "Epoch 00003: val_loss improved from 1.13174 to 1.09125, saving model to model_checkpoints/cp.ckpt\n"
          ]
        }
      ],
      "source": [
        "# Fit the model with callbacks\n",
        "history_101_food_classes_feature_extract = model.fit(train_data, \n",
        "                                                     epochs=3,\n",
        "                                                     steps_per_epoch=len(train_data),\n",
        "                                                     validation_data=test_data,\n",
        "                                                     validation_steps=int(0.15 * len(test_data)),\n",
        "                                                     callbacks=[create_tensorboard_callback(\"training_logs\", \n",
        "                                                                                            \"efficientnetb0_101_classes_all_data_feature_extract\"),\n",
        "                                                                model_checkpoint])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xg01Gh3EnQSu"
      },
      "source": [
        "Nice, looks like our feature extraction model is performing pretty well. How about we evaluate it on the whole test dataset?"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jhV7fvTreV27",
        "outputId": "ca5d6920-1d60-46b4-abd3-38f0e8776718"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "790/790 [==============================] - 14s 18ms/step - loss: 1.0924 - accuracy: 0.7053\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "[1.0923811197280884, 0.7053465247154236]"
            ]
          },
          "execution_count": 65,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Evaluate model (unsaved version) on whole test dataset\n",
        "results_feature_extract_model = model.evaluate(test_data)\n",
        "results_feature_extract_model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TI0li4ZenctF"
      },
      "source": [
        "And since we used the `ModelCheckpoint` callback, we've got a saved version of our model in the `model_checkpoints` directory.\n",
        "\n",
        "Let's load it in and make sure it performs just as well."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nNGoI1cS21um"
      },
      "source": [
        "## Load and evaluate checkpoint weights\n",
        "\n",
        "We can load in and evaluate our model's checkpoints by:\n",
        "\n",
        "1. Cloning our model using [`tf.keras.models.clone_model()`](https://www.tensorflow.org/api_docs/python/tf/keras/models/clone_model) to make a copy of our feature extraction model with reset weights.\n",
        "2. Calling the `load_weights()` method on our cloned model passing it the path to where our checkpointed weights are stored.\n",
        "3. Calling `evaluate()` on the cloned model with loaded weights.\n",
        "\n",
        "A reminder, checkpoints are helpful for when you perform an experiment such as fine-tuning your model. In the case you fine-tune your feature extraction model and find it doesn't offer any improvements, you can always revert back to the checkpointed version of your model."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C5a_eh9RKBSY",
        "outputId": "71986b44-476b-4252-a8fc-2f4e1d77f073"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Model: \"model_1\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "input_layer (InputLayer)     [(None, 224, 224, 3)]     0         \n",
            "_________________________________________________________________\n",
            "efficientnetb0 (Functional)  (None, None, None, 1280)  4049571   \n",
            "_________________________________________________________________\n",
            "pooling_layer (GlobalAverage (None, 1280)              0         \n",
            "_________________________________________________________________\n",
            "dense_1 (Dense)              (None, 101)               129381    \n",
            "_________________________________________________________________\n",
            "softmax_float32 (Activation) (None, 101)               0         \n",
            "=================================================================\n",
            "Total params: 4,178,952\n",
            "Trainable params: 129,381\n",
            "Non-trainable params: 4,049,571\n",
            "_________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "# Clone the model we created (this resets all weights)\n",
        "cloned_model = tf.keras.models.clone_model(model)\n",
        "cloned_model.summary()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UnndQiN44Naq",
        "outputId": "39cd4168-2ab7-4f13-cd9e-b5ff721942ec"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "checkpoint  cp.ckpt.data-00000-of-00001  cp.ckpt.index\r\n"
          ]
        }
      ],
      "source": [
        "!ls model_checkpoints/"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "3NBOvb9bkAHa",
        "outputId": "0ea80b8d-9570-4148-a784-f6fac093bc5e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'model_checkpoints/cp.ckpt'"
            ]
          },
          "execution_count": 68,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Where are our checkpoints stored?\n",
        "checkpoint_path"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mnagdIagKGZY",
        "outputId": "2787e959-6681-48fb-c37a-a324fad7f026"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<tensorflow.python.training.tracking.util.CheckpointLoadStatus at 0x7effebbd6b50>"
            ]
          },
          "execution_count": 69,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Load checkpointed weights into cloned_model\n",
        "cloned_model.load_weights(checkpoint_path)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wh_-7URJlapr"
      },
      "source": [
        "Each time you make a change to your model (including loading weights), you have to recompile."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "So0ybUwRKNSf"
      },
      "outputs": [],
      "source": [
        "# Compile cloned_model (with same parameters as original model)\n",
        "cloned_model.compile(loss=\"sparse_categorical_crossentropy\",\n",
        "                     optimizer=tf.keras.optimizers.Adam(),\n",
        "                     metrics=[\"accuracy\"])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aZtbkOhHKKLs",
        "outputId": "c7e27c13-3a60-4a75-fdb3-ec32fdcb260d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "790/790 [==============================] - 15s 18ms/step - loss: 1.7466 - accuracy: 0.5401\n"
          ]
        }
      ],
      "source": [
        "# Evalaute cloned model with loaded weights (should be same score as trained model)\n",
        "results_cloned_model_with_loaded_weights = cloned_model.evaluate(test_data)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_441Jd7PlkN4"
      },
      "source": [
        "Our cloned model with loaded weight's results should be very close to the feature extraction model's results (if the cell below errors, something went wrong)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zbcuQQgz5tNX",
        "outputId": "b0c76637-1c70-4b00-8338-ebe5c164909f"
      },
      "outputs": [
        {
          "ename": "AssertionError",
          "evalue": "",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m/tmp/ipykernel_726063/1110829135.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Loaded checkpoint weights should return very similar results to checkpoint weights prior to saving\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mnumpy\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0misclose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresults_feature_extract_model\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mresults_cloned_model_with_loaded_weights\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mall\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# check if all elements in array are close\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mAssertionError\u001b[0m: "
          ]
        }
      ],
      "source": [
        "# Loaded checkpoint weights should return very similar results to checkpoint weights prior to saving\n",
        "import numpy as np\n",
        "assert np.isclose(results_feature_extract_model, results_cloned_model_with_loaded_weights).all() # check if all elements in array are close"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n6j46R_L3VED"
      },
      "source": [
        "Cloning the model preserves `dtype_policy`'s of layers (but doesn't preserve weights) so if we wanted to continue fine-tuning with the cloned model, we could and it would still use the mixed precision dtype policy."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YjCO0tm9Je3N",
        "outputId": "d894df48-2202-4f34-c079-3d619f4f4345"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "input_2 True float32 <Policy \"float32\">\n",
            "rescaling_1 False float32 <Policy \"mixed_float16\">\n",
            "normalization_1 False float32 <Policy \"mixed_float16\">\n",
            "stem_conv_pad False float32 <Policy \"mixed_float16\">\n",
            "stem_conv False float32 <Policy \"mixed_float16\">\n",
            "stem_bn False float32 <Policy \"mixed_float16\">\n",
            "stem_activation False float32 <Policy \"mixed_float16\">\n",
            "block1a_dwconv False float32 <Policy \"mixed_float16\">\n",
            "block1a_bn False float32 <Policy \"mixed_float16\">\n",
            "block1a_activation False float32 <Policy \"mixed_float16\">\n",
            "block1a_se_squeeze False float32 <Policy \"mixed_float16\">\n",
            "block1a_se_reshape False float32 <Policy \"mixed_float16\">\n",
            "block1a_se_reduce False float32 <Policy \"mixed_float16\">\n",
            "block1a_se_expand False float32 <Policy \"mixed_float16\">\n",
            "block1a_se_excite False float32 <Policy \"mixed_float16\">\n",
            "block1a_project_conv False float32 <Policy \"mixed_float16\">\n",
            "block1a_project_bn False float32 <Policy \"mixed_float16\">\n",
            "block2a_expand_conv False float32 <Policy \"mixed_float16\">\n",
            "block2a_expand_bn False float32 <Policy \"mixed_float16\">\n",
            "block2a_expand_activation False float32 <Policy \"mixed_float16\">\n"
          ]
        }
      ],
      "source": [
        "# Check the layers in the base model and see what dtype policy they're using\n",
        "for layer in cloned_model.layers[1].layers[:20]: # check only the first 20 layers to save space\n",
        "  print(layer.name, layer.trainable, layer.dtype, layer.dtype_policy)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EvTGiIFv3eOe"
      },
      "source": [
        "## Save the whole model to file\n",
        "\n",
        "We can also save the whole model using the [`save()`](https://www.tensorflow.org/api_docs/python/tf/keras/Model#save) method.\n",
        "\n",
        "Since our model is quite large, you might want to save it to Google Drive (if you're using Google Colab) so you can load it in for use later.\n",
        "\n",
        "> 🔑 **Note:** Saving to Google Drive requires mounting Google Drive (go to Files -> Mount Drive)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "CH4jkVPBoPhe"
      },
      "outputs": [],
      "source": [
        "# ## Saving model to Google Drive (optional)\n",
        "\n",
        "# # Create save path to drive \n",
        "# save_dir = \"drive/MyDrive/tensorflow_course/food_vision/07_efficientnetb0_feature_extract_model_mixed_precision/\"\n",
        "# # os.makedirs(save_dir) # Make directory if it doesn't exist\n",
        "\n",
        "# # Save model\n",
        "# model.save(save_dir)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-P1L5fiwnApE"
      },
      "source": [
        "We can also save it directly to our Google Colab instance.\n",
        "\n",
        "> 🔑 **Note:** Google Colab storage is ephemeral and your model will delete itself (along with any other saved files) when the Colab session expires."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "collapsed": true,
        "id": "RHKn4Ex57wzF",
        "outputId": "6f8706a9-d2f5-4774-b68f-8f59c40ab789"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Assets written to: 07_efficientnetb0_feature_extract_model_mixed_precision/assets\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Assets written to: 07_efficientnetb0_feature_extract_model_mixed_precision/assets\n",
            "/home/daniel/code/tensorflow/env/lib/python3.9/site-packages/keras/utils/generic_utils.py:494: CustomMaskWarning: Custom mask layers require a config and must override get_config. When loading, the custom mask layer must be passed to the custom_objects argument.\n",
            "  warnings.warn('Custom mask layers require a config and must override '\n"
          ]
        }
      ],
      "source": [
        "# Save model locally (if you're using Google Colab, your saved model will Colab instance terminates)\n",
        "save_dir = \"07_efficientnetb0_feature_extract_model_mixed_precision\"\n",
        "model.save(save_dir)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QKiEXBC6n83F"
      },
      "source": [
        "And again, we can check whether or not our model saved correctly by loading it in and evaluating it."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "id": "bKGDBKrU6rej",
        "outputId": "25592c06-61f8-4359-cdcc-b1a62e2175b7"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "WARNING:absl:Importing a function (__inference_block3b_activation_layer_call_and_return_conditional_losses_143555) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5a_expand_activation_layer_call_and_return_conditional_losses_145084) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5b_expand_activation_layer_call_and_return_conditional_losses_108907) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6b_se_reduce_layer_call_and_return_conditional_losses_109467) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block3b_expand_activation_layer_call_and_return_conditional_losses_143461) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block7a_activation_layer_call_and_return_conditional_losses_109925) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5c_expand_activation_layer_call_and_return_conditional_losses_109074) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5a_se_reduce_layer_call_and_return_conditional_losses_145246) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block3b_se_reduce_layer_call_and_return_conditional_losses_108162) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4a_activation_layer_call_and_return_conditional_losses_143989) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4c_se_reduce_layer_call_and_return_conditional_losses_144834) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5b_activation_layer_call_and_return_conditional_losses_145543) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block3b_se_reduce_layer_call_and_return_conditional_losses_143623) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6c_se_reduce_layer_call_and_return_conditional_losses_147234) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5c_activation_layer_call_and_return_conditional_losses_145955) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block2b_se_reduce_layer_call_and_return_conditional_losses_107836) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6b_expand_activation_layer_call_and_return_conditional_losses_109400) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6d_se_reduce_layer_call_and_return_conditional_losses_147646) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5a_activation_layer_call_and_return_conditional_losses_108779) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6d_activation_layer_call_and_return_conditional_losses_109758) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block2a_expand_activation_layer_call_and_return_conditional_losses_142275) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5a_se_reduce_layer_call_and_return_conditional_losses_108822) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6a_se_reduce_layer_call_and_return_conditional_losses_109315) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block1a_activation_layer_call_and_return_conditional_losses_142004) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4b_expand_activation_layer_call_and_return_conditional_losses_144260) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_efficientnetb0_layer_call_and_return_conditional_losses_136248) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block2b_se_reduce_layer_call_and_return_conditional_losses_142824) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6a_expand_activation_layer_call_and_return_conditional_losses_146273) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block7a_activation_layer_call_and_return_conditional_losses_147990) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block1a_activation_layer_call_and_return_conditional_losses_107482) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block2b_activation_layer_call_and_return_conditional_losses_107793) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block3a_expand_activation_layer_call_and_return_conditional_losses_143074) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5c_se_reduce_layer_call_and_return_conditional_losses_109141) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5b_se_reduce_layer_call_and_return_conditional_losses_108974) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4c_expand_activation_layer_call_and_return_conditional_losses_108588) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block3a_activation_layer_call_and_return_conditional_losses_107967) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5a_activation_layer_call_and_return_conditional_losses_145178) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5a_expand_activation_layer_call_and_return_conditional_losses_108755) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block3a_se_reduce_layer_call_and_return_conditional_losses_143258) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5c_se_reduce_layer_call_and_return_conditional_losses_146023) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5b_activation_layer_call_and_return_conditional_losses_108931) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "WARNING:absl:Importing a function (__inference_block5b_se_reduce_layer_call_and_return_conditional_losses_145611) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_efficientnetb0_layer_call_and_return_conditional_losses_122182) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block2b_expand_activation_layer_call_and_return_conditional_losses_142662) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block7a_expand_activation_layer_call_and_return_conditional_losses_147896) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6c_expand_activation_layer_call_and_return_conditional_losses_147072) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6a_expand_activation_layer_call_and_return_conditional_losses_109241) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block2b_expand_activation_layer_call_and_return_conditional_losses_107769) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4b_activation_layer_call_and_return_conditional_losses_108445) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block2a_activation_layer_call_and_return_conditional_losses_107641) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_model_1_layer_call_and_return_conditional_losses_132004) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block3a_se_reduce_layer_call_and_return_conditional_losses_108010) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4a_se_reduce_layer_call_and_return_conditional_losses_108336) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5b_expand_activation_layer_call_and_return_conditional_losses_145449) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_stem_activation_layer_call_and_return_conditional_losses_107458) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4a_se_reduce_layer_call_and_return_conditional_losses_144057) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block2a_se_reduce_layer_call_and_return_conditional_losses_142459) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block1a_se_reduce_layer_call_and_return_conditional_losses_142072) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4b_se_reduce_layer_call_and_return_conditional_losses_108488) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6d_se_reduce_layer_call_and_return_conditional_losses_109801) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4a_activation_layer_call_and_return_conditional_losses_108293) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4b_se_reduce_layer_call_and_return_conditional_losses_144422) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_efficientnetb0_layer_call_and_return_conditional_losses_138119) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6a_activation_layer_call_and_return_conditional_losses_109272) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6c_expand_activation_layer_call_and_return_conditional_losses_109567) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6a_se_reduce_layer_call_and_return_conditional_losses_146457) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4a_expand_activation_layer_call_and_return_conditional_losses_143873) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4a_expand_activation_layer_call_and_return_conditional_losses_108262) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6c_se_reduce_layer_call_and_return_conditional_losses_109634) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_efficientnetb0_layer_call_and_return_conditional_losses_141728) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_top_activation_layer_call_and_return_conditional_losses_110053) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block3a_expand_activation_layer_call_and_return_conditional_losses_107936) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_top_activation_layer_call_and_return_conditional_losses_148261) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block7a_se_reduce_layer_call_and_return_conditional_losses_148058) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_model_1_layer_call_and_return_conditional_losses_130255) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6d_activation_layer_call_and_return_conditional_losses_147578) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6a_activation_layer_call_and_return_conditional_losses_146389) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_efficientnetb0_layer_call_and_return_conditional_losses_118373) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6b_se_reduce_layer_call_and_return_conditional_losses_146822) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference__wrapped_model_100137) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6c_activation_layer_call_and_return_conditional_losses_147166) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block7a_se_reduce_layer_call_and_return_conditional_losses_109968) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4b_activation_layer_call_and_return_conditional_losses_144354) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "WARNING:absl:Importing a function (__inference_block2a_expand_activation_layer_call_and_return_conditional_losses_107610) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6b_activation_layer_call_and_return_conditional_losses_109424) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4c_expand_activation_layer_call_and_return_conditional_losses_144672) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_efficientnetb0_layer_call_and_return_conditional_losses_139856) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block7a_expand_activation_layer_call_and_return_conditional_losses_109901) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6b_activation_layer_call_and_return_conditional_losses_146754) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6d_expand_activation_layer_call_and_return_conditional_losses_109734) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5c_activation_layer_call_and_return_conditional_losses_109098) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5c_expand_activation_layer_call_and_return_conditional_losses_145861) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6d_expand_activation_layer_call_and_return_conditional_losses_147484) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block2a_activation_layer_call_and_return_conditional_losses_142391) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block3b_expand_activation_layer_call_and_return_conditional_losses_108095) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6c_activation_layer_call_and_return_conditional_losses_109591) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6b_expand_activation_layer_call_and_return_conditional_losses_146660) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4c_activation_layer_call_and_return_conditional_losses_144766) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4c_se_reduce_layer_call_and_return_conditional_losses_108655) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block2a_se_reduce_layer_call_and_return_conditional_losses_107684) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4c_activation_layer_call_and_return_conditional_losses_108612) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4b_expand_activation_layer_call_and_return_conditional_losses_108421) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block2b_activation_layer_call_and_return_conditional_losses_142756) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block3b_activation_layer_call_and_return_conditional_losses_108119) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block1a_se_reduce_layer_call_and_return_conditional_losses_107525) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block3a_activation_layer_call_and_return_conditional_losses_143190) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_stem_activation_layer_call_and_return_conditional_losses_141910) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n"
          ]
        }
      ],
      "source": [
        "# Load model previously saved above\n",
        "loaded_saved_model = tf.keras.models.load_model(save_dir)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CT50keE46i9y"
      },
      "source": [
        "Loading a `SavedModel` also retains all of the underlying layers `dtype_policy` (we want them to be `\"mixed_float16\"`)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fUJXpxmMKnYV",
        "outputId": "8c0e1986-9282-48cd-c98a-e50c130afb46"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "input_2 True float32 <Policy \"float32\">\n",
            "rescaling_1 False float32 <Policy \"mixed_float16\">\n",
            "normalization_1 False float32 <Policy \"mixed_float16\">\n",
            "stem_conv_pad False float32 <Policy \"mixed_float16\">\n",
            "stem_conv False float32 <Policy \"mixed_float16\">\n",
            "stem_bn False float32 <Policy \"mixed_float16\">\n",
            "stem_activation False float32 <Policy \"mixed_float16\">\n",
            "block1a_dwconv False float32 <Policy \"mixed_float16\">\n",
            "block1a_bn False float32 <Policy \"mixed_float16\">\n",
            "block1a_activation False float32 <Policy \"mixed_float16\">\n",
            "block1a_se_squeeze False float32 <Policy \"mixed_float16\">\n",
            "block1a_se_reshape False float32 <Policy \"mixed_float16\">\n",
            "block1a_se_reduce False float32 <Policy \"mixed_float16\">\n",
            "block1a_se_expand False float32 <Policy \"mixed_float16\">\n",
            "block1a_se_excite False float32 <Policy \"mixed_float16\">\n",
            "block1a_project_conv False float32 <Policy \"mixed_float16\">\n",
            "block1a_project_bn False float32 <Policy \"mixed_float16\">\n",
            "block2a_expand_conv False float32 <Policy \"mixed_float16\">\n",
            "block2a_expand_bn False float32 <Policy \"mixed_float16\">\n",
            "block2a_expand_activation False float32 <Policy \"mixed_float16\">\n"
          ]
        }
      ],
      "source": [
        "# Check the layers in the base model and see what dtype policy they're using\n",
        "for layer in loaded_saved_model.layers[1].layers[:20]: # check only the first 20 layers to save output space\n",
        "  print(layer.name, layer.trainable, layer.dtype, layer.dtype_policy)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5Qym9gSm6vL_",
        "outputId": "f1b77e21-a61e-47c8-b628-f532f36d4026"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "790/790 [==============================] - 16s 19ms/step - loss: 1.0924 - accuracy: 0.7053\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "[1.0923796892166138, 0.7053465247154236]"
            ]
          },
          "execution_count": 78,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Check loaded model performance (this should be the same as results_feature_extract_model)\n",
        "results_loaded_saved_model = loaded_saved_model.evaluate(test_data)\n",
        "results_loaded_saved_model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4BUhHSXI-l0v"
      },
      "outputs": [],
      "source": [
        "# The loaded model's results should equal (or at least be very close) to the model's results prior to saving\n",
        "# Note: this will only work if you've instatiated results variables \n",
        "import numpy as np\n",
        "assert np.isclose(results_feature_extract_model, results_loaded_saved_model).all()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mXlDCU8zoUiK"
      },
      "source": [
        "That's what we want! Our loaded model performing as it should.\n",
        "\n",
        "> 🔑 **Note:** We spent a fair bit of time making sure our model saved correctly because training on a lot of data can be time-consuming, so we want to make sure we don't have to continaully train from scratch."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bj21OVxBGlw9"
      },
      "source": [
        "## Preparing our model's layers for fine-tuning\n",
        "\n",
        "Our feature-extraction model is showing some great promise after three epochs. But since we've got so much data, it's probably worthwhile that we see what results we can get with fine-tuning (fine-tuning usually works best when you've got quite a large amount of data).\n",
        "\n",
        "Remember our goal of beating the [DeepFood paper](https://arxiv.org/pdf/1606.05675.pdf)?\n",
        "\n",
        "They were able to achieve 77.4% top-1 accuracy on Food101 over 2-3 days of training.\n",
        "\n",
        "Do you think fine-tuning will get us there?\n",
        "\n",
        "Let's find out.\n",
        "\n",
        "To start, let's load in our saved model.\n",
        "\n",
        "> 🔑 **Note:** It's worth remembering a traditional workflow for fine-tuning is to freeze a pre-trained base model and then train only the output layers for a few iterations so their weights can be updated inline with your custom data (feature extraction). And then unfreeze a number or all of the layers in the base model and continue training until the model stops improving.\n",
        "\n",
        "Like all good cooking shows, I've saved a model I prepared earlier (the feature extraction model from above) to Google Storage.\n",
        "\n",
        "We can download it to make sure we're using the same model going forward."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "veoEmC6V-cZv",
        "outputId": "a52eff70-816d-4854-f092-050f4d905f63"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "--2021-12-15 11:50:25--  https://storage.googleapis.com/ztm_tf_course/food_vision/07_efficientnetb0_feature_extract_model_mixed_precision.zip\n",
            "Resolving storage.googleapis.com (storage.googleapis.com)... 142.250.67.16, 142.250.71.80, 172.217.24.48, ...\n",
            "Connecting to storage.googleapis.com (storage.googleapis.com)|142.250.67.16|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 16976857 (16M) [application/zip]\n",
            "Saving to: '07_efficientnetb0_feature_extract_model_mixed_precision.zip’\n",
            "\n",
            "07_efficientnetb0_f 100%[===================>]  16.19M  12.1MB/s    in 1.3s    \n",
            "\n",
            "2021-12-15 11:50:27 (12.1 MB/s) - '07_efficientnetb0_feature_extract_model_mixed_precision.zip’ saved [16976857/16976857]\n",
            "\n"
          ]
        }
      ],
      "source": [
        "# Download the saved model from Google Storage\n",
        "!wget https://storage.googleapis.com/ztm_tf_course/food_vision/07_efficientnetb0_feature_extract_model_mixed_precision.zip "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "F5uIf_0J-jRt",
        "outputId": "20f79229-9b94-4703-a6b8-a16662b59ff4"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "mkdir: cannot create directory ‘downloaded_gs_model’: File exists\n",
            "Archive:  07_efficientnetb0_feature_extract_model_mixed_precision.zip\n",
            "   creating: downloaded_gs_model/07_efficientnetb0_feature_extract_model_mixed_precision/\n",
            "   creating: downloaded_gs_model/07_efficientnetb0_feature_extract_model_mixed_precision/variables/\n",
            "  inflating: downloaded_gs_model/07_efficientnetb0_feature_extract_model_mixed_precision/variables/variables.data-00000-of-00001  \n",
            "  inflating: downloaded_gs_model/07_efficientnetb0_feature_extract_model_mixed_precision/variables/variables.index  \n",
            "  inflating: downloaded_gs_model/07_efficientnetb0_feature_extract_model_mixed_precision/saved_model.pb  \n",
            "   creating: downloaded_gs_model/07_efficientnetb0_feature_extract_model_mixed_precision/assets/\n"
          ]
        }
      ],
      "source": [
        "# Unzip the SavedModel downloaded from Google Stroage\n",
        "!mkdir downloaded_gs_model # create new dir to store downloaded feature extraction model\n",
        "!unzip 07_efficientnetb0_feature_extract_model_mixed_precision.zip -d downloaded_gs_model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Xbs5ywA6_CWV",
        "outputId": "52ee24ba-7faf-4c8e-d3e0-18b790b52873"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "WARNING:tensorflow:SavedModel saved prior to TF 2.5 detected when loading Keras model. Please ensure that you are saving the model with model.save() or tf.keras.models.save_model(), *NOT* tf.saved_model.save(). To confirm, there should be a file named \"keras_metadata.pb\" in the SavedModel directory.\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "WARNING:tensorflow:SavedModel saved prior to TF 2.5 detected when loading Keras model. Please ensure that you are saving the model with model.save() or tf.keras.models.save_model(), *NOT* tf.saved_model.save(). To confirm, there should be a file named \"keras_metadata.pb\" in the SavedModel directory.\n",
            "WARNING:absl:Importing a function (__inference_block1a_activation_layer_call_and_return_conditional_losses_158253) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block2a_activation_layer_call_and_return_conditional_losses_191539) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6d_expand_activation_layer_call_and_return_conditional_losses_196076) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6c_activation_layer_call_and_return_conditional_losses_195780) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6d_activation_layer_call_and_return_conditional_losses_196153) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_model_layer_call_and_return_conditional_losses_180010) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_stem_activation_layer_call_and_return_conditional_losses_191136) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4c_expand_activation_layer_call_and_return_conditional_losses_160354) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6c_expand_activation_layer_call_and_return_conditional_losses_195703) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block3b_expand_activation_layer_call_and_return_conditional_losses_159392) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block1a_activation_layer_call_and_return_conditional_losses_191213) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4c_se_reduce_layer_call_and_return_conditional_losses_193678) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5a_se_reduce_layer_call_and_return_conditional_losses_194051) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block2b_expand_activation_layer_call_and_return_conditional_losses_158768) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block2b_se_reduce_layer_call_and_return_conditional_losses_191907) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6d_se_reduce_layer_call_and_return_conditional_losses_162720) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5c_activation_layer_call_and_return_conditional_losses_194708) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6d_se_reduce_layer_call_and_return_conditional_losses_196195) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5b_expand_activation_layer_call_and_return_conditional_losses_194258) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_efficientnetb0_layer_call_and_return_conditional_losses_188022) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6b_activation_layer_call_and_return_conditional_losses_161995) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_efficientnetb0_layer_call_and_return_conditional_losses_183149) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block2b_activation_layer_call_and_return_conditional_losses_158824) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4a_activation_layer_call_and_return_conditional_losses_159787) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block2a_expand_activation_layer_call_and_return_conditional_losses_158482) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block2a_se_reduce_layer_call_and_return_conditional_losses_158588) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6b_se_reduce_layer_call_and_return_conditional_losses_195449) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5b_se_reduce_layer_call_and_return_conditional_losses_194377) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6d_expand_activation_layer_call_and_return_conditional_losses_162615) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block3a_activation_layer_call_and_return_conditional_losses_192238) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4b_se_reduce_layer_call_and_return_conditional_losses_160121) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4a_expand_activation_layer_call_and_return_conditional_losses_192860) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block2b_activation_layer_call_and_return_conditional_losses_191865) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4b_expand_activation_layer_call_and_return_conditional_losses_160016) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5c_se_reduce_layer_call_and_return_conditional_losses_194750) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_efficientnetb0_layer_call_and_return_conditional_losses_169029) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_efficientnetb0_layer_call_and_return_conditional_losses_170771) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block3b_activation_layer_call_and_return_conditional_losses_159448) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5c_expand_activation_layer_call_and_return_conditional_losses_194631) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4a_se_reduce_layer_call_and_return_conditional_losses_192979) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "WARNING:absl:Importing a function (__inference_block4b_activation_layer_call_and_return_conditional_losses_193263) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5b_expand_activation_layer_call_and_return_conditional_losses_160977) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block7a_expand_activation_layer_call_and_return_conditional_losses_162953) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4a_se_reduce_layer_call_and_return_conditional_losses_159836) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block2a_se_reduce_layer_call_and_return_conditional_losses_191581) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block2a_activation_layer_call_and_return_conditional_losses_158539) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6c_se_reduce_layer_call_and_return_conditional_losses_162382) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block7a_expand_activation_layer_call_and_return_conditional_losses_196449) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_top_activation_layer_call_and_return_conditional_losses_163238) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6c_expand_activation_layer_call_and_return_conditional_losses_162277) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block3b_expand_activation_layer_call_and_return_conditional_losses_192487) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block1a_se_reduce_layer_call_and_return_conditional_losses_191255) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block7a_activation_layer_call_and_return_conditional_losses_163009) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5b_activation_layer_call_and_return_conditional_losses_194335) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4c_expand_activation_layer_call_and_return_conditional_losses_193559) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4a_expand_activation_layer_call_and_return_conditional_losses_159730) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6a_se_reduce_layer_call_and_return_conditional_losses_161759) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block3a_expand_activation_layer_call_and_return_conditional_losses_192161) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4b_se_reduce_layer_call_and_return_conditional_losses_193305) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5a_activation_layer_call_and_return_conditional_losses_160748) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5c_activation_layer_call_and_return_conditional_losses_161371) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4a_activation_layer_call_and_return_conditional_losses_192937) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block7a_se_reduce_layer_call_and_return_conditional_losses_196568) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block2b_expand_activation_layer_call_and_return_conditional_losses_191788) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block3a_expand_activation_layer_call_and_return_conditional_losses_159106) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block3b_se_reduce_layer_call_and_return_conditional_losses_159497) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5c_expand_activation_layer_call_and_return_conditional_losses_161315) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_efficientnetb0_layer_call_and_return_conditional_losses_184891) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_model_layer_call_and_return_conditional_losses_178256) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6a_activation_layer_call_and_return_conditional_losses_161710) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6a_expand_activation_layer_call_and_return_conditional_losses_161653) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block3a_se_reduce_layer_call_and_return_conditional_losses_159212) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_stem_activation_layer_call_and_return_conditional_losses_158197) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_efficientnetb0_layer_call_and_return_conditional_losses_189764) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block3b_se_reduce_layer_call_and_return_conditional_losses_192606) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6a_activation_layer_call_and_return_conditional_losses_195081) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6c_activation_layer_call_and_return_conditional_losses_162333) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5a_se_reduce_layer_call_and_return_conditional_losses_160797) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5a_activation_layer_call_and_return_conditional_losses_194009) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6c_se_reduce_layer_call_and_return_conditional_losses_195822) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5b_activation_layer_call_and_return_conditional_losses_161033) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "WARNING:absl:Importing a function (__inference_block6b_expand_activation_layer_call_and_return_conditional_losses_195330) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block3a_activation_layer_call_and_return_conditional_losses_159163) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4c_se_reduce_layer_call_and_return_conditional_losses_160459) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6b_activation_layer_call_and_return_conditional_losses_195407) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block7a_se_reduce_layer_call_and_return_conditional_losses_163058) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block3a_se_reduce_layer_call_and_return_conditional_losses_192280) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6d_activation_layer_call_and_return_conditional_losses_162671) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference__wrapped_model_152628) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6b_se_reduce_layer_call_and_return_conditional_losses_162044) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block2b_se_reduce_layer_call_and_return_conditional_losses_158873) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4c_activation_layer_call_and_return_conditional_losses_160410) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6a_expand_activation_layer_call_and_return_conditional_losses_195004) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block3b_activation_layer_call_and_return_conditional_losses_192564) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5b_se_reduce_layer_call_and_return_conditional_losses_161082) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5c_se_reduce_layer_call_and_return_conditional_losses_161420) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4c_activation_layer_call_and_return_conditional_losses_193636) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_top_activation_layer_call_and_return_conditional_losses_196775) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4b_activation_layer_call_and_return_conditional_losses_160072) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6b_expand_activation_layer_call_and_return_conditional_losses_161939) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5a_expand_activation_layer_call_and_return_conditional_losses_193932) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4b_expand_activation_layer_call_and_return_conditional_losses_193186) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block1a_se_reduce_layer_call_and_return_conditional_losses_158302) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6a_se_reduce_layer_call_and_return_conditional_losses_195123) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block2a_expand_activation_layer_call_and_return_conditional_losses_191462) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block7a_activation_layer_call_and_return_conditional_losses_196526) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5a_expand_activation_layer_call_and_return_conditional_losses_160692) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n"
          ]
        }
      ],
      "source": [
        "# Load and evaluate downloaded GS model\n",
        "tf.get_logger().setLevel('INFO') # hide warning logs\n",
        "loaded_gs_model = tf.keras.models.load_model(\"downloaded_gs_model/07_efficientnetb0_feature_extract_model_mixed_precision\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YEZSqPs6pQxy",
        "outputId": "4237c482-54c0-4534-99e6-4531113720b3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Model: \"model\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "input_layer (InputLayer)     [(None, 224, 224, 3)]     0         \n",
            "_________________________________________________________________\n",
            "efficientnetb0 (Functional)  (None, None, None, 1280)  4049571   \n",
            "_________________________________________________________________\n",
            "pooling_layer (GlobalAverage (None, 1280)              0         \n",
            "_________________________________________________________________\n",
            "dense (Dense)                (None, 101)               129381    \n",
            "_________________________________________________________________\n",
            "softmax_float32 (Activation) (None, 101)               0         \n",
            "=================================================================\n",
            "Total params: 4,178,952\n",
            "Trainable params: 129,381\n",
            "Non-trainable params: 4,049,571\n",
            "_________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "# Get a summary of our downloaded model\n",
        "loaded_gs_model.summary()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AH6sS_DNzSe_"
      },
      "source": [
        "And now let's make sure our loaded model is performing as expected."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IlGs5V3Tosx3",
        "outputId": "a325d32a-845b-415b-da8b-ae5edfd8c93e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "790/790 [==============================] - 16s 19ms/step - loss: 1.0881 - accuracy: 0.7065\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "[1.0881080627441406, 0.7064950466156006]"
            ]
          },
          "execution_count": 97,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# How does the loaded model perform?\n",
        "results_loaded_gs_model = loaded_gs_model.evaluate(test_data)\n",
        "results_loaded_gs_model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2ZokTvmxzXv8"
      },
      "source": [
        "Great, our loaded model is performing as expected.\n",
        "\n",
        "When we first created our model, we froze all of the layers in the base model by setting `base_model.trainable=False` but since we've loaded in our model from file, let's check whether or not the layers are trainable or not."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "S-RQ633CapPk",
        "outputId": "07a27634-668f-40bd-e1fc-8ce54b43f70c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "input_layer True float32 <Policy \"float32\">\n",
            "efficientnetb0 True float32 <Policy \"mixed_float16\">\n",
            "pooling_layer True float32 <Policy \"mixed_float16\">\n",
            "dense True float32 <Policy \"mixed_float16\">\n",
            "softmax_float32 True float32 <Policy \"float32\">\n"
          ]
        }
      ],
      "source": [
        "# Are any of the layers in our model frozen?\n",
        "for layer in loaded_gs_model.layers:\n",
        "  layer.trainable = True # set all layers to trainable\n",
        "  print(layer.name, layer.trainable, layer.dtype, layer.dtype_policy) # make sure loaded model is using mixed precision dtype_policy (\"mixed_float16\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tTzYLrzGzs6W"
      },
      "source": [
        "Alright, it seems like each layer in our loaded model is trainable. But what if we got a little deeper and inspected each of the layers in our base model?\n",
        "\n",
        "> 🤔 **Question:** *Which layer in the loaded model is our base model?*\n",
        "\n",
        "Before saving the Functional model to file, we created it with five layers (layers below are 0-indexed):\n",
        "0. The input layer\n",
        "1. The pre-trained base model layer (`tf.keras.applications.EfficientNetB0`)\n",
        "2. The pooling layer\n",
        "3. The fully-connected (dense) layer\n",
        "4. The output softmax activation (with float32 dtype)\n",
        "\n",
        "Therefore to inspect our base model layer, we can access the `layers` attribute of the layer at index 1 in our model."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rob4ClPIa2hp",
        "outputId": "a4670a8a-4572-41b1-edbe-88fb084effad"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "input_1 True float32 <Policy \"float32\">\n",
            "rescaling True float32 <Policy \"mixed_float16\">\n",
            "normalization True float32 <Policy \"float32\">\n",
            "stem_conv_pad True float32 <Policy \"mixed_float16\">\n",
            "stem_conv True float32 <Policy \"mixed_float16\">\n",
            "stem_bn True float32 <Policy \"mixed_float16\">\n",
            "stem_activation True float32 <Policy \"mixed_float16\">\n",
            "block1a_dwconv True float32 <Policy \"mixed_float16\">\n",
            "block1a_bn True float32 <Policy \"mixed_float16\">\n",
            "block1a_activation True float32 <Policy \"mixed_float16\">\n",
            "block1a_se_squeeze True float32 <Policy \"mixed_float16\">\n",
            "block1a_se_reshape True float32 <Policy \"mixed_float16\">\n",
            "block1a_se_reduce True float32 <Policy \"mixed_float16\">\n",
            "block1a_se_expand True float32 <Policy \"mixed_float16\">\n",
            "block1a_se_excite True float32 <Policy \"mixed_float16\">\n",
            "block1a_project_conv True float32 <Policy \"mixed_float16\">\n",
            "block1a_project_bn True float32 <Policy \"mixed_float16\">\n",
            "block2a_expand_conv True float32 <Policy \"mixed_float16\">\n",
            "block2a_expand_bn True float32 <Policy \"mixed_float16\">\n",
            "block2a_expand_activation True float32 <Policy \"mixed_float16\">\n"
          ]
        }
      ],
      "source": [
        "# Check the layers in the base model and see what dtype policy they're using\n",
        "for layer in loaded_gs_model.layers[1].layers[:20]:\n",
        "  print(layer.name, layer.trainable, layer.dtype, layer.dtype_policy)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BRmD0IvT1bR_"
      },
      "source": [
        "Wonderful, it looks like each layer in our base model is trainable (unfrozen) and every layer which should be using the dtype policy `\"mixed_policy16\"` is using it.\n",
        "\n",
        "Since we've got so much data (750 images x 101 training classes = 75750 training images), let's keep all of our base model's layers unfrozen.\n",
        "\n",
        "> 🔑 **Note:** If you've got a small amount of data (less than 100 images per class), you may want to only unfreeze and fine-tune a small number of layers in the base model at a time. Otherwise, you risk overfitting."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m6_6m5jb2Nea"
      },
      "source": [
        "## A couple more callbacks\n",
        "\n",
        "We're about to start fine-tuning a deep learning model with over 200 layers using over 100,000 (75k+ training, 25K+ testing) images, which means our model's training time is probably going to be much longer than before.\n",
        "\n",
        "> 🤔 **Question:** *How long does training take?*\n",
        "\n",
        "It could be a couple of hours or in the case of the [DeepFood paper](https://arxiv.org/pdf/1606.05675.pdf) (the baseline we're trying to beat), their best performing model took 2-3 days of training time.\n",
        "\n",
        "You will really only know how long it'll take once you start training.\n",
        "\n",
        "> 🤔 **Question:** *When do you stop training?*\n",
        "\n",
        "Ideally, when your model stops improving. But again, due to the nature of deep learning, it can be hard to know when exactly a model will stop improving.\n",
        "\n",
        "Luckily, there's a solution: the [`EarlyStopping` callback](https://www.tensorflow.org/api_docs/python/tf/keras/callbacks/EarlyStopping).\n",
        "\n",
        "The `EarlyStopping` callback monitors a specified model performance metric (e.g. `val_loss`) and when it stops improving for a specified number of epochs, automatically stops training. \n",
        "\n",
        "Using the `EarlyStopping` callback combined with the `ModelCheckpoint` callback saving the best performing model automatically, we could keep our model training for an unlimited number of epochs until it stops improving.\n",
        "\n",
        "Let's set both of these up to monitor our model's `val_loss`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GcKFVlXVwjJy"
      },
      "outputs": [],
      "source": [
        "# Setup EarlyStopping callback to stop training if model's val_loss doesn't improve for 3 epochs\n",
        "early_stopping = tf.keras.callbacks.EarlyStopping(monitor=\"val_loss\", # watch the val loss metric\n",
        "                                                  patience=3) # if val loss decreases for 3 epochs in a row, stop training\n",
        "\n",
        "# Create ModelCheckpoint callback to save best model during fine-tuning\n",
        "checkpoint_path = \"fine_tune_checkpoints/\"\n",
        "model_checkpoint = tf.keras.callbacks.ModelCheckpoint(checkpoint_path,\n",
        "                                                      save_best_only=True,\n",
        "                                                      monitor=\"val_loss\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "14cdwkIi4WnG"
      },
      "source": [
        "Woohoo! Fine-tuning callbacks ready.\n",
        "\n",
        "If you're planning on training large models, the `ModelCheckpoint` and `EarlyStopping` are two callbacks you'll want to become very familiar with. \n",
        "\n",
        "We're almost ready to start fine-tuning our model but there's one more callback we're going to implement: [`ReduceLROnPlateau`](https://www.tensorflow.org/api_docs/python/tf/keras/callbacks/ReduceLROnPlateau).\n",
        "\n",
        "Remember how the learning rate is the most important model hyperparameter you can tune? (if not, treat this as a reminder).\n",
        "\n",
        "Well, the `ReduceLROnPlateau` callback helps to tune the learning rate for you.\n",
        "\n",
        "Like the `ModelCheckpoint` and `EarlyStopping` callbacks, the `ReduceLROnPlateau` callback montiors a specified metric and when that metric stops improving, it reduces the learning rate by a specified factor (e.g. divides the learning rate by 10).\n",
        "\n",
        "> 🤔 **Question:** *Why lower the learning rate?*\n",
        "\n",
        "Imagine having a coin at the back of the couch and you're trying to grab with your fingers. \n",
        "\n",
        "Now think of the learning rate as the size of the movements your hand makes towards the coin. \n",
        "\n",
        "The closer you get, the smaller you want your hand movements to be, otherwise the coin will be lost.\n",
        "\n",
        "Our model's ideal performance is the equivalent of grabbing the coin. So as training goes on and our model gets closer and closer to it's ideal performance (also called **convergence**), we want the amount it learns to be less and less.\n",
        "\n",
        "To do this we'll create an instance of the `ReduceLROnPlateau` callback to monitor the validation loss just like the `EarlyStopping` callback. \n",
        "\n",
        "Once the validation loss stops improving for two or more epochs, we'll reduce the learning rate by a factor of 5 (e.g. `0.001` to `0.0002`).\n",
        "\n",
        "And to make sure the learning rate doesn't get too low (and potentially result in our model learning nothing), we'll set the minimum learning rate to `1e-7`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "I794Kaiq4Ekk"
      },
      "outputs": [],
      "source": [
        "# Creating learning rate reduction callback\n",
        "reduce_lr = tf.keras.callbacks.ReduceLROnPlateau(monitor=\"val_loss\",  \n",
        "                                                 factor=0.2, # multiply the learning rate by 0.2 (reduce by 5x)\n",
        "                                                 patience=2,\n",
        "                                                 verbose=1, # print out when learning rate goes down \n",
        "                                                 min_lr=1e-7)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3v0BHURF6Lnz"
      },
      "source": [
        "Learning rate reduction ready to go!\n",
        "\n",
        "Now before we start training, we've got to recompile our model.\n",
        "\n",
        "We'll use sparse categorical crossentropy as the loss and since we're fine-tuning, we'll use a 10x lower learning rate than the Adam optimizers default (`1e-4` instead of `1e-3`). "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GlpO9LflcVHW"
      },
      "outputs": [],
      "source": [
        "# Compile the model\n",
        "loaded_gs_model.compile(loss=\"sparse_categorical_crossentropy\", # sparse_categorical_crossentropy for labels that are *not* one-hot\n",
        "                        optimizer=tf.keras.optimizers.Adam(0.0001), # 10x lower learning rate than the default\n",
        "                        metrics=[\"accuracy\"])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yo1bio8SYxvc"
      },
      "source": [
        "Okay, model compiled.\n",
        "\n",
        "Now let's fit it on all of the data. \n",
        "\n",
        "We'll set it up to run for up to 100 epochs. \n",
        "\n",
        "Since we're going to be using the `EarlyStopping` callback, it might stop before reaching 100 epochs.\n",
        "\n",
        "> 🔑 **Note:** Running the cell below will set the model up to fine-tune all of the pre-trained weights in the base model on all of the Food101 data. Doing so with **unoptimized** data pipelines and **without** mixed precision training will take a fairly long time per epoch depending on what type of GPU you're using (about 15-20 minutes on Colab GPUs). But don't worry, **the code we've written above will ensure it runs much faster** (more like 4-5 minutes per epoch)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LkUtOdVkbMPC",
        "outputId": "c316506e-0858-4b2e-81d7-c5921ef67368"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Saving TensorBoard log files to: training_logs/efficientb0_101_classes_all_data_fine_tuning/20211215-115307\n",
            "Epoch 1/100\n",
            "2368/2368 [==============================] - 141s 57ms/step - loss: 0.9242 - accuracy: 0.7500 - val_loss: 0.8070 - val_accuracy: 0.7725\n",
            "INFO:tensorflow:Assets written to: fine_tune_checkpoints/assets\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Assets written to: fine_tune_checkpoints/assets\n",
            "/home/daniel/code/tensorflow/env/lib/python3.9/site-packages/keras/utils/generic_utils.py:494: CustomMaskWarning: Custom mask layers require a config and must override get_config. When loading, the custom mask layer must be passed to the custom_objects argument.\n",
            "  warnings.warn('Custom mask layers require a config and must override '\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch 2/100\n",
            "2368/2368 [==============================] - 134s 57ms/step - loss: 0.5803 - accuracy: 0.8383 - val_loss: 0.7772 - val_accuracy: 0.7865\n",
            "INFO:tensorflow:Assets written to: fine_tune_checkpoints/assets\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Assets written to: fine_tune_checkpoints/assets\n",
            "/home/daniel/code/tensorflow/env/lib/python3.9/site-packages/keras/utils/generic_utils.py:494: CustomMaskWarning: Custom mask layers require a config and must override get_config. When loading, the custom mask layer must be passed to the custom_objects argument.\n",
            "  warnings.warn('Custom mask layers require a config and must override '\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch 3/100\n",
            "2368/2368 [==============================] - 135s 57ms/step - loss: 0.3320 - accuracy: 0.9069 - val_loss: 0.8457 - val_accuracy: 0.7770\n",
            "Epoch 4/100\n",
            "2368/2368 [==============================] - 134s 56ms/step - loss: 0.1779 - accuracy: 0.9472 - val_loss: 0.9881 - val_accuracy: 0.7786\n",
            "\n",
            "Epoch 00004: ReduceLROnPlateau reducing learning rate to 1.9999999494757503e-05.\n",
            "Epoch 5/100\n",
            "2368/2368 [==============================] - 134s 57ms/step - loss: 0.0360 - accuracy: 0.9919 - val_loss: 1.0248 - val_accuracy: 0.8040\n"
          ]
        }
      ],
      "source": [
        "# Start to fine-tune (all layers)\n",
        "history_101_food_classes_all_data_fine_tune = loaded_gs_model.fit(train_data,\n",
        "                                                        epochs=100, # fine-tune for a maximum of 100 epochs\n",
        "                                                        steps_per_epoch=len(train_data),\n",
        "                                                        validation_data=test_data,\n",
        "                                                        validation_steps=int(0.15 * len(test_data)), # validation during training on 15% of test data\n",
        "                                                        callbacks=[create_tensorboard_callback(\"training_logs\", \"efficientb0_101_classes_all_data_fine_tuning\"), # track the model training logs\n",
        "                                                                   model_checkpoint, # save only the best model during training\n",
        "                                                                   early_stopping, # stop model after X epochs of no improvements\n",
        "                                                                   reduce_lr]) # reduce the learning rate after X epochs of no improvements"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nC2HLXePh9Af"
      },
      "source": [
        "> 🔑 **Note:** If you didn't use mixed precision or use techniques such as [`prefetch()`](https://www.tensorflow.org/api_docs/python/tf/data/Dataset#prefetch) in the *Batch & prepare datasets* section, your model fine-tuning probably takes up to 2.5-3x longer per epoch (see the output below for an example).\n",
        "\n",
        "| | Prefetch and mixed precision | No prefetch and no mixed precision |\n",
        "|-----|-----|-----|\n",
        "| Time per epoch | ~280-300s | ~1127-1397s |\n",
        "\n",
        "*Results from fine-tuning Food Vision Big™ on Food101 dataset using an EfficienetNetB0 backbone using a Google Colab Tesla T4 GPU.*\n",
        "\n",
        "```\n",
        "Saving TensorBoard log files to: training_logs/efficientB0_101_classes_all_data_fine_tuning/20200928-013008\n",
        "Epoch 1/100\n",
        "2368/2368 [==============================] - 1397s 590ms/step - loss: 1.2068 - accuracy: 0.6820 - val_loss: 1.1623 - val_accuracy: 0.6894\n",
        "Epoch 2/100\n",
        "2368/2368 [==============================] - 1193s 504ms/step - loss: 0.9459 - accuracy: 0.7444 - val_loss: 1.1549 - val_accuracy: 0.6872\n",
        "Epoch 3/100\n",
        "2368/2368 [==============================] - 1143s 482ms/step - loss: 0.7848 - accuracy: 0.7838 - val_loss: 1.0402 - val_accuracy: 0.7142\n",
        "Epoch 4/100\n",
        "2368/2368 [==============================] - 1127s 476ms/step - loss: 0.6599 - accuracy: 0.8149 - val_loss: 0.9599 - val_accuracy: 0.7373\n",
        "```\n",
        "*Example fine-tuning time for non-prefetched data as well as non-mixed precision training (~2.5-3x longer per epoch).*\n",
        "\n",
        "Let's make sure we save our model before we start evaluating it."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "mwjxnUsgI558"
      },
      "outputs": [],
      "source": [
        "# # Save model to Google Drive (optional)\n",
        "# loaded_gs_model.save(\"/content/drive/MyDrive/tensorflow_course/food_vision/07_efficientnetb0_fine_tuned_101_classes_mixed_precision/\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "K1As0OhYHFX-",
        "outputId": "46408a84-943b-46f6-ae8c-2e4141ea27d2"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Assets written to: 07_efficientnetb0_fine_tuned_101_classes_mixed_precision/assets\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Assets written to: 07_efficientnetb0_fine_tuned_101_classes_mixed_precision/assets\n",
            "/home/daniel/code/tensorflow/env/lib/python3.9/site-packages/keras/utils/generic_utils.py:494: CustomMaskWarning: Custom mask layers require a config and must override get_config. When loading, the custom mask layer must be passed to the custom_objects argument.\n",
            "  warnings.warn('Custom mask layers require a config and must override '\n"
          ]
        }
      ],
      "source": [
        "# Save model locally (note: if you're using Google Colab and you save your model locally, it will be deleted when your Google Colab session ends)\n",
        "loaded_gs_model.save(\"07_efficientnetb0_fine_tuned_101_classes_mixed_precision\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CcpNGcSAZ2UC"
      },
      "source": [
        "Looks like our model has gained a few performance points from fine-tuning, let's evaluate on the whole test dataset and see if managed to beat the [DeepFood paper's](https://arxiv.org/abs/1606.05675) result of 77.4% accuracy."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2CR6q8MYM37K",
        "outputId": "d10180ce-1df4-4b77-a296-8f61ac7dd080"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "790/790 [==============================] - 15s 19ms/step - loss: 1.0241 - accuracy: 0.7985\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "[1.024148941040039, 0.7984554171562195]"
            ]
          },
          "execution_count": 109,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Evaluate mixed precision trained loaded model\n",
        "results_loaded_gs_model_fine_tuned = loaded_gs_model.evaluate(test_data) \n",
        "results_loaded_gs_model_fine_tuned"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rR-S5bKP0IxA"
      },
      "source": [
        "Woohoo!!!! It looks like our model beat the results mentioned in the DeepFood paper for Food101 (DeepFood's 77.4% top-1 accuracy versus our ~79% top-1 accuracy)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a0H1rSG9RBBV"
      },
      "source": [
        "## Download fine-tuned model from Google Storage\n",
        "\n",
        "As mentioned before, training models can take a significant amount of time.\n",
        "\n",
        "And again, like any good cooking show, here's something we prepared earlier...\n",
        "\n",
        "It's a fine-tuned model exactly like the one we trained above but it's saved to Google Storage so it can be accessed, imported and evaluated."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qRuBSsPxI8Yg",
        "outputId": "86a5343d-d0eb-4fb4-9ed8-7acae14f7a9e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "--2021-12-15 12:07:25--  https://storage.googleapis.com/ztm_tf_course/food_vision/07_efficientnetb0_fine_tuned_101_classes_mixed_precision.zip\n",
            "Resolving storage.googleapis.com (storage.googleapis.com)... 142.250.204.16, 172.217.167.80, 142.250.66.240, ...\n",
            "Connecting to storage.googleapis.com (storage.googleapis.com)|142.250.204.16|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 46790356 (45M) [application/zip]\n",
            "Saving to: '07_efficientnetb0_fine_tuned_101_classes_mixed_precision.zip’\n",
            "\n",
            "07_efficientnetb0_f 100%[===================>]  44.62M  13.0MB/s    in 3.5s    \n",
            "\n",
            "2021-12-15 12:07:29 (12.7 MB/s) - '07_efficientnetb0_fine_tuned_101_classes_mixed_precision.zip’ saved [46790356/46790356]\n",
            "\n"
          ]
        }
      ],
      "source": [
        "# Download and evaluate fine-tuned model from Google Storage\n",
        "!wget https://storage.googleapis.com/ztm_tf_course/food_vision/07_efficientnetb0_fine_tuned_101_classes_mixed_precision.zip"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5_KhgOeA_hCG"
      },
      "source": [
        "The downloaded model comes in zip format (`.zip`) so we'll unzip it into the Google Colab instance."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PNh0cPL7JBpv",
        "outputId": "c5ea36e4-1203-46eb-dd5a-285a8764d1e8"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Archive:  07_efficientnetb0_fine_tuned_101_classes_mixed_precision.zip\n",
            "   creating: downloaded_fine_tuned_gs_model/07_efficientnetb0_fine_tuned_101_classes_mixed_precision/\n",
            "   creating: downloaded_fine_tuned_gs_model/07_efficientnetb0_fine_tuned_101_classes_mixed_precision/variables/\n",
            "  inflating: downloaded_fine_tuned_gs_model/07_efficientnetb0_fine_tuned_101_classes_mixed_precision/variables/variables.data-00000-of-00001  \n",
            "  inflating: downloaded_fine_tuned_gs_model/07_efficientnetb0_fine_tuned_101_classes_mixed_precision/variables/variables.index  \n",
            "  inflating: downloaded_fine_tuned_gs_model/07_efficientnetb0_fine_tuned_101_classes_mixed_precision/saved_model.pb  \n",
            "   creating: downloaded_fine_tuned_gs_model/07_efficientnetb0_fine_tuned_101_classes_mixed_precision/assets/\n"
          ]
        }
      ],
      "source": [
        "# Unzip fine-tuned model\n",
        "!mkdir downloaded_fine_tuned_gs_model # create separate directory for fine-tuned model downloaded from Google Storage\n",
        "!unzip 07_efficientnetb0_fine_tuned_101_classes_mixed_precision -d downloaded_fine_tuned_gs_model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "blFdr0QJ_oQY"
      },
      "source": [
        "Now we can load it using the [`tf.keras.models.load_model()`](https://www.tensorflow.org/tutorials/keras/save_and_load) method and get a summary (it should be the exact same as the model we created above)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yBWWTb-QKuW1",
        "outputId": "0e15964d-adf2-49b8-abfe-1396c1000757"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "WARNING:tensorflow:SavedModel saved prior to TF 2.5 detected when loading Keras model. Please ensure that you are saving the model with model.save() or tf.keras.models.save_model(), *NOT* tf.saved_model.save(). To confirm, there should be a file named \"keras_metadata.pb\" in the SavedModel directory.\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "WARNING:tensorflow:SavedModel saved prior to TF 2.5 detected when loading Keras model. Please ensure that you are saving the model with model.save() or tf.keras.models.save_model(), *NOT* tf.saved_model.save(). To confirm, there should be a file named \"keras_metadata.pb\" in the SavedModel directory.\n",
            "WARNING:absl:Importing a function (__inference_block3b_expand_activation_layer_call_and_return_conditional_losses_443625) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5c_activation_layer_call_and_return_conditional_losses_412189) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block1a_se_reduce_layer_call_and_return_conditional_losses_409120) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6c_expand_activation_layer_call_and_return_conditional_losses_446895) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block1a_activation_layer_call_and_return_conditional_losses_442329) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_efficientnetb0_layer_call_and_return_conditional_losses_421687) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5b_activation_layer_call_and_return_conditional_losses_411851) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6b_se_reduce_layer_call_and_return_conditional_losses_446637) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6d_activation_layer_call_and_return_conditional_losses_447353) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5b_expand_activation_layer_call_and_return_conditional_losses_445426) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block1a_se_reduce_layer_call_and_return_conditional_losses_442371) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_efficientnetb0_layer_call_and_return_conditional_losses_419945) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block2a_se_reduce_layer_call_and_return_conditional_losses_442703) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5a_activation_layer_call_and_return_conditional_losses_445173) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_efficientnetb0_layer_call_and_return_conditional_losses_440876) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block7a_se_reduce_layer_call_and_return_conditional_losses_447774) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block7a_expand_activation_layer_call_and_return_conditional_losses_413771) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6c_se_reduce_layer_call_and_return_conditional_losses_413200) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4b_expand_activation_layer_call_and_return_conditional_losses_410834) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4c_se_reduce_layer_call_and_return_conditional_losses_411277) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block3b_expand_activation_layer_call_and_return_conditional_losses_410210) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5a_se_reduce_layer_call_and_return_conditional_losses_445215) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6c_activation_layer_call_and_return_conditional_losses_446974) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block3a_se_reduce_layer_call_and_return_conditional_losses_443414) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6d_expand_activation_layer_call_and_return_conditional_losses_413433) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_stem_activation_layer_call_and_return_conditional_losses_442250) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4b_activation_layer_call_and_return_conditional_losses_410890) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block7a_se_reduce_layer_call_and_return_conditional_losses_413876) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_top_activation_layer_call_and_return_conditional_losses_414056) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block3a_activation_layer_call_and_return_conditional_losses_409981) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_efficientnetb0_layer_call_and_return_conditional_losses_435905) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block3b_activation_layer_call_and_return_conditional_losses_410266) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block3a_expand_activation_layer_call_and_return_conditional_losses_409924) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4b_se_reduce_layer_call_and_return_conditional_losses_410939) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4c_activation_layer_call_and_return_conditional_losses_444794) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6b_se_reduce_layer_call_and_return_conditional_losses_412862) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5c_se_reduce_layer_call_and_return_conditional_losses_445926) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference__wrapped_model_403250) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5b_se_reduce_layer_call_and_return_conditional_losses_445547) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6d_expand_activation_layer_call_and_return_conditional_losses_447274) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "WARNING:absl:Importing a function (__inference_block6a_expand_activation_layer_call_and_return_conditional_losses_412471) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5c_se_reduce_layer_call_and_return_conditional_losses_412238) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5a_expand_activation_layer_call_and_return_conditional_losses_411510) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5c_activation_layer_call_and_return_conditional_losses_445884) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5a_se_reduce_layer_call_and_return_conditional_losses_411615) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block3b_se_reduce_layer_call_and_return_conditional_losses_410315) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4b_expand_activation_layer_call_and_return_conditional_losses_444336) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_model_layer_call_and_return_conditional_losses_429172) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block2a_se_reduce_layer_call_and_return_conditional_losses_409406) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6a_se_reduce_layer_call_and_return_conditional_losses_412577) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_efficientnetb0_layer_call_and_return_conditional_losses_434163) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_top_activation_layer_call_and_return_conditional_losses_447985) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6b_expand_activation_layer_call_and_return_conditional_losses_412757) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6a_expand_activation_layer_call_and_return_conditional_losses_446184) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5a_activation_layer_call_and_return_conditional_losses_411566) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4b_activation_layer_call_and_return_conditional_losses_444415) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block2b_expand_activation_layer_call_and_return_conditional_losses_442914) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block2a_expand_activation_layer_call_and_return_conditional_losses_409300) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block3a_activation_layer_call_and_return_conditional_losses_443372) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6d_se_reduce_layer_call_and_return_conditional_losses_447395) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5a_expand_activation_layer_call_and_return_conditional_losses_445094) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6d_activation_layer_call_and_return_conditional_losses_413489) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4a_expand_activation_layer_call_and_return_conditional_losses_410548) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6b_activation_layer_call_and_return_conditional_losses_412813) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4a_activation_layer_call_and_return_conditional_losses_444083) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4c_se_reduce_layer_call_and_return_conditional_losses_444836) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block7a_activation_layer_call_and_return_conditional_losses_447732) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5b_expand_activation_layer_call_and_return_conditional_losses_411795) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6b_expand_activation_layer_call_and_return_conditional_losses_446516) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4a_se_reduce_layer_call_and_return_conditional_losses_444125) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4c_expand_activation_layer_call_and_return_conditional_losses_444715) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block2b_se_reduce_layer_call_and_return_conditional_losses_443035) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block2a_activation_layer_call_and_return_conditional_losses_442661) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_model_layer_call_and_return_conditional_losses_430926) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4a_expand_activation_layer_call_and_return_conditional_losses_444004) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6c_expand_activation_layer_call_and_return_conditional_losses_413095) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5b_se_reduce_layer_call_and_return_conditional_losses_411900) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6c_se_reduce_layer_call_and_return_conditional_losses_447016) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6a_activation_layer_call_and_return_conditional_losses_412528) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block3b_se_reduce_layer_call_and_return_conditional_losses_443746) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block2b_activation_layer_call_and_return_conditional_losses_442993) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "WARNING:absl:Importing a function (__inference_block3a_expand_activation_layer_call_and_return_conditional_losses_443293) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6a_se_reduce_layer_call_and_return_conditional_losses_446305) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6b_activation_layer_call_and_return_conditional_losses_446595) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block7a_activation_layer_call_and_return_conditional_losses_413827) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block3b_activation_layer_call_and_return_conditional_losses_443704) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block2a_activation_layer_call_and_return_conditional_losses_409357) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6c_activation_layer_call_and_return_conditional_losses_413151) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block3a_se_reduce_layer_call_and_return_conditional_losses_410030) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4b_se_reduce_layer_call_and_return_conditional_losses_444457) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block1a_activation_layer_call_and_return_conditional_losses_409071) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5c_expand_activation_layer_call_and_return_conditional_losses_445805) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4c_activation_layer_call_and_return_conditional_losses_411228) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block2a_expand_activation_layer_call_and_return_conditional_losses_442582) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4a_se_reduce_layer_call_and_return_conditional_losses_410654) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block7a_expand_activation_layer_call_and_return_conditional_losses_447653) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6a_activation_layer_call_and_return_conditional_losses_446263) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block6d_se_reduce_layer_call_and_return_conditional_losses_413538) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5c_expand_activation_layer_call_and_return_conditional_losses_412133) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block2b_se_reduce_layer_call_and_return_conditional_losses_409691) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block2b_expand_activation_layer_call_and_return_conditional_losses_409586) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block5b_activation_layer_call_and_return_conditional_losses_445505) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4a_activation_layer_call_and_return_conditional_losses_410605) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_stem_activation_layer_call_and_return_conditional_losses_409015) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block2b_activation_layer_call_and_return_conditional_losses_409642) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_block4c_expand_activation_layer_call_and_return_conditional_losses_411172) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
            "WARNING:absl:Importing a function (__inference_efficientnetb0_layer_call_and_return_conditional_losses_439134) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n"
          ]
        }
      ],
      "source": [
        "# Load in fine-tuned model from Google Storage and evaluate\n",
        "loaded_fine_tuned_gs_model = tf.keras.models.load_model(\"downloaded_fine_tuned_gs_model/07_efficientnetb0_fine_tuned_101_classes_mixed_precision\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sysv2pDmJoe8",
        "outputId": "228088b7-0f87-4652-f894-3ef6accdb32a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Model: \"model\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "input_layer (InputLayer)     [(None, 224, 224, 3)]     0         \n",
            "_________________________________________________________________\n",
            "efficientnetb0 (Functional)  (None, None, None, 1280)  4049571   \n",
            "_________________________________________________________________\n",
            "pooling_layer (GlobalAverage (None, 1280)              0         \n",
            "_________________________________________________________________\n",
            "dense (Dense)                (None, 101)               129381    \n",
            "_________________________________________________________________\n",
            "softmax_float32 (Activation) (None, 101)               0         \n",
            "=================================================================\n",
            "Total params: 4,178,952\n",
            "Trainable params: 4,136,929\n",
            "Non-trainable params: 42,023\n",
            "_________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "# Get a model summary (same model architecture as above)\n",
        "loaded_fine_tuned_gs_model.summary()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SxP8rbAj_4lY"
      },
      "source": [
        "Finally, we can evaluate our model on the test data (this requires the `test_data` variable to be loaded."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ms0R3LZ9Jrr5",
        "outputId": "957b540d-e05e-4f27-c379-39f7bce49da9"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "790/790 [==============================] - 16s 19ms/step - loss: 0.9072 - accuracy: 0.8016\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "[0.9072359204292297, 0.8015841841697693]"
            ]
          },
          "execution_count": 114,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Note: Even if you're loading in the model from Google Storage, you will still need to load the test_data variable for this cell to work\n",
        "results_downloaded_fine_tuned_gs_model = loaded_fine_tuned_gs_model.evaluate(test_data)\n",
        "results_downloaded_fine_tuned_gs_model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yMAXmidMc_hA"
      },
      "source": [
        "Excellent! Our saved model is performing as expected (better results than the DeepFood paper!).\n",
        "\n",
        "Congrautlations! You should be excited! You just trained a computer vision model with competitive performance to a research paper and in far less time (our model took ~20 minutes to train versus DeepFood's quoted 2-3 days).\n",
        "\n",
        "In other words, you brought Food Vision life!\n",
        "\n",
        "If you really wanted to step things up, you could try using the [`EfficientNetB4`](https://www.tensorflow.org/api_docs/python/tf/keras/applications/EfficientNetB4) model (a larger version of `EfficientNetB0`). At at the time of writing, the EfficientNet family has the [state of the art classification results](https://paperswithcode.com/sota/fine-grained-image-classification-on-food-101) on the Food101 dataset.\n",
        "\n",
        "> 📖 **Resource:** To see which models are currently performing the best on a given dataset or problem type as well as the latest trending machine learning research, be sure to check out [paperswithcode.com](http://paperswithcode.com/) and [sotabench.com](https://sotabench.com/)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pFjooc5Gy0I2"
      },
      "source": [
        "## View training results on TensorBoard\n",
        "\n",
        "Since we tracked our model's fine-tuning training logs using the `TensorBoard` callback, let's upload them and inspect them on TensorBoard.dev."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DW9x3o1kWlO3"
      },
      "outputs": [],
      "source": [
        "# !tensorboard dev upload --logdir ./training_logs \\\n",
        "#   --name \"Fine-tuning EfficientNetB0 on all Food101 Data\" \\\n",
        "#   --description \"Training results for fine-tuning EfficientNetB0 on Food101 Data with learning rate 0.0001\" \\"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zvn5JfmuVSCf"
      },
      "source": [
        "Viewing at our [model's training curves on TensorBoard.dev](https://tensorboard.dev/experiment/2KINdYxgSgW2bUg7dIvevw/), it looks like our fine-tuning model gains boost in performance but starts to overfit as training goes on.\n",
        "\n",
        "See the training curves on TensorBoard.dev here: https://tensorboard.dev/experiment/2KINdYxgSgW2bUg7dIvevw/\n",
        "\n",
        "To fix this, in future experiments, we might try things like:\n",
        "* A different iteration of `EfficientNet` (e.g. `EfficientNetB4` instead of `EfficientNetB0`).\n",
        "* Unfreezing less layers of the base model and training them rather than unfreezing the whole base model in one go.\n",
        "\n",
        "You can also view and delete past experiments on TensorBoard.dev with the following commands."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fUpOtu_tNWcJ"
      },
      "outputs": [],
      "source": [
        "# View past TensorBoard experiments\n",
        "# !tensorboard dev list"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "u-Rl-L0hNbEv"
      },
      "outputs": [],
      "source": [
        "# Delete past TensorBoard experiments\n",
        "# !tensorboard dev delete --experiment_id YOUR_EXPERIMENT_ID\n",
        "\n",
        "# Example\n",
        "# !tensorboard dev delete --experiment_id OAE6KXizQZKQxDiqI3cnUQ"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nDDrrqy5egTn"
      },
      "source": [
        "## Exercises \n",
        "\n",
        "1. Use the same evaluation techniques on the large-scale Food Vision model as you did in the previous notebook ([Transfer Learning Part 3: Scaling up](https://github.com/mrdbourke/tensorflow-deep-learning/blob/main/06_transfer_learning_in_tensorflow_part_3_scaling_up.ipynb)). More specifically, it would be good to see:\n",
        "  * A confusion matrix between all of the model's predictions and true labels.\n",
        "  * A graph showing the f1-scores of each class.\n",
        "  * A visualization of the model making predictions on various images and comparing the predictions to the ground truth.\n",
        "    * For example, plot a sample image from the test dataset and have the title of the plot show the prediction, the prediction probability and the ground truth label. \n",
        "2. Take 3 of your own photos of food and use the Food Vision model to make predictions on them. How does it go? Share your images/predictions with the other students.\n",
        "3. Retrain the model (feature extraction and fine-tuning) we trained in this notebook, except this time use [`EfficientNetB4`](https://www.tensorflow.org/api_docs/python/tf/keras/applications/EfficientNetB4) as the base model instead of `EfficientNetB0`. Do you notice an improvement in performance? Does it take longer to train? Are there any tradeoffs to consider?\n",
        "4. Name one important benefit of mixed precision training, how does this benefit take place?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z8ncI458ZkpA"
      },
      "source": [
        "## Extra-curriculum\n",
        "\n",
        "* Read up on learning rate scheduling and the [learning rate scheduler callback](https://www.tensorflow.org/api_docs/python/tf/keras/callbacks/LearningRateScheduler). What is it? And how might it be helpful to this project?\n",
        "* Read up on TensorFlow data loaders ([improving TensorFlow data loading performance](https://www.tensorflow.org/guide/data_performance)). Is there anything we've missed? What methods you keep in mind whenever loading data in TensorFlow? Hint: check the summary at the bottom of the page for a gret round up of ideas.\n",
        "* Read up on the documentation for [TensorFlow mixed precision training](https://www.tensorflow.org/guide/mixed_precision). What are the important things to keep in mind when using mixed precision training?"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "collapsed_sections": [],
      "name": "07_food_vision_milestone_project_1.ipynb",
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "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.9.7"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}