diff --git "a/pokemon_image_training.ipynb" "b/pokemon_image_training.ipynb" new file mode 100644--- /dev/null +++ "b/pokemon_image_training.ipynb" @@ -0,0 +1,1037 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "machine_shape": "hm", + "gpuType": "T4" + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU" + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "Cell 1: Imports and Setup\n" + ], + "metadata": { + "id": "z7vB-lp3TOFE" + } + }, + { + "cell_type": "code", + "source": [ + "!pip install tensorflow opencv-python\n", + "\n", + "import tensorflow as tf\n", + "from tensorflow import keras\n", + "from tensorflow.keras import layers\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import os\n", + "from google.colab import drive\n", + "from tensorflow.keras.callbacks import EarlyStopping\n", + "from zipfile import ZipFile\n", + "import cv2\n", + "\n", + "# Set seeds for reproducibility\n", + "tf.random.set_seed(42)\n", + "np.random.seed(42)\n", + "\n", + "print(\"TensorFlow version:\", tf.__version__)\n", + "print(\"GPU Available:\", tf.config.list_physical_devices('GPU'))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "73N2fTb2TPlS", + "outputId": "25e16800-8d3d-4036-d60f-48955d265667", + "collapsed": true + }, + "execution_count": 45, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Requirement already satisfied: tensorflow in /usr/local/lib/python3.10/dist-packages (2.17.1)\n", + "Requirement already satisfied: opencv-python in /usr/local/lib/python3.10/dist-packages (4.10.0.84)\n", + "Requirement already satisfied: absl-py>=1.0.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (1.4.0)\n", + "Requirement already satisfied: astunparse>=1.6.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (1.6.3)\n", + "Requirement already satisfied: flatbuffers>=24.3.25 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (24.3.25)\n", + "Requirement already satisfied: gast!=0.5.0,!=0.5.1,!=0.5.2,>=0.2.1 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (0.6.0)\n", + "Requirement already satisfied: google-pasta>=0.1.1 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (0.2.0)\n", + "Requirement already satisfied: h5py>=3.10.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (3.12.1)\n", + "Requirement already satisfied: libclang>=13.0.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (18.1.1)\n", + "Requirement already satisfied: ml-dtypes<0.5.0,>=0.3.1 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (0.4.1)\n", + "Requirement already satisfied: opt-einsum>=2.3.2 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (3.4.0)\n", + "Requirement already satisfied: packaging in /usr/local/lib/python3.10/dist-packages (from tensorflow) (24.2)\n", + "Requirement already satisfied: protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<5.0.0dev,>=3.20.3 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (4.25.5)\n", + "Requirement already satisfied: requests<3,>=2.21.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (2.32.3)\n", + "Requirement already satisfied: setuptools in /usr/local/lib/python3.10/dist-packages (from tensorflow) (75.1.0)\n", + "Requirement already satisfied: six>=1.12.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (1.17.0)\n", + "Requirement already satisfied: termcolor>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (2.5.0)\n", + "Requirement already satisfied: typing-extensions>=3.6.6 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (4.12.2)\n", + "Requirement already satisfied: wrapt>=1.11.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (1.17.0)\n", + "Requirement already satisfied: grpcio<2.0,>=1.24.3 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (1.68.1)\n", + "Requirement already satisfied: tensorboard<2.18,>=2.17 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (2.17.1)\n", + "Requirement already satisfied: keras>=3.2.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (3.5.0)\n", + "Requirement already satisfied: tensorflow-io-gcs-filesystem>=0.23.1 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (0.37.1)\n", + "Requirement already satisfied: numpy<2.0.0,>=1.23.5 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (1.26.4)\n", + "Requirement already satisfied: wheel<1.0,>=0.23.0 in /usr/local/lib/python3.10/dist-packages (from astunparse>=1.6.0->tensorflow) (0.45.1)\n", + "Requirement already satisfied: rich in /usr/local/lib/python3.10/dist-packages (from keras>=3.2.0->tensorflow) (13.9.4)\n", + "Requirement already satisfied: namex in /usr/local/lib/python3.10/dist-packages (from keras>=3.2.0->tensorflow) (0.0.8)\n", + "Requirement already satisfied: optree in /usr/local/lib/python3.10/dist-packages (from keras>=3.2.0->tensorflow) (0.13.1)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests<3,>=2.21.0->tensorflow) (3.4.0)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests<3,>=2.21.0->tensorflow) (3.10)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests<3,>=2.21.0->tensorflow) (2.2.3)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests<3,>=2.21.0->tensorflow) (2024.12.14)\n", + "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.10/dist-packages (from tensorboard<2.18,>=2.17->tensorflow) (3.7)\n", + "Requirement already satisfied: tensorboard-data-server<0.8.0,>=0.7.0 in /usr/local/lib/python3.10/dist-packages (from tensorboard<2.18,>=2.17->tensorflow) (0.7.2)\n", + "Requirement already satisfied: werkzeug>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from tensorboard<2.18,>=2.17->tensorflow) (3.1.3)\n", + "Requirement already satisfied: MarkupSafe>=2.1.1 in /usr/local/lib/python3.10/dist-packages (from werkzeug>=1.0.1->tensorboard<2.18,>=2.17->tensorflow) (3.0.2)\n", + "Requirement already satisfied: markdown-it-py>=2.2.0 in /usr/local/lib/python3.10/dist-packages (from rich->keras>=3.2.0->tensorflow) (3.0.0)\n", + "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /usr/local/lib/python3.10/dist-packages (from rich->keras>=3.2.0->tensorflow) (2.18.0)\n", + "Requirement already satisfied: mdurl~=0.1 in /usr/local/lib/python3.10/dist-packages (from markdown-it-py>=2.2.0->rich->keras>=3.2.0->tensorflow) (0.1.2)\n", + "TensorFlow version: 2.17.1\n", + "GPU Available: [PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Cell 2: Mount Drive and Extract Zip\n", + "\n" + ], + "metadata": { + "id": "pfbh6i0AXi3Z" + } + }, + { + "cell_type": "code", + "source": [ + "drive.mount('/content/drive')\n", + "\n", + "zip_path = '/content/drive/MyDrive/Dataset/PokemonData.zip'\n", + "extracted_dir = '/content/PokemonData'\n", + "\n", + "if not os.path.exists(extracted_dir):\n", + " with ZipFile(zip_path, 'r') as zip_ref:\n", + " zip_ref.extractall(extracted_dir)\n", + " print(f\"Extracted {zip_path} to {extracted_dir}\")\n", + "else:\n", + " print(f\"Directory {extracted_dir} already exists. Skipping extraction.\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "kKHv9yYxTV9N", + "outputId": "20b2d141-f8c4-40be-f106-9f17e49de7f9" + }, + "execution_count": 46, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n", + "Directory /content/PokemonData already exists. Skipping extraction.\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "\n", + "\n", + "\n", + "Cell 3: Load Pre-trained Model\n", + "\n", + "\n" + ], + "metadata": { + "id": "vnnZ1qqtTYKT" + } + }, + { + "cell_type": "code", + "source": [ + "base_model = keras.applications.MobileNetV2(\n", + " weights='imagenet',\n", + " include_top=False,\n", + " input_shape=(224, 224, 3)\n", + ")\n", + "\n", + "base_model.trainable = False # Freeze initially" + ], + "metadata": { + "id": "8VB7YHtyTaZJ" + }, + "execution_count": 47, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Cell 4: Create Classifier\n", + "\n", + "\n" + ], + "metadata": { + "id": "cUHTGkPoTb8L" + } + }, + { + "cell_type": "code", + "source": [ + "inputs = keras.Input(shape=(224, 224, 3))\n", + "x = base_model(inputs, training=False)\n", + "x = layers.GlobalAveragePooling2D()(x)\n", + "x = layers.Dense(128, activation='relu')(x)\n", + "x = layers.Dropout(0.2)(x)\n", + "outputs = layers.Dense(151, activation='softmax')(x)\n", + "\n", + "model = keras.Model(inputs, outputs)" + ], + "metadata": { + "id": "cElxYwUbTdfF" + }, + "execution_count": 48, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "\n", + "\n", + "\n", + "Cell 5: Compile the Model\n", + "\n", + "\n" + ], + "metadata": { + "id": "wqoAfgABTjoH" + } + }, + { + "cell_type": "code", + "source": [ + "model.compile(\n", + " optimizer=keras.optimizers.Adam(),\n", + " loss=keras.losses.CategoricalCrossentropy(),\n", + " metrics=['accuracy']\n", + ")" + ], + "metadata": { + "id": "dvJ8AmI_TkFi" + }, + "execution_count": 49, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Cell 6: Data Augmentation\n", + "\n", + "\n" + ], + "metadata": { + "id": "irQ70BABTlfD" + } + }, + { + "cell_type": "code", + "source": [ + "data_augmentation = keras.Sequential(\n", + " [\n", + " layers.RandomFlip(\"horizontal\"),\n", + " layers.RandomRotation(0.1),\n", + " layers.RandomZoom(0.1),\n", + " ]\n", + ")" + ], + "metadata": { + "id": "FJVUiUDGTmxy" + }, + "execution_count": 50, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Cell 7: Data Preprocessing Function\n", + "\n", + "\n" + ], + "metadata": { + "id": "47wTgAMJTtHQ" + } + }, + { + "cell_type": "code", + "source": [ + "def preprocess_image(image, label):\n", + " image = tf.image.resize(image, (224, 224))\n", + " image = keras.applications.mobilenet_v2.preprocess_input(image)\n", + " return image, label" + ], + "metadata": { + "id": "sVzeZ9T6TtpP", + "collapsed": true + }, + "execution_count": 51, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "\n", + "\n", + "Cell 8: Data Loading (from extracted directory)\n", + "\n", + "\n" + ], + "metadata": { + "id": "TH16t19UTvf9" + } + }, + { + "cell_type": "code", + "source": [ + "dataset_path = '/content/PokemonData/PokemonData'\n", + "\n", + "\n", + "try:\n", + " # 1. Create a dataset for getting class names (with shuffle=False)\n", + " temp_ds = tf.keras.utils.image_dataset_from_directory(\n", + " dataset_path,\n", + " labels='inferred',\n", + " label_mode='categorical',\n", + " image_size=(256, 256),\n", + " batch_size=32,\n", + " shuffle=False # Crucial for consistent class names\n", + " )\n", + " class_names = temp_ds.class_names\n", + " del temp_ds\n", + "\n", + " # 2. Now create the TRAINING dataset (with validation_split and subset)\n", + " train_ds = tf.keras.utils.image_dataset_from_directory(\n", + " dataset_path,\n", + " labels='inferred',\n", + " label_mode='categorical',\n", + " image_size=(256, 256),\n", + " batch_size=32,\n", + " validation_split=0.2,\n", + " subset=\"training\",\n", + " seed=42\n", + " ).map(preprocess_image).cache().prefetch(tf.data.AUTOTUNE)\n", + "\n", + " # 3. Create the VALIDATION dataset (with validation_split and subset)\n", + " val_ds = tf.keras.utils.image_dataset_from_directory(\n", + " dataset_path,\n", + " labels='inferred',\n", + " label_mode='categorical',\n", + " image_size=(256, 256),\n", + " batch_size=32,\n", + " validation_split=0.2,\n", + " subset=\"validation\",\n", + " seed=42\n", + " ).map(preprocess_image).cache().prefetch(tf.data.AUTOTUNE)\n", + "\n", + " # 4. Check and reshape if labels are not one-hot encoded (Important!)\n", + " for images, labels in train_ds.take(1):\n", + " if labels.shape[-1] != 151: # Check if last dimension is not 151\n", + " print(\"Reshaping labels to one-hot encoding...\")\n", + " train_ds = train_ds.map(lambda x, y: (x, tf.keras.utils.to_categorical(y, num_classes=151)))\n", + " val_ds = val_ds.map(lambda x, y: (x, tf.keras.utils.to_categorical(y, num_classes=151)))\n", + " break\n", + "\n", + "except FileNotFoundError:\n", + " print(f\"Error: Dataset not found at {dataset_path}. Check your path in Google Drive and extraction directory.\")\n", + " exit()\n", + "\n", + "for images, labels in train_ds.take(1):\n", + " print(\"Training Images:\", images.shape, \"Training Labels:\", labels.shape)\n", + "\n", + "for images, labels in val_ds.take(1):\n", + " print(\"Validation Images:\", images.shape, \"Validation Labels:\", labels.shape)\n" + ], + "metadata": { + "id": "DXbR_WJKTw9O", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "7ea1b00c-ad7e-496a-d973-905bdaa7cab5" + }, + "execution_count": 52, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Found 11945 files belonging to 151 classes.\n", + "Found 11945 files belonging to 151 classes.\n", + "Using 9556 files for training.\n", + "Found 11945 files belonging to 151 classes.\n", + "Using 2389 files for validation.\n", + "Training Images: (32, 224, 224, 3) Training Labels: (32, 151)\n", + "Validation Images: (32, 224, 224, 3) Validation Labels: (32, 151)\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Cell 9: Visualize Images (Optional)\n", + "\n", + "\n" + ], + "metadata": { + "id": "R5fe7jxNTyYw" + } + }, + { + "cell_type": "code", + "source": [ + "plt.figure(figsize=(10, 10))\n", + "for images, labels in train_ds.take(1):\n", + " for i in range(9):\n", + " ax = plt.subplot(3, 3, i + 1)\n", + " plt.imshow(images[i].numpy().astype(\"uint8\"))\n", + " plt.title(class_names[np.argmax(labels[i])])\n", + " plt.axis(\"off\")\n", + "plt.show()" + ], + "metadata": { + "id": "HFlsEv2ATzlv", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 829 + }, + "outputId": "ff95e50d-0c73-4e8f-ee12-914e90719d0d" + }, + "execution_count": 53, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "\n", + "Cell 10: Train with Frozen Base (with Early Stopping)\n", + "\n", + "\n", + "\n" + ], + "metadata": { + "id": "Dygr8ycOT3Rh" + } + }, + { + "cell_type": "code", + "source": [ + "epochs = 50\n", + "early_stopping = EarlyStopping(monitor='val_loss', patience=5, restore_best_weights=True)\n", + "history = model.fit(train_ds, epochs=epochs, validation_data=val_ds, callbacks=[early_stopping])" + ], + "metadata": { + "id": "Vbx5DMipT8yX", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "cdcfcff2-fa45-443b-dea6-a842f8d5ff9f" + }, + "execution_count": 54, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch 1/50\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 78ms/step - accuracy: 0.0676 - loss: 4.6675 - val_accuracy: 0.4383 - val_loss: 2.6174\n", + "Epoch 2/50\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 36ms/step - accuracy: 0.4297 - loss: 2.3773 - val_accuracy: 0.5956 - val_loss: 1.6886\n", + "Epoch 3/50\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 35ms/step - accuracy: 0.6203 - loss: 1.5152 - val_accuracy: 0.6505 - val_loss: 1.3974\n", + "Epoch 4/50\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 35ms/step - accuracy: 0.6870 - loss: 1.1743 - val_accuracy: 0.6697 - val_loss: 1.2871\n", + "Epoch 5/50\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 35ms/step - accuracy: 0.7493 - loss: 0.9385 - val_accuracy: 0.6735 - val_loss: 1.2500\n", + "Epoch 6/50\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 36ms/step - accuracy: 0.7917 - loss: 0.7771 - val_accuracy: 0.6902 - val_loss: 1.1721\n", + "Epoch 7/50\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 36ms/step - accuracy: 0.8168 - loss: 0.6747 - val_accuracy: 0.7053 - val_loss: 1.1500\n", + "Epoch 8/50\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 35ms/step - accuracy: 0.8444 - loss: 0.5659 - val_accuracy: 0.7087 - val_loss: 1.1245\n", + "Epoch 9/50\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 35ms/step - accuracy: 0.8584 - loss: 0.5161 - val_accuracy: 0.7074 - val_loss: 1.1493\n", + "Epoch 10/50\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 35ms/step - accuracy: 0.8765 - loss: 0.4357 - val_accuracy: 0.7057 - val_loss: 1.1242\n", + "Epoch 11/50\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 35ms/step - accuracy: 0.8904 - loss: 0.3908 - val_accuracy: 0.7091 - val_loss: 1.1308\n", + "Epoch 12/50\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 35ms/step - accuracy: 0.8987 - loss: 0.3545 - val_accuracy: 0.6961 - val_loss: 1.1634\n", + "Epoch 13/50\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 35ms/step - accuracy: 0.9084 - loss: 0.3187 - val_accuracy: 0.7041 - val_loss: 1.1609\n", + "Epoch 14/50\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 35ms/step - accuracy: 0.9230 - loss: 0.2795 - val_accuracy: 0.7120 - val_loss: 1.1786\n", + "Epoch 15/50\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 35ms/step - accuracy: 0.9269 - loss: 0.2526 - val_accuracy: 0.7049 - val_loss: 1.2058\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Cell 11: Unfreeze and Fine-tune (with Early Stopping)\n", + "\n", + "\n" + ], + "metadata": { + "id": "GwrxJDyOUAFT" + } + }, + { + "cell_type": "code", + "source": [ + "base_model.trainable = True\n", + "fine_tune_at = 100\n", + "for layer in base_model.layers[:fine_tune_at]:\n", + " layer.trainable = False\n", + "\n", + "model.compile(\n", + " optimizer=keras.optimizers.Adam(1e-5),\n", + " loss=keras.losses.CategoricalCrossentropy(),\n", + " metrics=['accuracy']\n", + ")\n", + "\n", + "fine_tune_epochs = 50\n", + "total_epochs = epochs + fine_tune_epochs\n", + "early_stopping_fine = EarlyStopping(monitor='val_loss', patience=5, restore_best_weights=True)\n", + "history_fine = model.fit(train_ds,\n", + " epochs=total_epochs,\n", + " initial_epoch=history.epoch[-1],\n", + " validation_data=val_ds,\n", + " callbacks=[early_stopping_fine])" + ], + "metadata": { + "id": "Y87t5ZS5UApw", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "111db28c-05fd-4ec2-a1e9-de7ee848b6c5" + }, + "execution_count": 55, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch 15/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m44s\u001b[0m 88ms/step - accuracy: 0.5786 - loss: 1.5595 - val_accuracy: 0.7233 - val_loss: 1.0693\n", + "Epoch 16/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.7422 - loss: 0.9129 - val_accuracy: 0.7313 - val_loss: 1.0249\n", + "Epoch 17/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.8109 - loss: 0.6619 - val_accuracy: 0.7401 - val_loss: 0.9892\n", + "Epoch 18/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.8512 - loss: 0.5339 - val_accuracy: 0.7505 - val_loss: 0.9601\n", + "Epoch 19/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.8708 - loss: 0.4475 - val_accuracy: 0.7593 - val_loss: 0.9350\n", + "Epoch 20/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9051 - loss: 0.3498 - val_accuracy: 0.7639 - val_loss: 0.9150\n", + "Epoch 21/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9216 - loss: 0.3017 - val_accuracy: 0.7656 - val_loss: 0.8987\n", + "Epoch 22/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9333 - loss: 0.2553 - val_accuracy: 0.7702 - val_loss: 0.8832\n", + "Epoch 23/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9479 - loss: 0.2208 - val_accuracy: 0.7761 - val_loss: 0.8702\n", + "Epoch 24/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9545 - loss: 0.2007 - val_accuracy: 0.7786 - val_loss: 0.8580\n", + "Epoch 25/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9600 - loss: 0.1754 - val_accuracy: 0.7819 - val_loss: 0.8480\n", + "Epoch 26/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9663 - loss: 0.1536 - val_accuracy: 0.7857 - val_loss: 0.8384\n", + "Epoch 27/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9697 - loss: 0.1415 - val_accuracy: 0.7899 - val_loss: 0.8259\n", + "Epoch 28/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9751 - loss: 0.1213 - val_accuracy: 0.7941 - val_loss: 0.8152\n", + "Epoch 29/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9756 - loss: 0.1157 - val_accuracy: 0.7978 - val_loss: 0.8046\n", + "Epoch 30/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9799 - loss: 0.1004 - val_accuracy: 0.8020 - val_loss: 0.7916\n", + "Epoch 31/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9825 - loss: 0.0938 - val_accuracy: 0.8045 - val_loss: 0.7891\n", + "Epoch 32/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9852 - loss: 0.0819 - val_accuracy: 0.8058 - val_loss: 0.7798\n", + "Epoch 33/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━��━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9827 - loss: 0.0841 - val_accuracy: 0.8112 - val_loss: 0.7749\n", + "Epoch 34/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9863 - loss: 0.0722 - val_accuracy: 0.8133 - val_loss: 0.7648\n", + "Epoch 35/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9882 - loss: 0.0654 - val_accuracy: 0.8116 - val_loss: 0.7708\n", + "Epoch 36/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9897 - loss: 0.0588 - val_accuracy: 0.8116 - val_loss: 0.7682\n", + "Epoch 37/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9920 - loss: 0.0512 - val_accuracy: 0.8171 - val_loss: 0.7662\n", + "Epoch 38/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9890 - loss: 0.0541 - val_accuracy: 0.8167 - val_loss: 0.7564\n", + "Epoch 39/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9913 - loss: 0.0485 - val_accuracy: 0.8175 - val_loss: 0.7518\n", + "Epoch 40/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9922 - loss: 0.0473 - val_accuracy: 0.8196 - val_loss: 0.7457\n", + "Epoch 41/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9902 - loss: 0.0476 - val_accuracy: 0.8229 - val_loss: 0.7418\n", + "Epoch 42/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9934 - loss: 0.0375 - val_accuracy: 0.8200 - val_loss: 0.7417\n", + "Epoch 43/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9929 - loss: 0.0378 - val_accuracy: 0.8225 - val_loss: 0.7337\n", + "Epoch 44/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9940 - loss: 0.0358 - val_accuracy: 0.8221 - val_loss: 0.7315\n", + "Epoch 45/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9943 - loss: 0.0344 - val_accuracy: 0.8242 - val_loss: 0.7348\n", + "Epoch 46/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9947 - loss: 0.0334 - val_accuracy: 0.8225 - val_loss: 0.7289\n", + "Epoch 47/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9957 - loss: 0.0295 - val_accuracy: 0.8275 - val_loss: 0.7218\n", + "Epoch 48/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9938 - loss: 0.0315 - val_accuracy: 0.8305 - val_loss: 0.7155\n", + "Epoch 49/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9950 - loss: 0.0268 - val_accuracy: 0.8330 - val_loss: 0.7132\n", + "Epoch 50/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9961 - loss: 0.0267 - val_accuracy: 0.8334 - val_loss: 0.7179\n", + "Epoch 51/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9954 - loss: 0.0256 - val_accuracy: 0.8313 - val_loss: 0.7124\n", + "Epoch 52/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9964 - loss: 0.0237 - val_accuracy: 0.8313 - val_loss: 0.7124\n", + "Epoch 53/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9960 - loss: 0.0247 - val_accuracy: 0.8301 - val_loss: 0.7129\n", + "Epoch 54/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9973 - loss: 0.0205 - val_accuracy: 0.8313 - val_loss: 0.7151\n", + "Epoch 55/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9961 - loss: 0.0214 - val_accuracy: 0.8384 - val_loss: 0.7099\n", + "Epoch 56/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9972 - loss: 0.0192 - val_accuracy: 0.8372 - val_loss: 0.7090\n", + "Epoch 57/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9976 - loss: 0.0187 - val_accuracy: 0.8342 - val_loss: 0.7093\n", + "Epoch 58/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9971 - loss: 0.0172 - val_accuracy: 0.8347 - val_loss: 0.7035\n", + "Epoch 59/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m14s\u001b[0m 48ms/step - accuracy: 0.9984 - loss: 0.0164 - val_accuracy: 0.8342 - val_loss: 0.7038\n", + "Epoch 60/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9986 - loss: 0.0155 - val_accuracy: 0.8338 - val_loss: 0.7013\n", + "Epoch 61/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9980 - loss: 0.0148 - val_accuracy: 0.8376 - val_loss: 0.6995\n", + "Epoch 62/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9975 - loss: 0.0159 - val_accuracy: 0.8359 - val_loss: 0.6991\n", + "Epoch 63/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9981 - loss: 0.0145 - val_accuracy: 0.8393 - val_loss: 0.6981\n", + "Epoch 64/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9976 - loss: 0.0159 - val_accuracy: 0.8393 - val_loss: 0.6946\n", + "Epoch 65/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9986 - loss: 0.0131 - val_accuracy: 0.8368 - val_loss: 0.7040\n", + "Epoch 66/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9990 - loss: 0.0119 - val_accuracy: 0.8409 - val_loss: 0.7008\n", + "Epoch 67/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9977 - loss: 0.0137 - val_accuracy: 0.8430 - val_loss: 0.6999\n", + "Epoch 68/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9978 - loss: 0.0129 - val_accuracy: 0.8414 - val_loss: 0.7073\n", + "Epoch 69/100\n", + "\u001b[1m299/299\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 49ms/step - accuracy: 0.9981 - loss: 0.0119 - val_accuracy: 0.8405 - val_loss: 0.7006\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Cell 12: Convert to TFLite\n", + "\n", + "\n" + ], + "metadata": { + "id": "YWeLskj2UDaH" + } + }, + { + "cell_type": "code", + "source": [ + "converter = tf.lite.TFLiteConverter.from_keras_model(model)\n", + "tflite_model = converter.convert()\n", + "\n", + "with open('pokemon_model.tflite', 'wb') as f:\n", + " f.write(tflite_model)" + ], + "metadata": { + "id": "Kfg0fDANUFTh", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "ff49577e-2552-4c90-f472-7c6b383055bb" + }, + "execution_count": 56, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saved artifact at '/tmp/tmpuwrxapd_'. The following endpoints are available:\n", + "\n", + "* Endpoint 'serve'\n", + " args_0 (POSITIONAL_ONLY): TensorSpec(shape=(None, 224, 224, 3), dtype=tf.float32, name='keras_tensor_474')\n", + "Output Type:\n", + " TensorSpec(shape=(None, 151), dtype=tf.float32, name=None)\n", + "Captures:\n", + " 138453281969552: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452934180560: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452934168240: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452934166128: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452934172640: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453238144464: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452934179504: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452934169648: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138455203890096: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138455203898192: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452934166480: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452383962160: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452383960752: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453270143296: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452383962336: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452933913312: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452383966912: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452383969376: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452383965504: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452383968144: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452383965856: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453283834512: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453283836976: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453283832400: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453283835920: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453283843136: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453283842080: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453283844544: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453283840672: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453283843312: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453283840320: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452400785008: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452400783600: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453283847184: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452400785184: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452400792048: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452400790992: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452400793632: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452400785360: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452400791520: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452400796624: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452400789936: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452400795392: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452400797680: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452400276576: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452383972544: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452400283616: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452400284672: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452400280800: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452400283440: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452400288896: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452400288544: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452400288720: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452400289952: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452567819712: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452400287664: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452567826752: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452567827808: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452567823936: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452567826576: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452567832560: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452567831504: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452567833968: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452567830096: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452567832736: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452567830448: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452567757168: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452567759808: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452567755760: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452567757696: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452567765968: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452567764912: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452567767376: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452567753824: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452567766144: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452400287840: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452567593856: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452567594912: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452567591040: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452567593680: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452567600896: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452567599840: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452567602480: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452567591392: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452567600368: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452567596496: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398591840: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398589376: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398588496: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398592016: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398599056: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398598000: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398600464: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398596592: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398599232: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398596944: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398558016: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398560480: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398555904: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398559424: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398566640: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398565584: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398568048: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398564176: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398566816: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398563824: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398262048: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398260640: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398570688: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398262224: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398269088: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398268032: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398270672: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398262400: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398268560: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398273664: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398266976: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398272432: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398274720: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398540048: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398603632: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398547088: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398548144: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398544272: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398546912: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398554128: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398550608: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398550256: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398551312: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398554304: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398549728: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284772976: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284774032: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284770160: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284772800: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284780192: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284779136: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284781600: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284777728: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284780368: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284778080: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284868640: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284871280: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284867232: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284869168: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284877440: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284876384: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284878848: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284865296: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284877616: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452398549904: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284541488: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284542544: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284538672: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284541312: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284548528: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284547472: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284550112: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284539024: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284548000: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284544128: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284982800: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284983328: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284979456: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284982976: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284988608: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138460132810896: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284993008: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284986144: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284988784: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284660224: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284659168: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284661808: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284657760: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284659696: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284664800: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284619360: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284663568: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284665856: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284618304: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284651776: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284626928: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284627984: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284624112: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284626752: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284633968: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284630448: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284630096: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284631152: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284629920: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284629568: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452903293376: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452903281056: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452903284576: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452903292320: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452903295312: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452903294256: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452903281760: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452903290912: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452903295488: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452903289504: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452903024896: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452903027536: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452903023488: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452903025424: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452903033696: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284987904: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452400717888: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452903988208: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138460132812656: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138456744344240: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452903029296: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452903031936: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452903033168: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452903031408: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452903028416: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284605264: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284607904: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284603856: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284605792: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284614064: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284613008: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284615472: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284601920: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284614240: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453284611248: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452902907744: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452902905280: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452902904400: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452902907920: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452902914784: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452902913728: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452902916368: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452902904576: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452902914256: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138452902919360: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453266762560: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453266760624: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453266763088: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453266762736: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453266769776: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453266768720: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453266771184: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453266767312: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453266769952: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453266774000: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453266808896: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453266809072: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453266775056: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453266810656: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453266772768: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453266816816: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453266819280: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453266815408: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453266818048: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453266824208: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453266815760: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453266816640: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453266821920: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453266824032: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453266822096: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453266738768: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453266742112: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 138453266740352: TensorSpec(shape=(), dtype=tf.resource, name=None)\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Cell 13: Plot Training History\n" + ], + "metadata": { + "id": "jUyGHrCuYPNp" + } + }, + { + "cell_type": "code", + "source": [ + "acc = history.history['accuracy'] + history_fine.history['accuracy']\n", + "val_acc = history.history['val_accuracy'] + history_fine.history['val_accuracy']\n", + "\n", + "loss = history.history['loss'] + history_fine.history['loss']\n", + "val_loss = history.history['val_loss'] + history_fine.history['val_loss']\n", + "\n", + "plt.figure(figsize=(8, 8))\n", + "plt.subplot(2, 1, 1)\n", + "plt.plot(acc, label='Training Accuracy')\n", + "plt.plot(val_acc, label='Validation Accuracy')\n", + "plt.plot([epochs-1, epochs-1], plt.ylim(), label='Start Fine Tuning')\n", + "plt.legend(loc='lower right')\n", + "plt.ylabel('Accuracy')\n", + "plt.title('Training and Validation Accuracy')\n", + "\n", + "plt.subplot(2, 1, 2)\n", + "plt.plot(loss, label='Training Loss')\n", + "plt.plot(val_loss, label='Validation Loss')\n", + "plt.plot([epochs-1, epochs-1], plt.ylim(), label='Start Fine Tuning')\n", + "plt.legend(loc='upper right')\n", + "plt.ylabel('Cross Entropy')\n", + "plt.title('Training and Validation Loss')\n", + "plt.xlabel('epoch')\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 718 + }, + "id": "p9Fz3rV3nqB2", + "outputId": "a417fb56-fb39-4e23-e00d-169105c9751c" + }, + "execution_count": 57, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + } + ] +} \ No newline at end of file