transfer_learning_with_tensorflow_feature_extraction.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyPtWlEe4xFUxtnfZC3HFVXW",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/SaketMunda/transfer-learning-with-tensorflow/blob/master/transfer_learning_with_tensorflow_feature_extraction.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Transfer Learning with TensorFlow - Part 1 : Feature Extraction\n",
        "\n",
        "\n",
        "If you've been thinking, \"surely someone else has spent the time crafting the right model for the job...\" then you're in luck.\n",
        "\n",
        "For many of the problems, you'll want to use deep learning for, chances are, a working model already exists.\n",
        "\n",
        "And the good news is, you can access many of them on TensorFlow Hub.\n",
        "\n",
        "[TensorFlow Hub](https://tfhub.dev/) is a repository for existing model components. It makes it so you can import and use a fully trained model with as little as a URL.\n",
        "\n",
        "For this notebook we will experiment the Food Vision problem that we did in [this repo](https://github.com/SaketMunda/cnn-computer-vision-introduction) but with less data, to be specific only 10% of data for training set.\n",
        "\n",
        "Why ? **Transfer leanring often allows you to get great results with less data.**\n",
        "\n",
        "## Problem Definition\n",
        "\n",
        "We're working towards building, taking a pre-trained model and adding our own custom layers on top, extracting all of the underlying patterns learned on another dataset of our own images."
      ],
      "metadata": {
        "id": "HVt0lPEjIicm"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Downloading and becoming one with the data"
      ],
      "metadata": {
        "id": "sUlKKdSLLAZq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import zipfile\n",
        "\n",
        "# Download data\n",
        "!wget https://storage.googleapis.com/ztm_tf_course/food_vision/10_food_classes_10_percent.zip\n",
        "\n",
        "# unzip the downloaded data\n",
        "zip_ref = zipfile.ZipFile(\"10_food_classes_10_percent.zip\", \"r\")\n",
        "zip_ref.extractall()\n",
        "zip_ref.close()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KjcnvRz-LENA",
        "outputId": "acda7cfa-9e04-4e85-e48d-33f655dc8027"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--2022-12-09 06:58:20--  https://storage.googleapis.com/ztm_tf_course/food_vision/10_food_classes_10_percent.zip\n",
            "Resolving storage.googleapis.com (storage.googleapis.com)... 108.177.119.128, 108.177.126.128, 108.177.127.128, ...\n",
            "Connecting to storage.googleapis.com (storage.googleapis.com)|108.177.119.128|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 168546183 (161M) [application/zip]\n",
            "Saving to: ‘10_food_classes_10_percent.zip’\n",
            "\n",
            "10_food_classes_10_ 100%[===================>] 160.74M  41.6MB/s    in 4.7s    \n",
            "\n",
            "2022-12-09 06:58:25 (34.5 MB/s) - ‘10_food_classes_10_percent.zip’ saved [168546183/168546183]\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# How many images we have in each folder ?\n",
        "\n",
        "import os\n",
        "\n",
        "for dirpath, dirnames, filenames in os.walk('10_food_classes_10_percent'):\n",
        "  print(f\"There are {len(dirnames)} directories and {len(filenames)} images in '{dirpath}'\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QAqHWvUCLaVp",
        "outputId": "60a1d492-9880-41c2-cd77-f6823da0a039"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "There are 2 directories and 0 images in '10_food_classes_10_percent'\n",
            "There are 10 directories and 0 images in '10_food_classes_10_percent/test'\n",
            "There are 0 directories and 250 images in '10_food_classes_10_percent/test/hamburger'\n",
            "There are 0 directories and 250 images in '10_food_classes_10_percent/test/grilled_salmon'\n",
            "There are 0 directories and 250 images in '10_food_classes_10_percent/test/chicken_wings'\n",
            "There are 0 directories and 250 images in '10_food_classes_10_percent/test/chicken_curry'\n",
            "There are 0 directories and 250 images in '10_food_classes_10_percent/test/ice_cream'\n",
            "There are 0 directories and 250 images in '10_food_classes_10_percent/test/sushi'\n",
            "There are 0 directories and 250 images in '10_food_classes_10_percent/test/fried_rice'\n",
            "There are 0 directories and 250 images in '10_food_classes_10_percent/test/steak'\n",
            "There are 0 directories and 250 images in '10_food_classes_10_percent/test/ramen'\n",
            "There are 0 directories and 250 images in '10_food_classes_10_percent/test/pizza'\n",
            "There are 10 directories and 0 images in '10_food_classes_10_percent/train'\n",
            "There are 0 directories and 75 images in '10_food_classes_10_percent/train/hamburger'\n",
            "There are 0 directories and 75 images in '10_food_classes_10_percent/train/grilled_salmon'\n",
            "There are 0 directories and 75 images in '10_food_classes_10_percent/train/chicken_wings'\n",
            "There are 0 directories and 75 images in '10_food_classes_10_percent/train/chicken_curry'\n",
            "There are 0 directories and 75 images in '10_food_classes_10_percent/train/ice_cream'\n",
            "There are 0 directories and 75 images in '10_food_classes_10_percent/train/sushi'\n",
            "There are 0 directories and 75 images in '10_food_classes_10_percent/train/fried_rice'\n",
            "There are 0 directories and 75 images in '10_food_classes_10_percent/train/steak'\n",
            "There are 0 directories and 75 images in '10_food_classes_10_percent/train/ramen'\n",
            "There are 0 directories and 75 images in '10_food_classes_10_percent/train/pizza'\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Notice how each of the training directories now has 75 images rather than 750 images. This is the key to demonstrating how well transfer learning can perform with less labelled images.\n",
        "\n",
        "The test directories still have the same amount of images. This means we'll be training on less data but evaluating our models on the same amount of test data."
      ],
      "metadata": {
        "id": "j7fMMxArL19B"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Creating data loaders (preparing the data)\n",
        "\n",
        "Now we've downloaded the data, let's use the `ImageDateGenerator` class along with the `flow_from_directory` method to load in our images."
      ],
      "metadata": {
        "id": "agsNsTCbMNbW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Setup the data inputs\n",
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
        "\n",
        "IMG_SHAPE = (224, 224)\n",
        "BATCH_SIZE = 32\n",
        "\n",
        "train_dir = \"10_food_classes_10_percent/train/\"\n",
        "test_dir = \"10_food_classes_10_percent/test\"\n",
        "\n",
        "# Initiating ImageDataGenerator\n",
        "train_datagen = ImageDataGenerator(rescale=1/255.)\n",
        "test_datagen = ImageDataGenerator(rescale=1/255.)\n",
        "\n",
        "print(\"Training images:\")\n",
        "train_data_10_percent = train_datagen.flow_from_directory(train_dir,\n",
        "                                                          target_size=IMG_SHAPE,\n",
        "                                                          batch_size=BATCH_SIZE,\n",
        "                                                          class_mode=\"categorical\")\n",
        "\n",
        "print(\"Test images:\")\n",
        "test_data = test_datagen.flow_from_directory(test_dir,\n",
        "                                             target_size=IMG_SHAPE,\n",
        "                                             batch_size=BATCH_SIZE,\n",
        "                                             class_mode=\"categorical\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DNC5LCKZMbXV",
        "outputId": "a11ab599-567a-49cb-9621-43399d0c9789"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training images:\n",
            "Found 750 images belonging to 10 classes.\n",
            "Test images:\n",
            "Found 2500 images belonging to 10 classes.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Setting up callbacks (thing to run whilst training our model)\n",
        "\n",
        "Before we build a model, there's an important concept we're going to get familiar with because it's going to play a key role in our future model experiments.\n",
        "\n",
        "And that concept is **callbacks**.\n",
        "\n",
        "[Callbacks](https://www.tensorflow.org/api_docs/python/tf/keras/callbacks) are extra functionality you can add to your models to be performed during or after training. Some of the most popular callbacks include:\n",
        "\n",
        "- [Experiment tracking with TensorBoard](https://www.tensorflow.org/api_docs/python/tf/keras/callbacks/TensorBoard) - log the performance of multiple models and then view and compare these models in a visual way on [TensorBoard](https://www.tensorflow.org/tensorboard)(a dashboard for inspecting neural network parameters). Helpful to compare the results of different models on your data.\n",
        "- [Model Checkpoints](https://www.tensorflow.org/api_docs/python/tf/keras/callbacks/ModelCheckpoint) - save your model as it trains so you can stop training if needed and come back to continue off where you left. Helpful if training takes a long time and can't be done in one sitting.\n",
        "- [Early Stopping](https://www.tensorflow.org/api_docs/python/tf/keras/callbacks/EarlyStopping) - leave your model training for an arbitrary amount of time and have it stop training automatically when it ceases to improve. Helpful when you've got a large dataset and don't know how long training will take.\n",
        "\n",
        "\n",
        "The Tensorboard callback can be accessed using `tf.keras.callbacks.TensorBoard()`.\n",
        "\n",
        "It's main functionality is saving a model's training performance metrics to a specified `log_dir`.\n",
        "\n",
        "To track our modelling experiments using TensorBoard, let's create a function which creates a TensorBoard callback for us.\n",
        "\n",
        "> **Note**: We create a function for creating a TensorBoard callback because as we'll see later on, each model needs its own TensorBoard callback instance(so the function will create a new one each time it's run).\n"
      ],
      "metadata": {
        "id": "kT4_1hd8Nfw7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# CReate tensorboard callback (functionized because need to create a new one for each model)\n",
        "import datetime\n",
        "import tensorflow\n",
        "def create_tensorboard_callback(dir_name, experiment_name):\n",
        "  log_dir = dir_name + \"/\" + experiment_name + \"/\" + datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\")\n",
        "  tensorboard_callback = tensorflow.keras.callbacks.TensorBoard(\n",
        "      log_dir = log_dir\n",
        "  )\n",
        "  print(f\"Saving TensorBoard log files to: {log_dir}\")\n",
        "  return tensorboard_callback"
      ],
      "metadata": {
        "id": "ALRSx1QNPoZx"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Because we're going to run multiple experiments, it's a good idea to be able to track them in some way.\n",
        "\n",
        "In our case, our function save a model's performace logs to a directory named,\n",
        "`[dir_name]/[experiment_name]/[current_timestamp]`\n"
      ],
      "metadata": {
        "id": "oP_gyQaqQV9g"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Creating models using TensorFlow Hub\n",
        "\n",
        "In the past we've used TensorFlow to create our own models layer by layer from scratch.\n",
        "\n",
        "Now we're going to do a similar process, except the majority of our model's layers are going to come from `TensorFlow Hub`.\n",
        "\n",
        "In fact, we're going to use two models from TensorFlow Hub:\n",
        "* [ResNet50V2](https://arxiv.org/abs/1603.05027) : a state of art computer vision model architecture from 2016\n",
        "* [EfficientNetB0](https://arxiv.org/abs/1905.11946) : a state of art computer vision model architecture from 2019\n",
        "\n",
        "State of the art means that at some point, both of these models have achieved the lowest error rate on [ImageNet (ILSVRC-2012-CLS)](http://www.image-net.org/), the gold standard of computer vision benchmarks.\n",
        "\n",
        "We can see a list of state of the art models on [paperwithcode.com](https://www.paperswithcode.com/), a resource for collecting the latest in deep learning paper results which have code implementations for the findings they report.\n",
        "\n",
        "Since, we're working with images, our target are the [models which performs best on ImageNet](https://paperswithcode.com/sota/image-classification-on-imagenet).\n",
        "\n",
        "Let's build our model using the above said models from TensorFlow Hub.\n",
        "\n",
        "First we'll import TensorFlow and TensorFlow Hub."
      ],
      "metadata": {
        "id": "27ZdprOfgfzg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow as tf\n",
        "import tensorflow_hub as hub\n",
        "from tensorflow.keras import layers"
      ],
      "metadata": {
        "id": "K7_ujmFhicXd"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now we'll get feature vector URLs of two common computer vision architectures, [EfficientNetB0(2019)](https://tfhub.dev/tensorflow/efficientnet/b0/feature-vector/1) and [ResNetV250(2016)](https://tfhub.dev/google/imagenet/resnet_v2_50/feature_vector/4) from TensorFlow Hub"
      ],
      "metadata": {
        "id": "BNUbIHVjijWP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Resnet50V2 feature vector\n",
        "resnet_url = \"https://tfhub.dev/google/imagenet/resnet_v2_50/feature_vector/4\"\n",
        "\n",
        "# EfficientNetB0 feature vector\n",
        "efficientnet_url = \"https://tfhub.dev/tensorflow/efficientnet/b0/feature-vector/1\""
      ],
      "metadata": {
        "id": "8Kdl_yJli4Ja"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "These URLs link to a saved pretrained model on TensorFlow Hub.\n",
        "\n",
        "When we use them in our model, the model will automatically be downloaded for us to use.\n",
        "\n",
        "To do this, we can use the `KerasLayer()` model inside the TensorFlow Hub library.\n",
        "\n",
        "Since we're going to be comparing two models, to save ourselves code, we'll create a function `create_model()`. This function will take a model's TensorFlow Hub URL, instantiate a Keras Sequential model with the appropriate number of output layers, compile the model and return the model."
      ],
      "metadata": {
        "id": "zabEv7dpjbFr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def create_model(model_url, num_classes=10):\n",
        "  \"\"\"\n",
        "  Takes a TensorFlow Hub URL and creates a Keras Sequential model with it.\n",
        "\n",
        "  Args:\n",
        "    model_url(str): A TensorFlow Hub feature extraction URL.\n",
        "    num_classes(int): Number of output neurons in output layer, should be equal\n",
        "    to number of target classes, default 10.\n",
        "  Returns:\n",
        "    A compiled Keras Sequential model with model_url as feature\n",
        "    extractor layer and Dense output layer with num_classes outputs.\n",
        "  \"\"\"\n",
        "\n",
        "  # Download the pretrained model and save it as Keras layer\n",
        "  feature_extractor_layer = hub.KerasLayer(model_url,\n",
        "                                           trainable=False, # freeze the underlying patterns\n",
        "                                           name='feature_extraction_layer',\n",
        "                                           input_shape=IMG_SHAPE+(3,)) # define the input image shape\n",
        "\n",
        "  # Create our own model\n",
        "  model = tf.keras.Sequential([\n",
        "      feature_extractor_layer, # use feature extraction layer as the base\n",
        "      layers.Dense(num_classes, activation='softmax', name='output_layer') # create our own output layer\n",
        "  ])\n",
        "\n",
        "  # compile our model\n",
        "  model.compile(loss=tf.keras.losses.CategoricalCrossentropy(),\n",
        "                optimizer='Adam',\n",
        "                metrics=['accuracy'])\n",
        "  \n",
        "  return model"
      ],
      "metadata": {
        "id": "do94rx1Tm862"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Great ! Now we've got a function for creating a model, we'll use it to first create and compile a model using Resnet50V2 architecture as our feature extraction compiled model.\n",
        "\n",
        "Then we'll fit the model with our own training data and test data and also use the callbacks."
      ],
      "metadata": {
        "id": "JBSkXO8nowVZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create and Compile a model\n",
        "resnet_model = create_model(model_url=resnet_url,\n",
        "                            num_classes=train_data_10_percent.num_classes)\n",
        "\n",
        "# Fit the model\n",
        "resnet_history = resnet_model.fit(train_data_10_percent,\n",
        "                                  epochs=5,\n",
        "                                  steps_per_epoch=len(train_data_10_percent),\n",
        "                                  validation_data=test_data,\n",
        "                                  validation_steps=len(test_data),\n",
        "                                  callbacks=[create_tensorboard_callback(dir_name='tensorflow_hub',\n",
        "                                                                         experiment_name='resnet50V2')])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PF92H1oMpRHo",
        "outputId": "73cff044-b3dc-4b6b-8153-fd9244553a57"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving TensorBoard log files to: tensorflow_hub/resnet50V2/20221209-065840\n",
            "Epoch 1/5\n",
            "24/24 [==============================] - 33s 948ms/step - loss: 2.0681 - accuracy: 0.3000 - val_loss: 1.2714 - val_accuracy: 0.5788\n",
            "Epoch 2/5\n",
            "24/24 [==============================] - 25s 1s/step - loss: 0.9260 - accuracy: 0.7227 - val_loss: 0.8960 - val_accuracy: 0.7064\n",
            "Epoch 3/5\n",
            "24/24 [==============================] - 17s 735ms/step - loss: 0.6290 - accuracy: 0.8200 - val_loss: 0.7857 - val_accuracy: 0.7404\n",
            "Epoch 4/5\n",
            "24/24 [==============================] - 18s 764ms/step - loss: 0.4878 - accuracy: 0.8800 - val_loss: 0.7212 - val_accuracy: 0.7580\n",
            "Epoch 5/5\n",
            "24/24 [==============================] - 17s 737ms/step - loss: 0.3861 - accuracy: 0.9080 - val_loss: 0.6915 - val_accuracy: 0.7700\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Wow !\n",
        "\n",
        "It seems that after only 5 epochs, the ResNet50V2 feature extraction model was able to blow any of the architectures we made out of the water, achieving around 90% accuracy on the training set and nearly 80% accuracy on the test set...**with only 10 percent of the training images!**\n",
        "\n",
        "That goes to show the power of transfer learning. And it's one of the main reasons whenever you're trying to model your own datasets, you should look into what pretrained models already exist.\n",
        "\n",
        "Let's check out our model's training curves using our `plot_loss_curves` function."
      ],
      "metadata": {
        "id": "XTrKkgc6qDpW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Plot the validation and training data separately\n",
        "def plot_loss_curves(history):\n",
        "  \"\"\"\n",
        "  Returns separate loss curves for training and validation metrics.\n",
        "  \"\"\"\n",
        "  loss = history.history['loss']\n",
        "  val_loss = history.history['val_loss']\n",
        "\n",
        "  accuracy = history.history['accuracy']\n",
        "  val_accuracy = history.history['val_accuracy']\n",
        "\n",
        "  epochs = range(len(history.history['loss']))\n",
        "\n",
        "  # Plot loss\n",
        "  plt.plot(epochs, loss, label='Training_loss')\n",
        "  plt.plot(epochs, val_loss, label='val_loss')\n",
        "  plt.title('Loss')\n",
        "  plt.xlabel('Epochs')\n",
        "  plt.legend()\n",
        "\n",
        "  plt.figure()\n",
        "\n",
        "  # Plot accuracy\n",
        "  plt.plot(epochs, accuracy, label='training accuracy')\n",
        "  plt.plot(epochs, val_accuracy, label='val_accuracy')\n",
        "  plt.title('Accuracy')\n",
        "  plt.xlabel('Epochs')\n",
        "  plt.legend(); "
      ],
      "metadata": {
        "id": "iGWjxMzHrgdL"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plot_loss_curves(resnet_history)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 573
        },
        "id": "JZDLu5FVsf7r",
        "outputId": "9c9e09dd-c917-4853-e014-bb6f09b7b0c7"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "And what about a summary of our model ?"
      ],
      "metadata": {
        "id": "_thn7yUMsjnX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "resnet_model.summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rT3gQPQMso9f",
        "outputId": "e5bec528-b51d-4556-8d1a-78e4cf97b1e3"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " feature_extraction_layer (K  (None, 2048)             23564800  \n",
            " erasLayer)                                                      \n",
            "                                                                 \n",
            " output_layer (Dense)        (None, 10)                20490     \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 23,585,290\n",
            "Trainable params: 20,490\n",
            "Non-trainable params: 23,564,800\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "You can see the power of TensorFlow Hub here. The feature extraction layer has 23,585,800 parameters which are prelearned patterns the model has already learned on the ImageNet dataset.\n",
        "Since we set `trainable=False`, these patterns remain frozen(non-trainable) during training.\n",
        "\n",
        "This means during training the model updates the 20,490 parameters in the output layer to suit our dataset.\n",
        "\n",
        "\n",
        "Now we've trained the Resnet50V2 model, time to do the same with EfficientNetB0 model."
      ],
      "metadata": {
        "id": "dGywAcRksqhC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create and compile model\n",
        "efficientnet_model = create_model(efficientnet_url,\n",
        "                                  train_data_10_percent.num_classes)\n",
        "\n",
        "# fit the model\n",
        "efficientnet_history = efficientnet_model.fit(train_data_10_percent,\n",
        "                                              epochs=5,\n",
        "                                              steps_per_epoch=len(train_data_10_percent),\n",
        "                                              validation_data=test_data,\n",
        "                                              validation_steps=len(test_data),\n",
        "                                              callbacks=[\n",
        "                                                  create_tensorboard_callback(dir_name='tensorflow_hub',\n",
        "                                                                               experiment_name='efficientnetb0')\n",
        "                                              ])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p3AdPDtStf9J",
        "outputId": "83c65df1-148f-4d76-ebd7-c7348581a66f"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving TensorBoard log files to: tensorflow_hub/efficientnetb0/20221209-071049\n",
            "Epoch 1/5\n",
            "24/24 [==============================] - 26s 726ms/step - loss: 1.8454 - accuracy: 0.4307 - val_loss: 1.2916 - val_accuracy: 0.7480\n",
            "Epoch 2/5\n",
            "24/24 [==============================] - 17s 716ms/step - loss: 1.0734 - accuracy: 0.7867 - val_loss: 0.8647 - val_accuracy: 0.8216\n",
            "Epoch 3/5\n",
            "24/24 [==============================] - 16s 667ms/step - loss: 0.7574 - accuracy: 0.8373 - val_loss: 0.6943 - val_accuracy: 0.8420\n",
            "Epoch 4/5\n",
            "24/24 [==============================] - 16s 670ms/step - loss: 0.6088 - accuracy: 0.8640 - val_loss: 0.6076 - val_accuracy: 0.8512\n",
            "Epoch 5/5\n",
            "24/24 [==============================] - 16s 671ms/step - loss: 0.5159 - accuracy: 0.8880 - val_loss: 0.5501 - val_accuracy: 0.8628\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The EfficientNetB0 model does even better than ResNet50V2 model! Achieving over 85% accuracy on the test set.. again with only 10% of the training data.\n",
        "\n",
        "With a couple of lines of code we're able to leverage state of the art models and adjust them to our own use case.\n",
        "\n",
        "let's check out the loss curves."
      ],
      "metadata": {
        "id": "z1zlIA9VuI0a"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plot_loss_curves(efficientnet_history)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 573
        },
        "id": "NlAI51U7w82s",
        "outputId": "08dfd59d-5e6c-40cd-fb7f-12632ac7e234"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "From the look of the EfficientNetB0 model's loss curves, it looks like if we kept training for longer, the validation accuracy will increase hence improve our model even more for our use case.\n",
        "\n",
        "Let's check out the model summary."
      ],
      "metadata": {
        "id": "cOk6Drxiw_4r"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "efficientnet_model.summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eFhXqxLexUZS",
        "outputId": "56d87c95-edf9-4bf7-b9db-5e2f436b13f3"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_2\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " feature_extraction_layer (K  (None, 1280)             4049564   \n",
            " erasLayer)                                                      \n",
            "                                                                 \n",
            " output_layer (Dense)        (None, 10)                12810     \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 4,062,374\n",
            "Trainable params: 12,810\n",
            "Non-trainable params: 4,049,564\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "It seems that, despite having over four times less parameters (4,049,564 vs 23,564,800) than the ResNet50V2 extraction layer, the EfficientNetB0 feature extraction layer yields better performance. Now it's clear where the 'efficient' name came from."
      ],
      "metadata": {
        "id": "NTIFSiHbxWZJ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Types of Transfer Learning\n",
        "\n",
        "1. **\"As is\" transfer learning** is when you take a pretrained model as it is and apply it to your task without any changes.\n",
        "  - For example, many compVis models are pretrained on the ImageNet dataset which contains 1000 different classes of images. This means passing a single image to this model will produce 1000 different prediction probability values (1 for each class).\n",
        "    - This is helpful if you have 1000 classes of image you'd like to classify and they're all the same as the ImageNet classes, however, it;s not helpful if you want to classify only a small subset of classes (such as 10 different kinds of food). Models with `/classification` in their name on TensorFlow Hub provide this kind of functionality.\n",
        "2. **\"Feature Extraction\" transfer learning** is when you take the underlying patterns (also called weights) a pretrained model has learned and adjust its outputs to be more suited to your problem.\n",
        "  - For eg, say the pretrained model you were using had 236 different layers(EfficientNetB0 has 236 layers), but the top layer outputs 1000 classes because it was pretrained on ImageNet. To adjust this to your own problem, you might remove the original activation layer and replace it with your own but with the right number of output classes. The important part here is that **only the top few layers become trainable, the rest remain frozen.**\n",
        "3. **\"Fine-Tuning\" transfer learning** is when you take the underlying patterns (also called weights) of a pretrained model and adjust(fine-tune) them to your own problem.\n",
        "  - This usually means training **some, many or all** of the layers in the pretrained model. This is useful when you've got a large dataset (e.g 100+ images per class) where your data is slightly different to the data the original model was trained on."
      ],
      "metadata": {
        "id": "K94f2EKY1UOc"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Comparing models using TensorBoard\n",
        "\n",
        "Alright, event though we've already compared the performance of our two models by looking at the accuracy scores. But what if you had more than two models ?\n",
        "\n",
        "That's where an experiment tracking tool like [TensorBoard](https://www.tensorflow.org/tensorboard) comes in.\n",
        "\n",
        "The good thing is, since we setup a TensorBoard callback, all of our model's training logs have been saved automatically. To visualize them, we can upload the results to [TensorBoard.dev](https://tensorboard.dev/)\n",
        "\n",
        "Uploading your results to TensorBoard.dev enables you to track and share multiple different modelling experiments. So if you needed to show someone your results, you could send them a link to your TensorBoard.dev as well as the accompaning Colab Notebook."
      ],
      "metadata": {
        "id": "pajFLLcDxqcc"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Uploading experiments to TensorBoard\n",
        "\n",
        "To upload a series of TensorFlow logs to Tensorboard, we can use the following command:"
      ],
      "metadata": {
        "id": "2e-upqcKyltw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!tensorboard dev upload --logdir ./tensorflow_hub/ \\\n",
        "  --name \"EfficientNetB0 Vs ResNet50V2\" \\\n",
        "  --description \"Comparing two different TF hub feature extraction models architecture using 10% of training images\" \\\n",
        "  --one_shot # this is to exit"
      ],
      "metadata": {
        "id": "vqWjzccSyvlu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "TensorBoard Experiment URL : https://tensorboard.dev/experiment/PFzAwQrlS1eXwkNwq3bZ4w/"
      ],
      "metadata": {
        "id": "jLQFCjcnzVEB"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "In above execution code,\n",
        "* `--logdir` is the target upload directory\n",
        "* `--name` is the name of the experiment\n",
        "* `--description` is the description\n",
        "* `--one_shot` exits the TensorBoard uploader once uploading is finished"
      ],
      "metadata": {
        "id": "lGiG8-x1z18U"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Listing experiments you've saved to TensorBoard\n",
        "\n",
        "To see all the experiments you've uploaded you can use the command:\n",
        "`tensorboard dev list`"
      ],
      "metadata": {
        "id": "6Fp1Mgqkzzlc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!tensorboard dev list"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wnInR7mn05Vg",
        "outputId": "519d5662-74f7-4429-a74c-f7e079c8dc92"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "https://tensorboard.dev/experiment/PFzAwQrlS1eXwkNwq3bZ4w/\n",
            "\tName                 EfficientNetB0 Vs ResNet50V2\n",
            "\tDescription          Comparing two different TF hub feature extraction models architecture using 10% of training images\n",
            "\tId                   PFzAwQrlS1eXwkNwq3bZ4w\n",
            "\tCreated              2022-12-09 07:33:32 (6 minutes ago)\n",
            "\tUpdated              2022-12-09 07:33:36 (6 minutes ago)\n",
            "\tRuns                 4\n",
            "\tTags                 5\n",
            "\tScalars              60\n",
            "\tTensor bytes         0\n",
            "\tBinary object bytes  5918466\n",
            "Total: 1 experiment(s)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Deleting experiment from Tensorboard\n",
        "\n",
        "Remember, all uploads to TensorBoard.dev are public, so to delete an experiment you can use the command:\n",
        "\n",
        "`tensorboard dev delete --experiment_id [INSERT_EXPERIMENT_ID]`"
      ],
      "metadata": {
        "id": "Xc002M1w067e"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Q5VpIAwq1OSG"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}