section4.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyPc+O/e3cGNv1pzqqCspzf9",
      "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/GustaFTW/TensorFlow-ZTM/blob/main/section4.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",
        "Transfer learning is leveraging a working model's existing architecture and learned patterns for our own problem.\n",
        "\n",
        "There are two main benefits:\n",
        "1. Can leverage an existing neural network architecture proven to work on problems similar to our own.\n",
        "2. Can leverage a working neural network architecture which has already learned patterns on similar data to our own, then we can adapt those patterns to our own data."
      ],
      "metadata": {
        "id": "kGTSotSby382"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Are we using a GPU?\n",
        "!nvidia-smi"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LiFxYYhO3jgb",
        "outputId": "d04ffc6c-563a-4f16-8721-220dc3cc6f5b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mon Dec 12 15:06:01 2022       \n",
            "+-----------------------------------------------------------------------------+\n",
            "| NVIDIA-SMI 460.32.03    Driver Version: 460.32.03    CUDA Version: 11.2     |\n",
            "|-------------------------------+----------------------+----------------------+\n",
            "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
            "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
            "|                               |                      |               MIG M. |\n",
            "|===============================+======================+======================|\n",
            "|   0  Tesla T4            Off  | 00000000:00:04.0 Off |                    0 |\n",
            "| N/A   54C    P0    28W /  70W |      0MiB / 15109MiB |      0%      Default |\n",
            "|                               |                      |                  N/A |\n",
            "+-------------------------------+----------------------+----------------------+\n",
            "                                                                               \n",
            "+-----------------------------------------------------------------------------+\n",
            "| Processes:                                                                  |\n",
            "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n",
            "|        ID   ID                                                   Usage      |\n",
            "|=============================================================================|\n",
            "|  No running processes found                                                 |\n",
            "+-----------------------------------------------------------------------------+\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Downloading and becoming one with the data"
      ],
      "metadata": {
        "id": "Ki89PjN23vXb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Get data (10% of 10 food classes from Food101)\n",
        "import zipfile\n",
        "\n",
        "# Download the data\n",
        "!wget https://storage.googleapis.com/ztm_tf_course/food_vision/10_food_classes_10_percent.zip\n",
        "\n",
        "# Unzip the downloaded file\n",
        "zip_ref = zipfile.ZipFile(\"10_food_classes_10_percent.zip\")\n",
        "zip_ref.extractall()\n",
        "zip_ref.close()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "onZsbHI7311q",
        "outputId": "6175214d-943c-46d9-a11a-ff6fe96f25c4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--2022-12-12 15:08:05--  https://storage.googleapis.com/ztm_tf_course/food_vision/10_food_classes_10_percent.zip\n",
            "Resolving storage.googleapis.com (storage.googleapis.com)... 173.194.202.128, 74.125.20.128, 74.125.197.128, ...\n",
            "Connecting to storage.googleapis.com (storage.googleapis.com)|173.194.202.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.1’\n",
            "\n",
            "10_food_classes_10_ 100%[===================>] 160.74M   220MB/s    in 0.7s    \n",
            "\n",
            "2022-12-12 15:08:06 (220 MB/s) - ‘10_food_classes_10_percent.zip.1’ saved [168546183/168546183]\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# How many images in each folder?\n",
        "import os\n",
        "\n",
        "# Walk through 10 percent data directory and list number of files\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": "LnsnWCge4MuU",
        "outputId": "e145de9b-8b98-4708-f49f-9ecaad52c3f8"
      },
      "execution_count": null,
      "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/grilled_salmon'\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/chicken_wings'\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/ramen'\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/fried_rice'\n",
            "There are 0 directories and 250 images in '10_food_classes_10_percent/test/pizza'\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/steak'\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/grilled_salmon'\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/chicken_wings'\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/ramen'\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/fried_rice'\n",
            "There are 0 directories and 75 images in '10_food_classes_10_percent/train/pizza'\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/steak'\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Creating data loaders (preparing the data)\n",
        "\n",
        "We'll use the `ImageDataGenerator` class to load in our images in batches."
      ],
      "metadata": {
        "id": "SkdXxhxx4qFr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Setup data inputs\n",
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
        "\n",
        "IMG_SHAPE = (224, 224)\n",
        "BATCH_SIZE = 32\n",
        "\n",
        "\n",
        "train_dir = \"10_food_classes_10_percent/train/\"\n",
        "test_dir = \"10_food_classes_10_percent/test/\"\n",
        "\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",
        "print(\"Testing 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": "svAmzuTO5mVt",
        "outputId": "72faeee4-7d32-4a03-b2ff-a5d129c1c4be"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training images: \n",
            "Found 750 images belonging to 10 classes.\n",
            "Testing images: \n",
            "Found 2500 images belonging to 10 classes.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Setting up callbacks (things to run whilst \n",
        "our model trains)\n",
        "\n",
        "Callbacks are extra functionality you can add to your models to be performed during or after training. Some of the most popular callbacks:\n",
        "\n",
        "* Tracking experiments with the TensorBoard callback\n",
        "* Model checkpoint with the ModelCheckpoint callback\n",
        "* Stopping a model from training (before it trains too long and overfits) with the EarlyStopping callback"
      ],
      "metadata": {
        "id": "yzM90SN76jrr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create TensorBoard callback (functionized because we need to create a new one for each model)\n",
        "import datetime\n",
        "import tensorflow as tf\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 = tf.keras.callbacks.TensorBoard(log_dir=log_dir)\n",
        "    print(f\"Saving TensorBoard log files to: {log_dir}\")\n",
        "    return tensorboard_callback"
      ],
      "metadata": {
        "id": "-Lo5W-8X7Ltd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "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 simlar process, except the majority of our model's layers are going to come f rom TensorFlow Hub\n",
        "\n",
        "We can access pretrained models on: https://tfhub.dev/\n",
        "\n",
        "Browsing the TensorFlow Hub page and sorting for image classification, we found the following featre vector model link:\n",
        "https://tfhub.dev/tensorflow/efficientnet/b0/feature-vector/1\n"
      ],
      "metadata": {
        "id": "3hRF-NeG893X"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Let's compare the following two model\n",
        "resnet_url = \"https://tfhub.dev/google/imagenet/resnet_v2_50/feature_vector/4\"\n",
        "\n",
        "efficientnet_url = \"https://tfhub.dev/tensorflow/efficientnet/b0/feature-vector/1\""
      ],
      "metadata": {
        "id": "3nFETnCv9Saf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Import dependencies\n",
        "import tensorflow as tf\n",
        "import tensorflow_hub as hub\n",
        "from tensorflow.keras import layers"
      ],
      "metadata": {
        "id": "mGywhZwTAM8p"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Let's make a create_model() function to create a model from a URL\n",
        "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 the output layer,\n",
        "      should be equal to number of target classes, default10.\n",
        "    \n",
        "    Return:\n",
        "      An uncompiled Keras Sequential model with model_url as feature extractor \n",
        "      layer and Dense output layer With num_classes output neurons.\n",
        "    \"\"\"\n",
        "\n",
        "    # Download the pretrained model and save it as a Keras layer\n",
        "    feature_extraction_layer = hub.KerasLayer(model_url, \n",
        "                                              trainable=False, # freeze the already learned patterns\n",
        "                                              name=\"feature_extraction_layer\",\n",
        "                                              input_shape=IMG_SHAPE+(3,))\n",
        "    \n",
        "    # Create our own model\n",
        "    model = tf.keras.Sequential([\n",
        "        feature_extraction_layer,\n",
        "        layers.Dense(num_classes, activation=\"softmax\", name=\"output_layer\")\n",
        "    ])\n",
        "\n",
        "    return model"
      ],
      "metadata": {
        "id": "fc1zOVacAnSY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Creating and testing ResNet TensorFlow Hub Feature Extraction model"
      ],
      "metadata": {
        "id": "24HHWtlGCDZh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create Resnet model\n",
        "resnet_model = create_model(resnet_url,\n",
        "                      num_classes=train_data_10_percent.num_classes)"
      ],
      "metadata": {
        "id": "MxTzp8Z4B9LX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Compile our resnet model\n",
        "resnet_model.compile(loss=\"CategoricalCrossentropy\",\n",
        "                     optimizer=\"adam\",\n",
        "                     metrics=[\"accuracy\"])"
      ],
      "metadata": {
        "id": "2jOpZqJtCVt5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "resnet_model.summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cD6SAuerCvjM",
        "outputId": "867a6a77-b501-494e-afaa-956d57dee532"
      },
      "execution_count": null,
      "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": "code",
      "source": [
        "# Let's fit our ResNet model to the data (10 percent of 10 classes)\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(\"tensorflow_hub\", \"resnet50V2\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iZf3gGjTDL47",
        "outputId": "0498d3a1-3c5a-45ff-b062-5644e80027c6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving TensorBoard log files to: tensorflow_hub/resnet50V2/20221212-160204\n",
            "Epoch 1/5\n",
            "24/24 [==============================] - 16s 685ms/step - loss: 0.3112 - accuracy: 0.9453 - val_loss: 0.6722 - val_accuracy: 0.7788\n",
            "Epoch 2/5\n",
            "24/24 [==============================] - 16s 687ms/step - loss: 0.2634 - accuracy: 0.9573 - val_loss: 0.6472 - val_accuracy: 0.7824\n",
            "Epoch 3/5\n",
            "24/24 [==============================] - 16s 679ms/step - loss: 0.2240 - accuracy: 0.9693 - val_loss: 0.6437 - val_accuracy: 0.7884\n",
            "Epoch 4/5\n",
            "24/24 [==============================] - 16s 674ms/step - loss: 0.1902 - accuracy: 0.9787 - val_loss: 0.6320 - val_accuracy: 0.7860\n",
            "Epoch 5/5\n",
            "24/24 [==============================] - 16s 681ms/step - loss: 0.1668 - accuracy: 0.9827 - val_loss: 0.6368 - val_accuracy: 0.7836\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Wow!\n",
        "\n",
        "That's incredible, our transfer learning feature extractor model out performed ALL of the previoues models we built by hand... and in a quicker training time AND with only 10% of the training examples."
      ],
      "metadata": {
        "id": "vKxVfrGHFoLP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Let's create a function to plot our loss curves...\n",
        "# Tidbit: you could put a function like this into a script called \"helper.py\" and import it when you need it...\n",
        "import matplotlib.pyplot as plt\n",
        "def plot_loss_curves(history):\n",
        "    \n",
        "    \n",
        "    \"\"\"\n",
        "    Returns separate loss curves for training and validation metrics.\n",
        "    \"\"\"\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\"])) # how many epochs we ran through\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",
        "    # Plot accuracy\n",
        "    plt.figure()\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()\n"
      ],
      "metadata": {
        "id": "aocEM6x7F8Z7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plot_loss_curves(resnet_history)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 573
        },
        "id": "mtGmqgDqGJON",
        "outputId": "97c4e16d-5375-4193-affe-9c1d37af7cba"
      },
      "execution_count": null,
      "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": [
        "### Creating and testing EfficientNetB0 TensorFlow Hub Feature Extraction model"
      ],
      "metadata": {
        "id": "6lK1K43AGRyu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create EfficientNetB0 TensorFlow Hub Feature Extraction Model\n",
        "efficient_net = create_model(efficientnet_url,\n",
        "                      num_classes=train_data_10_percent.num_classes)"
      ],
      "metadata": {
        "id": "jbwskC0VHC9X"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Compile EfficientNet model\n",
        "efficient_net.compile(loss=\"CategoricalCrossentropy\",\n",
        "                      optimizer=\"Adam\",\n",
        "                      metrics=[\"Accuracy\"])"
      ],
      "metadata": {
        "id": "kd3hlHHNHmnV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Fit EfficientNet model\n",
        "efficientnet_history = efficient_net.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(\"tensorflow_hub\", \"efficientnetb0\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eWV4-0KOIB0c",
        "outputId": "7b1357d7-8ec1-41a9-de5c-92e5762a18bb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving TensorBoard log files to: tensorflow_hub/efficientnetb0/20221212-161928\n",
            "Epoch 1/5\n",
            "24/24 [==============================] - 26s 738ms/step - loss: 1.8351 - Accuracy: 0.4200 - val_loss: 1.2724 - val_Accuracy: 0.7384\n",
            "Epoch 2/5\n",
            "24/24 [==============================] - 16s 686ms/step - loss: 1.0450 - Accuracy: 0.7653 - val_loss: 0.8516 - val_Accuracy: 0.8276\n",
            "Epoch 3/5\n",
            "24/24 [==============================] - 15s 659ms/step - loss: 0.7460 - Accuracy: 0.8360 - val_loss: 0.6896 - val_Accuracy: 0.8492\n",
            "Epoch 4/5\n",
            "24/24 [==============================] - 17s 741ms/step - loss: 0.6019 - Accuracy: 0.8640 - val_loss: 0.6045 - val_Accuracy: 0.8596\n",
            "Epoch 5/5\n",
            "24/24 [==============================] - 15s 665ms/step - loss: 0.5076 - Accuracy: 0.8933 - val_loss: 0.5533 - val_Accuracy: 0.8620\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plot_loss_curves(efficientnet_history)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 573
        },
        "id": "nMgQ6kcUIko7",
        "outputId": "433982ba-3709-4e7c-805b-2ad20ce3bfc3"
      },
      "execution_count": null,
      "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": "code",
      "source": [
        "efficient_net.summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BM_NrofoLJHP",
        "outputId": "63aaf31c-f305-46ac-8bcf-35fd4e938341"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_1\"\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": "code",
      "source": [
        "resnet_model.summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tRqbfWfbJgCN",
        "outputId": "8e75215a-7c16-4e69-ba5c-2695cd5490ed"
      },
      "execution_count": null,
      "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": "code",
      "source": [
        "# How many layers does our efficientnetb0 feature extractor have?\n",
        "len(efficient_net.layers[0].weights)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "W8FH11S9MdFi",
        "outputId": "eee4076d-536d-4239-c42b-d9f506941350"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "309"
            ]
          },
          "metadata": {},
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Different types of transfer learning\n",
        "\n",
        "* **\"As is\" transfer learning** - using an existing model with no chages whatsoever (e.g using ImageNet model on 1000 ImageNet classes, none of your own)\n",
        "* **\"Feature extraction\" transfer learning** - use the prelearned patterns of an existing model (e.g EfficientNetB0 trained on ImageNet) and adjust the output layer for your own problem (e.g 1000 classes -> 10 classes of food)\n",
        "* **\"Fine-tuning\" transfer learning** - use the prelearned patterns of an existing model and \"fine-tune\" many or all of the underlying layers (including new output layers)"
      ],
      "metadata": {
        "id": "FB_3DlAoLUog"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Comparing our models results using TensorBoard\n",
        "\n",
        "> **Note:** When you upload things to TensorBoard.dev, you experiments are public. So if you're running private experiments (things you don't want other to see) do not upload them to TensorBoard.dev"
      ],
      "metadata": {
        "id": "uykMk6PMMBFq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Upload TensorBoard dev records\n",
        "!tensorboard dev upload --logdir ./tensorflow_hub/ \\\n",
        " --name \"EfficientNetB0 vs. ResNet50V2\" \\\n",
        " --description \"Comparing two different TF Hub feature extraction model architectures using 10% of the training data\" \\\n",
        " --one_shot"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FBXckKpON3gH",
        "outputId": "7ae5f265-cbef-42fd-f2ec-837d6d4cd0e3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "***** TensorBoard Uploader *****\n",
            "\n",
            "This will upload your TensorBoard logs to https://tensorboard.dev/ from\n",
            "the following directory:\n",
            "\n",
            "./tensorflow_hub/\n",
            "\n",
            "This TensorBoard will be visible to everyone. Do not upload sensitive\n",
            "data.\n",
            "\n",
            "Your use of this service is subject to Google's Terms of Service\n",
            "<https://policies.google.com/terms> and Privacy Policy\n",
            "<https://policies.google.com/privacy>, and TensorBoard.dev's Terms of Service\n",
            "<https://tensorboard.dev/policy/terms/>.\n",
            "\n",
            "This notice will not be shown again while you are logged into the uploader.\n",
            "To log out, run `tensorboard dev auth revoke`.\n",
            "\n",
            "Continue? (yes/NO) yes\n",
            "\n",
            "Please visit this URL to authorize this application: https://accounts.google.com/o/oauth2/auth?response_type=code&client_id=373649185512-8v619h5kft38l4456nm2dj4ubeqsrvh6.apps.googleusercontent.com&redirect_uri=urn%3Aietf%3Awg%3Aoauth%3A2.0%3Aoob&scope=openid+https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fuserinfo.email&state=222JXik89NvZESbLeUV8KaY7uqn9N7&prompt=consent&access_type=offline\n",
            "Enter the authorization code: 4/1AfgeXvuaADMyx3wsHFtxmsO2oEzA8feqTpr-OuaMzIYjKAD0YbKYFSakW8Q\n",
            "\n",
            "\n",
            "New experiment created. View your TensorBoard at: https://tensorboard.dev/experiment/8XYMVuxpQuOFEVSvZ6gVSw/\n",
            "\n",
            "\u001b[1m[2022-12-12T16:50:13]\u001b[0m Started scanning logdir.\n",
            "\u001b[1m[2022-12-12T16:50:16]\u001b[0m Total uploaded: 60 scalars, 0 tensors, 2 binary objects (5.6 MB)\n",
            "\u001b[1m[2022-12-12T16:50:16]\u001b[0m Done scanning logdir.\n",
            "\n",
            "\n",
            "Done. View your TensorBoard at https://tensorboard.dev/experiment/8XYMVuxpQuOFEVSvZ6gVSw/\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Our TensorBoard experiments are uploaded publically here: https://tensorboard.dev/experiment/8XYMVuxpQuOFEVSvZ6gVSw/#scalars"
      ],
      "metadata": {
        "id": "lgDLKeTZPbnt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Check out what TensorBoard experiments you have\n",
        "!tensorboard dev list"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7JriU6H_Q516",
        "outputId": "279739ea-f7a4-4134-c515-fa81f48c184d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "https://tensorboard.dev/experiment/8XYMVuxpQuOFEVSvZ6gVSw/\n",
            "\tName                 EfficientNetB0 vs. ResNet50V2\n",
            "\tDescription          Comparing two different TF Hub feature extraction model architectures using 10% of the training data\n",
            "\tId                   8XYMVuxpQuOFEVSvZ6gVSw\n",
            "\tCreated              2022-12-12 16:50:13 (6 minutes ago)\n",
            "\tUpdated              2022-12-12 16:50:16 (6 minutes ago)\n",
            "\tRuns                 4\n",
            "\tTags                 7\n",
            "\tScalars              60\n",
            "\tTensor bytes         0\n",
            "\tBinary object bytes  5918715\n",
            "Total: 1 experiment(s)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Delete and experiment\n",
        "# !tensorboard dev delete --experiment_id theIDtobeDeleted"
      ],
      "metadata": {
        "id": "c7mALErBQ_1j"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Confirm the deletion by re-rechecking what experiments you have left\n",
        "!tensorboard dev list"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aUavalQ2RUL1",
        "outputId": "d0ff4799-577a-4235-dd3f-cce2eae969ea"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "https://tensorboard.dev/experiment/8XYMVuxpQuOFEVSvZ6gVSw/\n",
            "\tName                 EfficientNetB0 vs. ResNet50V2\n",
            "\tDescription          Comparing two different TF Hub feature extraction model architectures using 10% of the training data\n",
            "\tId                   8XYMVuxpQuOFEVSvZ6gVSw\n",
            "\tCreated              2022-12-12 16:50:13 (8 minutes ago)\n",
            "\tUpdated              2022-12-12 16:50:16 (7 minutes ago)\n",
            "\tRuns                 4\n",
            "\tTags                 7\n",
            "\tScalars              60\n",
            "\tTensor bytes         0\n",
            "\tBinary object bytes  5918715\n",
            "Total: 1 experiment(s)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "7mb5C2kCRaVa"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}