Transfer_Learning.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4",
      "authorship_tag": "ABX9TyPZIbSA9sBnaRSHomEXgeWn",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Idk507/computer_vision_learning_cnn/blob/main/Transfer_Learning.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 63,
      "metadata": {
        "id": "81G4J5-QFKbF"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import tensorflow as tf\n",
        "from tensorflow.keras import models"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\"\n",
        "Transfer LEarning is leveraging a working models existing architecture and learned patterns for out own problem\n",
        "1.Can leverage on exixting NN\n",
        "2.Can leverage on working neural network\n",
        "\"\"\""
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        },
        "id": "-CVUFSCQFUHL",
        "outputId": "8ecb3a36-a786-48d9-eedc-f912c193ea46"
      },
      "execution_count": 64,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'\\nTransfer LEarning is leveraging a working models existing architecture and learned patterns for out own problem\\n1.Can leverage on exixting NN\\n2.Can leverage on working neural network\\n'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 64
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!nvidia-smi"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ig6BrxwUFzsY",
        "outputId": "78aea124-03d1-499a-f58b-aedb37c78702"
      },
      "execution_count": 65,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Tue Jan 30 18:59:36 2024       \n",
            "+---------------------------------------------------------------------------------------+\n",
            "| NVIDIA-SMI 535.104.05             Driver Version: 535.104.05   CUDA Version: 12.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   46C    P0              25W /  70W |    615MiB / 15360MiB |      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",
            "+---------------------------------------------------------------------------------------+\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "82sJ9ch-F9Il"
      },
      "execution_count": 65,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Download and become with data"
      ],
      "metadata": {
        "id": "8_jAnNbIGBt0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import zipfile\n",
        "\n",
        "#download the data\n",
        "\n",
        "!wget https://storage.googleapis.com/ztm_tf_course/food_vision/10_food_classes_10_percent.zip"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3HvwOgN9GIw7",
        "outputId": "b54fb57c-834c-4396-9ae9-ef52ed1b7117"
      },
      "execution_count": 66,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--2024-01-30 18:59:36--  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.127.207, 172.217.218.207, 142.251.31.207, ...\n",
            "Connecting to storage.googleapis.com (storage.googleapis.com)|108.177.127.207|: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.3’\n",
            "\n",
            "10_food_classes_10_ 100%[===================>] 160.74M  41.0MB/s    in 4.5s    \n",
            "\n",
            "2024-01-30 18:59:41 (35.5 MB/s) - ‘10_food_classes_10_percent.zip.3’ saved [168546183/168546183]\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "zip_ref = zipfile.ZipFile(\"10_food_classes_10_percent.zip\")\n",
        "zip_ref.extractall()\n",
        "zip_ref.close()"
      ],
      "metadata": {
        "id": "da4aQhlUGY7I"
      },
      "execution_count": 67,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "zip_ref"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5YvmFrFcGkSo",
        "outputId": "d99f7ec0-cd44-48ab-8d00-04228b0eb6c6"
      },
      "execution_count": 68,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<zipfile.ZipFile [closed]>"
            ]
          },
          "metadata": {},
          "execution_count": 68
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "\n",
        "#walk through the dataset\n",
        "\n",
        "for dir_path,dir_names,filenames in os.walk(\"10_food_classes_10_percent\"):\n",
        "  print(f\"There are {len(dir_names)} directories and {len(filenames)} images in {dir_path}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NjQodt7sHN63",
        "outputId": "2903d7a5-8188-4c4f-9f64-6ae2d1f26d73"
      },
      "execution_count": 69,
      "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/train\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/hamburger\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/ramen\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/pizza\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/grilled_salmon\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/chicken_curry\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/steak\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/fried_rice\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/sushi\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_wings\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/ice_cream\n",
            "There are 0 directories and 250 images in 10_food_classes_10_percent/test/chicken_curry\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\"\n",
        "We will use ImageDataGenerator class to load in our images\n",
        "\"\"\"\n",
        "\n",
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
        "\n",
        "\n",
        "IMG_SHAPE =(224,224)\n",
        "BATCH_SIZE = 32\n",
        "\n",
        "train_dir = \"/content/10_food_classes_10_percent/train\"\n",
        "test_dir = \"/content/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",
        "\n",
        "train_data_10_percent = train_datagen.flow_from_directory(train_dir,target_size=IMG_SHAPE,batch_size=BATCH_SIZE,class_mode=\"categorical\")\n",
        "\n",
        "print(\"Testing Images\")\n",
        "\n",
        "test_data_10_percent = test_datagen.flow_from_directory(test_dir,target_size=IMG_SHAPE,batch_size = BATCH_SIZE,class_mode=\"categorical\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qONDQcXdIJkM",
        "outputId": "1c81cdef-4dfb-40ad-d6c3-7de2ec7ae1cb"
      },
      "execution_count": 70,
      "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": "code",
      "source": [
        "#setting up the callbacks\n",
        "\"\"\"\n",
        "Callbacks are extra functionality you can add to your models to be performed during or after training.\n",
        "1.Tracking experiments with tensorboard\n",
        "2.Model checkpoints with modelcheckpoint Callbacks\n",
        "3.Stopping a model from training\n",
        "\"\"\""
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        },
        "id": "hWKPzT5qJnU_",
        "outputId": "0f0efafb-09ca-4a7b-b667-640d4dc2ff9c"
      },
      "execution_count": 71,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'\\nCallbacks are extra functionality you can add to your models to be performed during or after training.\\n1.Tracking experiments with tensorboard\\n2.Model checkpoints with modelcheckpoint Callbacks\\n3.Stopping a model from training\\n'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 71
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import datetime\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(\n",
        "      log_dir=log_dir\n",
        "  )\n",
        "  print(f\"Saving TensorBoard log files to: {log_dir}\")\n",
        "  return tensorboard_callback"
      ],
      "metadata": {
        "id": "aiqODCk-KN_b"
      },
      "execution_count": 87,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install -U tensorflow_hub"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Q9RNNhjKWo9Y",
        "outputId": "e9cc3515-f258-4605-f399-39790c0f4491"
      },
      "execution_count": 73,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: tensorflow_hub in /usr/local/lib/python3.10/dist-packages (0.16.1)\n",
            "Requirement already satisfied: numpy>=1.12.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow_hub) (1.23.5)\n",
            "Requirement already satisfied: protobuf>=3.19.6 in /usr/local/lib/python3.10/dist-packages (from tensorflow_hub) (3.20.3)\n",
            "Requirement already satisfied: tf-keras>=2.14.1 in /usr/local/lib/python3.10/dist-packages (from tensorflow_hub) (2.15.0)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Creating models using Tensorflow Hub\n"
      ],
      "metadata": {
        "id": "47CTRkynXId0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow as tf\n",
        "import tensorflow_hub as hub\n",
        "from tensorflow.keras import layers\n",
        "\n"
      ],
      "metadata": {
        "id": "8c9qdS4wXEtD"
      },
      "execution_count": 74,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Resnet 50 V2 feature vector\n",
        "resnet_url = \"https://tfhub.dev/google/imagenet/resnet_v2_50/feature_vector/4\"\n",
        "\n",
        "# Original: EfficientNetB0 feature vector (version 1)\n",
        "efficientnet_url = \"https://tfhub.dev/tensorflow/efficientnet/b0/feature-vector/1\""
      ],
      "metadata": {
        "id": "S_0WWsbIe3iM"
      },
      "execution_count": 75,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def create_model(model_url,num_classes = 10):\n",
        "  \"\"\"\n",
        "  Take a Tensorflow HubURL and create keras SEquential model witht it\n",
        "\n",
        "  Args:\n",
        "  model_url (str): A tensorlow hub feature ectraction URL\n",
        "  num_classes(int) : Number of output neurona in the output layer\n",
        "\n",
        "  Return:\n",
        "  An uncompiled keras Sequential model with mode_url as feature extraction\n",
        "\n",
        "  \"\"\"\n",
        "  # Download the pretrained model and save it as a 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 the feature extraction layer as the base\n",
        "    layers.Dense(num_classes, activation='softmax', name='output_layer') # create our own output layer\n",
        "  ])\n",
        "\n",
        "  return model"
      ],
      "metadata": {
        "id": "qv3FWVrVdVKZ"
      },
      "execution_count": 76,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "resnet_model = create_model(resnet_url,num_classes = train_data_10_percent.num_classes)"
      ],
      "metadata": {
        "id": "YqDll8LxfZwJ"
      },
      "execution_count": 77,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "resnet_model.summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RshvXiiOhYXe",
        "outputId": "7a2ecc1e-1376-4f60-f3fd-7758e7d2fd60"
      },
      "execution_count": 78,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_2\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " feature_extraction_layer (  (None, 2048)              23564800  \n",
            " KerasLayer)                                                     \n",
            "                                                                 \n",
            " output_layer (Dense)        (None, 10)                20490     \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 23585290 (89.97 MB)\n",
            "Trainable params: 20490 (80.04 KB)\n",
            "Non-trainable params: 23564800 (89.89 MB)\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "resnet_model.compile(loss=\"categorical_crossentropy\",optimizer = tf.keras.optimizers.Adam(),metrics =[\"accuracy\"] )"
      ],
      "metadata": {
        "id": "ZsmTZnm_h0d-"
      },
      "execution_count": 79,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "resnet_history = resnet_model.fit(train_data_10_percent,epochs=5,steps_per_epoch=len(train_data_10_percent),validation_data = test_data_10_percent,validation_steps=len(test_data_10_percent),callbacks = [create_tensorboard_callback(dir_name=\"tensorflow_hub\",experiment_name=\"resnet50V2\")])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "c1BibJgHiGgq",
        "outputId": "16f32e56-028d-42b5-f762-120efd5fdadb"
      },
      "execution_count": 88,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving TensorBoard log files to: tensorflow_hub/resnet50V2/20240130-190853\n",
            "Epoch 1/5\n",
            "24/24 [==============================] - 23s 612ms/step - loss: 1.9621 - accuracy: 0.3680 - val_loss: 1.2268 - val_accuracy: 0.6072\n",
            "Epoch 2/5\n",
            "24/24 [==============================] - 11s 462ms/step - loss: 0.8966 - accuracy: 0.7453 - val_loss: 0.8470 - val_accuracy: 0.7212\n",
            "Epoch 3/5\n",
            "24/24 [==============================] - 13s 547ms/step - loss: 0.6163 - accuracy: 0.8133 - val_loss: 0.7570 - val_accuracy: 0.7500\n",
            "Epoch 4/5\n",
            "24/24 [==============================] - 12s 499ms/step - loss: 0.4753 - accuracy: 0.8880 - val_loss: 0.7126 - val_accuracy: 0.7628\n",
            "Epoch 5/5\n",
            "24/24 [==============================] - 13s 547ms/step - loss: 0.3735 - accuracy: 0.9173 - val_loss: 0.6639 - val_accuracy: 0.7864\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "def plt_loss_curves(history):\n",
        "  \"\"\"\n",
        "  Args:\n",
        "  History: Tensorflow history object\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",
        "  #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",
        "\n"
      ],
      "metadata": {
        "id": "CxoFAklUwdmm"
      },
      "execution_count": 96,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plt_loss_curves(resnet_model.history)"
      ],
      "metadata": {
        "id": "6Y22SNps3tSo",
        "outputId": "ef026651-9f58-44f7-884f-a6a130e43495",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 927
        }
      },
      "execution_count": 97,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Efficienet"
      ],
      "metadata": {
        "id": "gTZf3oyd45PQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create model\n",
        "efficientnet_model = create_model(model_url=efficientnet_url, # use EfficientNetB0 TensorFlow Hub URL\n",
        "                                  num_classes=train_data_10_percent.num_classes)\n",
        "\n",
        "# Compile EfficientNet model\n",
        "efficientnet_model.compile(loss='categorical_crossentropy',\n",
        "                           optimizer=tf.keras.optimizers.Adam(),\n",
        "                           metrics=['accuracy'])\n",
        "\n",
        "# Fit EfficientNet model\n",
        "efficientnet_history = efficientnet_model.fit(train_data_10_percent, # only use 10% of training data\n",
        "                                              epochs=5, # train for 5 epochs\n",
        "                                              steps_per_epoch=len(train_data_10_percent),\n",
        "                                              validation_data=test_data_10_percent,\n",
        "                                              validation_steps=len(test_data_10_percent),\n",
        "                                              callbacks=[create_tensorboard_callback(dir_name=\"tensorflow_hub\",\n",
        "                                                                                     # Track logs under different experiment name\n",
        "                                                                                     experiment_name=\"efficientnetB0\")])"
      ],
      "metadata": {
        "id": "k4Ch0Qc830XK",
        "outputId": "214a7b1b-6627-4f17-da06-cae3035d5b35",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 106,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving TensorBoard log files to: tensorflow_hub/efficientnetB0/20240130-195313\n",
            "Epoch 1/5\n",
            "24/24 [==============================] - 27s 575ms/step - loss: 1.8255 - accuracy: 0.4533 - val_loss: 1.2711 - val_accuracy: 0.7404\n",
            "Epoch 2/5\n",
            "24/24 [==============================] - 11s 475ms/step - loss: 1.0588 - accuracy: 0.7640 - val_loss: 0.8494 - val_accuracy: 0.8256\n",
            "Epoch 3/5\n",
            "24/24 [==============================] - 13s 539ms/step - loss: 0.7600 - accuracy: 0.8213 - val_loss: 0.6864 - val_accuracy: 0.8456\n",
            "Epoch 4/5\n",
            "24/24 [==============================] - 11s 452ms/step - loss: 0.6144 - accuracy: 0.8547 - val_loss: 0.6013 - val_accuracy: 0.8572\n",
            "Epoch 5/5\n",
            "24/24 [==============================] - 10s 428ms/step - loss: 0.5170 - accuracy: 0.8893 - val_loss: 0.5500 - val_accuracy: 0.8660\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt_loss_curves(efficientnet_history)"
      ],
      "metadata": {
        "id": "P01XovR27Nf9",
        "outputId": "3a5d01db-0de0-4536-c06f-750bbbf1fd0e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 927
        }
      },
      "execution_count": 109,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "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 architectures using 10% of training images\" \\\n",
        "  --one_shot"
      ],
      "metadata": {
        "id": "-wnEkr9q9jgg",
        "outputId": "65d2b76c-d874-4def-9329-ad81dd34de77",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 110,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2024-01-30 20:02:13.382222: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
            "2024-01-30 20:02:13.382294: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
            "2024-01-30 20:02:13.383685: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
            "2024-01-30 20:02:14.436169: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n",
            "****************************************************************\n",
            "****************************************************************\n",
            "****************************************************************\n",
            "\n",
            "Uploading TensorBoard logs to https://tensorboard.dev/ is no longer\n",
            "supported.\n",
            "\n",
            "TensorBoard.dev is shutting down.\n",
            "\n",
            "Please export your experiments by Dec 31, 2023.\n",
            "\n",
            "See the FAQ at https://tensorboard.dev.\n",
            "\n",
            "****************************************************************\n",
            "****************************************************************\n",
            "****************************************************************\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Zd9dQOY19vuK"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}