{ "cells": [ { "cell_type": "code", "execution_count": 4, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "fiSLNLacWkDO", "outputId": "84be5341-b11f-4b64-f976-5ef7983b1e00" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Requirement already satisfied: datasets in /usr/local/lib/python3.11/dist-packages (3.6.0)\n", "Requirement already satisfied: filelock in /usr/local/lib/python3.11/dist-packages (from datasets) (3.18.0)\n", "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.11/dist-packages (from datasets) (2.0.2)\n", "Requirement already satisfied: pyarrow>=15.0.0 in /usr/local/lib/python3.11/dist-packages (from datasets) (18.1.0)\n", "Requirement already satisfied: dill<0.3.9,>=0.3.0 in /usr/local/lib/python3.11/dist-packages (from datasets) (0.3.7)\n", "Requirement already satisfied: pandas in /usr/local/lib/python3.11/dist-packages (from datasets) (2.2.2)\n", "Requirement already satisfied: requests>=2.32.2 in /usr/local/lib/python3.11/dist-packages (from datasets) (2.32.3)\n", "Requirement already satisfied: tqdm>=4.66.3 in /usr/local/lib/python3.11/dist-packages (from datasets) (4.67.1)\n", "Requirement already satisfied: xxhash in /usr/local/lib/python3.11/dist-packages (from datasets) (3.5.0)\n", "Requirement already satisfied: multiprocess<0.70.17 in /usr/local/lib/python3.11/dist-packages (from datasets) (0.70.15)\n", "Requirement already satisfied: fsspec<=2025.3.0,>=2023.1.0 in /usr/local/lib/python3.11/dist-packages (from fsspec[http]<=2025.3.0,>=2023.1.0->datasets) (2025.3.0)\n", "Requirement already satisfied: huggingface-hub>=0.24.0 in /usr/local/lib/python3.11/dist-packages (from datasets) (0.32.2)\n", "Requirement already satisfied: packaging in /usr/local/lib/python3.11/dist-packages (from datasets) (24.2)\n", "Requirement already satisfied: pyyaml>=5.1 in /usr/local/lib/python3.11/dist-packages (from datasets) (6.0.2)\n", "Requirement already satisfied: aiohttp!=4.0.0a0,!=4.0.0a1 in /usr/local/lib/python3.11/dist-packages (from fsspec[http]<=2025.3.0,>=2023.1.0->datasets) (3.11.15)\n", "Requirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.11/dist-packages (from huggingface-hub>=0.24.0->datasets) (4.13.2)\n", "Requirement already satisfied: hf-xet<2.0.0,>=1.1.2 in /usr/local/lib/python3.11/dist-packages (from huggingface-hub>=0.24.0->datasets) (1.1.2)\n", "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.11/dist-packages (from requests>=2.32.2->datasets) (3.4.2)\n", "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.11/dist-packages (from requests>=2.32.2->datasets) (3.10)\n", "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.11/dist-packages (from requests>=2.32.2->datasets) (2.4.0)\n", "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.11/dist-packages (from requests>=2.32.2->datasets) (2025.4.26)\n", "Requirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.11/dist-packages (from pandas->datasets) (2.9.0.post0)\n", "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.11/dist-packages (from pandas->datasets) (2025.2)\n", "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.11/dist-packages (from pandas->datasets) (2025.2)\n", "Requirement already satisfied: aiohappyeyeballs>=2.3.0 in /usr/local/lib/python3.11/dist-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<=2025.3.0,>=2023.1.0->datasets) (2.6.1)\n", "Requirement already satisfied: aiosignal>=1.1.2 in /usr/local/lib/python3.11/dist-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<=2025.3.0,>=2023.1.0->datasets) (1.3.2)\n", "Requirement already satisfied: attrs>=17.3.0 in /usr/local/lib/python3.11/dist-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<=2025.3.0,>=2023.1.0->datasets) (25.3.0)\n", "Requirement already satisfied: frozenlist>=1.1.1 in /usr/local/lib/python3.11/dist-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<=2025.3.0,>=2023.1.0->datasets) (1.6.0)\n", "Requirement already satisfied: multidict<7.0,>=4.5 in /usr/local/lib/python3.11/dist-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<=2025.3.0,>=2023.1.0->datasets) (6.4.4)\n", "Requirement already satisfied: propcache>=0.2.0 in /usr/local/lib/python3.11/dist-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<=2025.3.0,>=2023.1.0->datasets) (0.3.1)\n", "Requirement already satisfied: yarl<2.0,>=1.17.0 in /usr/local/lib/python3.11/dist-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<=2025.3.0,>=2023.1.0->datasets) (1.20.0)\n", "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.11/dist-packages (from python-dateutil>=2.8.2->pandas->datasets) (1.17.0)\n" ] } ], "source": [ "!pip install --upgrade datasets" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "mq6Bmp_ocEYp" }, "outputs": [], "source": [ "import tensorflow as tf\n", "from tensorflow import keras\n", "from tensorflow.keras import layers\n", "from tensorflow.keras.applications import VGG16, ResNet50\n", "from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from sklearn.metrics import classification_report, confusion_matrix\n", "import seaborn as sns\n", "from datasets import load_dataset\n", "import pandas as pd\n", "import time\n", "\n", "tf.random.set_seed(42)\n", "np.random.seed(42)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "Xd_u8Dg0cUgO" }, "outputs": [], "source": [ "class TransferLearningClassifier:\n", " def __init__(self, img_size=(224, 224), num_classes=3):\n", " self.img_size = img_size\n", " self.num_classes = num_classes\n", " self.models = {}\n", " self.histories = {}\n", " self.class_names = None\n", "\n", " def load_and_preprocess_dataset(self):\n", " print(\"Loading beans dataset from Hugging Face...\")\n", "\n", " dataset = load_dataset(\"AI-Lab-Makerere/beans\")\n", " self.class_names = dataset['train'].features['labels'].names\n", " print(f\"Classes: {self.class_names}\")\n", "\n", " train_images, train_labels = self._process_split(dataset['train'])\n", " val_images, val_labels = self._process_split(dataset['validation'])\n", " test_images, test_labels = self._process_split(dataset['test'])\n", "\n", " print(f\"Training samples: {len(train_images)}\")\n", " print(f\"Validation samples: {len(val_images)}\")\n", " print(f\"Test samples: {len(test_images)}\")\n", "\n", " return (train_images, train_labels), (val_images, val_labels), (test_images, test_labels)\n", "\n", " def _process_split(self, split):\n", " images = []\n", " labels = []\n", "\n", " for item in split:\n", " img = item['image']\n", " if img.mode != 'RGB':\n", " img = img.convert('RGB')\n", "\n", " img = img.resize(self.img_size)\n", " img_array = np.array(img) / 255.0\n", "\n", " images.append(img_array)\n", " labels.append(item['labels'])\n", "\n", " return np.array(images), np.array(labels)\n", "\n", " def build_baseline_cnn(self):\n", " model = keras.Sequential([\n", " layers.Conv2D(32, (3, 3), activation='relu', input_shape=(*self.img_size, 3)),\n", " layers.MaxPooling2D((2, 2)),\n", " layers.Dropout(0.25),\n", "\n", " layers.Conv2D(64, (3, 3), activation='relu'),\n", " layers.MaxPooling2D((2, 2)),\n", " layers.Dropout(0.25),\n", "\n", " layers.Conv2D(128, (3, 3), activation='relu'),\n", " layers.MaxPooling2D((2, 2)),\n", " layers.Dropout(0.25),\n", "\n", " layers.Conv2D(256, (3, 3), activation='relu'),\n", " layers.MaxPooling2D((2, 2)),\n", " layers.Dropout(0.25),\n", "\n", " layers.Flatten(),\n", " layers.Dense(512, activation='relu'),\n", " layers.Dropout(0.5),\n", " layers.Dense(256, activation='relu'),\n", " layers.Dropout(0.5),\n", " layers.Dense(self.num_classes, activation='softmax')\n", " ], name='baseline_cnn')\n", "\n", " model.compile(\n", " optimizer='adam',\n", " loss='sparse_categorical_crossentropy',\n", " metrics=['accuracy']\n", " )\n", "\n", " return model\n", "\n", " def build_vgg16_transfer_model(self):\n", " base_model = VGG16(\n", " weights='imagenet',\n", " include_top=False,\n", " input_shape=(*self.img_size, 3)\n", " )\n", "\n", " base_model.trainable = False\n", "\n", " model = keras.Sequential([\n", " base_model,\n", " layers.GlobalAveragePooling2D(),\n", " layers.Dense(512, activation='relu'),\n", " layers.Dropout(0.5),\n", " layers.Dense(256, activation='relu'),\n", " layers.Dropout(0.3),\n", " layers.Dense(self.num_classes, activation='softmax')\n", " ], name='vgg16_transfer')\n", "\n", " model.compile(\n", " optimizer=keras.optimizers.Adam(learning_rate=0.0001),\n", " loss='sparse_categorical_crossentropy',\n", " metrics=['accuracy']\n", " )\n", "\n", " return model\n", "\n", " def build_resnet50_transfer_model(self):\n", " base_model = ResNet50(\n", " weights='imagenet',\n", " include_top=False,\n", " input_shape=(*self.img_size, 3)\n", " )\n", "\n", " base_model.trainable = False\n", "\n", " model = keras.Sequential([\n", " base_model,\n", " layers.GlobalAveragePooling2D(),\n", " layers.Dense(512, activation='relu'),\n", " layers.BatchNormalization(),\n", " layers.Dropout(0.5),\n", " layers.Dense(256, activation='relu'),\n", " layers.Dropout(0.3),\n", " layers.Dense(self.num_classes, activation='softmax')\n", " ], name='resnet50_transfer')\n", "\n", " model.compile(\n", " optimizer=keras.optimizers.Adam(learning_rate=0.0001),\n", " loss='sparse_categorical_crossentropy',\n", " metrics=['accuracy']\n", " )\n", "\n", " return model\n", "\n", " def fine_tune_model(self, model, model_name):\n", " if 'vgg16' in model_name.lower():\n", " base_model = model.layers[0]\n", " base_model.trainable = True\n", " for layer in base_model.layers[:-4]:\n", " layer.trainable = False\n", " elif 'resnet50' in model_name.lower():\n", " base_model = model.layers[0]\n", " base_model.trainable = True\n", " for layer in base_model.layers[:-10]:\n", " layer.trainable = False\n", "\n", " model.compile(\n", " optimizer=keras.optimizers.Adam(learning_rate=0.00001),\n", " loss='sparse_categorical_crossentropy',\n", " metrics=['accuracy']\n", " )\n", "\n", " return model\n", "\n", " def get_callbacks(self, model_name):\n", " callbacks = [\n", " EarlyStopping(\n", " monitor='val_accuracy',\n", " patience=15,\n", " restore_best_weights=True,\n", " verbose=1\n", " ),\n", " ModelCheckpoint(\n", " f'best_{model_name}_model.h5',\n", " monitor='val_accuracy',\n", " save_best_only=True,\n", " verbose=1\n", " ),\n", " ReduceLROnPlateau(\n", " monitor='val_loss',\n", " factor=0.2,\n", " patience=5,\n", " min_lr=1e-7,\n", " verbose=1\n", " )\n", " ]\n", " return callbacks\n", "\n", " def train_model(self, model, model_name, train_data, val_data, epochs=50, batch_size=32):\n", " train_images, train_labels = train_data\n", " val_images, val_labels = val_data\n", "\n", " callbacks = self.get_callbacks(model_name)\n", "\n", " print(f\"\\nTraining {model_name}...\")\n", " start_time = time.time()\n", "\n", " history = model.fit(\n", " train_images, train_labels,\n", " batch_size=batch_size,\n", " epochs=epochs,\n", " validation_data=(val_images, val_labels),\n", " callbacks=callbacks,\n", " verbose=1\n", " )\n", "\n", " training_time = time.time() - start_time\n", " print(f\"{model_name} training completed in {training_time:.2f} seconds\")\n", "\n", " self.models[model_name] = model\n", " self.histories[model_name] = history\n", "\n", " return history\n", "\n", " def train_with_fine_tuning(self, model, model_name, train_data, val_data,\n", " initial_epochs=20, fine_tune_epochs=30, batch_size=32):\n", "\n", " print(f\"\\n=== Phase 1: Initial Training ({model_name}) ===\")\n", " history1 = self.train_model(model, f\"{model_name}_initial\", train_data, val_data,\n", " epochs=initial_epochs, batch_size=batch_size)\n", "\n", " print(f\"\\n=== Phase 2: Fine-tuning ({model_name}) ===\")\n", " model = self.fine_tune_model(model, model_name)\n", "\n", " history2 = model.fit(\n", " train_data[0], train_data[1],\n", " batch_size=batch_size,\n", " epochs=fine_tune_epochs,\n", " validation_data=(val_data[0], val_data[1]),\n", " callbacks=self.get_callbacks(f\"{model_name}_finetuned\"),\n", " verbose=1\n", " )\n", "\n", " combined_history = self._combine_histories(history1, history2)\n", "\n", " self.models[model_name] = model\n", " self.histories[model_name] = combined_history\n", "\n", " return combined_history\n", "\n", " def _combine_histories(self, hist1, hist2):\n", " combined = {}\n", " for key in hist1.history.keys():\n", " combined[key] = hist1.history[key] + hist2.history[key]\n", "\n", " class CombinedHistory:\n", " def __init__(self, history_dict):\n", " self.history = history_dict\n", "\n", " return CombinedHistory(combined)\n", "\n", " def evaluate_all_models(self, test_data):\n", " test_images, test_labels = test_data\n", " results = {}\n", "\n", " print(\"\\n\" + \"=\"*80)\n", " print(\"MODEL EVALUATION RESULTS\")\n", " print(\"=\"*80)\n", "\n", " for model_name, model in self.models.items():\n", " print(f\"\\nEvaluating {model_name}...\")\n", "\n", " test_loss, test_accuracy = model.evaluate(test_images, test_labels, verbose=0)\n", " predictions = model.predict(test_images, verbose=0)\n", " predicted_classes = np.argmax(predictions, axis=1)\n", "\n", " report = classification_report(\n", " test_labels, predicted_classes,\n", " target_names=self.class_names,\n", " output_dict=True\n", " )\n", "\n", " cm = confusion_matrix(test_labels, predicted_classes)\n", "\n", " results[model_name] = {\n", " 'test_loss': test_loss,\n", " 'test_accuracy': test_accuracy,\n", " 'predictions': predictions,\n", " 'predicted_classes': predicted_classes,\n", " 'classification_report': report,\n", " 'confusion_matrix': cm\n", " }\n", "\n", " print(f\"{model_name} Test Accuracy: {test_accuracy:.4f}\")\n", " print(f\"{model_name} Test Loss: {test_loss:.4f}\")\n", "\n", " return results\n", "\n", " def generate_detailed_reports(self, results, test_data):\n", " test_images, test_labels = test_data\n", "\n", " print(\"\\n\" + \"=\"*100)\n", " print(\"DETAILED CLASSIFICATION REPORTS\")\n", " print(\"=\"*100)\n", "\n", " for model_name, result in results.items():\n", " print(f\"\\n{model_name.upper()} CLASSIFICATION REPORT:\")\n", " print(\"-\" * 60)\n", " print(classification_report(\n", " test_labels, result['predicted_classes'],\n", " target_names=self.class_names\n", " ))\n", "\n", " self._plot_confusion_matrices(results)\n", " self._plot_training_histories()\n", " self._create_comparison_table(results)\n", "\n", " def _plot_confusion_matrices(self, results):\n", " n_models = len(results)\n", " fig, axes = plt.subplots(1, n_models, figsize=(6*n_models, 5))\n", "\n", " if n_models == 1:\n", " axes = [axes]\n", "\n", " for idx, (model_name, result) in enumerate(results.items()):\n", " cm = result['confusion_matrix']\n", "\n", " sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',\n", " xticklabels=self.class_names, yticklabels=self.class_names,\n", " ax=axes[idx])\n", " axes[idx].set_title(f'{model_name} Confusion Matrix')\n", " axes[idx].set_xlabel('Predicted')\n", " axes[idx].set_ylabel('Actual')\n", "\n", " plt.tight_layout()\n", " plt.savefig('all_confusion_matrices.png', dpi=300, bbox_inches='tight')\n", " plt.show()\n", "\n", " def _plot_training_histories(self):\n", " n_models = len(self.histories)\n", " fig, axes = plt.subplots(2, n_models, figsize=(6*n_models, 10))\n", "\n", " if n_models == 1:\n", " axes = axes.reshape(-1, 1)\n", "\n", " for idx, (model_name, history) in enumerate(self.histories.items()):\n", " axes[0, idx].plot(history.history['accuracy'], label='Training Accuracy')\n", " axes[0, idx].plot(history.history['val_accuracy'], label='Validation Accuracy')\n", " axes[0, idx].set_title(f'{model_name} Accuracy')\n", " axes[0, idx].set_xlabel('Epoch')\n", " axes[0, idx].set_ylabel('Accuracy')\n", " axes[0, idx].legend()\n", " axes[0, idx].grid(True)\n", "\n", " axes[1, idx].plot(history.history['loss'], label='Training Loss')\n", " axes[1, idx].plot(history.history['val_loss'], label='Validation Loss')\n", " axes[1, idx].set_title(f'{model_name} Loss')\n", " axes[1, idx].set_xlabel('Epoch')\n", " axes[1, idx].set_ylabel('Loss')\n", " axes[1, idx].legend()\n", " axes[1, idx].grid(True)\n", "\n", " plt.tight_layout()\n", " plt.savefig('all_training_histories.png', dpi=300, bbox_inches='tight')\n", " plt.show()\n", "\n", " def _create_comparison_table(self, results):\n", " comparison_data = []\n", "\n", " for model_name, result in results.items():\n", " report = result['classification_report']\n", "\n", " row = {\n", " 'Model': model_name,\n", " 'Test Accuracy': result['test_accuracy'],\n", " 'Test Loss': result['test_loss'],\n", " 'Macro Avg Precision': report['macro avg']['precision'],\n", " 'Macro Avg Recall': report['macro avg']['recall'],\n", " 'Macro Avg F1-Score': report['macro avg']['f1-score'],\n", " 'Weighted Avg Precision': report['weighted avg']['precision'],\n", " 'Weighted Avg Recall': report['weighted avg']['recall'],\n", " 'Weighted Avg F1-Score': report['weighted avg']['f1-score']\n", " }\n", "\n", " for class_name in self.class_names:\n", " row[f'{class_name} Precision'] = report[class_name]['precision']\n", " row[f'{class_name} Recall'] = report[class_name]['recall']\n", " row[f'{class_name} F1-Score'] = report[class_name]['f1-score']\n", "\n", " comparison_data.append(row)\n", "\n", " df = pd.DataFrame(comparison_data)\n", "\n", " print(\"\\n\" + \"=\"*120)\n", " print(\"MODEL COMPARISON TABLE\")\n", " print(\"=\"*120)\n", " print(df.round(4).to_string(index=False))\n", "\n", " df.round(4).to_csv('model_comparison.csv', index=False)\n", " print(\"\\nComparison table saved as 'model_comparison.csv'\")\n", "\n", " return df" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "background_save": true, "base_uri": "https://localhost:8080/", "height": 1000, "referenced_widgets": [ "064133d59ba94f34b8a85a2689749c11", "ab01197c5e604f479bad0c0f5ccc9083", "c68364f830084904a4438c55e4e43540", "c25b54b32014477fbe6b6d6c0a9b6a0f", "e89a51d63cb14c7b8f935a055ffffb05", "4500f28a42b949aeae5bf81608d291e2", "95d08e317b0d43b585a68d7b66c07e89", "3ffefea4a5f54843ab8bd2b091e0e9ce", "1d5078a1b9934f8c9fdac1a0c3f0009a", "11ed39f16d6b451d97b092979784165f", "9bac7f89c60643e3800d233651bf9375", "7dbd4fc014654fcbb5a901da3f84f6cc", "a174e70991a34b8284205672af6a7f9c", "8ca3fad55cfc423fbac8ad912e5e640d", "ec502fba22784abb951adea17d6e92cf", "71ade4e34c624e78bb084605aa46d9eb", "4d79a8fc6f1842dbb822ec2b0341dbf1", "3565811a595f473482cc6586c66132ff", "6318871e48c24ef583b1086c2177106d", "daad54685b0441e3995fcd997309ed15", "7d7052c69ada4bd791bd599fc212a123", "3a93189941b74dad870232a745381143", "5da8f888a0ab42cabd59673eb8dadb45", "e823079163174fe8a0317f7f4fd5db85", "e583fbc663d046459a8cd4be77768dc6", "1ecdc8db7e11426baa94355b3583b998", "6beba30ce3834cf78e05b8150681e472", "315a1dadda0a49c896379b1651927bd9", "78400dbd4b894638b066952c5c739605", "bf705be275df4c2196888a08ed35fb53", "03740d2fc4994d87a132fb718a82dbc9", "79b7fe254d8f43648ef78375dfb435c9", "18173592fa7a462a846292b669aa17da", "d8b6bf983a6f4b4197297f9fee965259", "ecc250699c7247b8b5d8b803db5c46d3", "eacffde253464c93831a7be8a8492c77", "fcac1865e83e4c0c929c426b3145b732", "ba125eb6c0004c1ca0494b3911c4a719", "f3dff036008b4955b6509c0e296fde82", "94de925f314f45fdb3bd6fb150eb7562", "9cf6cb50630547d78ca166ef3adb2ea3", "77c04244da1b466fb76274a0f7d55067", "34b2bb9d2ff6431eba4b38fcfb5798d0", "708fb1be8d334f3b8a48323ee17fd2c8", "ac1e02bbca464d779340ec3f8fd6a071", "9e4e00f80fc744898df9a1c82654c15a", "8f3d2ad1755b4f518310200b52d664ef", "ae52ad0f94514e178fb30f84787d97eb", "2c7f2e15ad964de4831ff6b6c21b7665", "86a66d9b1d5144c88ca7c0347368cda1", "00967fb0bc494db29242b6b400db920a", "8cc0e05b37aa4b9b9ecd4019a8dd765b", "e49c9151d2d842549d1627905c7754b4", "c308654204964a5c9a8788c1c2531e1e", "cd82c211a3fb424c90262f8cb1fdc5b0", "71e188c65ee4415aa486a339b060d28c", "4f33d403ec244f3b8dd88cd2671715f0", "0661e6c99f49485587d6dc08541840a7", "26cf42f0d9a04920a316ae013e405655", "3e0e2887778041109de0a60118f06f0b", "cde6b27e0ed1483fadb7dc67296e7e01", "d127e48c331f4aee80c62ce25383c689", "fde30f8471d349a0a5e92f48d93b680b", "58038761ae8c422fa8019b33d8b50d2d", "fe85c9a7dd7943cc99a78a28d747ecd8", "fceb8c33d3084ac584807221b577c327", "c42142e1fae9450e8ba3d23532508681", "39cee2cdf4a14f27a2fcde5e9f35723d", "ea68697adf374bfabdfd9e139616a8f3", "e2fd46ce8e6a4d61bfed998a5268596a", "8ea94d24bdc74531b5367c1abde89dcb", "9576c7e7166046cc8f17daa266cbd6a7", "e8e5f1e9269c4aa3b11771c70f981809", "3664148b2ff146b691f98b16524087de", "32781f022fc64d8abc353fa69c7611e8", "b143024e14ed44928c84f010fd3a6377", "22fb3c804fd9488a8fba551a2cfea705" ] }, "id": "sJKUld81ca55", "outputId": "0e34ac22-f264-472f-f985-b42dbb26eaa5" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Bean Leaf Disease Classification - Transfer Learning Comparison\n", "======================================================================\n", "Loading beans dataset from Hugging Face...\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/local/lib/python3.11/dist-packages/huggingface_hub/utils/_auth.py:94: UserWarning: \n", "The secret `HF_TOKEN` does not exist in your Colab secrets.\n", "To authenticate with the Hugging Face Hub, create a token in your settings tab (https://huggingface.co/settings/tokens), set it as secret in your Google Colab and restart your session.\n", "You will be able to reuse this secret in all of your notebooks.\n", "Please note that authentication is recommended but still optional to access public models or datasets.\n", " warnings.warn(\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "064133d59ba94f34b8a85a2689749c11", "version_major": 2, "version_minor": 0 }, "text/plain": [ "README.md: 0%| | 0.00/4.95k [00:00" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "\n", "========================================================================================================================\n", "MODEL COMPARISON TABLE\n", "========================================================================================================================\n", " Model Test Accuracy Test Loss Macro Avg Precision Macro Avg Recall Macro Avg F1-Score Weighted Avg Precision Weighted Avg Recall Weighted Avg F1-Score angular_leaf_spot Precision angular_leaf_spot Recall angular_leaf_spot F1-Score bean_rust Precision bean_rust Recall bean_rust F1-Score healthy Precision healthy Recall healthy F1-Score\n", " baseline_cnn 0.8516 0.4557 0.8594 0.8514 0.8527 0.8585 0.8516 0.8524 0.8333 0.9302 0.8791 0.7727 0.7907 0.7816 0.9722 0.8333 0.8974\n", " vgg16_transfer_initial 0.9297 0.2107 0.9343 0.9300 0.9305 0.9338 0.9297 0.9300 0.9487 0.8605 0.9024 0.8542 0.9535 0.9011 1.0000 0.9762 0.9880\n", " vgg16_transfer 0.9297 0.2107 0.9343 0.9300 0.9305 0.9338 0.9297 0.9300 0.9487 0.8605 0.9024 0.8542 0.9535 0.9011 1.0000 0.9762 0.9880\n", "resnet50_transfer_initial 0.6875 0.7403 0.6873 0.6879 0.6854 0.6876 0.6875 0.6854 0.7674 0.7674 0.7674 0.6486 0.5581 0.6000 0.6458 0.7381 0.6889\n", " resnet50_transfer 0.6875 0.7403 0.6873 0.6879 0.6854 0.6876 0.6875 0.6854 0.7674 0.7674 0.7674 0.6486 0.5581 0.6000 0.6458 0.7381 0.6889\n", "\n", "Comparison table saved as 'model_comparison.csv'\n", "\n", "================================================================================\n", "TRAINING AND EVALUATION COMPLETED!\n", "================================================================================\n", "Files generated:\n", "- best_baseline_cnn_model.h5\n", "- best_vgg16_transfer_model.h5\n", "- best_resnet50_transfer_model.h5\n", "- all_confusion_matrices.png\n", "- all_training_histories.png\n", "- model_comparison.csv\n" ] } ], "source": [ "def main():\n", " print(\"Bean Leaf Disease Classification - Transfer Learning Comparison\")\n", " print(\"=\"*70)\n", "\n", " classifier = TransferLearningClassifier(img_size=(224, 224), num_classes=3)\n", "\n", " train_data, val_data, test_data = classifier.load_and_preprocess_dataset()\n", "\n", " print(\"\\n=== BUILDING AND TRAINING MODELS ===\")\n", "\n", " baseline_model = classifier.build_baseline_cnn()\n", " print(\"Baseline CNN model built\")\n", "\n", " vgg16_model = classifier.build_vgg16_transfer_model()\n", " print(\"VGG16 transfer model built\")\n", "\n", " resnet50_model = classifier.build_resnet50_transfer_model()\n", " print(\"ResNet50 transfer model built\")\n", "\n", " classifier.train_model(baseline_model, \"baseline_cnn\", train_data, val_data, epochs=50)\n", "\n", " classifier.train_with_fine_tuning(vgg16_model, \"vgg16_transfer\", train_data, val_data,\n", " initial_epochs=20, fine_tune_epochs=30)\n", "\n", " classifier.train_with_fine_tuning(resnet50_model, \"resnet50_transfer\", train_data, val_data,\n", " initial_epochs=20, fine_tune_epochs=30)\n", "\n", " results = classifier.evaluate_all_models(test_data)\n", "\n", " classifier.generate_detailed_reports(results, test_data)\n", "\n", " print(\"\\n\" + \"=\"*80)\n", " print(\"TRAINING AND EVALUATION COMPLETED!\")\n", " print(\"=\"*80)\n", " print(\"Files generated:\")\n", " print(\"- best_baseline_cnn_model.h5\")\n", " print(\"- best_vgg16_transfer_model.h5\")\n", " print(\"- best_resnet50_transfer_model.h5\")\n", " print(\"- all_confusion_matrices.png\")\n", " print(\"- all_training_histories.png\")\n", " print(\"- model_comparison.csv\")\n", "\n", "if __name__ == \"__main__\":\n", " main()" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "id": "RNf-LfA4lrIR", "colab": { "base_uri": "https://localhost:8080/", "height": 1000 }, "outputId": "8b148b41-f697-4f00-bca1-051e1f4cb412" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Bean Leaf Disease Classification - Transfer Learning Comparison\n", "======================================================================\n", "User: sntsemilio\n", "Start Time: 2025-06-05 04:02:02 UTC\n", "======================================================================\n", "Models will be saved to: models_sntsemilio_20250605_040202\n", "User: sntsemilio | Date: 2025-06-05 04:02:02 UTC\n", "Loading beans dataset from Hugging Face...\n", "Classes: ['angular_leaf_spot', 'bean_rust', 'healthy']\n", "Training samples: 1034\n", "Validation samples: 133\n", "Test samples: 128\n", "\n", "=== BUILDING AND TRAINING MODELS ===\n", "Baseline CNN model built\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "/usr/local/lib/python3.11/dist-packages/keras/src/layers/convolutional/base_conv.py:107: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n", " super().__init__(activity_regularizer=activity_regularizer, **kwargs)\n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "VGG16 transfer model built\n", "ResNet50 transfer model built\n", "\n", "Training baseline_cnn...\n", "Epoch 1/50\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 247ms/step - accuracy: 0.3324 - loss: 1.3709\n", "Epoch 1: val_accuracy improved from -inf to 0.57143, saving model to models_sntsemilio_20250605_040202/best_baseline_cnn_model.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 313ms/step - accuracy: 0.3338 - loss: 1.3652 - val_accuracy: 0.5714 - val_loss: 0.9577 - learning_rate: 0.0010\n", "Epoch 2/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - accuracy: 0.5139 - loss: 0.9854\n", "Epoch 2: val_accuracy did not improve from 0.57143\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 67ms/step - accuracy: 0.5159 - loss: 0.9829 - val_accuracy: 0.5639 - val_loss: 0.8745 - learning_rate: 0.0010\n", "Epoch 3/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 60ms/step - accuracy: 0.5428 - loss: 0.9930\n", "Epoch 3: val_accuracy improved from 0.57143 to 0.60150, saving model to models_sntsemilio_20250605_040202/best_baseline_cnn_model.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 89ms/step - accuracy: 0.5445 - loss: 0.9887 - val_accuracy: 0.6015 - val_loss: 0.8453 - learning_rate: 0.0010\n", "Epoch 4/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 60ms/step - accuracy: 0.5691 - loss: 0.9094\n", "Epoch 4: val_accuracy improved from 0.60150 to 0.60902, saving model to models_sntsemilio_20250605_040202/best_baseline_cnn_model.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 89ms/step - accuracy: 0.5704 - loss: 0.9068 - val_accuracy: 0.6090 - val_loss: 0.8114 - learning_rate: 0.0010\n", "Epoch 5/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 59ms/step - accuracy: 0.5783 - loss: 0.8934\n", "Epoch 5: val_accuracy did not improve from 0.60902\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 64ms/step - accuracy: 0.5807 - loss: 0.8902 - val_accuracy: 0.5714 - val_loss: 0.7988 - learning_rate: 0.0010\n", "Epoch 6/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 59ms/step - accuracy: 0.5620 - loss: 0.9356\n", "Epoch 6: val_accuracy improved from 0.60902 to 0.62406, saving model to models_sntsemilio_20250605_040202/best_baseline_cnn_model.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 92ms/step - accuracy: 0.5656 - loss: 0.9301 - val_accuracy: 0.6241 - val_loss: 0.7623 - learning_rate: 0.0010\n", "Epoch 7/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - accuracy: 0.6006 - loss: 0.8583\n", "Epoch 7: val_accuracy improved from 0.62406 to 0.69173, saving model to models_sntsemilio_20250605_040202/best_baseline_cnn_model.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 91ms/step - accuracy: 0.6034 - loss: 0.8537 - val_accuracy: 0.6917 - val_loss: 0.6905 - learning_rate: 0.0010\n", "Epoch 8/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - accuracy: 0.6547 - loss: 0.7335\n", "Epoch 8: val_accuracy improved from 0.69173 to 0.78195, saving model to models_sntsemilio_20250605_040202/best_baseline_cnn_model.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 94ms/step - accuracy: 0.6564 - loss: 0.7313 - val_accuracy: 0.7820 - val_loss: 0.6244 - learning_rate: 0.0010\n", "Epoch 9/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - accuracy: 0.6850 - loss: 0.7018\n", "Epoch 9: val_accuracy did not improve from 0.78195\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 66ms/step - accuracy: 0.6866 - loss: 0.6992 - val_accuracy: 0.7594 - val_loss: 0.5312 - learning_rate: 0.0010\n", "Epoch 10/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 59ms/step - accuracy: 0.7039 - loss: 0.6460\n", "Epoch 10: val_accuracy did not improve from 0.78195\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 64ms/step - accuracy: 0.7054 - loss: 0.6433 - val_accuracy: 0.7444 - val_loss: 0.5981 - learning_rate: 0.0010\n", "Epoch 11/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 59ms/step - accuracy: 0.7571 - loss: 0.5546\n", "Epoch 11: val_accuracy did not improve from 0.78195\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 62ms/step - accuracy: 0.7590 - loss: 0.5527 - val_accuracy: 0.7594 - val_loss: 0.5971 - learning_rate: 0.0010\n", "Epoch 12/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 58ms/step - accuracy: 0.7706 - loss: 0.5446\n", "Epoch 12: val_accuracy did not improve from 0.78195\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 63ms/step - accuracy: 0.7722 - loss: 0.5414 - val_accuracy: 0.7519 - val_loss: 0.5850 - learning_rate: 0.0010\n", "Epoch 13/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 60ms/step - accuracy: 0.7704 - loss: 0.5899\n", "Epoch 13: val_accuracy improved from 0.78195 to 0.81955, saving model to models_sntsemilio_20250605_040202/best_baseline_cnn_model.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 128ms/step - accuracy: 0.7728 - loss: 0.5848 - val_accuracy: 0.8195 - val_loss: 0.4517 - learning_rate: 0.0010\n", "Epoch 14/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 60ms/step - accuracy: 0.7728 - loss: 0.5504\n", "Epoch 14: val_accuracy did not improve from 0.81955\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 65ms/step - accuracy: 0.7750 - loss: 0.5460 - val_accuracy: 0.7293 - val_loss: 0.5651 - learning_rate: 0.0010\n", "Epoch 15/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 59ms/step - accuracy: 0.8240 - loss: 0.4196\n", "Epoch 15: val_accuracy did not improve from 0.81955\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 62ms/step - accuracy: 0.8259 - loss: 0.4165 - val_accuracy: 0.7820 - val_loss: 0.5702 - learning_rate: 0.0010\n", "Epoch 16/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 59ms/step - accuracy: 0.8570 - loss: 0.3420\n", "Epoch 16: val_accuracy did not improve from 0.81955\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 62ms/step - accuracy: 0.8580 - loss: 0.3401 - val_accuracy: 0.8045 - val_loss: 0.5027 - learning_rate: 0.0010\n", "Epoch 17/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 59ms/step - accuracy: 0.8736 - loss: 0.3096\n", "Epoch 17: val_accuracy did not improve from 0.81955\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 62ms/step - accuracy: 0.8747 - loss: 0.3077 - val_accuracy: 0.7669 - val_loss: 0.5964 - learning_rate: 0.0010\n", "Epoch 18/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 59ms/step - accuracy: 0.8801 - loss: 0.2903\n", "Epoch 18: val_accuracy did not improve from 0.81955\n", "\n", "Epoch 18: ReduceLROnPlateau reducing learning rate to 0.00020000000949949026.\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 65ms/step - accuracy: 0.8801 - loss: 0.2909 - val_accuracy: 0.7820 - val_loss: 0.6393 - learning_rate: 0.0010\n", "Epoch 19/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - accuracy: 0.8991 - loss: 0.2402\n", "Epoch 19: val_accuracy did not improve from 0.81955\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 65ms/step - accuracy: 0.9003 - loss: 0.2383 - val_accuracy: 0.8045 - val_loss: 0.4273 - learning_rate: 2.0000e-04\n", "Epoch 20/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 59ms/step - accuracy: 0.9163 - loss: 0.1996\n", "Epoch 20: val_accuracy did not improve from 0.81955\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 62ms/step - accuracy: 0.9168 - loss: 0.1993 - val_accuracy: 0.7970 - val_loss: 0.4227 - learning_rate: 2.0000e-04\n", "Epoch 21/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 59ms/step - accuracy: 0.9461 - loss: 0.1666\n", "Epoch 21: val_accuracy did not improve from 0.81955\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 62ms/step - accuracy: 0.9459 - loss: 0.1661 - val_accuracy: 0.8120 - val_loss: 0.4231 - learning_rate: 2.0000e-04\n", "Epoch 22/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 58ms/step - accuracy: 0.9506 - loss: 0.1406\n", "Epoch 22: val_accuracy improved from 0.81955 to 0.84962, saving model to models_sntsemilio_20250605_040202/best_baseline_cnn_model.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 93ms/step - accuracy: 0.9505 - loss: 0.1401 - val_accuracy: 0.8496 - val_loss: 0.4022 - learning_rate: 2.0000e-04\n", "Epoch 23/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 60ms/step - accuracy: 0.9343 - loss: 0.1338\n", "Epoch 23: val_accuracy did not improve from 0.84962\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 65ms/step - accuracy: 0.9354 - loss: 0.1328 - val_accuracy: 0.8346 - val_loss: 0.4223 - learning_rate: 2.0000e-04\n", "Epoch 24/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 60ms/step - accuracy: 0.9518 - loss: 0.1072\n", "Epoch 24: val_accuracy did not improve from 0.84962\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 63ms/step - accuracy: 0.9526 - loss: 0.1063 - val_accuracy: 0.8496 - val_loss: 0.4225 - learning_rate: 2.0000e-04\n", "Epoch 25/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 59ms/step - accuracy: 0.9509 - loss: 0.1187\n", "Epoch 25: val_accuracy did not improve from 0.84962\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 62ms/step - accuracy: 0.9514 - loss: 0.1181 - val_accuracy: 0.8421 - val_loss: 0.4578 - learning_rate: 2.0000e-04\n", "Epoch 26/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 59ms/step - accuracy: 0.9548 - loss: 0.1090\n", "Epoch 26: val_accuracy did not improve from 0.84962\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 64ms/step - accuracy: 0.9552 - loss: 0.1087 - val_accuracy: 0.8421 - val_loss: 0.4419 - learning_rate: 2.0000e-04\n", "Epoch 27/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 59ms/step - accuracy: 0.9593 - loss: 0.1021\n", "Epoch 27: val_accuracy did not improve from 0.84962\n", "\n", "Epoch 27: ReduceLROnPlateau reducing learning rate to 4.0000001899898055e-05.\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 62ms/step - accuracy: 0.9594 - loss: 0.1019 - val_accuracy: 0.8421 - val_loss: 0.4614 - learning_rate: 2.0000e-04\n", "Epoch 28/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 59ms/step - accuracy: 0.9726 - loss: 0.0816\n", "Epoch 28: val_accuracy improved from 0.84962 to 0.85714, saving model to models_sntsemilio_20250605_040202/best_baseline_cnn_model.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 98ms/step - accuracy: 0.9728 - loss: 0.0814 - val_accuracy: 0.8571 - val_loss: 0.4349 - learning_rate: 4.0000e-05\n", "Epoch 29/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 60ms/step - accuracy: 0.9667 - loss: 0.0899\n", "Epoch 29: val_accuracy improved from 0.85714 to 0.86466, saving model to models_sntsemilio_20250605_040202/best_baseline_cnn_model.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 92ms/step - accuracy: 0.9668 - loss: 0.0898 - val_accuracy: 0.8647 - val_loss: 0.4326 - learning_rate: 4.0000e-05\n", "Epoch 30/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 59ms/step - accuracy: 0.9693 - loss: 0.0792\n", "Epoch 30: val_accuracy did not improve from 0.86466\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 62ms/step - accuracy: 0.9694 - loss: 0.0790 - val_accuracy: 0.8647 - val_loss: 0.4276 - learning_rate: 4.0000e-05\n", "Epoch 31/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 60ms/step - accuracy: 0.9718 - loss: 0.0788\n", "Epoch 31: val_accuracy did not improve from 0.86466\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 63ms/step - accuracy: 0.9719 - loss: 0.0785 - val_accuracy: 0.8571 - val_loss: 0.4464 - learning_rate: 4.0000e-05\n", "Epoch 32/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - accuracy: 0.9723 - loss: 0.0780\n", "Epoch 32: val_accuracy did not improve from 0.86466\n", "\n", "Epoch 32: ReduceLROnPlateau reducing learning rate to 8.000000525498762e-06.\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 67ms/step - accuracy: 0.9724 - loss: 0.0776 - val_accuracy: 0.8647 - val_loss: 0.4363 - learning_rate: 4.0000e-05\n", "Epoch 33/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 60ms/step - accuracy: 0.9697 - loss: 0.0760\n", "Epoch 33: val_accuracy did not improve from 0.86466\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 63ms/step - accuracy: 0.9700 - loss: 0.0753 - val_accuracy: 0.8647 - val_loss: 0.4358 - learning_rate: 8.0000e-06\n", "Epoch 34/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 60ms/step - accuracy: 0.9755 - loss: 0.0625\n", "Epoch 34: val_accuracy did not improve from 0.86466\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 63ms/step - accuracy: 0.9752 - loss: 0.0628 - val_accuracy: 0.8647 - val_loss: 0.4360 - learning_rate: 8.0000e-06\n", "Epoch 35/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 59ms/step - accuracy: 0.9682 - loss: 0.0779\n", "Epoch 35: val_accuracy did not improve from 0.86466\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 63ms/step - accuracy: 0.9680 - loss: 0.0778 - val_accuracy: 0.8647 - val_loss: 0.4396 - learning_rate: 8.0000e-06\n", "Epoch 36/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 59ms/step - accuracy: 0.9814 - loss: 0.0557\n", "Epoch 36: val_accuracy did not improve from 0.86466\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 64ms/step - accuracy: 0.9816 - loss: 0.0557 - val_accuracy: 0.8647 - val_loss: 0.4427 - learning_rate: 8.0000e-06\n", "Epoch 37/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 60ms/step - accuracy: 0.9809 - loss: 0.0690\n", "Epoch 37: val_accuracy did not improve from 0.86466\n", "\n", "Epoch 37: ReduceLROnPlateau reducing learning rate to 1.6000001778593287e-06.\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 66ms/step - accuracy: 0.9807 - loss: 0.0688 - val_accuracy: 0.8647 - val_loss: 0.4451 - learning_rate: 8.0000e-06\n", "Epoch 38/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - accuracy: 0.9842 - loss: 0.0584\n", "Epoch 38: val_accuracy did not improve from 0.86466\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 65ms/step - accuracy: 0.9839 - loss: 0.0585 - val_accuracy: 0.8647 - val_loss: 0.4447 - learning_rate: 1.6000e-06\n", "Epoch 39/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 59ms/step - accuracy: 0.9756 - loss: 0.0782\n", "Epoch 39: val_accuracy did not improve from 0.86466\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 63ms/step - accuracy: 0.9758 - loss: 0.0775 - val_accuracy: 0.8647 - val_loss: 0.4458 - learning_rate: 1.6000e-06\n", "Epoch 40/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 60ms/step - accuracy: 0.9689 - loss: 0.0913\n", "Epoch 40: val_accuracy did not improve from 0.86466\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 63ms/step - accuracy: 0.9691 - loss: 0.0905 - val_accuracy: 0.8647 - val_loss: 0.4448 - learning_rate: 1.6000e-06\n", "Epoch 41/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 59ms/step - accuracy: 0.9745 - loss: 0.0695\n", "Epoch 41: val_accuracy did not improve from 0.86466\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 64ms/step - accuracy: 0.9748 - loss: 0.0689 - val_accuracy: 0.8647 - val_loss: 0.4445 - learning_rate: 1.6000e-06\n", "Epoch 42/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 59ms/step - accuracy: 0.9560 - loss: 0.0858\n", "Epoch 42: val_accuracy did not improve from 0.86466\n", "\n", "Epoch 42: ReduceLROnPlateau reducing learning rate to 3.200000264769187e-07.\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 63ms/step - accuracy: 0.9571 - loss: 0.0846 - val_accuracy: 0.8647 - val_loss: 0.4451 - learning_rate: 1.6000e-06\n", "Epoch 43/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - accuracy: 0.9753 - loss: 0.0751\n", "Epoch 43: val_accuracy did not improve from 0.86466\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 66ms/step - accuracy: 0.9756 - loss: 0.0746 - val_accuracy: 0.8647 - val_loss: 0.4452 - learning_rate: 3.2000e-07\n", "Epoch 44/50\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 59ms/step - accuracy: 0.9672 - loss: 0.0807\n", "Epoch 44: val_accuracy did not improve from 0.86466\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 64ms/step - accuracy: 0.9676 - loss: 0.0801 - val_accuracy: 0.8647 - val_loss: 0.4453 - learning_rate: 3.2000e-07\n", "Epoch 44: early stopping\n", "Restoring model weights from the end of the best epoch: 29.\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "baseline_cnn training completed in 142.16 seconds\n", "Final model saved: models_sntsemilio_20250605_040202/final_baseline_cnn_model.h5\n", "\n", "=== Phase 1: Initial Training (vgg16_transfer) ===\n", "Epoch 1/20\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 202ms/step - accuracy: 0.3725 - loss: 1.1731\n", "Epoch 1: val_accuracy improved from -inf to 0.58647, saving model to models_sntsemilio_20250605_040202/best_vgg16_transfer_model_initial.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m14s\u001b[0m 308ms/step - accuracy: 0.3721 - loss: 1.1734 - val_accuracy: 0.5865 - val_loss: 1.0450 - learning_rate: 1.0000e-04\n", "Epoch 2/20\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 152ms/step - accuracy: 0.3881 - loss: 1.1477\n", "Epoch 2: val_accuracy improved from 0.58647 to 0.70677, saving model to models_sntsemilio_20250605_040202/best_vgg16_transfer_model_initial.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 203ms/step - accuracy: 0.3888 - loss: 1.1468 - val_accuracy: 0.7068 - val_loss: 0.9881 - learning_rate: 1.0000e-04\n", "Epoch 3/20\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 152ms/step - accuracy: 0.4184 - loss: 1.0877\n", "Epoch 3: val_accuracy did not improve from 0.70677\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 174ms/step - accuracy: 0.4191 - loss: 1.0871 - val_accuracy: 0.6767 - val_loss: 0.9368 - learning_rate: 1.0000e-04\n", "Epoch 4/20\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 154ms/step - accuracy: 0.5148 - loss: 0.9854\n", "Epoch 4: val_accuracy did not improve from 0.70677\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 176ms/step - accuracy: 0.5147 - loss: 0.9852 - val_accuracy: 0.6992 - val_loss: 0.8864 - learning_rate: 1.0000e-04\n", "Epoch 5/20\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 154ms/step - accuracy: 0.5381 - loss: 0.9546\n", "Epoch 5: val_accuracy did not improve from 0.70677\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 195ms/step - accuracy: 0.5390 - loss: 0.9541 - val_accuracy: 0.6842 - val_loss: 0.8402 - learning_rate: 1.0000e-04\n", "Epoch 6/20\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 155ms/step - accuracy: 0.5561 - loss: 0.9303\n", "Epoch 6: val_accuracy improved from 0.70677 to 0.72180, saving model to models_sntsemilio_20250605_040202/best_vgg16_transfer_model_initial.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 185ms/step - accuracy: 0.5567 - loss: 0.9295 - val_accuracy: 0.7218 - val_loss: 0.7894 - learning_rate: 1.0000e-04\n", "Epoch 7/20\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 154ms/step - accuracy: 0.5805 - loss: 0.8777\n", "Epoch 7: val_accuracy improved from 0.72180 to 0.74436, saving model to models_sntsemilio_20250605_040202/best_vgg16_transfer_model_initial.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 183ms/step - accuracy: 0.5809 - loss: 0.8773 - val_accuracy: 0.7444 - val_loss: 0.7511 - learning_rate: 1.0000e-04\n", "Epoch 8/20\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 154ms/step - accuracy: 0.6004 - loss: 0.8254\n", "Epoch 8: val_accuracy did not improve from 0.74436\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 178ms/step - accuracy: 0.6008 - loss: 0.8248 - val_accuracy: 0.7368 - val_loss: 0.7191 - learning_rate: 1.0000e-04\n", "Epoch 9/20\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 155ms/step - accuracy: 0.6350 - loss: 0.7914\n", "Epoch 9: val_accuracy improved from 0.74436 to 0.75940, saving model to models_sntsemilio_20250605_040202/best_vgg16_transfer_model_initial.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 202ms/step - accuracy: 0.6358 - loss: 0.7905 - val_accuracy: 0.7594 - val_loss: 0.6831 - learning_rate: 1.0000e-04\n", "Epoch 10/20\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 155ms/step - accuracy: 0.6775 - loss: 0.7385\n", "Epoch 10: val_accuracy did not improve from 0.75940\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 196ms/step - accuracy: 0.6781 - loss: 0.7378 - val_accuracy: 0.7594 - val_loss: 0.6596 - learning_rate: 1.0000e-04\n", "Epoch 11/20\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 156ms/step - accuracy: 0.6881 - loss: 0.7270\n", "Epoch 11: val_accuracy improved from 0.75940 to 0.76692, saving model to models_sntsemilio_20250605_040202/best_vgg16_transfer_model_initial.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 184ms/step - accuracy: 0.6883 - loss: 0.7267 - val_accuracy: 0.7669 - val_loss: 0.6364 - learning_rate: 1.0000e-04\n", "Epoch 12/20\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 155ms/step - accuracy: 0.6697 - loss: 0.7407\n", "Epoch 12: val_accuracy did not improve from 0.76692\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 177ms/step - accuracy: 0.6709 - loss: 0.7397 - val_accuracy: 0.7444 - val_loss: 0.6297 - learning_rate: 1.0000e-04\n", "Epoch 13/20\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 156ms/step - accuracy: 0.7074 - loss: 0.6965\n", "Epoch 13: val_accuracy did not improve from 0.76692\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 179ms/step - accuracy: 0.7079 - loss: 0.6959 - val_accuracy: 0.7444 - val_loss: 0.6170 - learning_rate: 1.0000e-04\n", "Epoch 14/20\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 156ms/step - accuracy: 0.6898 - loss: 0.6660\n", "Epoch 14: val_accuracy did not improve from 0.76692\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 197ms/step - accuracy: 0.6908 - loss: 0.6655 - val_accuracy: 0.7594 - val_loss: 0.6015 - learning_rate: 1.0000e-04\n", "Epoch 15/20\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 156ms/step - accuracy: 0.7017 - loss: 0.6591\n", "Epoch 15: val_accuracy did not improve from 0.76692\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 196ms/step - accuracy: 0.7025 - loss: 0.6584 - val_accuracy: 0.7669 - val_loss: 0.5887 - learning_rate: 1.0000e-04\n", "Epoch 16/20\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 157ms/step - accuracy: 0.7229 - loss: 0.6526\n", "Epoch 16: val_accuracy did not improve from 0.76692\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 180ms/step - accuracy: 0.7234 - loss: 0.6520 - val_accuracy: 0.7669 - val_loss: 0.5786 - learning_rate: 1.0000e-04\n", "Epoch 17/20\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 156ms/step - accuracy: 0.7268 - loss: 0.6366\n", "Epoch 17: val_accuracy improved from 0.76692 to 0.78195, saving model to models_sntsemilio_20250605_040202/best_vgg16_transfer_model_initial.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 203ms/step - accuracy: 0.7274 - loss: 0.6361 - val_accuracy: 0.7820 - val_loss: 0.5602 - learning_rate: 1.0000e-04\n", "Epoch 18/20\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 158ms/step - accuracy: 0.7507 - loss: 0.6150\n", "Epoch 18: val_accuracy did not improve from 0.78195\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 180ms/step - accuracy: 0.7510 - loss: 0.6145 - val_accuracy: 0.7744 - val_loss: 0.5604 - learning_rate: 1.0000e-04\n", "Epoch 19/20\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 156ms/step - accuracy: 0.7251 - loss: 0.6215\n", "Epoch 19: val_accuracy improved from 0.78195 to 0.78947, saving model to models_sntsemilio_20250605_040202/best_vgg16_transfer_model_initial.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 204ms/step - accuracy: 0.7259 - loss: 0.6207 - val_accuracy: 0.7895 - val_loss: 0.5424 - learning_rate: 1.0000e-04\n", "Epoch 20/20\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 157ms/step - accuracy: 0.7475 - loss: 0.5963\n", "Epoch 20: val_accuracy did not improve from 0.78947\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 179ms/step - accuracy: 0.7481 - loss: 0.5956 - val_accuracy: 0.7895 - val_loss: 0.5329 - learning_rate: 1.0000e-04\n", "Restoring model weights from the end of the best epoch: 19.\n", "\n", "=== Phase 2: Fine-tuning (vgg16_transfer) ===\n", "Epoch 1/30\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 235ms/step - accuracy: 0.7332 - loss: 0.6069\n", "Epoch 1: val_accuracy improved from -inf to 0.78947, saving model to models_sntsemilio_20250605_040202/best_vgg16_transfer_model_finetuned.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 318ms/step - accuracy: 0.7341 - loss: 0.6059 - val_accuracy: 0.7895 - val_loss: 0.5228 - learning_rate: 1.0000e-05\n", "Epoch 2/30\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - accuracy: 0.8063 - loss: 0.4770\n", "Epoch 2: val_accuracy improved from 0.78947 to 0.81203, saving model to models_sntsemilio_20250605_040202/best_vgg16_transfer_model_finetuned.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 231ms/step - accuracy: 0.8064 - loss: 0.4768 - val_accuracy: 0.8120 - val_loss: 0.4677 - learning_rate: 1.0000e-05\n", "Epoch 3/30\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - accuracy: 0.8285 - loss: 0.4514\n", "Epoch 3: val_accuracy improved from 0.81203 to 0.85714, saving model to models_sntsemilio_20250605_040202/best_vgg16_transfer_model_finetuned.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 233ms/step - accuracy: 0.8287 - loss: 0.4505 - val_accuracy: 0.8571 - val_loss: 0.4099 - learning_rate: 1.0000e-05\n", "Epoch 4/30\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 181ms/step - accuracy: 0.8359 - loss: 0.3940\n", "Epoch 4: val_accuracy did not improve from 0.85714\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 203ms/step - accuracy: 0.8365 - loss: 0.3931 - val_accuracy: 0.8346 - val_loss: 0.3938 - learning_rate: 1.0000e-05\n", "Epoch 5/30\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 181ms/step - accuracy: 0.8747 - loss: 0.3612\n", "Epoch 5: val_accuracy did not improve from 0.85714\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 204ms/step - accuracy: 0.8751 - loss: 0.3600 - val_accuracy: 0.8421 - val_loss: 0.3852 - learning_rate: 1.0000e-05\n", "Epoch 6/30\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 182ms/step - accuracy: 0.8679 - loss: 0.3303\n", "Epoch 6: val_accuracy improved from 0.85714 to 0.87218, saving model to models_sntsemilio_20250605_040202/best_vgg16_transfer_model_finetuned.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 216ms/step - accuracy: 0.8686 - loss: 0.3293 - val_accuracy: 0.8722 - val_loss: 0.3412 - learning_rate: 1.0000e-05\n", "Epoch 7/30\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 183ms/step - accuracy: 0.8972 - loss: 0.2850\n", "Epoch 7: val_accuracy did not improve from 0.87218\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 205ms/step - accuracy: 0.8978 - loss: 0.2840 - val_accuracy: 0.8647 - val_loss: 0.3628 - learning_rate: 1.0000e-05\n", "Epoch 8/30\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 183ms/step - accuracy: 0.9173 - loss: 0.2567\n", "Epoch 8: val_accuracy did not improve from 0.87218\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 224ms/step - accuracy: 0.9176 - loss: 0.2556 - val_accuracy: 0.8571 - val_loss: 0.3326 - learning_rate: 1.0000e-05\n", "Epoch 9/30\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 181ms/step - accuracy: 0.9293 - loss: 0.2256\n", "Epoch 9: val_accuracy did not improve from 0.87218\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 205ms/step - accuracy: 0.9296 - loss: 0.2246 - val_accuracy: 0.8647 - val_loss: 0.3142 - learning_rate: 1.0000e-05\n", "Epoch 10/30\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 181ms/step - accuracy: 0.9345 - loss: 0.1868\n", "Epoch 10: val_accuracy did not improve from 0.87218\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 222ms/step - accuracy: 0.9350 - loss: 0.1861 - val_accuracy: 0.8647 - val_loss: 0.3338 - learning_rate: 1.0000e-05\n", "Epoch 11/30\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 183ms/step - accuracy: 0.9454 - loss: 0.1560\n", "Epoch 11: val_accuracy improved from 0.87218 to 0.87970, saving model to models_sntsemilio_20250605_040202/best_vgg16_transfer_model_finetuned.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 234ms/step - accuracy: 0.9457 - loss: 0.1557 - val_accuracy: 0.8797 - val_loss: 0.3400 - learning_rate: 1.0000e-05\n", "Epoch 12/30\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 182ms/step - accuracy: 0.9536 - loss: 0.1490\n", "Epoch 12: val_accuracy improved from 0.87970 to 0.89474, saving model to models_sntsemilio_20250605_040202/best_vgg16_transfer_model_finetuned.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 214ms/step - accuracy: 0.9540 - loss: 0.1482 - val_accuracy: 0.8947 - val_loss: 0.3280 - learning_rate: 1.0000e-05\n", "Epoch 13/30\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 182ms/step - accuracy: 0.9563 - loss: 0.1404\n", "Epoch 13: val_accuracy did not improve from 0.89474\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 223ms/step - accuracy: 0.9566 - loss: 0.1397 - val_accuracy: 0.8872 - val_loss: 0.3009 - learning_rate: 1.0000e-05\n", "Epoch 14/30\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 182ms/step - accuracy: 0.9687 - loss: 0.1106\n", "Epoch 14: val_accuracy did not improve from 0.89474\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 224ms/step - accuracy: 0.9688 - loss: 0.1103 - val_accuracy: 0.8797 - val_loss: 0.3098 - learning_rate: 1.0000e-05\n", "Epoch 15/30\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 181ms/step - accuracy: 0.9756 - loss: 0.1068\n", "Epoch 15: val_accuracy did not improve from 0.89474\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 222ms/step - accuracy: 0.9756 - loss: 0.1063 - val_accuracy: 0.8947 - val_loss: 0.3089 - learning_rate: 1.0000e-05\n", "Epoch 16/30\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 181ms/step - accuracy: 0.9869 - loss: 0.0773\n", "Epoch 16: val_accuracy did not improve from 0.89474\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 204ms/step - accuracy: 0.9869 - loss: 0.0771 - val_accuracy: 0.8947 - val_loss: 0.2992 - learning_rate: 1.0000e-05\n", "Epoch 17/30\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 181ms/step - accuracy: 0.9829 - loss: 0.0724\n", "Epoch 17: val_accuracy improved from 0.89474 to 0.90226, saving model to models_sntsemilio_20250605_040202/best_vgg16_transfer_model_finetuned.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 214ms/step - accuracy: 0.9831 - loss: 0.0720 - val_accuracy: 0.9023 - val_loss: 0.3145 - learning_rate: 1.0000e-05\n", "Epoch 18/30\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 181ms/step - accuracy: 0.9870 - loss: 0.0680\n", "Epoch 18: val_accuracy did not improve from 0.90226\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 203ms/step - accuracy: 0.9870 - loss: 0.0677 - val_accuracy: 0.9023 - val_loss: 0.3050 - learning_rate: 1.0000e-05\n", "Epoch 19/30\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 180ms/step - accuracy: 0.9866 - loss: 0.0606\n", "Epoch 19: val_accuracy did not improve from 0.90226\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 203ms/step - accuracy: 0.9867 - loss: 0.0604 - val_accuracy: 0.8797 - val_loss: 0.3368 - learning_rate: 1.0000e-05\n", "Epoch 20/30\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 181ms/step - accuracy: 0.9929 - loss: 0.0497\n", "Epoch 20: val_accuracy improved from 0.90226 to 0.91729, saving model to models_sntsemilio_20250605_040202/best_vgg16_transfer_model_finetuned.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 212ms/step - accuracy: 0.9929 - loss: 0.0495 - val_accuracy: 0.9173 - val_loss: 0.3085 - learning_rate: 1.0000e-05\n", "Epoch 21/30\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 181ms/step - accuracy: 0.9907 - loss: 0.0505\n", "Epoch 21: val_accuracy did not improve from 0.91729\n", "\n", "Epoch 21: ReduceLROnPlateau reducing learning rate to 1.9999999494757505e-06.\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 222ms/step - accuracy: 0.9908 - loss: 0.0501 - val_accuracy: 0.9023 - val_loss: 0.3062 - learning_rate: 1.0000e-05\n", "Epoch 22/30\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 180ms/step - accuracy: 0.9937 - loss: 0.0371\n", "Epoch 22: val_accuracy did not improve from 0.91729\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 203ms/step - accuracy: 0.9938 - loss: 0.0371 - val_accuracy: 0.9098 - val_loss: 0.3181 - learning_rate: 2.0000e-06\n", "Epoch 23/30\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 182ms/step - accuracy: 0.9869 - loss: 0.0427\n", "Epoch 23: val_accuracy did not improve from 0.91729\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 204ms/step - accuracy: 0.9871 - loss: 0.0424 - val_accuracy: 0.9098 - val_loss: 0.3140 - learning_rate: 2.0000e-06\n", "Epoch 24/30\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 181ms/step - accuracy: 0.9926 - loss: 0.0383\n", "Epoch 24: val_accuracy improved from 0.91729 to 0.92481, saving model to models_sntsemilio_20250605_040202/best_vgg16_transfer_model_finetuned.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 214ms/step - accuracy: 0.9927 - loss: 0.0381 - val_accuracy: 0.9248 - val_loss: 0.3162 - learning_rate: 2.0000e-06\n", "Epoch 25/30\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 182ms/step - accuracy: 0.9972 - loss: 0.0338\n", "Epoch 25: val_accuracy did not improve from 0.92481\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 204ms/step - accuracy: 0.9971 - loss: 0.0337 - val_accuracy: 0.9098 - val_loss: 0.3369 - learning_rate: 2.0000e-06\n", "Epoch 26/30\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 182ms/step - accuracy: 0.9922 - loss: 0.0430\n", "Epoch 26: val_accuracy did not improve from 0.92481\n", "\n", "Epoch 26: ReduceLROnPlateau reducing learning rate to 3.999999989900971e-07.\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 204ms/step - accuracy: 0.9923 - loss: 0.0428 - val_accuracy: 0.9173 - val_loss: 0.3266 - learning_rate: 2.0000e-06\n", "Epoch 27/30\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 181ms/step - accuracy: 0.9973 - loss: 0.0327\n", "Epoch 27: val_accuracy did not improve from 0.92481\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 204ms/step - accuracy: 0.9974 - loss: 0.0325 - val_accuracy: 0.9248 - val_loss: 0.3165 - learning_rate: 4.0000e-07\n", "Epoch 28/30\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 183ms/step - accuracy: 0.9905 - loss: 0.0367\n", "Epoch 28: val_accuracy did not improve from 0.92481\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 206ms/step - accuracy: 0.9907 - loss: 0.0364 - val_accuracy: 0.9248 - val_loss: 0.3159 - learning_rate: 4.0000e-07\n", "Epoch 29/30\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 182ms/step - accuracy: 0.9931 - loss: 0.0327\n", "Epoch 29: val_accuracy did not improve from 0.92481\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 204ms/step - accuracy: 0.9931 - loss: 0.0325 - val_accuracy: 0.9248 - val_loss: 0.3180 - learning_rate: 4.0000e-07\n", "Epoch 30/30\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 182ms/step - accuracy: 0.9961 - loss: 0.0258\n", "Epoch 30: val_accuracy did not improve from 0.92481\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 205ms/step - accuracy: 0.9962 - loss: 0.0257 - val_accuracy: 0.9248 - val_loss: 0.3208 - learning_rate: 4.0000e-07\n", "Restoring model weights from the end of the best epoch: 24.\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "Final fine-tuned model saved: models_sntsemilio_20250605_040202/final_vgg16_transfer_model.h5\n", "\n", "=== Phase 1: Initial Training (resnet50_transfer) ===\n", "Epoch 1/20\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 218ms/step - accuracy: 0.3880 - loss: 1.2372\n", "Epoch 1: val_accuracy improved from -inf to 0.33083, saving model to models_sntsemilio_20250605_040202/best_resnet50_transfer_model_initial.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 475ms/step - accuracy: 0.3879 - loss: 1.2367 - val_accuracy: 0.3308 - val_loss: 1.1272 - learning_rate: 1.0000e-04\n", "Epoch 2/20\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 84ms/step - accuracy: 0.4428 - loss: 1.1451\n", "Epoch 2: val_accuracy did not improve from 0.33083\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 94ms/step - accuracy: 0.4440 - loss: 1.1440 - val_accuracy: 0.3308 - val_loss: 1.1085 - learning_rate: 1.0000e-04\n", "Epoch 3/20\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 83ms/step - accuracy: 0.5342 - loss: 1.0015\n", "Epoch 3: val_accuracy improved from 0.33083 to 0.38346, saving model to models_sntsemilio_20250605_040202/best_resnet50_transfer_model_initial.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 114ms/step - accuracy: 0.5340 - loss: 1.0015 - val_accuracy: 0.3835 - val_loss: 1.0854 - learning_rate: 1.0000e-04\n", "Epoch 4/20\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 82ms/step - accuracy: 0.5533 - loss: 0.9696\n", "Epoch 4: val_accuracy did not improve from 0.38346\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 101ms/step - accuracy: 0.5532 - loss: 0.9687 - val_accuracy: 0.3835 - val_loss: 1.0740 - learning_rate: 1.0000e-04\n", "Epoch 5/20\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 82ms/step - accuracy: 0.5898 - loss: 0.8967\n", "Epoch 5: val_accuracy did not improve from 0.38346\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 93ms/step - accuracy: 0.5897 - loss: 0.8967 - val_accuracy: 0.3759 - val_loss: 1.0711 - learning_rate: 1.0000e-04\n", "Epoch 6/20\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 83ms/step - accuracy: 0.5708 - loss: 0.9230\n", "Epoch 6: val_accuracy improved from 0.38346 to 0.54135, saving model to models_sntsemilio_20250605_040202/best_resnet50_transfer_model_initial.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 117ms/step - accuracy: 0.5728 - loss: 0.9214 - val_accuracy: 0.5414 - val_loss: 1.0439 - learning_rate: 1.0000e-04\n", "Epoch 7/20\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 82ms/step - accuracy: 0.6129 - loss: 0.8502\n", "Epoch 7: val_accuracy did not improve from 0.54135\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 93ms/step - accuracy: 0.6142 - loss: 0.8498 - val_accuracy: 0.4812 - val_loss: 1.0372 - learning_rate: 1.0000e-04\n", "Epoch 8/20\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 82ms/step - accuracy: 0.6166 - loss: 0.8864\n", "Epoch 8: val_accuracy did not improve from 0.54135\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 92ms/step - accuracy: 0.6165 - loss: 0.8847 - val_accuracy: 0.3759 - val_loss: 1.0512 - learning_rate: 1.0000e-04\n", "Epoch 9/20\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 85ms/step - accuracy: 0.6244 - loss: 0.8305\n", "Epoch 9: val_accuracy did not improve from 0.54135\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 96ms/step - accuracy: 0.6244 - loss: 0.8307 - val_accuracy: 0.4286 - val_loss: 1.0305 - learning_rate: 1.0000e-04\n", "Epoch 10/20\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 81ms/step - accuracy: 0.6111 - loss: 0.8554\n", "Epoch 10: val_accuracy improved from 0.54135 to 0.61654, saving model to models_sntsemilio_20250605_040202/best_resnet50_transfer_model_initial.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 111ms/step - accuracy: 0.6126 - loss: 0.8522 - val_accuracy: 0.6165 - val_loss: 0.9727 - learning_rate: 1.0000e-04\n", "Epoch 11/20\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 82ms/step - accuracy: 0.6425 - loss: 0.8060\n", "Epoch 11: val_accuracy improved from 0.61654 to 0.64662, saving model to models_sntsemilio_20250605_040202/best_resnet50_transfer_model_initial.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 127ms/step - accuracy: 0.6430 - loss: 0.8049 - val_accuracy: 0.6466 - val_loss: 0.9458 - learning_rate: 1.0000e-04\n", "Epoch 12/20\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 82ms/step - accuracy: 0.6670 - loss: 0.7968\n", "Epoch 12: val_accuracy improved from 0.64662 to 0.65414, saving model to models_sntsemilio_20250605_040202/best_resnet50_transfer_model_initial.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 121ms/step - accuracy: 0.6675 - loss: 0.7946 - val_accuracy: 0.6541 - val_loss: 0.9107 - learning_rate: 1.0000e-04\n", "Epoch 13/20\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 83ms/step - accuracy: 0.6658 - loss: 0.7563\n", "Epoch 13: val_accuracy did not improve from 0.65414\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 93ms/step - accuracy: 0.6667 - loss: 0.7557 - val_accuracy: 0.5414 - val_loss: 0.9355 - learning_rate: 1.0000e-04\n", "Epoch 14/20\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 83ms/step - accuracy: 0.6396 - loss: 0.8010\n", "Epoch 14: val_accuracy did not improve from 0.65414\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 103ms/step - accuracy: 0.6416 - loss: 0.7984 - val_accuracy: 0.5263 - val_loss: 0.9100 - learning_rate: 1.0000e-04\n", "Epoch 15/20\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 81ms/step - accuracy: 0.6836 - loss: 0.7620\n", "Epoch 15: val_accuracy did not improve from 0.65414\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 92ms/step - accuracy: 0.6834 - loss: 0.7612 - val_accuracy: 0.5789 - val_loss: 0.8892 - learning_rate: 1.0000e-04\n", "Epoch 16/20\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 82ms/step - accuracy: 0.6504 - loss: 0.7998\n", "Epoch 16: val_accuracy did not improve from 0.65414\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 93ms/step - accuracy: 0.6524 - loss: 0.7966 - val_accuracy: 0.5639 - val_loss: 0.9075 - learning_rate: 1.0000e-04\n", "Epoch 17/20\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 84ms/step - accuracy: 0.6812 - loss: 0.7276\n", "Epoch 17: val_accuracy did not improve from 0.65414\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 104ms/step - accuracy: 0.6826 - loss: 0.7259 - val_accuracy: 0.4962 - val_loss: 0.9750 - learning_rate: 1.0000e-04\n", "Epoch 18/20\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 82ms/step - accuracy: 0.6727 - loss: 0.7037\n", "Epoch 18: val_accuracy did not improve from 0.65414\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 102ms/step - accuracy: 0.6734 - loss: 0.7031 - val_accuracy: 0.6090 - val_loss: 0.8549 - learning_rate: 1.0000e-04\n", "Epoch 19/20\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 82ms/step - accuracy: 0.6952 - loss: 0.7157\n", "Epoch 19: val_accuracy did not improve from 0.65414\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 101ms/step - accuracy: 0.6959 - loss: 0.7141 - val_accuracy: 0.5714 - val_loss: 0.9107 - learning_rate: 1.0000e-04\n", "Epoch 20/20\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 84ms/step - accuracy: 0.6893 - loss: 0.7541\n", "Epoch 20: val_accuracy did not improve from 0.65414\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 96ms/step - accuracy: 0.6902 - loss: 0.7516 - val_accuracy: 0.5038 - val_loss: 1.0926 - learning_rate: 1.0000e-04\n", "Restoring model weights from the end of the best epoch: 12.\n", "\n", "=== Phase 2: Fine-tuning (resnet50_transfer) ===\n", "Epoch 1/30\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 275ms/step - accuracy: 0.5178 - loss: 1.1269\n", "Epoch 1: val_accuracy improved from -inf to 0.33083, saving model to models_sntsemilio_20250605_040202/best_resnet50_transfer_model_finetuned.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 544ms/step - accuracy: 0.5183 - loss: 1.1258 - val_accuracy: 0.3308 - val_loss: 2.4122 - learning_rate: 1.0000e-05\n", "Epoch 2/30\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 93ms/step - accuracy: 0.6017 - loss: 0.9034\n", "Epoch 2: val_accuracy did not improve from 0.33083\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 112ms/step - accuracy: 0.6013 - loss: 0.9038 - val_accuracy: 0.3308 - val_loss: 3.9202 - learning_rate: 1.0000e-05\n", "Epoch 3/30\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 92ms/step - accuracy: 0.6383 - loss: 0.8466\n", "Epoch 3: val_accuracy did not improve from 0.33083\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 102ms/step - accuracy: 0.6390 - loss: 0.8454 - val_accuracy: 0.3308 - val_loss: 4.7970 - learning_rate: 1.0000e-05\n", "Epoch 4/30\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 92ms/step - accuracy: 0.6539 - loss: 0.8025\n", "Epoch 4: val_accuracy did not improve from 0.33083\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 103ms/step - accuracy: 0.6546 - loss: 0.8019 - val_accuracy: 0.3308 - val_loss: 5.3888 - learning_rate: 1.0000e-05\n", "Epoch 5/30\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 92ms/step - accuracy: 0.6836 - loss: 0.7625\n", "Epoch 5: val_accuracy did not improve from 0.33083\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 112ms/step - accuracy: 0.6835 - loss: 0.7625 - val_accuracy: 0.3308 - val_loss: 6.0944 - learning_rate: 1.0000e-05\n", "Epoch 6/30\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 92ms/step - accuracy: 0.7226 - loss: 0.6630\n", "Epoch 6: val_accuracy did not improve from 0.33083\n", "\n", "Epoch 6: ReduceLROnPlateau reducing learning rate to 1.9999999494757505e-06.\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 103ms/step - accuracy: 0.7225 - loss: 0.6638 - val_accuracy: 0.3308 - val_loss: 6.5654 - learning_rate: 1.0000e-05\n", "Epoch 7/30\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 92ms/step - accuracy: 0.7274 - loss: 0.6469\n", "Epoch 7: val_accuracy did not improve from 0.33083\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 111ms/step - accuracy: 0.7280 - loss: 0.6457 - val_accuracy: 0.3308 - val_loss: 6.1599 - learning_rate: 2.0000e-06\n", "Epoch 8/30\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 95ms/step - accuracy: 0.7319 - loss: 0.6576\n", "Epoch 8: val_accuracy did not improve from 0.33083\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 106ms/step - accuracy: 0.7325 - loss: 0.6568 - val_accuracy: 0.3308 - val_loss: 5.1411 - learning_rate: 2.0000e-06\n", "Epoch 9/30\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 93ms/step - accuracy: 0.7195 - loss: 0.6239\n", "Epoch 9: val_accuracy improved from 0.33083 to 0.33835, saving model to models_sntsemilio_20250605_040202/best_resnet50_transfer_model_finetuned.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 128ms/step - accuracy: 0.7197 - loss: 0.6244 - val_accuracy: 0.3383 - val_loss: 3.7146 - learning_rate: 2.0000e-06\n", "Epoch 10/30\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 93ms/step - accuracy: 0.7250 - loss: 0.6353\n", "Epoch 10: val_accuracy did not improve from 0.33835\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 105ms/step - accuracy: 0.7256 - loss: 0.6350 - val_accuracy: 0.3383 - val_loss: 2.6253 - learning_rate: 2.0000e-06\n", "Epoch 11/30\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 94ms/step - accuracy: 0.7254 - loss: 0.5993\n", "Epoch 11: val_accuracy improved from 0.33835 to 0.37594, saving model to models_sntsemilio_20250605_040202/best_resnet50_transfer_model_finetuned.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 127ms/step - accuracy: 0.7260 - loss: 0.5997 - val_accuracy: 0.3759 - val_loss: 1.9466 - learning_rate: 2.0000e-06\n", "Epoch 12/30\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 92ms/step - accuracy: 0.7411 - loss: 0.6400\n", "Epoch 12: val_accuracy improved from 0.37594 to 0.42857, saving model to models_sntsemilio_20250605_040202/best_resnet50_transfer_model_finetuned.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 125ms/step - accuracy: 0.7409 - loss: 0.6385 - val_accuracy: 0.4286 - val_loss: 1.5931 - learning_rate: 2.0000e-06\n", "Epoch 13/30\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 95ms/step - accuracy: 0.7418 - loss: 0.6015\n", "Epoch 13: val_accuracy improved from 0.42857 to 0.49624, saving model to models_sntsemilio_20250605_040202/best_resnet50_transfer_model_finetuned.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 129ms/step - accuracy: 0.7426 - loss: 0.5996 - val_accuracy: 0.4962 - val_loss: 1.3080 - learning_rate: 2.0000e-06\n", "Epoch 14/30\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 92ms/step - accuracy: 0.7394 - loss: 0.6257\n", "Epoch 14: val_accuracy improved from 0.49624 to 0.57895, saving model to models_sntsemilio_20250605_040202/best_resnet50_transfer_model_finetuned.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 125ms/step - accuracy: 0.7407 - loss: 0.6238 - val_accuracy: 0.5789 - val_loss: 1.0958 - learning_rate: 2.0000e-06\n", "Epoch 15/30\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 92ms/step - accuracy: 0.7190 - loss: 0.6117\n", "Epoch 15: val_accuracy improved from 0.57895 to 0.59398, saving model to models_sntsemilio_20250605_040202/best_resnet50_transfer_model_finetuned.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 143ms/step - accuracy: 0.7200 - loss: 0.6107 - val_accuracy: 0.5940 - val_loss: 0.9770 - learning_rate: 2.0000e-06\n", "Epoch 16/30\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 92ms/step - accuracy: 0.7661 - loss: 0.5629\n", "Epoch 16: val_accuracy improved from 0.59398 to 0.61654, saving model to models_sntsemilio_20250605_040202/best_resnet50_transfer_model_finetuned.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 134ms/step - accuracy: 0.7671 - loss: 0.5621 - val_accuracy: 0.6165 - val_loss: 0.9052 - learning_rate: 2.0000e-06\n", "Epoch 17/30\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 94ms/step - accuracy: 0.7347 - loss: 0.6233\n", "Epoch 17: val_accuracy improved from 0.61654 to 0.64662, saving model to models_sntsemilio_20250605_040202/best_resnet50_transfer_model_finetuned.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 128ms/step - accuracy: 0.7365 - loss: 0.6213 - val_accuracy: 0.6466 - val_loss: 0.8434 - learning_rate: 2.0000e-06\n", "Epoch 18/30\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 95ms/step - accuracy: 0.7439 - loss: 0.5739\n", "Epoch 18: val_accuracy improved from 0.64662 to 0.65414, saving model to models_sntsemilio_20250605_040202/best_resnet50_transfer_model_finetuned.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 137ms/step - accuracy: 0.7455 - loss: 0.5716 - val_accuracy: 0.6541 - val_loss: 0.8158 - learning_rate: 2.0000e-06\n", "Epoch 19/30\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 93ms/step - accuracy: 0.7517 - loss: 0.5420\n", "Epoch 19: val_accuracy improved from 0.65414 to 0.69173, saving model to models_sntsemilio_20250605_040202/best_resnet50_transfer_model_finetuned.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 134ms/step - accuracy: 0.7531 - loss: 0.5411 - val_accuracy: 0.6917 - val_loss: 0.7988 - learning_rate: 2.0000e-06\n", "Epoch 20/30\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 92ms/step - accuracy: 0.7784 - loss: 0.5483\n", "Epoch 20: val_accuracy did not improve from 0.69173\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 105ms/step - accuracy: 0.7786 - loss: 0.5481 - val_accuracy: 0.6692 - val_loss: 0.7934 - learning_rate: 2.0000e-06\n", "Epoch 21/30\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 94ms/step - accuracy: 0.7477 - loss: 0.5694\n", "Epoch 21: val_accuracy did not improve from 0.69173\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 113ms/step - accuracy: 0.7488 - loss: 0.5674 - val_accuracy: 0.6617 - val_loss: 0.7829 - learning_rate: 2.0000e-06\n", "Epoch 22/30\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 93ms/step - accuracy: 0.7712 - loss: 0.5231\n", "Epoch 22: val_accuracy improved from 0.69173 to 0.69925, saving model to models_sntsemilio_20250605_040202/best_resnet50_transfer_model_finetuned.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 126ms/step - accuracy: 0.7714 - loss: 0.5232 - val_accuracy: 0.6992 - val_loss: 0.7830 - learning_rate: 2.0000e-06\n", "Epoch 23/30\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 95ms/step - accuracy: 0.7964 - loss: 0.5199\n", "Epoch 23: val_accuracy improved from 0.69925 to 0.70677, saving model to models_sntsemilio_20250605_040202/best_resnet50_transfer_model_finetuned.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 129ms/step - accuracy: 0.7960 - loss: 0.5196 - val_accuracy: 0.7068 - val_loss: 0.7815 - learning_rate: 2.0000e-06\n", "Epoch 24/30\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 92ms/step - accuracy: 0.7593 - loss: 0.5423\n", "Epoch 24: val_accuracy did not improve from 0.70677\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 103ms/step - accuracy: 0.7596 - loss: 0.5421 - val_accuracy: 0.6917 - val_loss: 0.7678 - learning_rate: 2.0000e-06\n", "Epoch 25/30\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 94ms/step - accuracy: 0.8180 - loss: 0.4796\n", "Epoch 25: val_accuracy did not improve from 0.70677\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 105ms/step - accuracy: 0.8173 - loss: 0.4799 - val_accuracy: 0.6992 - val_loss: 0.7674 - learning_rate: 2.0000e-06\n", "Epoch 26/30\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 93ms/step - accuracy: 0.7727 - loss: 0.5569\n", "Epoch 26: val_accuracy improved from 0.70677 to 0.71429, saving model to models_sntsemilio_20250605_040202/best_resnet50_transfer_model_finetuned.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 126ms/step - accuracy: 0.7736 - loss: 0.5552 - val_accuracy: 0.7143 - val_loss: 0.7656 - learning_rate: 2.0000e-06\n", "Epoch 27/30\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 93ms/step - accuracy: 0.7901 - loss: 0.5231\n", "Epoch 27: val_accuracy did not improve from 0.71429\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 112ms/step - accuracy: 0.7905 - loss: 0.5221 - val_accuracy: 0.7068 - val_loss: 0.7714 - learning_rate: 2.0000e-06\n", "Epoch 28/30\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 95ms/step - accuracy: 0.7895 - loss: 0.4839\n", "Epoch 28: val_accuracy improved from 0.71429 to 0.72180, saving model to models_sntsemilio_20250605_040202/best_resnet50_transfer_model_finetuned.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 129ms/step - accuracy: 0.7897 - loss: 0.4837 - val_accuracy: 0.7218 - val_loss: 0.7704 - learning_rate: 2.0000e-06\n", "Epoch 29/30\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 93ms/step - accuracy: 0.7765 - loss: 0.5247\n", "Epoch 29: val_accuracy improved from 0.72180 to 0.73684, saving model to models_sntsemilio_20250605_040202/best_resnet50_transfer_model_finetuned.h5\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 127ms/step - accuracy: 0.7770 - loss: 0.5231 - val_accuracy: 0.7368 - val_loss: 0.7583 - learning_rate: 2.0000e-06\n", "Epoch 30/30\n", "\u001b[1m32/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 93ms/step - accuracy: 0.7959 - loss: 0.4764\n", "Epoch 30: val_accuracy did not improve from 0.73684\n", "\u001b[1m33/33\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 112ms/step - accuracy: 0.7969 - loss: 0.4753 - val_accuracy: 0.7368 - val_loss: 0.7643 - learning_rate: 2.0000e-06\n", "Restoring model weights from the end of the best epoch: 29.\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "Final fine-tuned model saved: models_sntsemilio_20250605_040202/final_resnet50_transfer_model.h5\n", "\n", "================================================================================\n", "MODEL EVALUATION RESULTS\n", "================================================================================\n", "\n", "Evaluating baseline_cnn...\n", "baseline_cnn Test Accuracy: 0.8594\n", "baseline_cnn Test Loss: 0.6070\n", "\n", "Evaluating vgg16_transfer...\n", "vgg16_transfer Test Accuracy: 0.9297\n", "vgg16_transfer Test Loss: 0.2079\n", "\n", "Evaluating resnet50_transfer...\n", "resnet50_transfer Test Accuracy: 0.6953\n", "resnet50_transfer Test Loss: 0.7283\n", "\n", "====================================================================================================\n", "DETAILED CLASSIFICATION REPORTS\n", "====================================================================================================\n", "\n", "BASELINE_CNN CLASSIFICATION REPORT:\n", "------------------------------------------------------------\n", " precision recall f1-score support\n", "\n", "angular_leaf_spot 0.85 0.93 0.89 43\n", " bean_rust 0.78 0.81 0.80 43\n", " healthy 0.97 0.83 0.90 42\n", "\n", " accuracy 0.86 128\n", " macro avg 0.87 0.86 0.86 128\n", " weighted avg 0.87 0.86 0.86 128\n", "\n", "\n", "VGG16_TRANSFER CLASSIFICATION REPORT:\n", "------------------------------------------------------------\n", " precision recall f1-score support\n", "\n", "angular_leaf_spot 0.93 0.91 0.92 43\n", " bean_rust 0.89 0.91 0.90 43\n", " healthy 0.98 0.98 0.98 42\n", "\n", " accuracy 0.93 128\n", " macro avg 0.93 0.93 0.93 128\n", " weighted avg 0.93 0.93 0.93 128\n", "\n", "\n", "RESNET50_TRANSFER CLASSIFICATION REPORT:\n", "------------------------------------------------------------\n", " precision recall f1-score support\n", "\n", "angular_leaf_spot 0.72 0.72 0.72 43\n", " bean_rust 0.67 0.60 0.63 43\n", " healthy 0.70 0.76 0.73 42\n", "\n", " accuracy 0.70 128\n", " macro avg 0.69 0.70 0.69 128\n", " weighted avg 0.69 0.70 0.69 128\n", "\n", "Confusion matrices saved: models_sntsemilio_20250605_040202/all_confusion_matrices.png\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} }, { "output_type": "stream", "name": "stdout", "text": [ "Training histories saved: models_sntsemilio_20250605_040202/all_training_histories.png\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} }, { "output_type": "stream", "name": "stdout", "text": [ "\n", "========================================================================================================================\n", "MODEL COMPARISON TABLE\n", "========================================================================================================================\n", " Model Test Accuracy Test Loss Macro Avg Precision Macro Avg Recall Macro Avg F1-Score Weighted Avg Precision Weighted Avg Recall Weighted Avg F1-Score angular_leaf_spot Precision angular_leaf_spot Recall angular_leaf_spot F1-Score bean_rust Precision bean_rust Recall bean_rust F1-Score healthy Precision healthy Recall healthy F1-Score\n", " baseline_cnn 0.8594 0.6070 0.8670 0.8592 0.8606 0.8662 0.8594 0.8603 0.8511 0.9302 0.8889 0.7778 0.8140 0.7955 0.9722 0.8333 0.8974\n", " vgg16_transfer 0.9297 0.2079 0.9304 0.9300 0.9301 0.9300 0.9297 0.9298 0.9286 0.9070 0.9176 0.8864 0.9070 0.8966 0.9762 0.9762 0.9762\n", "resnet50_transfer 0.6953 0.7283 0.6944 0.6958 0.6941 0.6944 0.6953 0.6939 0.7209 0.7209 0.7209 0.6667 0.6047 0.6341 0.6957 0.7619 0.7273\n", "\n", "Comparison table saved: models_sntsemilio_20250605_040202/model_comparison.csv\n", "\n", "Saved H5 model files in models_sntsemilio_20250605_040202:\n", "1. best_baseline_cnn_model.h5 (222.03 MB)\n", "2. best_resnet50_transfer_model_finetuned.h5 (137.99 MB)\n", "3. best_resnet50_transfer_model_initial.h5 (103.91 MB)\n", "4. best_vgg16_transfer_model_finetuned.h5 (114.75 MB)\n", "5. best_vgg16_transfer_model_initial.h5 (60.73 MB)\n", "6. final_baseline_cnn_model.h5 (222.03 MB)\n", "7. final_resnet50_transfer_model.h5 (137.99 MB)\n", "8. final_vgg16_transfer_model.h5 (114.75 MB)\n", "\n", "================================================================================\n", "TRAINING AND EVALUATION COMPLETED!\n", "User: sntsemilio | Completion Time: 2025-06-05 04:17:44 UTC\n", "================================================================================\n", "Generated H5 model files:\n", "- best_baseline_cnn_model.h5\n", "- final_baseline_cnn_model.h5\n", "- best_vgg16_transfer_model_initial.h5\n", "- best_vgg16_transfer_model_finetuned.h5\n", "- final_vgg16_transfer_model.h5\n", "- best_resnet50_transfer_model_initial.h5\n", "- best_resnet50_transfer_model_finetuned.h5\n", "- final_resnet50_transfer_model.h5\n", "\n", "Other files:\n", "- all_confusion_matrices.png\n", "- all_training_histories.png\n", "- model_comparison.csv\n" ] } ], "source": [ "import tensorflow as tf\n", "from tensorflow import keras\n", "from tensorflow.keras import layers\n", "from tensorflow.keras.applications import VGG16, ResNet50\n", "from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from sklearn.metrics import classification_report, confusion_matrix\n", "import seaborn as sns\n", "from datasets import load_dataset\n", "import pandas as pd\n", "import time\n", "import os\n", "from datetime import datetime\n", "\n", "tf.random.set_seed(42)\n", "np.random.seed(42)\n", "\n", "class TransferLearningClassifier:\n", " def __init__(self, img_size=(224, 224), num_classes=3):\n", " self.img_size = img_size\n", " self.num_classes = num_classes\n", " self.models = {}\n", " self.histories = {}\n", " self.class_names = None\n", "\n", " # Create directory for models with user and timestamp\n", " timestamp = datetime.now().strftime(\"%Y%m%d_%H%M%S\")\n", " self.save_dir = f'models_sntsemilio_{timestamp}'\n", " os.makedirs(self.save_dir, exist_ok=True)\n", "\n", " print(f\"Models will be saved to: {self.save_dir}\")\n", " print(f\"User: sntsemilio | Date: {datetime.now().strftime('%Y-%m-%d %H:%M:%S UTC')}\")\n", "\n", " def load_and_preprocess_dataset(self):\n", " print(\"Loading beans dataset from Hugging Face...\")\n", "\n", " dataset = load_dataset(\"AI-Lab-Makerere/beans\")\n", " self.class_names = dataset['train'].features['labels'].names\n", " print(f\"Classes: {self.class_names}\")\n", "\n", " train_images, train_labels = self._process_split(dataset['train'])\n", " val_images, val_labels = self._process_split(dataset['validation'])\n", " test_images, test_labels = self._process_split(dataset['test'])\n", "\n", " print(f\"Training samples: {len(train_images)}\")\n", " print(f\"Validation samples: {len(val_images)}\")\n", " print(f\"Test samples: {len(test_images)}\")\n", "\n", " return (train_images, train_labels), (val_images, val_labels), (test_images, test_labels)\n", "\n", " def _process_split(self, split):\n", " images = []\n", " labels = []\n", "\n", " for item in split:\n", " img = item['image']\n", " if img.mode != 'RGB':\n", " img = img.convert('RGB')\n", "\n", " img = img.resize(self.img_size)\n", " img_array = np.array(img) / 255.0\n", "\n", " images.append(img_array)\n", " labels.append(item['labels'])\n", "\n", " return np.array(images), np.array(labels)\n", "\n", " def build_baseline_cnn(self):\n", " model = keras.Sequential([\n", " layers.Conv2D(32, (3, 3), activation='relu', input_shape=(*self.img_size, 3)),\n", " layers.MaxPooling2D((2, 2)),\n", " layers.Dropout(0.25),\n", "\n", " layers.Conv2D(64, (3, 3), activation='relu'),\n", " layers.MaxPooling2D((2, 2)),\n", " layers.Dropout(0.25),\n", "\n", " layers.Conv2D(128, (3, 3), activation='relu'),\n", " layers.MaxPooling2D((2, 2)),\n", " layers.Dropout(0.25),\n", "\n", " layers.Conv2D(256, (3, 3), activation='relu'),\n", " layers.MaxPooling2D((2, 2)),\n", " layers.Dropout(0.25),\n", "\n", " layers.Flatten(),\n", " layers.Dense(512, activation='relu'),\n", " layers.Dropout(0.5),\n", " layers.Dense(256, activation='relu'),\n", " layers.Dropout(0.5),\n", " layers.Dense(self.num_classes, activation='softmax')\n", " ], name='baseline_cnn')\n", "\n", " model.compile(\n", " optimizer='adam',\n", " loss='sparse_categorical_crossentropy',\n", " metrics=['accuracy']\n", " )\n", "\n", " return model\n", "\n", " def build_vgg16_transfer_model(self):\n", " base_model = VGG16(\n", " weights='imagenet',\n", " include_top=False,\n", " input_shape=(*self.img_size, 3)\n", " )\n", "\n", " base_model.trainable = False\n", "\n", " model = keras.Sequential([\n", " base_model,\n", " layers.GlobalAveragePooling2D(),\n", " layers.Dense(512, activation='relu'),\n", " layers.Dropout(0.5),\n", " layers.Dense(256, activation='relu'),\n", " layers.Dropout(0.3),\n", " layers.Dense(self.num_classes, activation='softmax')\n", " ], name='vgg16_transfer')\n", "\n", " model.compile(\n", " optimizer=keras.optimizers.Adam(learning_rate=0.0001),\n", " loss='sparse_categorical_crossentropy',\n", " metrics=['accuracy']\n", " )\n", "\n", " return model\n", "\n", " def build_resnet50_transfer_model(self):\n", " base_model = ResNet50(\n", " weights='imagenet',\n", " include_top=False,\n", " input_shape=(*self.img_size, 3)\n", " )\n", "\n", " base_model.trainable = False\n", "\n", " model = keras.Sequential([\n", " base_model,\n", " layers.GlobalAveragePooling2D(),\n", " layers.Dense(512, activation='relu'),\n", " layers.BatchNormalization(),\n", " layers.Dropout(0.5),\n", " layers.Dense(256, activation='relu'),\n", " layers.Dropout(0.3),\n", " layers.Dense(self.num_classes, activation='softmax')\n", " ], name='resnet50_transfer')\n", "\n", " model.compile(\n", " optimizer=keras.optimizers.Adam(learning_rate=0.0001),\n", " loss='sparse_categorical_crossentropy',\n", " metrics=['accuracy']\n", " )\n", "\n", " return model\n", "\n", " def fine_tune_model(self, model, model_name):\n", " if 'vgg16' in model_name.lower():\n", " base_model = model.layers[0]\n", " base_model.trainable = True\n", " for layer in base_model.layers[:-4]:\n", " layer.trainable = False\n", " elif 'resnet50' in model_name.lower():\n", " base_model = model.layers[0]\n", " base_model.trainable = True\n", " for layer in base_model.layers[:-10]:\n", " layer.trainable = False\n", "\n", " model.compile(\n", " optimizer=keras.optimizers.Adam(learning_rate=0.00001),\n", " loss='sparse_categorical_crossentropy',\n", " metrics=['accuracy']\n", " )\n", "\n", " return model\n", "\n", " def get_callbacks(self, model_name, phase=\"\"):\n", " \"\"\"Get callbacks including H5 model saving\"\"\"\n", " file_suffix = f\"_{phase}\" if phase else \"\"\n", "\n", " callbacks = [\n", " EarlyStopping(\n", " monitor='val_accuracy',\n", " patience=15,\n", " restore_best_weights=True,\n", " verbose=1\n", " ),\n", " # Save H5 model file\n", " ModelCheckpoint(\n", " f'{self.save_dir}/best_{model_name}_model{file_suffix}.h5',\n", " monitor='val_accuracy',\n", " save_best_only=True,\n", " save_weights_only=False,\n", " verbose=1\n", " ),\n", " ReduceLROnPlateau(\n", " monitor='val_loss',\n", " factor=0.2,\n", " patience=5,\n", " min_lr=1e-7,\n", " verbose=1\n", " )\n", " ]\n", " return callbacks\n", "\n", " def train_model(self, model, model_name, train_data, val_data, epochs=50, batch_size=32):\n", " train_images, train_labels = train_data\n", " val_images, val_labels = val_data\n", "\n", " callbacks = self.get_callbacks(model_name)\n", "\n", " print(f\"\\nTraining {model_name}...\")\n", " start_time = time.time()\n", "\n", " history = model.fit(\n", " train_images, train_labels,\n", " batch_size=batch_size,\n", " epochs=epochs,\n", " validation_data=(val_images, val_labels),\n", " callbacks=callbacks,\n", " verbose=1\n", " )\n", "\n", " training_time = time.time() - start_time\n", " print(f\"{model_name} training completed in {training_time:.2f} seconds\")\n", "\n", " # Save final model as well\n", " final_model_path = f'{self.save_dir}/final_{model_name}_model.h5'\n", " model.save(final_model_path)\n", " print(f\"Final model saved: {final_model_path}\")\n", "\n", " self.models[model_name] = model\n", " self.histories[model_name] = history\n", "\n", " return history\n", "\n", " def train_with_fine_tuning(self, model, model_name, train_data, val_data,\n", " initial_epochs=20, fine_tune_epochs=30, batch_size=32):\n", "\n", " print(f\"\\n=== Phase 1: Initial Training ({model_name}) ===\")\n", "\n", " # Phase 1: Initial training with frozen base\n", " callbacks_initial = self.get_callbacks(model_name, \"initial\")\n", "\n", " history1 = model.fit(\n", " train_data[0], train_data[1],\n", " batch_size=batch_size,\n", " epochs=initial_epochs,\n", " validation_data=(val_data[0], val_data[1]),\n", " callbacks=callbacks_initial,\n", " verbose=1\n", " )\n", "\n", " print(f\"\\n=== Phase 2: Fine-tuning ({model_name}) ===\")\n", "\n", " # Phase 2: Fine-tuning with unfrozen layers\n", " model = self.fine_tune_model(model, model_name)\n", " callbacks_finetuned = self.get_callbacks(model_name, \"finetuned\")\n", "\n", " history2 = model.fit(\n", " train_data[0], train_data[1],\n", " batch_size=batch_size,\n", " epochs=fine_tune_epochs,\n", " validation_data=(val_data[0], val_data[1]),\n", " callbacks=callbacks_finetuned,\n", " verbose=1\n", " )\n", "\n", " # Save final fine-tuned model\n", " final_model_path = f'{self.save_dir}/final_{model_name}_model.h5'\n", " model.save(final_model_path)\n", " print(f\"Final fine-tuned model saved: {final_model_path}\")\n", "\n", " combined_history = self._combine_histories(history1, history2)\n", "\n", " self.models[model_name] = model\n", " self.histories[model_name] = combined_history\n", "\n", " return combined_history\n", "\n", " def _combine_histories(self, hist1, hist2):\n", " combined = {}\n", " for key in hist1.history.keys():\n", " combined[key] = hist1.history[key] + hist2.history[key]\n", "\n", " class CombinedHistory:\n", " def __init__(self, history_dict):\n", " self.history = history_dict\n", "\n", " return CombinedHistory(combined)\n", "\n", " def evaluate_all_models(self, test_data):\n", " test_images, test_labels = test_data\n", " results = {}\n", "\n", " print(\"\\n\" + \"=\"*80)\n", " print(\"MODEL EVALUATION RESULTS\")\n", " print(\"=\"*80)\n", "\n", " for model_name, model in self.models.items():\n", " print(f\"\\nEvaluating {model_name}...\")\n", "\n", " test_loss, test_accuracy = model.evaluate(test_images, test_labels, verbose=0)\n", " predictions = model.predict(test_images, verbose=0)\n", " predicted_classes = np.argmax(predictions, axis=1)\n", "\n", " report = classification_report(\n", " test_labels, predicted_classes,\n", " target_names=self.class_names,\n", " output_dict=True\n", " )\n", "\n", " cm = confusion_matrix(test_labels, predicted_classes)\n", "\n", " results[model_name] = {\n", " 'test_loss': test_loss,\n", " 'test_accuracy': test_accuracy,\n", " 'predictions': predictions,\n", " 'predicted_classes': predicted_classes,\n", " 'classification_report': report,\n", " 'confusion_matrix': cm\n", " }\n", "\n", " print(f\"{model_name} Test Accuracy: {test_accuracy:.4f}\")\n", " print(f\"{model_name} Test Loss: {test_loss:.4f}\")\n", "\n", " return results\n", "\n", " def generate_detailed_reports(self, results, test_data):\n", " test_images, test_labels = test_data\n", "\n", " print(\"\\n\" + \"=\"*100)\n", " print(\"DETAILED CLASSIFICATION REPORTS\")\n", " print(\"=\"*100)\n", "\n", " for model_name, result in results.items():\n", " print(f\"\\n{model_name.upper()} CLASSIFICATION REPORT:\")\n", " print(\"-\" * 60)\n", " print(classification_report(\n", " test_labels, result['predicted_classes'],\n", " target_names=self.class_names\n", " ))\n", "\n", " self._plot_confusion_matrices(results)\n", " self._plot_training_histories()\n", " self._create_comparison_table(results)\n", "\n", " def _plot_confusion_matrices(self, results):\n", " n_models = len(results)\n", " fig, axes = plt.subplots(1, n_models, figsize=(6*n_models, 5))\n", "\n", " if n_models == 1:\n", " axes = [axes]\n", "\n", " for idx, (model_name, result) in enumerate(results.items()):\n", " cm = result['confusion_matrix']\n", "\n", " sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',\n", " xticklabels=self.class_names, yticklabels=self.class_names,\n", " ax=axes[idx])\n", " axes[idx].set_title(f'{model_name} Confusion Matrix')\n", " axes[idx].set_xlabel('Predicted')\n", " axes[idx].set_ylabel('Actual')\n", "\n", " plt.tight_layout()\n", " confusion_path = f'{self.save_dir}/all_confusion_matrices.png'\n", " plt.savefig(confusion_path, dpi=300, bbox_inches='tight')\n", " print(f\"Confusion matrices saved: {confusion_path}\")\n", " plt.show()\n", "\n", " def _plot_training_histories(self):\n", " n_models = len(self.histories)\n", " fig, axes = plt.subplots(2, n_models, figsize=(6*n_models, 10))\n", "\n", " if n_models == 1:\n", " axes = axes.reshape(-1, 1)\n", "\n", " for idx, (model_name, history) in enumerate(self.histories.items()):\n", " axes[0, idx].plot(history.history['accuracy'], label='Training Accuracy')\n", " axes[0, idx].plot(history.history['val_accuracy'], label='Validation Accuracy')\n", " axes[0, idx].set_title(f'{model_name} Accuracy')\n", " axes[0, idx].set_xlabel('Epoch')\n", " axes[0, idx].set_ylabel('Accuracy')\n", " axes[0, idx].legend()\n", " axes[0, idx].grid(True)\n", "\n", " axes[1, idx].plot(history.history['loss'], label='Training Loss')\n", " axes[1, idx].plot(history.history['val_loss'], label='Validation Loss')\n", " axes[1, idx].set_title(f'{model_name} Loss')\n", " axes[1, idx].set_xlabel('Epoch')\n", " axes[1, idx].set_ylabel('Loss')\n", " axes[1, idx].legend()\n", " axes[1, idx].grid(True)\n", "\n", " plt.tight_layout()\n", " history_path = f'{self.save_dir}/all_training_histories.png'\n", " plt.savefig(history_path, dpi=300, bbox_inches='tight')\n", " print(f\"Training histories saved: {history_path}\")\n", " plt.show()\n", "\n", " def _create_comparison_table(self, results):\n", " comparison_data = []\n", "\n", " for model_name, result in results.items():\n", " report = result['classification_report']\n", "\n", " row = {\n", " 'Model': model_name,\n", " 'Test Accuracy': result['test_accuracy'],\n", " 'Test Loss': result['test_loss'],\n", " 'Macro Avg Precision': report['macro avg']['precision'],\n", " 'Macro Avg Recall': report['macro avg']['recall'],\n", " 'Macro Avg F1-Score': report['macro avg']['f1-score'],\n", " 'Weighted Avg Precision': report['weighted avg']['precision'],\n", " 'Weighted Avg Recall': report['weighted avg']['recall'],\n", " 'Weighted Avg F1-Score': report['weighted avg']['f1-score']\n", " }\n", "\n", " for class_name in self.class_names:\n", " row[f'{class_name} Precision'] = report[class_name]['precision']\n", " row[f'{class_name} Recall'] = report[class_name]['recall']\n", " row[f'{class_name} F1-Score'] = report[class_name]['f1-score']\n", "\n", " comparison_data.append(row)\n", "\n", " df = pd.DataFrame(comparison_data)\n", "\n", " print(\"\\n\" + \"=\"*120)\n", " print(\"MODEL COMPARISON TABLE\")\n", " print(\"=\"*120)\n", " print(df.round(4).to_string(index=False))\n", "\n", " comparison_path = f'{self.save_dir}/model_comparison.csv'\n", " df.round(4).to_csv(comparison_path, index=False)\n", " print(f\"\\nComparison table saved: {comparison_path}\")\n", "\n", " return df\n", "\n", " def list_saved_models(self):\n", " \"\"\"List all saved H5 model files\"\"\"\n", " print(f\"\\nSaved H5 model files in {self.save_dir}:\")\n", " if os.path.exists(self.save_dir):\n", " h5_files = [f for f in os.listdir(self.save_dir) if f.endswith('.h5')]\n", " for i, file in enumerate(sorted(h5_files), 1):\n", " file_path = os.path.join(self.save_dir, file)\n", " file_size = os.path.getsize(file_path) / (1024*1024) # MB\n", " print(f\"{i}. {file} ({file_size:.2f} MB)\")\n", " else:\n", " print(\"No saved models directory found.\")\n", "\n", "def main():\n", " print(\"Bean Leaf Disease Classification - Transfer Learning Comparison\")\n", " print(\"=\"*70)\n", " print(f\"User: sntsemilio\")\n", " print(f\"Start Time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S UTC')}\")\n", " print(\"=\"*70)\n", "\n", " classifier = TransferLearningClassifier(img_size=(224, 224), num_classes=3)\n", "\n", " train_data, val_data, test_data = classifier.load_and_preprocess_dataset()\n", "\n", " print(\"\\n=== BUILDING AND TRAINING MODELS ===\")\n", "\n", " baseline_model = classifier.build_baseline_cnn()\n", " print(\"Baseline CNN model built\")\n", "\n", " vgg16_model = classifier.build_vgg16_transfer_model()\n", " print(\"VGG16 transfer model built\")\n", "\n", " resnet50_model = classifier.build_resnet50_transfer_model()\n", " print(\"ResNet50 transfer model built\")\n", "\n", " classifier.train_model(baseline_model, \"baseline_cnn\", train_data, val_data, epochs=50)\n", "\n", " classifier.train_with_fine_tuning(vgg16_model, \"vgg16_transfer\", train_data, val_data,\n", " initial_epochs=20, fine_tune_epochs=30)\n", "\n", " classifier.train_with_fine_tuning(resnet50_model, \"resnet50_transfer\", train_data, val_data,\n", " initial_epochs=20, fine_tune_epochs=30)\n", "\n", " results = classifier.evaluate_all_models(test_data)\n", "\n", " classifier.generate_detailed_reports(results, test_data)\n", "\n", " # List all saved models\n", " classifier.list_saved_models()\n", "\n", " print(\"\\n\" + \"=\"*80)\n", " print(\"TRAINING AND EVALUATION COMPLETED!\")\n", " print(f\"User: sntsemilio | Completion Time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S UTC')}\")\n", " print(\"=\"*80)\n", " print(\"Generated H5 model files:\")\n", " print(\"- best_baseline_cnn_model.h5\")\n", " print(\"- final_baseline_cnn_model.h5\")\n", " print(\"- best_vgg16_transfer_model_initial.h5\")\n", " print(\"- best_vgg16_transfer_model_finetuned.h5\")\n", " print(\"- final_vgg16_transfer_model.h5\")\n", " print(\"- best_resnet50_transfer_model_initial.h5\")\n", " print(\"- best_resnet50_transfer_model_finetuned.h5\")\n", " print(\"- final_resnet50_transfer_model.h5\")\n", " print(\"\\nOther files:\")\n", " print(\"- all_confusion_matrices.png\")\n", " print(\"- all_training_histories.png\")\n", " print(\"- model_comparison.csv\")\n", "\n", "if __name__ == \"__main__\":\n", " main()" ] }, { "cell_type": "code", "source": [], "metadata": { "id": "7aNsyGswQL8x" }, "execution_count": null, "outputs": [] } ], "metadata": { "accelerator": "GPU", "colab": { "gpuType": "T4", "provenance": [] }, "kernelspec": { "display_name": "Python 3", "name": "python3" }, "language_info": { "name": "python" }, "widgets": { "application/vnd.jupyter.widget-state+json": { "00967fb0bc494db29242b6b400db920a": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "DescriptionStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "DescriptionStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "description_width": "" } }, "03740d2fc4994d87a132fb718a82dbc9": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "bar_color": null, "description_width": "" } }, "064133d59ba94f34b8a85a2689749c11": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HBoxView", "box_style": "", "children": [ "IPY_MODEL_ab01197c5e604f479bad0c0f5ccc9083", "IPY_MODEL_c68364f830084904a4438c55e4e43540", "IPY_MODEL_c25b54b32014477fbe6b6d6c0a9b6a0f" ], "layout": "IPY_MODEL_e89a51d63cb14c7b8f935a055ffffb05" } }, "0661e6c99f49485587d6dc08541840a7": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "ProgressView", "bar_style": "success", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_fde30f8471d349a0a5e92f48d93b680b", "max": 133, "min": 0, "orientation": "horizontal", "style": "IPY_MODEL_58038761ae8c422fa8019b33d8b50d2d", "value": 133 } }, "11ed39f16d6b451d97b092979784165f": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "18173592fa7a462a846292b669aa17da": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "DescriptionStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "DescriptionStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "description_width": "" } }, "1d5078a1b9934f8c9fdac1a0c3f0009a": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "bar_color": null, "description_width": "" } }, "1ecdc8db7e11426baa94355b3583b998": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HTMLView", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_79b7fe254d8f43648ef78375dfb435c9", "placeholder": "​", "style": "IPY_MODEL_18173592fa7a462a846292b669aa17da", "value": " 18.5M/18.5M [00:00<00:00, 107MB/s]" } }, "22fb3c804fd9488a8fba551a2cfea705": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "DescriptionStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "DescriptionStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "description_width": "" } }, "26cf42f0d9a04920a316ae013e405655": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HTMLView", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_fe85c9a7dd7943cc99a78a28d747ecd8", "placeholder": "​", "style": "IPY_MODEL_fceb8c33d3084ac584807221b577c327", "value": " 133/133 [00:00<00:00, 1701.39 examples/s]" } }, "2c7f2e15ad964de4831ff6b6c21b7665": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "315a1dadda0a49c896379b1651927bd9": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "32781f022fc64d8abc353fa69c7611e8": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "bar_color": null, "description_width": "" } }, "34b2bb9d2ff6431eba4b38fcfb5798d0": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "3565811a595f473482cc6586c66132ff": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "DescriptionStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "DescriptionStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "description_width": "" } }, "3664148b2ff146b691f98b16524087de": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "39cee2cdf4a14f27a2fcde5e9f35723d": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HTMLView", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_9576c7e7166046cc8f17daa266cbd6a7", "placeholder": "​", "style": "IPY_MODEL_e8e5f1e9269c4aa3b11771c70f981809", "value": "Generating test split: 100%" } }, "3a93189941b74dad870232a745381143": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "DescriptionStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "DescriptionStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "description_width": "" } }, "3e0e2887778041109de0a60118f06f0b": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "3ffefea4a5f54843ab8bd2b091e0e9ce": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "4500f28a42b949aeae5bf81608d291e2": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "4d79a8fc6f1842dbb822ec2b0341dbf1": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "4f33d403ec244f3b8dd88cd2671715f0": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HTMLView", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_cde6b27e0ed1483fadb7dc67296e7e01", "placeholder": "​", "style": "IPY_MODEL_d127e48c331f4aee80c62ce25383c689", "value": "Generating validation split: 100%" } }, "58038761ae8c422fa8019b33d8b50d2d": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "bar_color": null, "description_width": "" } }, "5da8f888a0ab42cabd59673eb8dadb45": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HBoxView", "box_style": "", "children": [ "IPY_MODEL_e823079163174fe8a0317f7f4fd5db85", "IPY_MODEL_e583fbc663d046459a8cd4be77768dc6", "IPY_MODEL_1ecdc8db7e11426baa94355b3583b998" ], "layout": "IPY_MODEL_6beba30ce3834cf78e05b8150681e472" } }, "6318871e48c24ef583b1086c2177106d": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "6beba30ce3834cf78e05b8150681e472": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "708fb1be8d334f3b8a48323ee17fd2c8": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "DescriptionStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "DescriptionStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "description_width": "" } }, "71ade4e34c624e78bb084605aa46d9eb": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "71e188c65ee4415aa486a339b060d28c": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HBoxView", "box_style": "", "children": [ "IPY_MODEL_4f33d403ec244f3b8dd88cd2671715f0", "IPY_MODEL_0661e6c99f49485587d6dc08541840a7", "IPY_MODEL_26cf42f0d9a04920a316ae013e405655" ], "layout": "IPY_MODEL_3e0e2887778041109de0a60118f06f0b" } }, "77c04244da1b466fb76274a0f7d55067": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "bar_color": null, "description_width": "" } }, "78400dbd4b894638b066952c5c739605": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "DescriptionStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "DescriptionStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "description_width": "" } }, "79b7fe254d8f43648ef78375dfb435c9": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "7d7052c69ada4bd791bd599fc212a123": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "7dbd4fc014654fcbb5a901da3f84f6cc": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HBoxView", "box_style": "", "children": [ "IPY_MODEL_a174e70991a34b8284205672af6a7f9c", "IPY_MODEL_8ca3fad55cfc423fbac8ad912e5e640d", "IPY_MODEL_ec502fba22784abb951adea17d6e92cf" ], "layout": "IPY_MODEL_71ade4e34c624e78bb084605aa46d9eb" } }, "86a66d9b1d5144c88ca7c0347368cda1": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "8ca3fad55cfc423fbac8ad912e5e640d": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "ProgressView", "bar_style": "success", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_6318871e48c24ef583b1086c2177106d", "max": 143773054, "min": 0, "orientation": "horizontal", "style": "IPY_MODEL_daad54685b0441e3995fcd997309ed15", "value": 143773054 } }, "8cc0e05b37aa4b9b9ecd4019a8dd765b": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "8ea94d24bdc74531b5367c1abde89dcb": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "8f3d2ad1755b4f518310200b52d664ef": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "ProgressView", "bar_style": "success", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_8cc0e05b37aa4b9b9ecd4019a8dd765b", "max": 1034, "min": 0, "orientation": "horizontal", "style": "IPY_MODEL_e49c9151d2d842549d1627905c7754b4", "value": 1034 } }, "94de925f314f45fdb3bd6fb150eb7562": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "DescriptionStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "DescriptionStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "description_width": "" } }, "9576c7e7166046cc8f17daa266cbd6a7": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "95d08e317b0d43b585a68d7b66c07e89": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "DescriptionStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "DescriptionStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "description_width": "" } }, "9bac7f89c60643e3800d233651bf9375": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "DescriptionStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "DescriptionStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "description_width": "" } }, "9cf6cb50630547d78ca166ef3adb2ea3": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "9e4e00f80fc744898df9a1c82654c15a": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HTMLView", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_86a66d9b1d5144c88ca7c0347368cda1", "placeholder": "​", "style": "IPY_MODEL_00967fb0bc494db29242b6b400db920a", "value": "Generating train split: 100%" } }, "a174e70991a34b8284205672af6a7f9c": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HTMLView", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_4d79a8fc6f1842dbb822ec2b0341dbf1", "placeholder": "​", "style": "IPY_MODEL_3565811a595f473482cc6586c66132ff", "value": "train-00000-of-00001.parquet: 100%" } }, "ab01197c5e604f479bad0c0f5ccc9083": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HTMLView", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_4500f28a42b949aeae5bf81608d291e2", "placeholder": "​", "style": "IPY_MODEL_95d08e317b0d43b585a68d7b66c07e89", "value": "README.md: 100%" } }, "ac1e02bbca464d779340ec3f8fd6a071": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HBoxView", "box_style": "", "children": [ "IPY_MODEL_9e4e00f80fc744898df9a1c82654c15a", "IPY_MODEL_8f3d2ad1755b4f518310200b52d664ef", "IPY_MODEL_ae52ad0f94514e178fb30f84787d97eb" ], "layout": "IPY_MODEL_2c7f2e15ad964de4831ff6b6c21b7665" } }, "ae52ad0f94514e178fb30f84787d97eb": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HTMLView", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_c308654204964a5c9a8788c1c2531e1e", "placeholder": "​", "style": "IPY_MODEL_cd82c211a3fb424c90262f8cb1fdc5b0", "value": " 1034/1034 [00:00<00:00, 1963.71 examples/s]" } }, "b143024e14ed44928c84f010fd3a6377": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "ba125eb6c0004c1ca0494b3911c4a719": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "bf705be275df4c2196888a08ed35fb53": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "c25b54b32014477fbe6b6d6c0a9b6a0f": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HTMLView", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_11ed39f16d6b451d97b092979784165f", "placeholder": "​", "style": "IPY_MODEL_9bac7f89c60643e3800d233651bf9375", "value": " 4.95k/4.95k [00:00<00:00, 210kB/s]" } }, "c308654204964a5c9a8788c1c2531e1e": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "c42142e1fae9450e8ba3d23532508681": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HBoxView", "box_style": "", "children": [ "IPY_MODEL_39cee2cdf4a14f27a2fcde5e9f35723d", "IPY_MODEL_ea68697adf374bfabdfd9e139616a8f3", "IPY_MODEL_e2fd46ce8e6a4d61bfed998a5268596a" ], "layout": "IPY_MODEL_8ea94d24bdc74531b5367c1abde89dcb" } }, "c68364f830084904a4438c55e4e43540": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "ProgressView", "bar_style": "success", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_3ffefea4a5f54843ab8bd2b091e0e9ce", "max": 4945, "min": 0, "orientation": "horizontal", "style": "IPY_MODEL_1d5078a1b9934f8c9fdac1a0c3f0009a", "value": 4945 } }, "cd82c211a3fb424c90262f8cb1fdc5b0": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "DescriptionStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "DescriptionStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "description_width": "" } }, "cde6b27e0ed1483fadb7dc67296e7e01": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "d127e48c331f4aee80c62ce25383c689": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "DescriptionStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "DescriptionStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "description_width": "" } }, "d8b6bf983a6f4b4197297f9fee965259": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HBoxView", "box_style": "", "children": [ "IPY_MODEL_ecc250699c7247b8b5d8b803db5c46d3", "IPY_MODEL_eacffde253464c93831a7be8a8492c77", "IPY_MODEL_fcac1865e83e4c0c929c426b3145b732" ], "layout": "IPY_MODEL_ba125eb6c0004c1ca0494b3911c4a719" } }, "daad54685b0441e3995fcd997309ed15": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "bar_color": null, "description_width": "" } }, "e2fd46ce8e6a4d61bfed998a5268596a": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HTMLView", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_b143024e14ed44928c84f010fd3a6377", "placeholder": "​", "style": "IPY_MODEL_22fb3c804fd9488a8fba551a2cfea705", "value": " 128/128 [00:00<00:00, 1480.52 examples/s]" } }, "e49c9151d2d842549d1627905c7754b4": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "bar_color": null, "description_width": "" } }, "e583fbc663d046459a8cd4be77768dc6": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "ProgressView", "bar_style": "success", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_bf705be275df4c2196888a08ed35fb53", "max": 18499710, "min": 0, "orientation": "horizontal", "style": "IPY_MODEL_03740d2fc4994d87a132fb718a82dbc9", "value": 18499710 } }, "e823079163174fe8a0317f7f4fd5db85": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HTMLView", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_315a1dadda0a49c896379b1651927bd9", "placeholder": "​", "style": "IPY_MODEL_78400dbd4b894638b066952c5c739605", "value": "validation-00000-of-00001.parquet: 100%" } }, "e89a51d63cb14c7b8f935a055ffffb05": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "e8e5f1e9269c4aa3b11771c70f981809": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "DescriptionStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "DescriptionStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "description_width": "" } }, "ea68697adf374bfabdfd9e139616a8f3": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "ProgressView", "bar_style": "success", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_3664148b2ff146b691f98b16524087de", "max": 128, "min": 0, "orientation": "horizontal", "style": "IPY_MODEL_32781f022fc64d8abc353fa69c7611e8", "value": 128 } }, "eacffde253464c93831a7be8a8492c77": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "ProgressView", "bar_style": "success", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_9cf6cb50630547d78ca166ef3adb2ea3", "max": 17706070, "min": 0, "orientation": "horizontal", "style": "IPY_MODEL_77c04244da1b466fb76274a0f7d55067", "value": 17706070 } }, "ec502fba22784abb951adea17d6e92cf": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HTMLView", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_7d7052c69ada4bd791bd599fc212a123", "placeholder": "​", "style": "IPY_MODEL_3a93189941b74dad870232a745381143", "value": " 144M/144M [00:00<00:00, 233MB/s]" } }, "ecc250699c7247b8b5d8b803db5c46d3": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HTMLView", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_f3dff036008b4955b6509c0e296fde82", "placeholder": "​", "style": "IPY_MODEL_94de925f314f45fdb3bd6fb150eb7562", "value": "test-00000-of-00001.parquet: 100%" } }, "f3dff036008b4955b6509c0e296fde82": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "fcac1865e83e4c0c929c426b3145b732": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HTMLView", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_34b2bb9d2ff6431eba4b38fcfb5798d0", "placeholder": "​", "style": "IPY_MODEL_708fb1be8d334f3b8a48323ee17fd2c8", "value": " 17.7M/17.7M [00:00<00:00, 117MB/s]" } }, "fceb8c33d3084ac584807221b577c327": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "DescriptionStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "DescriptionStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "description_width": "" } }, "fde30f8471d349a0a5e92f48d93b680b": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "fe85c9a7dd7943cc99a78a28d747ecd8": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } } } } }, "nbformat": 4, "nbformat_minor": 0 }