Bird_Classification_Model_Training.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "V100",
      "authorship_tag": "ABX9TyPrx3ZaarPlboTpMMg6NwB6",
      "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/nripstein/What-Bird-is-That/blob/main/Bird_Classification_Model_Training.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Obtain dataset from kaggle\n",
        "# THIS WHOLE NOTEBOOK PROBABLY WILL TAKE 6 hours if I use b4"
      ],
      "metadata": {
        "id": "Ev1O8xPTy5MN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount(\"/content/drive\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jC9ByafHyv0o",
        "outputId": "d11d5350-98ce-48ea-804f-5c08bc60a91f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CIGchdUpylbK",
        "outputId": "dcda96fb-d0d6-4d9f-a729-46d40be61a47"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Requirement already satisfied: kaggle in /usr/local/lib/python3.10/dist-packages (1.5.13)\n",
            "Requirement already satisfied: six>=1.10 in /usr/local/lib/python3.10/dist-packages (from kaggle) (1.16.0)\n",
            "Requirement already satisfied: certifi in /usr/local/lib/python3.10/dist-packages (from kaggle) (2022.12.7)\n",
            "Requirement already satisfied: python-dateutil in /usr/local/lib/python3.10/dist-packages (from kaggle) (2.8.2)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from kaggle) (2.27.1)\n",
            "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from kaggle) (4.65.0)\n",
            "Requirement already satisfied: python-slugify in /usr/local/lib/python3.10/dist-packages (from kaggle) (8.0.1)\n",
            "Requirement already satisfied: urllib3 in /usr/local/lib/python3.10/dist-packages (from kaggle) (1.26.15)\n",
            "Requirement already satisfied: text-unidecode>=1.3 in /usr/local/lib/python3.10/dist-packages (from python-slugify->kaggle) (1.3)\n",
            "Requirement already satisfied: charset-normalizer~=2.0.0 in /usr/local/lib/python3.10/dist-packages (from requests->kaggle) (2.0.12)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->kaggle) (3.4)\n"
          ]
        }
      ],
      "source": [
        "! pip install kaggle"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "! mkdir ~/.kaggle\n",
        "!cp /content/drive/MyDrive/kaggle.json ~/.kaggle/kaggle.json"
      ],
      "metadata": {
        "id": "VYXgFhoLyu3_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "! kaggle datasets download gpiosenka/100-bird-species\n",
        "!unzip -q 100-bird-species.zip -d dataset"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k7IWDy6NyzYb",
        "outputId": "55d5fa54-2a0a-4d05-e213-673b576d1771"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading 100-bird-species.zip to /content\n",
            "100% 1.95G/1.96G [01:06<00:00, 36.0MB/s]\n",
            "100% 1.96G/1.96G [01:06<00:00, 31.7MB/s]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Import dependencies"
      ],
      "metadata": {
        "id": "FFeSRGtky-3o"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "import pathlib\n",
        "from glob import glob\n",
        "import numpy as np\n",
        "import random\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.image as mpimg\n",
        "import datetime as dt\n",
        "from sklearn.metrics import precision_recall_fscore_support, accuracy_score\n",
        "from PIL import Image\n",
        "import pandas as pd"
      ],
      "metadata": {
        "id": "OxOIzHUFy-e3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install -U -q tensorflow==2.9.0  # tensorflow 2.10 and greater can't export efficientnet models properly"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XJqIQLqXzENT",
        "outputId": "e0418591-5fdc-4562-9dab-beebbf30d4da"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m511.7/511.7 MB\u001b[0m \u001b[31m1.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.6/1.6 MB\u001b[0m \u001b[31m31.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m42.6/42.6 kB\u001b[0m \u001b[31m1.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m5.8/5.8 MB\u001b[0m \u001b[31m50.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m438.7/438.7 kB\u001b[0m \u001b[31m30.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.1/1.1 MB\u001b[0m \u001b[31m30.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m4.9/4.9 MB\u001b[0m \u001b[31m37.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n",
            "tensorflow-datasets 4.9.2 requires protobuf>=3.20, but you have protobuf 3.19.6 which is incompatible.\n",
            "tensorflow-metadata 1.13.1 requires protobuf<5,>=3.20.3, but you have protobuf 3.19.6 which is incompatible.\u001b[0m\u001b[31m\n",
            "\u001b[0m"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow as tf\n",
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator"
      ],
      "metadata": {
        "id": "9incux_tzHmj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Define helper functions to be used later"
      ],
      "metadata": {
        "id": "ZJQhJcWx2Nm2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def calculate_results(y_true, y_pred):\n",
        "    \"\"\"\n",
        "    Calculates model accuracy, precision, recall and f1 score of a binary classification model.\n",
        "\n",
        "    Args:\n",
        "        y_true: true labels in the form of a 1D array\n",
        "        y_pred: predicted labels in the form of a 1D array\n",
        "\n",
        "    Returns a dictionary of accuracy, precision, recall, f1-score.\n",
        "    \"\"\"\n",
        "    # Calculate model accuracy\n",
        "    model_accuracy = accuracy_score(y_true, y_pred)\n",
        "    # Calculate model precision, recall and f1 score using \"weighted average\n",
        "    model_precision, model_recall, model_f1, _ = precision_recall_fscore_support(y_true, y_pred, average=\"weighted\", zero_division=1) # zero division param new\n",
        "    model_results = {\"accuracy\": model_accuracy,\n",
        "                    \"precision\": model_precision,\n",
        "                    \"recall\": model_recall,\n",
        "                    \"f1\": model_f1}\n",
        "    return model_results"
      ],
      "metadata": {
        "id": "aSWUjYfJ2NRj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def pred_and_plot9(model, class_names, directory):\n",
        "    random_images = random.sample(os.listdir(directory), 9)\n",
        "    fig, axes = plt.subplots(3, 3, figsize=(9, 9))\n",
        "\n",
        "    for i, image_name in enumerate(random_images):\n",
        "        image_path = os.path.join(directory, image_name)\n",
        "        image_path = os.path.join(image_path, os.listdir(image_path)[0])\n",
        "\n",
        "        if os.path.isfile(image_path):\n",
        "            # Read the image, resize it to match the input size your model expects,\n",
        "            # and normalize it in the same way as your training/test images\n",
        "            img = Image.open(image_path)\n",
        "            img = img.resize((224, 224))  # Resize the image\n",
        "            img_array = np.array(img) / 255.  # Normalize the image\n",
        "            img_array = img_array[:,:,:3] # ensure img is 224,224,3\n",
        "\n",
        "            # Make a prediction\n",
        "            pred = model.predict(np.expand_dims(img_array, axis=0))\n",
        "\n",
        "            # Get the predicted class\n",
        "            pred_class = class_names[np.argmax(pred[0])]\n",
        "\n",
        "            # Plot the image and predicted class\n",
        "            row = i // 3\n",
        "            col = i % 3\n",
        "            axes[row, col].imshow(img)\n",
        "            axes[row, col].set_title(f\"Pred: {pred_class}\\nLabel: {image_name}\")\n",
        "            axes[row, col].axis(False)\n",
        "        else:\n",
        "            print(f\"Skipping {image_path} as it is not a valid image file.\")\n",
        "\n",
        "    plt.tight_layout()\n",
        "    plt.show()"
      ],
      "metadata": {
        "id": "p_kUKq9G2TGt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "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",
        "    # 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",
        "    plt.show()"
      ],
      "metadata": {
        "id": "cthtbXkn2fIc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def compare_historys(original_history, new_history, initial_epochs=5):\n",
        "    \"\"\"\n",
        "    Compares two model history objects.\n",
        "    \"\"\"\n",
        "    # Get original history measurements\n",
        "    acc = original_history.history[\"accuracy\"]\n",
        "    loss = original_history.history[\"loss\"]\n",
        "\n",
        "\n",
        "    val_acc = original_history.history[\"val_accuracy\"]\n",
        "    val_loss = original_history.history[\"val_loss\"]\n",
        "\n",
        "    # Combine original history with new history\n",
        "    total_acc = acc + new_history.history[\"accuracy\"]\n",
        "    total_loss = loss + new_history.history[\"loss\"]\n",
        "\n",
        "    total_val_acc = val_acc + new_history.history[\"val_accuracy\"]\n",
        "    total_val_loss = val_loss + new_history.history[\"val_loss\"]\n",
        "\n",
        "    # print(len(total_acc))\n",
        "    # print(total_acc)\n",
        "\n",
        "    # Make plots\n",
        "    plt.figure(figsize=(8, 8))\n",
        "    plt.subplot(2, 1, 1)\n",
        "    plt.plot(total_acc, label='Training Accuracy')\n",
        "    plt.plot(total_val_acc, label='Validation Accuracy')\n",
        "    plt.plot([initial_epochs-1, initial_epochs-1],\n",
        "              plt.ylim(), label='Start Fine Tuning') # reshift plot around epochs\n",
        "    plt.legend(loc='lower right')\n",
        "    plt.title('Training and Validation Accuracy')\n",
        "\n",
        "    plt.subplot(2, 1, 2)\n",
        "    plt.plot(total_loss, label='Training Loss')\n",
        "    plt.plot(total_val_loss, label='Validation Loss')\n",
        "    plt.plot([initial_epochs-1, initial_epochs-1],\n",
        "              plt.ylim(), label='Start Fine Tuning') # reshift plot around epochs\n",
        "    plt.legend(loc='upper right')\n",
        "    plt.title('Training and Validation Loss')\n",
        "    plt.xlabel('epoch')\n",
        "    plt.show()"
      ],
      "metadata": {
        "id": "yuMzT15Y2Xs7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Load data in appropriate format"
      ],
      "metadata": {
        "id": "oMQEhLMA0f0x"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "train_dir = \"dataset/train\"\n",
        "valid_dir = \"dataset/valid\"\n",
        "test_dir = \"dataset/test\"\n",
        "IMAGE_DIMENSIONS = (380, 380) # efficientnetB4 image size\n",
        "\n",
        "data_gen = ImageDataGenerator()  # don't use rescale=1./255 because EfficientNetBx doesn't want rescaled data\n",
        "\n",
        "train_data = data_gen.flow_from_directory(directory=train_dir,\n",
        "                                          target_size=IMAGE_DIMENSIONS,\n",
        "                                          class_mode=\"categorical\",\n",
        "                                          batch_size=32,\n",
        "                                          seed=42,\n",
        "                                          shuffle=True)\n",
        "\n",
        "valid_data = data_gen.flow_from_directory(valid_dir,\n",
        "                                          batch_size=32,\n",
        "                                          target_size=IMAGE_DIMENSIONS,\n",
        "                                          class_mode=\"categorical\",\n",
        "                                          seed=42,\n",
        "                                          shuffle=False)  # don't shuffle validation or test data so labels are ordered correctly when evaluation\n",
        "\n",
        "test_data = data_gen.flow_from_directory(test_dir,\n",
        "                                         batch_size=32,\n",
        "                                         target_size=IMAGE_DIMENSIONS,\n",
        "                                         class_mode=\"categorical\",\n",
        "                                         seed=42,\n",
        "                                         shuffle=False)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "h_Zc3Xyi0iLU",
        "outputId": "ddc34167-1d3a-40c2-d8e1-fe687ac4105a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 84635 images belonging to 525 classes.\n",
            "Found 2625 images belonging to 525 classes.\n",
            "Found 2625 images belonging to 525 classes.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Design the neural network"
      ],
      "metadata": {
        "id": "7LT6F7v1zPmv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "data_augmentation = tf.keras.models.Sequential([\n",
        "    tf.keras.layers.RandomFlip(\"horizontal\"),\n",
        "    tf.keras.layers.RandomHeight(0.2),\n",
        "    tf.keras.layers.RandomWidth(0.2),\n",
        "    tf.keras.layers.RandomZoom(0.2),\n",
        "    tf.keras.layers.RandomRotation(0.2),\n",
        "    tf.keras.layers.RandomContrast(factor=0.1),\n",
        "], name=\"data_augmentation_layer\")"
      ],
      "metadata": {
        "id": "EFNFp2VczRry"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "INPUT_SHAPE = IMAGE_DIMENSIONS + (3,)\n",
        "\n",
        "# create frozen base model\n",
        "base_model = tf.keras.applications.EfficientNetB4(include_top=False, drop_connect_rate=0.4) # default drop_connect_rate is 0.2, 0.4 increases regularization\n",
        "base_model.trainable = False\n",
        "\n",
        "# create inputs and outputs and layers between\n",
        "inputs = tf.keras.layers.Input(shape=INPUT_SHAPE, name=\"input_layer\")\n",
        "x = data_augmentation(inputs)\n",
        "x = base_model(x, training=False) # pass augmented images to base model but keep it in inference mode, so batch norm layers don't get updated. we want this even in fine tuning\n",
        "\n",
        "x = tf.keras.layers.GlobalAveragePooling2D(name=\"global_avg_pooling2d\")(x) # turn base model into feature vector\n",
        "x = tf.keras.layers.Dropout(0.2, name=\"droupout_layer\")(x) # droupout to reduce overfitting\n",
        "\n",
        "outputs = tf.keras.layers.Dense(525, activation=\"softmax\", name=\"output_layer\")(x)\n",
        "\n",
        "model = tf.keras.Model(inputs, outputs)\n",
        "\n",
        "model.compile(loss=tf.keras.losses.CategoricalCrossentropy(),\n",
        "              optimizer=tf.keras.optimizers.Adam(),\n",
        "              metrics=[\"accuracy\"])"
      ],
      "metadata": {
        "id": "it7mOerOzWEf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Initial training of neural network using feature extraction"
      ],
      "metadata": {
        "id": "Z3NmFNGe3Pv9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "initial_epochs = 5\n",
        "\n",
        "model_history = model.fit(train_data,\n",
        "                          epochs=initial_epochs,\n",
        "                          steps_per_epoch=len(train_data),\n",
        "                          validation_data=valid_data,\n",
        "                          validation_steps=int(0.1 * len(valid_data))) # didn't use callbacks to save time bc I never use them"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CVQzU__93PPt",
        "outputId": "1384b561-c17f-44cc-c9c2-de3943bfb107"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/5\n",
            "2645/2645 [==============================] - 1118s 422ms/step - loss: 1.2420 - accuracy: 0.7492 - val_loss: 0.6440 - val_accuracy: 0.8438\n",
            "Epoch 2/5\n",
            "2645/2645 [==============================] - 983s 372ms/step - loss: 0.5766 - accuracy: 0.8591 - val_loss: 0.4894 - val_accuracy: 0.8750\n",
            "Epoch 3/5\n",
            "2645/2645 [==============================] - 942s 356ms/step - loss: 0.4653 - accuracy: 0.8800 - val_loss: 0.4168 - val_accuracy: 0.8945\n",
            "Epoch 4/5\n",
            "2645/2645 [==============================] - 898s 339ms/step - loss: 0.4066 - accuracy: 0.8936 - val_loss: 0.4232 - val_accuracy: 0.8750\n",
            "Epoch 5/5\n",
            "2645/2645 [==============================] - 888s 336ms/step - loss: 0.3642 - accuracy: 0.9024 - val_loss: 0.4161 - val_accuracy: 0.8789\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Pre-fine tuning metrics:"
      ],
      "metadata": {
        "id": "coH14Uhz3e-o"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model_initial_results = calculate_results(valid_data.labels, np.argmax(model.predict(valid_data), axis=1))\n",
        "model_initial_results"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gfk9kLCW3hMS",
        "outputId": "0e1bd12a-80fa-4b7f-8a3f-b675f7536aa6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "83/83 [==============================] - 15s 144ms/step\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'accuracy': 0.9462857142857143,\n",
              " 'precision': 0.9587165532879818,\n",
              " 'recall': 0.9462857142857143,\n",
              " 'f1': 0.9454263856280662}"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plot_loss_curves(model_history)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 927
        },
        "id": "IIHJRQ_c3izJ",
        "outputId": "ce3993fc-5e70-49f8-96bd-42fd1ccc18cc"
      },
      "execution_count": null,
      "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": [
        "# Fine tuning"
      ],
      "metadata": {
        "id": "WEKS5e5y3p-Z"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "base_model.trainable = True\n",
        "\n",
        "# allow training of last 5 layers of EfficientNet\n",
        "for layer in base_model.layers[:-5]:\n",
        "    layer.trainable = False\n",
        "\n",
        "\n",
        "# recompile model whenever we make a change\n",
        "model.compile(loss=tf.keras.losses.CategoricalCrossentropy(),\n",
        "              optimizer=tf.keras.optimizers.Adam(learning_rate=1e-4),  # lower learning rate for fine tuning because the unfrozen layers have already learned\n",
        "              metrics=[\"accuracy\"])"
      ],
      "metadata": {
        "id": "eztFmubo3rW0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# fine tune for another 3 epochs\n",
        "fine_tune_epochs = initial_epochs + 3\n",
        "\n",
        "# refit model (same as without fine-tuning, but has more trainable layers)\n",
        "model_fine_tune_history = model.fit(train_data,\n",
        "                                    epochs=fine_tune_epochs,\n",
        "                                    steps_per_epoch=(len(train_data)),\n",
        "                                    validation_data=valid_data,\n",
        "                                    validation_steps=int(0.1 * len(valid_data)),\n",
        "                                    initial_epoch=model_history.epoch[-1], # start training from previous last epoch\n",
        "                                    )"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ozj0CkiGWFB3",
        "outputId": "e75aae03-eef2-403a-f068-0334683eb35c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 5/8\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:tensorflow:Using a while_loop for converting RngReadAndSkip\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformFullIntV2\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomGetKeyCounter\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformV2\n",
            "WARNING:tensorflow:Using a while_loop for converting AdjustContrastv2\n",
            "WARNING:tensorflow:Using a while_loop for converting RngReadAndSkip\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformFullIntV2\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomGetKeyCounter\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformV2\n",
            "WARNING:tensorflow:Using a while_loop for converting AdjustContrastv2\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2645/2645 [==============================] - 913s 339ms/step - loss: 0.2773 - accuracy: 0.9252 - val_loss: 0.3597 - val_accuracy: 0.9141\n",
            "Epoch 6/8\n",
            "2645/2645 [==============================] - 863s 326ms/step - loss: 0.2484 - accuracy: 0.9325 - val_loss: 0.3410 - val_accuracy: 0.9219\n",
            "Epoch 7/8\n",
            "2645/2645 [==============================] - 867s 328ms/step - loss: 0.2260 - accuracy: 0.9378 - val_loss: 0.3238 - val_accuracy: 0.9219\n",
            "Epoch 8/8\n",
            "2645/2645 [==============================] - 863s 326ms/step - loss: 0.2173 - accuracy: 0.9397 - val_loss: 0.3284 - val_accuracy: 0.9141\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model_tuned_predicted_val_labels = np.argmax(model.predict(valid_data), axis=1)\n",
        "model_tuned_predicted_test_labels = np.argmax(model.predict(test_data), axis=1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MwFpI5QPWXLD",
        "outputId": "064c268e-929b-4e24-d1b9-a5826a228fd4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "83/83 [==============================] - 12s 101ms/step\n",
            "83/83 [==============================] - 12s 143ms/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model_tuned_results = calculate_results(valid_data.labels, model_tuned_predicted_val_labels)\n",
        "model_tuned_results"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LjFR278UWRXe",
        "outputId": "4b231d4c-bd8a-4b1f-8513-73f20e395d49"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'accuracy': 0.9573333333333334,\n",
              " 'precision': 0.9659931972789115,\n",
              " 'recall': 0.9573333333333334,\n",
              " 'f1': 0.9564192527049669}"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model_test_results = calculate_results(test_data.labels, model_tuned_predicted_test_labels)\n",
        "model_test_results"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BXpEAHu-X33B",
        "outputId": "252a15a5-387a-4db9-f8fc-b3d73ee2f6e1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'accuracy': 0.9782857142857143,\n",
              " 'precision': 0.981859410430839,\n",
              " 'recall': 0.9782857142857143,\n",
              " 'f1': 0.9778991378991378}"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Save model"
      ],
      "metadata": {
        "id": "z5imCKh0Y1IH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "folder_path = \"saved_model_h5\"\n",
        "if not os.path.exists(folder_path):\n",
        "    os.makedirs(folder_path)\n",
        "\n",
        "# Save TF Hub Sentence Encoder model to HDF5 format inside the folder\n",
        "model.save(os.path.join(folder_path, \"bird_model_b2.h5\"))"
      ],
      "metadata": {
        "id": "uqWdLBLEY2C_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "folder_path = \"saved_model_tf\"\n",
        "if not os.path.exists(folder_path):\n",
        "    os.makedirs(folder_path)\n",
        "\n",
        "# Save TF Hub Sentence Encoder model to TF format inside the folder\n",
        "model.save(os.path.join(folder_path, \"bird_model_b2\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ld2RTHl6Y_Ax",
        "outputId": "8aca6651-80b4-4d84-d9df-5b459d3af2b1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:tensorflow:Using a while_loop for converting RngReadAndSkip\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformFullIntV2\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomGetKeyCounter\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformV2\n",
            "WARNING:tensorflow:Using a while_loop for converting AdjustContrastv2\n",
            "WARNING:tensorflow:Using a while_loop for converting RngReadAndSkip\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformFullIntV2\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomGetKeyCounter\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformV2\n",
            "WARNING:tensorflow:Using a while_loop for converting AdjustContrastv2\n",
            "WARNING:tensorflow:Using a while_loop for converting RngReadAndSkip\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformFullIntV2\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomGetKeyCounter\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformV2\n",
            "WARNING:tensorflow:Using a while_loop for converting AdjustContrastv2\n",
            "WARNING:tensorflow:Using a while_loop for converting RngReadAndSkip\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformFullIntV2\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomGetKeyCounter\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformV2\n",
            "WARNING:tensorflow:Using a while_loop for converting AdjustContrastv2\n",
            "WARNING:tensorflow:Using a while_loop for converting RngReadAndSkip\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformFullIntV2\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomGetKeyCounter\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformV2\n",
            "WARNING:tensorflow:Using a while_loop for converting AdjustContrastv2\n",
            "WARNING:tensorflow:Using a while_loop for converting RngReadAndSkip\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformFullIntV2\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomGetKeyCounter\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformV2\n",
            "WARNING:tensorflow:Using a while_loop for converting AdjustContrastv2\n",
            "WARNING:tensorflow:Using a while_loop for converting RngReadAndSkip\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformFullIntV2\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomGetKeyCounter\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformV2\n",
            "WARNING:tensorflow:Using a while_loop for converting AdjustContrastv2\n",
            "WARNING:tensorflow:Using a while_loop for converting RngReadAndSkip\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformFullIntV2\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomGetKeyCounter\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformV2\n",
            "WARNING:tensorflow:Using a while_loop for converting AdjustContrastv2\n",
            "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 160). These functions will not be directly callable after loading.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "saving_path = os.path.join(os.getcwd(), \"drive/MyDrive\")\n",
        "# folder_path = \"saved_model_tf\"\n",
        "# if not os.path.exists(folder_path):\n",
        "#     os.makedirs(folder_path)\n",
        "\n",
        "# Save TF Hub Sentence Encoder model to TF format inside the folder\n",
        "model.save(os.path.join(saving_path, \"bird_model_b2\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5egIgvuxIWrx",
        "outputId": "59f38a58-e661-48e0-d8a4-32172275b898"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:tensorflow:Using a while_loop for converting RngReadAndSkip\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformFullIntV2\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomGetKeyCounter\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformV2\n",
            "WARNING:tensorflow:Using a while_loop for converting AdjustContrastv2\n",
            "WARNING:tensorflow:Using a while_loop for converting RngReadAndSkip\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformFullIntV2\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomGetKeyCounter\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformV2\n",
            "WARNING:tensorflow:Using a while_loop for converting AdjustContrastv2\n",
            "WARNING:tensorflow:Using a while_loop for converting RngReadAndSkip\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformFullIntV2\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomGetKeyCounter\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformV2\n",
            "WARNING:tensorflow:Using a while_loop for converting AdjustContrastv2\n",
            "WARNING:tensorflow:Using a while_loop for converting RngReadAndSkip\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformFullIntV2\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomGetKeyCounter\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformV2\n",
            "WARNING:tensorflow:Using a while_loop for converting AdjustContrastv2\n",
            "WARNING:tensorflow:Using a while_loop for converting RngReadAndSkip\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformFullIntV2\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomGetKeyCounter\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformV2\n",
            "WARNING:tensorflow:Using a while_loop for converting AdjustContrastv2\n",
            "WARNING:tensorflow:Using a while_loop for converting RngReadAndSkip\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformFullIntV2\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomGetKeyCounter\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformV2\n",
            "WARNING:tensorflow:Using a while_loop for converting AdjustContrastv2\n",
            "WARNING:tensorflow:Using a while_loop for converting RngReadAndSkip\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformFullIntV2\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomGetKeyCounter\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformV2\n",
            "WARNING:tensorflow:Using a while_loop for converting AdjustContrastv2\n",
            "WARNING:tensorflow:Using a while_loop for converting RngReadAndSkip\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformFullIntV2\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomGetKeyCounter\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformV2\n",
            "WARNING:tensorflow:Using a while_loop for converting AdjustContrastv2\n",
            "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 160). These functions will not be directly callable after loading.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Specify the saving path on your Google Drive\n",
        "saving_path = '/content/drive/MyDrive/saved_models/model'\n",
        "\n",
        "# Save the TensorFlow model\n",
        "tf.saved_model.save(model, saving_path)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZYnVXATMJmu9",
        "outputId": "a14b0985-8a0c-4fa4-d6e6-bd749c50e830"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:tensorflow:Using a while_loop for converting RngReadAndSkip\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformFullIntV2\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomGetKeyCounter\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformV2\n",
            "WARNING:tensorflow:Using a while_loop for converting AdjustContrastv2\n",
            "WARNING:tensorflow:Using a while_loop for converting RngReadAndSkip\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformFullIntV2\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomGetKeyCounter\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformV2\n",
            "WARNING:tensorflow:Using a while_loop for converting AdjustContrastv2\n",
            "WARNING:tensorflow:Using a while_loop for converting RngReadAndSkip\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformFullIntV2\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomGetKeyCounter\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformV2\n",
            "WARNING:tensorflow:Using a while_loop for converting AdjustContrastv2\n",
            "WARNING:tensorflow:Using a while_loop for converting RngReadAndSkip\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformFullIntV2\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomGetKeyCounter\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformV2\n",
            "WARNING:tensorflow:Using a while_loop for converting AdjustContrastv2\n",
            "WARNING:tensorflow:Using a while_loop for converting RngReadAndSkip\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformFullIntV2\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomGetKeyCounter\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformV2\n",
            "WARNING:tensorflow:Using a while_loop for converting AdjustContrastv2\n",
            "WARNING:tensorflow:Using a while_loop for converting RngReadAndSkip\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformFullIntV2\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomGetKeyCounter\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformV2\n",
            "WARNING:tensorflow:Using a while_loop for converting AdjustContrastv2\n",
            "WARNING:tensorflow:Using a while_loop for converting RngReadAndSkip\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformFullIntV2\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomGetKeyCounter\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformV2\n",
            "WARNING:tensorflow:Using a while_loop for converting AdjustContrastv2\n",
            "WARNING:tensorflow:Using a while_loop for converting RngReadAndSkip\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting Bitcast\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformFullIntV2\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomGetKeyCounter\n",
            "WARNING:tensorflow:Using a while_loop for converting StatelessRandomUniformV2\n",
            "WARNING:tensorflow:Using a while_loop for converting AdjustContrastv2\n",
            "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 160). These functions will not be directly callable after loading.\n"
          ]
        }
      ]
    }
  ]
}