food_vision.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Project: Food Vision"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Check GPU\n",
    "\n",
    "Google Colab offers free GPUs (thank you Google), however, not all of them are compatiable with mixed precision training.\n",
    "\n",
    "Google Colab offers:\n",
    "* K80 (not compatible)\n",
    "* P100 (not compatible) \n",
    "* Tesla T4 (compatible)\n",
    "\n",
    "Knowing this, in order to use mixed precision training we need access to a Tesla T4 (from within Google Colab) or if we're using our own hardware, our GPU needs a score of 7.0+ (see here: https://developer.nvidia.com/cuda-gpus).\n",
    "\n",
    "📖 **Resource:** You can read more about the benefits of mixed precision training in the TensorFlow Mixed Precision documentation: https://www.tensorflow.org/guide/mixed_precision \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GPU 0: NVIDIA GeForce MX330 (UUID: GPU-77eebd61-350b-2f9c-b351-0acab8f44c51)\n"
     ]
    }
   ],
   "source": [
    "# If the following line doesn't output \"Tesla T4\", you can try getting access to\n",
    "# another GPU by going to Runtime -> Factory Reset Runtime -> \"Yes\" and then\n",
    "# re-running this cell.\n",
    "!nvidia-smi -L"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NOTE:** Since I don't have a good GPU for mixed precision, I had executed the code in Google Colab using the Tesla T4 GPU and had paste the output here."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Get helper functions\n",
    "helper.py file consists of many pre-written functions such as for graphs etc. which will be very useful in this project.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import series of helper functions for the notebook\n",
    "from helper_functions import create_tensorboard_callback, plot_loss_curves, compare_historys"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Use TensorFlow Datasets to Download Data\n",
    "\n",
    "If you want to get an overview of TensorFlow Datasets (TFDS), read the guide: https://www.tensorflow.org/datasets/overview"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get TensorFlow Datasets\n",
    "import tensorflow_datasets as tfds"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**IMPORTANT NOTE:** Some of the datasets contained within TensorFlow datasets are over 100GB+, meaning if you run the cell below (outside of Google Colab), you might be downloading 100GB+ to your computer or the computer that you're using. Beware as this could take a large amount of bandwidth."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# List all available datasets\n",
    "datasets_list = tfds.list_builders() # get all available datasets in TFDS\n",
    "print(\"food101\" in datasets_list) # is our target dataset in the list of TFDS datasets?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load in the data (takes 5-6 minutes in Google Colab)\n",
    "(train_data, test_data), ds_info = tfds.load(name=\"food101\",\n",
    "                                             split=[\"train\", \"validation\"], # splits can be a little tricky, for more see: https://www.tensorflow.org/datasets/splits \n",
    "                                             shuffle_files=True,\n",
    "                                             as_supervised=True, # data gets returned in tuple format (data, label)\n",
    "                                             with_info=True) # for meta-data\n",
    "\n",
    "#OUTPUT:\n",
    "# Downloading and preparing dataset 4.65 GiB (download: 4.65 GiB, generated: Unknown size, total: 4.65 GiB) to /root/tensorflow_datasets/food101/2.0.0...\n",
    "# Dl Completed...: 100%\n",
    "# 1/1 [11:00<00:00, 343.23s/ url]\n",
    "# Dl Size...: 100%\n",
    "# 4764/4764 [11:00<00:00, 15.26 MiB/s]\n",
    "# Extraction completed...: 94%\n",
    "# 101008/101008 [11:00<00:00, 1083.67 file/s]\n",
    "# Dataset food101 downloaded and prepared to /root/tensorflow_datasets/food101/2.0.0. Subsequent calls will reuse this data."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exploring the Food101 data from TensorFlow Datasets\n",
    "\n",
    "To become one with our data, we want to find:\n",
    "* Class names\n",
    "* The shape of our input data (image tensors)\n",
    "* The datatype of our input data\n",
    "* What the labels look like (e.g. are they one-hot encoded or are they label encoded)\n",
    "* Do the labels match up with the class names?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Features of Food101 from TFDS\n",
    "ds_info.features\n",
    "\n",
    "#OUTPUT:\n",
    "# FeaturesDict({\n",
    "#     'image': Image(shape=(None, None, 3), dtype=uint8),\n",
    "#     'label': ClassLabel(shape=(), dtype=int64, num_classes=101),\n",
    "# })"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the class names\n",
    "class_names = ds_info.features[\"label\"].names\n",
    "class_names[:10]\n",
    "\n",
    "# OUTPUT:\n",
    "# ['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']\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Take one sample of the train data\n",
    "train_one_sample = train_data.take(1) # samples are in format (image_tensor, label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# What does one sample of our training data look like?\n",
    "train_one_sample\n",
    "\n",
    "# OUTPUT:\n",
    "# <_TakeDataset element_spec=(TensorSpec(shape=(None, None, 3), dtype=tf.uint8, name=None), TensorSpec(shape=(), dtype=tf.int64, name=None))>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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 datatype: {image.dtype}\n",
    "  Target class from Food101 (tensor form): {label}\n",
    "  Class name (str form): {class_names[label.numpy()]}\n",
    "  \"\"\")\n",
    "\n",
    "  # OUTPUT:\n",
    "  # Image shape: (512, 512, 3)\n",
    "  # Image datatype: <dtype: 'uint8'>\n",
    "  # Target class from Food101 (tensor form): 72\n",
    "  # Class name (str form): pancakes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# What does our image tensor from TFDS's Food101 look like?\n",
    "image\n",
    "\n",
    "#OUTPUT:\n",
    "# <tf.Tensor: shape=(512, 512, 3), dtype=uint8, numpy=\n",
    "# array([[[ 42,  40,  51],\n",
    "#         [ 41,  39,  50],\n",
    "#         [ 40,  38,  49],\n",
    "#         ...,\n",
    "#         [ 50,  23,   6],\n",
    "#         [ 51,  24,   7],\n",
    "#         [ 51,  24,   7]],\n",
    "\n",
    "#        [[ 41,  39,  50],\n",
    "#         [ 41,  39,  50],\n",
    "#         [ 41,  39,  50],\n",
    "#         ...,\n",
    "#         [ 47,  20,   3],\n",
    "#         [ 48,  21,   4],\n",
    "#         [ 49,  22,   5]],\n",
    "\n",
    "#        [[ 40,  38,  49],\n",
    "#         [ 41,  39,  50],\n",
    "#         [ 42,  40,  51],\n",
    "#         ...,\n",
    "#         [ 47,  20,   3],\n",
    "#         [ 48,  21,   4],\n",
    "#         [ 48,  21,   4]],\n",
    "\n",
    "#        ...,\n",
    "\n",
    "#        [[188, 180, 191],\n",
    "#         [188, 180, 191],\n",
    "#         [189, 181, 192],\n",
    "#         ...,\n",
    "#         [179, 178, 186],\n",
    "#         [177, 176, 184],\n",
    "#         [175, 174, 182]],\n",
    "\n",
    "#        [[185, 177, 188],\n",
    "#         [186, 178, 189],\n",
    "#         [187, 179, 190],\n",
    "#         ...,\n",
    "#         [178, 177, 185],\n",
    "#         [176, 175, 183],\n",
    "#         [175, 174, 182]],\n",
    "\n",
    "#        [[179, 171, 182],\n",
    "#         [181, 173, 184],\n",
    "#         [183, 175, 186],\n",
    "#         ...,\n",
    "#         [177, 176, 184],\n",
    "#         [176, 175, 183],\n",
    "#         [174, 173, 181]]], dtype=uint8)>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# What are the min and max values of our image tensor?\n",
    "import tensorflow as tf\n",
    "tf.reduce_min(image), tf.reduce_max(image)\n",
    "\n",
    "# OUTPUT:\n",
    "# (<tf.Tensor: shape=(), dtype=uint8, numpy=0>,\n",
    "#  <tf.Tensor: shape=(), dtype=uint8, numpy=255>)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot an image from TensorFlow Datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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 to verify the label is assosciated with the right image\n",
    "plt.axis(False);"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](data:image/png;base64,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)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create preprocessing functions for our data\n",
    "\n",
    "Neural networks perform best when data is in a certain way (e.g. batched, normalized, etc).\n",
    "\n",
    "However, not all data (including data from from TensorFlow Datasets) comes like this.\n",
    "\n",
    "So in order to get it ready for a neural network, you'll often have to write preprocessing functions and map it to your data.\n",
    "\n",
    "What we know about our data:\n",
    "* In `uint8` datatype\n",
    "* Comprised of all different size tensors (different sized images)\n",
    "* Not scaled (the pixel values are between 0 & 255)\n",
    "\n",
    "What we know models like:\n",
    "* Data in `float32` dtype (or for mixed precision `float16` and `float32`)\n",
    "* For batches, TensorFlow likes all of the tensors within a batch to be of the same size\n",
    "* Scaled (values between 0 & 1) also called normalized tensors generally perform better\n",
    "\n",
    "With these points in mind, we've got a few things we can tackle with a preprocessing function.\n",
    "\n",
    "Since we're going to be using an EfficientNetBX pretrained model from tf.keras.applications we don't need to rescale our data (these architectures have rescaling built-in).\n",
    "\n",
    "This means our functions needs to:\n",
    "1. Reshape our images to all the same size\n",
    "2. Convert the dtype of our image tensors from `unit8` to `float32`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Our data comes in the tuple structure: (image, label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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\n",
    "  image to [img_shape, img_shape, colour_channels]\n",
    "  \"\"\"\n",
    "  image = tf.image.resize(image, [img_shape, img_shape]) # reshape target image\n",
    "  # image = image/255. # scale image values (not required with EfficientNetBX models from tf.keras.applications)\n",
    "  return tf.cast(image, tf.float32), label # return (float32_image, label) tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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}\")\n",
    "\n",
    "# OUTPUT:\n",
    "# Image before preprocessing:\n",
    "#  [[[42 40 51]\n",
    "#   [41 39 50]\n",
    "#   [40 38 49]\n",
    "#   ...\n",
    "#   [50 23  6]\n",
    "#   [51 24  7]\n",
    "#   [51 24  7]]\n",
    "\n",
    "#  [[41 39 50]\n",
    "#   [41 39 50]\n",
    "#   [41 39 50]\n",
    "#   ...\n",
    "#   [47 20  3]\n",
    "#   [48 21  4]\n",
    "#   [49 22  5]]]..., \n",
    "# Shape: (512, 512, 3),\n",
    "# Datatype: <dtype: 'uint8'>\n",
    "\n",
    "# Image after preprocessing:\n",
    "# [[[41.127552  39.127552  50.127552 ]\n",
    "#   [40.642857  38.642857  49.642857 ]\n",
    "#   [40.285713  38.285713  49.285713 ]\n",
    "#   ...\n",
    "#   [48.92855   21.928549   4.500022 ]\n",
    "#   [47.7398    20.7398     3.7398005]\n",
    "#   [49.301044  22.301043   5.3010426]]\n",
    "\n",
    "#  [[40.642857  38.642857  49.642857 ]\n",
    "#   [42.9949    40.9949    51.9949   ]\n",
    "#   [41.85714   39.85714   50.85714  ]\n",
    "#   ...\n",
    "#   [49.127533  22.127531   4.699003 ]\n",
    "#   [47.862247  20.862246   3.8622465]\n",
    "#   [48.928574  21.928572   4.9285717]]]...,\n",
    "# Shape: (224, 224, 3),\n",
    "# Datatype: <dtype: 'float32'>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Batch & prepare datasets\n",
    "\n",
    "We're now going to make our data input pipeline run really fast. \n",
    "\n",
    "For more resources: https://www.tensorflow.org/guide/data_performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Map preprocessing function to training (and parallelize)\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 preprocessing function to test data\n",
    "test_data = test_data.map(preprocess_img, num_parallel_calls=tf.data.AUTOTUNE).batch(32).prefetch(tf.data.AUTOTUNE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data, test_data\n",
    "\n",
    "# OUTPUT:\n",
    "# (<_PrefetchDataset element_spec=(TensorSpec(shape=(None, 224, 224, 3), dtype=tf.float32, name=None), TensorSpec(shape=(None,), dtype=tf.int64, name=None))>,\n",
    "#  <_PrefetchDataset element_spec=(TensorSpec(shape=(None, 224, 224, 3), dtype=tf.float32, name=None), TensorSpec(shape=(None,), dtype=tf.int64, name=None))>)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **NOTE:** *Performance data pipeline does the following:* Map this preprocessing function (`preprocess_img`) across our training dataset, then shuffle a number of elements and then batch them together and finally make sure that it prepare new batches (prefetch) whilst the model is looking through (finding patterns) in the current batch.\""
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create modelling callbacks\n",
    "\n",
    "We're going to create a couple of callbacks to help us while our model trains:\n",
    "* TensorBoard callback to log training results (so we can visualize them later if need be)\n",
    "* ModelCheckpoint callback to save our model's progress after feature extraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create tensorboard callback (import from helper_functions.py)\n",
    "from helper_functions import create_tensorboard_callback\n",
    "\n",
    "# Create ModelCheckpoint callback to save a model's progress during training \n",
    "checkpoint_path = \"model_checkpoints/cp.ckpt\"\n",
    "model_checkpoint = tf.keras.callbacks.ModelCheckpoint(checkpoint_path,\n",
    "                                                      montior=\"val_acc\",\n",
    "                                                      save_best_only=True,\n",
    "                                                      save_weights_only=True,\n",
    "                                                      verbose=0) # don't print whether or not model is being saved"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup mixed precision training\n",
    "\n",
    "Check out the TensorFlow guide for mixed precision: https://www.tensorflow.org/guide/mixed_precision\n",
    "\n",
    "Mixed precision utilizes a combination of float32 and float16 data types to speed up model performance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Mixed precision compatibility check (mixed_float16): WARNING\n",
      "The dtype policy mixed_float16 may run slowly because this machine does not have a GPU. Only Nvidia GPUs with compute capability of at least 7.0 run quickly with mixed_float16.\n",
      "If you will use compatible GPU(s) not attached to this host, e.g. by running a multi-worker model, you can ignore this warning. This message will only be logged once\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Mixed precision compatibility check (mixed_float16): WARNING\n",
      "The dtype policy mixed_float16 may run slowly because this machine does not have a GPU. Only Nvidia GPUs with compute capability of at least 7.0 run quickly with mixed_float16.\n",
      "If you will use compatible GPU(s) not attached to this host, e.g. by running a multi-worker model, you can ignore this warning. This message will only be logged once\n"
     ]
    }
   ],
   "source": [
    "# Turn on mixed precision training\n",
    "from tensorflow.keras import mixed_precision\n",
    "mixed_precision.set_global_policy(\"mixed_float16\") # set global data policy to mixed precision\n",
    "\n",
    "#The below error has occurred because of the incompatible GPU which I have."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Policy \"mixed_float16\">"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mixed_precision.global_policy()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Build feature extraction model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras import layers\n",
    "from tensorflow.keras.layers.experimental import preprocessing\n",
    "\n",
    "# Create base model\n",
    "input_shape = (224, 224, 3)\n",
    "base_model = tf.keras.applications.EfficientNetB0(include_top=False)\n",
    "base_model.trainable = False\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 doesn't you can have a layer like below\n",
    "# x = preprocessing.Rescaling(1./255)(x)\n",
    "x = base_model(inputs, training=False) # makes sure layers which should be in inference mode only stay like that\n",
    "x = layers.GlobalAveragePooling2D()(x)\n",
    "x = layers.Dense(len(class_names))(x)\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\",\n",
    "              optimizer=tf.keras.optimizers.Adam(),\n",
    "              metrics=[\"accuracy\"])\n",
    "\n",
    "\n",
    "#OUTPUT:\n",
    "# Downloading data from https://storage.googleapis.com/keras-applications/efficientnetb0_notop.h5\n",
    "# 16705208/16705208 [==============================] - 2s 0us/step"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.summary()\n",
    "\n",
    "#OUTPUT:\n",
    "# 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",
    "#  global_average_pooling2d (G  (None, 1280)             0         \n",
    "#  lobalAveragePooling2D)                                          \n",
    "                                                                 \n",
    "#  dense (Dense)               (None, 101)               129381    \n",
    "                                                                 \n",
    "#  softmax_float32 (Activation  (None, 101)              0         \n",
    "#  )                                                               \n",
    "                                                                 \n",
    "# =================================================================\n",
    "# Total params: 4,178,952\n",
    "# Trainable params: 129,381\n",
    "# Non-trainable params: 4,049,571\n",
    "# _________________________________________________________________"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Checking layer dtype policies (are we using mixed precision?)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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)\n",
    "\n",
    "#OUTPUT:\n",
    "# input_layer True float32 <Policy \"float32\">\n",
    "# efficientnetb0 False float32 <Policy \"mixed_float16\">\n",
    "# global_average_pooling2d True float32 <Policy \"mixed_float16\">\n",
    "# dense True float32 <Policy \"mixed_float16\">\n",
    "# softmax_float32 True float32 <Policy \"float32\">"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Going through the above we see:\n",
    "* `layer.name`: the human readable name of a particular layer\n",
    "* `layer.trainable`: is the layer trainable or not? (if `False`, the weights are frozen)\n",
    "* `layer.dtype`: the data type a layer stores its variables in\n",
    "* `layer.dtype_policy`: the data type policy a layer computes on its variables with"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check the dtype_policy attributes of layers in the base model\n",
    "for layer in model.layers[1].layers[:20]: # check the layers of the base model (layer at index 1 of `model`)\n",
    "  print(layer.name, layer.trainable, layer.dtype, layer.dtype_policy)\n",
    "\n",
    "#OUTPUT:\n",
    "# input_1 False float32 <Policy \"float32\">\n",
    "# rescaling False float32 <Policy \"mixed_float16\">\n",
    "# normalization False float32 <Policy \"mixed_float16\">\n",
    "# rescaling_1 False float32 <Policy \"mixed_float16\">\n",
    "# stem_conv_pad False float32 <Policy \"mixed_float16\">\n",
    "# stem_conv False float32 <Policy \"mixed_float16\">\n",
    "# stem_bn False float32 <Policy \"mixed_float16\">\n",
    "# stem_activation False float32 <Policy \"mixed_float16\">\n",
    "# block1a_dwconv False float32 <Policy \"mixed_float16\">\n",
    "# block1a_bn False float32 <Policy \"mixed_float16\">\n",
    "# block1a_activation False float32 <Policy \"mixed_float16\">\n",
    "# block1a_se_squeeze False float32 <Policy \"mixed_float16\">\n",
    "# block1a_se_reshape False float32 <Policy \"mixed_float16\">\n",
    "# block1a_se_reduce False float32 <Policy \"mixed_float16\">\n",
    "# block1a_se_expand False float32 <Policy \"mixed_float16\">\n",
    "# block1a_se_excite False float32 <Policy \"mixed_float16\">\n",
    "# block1a_project_conv False float32 <Policy \"mixed_float16\">\n",
    "# block1a_project_bn False float32 <Policy \"mixed_float16\">\n",
    "# block2a_expand_conv False float32 <Policy \"mixed_float16\">\n",
    "# block2a_expand_bn False float32 <Policy \"mixed_float16\">"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fit the feature extraction model\n",
    "\n",
    "If our goal is to fine-tune a pretrained model, the general order of doing things is:\n",
    "1. Build a feature extraction model (train a couple output layers with base layers frozen) \n",
    "2. Fine-tune some of the frozen layers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fit the feature extraction 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(dir_name=\"training_logs\",\n",
    "                                                                                            experiment_name=\"efficientnetb0_101_classes_all_data_feature_extract\"),\n",
    "                                                                model_checkpoint])\n",
    "\n",
    "#OUTPUT:\n",
    "# WARNING:tensorflow:Model failed to serialize as JSON. Ignoring... Unable to serialize [2.0896919 2.1128857 2.1081853] to JSON. Unrecognized type <class 'tensorflow.python.framework.ops.EagerTensor'>.\n",
    "# Saving TensorBoard log files to: training_logs/efficientnetb0_101_classes_all_data_feature_extract/20230604-180037\n",
    "# Epoch 1/3\n",
    "# 2368/2368 [==============================] - 224s 87ms/step - loss: 1.7183 - accuracy: 0.5840 - val_loss: 1.1230 - val_accuracy: 0.6954\n",
    "# Epoch 2/3\n",
    "# 2368/2368 [==============================] - 207s 86ms/step - loss: 1.1993 - accuracy: 0.6892 - val_loss: 1.0306 - val_accuracy: 0.7214\n",
    "# Epoch 3/3\n",
    "# 2368/2368 [==============================] - 209s 87ms/step - loss: 1.0537 - accuracy: 0.7240 - val_loss: 0.9891 - val_accuracy: 0.7272"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Evaluate model on whole test dataset\n",
    "results_feature_extract_model = model.evaluate(test_data)\n",
    "results_feature_extract_model\n",
    "\n",
    "#OUTPUT:\n",
    "# 790/790 [==============================] - 60s 75ms/step - loss: 0.9956 - accuracy: 0.7283\n",
    "# [0.9955681562423706, 0.7282772064208984]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load and evaluate checkpoint weights:\n",
    "We can load in and evaluate our model's checkpoints by:\n",
    "\n",
    "1. Recreating a new instance of our model called created_model by turning our original model creation code into a function called create_model().\n",
    "2. Compiling our created_model with the same loss, optimizer and metrics as the original model (every time you create a new model, you must compile it).\n",
    "3. Calling the load_weights() method on our created_model and passing it the path to where our checkpointed weights are stored.\n",
    "4. Calling evaluate() on created_model with loaded weights and saving the results.\n",
    "5. Comparing the created_model results to our previous model results (these should be the exact same, if not very close).\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."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**IMPORTANT NOTE:** This section originally used the tf.keras.clone_model method, however, due to several potential errors with that method, it changed to create a new model (rather than cloning) via a create_model() function. See the discussion on the course GitHub for more."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. Create a function to recreate the original model\n",
    "def create_model():\n",
    "  # Create base model\n",
    "  input_shape = (224, 224, 3)\n",
    "  base_model = tf.keras.applications.efficientnet.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 = layers.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",
    "  return model\n",
    "\n",
    "# 2. Create and compile a new version of the original model (new weights)\n",
    "created_model = create_model()\n",
    "created_model.compile(loss=\"sparse_categorical_crossentropy\",\n",
    "                      optimizer=tf.keras.optimizers.Adam(),\n",
    "                      metrics=[\"accuracy\"])\n",
    "\n",
    "# 3. Load the saved weights\n",
    "created_model.load_weights(checkpoint_path)\n",
    "\n",
    "# 4. Evaluate the model with loaded weights\n",
    "results_created_model_with_loaded_weights = created_model.evaluate(test_data)\n",
    "\n",
    "#OUTPUT:\n",
    "# 790/790 [==============================] - 62s 71ms/step - loss: 0.9975 - accuracy: 0.7290"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5. Loaded checkpoint weights should return very similar results to checkpoint weights prior to saving\n",
    "import numpy as np\n",
    "np.isclose(results_feature_extract_model, results_created_model_with_loaded_weights).all() # check if all elements in array are close\n",
    "\n",
    "#OUTPUT:\n",
    "# True"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cloning the model preserves dtype_policy's of layers (but doesn't preserve weights) so if we wanted to continue fine-tuning our created_model, we could and it would still use the mixed precision dtype policy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check the layers in the base model and see what dtype policy they're using\n",
    "for layer in created_model.layers[1].layers[:20]: # check only the first 20 layers to save printing space\n",
    "    print(layer.name, layer.trainable, layer.dtype, layer.dtype_policy)\n",
    "\n",
    "\n",
    "#OUTPUT:\n",
    "# input_2 False float32 <Policy \"float32\">\n",
    "# rescaling_2 False float32 <Policy \"mixed_float16\">\n",
    "# normalization_1 False float32 <Policy \"mixed_float16\">\n",
    "# rescaling_3 False float32 <Policy \"mixed_float16\">\n",
    "# stem_conv_pad False float32 <Policy \"mixed_float16\">\n",
    "# stem_conv False float32 <Policy \"mixed_float16\">\n",
    "# stem_bn False float32 <Policy \"mixed_float16\">\n",
    "# stem_activation False float32 <Policy \"mixed_float16\">\n",
    "# block1a_dwconv False float32 <Policy \"mixed_float16\">\n",
    "# block1a_bn False float32 <Policy \"mixed_float16\">\n",
    "# block1a_activation False float32 <Policy \"mixed_float16\">\n",
    "# block1a_se_squeeze False float32 <Policy \"mixed_float16\">\n",
    "# block1a_se_reshape False float32 <Policy \"mixed_float16\">\n",
    "# block1a_se_reduce False float32 <Policy \"mixed_float16\">\n",
    "# block1a_se_expand False float32 <Policy \"mixed_float16\">\n",
    "# block1a_se_excite False float32 <Policy \"mixed_float16\">\n",
    "# block1a_project_conv False float32 <Policy \"mixed_float16\">\n",
    "# block1a_project_bn False float32 <Policy \"mixed_float16\">\n",
    "# block2a_expand_conv False float32 <Policy \"mixed_float16\">\n",
    "# block2a_expand_bn False float32 <Policy \"mixed_float16\">"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Save the whole model to file\n",
    "We can also save the whole model using the save() method."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NOTE:** The below code for saving the model will not result into errors with the tensorflow version 2.9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ## Saving model to Google Drive (optional)\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",
    "# model.save(save_dir)\n",
    "\n",
    "# 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)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check whether or not our model saved correctly by loading it in and evaluating it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load model previously saved above\n",
    "loaded_saved_model = tf.keras.models.load_model(save_dir)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "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": {},
   "outputs": [],
   "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": {},
   "outputs": [],
   "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": {},
   "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()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**IMPORTANT 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 continually train from scratch."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preparing our model's layers for fine-tuning\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",
    "**IMPORTANT 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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": {},
   "outputs": [],
   "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": {},
   "outputs": [],
   "source": [
    "# Load and evaluate downloaded GS model\n",
    "loaded_gs_model = tf.keras.models.load_model(\"downloaded_gs_model/07_efficientnetb0_feature_extract_model_mixed_precision\")\n",
    "\n",
    "#OUTPUT:\n",
    "# WARNING:absl:Importing a function (__inference_block3b_expand_activation_layer_call_and_return_conditional_losses_192487) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
    "# WARNING:absl:Importing a function (__inference_block1a_se_reduce_layer_call_and_return_conditional_losses_191255) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
    "# WARNING:absl:Importing a function (__inference_block7a_activation_layer_call_and_return_conditional_losses_163009) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
    "# WARNING:absl:Importing a function (__inference_block5b_activation_layer_call_and_return_conditional_losses_194335) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
    "# WARNING:absl:Importing a function (__inference_block4c_expand_activation_layer_call_and_return_conditional_losses_193559) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
    "# WARNING:absl:Importing a function (__inference_block4a_expand_activation_layer_call_and_return_conditional_losses_159730) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
    "# WARNING:absl:Importing a function (__inference_block6a_se_reduce_layer_call_and_return_conditional_losses_161759) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
    "# WARNING:absl:Importing a function (__inference_block3a_expand_activation_layer_call_and_return_conditional_losses_192161) with ops with unsaved custom gradients. Will likely fail if a gradient is requested.\n",
    "# WARNING:absl:Importing a function (__inference_block4b_se_reduce_layer_call_and_return_conditional_losses_193305) with ops with unsaved custom gradients. Will likely fail if a gradient is requested."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get a summary of our downloaded model\n",
    "loaded_gs_model.summary()\n",
    "\n",
    "#OUTPUT:\n",
    "# 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 (GlobalAverag  (None, 1280)             0         \n",
    "#  ePooling2D)                                                     \n",
    "                                                                 \n",
    "#  dense (Dense)               (None, 101)               129381    \n",
    "                                                                 \n",
    "#  softmax_float32 (Activation  (None, 101)              0         \n",
    "#  )                                                               \n",
    "                                                                 \n",
    "# =================================================================\n",
    "# Total params: 4,178,952\n",
    "# Trainable params: 129,381\n",
    "# Non-trainable params: 4,049,571\n",
    "# _________________________________________________________________"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# How does the loaded model perform?\n",
    "results_loaded_gs_model = loaded_gs_model.evaluate(test_data)\n",
    "results_loaded_gs_model\n",
    "\n",
    "#OUTPUT:\n",
    "# 790/790 [==============================] - 77s 95ms/step - loss: 1.0881 - accuracy: 0.7066\n",
    "# [1.0880998373031616, 0.7066138386726379]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "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": {},
   "outputs": [],
   "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\")\n",
    "\n",
    "#OUTPUT:\n",
    "# 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\">"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before saving the Functional model to file, we created it with five layers (layers below are 0-indexed):\n",
    "\n",
    "0. The input layer\n",
    "1. The pre-trained base model layer (tf.keras.applications.efficientnet.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": {},
   "outputs": [],
   "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)\n",
    "\n",
    "#OUTPUT:\n",
    "# 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\">"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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",
    "> **IMPORTANT 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."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More Callbacks\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",
    "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)."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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",
    "There's one more callback we're going to implement: [`ReduceLROnPlateau`](https://www.tensorflow.org/api_docs/python/tf/keras/callbacks/ReduceLROnPlateau).\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",
    "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",
    "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": {},
   "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)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\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": {},
   "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\"])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's fit it on all of the data. We'll set it up to run for up to 100 epochs. Since we're going to be using the `EarlyStopping` callback, it might stop before reaching 100 epochs."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **IMPORTANT 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)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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\n",
    "\n",
    "\n",
    "#OUTPUT:\n",
    "# Saving TensorBoard log files to: training_logs/efficientb0_101_classes_all_data_fine_tuning/20230606-191211\n",
    "# Epoch 1/100\n",
    "# 2368/2368 [==============================] - ETA: 0s - loss: 0.9221 - accuracy: 0.7510WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 81). These functions will not be directly callable after loading.\n",
    "# 2368/2368 [==============================] - 481s 177ms/step - loss: 0.9221 - accuracy: 0.7510 - val_loss: 0.7731 - val_accuracy: 0.7860 - lr: 1.0000e-04\n",
    "# Epoch 2/100\n",
    "# 2368/2368 [==============================] - 366s 153ms/step - loss: 0.5790 - accuracy: 0.8395 - val_loss: 0.7936 - val_accuracy: 0.7887 - lr: 1.0000e-04\n",
    "# Epoch 3/100\n",
    "# 2368/2368 [==============================] - ETA: 0s - loss: 0.3309 - accuracy: 0.9071\n",
    "# Epoch 3: ReduceLROnPlateau reducing learning rate to 1.9999999494757503e-05.\n",
    "# 2368/2368 [==============================] - 365s 152ms/step - loss: 0.3309 - accuracy: 0.9071 - val_loss: 0.8302 - val_accuracy: 0.7892 - lr: 1.0000e-04\n",
    "# Epoch 4/100\n",
    "# 2368/2368 [==============================] - 363s 152ms/step - loss: 0.0861 - accuracy: 0.9788 - val_loss: 0.9283 - val_accuracy: 0.8051 - lr: 2.0000e-05"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **IMPORTANT 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"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the training loss is significantly lower than the validation loss, it's a hint that the model has overfit the training data and not learned generalizable patterns to unseen data.\n",
    "\n",
    "But it does look like our model has gained a few performance points from fine-tuning, let's evaluate on the whole test dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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": {},
   "outputs": [],
   "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\")\n",
    "\n",
    "#OUTPUT:\n",
    "# WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 81). These functions will not be directly callable after loading."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Download fine-tuned model from Google Storage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Unzip fine-tuned model\n",
    "# !mkdir downloaded_fine_tuned_gs_model # create separate directory for fine-tuned 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).model downloaded from Google Storage\n",
    "# !unzip 07_efficientnetb0_fine_tuned_101_classes_mixed_precision -d downloaded_fine_tuned_gs_model"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "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": {},
   "outputs": [],
   "source": [
    "# Load in fine-tuned model from Google Storage and evaluate\n",
    "loaded_fine_tuned_gs_model = tf.keras.models.load_model(\"07_efficientnetb0_fine_tuned_101_classes_mixed_precision\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get a model summary (same model architecture as above)\n",
    "loaded_fine_tuned_gs_model.summary()\n",
    "\n",
    "#OUTPUT:\n",
    "# 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 (GlobalAverag  (None, 1280)             0         \n",
    "#  ePooling2D)                                                     \n",
    "                                                                 \n",
    "#  dense (Dense)               (None, 101)               129381    \n",
    "                                                                 \n",
    "#  softmax_float32 (Activation  (None, 101)              0         \n",
    "#  )                                                               \n",
    "                                                                 \n",
    "# =================================================================\n",
    "# Total params: 4,178,952\n",
    "# Trainable params: 4,136,929\n",
    "# Non-trainable params: 42,023\n",
    "# _________________________________________________________________"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "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": {},
   "outputs": [],
   "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\n",
    "\n",
    "#OUTPUT:\n",
    "# 790/790 [==============================] - 57s 70ms/step - loss: 0.9275 - accuracy: 0.7979\n",
    "# [0.9275301098823547, 0.7979406118392944]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Excellent! Our saved model is performing as expected (better results than the DeepFood paper!).\n",
    "\n",
    "Thus, We have trained a computer vision model with competitive performance to a research paper and in far less time (our model took ~15 minutes to train versus DeepFood's quoted 2-3 days).\n",
    "\n",
    "We can also try using the [`EfficientNetB4`](https://www.tensorflow.org/api_docs/python/tf/keras/applications/EfficientNetB4) model (a larger version of `EfficientNetB0`)."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "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": {},
   "outputs": [],
   "source": [
    "# Upload experiment results to TensorBoard (uncomment to run)\n",
    "!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"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "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",
    "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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# View past TensorBoard experiments\n",
    "!tensorboard dev list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Delete past TensorBoard experiments\n",
    "!tensorboard dev delete --experiment_id OAE6KXizQZKQxDiqI3cnUQ"
   ]
  }
 ],
 "metadata": {
  "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.10"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}