07_food_vision_milestone_project_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "view-in-github"
   },
   "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."
   ]
  },
  {
   "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: Tesla T4 (UUID: GPU-60ebc9b4-1cbc-ed62-9d0f-6e8ba24db56b)\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.4.1\n"
     ]
    }
   ],
   "source": [
    "# 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": [
      "--2021-03-22 03:22:37--  https://raw.githubusercontent.com/mrdbourke/tensorflow-deep-learning/main/extras/helper_functions.py\n",
      "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.111.133, 185.199.108.133, 185.199.110.133, ...\n",
      "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.111.133|:443... connected.\n",
      "HTTP request sent, awaiting response... 200 OK\n",
      "Length: 9304 (9.1K) [text/plain]\n",
      "Saving to: ‘helper_functions.py’\n",
      "\n",
      "\r",
      "helper_functions.py   0%[                    ]       0  --.-KB/s               \r",
      "helper_functions.py 100%[===================>]   9.09K  --.-KB/s    in 0s      \n",
      "\n",
      "2021-03-22 03:22:37 (111 MB/s) - ‘helper_functions.py’ saved [9304/9304]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Get helper functions file\n",
    "!wget https://raw.githubusercontent.com/mrdbourke/tensorflow-deep-learning/main/extras/helper_functions.py"
   ]
  },
  {
   "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": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 347,
     "referenced_widgets": [
      "c464cf7f692747dd8a9e5c224b72e683",
      "e19cbd5c9eca4db6b023d501ae96447b",
      "465a84232f9344b7852bc0315aaf6147",
      "a15efd3f9c514ce1947bd75330ddc60f",
      "1630703c5da345df876cd4a38ac062d0",
      "48c761f4ebf541169f0b674e835081bd",
      "fc53cb8f72eb45d9987f22fa391e64ff",
      "5b48d0e1bd664416b3a8da6daedf29eb",
      "116932efaceb4e6889b9e9a7585a851f",
      "449c05474a464357a0a2aa0671849a84",
      "33aad3ba3e0648d18b64c2a0e013ea7e",
      "5ffe42dfcc8945058a1211325bb12276",
      "7aff75e4e7094ab2b7c4bff04b8b8e60",
      "02364bec4a004ed4a4b0970e1b572410",
      "e6780bf5a7a84f4886a2ad32df1db1e0",
      "0f5af87526534cb9a021e362e61a089b",
      "16688ead8185417fbe6acf39649c222a",
      "5bdf272dff1049afac690fe78c530277",
      "7cd57199faa1403b806f64a00c220e3f",
      "8f1b23e71fd14fcc97a32f0abdc96419",
      "daf7463ed2b14751bb7532a91429bf67",
      "97e5f68c3ae040b6a22709f4fabc09b8",
      "02df2b60820b46cbb03c61e9d3a171be",
      "7caebdb45e1f41ae88eddfabada5ff67",
      "da96cbabe8ff449388e052dd55213653",
      "56eb15d4d1dd450aaa727875c04b1957",
      "41908c7012174ecabfe801a2f5e3dee5",
      "103a4aded56c4acd81aac7fe81851956",
      "fa047be5ac684f76b2d245fbb99b2920",
      "6f9a55e4f5fd4f459eac237f02c37829",
      "309a4eb5407d4a2091efcfabd211b967",
      "e6dc230531bc449cb651470bfb3ccc85",
      "308c42badc014391aaee6b1beb47dbf6",
      "fce62bc99e2b47b3b15005ae97d287bd",
      "fe172d6537a642be985520c0e66d7801",
      "25d1eb6b6bcb48bbb79749475775b295",
      "e8ef9677adbf4f368a258d64732d152a",
      "acc1ea5a5531425c885afe2bdbce4273",
      "07922060a53a4fc0812a5bbc977ca268",
      "3b4eb46bc9fc482d94e0d2b20b70eb66",
      "0624ceb3768e4c62a220b188c7ed1141",
      "20657b32df4848e6a1f3d3fc88236d57",
      "113e3bf10abe4f5d943c10da89fd9adc",
      "7c0827a68eb141e5a1939597a171c593",
      "b2c9c7704b8e407d97f2471dddec0f06",
      "3485e9277b49412fa22ff0065d3832b4",
      "4ffa9402790542c388443678b0fb9982",
      "5fba5aafc52c43aaa52619421330dd57",
      "8a925d410ebb413a808ce40f12e7d91e",
      "9a9338dbc9c04a078575071d48b25e51",
      "7b2c7af82c5e4c8b812c3d4514976101",
      "473159e3bfdd463590775781ed676f55",
      "568e801778124de386e7badcf1e58456",
      "fe96151f8be04763bedf23083b6a6b7b",
      "142f3e1df4c1470c81be604db7f2aa95",
      "24efd5b54c444043bde8fad2dd326163"
     ]
    },
    "id": "ClXZDWng-s8F",
    "outputId": "57febdf7-894d-4524-fb3b-9bc63d7c2d36"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mDownloading and preparing dataset food101/2.0.0 (download: 4.65 GiB, generated: Unknown size, total: 4.65 GiB) to /root/tensorflow_datasets/food101/2.0.0...\u001b[0m\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c464cf7f692747dd8a9e5c224b72e683",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=1.0, bar_style='info', description='Dl Completed...', max=1.0, style=Progre…"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "116932efaceb4e6889b9e9a7585a851f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=1.0, bar_style='info', description='Dl Size...', max=1.0, style=ProgressSty…"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "16688ead8185417fbe6acf39649c222a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=1.0, bar_style='info', description='Extraction completed...', max=1.0, styl…"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "da96cbabe8ff449388e052dd55213653",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=1.0, bar_style='info', max=1.0), HTML(value='')))"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\r",
      "Shuffling and writing examples to /root/tensorflow_datasets/food101/2.0.0.incompleteL6ZW0E/food101-train.tfrecord\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "308c42badc014391aaee6b1beb47dbf6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=75750.0), HTML(value='')))"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0624ceb3768e4c62a220b188c7ed1141",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=1.0, bar_style='info', max=1.0), HTML(value='')))"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shuffling and writing examples to /root/tensorflow_datasets/food101/2.0.0.incompleteL6ZW0E/food101-validation.tfrecord\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8a925d410ebb413a808ce40f12e7d91e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=25250.0), HTML(value='')))"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mDataset food101 downloaded and prepared to /root/tensorflow_datasets/food101/2.0.0. Subsequent calls will reuse this data.\u001b[0m\n"
     ]
    }
   ],
   "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": 12,
     "metadata": {
      "tags": []
     },
     "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": 13,
     "metadata": {
      "tags": []
     },
     "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": 15,
     "metadata": {
      "tags": []
     },
     "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, 512, 3)\n",
      "  Image dtype: <dtype: 'uint8'>\n",
      "  Target class from Food101 (tensor form): 25\n",
      "  Class name (str form): club_sandwich\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, 512, 3), dtype=uint8, numpy=\n",
       "array([[[135, 156, 175],\n",
       "        [125, 148, 166],\n",
       "        [114, 136, 159],\n",
       "        ...,\n",
       "        [ 26,   5,  12],\n",
       "        [ 26,   3,  11],\n",
       "        [ 27,   4,  12]],\n",
       "\n",
       "       [[128, 150, 171],\n",
       "        [115, 140, 160],\n",
       "        [102, 127, 149],\n",
       "        ...,\n",
       "        [ 28,   7,  14],\n",
       "        [ 29,   6,  14],\n",
       "        [ 30,   7,  15]],\n",
       "\n",
       "       [[112, 139, 160],\n",
       "        [ 99, 127, 148],\n",
       "        [ 87, 115, 137],\n",
       "        ...,\n",
       "        [ 29,   6,  16],\n",
       "        [ 31,   5,  16],\n",
       "        [ 32,   6,  17]],\n",
       "\n",
       "       ...,\n",
       "\n",
       "       [[ 48,  47,  53],\n",
       "        [ 53,  52,  58],\n",
       "        [ 52,  51,  59],\n",
       "        ...,\n",
       "        [111,  99,  99],\n",
       "        [108,  98,  97],\n",
       "        [106,  96,  97]],\n",
       "\n",
       "       [[ 44,  45,  47],\n",
       "        [ 48,  49,  51],\n",
       "        [ 46,  47,  51],\n",
       "        ...,\n",
       "        [108,  96,  98],\n",
       "        [105,  94,  98],\n",
       "        [102,  93,  96]],\n",
       "\n",
       "       [[ 40,  42,  41],\n",
       "        [ 45,  47,  46],\n",
       "        [ 44,  45,  49],\n",
       "        ...,\n",
       "        [105,  95,  96],\n",
       "        [104,  93,  99],\n",
       "        [100,  91,  96]]], dtype=uint8)>"
      ]
     },
     "execution_count": 17,
     "metadata": {
      "tags": []
     },
     "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": 18,
     "metadata": {
      "tags": []
     },
     "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": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "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",
      " [[[135 156 175]\n",
      "  [125 148 166]\n",
      "  [114 136 159]\n",
      "  ...\n",
      "  [ 26   5  12]\n",
      "  [ 26   3  11]\n",
      "  [ 27   4  12]]\n",
      "\n",
      " [[128 150 171]\n",
      "  [115 140 160]\n",
      "  [102 127 149]\n",
      "  ...\n",
      "  [ 28   7  14]\n",
      "  [ 29   6  14]\n",
      "  [ 30   7  15]]]...,\n",
      "Shape: (512, 512, 3),\n",
      "Datatype: <dtype: 'uint8'>\n",
      "\n",
      "Image after preprocessing:\n",
      " [[[122.83163   146.17346   165.81633  ]\n",
      "  [ 95.07653   122.122444  144.47958  ]\n",
      "  [ 72.5051    106.994896  134.34694  ]\n",
      "  ...\n",
      "  [ 20.714308    2.3570995   3.9285717]\n",
      "  [ 27.285715    6.285714   13.285714 ]\n",
      "  [ 28.28575     5.2857494  13.285749 ]]\n",
      "\n",
      " [[ 88.65305   119.41326   140.41327  ]\n",
      "  [ 74.59694   108.30102   133.02042  ]\n",
      "  [ 75.2551    112.57143   141.91325  ]\n",
      "  ...\n",
      "  [ 26.857143    6.285671   11.040798 ]\n",
      "  [ 30.061235    6.86222    16.795908 ]\n",
      "  [ 31.688843    5.688843   16.688843 ]]]...,\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",
      "tags": []
     },
     "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": 25,
     "metadata": {
      "tags": []
     },
     "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_acc\", # 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=0) # 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": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "5BuEjmlybR7V",
    "outputId": "ebb171e8-4ae9-406d-c771-6cdf4f5b2a8d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Mixed precision compatibility check (mixed_float16): OK\n",
      "Your GPU will likely run quickly with dtype policy mixed_float16 as it has compute capability of at least 7.0. Your GPU: Tesla T4, compute capability 7.5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Mixed precision compatibility check (mixed_float16): OK\n",
      "Your GPU will likely run quickly with dtype policy mixed_float16 as it has compute capability of at least 7.0. Your GPU: Tesla T4, compute capability 7.5\n"
     ]
    }
   ],
   "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": 28,
     "metadata": {
      "tags": []
     },
     "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": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "GrkWpCzfXKE7",
    "outputId": "d3ae00b1-4c19-4d6e-c25f-5d0114a9168a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading data from https://storage.googleapis.com/keras-applications/efficientnetb0_notop.h5\n",
      "16711680/16705208 [==============================] - 0s 0us/step\n"
     ]
    }
   ],
   "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\")\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\"\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": [
    "# 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 float32 <Policy \"float32\">\n",
      "efficientnetb0 False 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": [
    "# 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_1 False float32 <Policy \"float32\">\n",
      "rescaling False float32 <Policy \"mixed_float16\">\n",
      "normalization False float32 <Policy \"float32\">\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/20210317-032425\n",
      "Epoch 1/3\n",
      "2368/2368 [==============================] - 218s 76ms/step - loss: 2.3139 - accuracy: 0.4693 - val_loss: 1.2324 - val_accuracy: 0.6711\n",
      "Epoch 2/3\n",
      "2368/2368 [==============================] - 156s 65ms/step - loss: 1.3124 - accuracy: 0.6626 - val_loss: 1.1215 - val_accuracy: 0.7005\n",
      "Epoch 3/3\n",
      "2368/2368 [==============================] - 154s 64ms/step - loss: 1.1467 - accuracy: 0.7009 - val_loss: 1.0856 - val_accuracy: 0.7105\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 [==============================] - 53s 67ms/step - loss: 1.0854 - accuracy: 0.7098\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1.0854089260101318, 0.7098217606544495]"
      ]
     },
     "execution_count": 35,
     "metadata": {
      "tags": []
     },
     "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\"\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": [
    "# 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": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "3NBOvb9bkAHa",
    "outputId": "0ea80b8d-9570-4148-a784-f6fac093bc5e"
   },
   "outputs": [
    {
     "data": {
      "application/vnd.google.colaboratory.intrinsic+json": {
       "type": "string"
      },
      "text/plain": [
       "'model_checkpoints/cp.ckpt'"
      ]
     },
     "execution_count": 37,
     "metadata": {
      "tags": []
     },
     "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 0x7f186ca8ba90>"
      ]
     },
     "execution_count": 39,
     "metadata": {
      "tags": []
     },
     "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 [==============================] - 47s 56ms/step - loss: 1.0916 - accuracy: 0.7043\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"
   },
   "outputs": [],
   "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_1 True float32 <Policy \"float32\">\n",
      "rescaling False float32 <Policy \"mixed_float16\">\n",
      "normalization False float32 <Policy \"float32\">\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/"
    },
    "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"
     ]
    }
   ],
   "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": {
    "id": "bKGDBKrU6rej"
   },
   "outputs": [],
   "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_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_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 [==============================] - 46s 56ms/step - loss: 1.0854 - accuracy: 0.7098\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1.0854086875915527, 0.7098217606544495]"
      ]
     },
     "execution_count": 48,
     "metadata": {
      "tags": []
     },
     "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-03-17 03:44:38--  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)... 74.125.195.128, 74.125.20.128, 74.125.142.128, ...\n",
      "Connecting to storage.googleapis.com (storage.googleapis.com)|74.125.195.128|: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  79.1MB/s    in 0.2s    \n",
      "\n",
      "2021-03-17 03:44:38 (79.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": [
      "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"
   },
   "outputs": [],
   "source": [
    "# Load and evaluate downloaded GS model\n",
    "loaded_gs_model = tf.keras.models.load_model(\"/content/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: 4,136,929\n",
      "Non-trainable params: 42,023\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 [==============================] - 46s 57ms/step - loss: 1.0881 - accuracy: 0.7065\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1.0881282091140747, 0.7064950466156006]"
      ]
     },
     "execution_count": 55,
     "metadata": {
      "tags": []
     },
     "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/20210317-034947\n",
      "Epoch 1/100\n",
      "2368/2368 [==============================] - 304s 123ms/step - loss: 0.9813 - accuracy: 0.7357 - val_loss: 0.7932 - val_accuracy: 0.7842\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"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2/100\n",
      "2368/2368 [==============================] - 287s 121ms/step - loss: 0.5896 - accuracy: 0.8363 - val_loss: 0.8097 - val_accuracy: 0.7820\n",
      "Epoch 3/100\n",
      "2368/2368 [==============================] - 287s 121ms/step - loss: 0.3337 - accuracy: 0.9068 - val_loss: 0.8791 - val_accuracy: 0.7850\n",
      "\n",
      "Epoch 00003: ReduceLROnPlateau reducing learning rate to 1.9999999494757503e-05.\n",
      "Epoch 4/100\n",
      "2368/2368 [==============================] - 287s 121ms/step - loss: 0.1099 - accuracy: 0.9724 - val_loss: 0.9399 - val_accuracy: 0.8008\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"
     ]
    }
   ],
   "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 [==============================] - 55s 69ms/step - loss: 0.9397 - accuracy: 0.7964\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.9397100210189819, 0.7963564395904541]"
      ]
     },
     "execution_count": 64,
     "metadata": {
      "tags": []
     },
     "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-03-17 04:13:33--  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)... 74.125.20.128, 74.125.197.128, 74.125.142.128, ...\n",
      "Connecting to storage.googleapis.com (storage.googleapis.com)|74.125.20.128|: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   109MB/s    in 0.4s    \n",
      "\n",
      "2021-03-17 04:13:34 (109 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:  /content/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 /content/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"
   },
   "outputs": [],
   "source": [
    "# Load in fine-tuned model from Google Storage and evaluate\n",
    "loaded_fine_tuned_gs_model = tf.keras.models.load_model(\"/content/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 [==============================] - 46s 56ms/step - loss: 0.9073 - accuracy: 0.8017\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.907255232334137, 0.8017029762268066]"
      ]
     },
     "execution_count": 69,
     "metadata": {
      "tags": []
     },
     "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\" \\\n",
    "  --one_shot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Cnqjq9aWM6pd"
   },
   "outputs": [],
   "source": [
    "View experiment: https://tensorboard.dev/experiment/2KINdYxgSgW2bUg7dIvevw/"
   ]
  },
  {
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "fUpOtu_tNWcJ",
    "outputId": "1b9f45dd-95c6-4088-c939-761a491a3d3a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data for the \"text\" plugin is now uploaded to TensorBoard.dev! Note that uploaded data is public. If you do not want to upload data for this plugin, use the \"--plugins\" command line argument.\n",
      "https://tensorboard.dev/experiment/2KINdYxgSgW2bUg7dIvevw/\n",
      "\tName                 Fine-tuning EfficientNetB0 on all Food101 Data\n",
      "\tDescription          Training results for fine-tuning EfficientNetB0 on Food101 Data with learning rate 0.0001\n",
      "\tId                   2KINdYxgSgW2bUg7dIvevw\n",
      "\tCreated              2021-03-09 04:16:36 (2 minutes ago)\n",
      "\tUpdated              2021-03-09 04:16:39 (2 minutes ago)\n",
      "\tRuns                 4\n",
      "\tTags                 3\n",
      "\tScalars              28\n",
      "\tTensor bytes         0\n",
      "\tBinary object bytes  2079943\n",
      "https://tensorboard.dev/experiment/vcySzjmkRkKBLVSdAQMO8g/\n",
      "\tName                 Transfer Learning Experiments with 10 Food101 Classes\n",
      "\tDescription          A series of different transfer learning experiments with varying amounts of data and fine-tuning.\n",
      "\tId                   vcySzjmkRkKBLVSdAQMO8g\n",
      "\tCreated              2021-02-18 05:43:45\n",
      "\tUpdated              2021-02-18 05:43:50\n",
      "\tRuns                 10\n",
      "\tTags                 3\n",
      "\tScalars              108\n",
      "\tTensor bytes         0\n",
      "\tBinary object bytes  4162671\n",
      "https://tensorboard.dev/experiment/dQBrpdwIRgS2qI0Andv8Yg/\n",
      "\tName                 EfficientNetB0 vs. ResNet50V2\n",
      "\tDescription          Comparing two different TF Hub feature extraction model architectures using 10% of the training data\n",
      "\tId                   dQBrpdwIRgS2qI0Andv8Yg\n",
      "\tCreated              2021-02-15 02:13:39\n",
      "\tUpdated              2021-02-15 02:13:41\n",
      "\tRuns                 4\n",
      "\tTags                 3\n",
      "\tScalars              40\n",
      "\tTensor bytes         0\n",
      "\tBinary object bytes  6020432\n",
      "https://tensorboard.dev/experiment/OAE6KXizQZKQxDiqI3cnUQ/\n",
      "\tName                 Fine-tuning EfficientNetB0 on all Food101 Data\n",
      "\tDescription          Training results for fine-tuning EfficientNetB0 on Food101 Data with learning rate 0.0001\n",
      "\tId                   OAE6KXizQZKQxDiqI3cnUQ\n",
      "\tCreated              2020-09-28 05:46:53\n",
      "\tUpdated              2020-09-28 05:46:55\n",
      "\tRuns                 2\n",
      "\tTags                 3\n",
      "\tScalars              56\n",
      "\tTensor bytes         0\n",
      "\tBinary object bytes  1338330\n",
      "https://tensorboard.dev/experiment/2O76kw3PQbKl0lByfg5B4w/\n",
      "\tName                 Transfer learning experiments\n",
      "\tDescription          A series of different transfer learning experiments with varying amounts of data and fine-tuning\n",
      "\tId                   2O76kw3PQbKl0lByfg5B4w\n",
      "\tCreated              2020-09-17 22:51:37\n",
      "\tUpdated              2020-09-17 22:51:47\n",
      "\tRuns                 10\n",
      "\tTags                 3\n",
      "\tScalars              128\n",
      "\tTensor bytes         0\n",
      "\tBinary object bytes  9520961\n",
      "https://tensorboard.dev/experiment/73taSKxXQeGPQsNBcVvY3g/\n",
      "\tName                 EfficientNetB0 vs. ResNet50V2\n",
      "\tDescription          Comparing two different TF Hub feature extraction models architectures using 10% of training images\n",
      "\tId                   73taSKxXQeGPQsNBcVvY3g\n",
      "\tCreated              2020-09-14 05:02:48\n",
      "\tUpdated              2020-09-14 05:02:50\n",
      "\tRuns                 4\n",
      "\tTags                 3\n",
      "\tScalars              40\n",
      "\tTensor bytes         0\n",
      "\tBinary object bytes  3402042\n",
      "Total: 6 experiment(s)\n"
     ]
    }
   ],
   "source": [
    "# View past TensorBoard experiments\n",
    "!tensorboard dev list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "u-Rl-L0hNbEv",
    "outputId": "8b497600-ccd0-4f01-c4e5-defcb597310b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data for the \"text\" plugin is now uploaded to TensorBoard.dev! Note that uploaded data is public. If you do not want to upload data for this plugin, use the \"--plugins\" command line argument.\n",
      "Deleted experiment OAE6KXizQZKQxDiqI3cnUQ.\n"
     ]
    }
   ],
   "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": {
   "authorship_tag": "ABX9TyNumgZTSUY6303HvBK9xoUq",
   "collapsed_sections": [],
   "include_colab_link": true,
   "mount_file_id": "1c4WrBrZ-ZQUKE9I17T6vDv4TzoXV6Wu1",
   "name": "07_food_vision_milestone_project_1.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "02364bec4a004ed4a4b0970e1b572410": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "02df2b60820b46cbb03c61e9d3a171be": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "0624ceb3768e4c62a220b188c7ed1141": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_113e3bf10abe4f5d943c10da89fd9adc",
       "IPY_MODEL_7c0827a68eb141e5a1939597a171c593"
      ],
      "layout": "IPY_MODEL_20657b32df4848e6a1f3d3fc88236d57"
     }
    },
    "07922060a53a4fc0812a5bbc977ca268": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "0f5af87526534cb9a021e362e61a089b": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "103a4aded56c4acd81aac7fe81851956": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_e6dc230531bc449cb651470bfb3ccc85",
      "placeholder": "​",
      "style": "IPY_MODEL_309a4eb5407d4a2091efcfabd211b967",
      "value": " 75750/0 [01:52&lt;00:00, 601.00 examples/s]"
     }
    },
    "113e3bf10abe4f5d943c10da89fd9adc": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "info",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_3485e9277b49412fa22ff0065d3832b4",
      "max": 1,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_b2c9c7704b8e407d97f2471dddec0f06",
      "value": 1
     }
    },
    "116932efaceb4e6889b9e9a7585a851f": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_33aad3ba3e0648d18b64c2a0e013ea7e",
       "IPY_MODEL_5ffe42dfcc8945058a1211325bb12276"
      ],
      "layout": "IPY_MODEL_449c05474a464357a0a2aa0671849a84"
     }
    },
    "142f3e1df4c1470c81be604db7f2aa95": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "1630703c5da345df876cd4a38ac062d0": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": "initial"
     }
    },
    "16688ead8185417fbe6acf39649c222a": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_7cd57199faa1403b806f64a00c220e3f",
       "IPY_MODEL_8f1b23e71fd14fcc97a32f0abdc96419"
      ],
      "layout": "IPY_MODEL_5bdf272dff1049afac690fe78c530277"
     }
    },
    "20657b32df4848e6a1f3d3fc88236d57": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "24efd5b54c444043bde8fad2dd326163": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "25d1eb6b6bcb48bbb79749475775b295": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_3b4eb46bc9fc482d94e0d2b20b70eb66",
      "placeholder": "​",
      "style": "IPY_MODEL_07922060a53a4fc0812a5bbc977ca268",
      "value": " 75677/75750 [01:40&lt;00:00, 888.38 examples/s]"
     }
    },
    "308c42badc014391aaee6b1beb47dbf6": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_fe172d6537a642be985520c0e66d7801",
       "IPY_MODEL_25d1eb6b6bcb48bbb79749475775b295"
      ],
      "layout": "IPY_MODEL_fce62bc99e2b47b3b15005ae97d287bd"
     }
    },
    "309a4eb5407d4a2091efcfabd211b967": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "33aad3ba3e0648d18b64c2a0e013ea7e": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "success",
      "description": "Dl Size...: 100%",
      "description_tooltip": null,
      "layout": "IPY_MODEL_02364bec4a004ed4a4b0970e1b572410",
      "max": 1,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_7aff75e4e7094ab2b7c4bff04b8b8e60",
      "value": 1
     }
    },
    "3485e9277b49412fa22ff0065d3832b4": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "3b4eb46bc9fc482d94e0d2b20b70eb66": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "41908c7012174ecabfe801a2f5e3dee5": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "info",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_6f9a55e4f5fd4f459eac237f02c37829",
      "max": 1,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_fa047be5ac684f76b2d245fbb99b2920",
      "value": 1
     }
    },
    "449c05474a464357a0a2aa0671849a84": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "465a84232f9344b7852bc0315aaf6147": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "success",
      "description": "Dl Completed...: 100%",
      "description_tooltip": null,
      "layout": "IPY_MODEL_48c761f4ebf541169f0b674e835081bd",
      "max": 1,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_1630703c5da345df876cd4a38ac062d0",
      "value": 1
     }
    },
    "473159e3bfdd463590775781ed676f55": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_24efd5b54c444043bde8fad2dd326163",
      "placeholder": "​",
      "style": "IPY_MODEL_142f3e1df4c1470c81be604db7f2aa95",
      "value": " 25191/25250 [00:30&lt;00:00, 665.79 examples/s]"
     }
    },
    "48c761f4ebf541169f0b674e835081bd": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "4ffa9402790542c388443678b0fb9982": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "568e801778124de386e7badcf1e58456": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": "initial"
     }
    },
    "56eb15d4d1dd450aaa727875c04b1957": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "5b48d0e1bd664416b3a8da6daedf29eb": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "5bdf272dff1049afac690fe78c530277": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "5fba5aafc52c43aaa52619421330dd57": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "5ffe42dfcc8945058a1211325bb12276": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_0f5af87526534cb9a021e362e61a089b",
      "placeholder": "​",
      "style": "IPY_MODEL_e6780bf5a7a84f4886a2ad32df1db1e0",
      "value": " 4764/4764 [06:05&lt;00:00, 13.04 MiB/s]"
     }
    },
    "6f9a55e4f5fd4f459eac237f02c37829": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "7aff75e4e7094ab2b7c4bff04b8b8e60": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": "initial"
     }
    },
    "7b2c7af82c5e4c8b812c3d4514976101": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "danger",
      "description": "100%",
      "description_tooltip": null,
      "layout": "IPY_MODEL_fe96151f8be04763bedf23083b6a6b7b",
      "max": 25250,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_568e801778124de386e7badcf1e58456",
      "value": 25191
     }
    },
    "7c0827a68eb141e5a1939597a171c593": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_5fba5aafc52c43aaa52619421330dd57",
      "placeholder": "​",
      "style": "IPY_MODEL_4ffa9402790542c388443678b0fb9982",
      "value": " 25250/0 [00:50&lt;00:00, 499.43 examples/s]"
     }
    },
    "7caebdb45e1f41ae88eddfabada5ff67": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "7cd57199faa1403b806f64a00c220e3f": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "success",
      "description": "Extraction completed...: 100%",
      "description_tooltip": null,
      "layout": "IPY_MODEL_97e5f68c3ae040b6a22709f4fabc09b8",
      "max": 1,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_daf7463ed2b14751bb7532a91429bf67",
      "value": 1
     }
    },
    "8a925d410ebb413a808ce40f12e7d91e": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_7b2c7af82c5e4c8b812c3d4514976101",
       "IPY_MODEL_473159e3bfdd463590775781ed676f55"
      ],
      "layout": "IPY_MODEL_9a9338dbc9c04a078575071d48b25e51"
     }
    },
    "8f1b23e71fd14fcc97a32f0abdc96419": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_7caebdb45e1f41ae88eddfabada5ff67",
      "placeholder": "​",
      "style": "IPY_MODEL_02df2b60820b46cbb03c61e9d3a171be",
      "value": " 1/1 [06:05&lt;00:00, 365.26s/ file]"
     }
    },
    "97e5f68c3ae040b6a22709f4fabc09b8": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "9a9338dbc9c04a078575071d48b25e51": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "a15efd3f9c514ce1947bd75330ddc60f": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_5b48d0e1bd664416b3a8da6daedf29eb",
      "placeholder": "​",
      "style": "IPY_MODEL_fc53cb8f72eb45d9987f22fa391e64ff",
      "value": " 1/1 [06:05&lt;00:00, 365.33s/ url]"
     }
    },
    "acc1ea5a5531425c885afe2bdbce4273": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "b2c9c7704b8e407d97f2471dddec0f06": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": "initial"
     }
    },
    "c464cf7f692747dd8a9e5c224b72e683": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_465a84232f9344b7852bc0315aaf6147",
       "IPY_MODEL_a15efd3f9c514ce1947bd75330ddc60f"
      ],
      "layout": "IPY_MODEL_e19cbd5c9eca4db6b023d501ae96447b"
     }
    },
    "da96cbabe8ff449388e052dd55213653": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_41908c7012174ecabfe801a2f5e3dee5",
       "IPY_MODEL_103a4aded56c4acd81aac7fe81851956"
      ],
      "layout": "IPY_MODEL_56eb15d4d1dd450aaa727875c04b1957"
     }
    },
    "daf7463ed2b14751bb7532a91429bf67": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": "initial"
     }
    },
    "e19cbd5c9eca4db6b023d501ae96447b": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "e6780bf5a7a84f4886a2ad32df1db1e0": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "e6dc230531bc449cb651470bfb3ccc85": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "e8ef9677adbf4f368a258d64732d152a": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": "initial"
     }
    },
    "fa047be5ac684f76b2d245fbb99b2920": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": "initial"
     }
    },
    "fc53cb8f72eb45d9987f22fa391e64ff": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "fce62bc99e2b47b3b15005ae97d287bd": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "fe172d6537a642be985520c0e66d7801": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "danger",
      "description": "100%",
      "description_tooltip": null,
      "layout": "IPY_MODEL_acc1ea5a5531425c885afe2bdbce4273",
      "max": 75750,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_e8ef9677adbf4f368a258d64732d152a",
      "value": 75677
     }
    },
    "fe96151f8be04763bedf23083b6a6b7b": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    }
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}