diff --git "a/src/CNN_FishClassification.ipynb" "b/src/CNN_FishClassification.ipynb" new file mode 100644--- /dev/null +++ "b/src/CNN_FishClassification.ipynb" @@ -0,0 +1,1642 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b0fa72db-2e95-4f72-9ede-592e3c7783a5", + "metadata": {}, + "source": [ + "### CNN FishData" + ] + }, + { + "cell_type": "markdown", + "id": "17902fec-1a97-4595-bdc3-82887d19face", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "id": "740d8bca-3cf6-4b8a-b959-609de8259d0e", + "metadata": {}, + "source": [ + "### Introduction\n", + "\n", + "In this project, I built a Convolutional Neural Network (CNN) from scratch to classify images of nine different fish species.\n", + "The dataset is called “A Large Scale Fish Dataset” and contains many images of similar-looking fish like Sea Bass, Bream, Mackerel, Shrimp and Mullet.\n", + "The goal was to create a working deep learning model without transfer learning, using at least 5 convolutional layers and 3 pooling layers, and to evaluate it properly.\n", + "This work is part of my deep learning assignment where I build CNN models for several datasets and compare them later with transfer learning models." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ca313177-6869-43af-bbbc-b791fe4d39c4", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.12/dist-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Path to dataset files: /root/.cache/kagglehub/datasets/crowww/a-large-scale-fish-dataset/versions/2\n" + ] + } + ], + "source": [ + "import kagglehub\n", + "\n", + "# Download latest version\n", + "path2 = kagglehub.dataset_download(\"crowww/a-large-scale-fish-dataset\")\n", + "\n", + "print(\"Path to dataset files:\", path2)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "bf45f3b1-2d64-49dc-b659-09b1f0a4a7cc", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'\n", + "os.environ['CUDA_LAUNCH_BLOCKING'] = '0' # Delay-Timing\n", + "os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' # TensorFlow\n", + "os.environ['NVIDIA_TF32_OVERRIDE'] = '0' # TF32 Profiling" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "bc676980-372d-43cb-a215-a10199b17b49", + "metadata": {}, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "tf.debugging.disable_traceback_filtering()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "bc5f6e16-31a0-4570-bca4-7f4f7f550380", + "metadata": {}, + "outputs": [], + "source": [ + "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n", + "from tensorflow.keras.models import Sequential\n", + "from tensorflow.keras.layers import Input, Conv2D, MaxPooling2D, Flatten, Dense, Dropout, BatchNormalization\n", + "from tensorflow.keras.optimizers import Adam\n", + "from tensorflow.keras.metrics import SparseTopKCategoricalAccuracy\n", + "from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau\n", + "from tensorflow.keras.layers import GlobalAveragePooling2D\n", + "from tensorflow.keras.metrics import Precision, Recall\n", + "import matplotlib.pyplot as plt\n", + "from sklearn.metrics import confusion_matrix, classification_report\n", + "import seaborn as sns\n", + "import numpy as np\n", + "import tensorflow as tf\n", + "import pickle\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "af03ef26-d774-4d23-970f-67688b6158a1", + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "\n", + "data_dir = Path(path2) / \"Fish_Dataset\" / \"Fish_Dataset\"" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "92833ab1-263d-4cff-a57f-71610e2491d6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['Black Sea Sprat',\n", + " 'Red Mullet',\n", + " 'Gilt-Head Bream',\n", + " 'Trout',\n", + " 'Hourse Mackerel',\n", + " 'Striped Red Mullet',\n", + " 'license.txt',\n", + " 'Sea Bass',\n", + " 'Shrimp',\n", + " 'Red Sea Bream',\n", + " 'README.txt',\n", + " 'Segmentation_example_script.m']" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import os\n", + "os.listdir(data_dir)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "a4fe4df6-cf31-4ee0-bfd4-1a6c207049ad", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 14400 images belonging to 9 classes.\n", + "Found 3600 images belonging to 9 classes.\n" + ] + } + ], + "source": [ + "data_dir = Path(path2) / \"Fish_Dataset\" / \"Fish_Dataset\"\n", + "\n", + "img_size = (224, 224)\n", + "batch_size = 16\n", + "\n", + "train_datagen = ImageDataGenerator(\n", + " rescale=1./255,\n", + " validation_split=0.2,\n", + " rotation_range=15,\n", + " width_shift_range=0.10,\n", + " height_shift_range=0.10,\n", + " zoom_range=0.10,\n", + " shear_range=0.10,\n", + " horizontal_flip=True,\n", + " fill_mode='nearest'\n", + ")\n", + "\n", + "val_datagen = ImageDataGenerator(\n", + " rescale=1./255,\n", + " validation_split=0.2\n", + ")\n", + "\n", + "train_data = train_datagen.flow_from_directory(\n", + " data_dir,\n", + " target_size=img_size,\n", + " batch_size=batch_size,\n", + " subset='training',\n", + " class_mode='sparse',\n", + " shuffle=True\n", + ")\n", + "\n", + "val_data = val_datagen.flow_from_directory(\n", + " data_dir,\n", + " target_size=img_size,\n", + " batch_size=batch_size,\n", + " subset='validation',\n", + " class_mode='sparse',\n", + " shuffle=False\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "9f151a81-efec-47d3-b94a-56f78ec44929", + "metadata": {}, + "source": [ + "### Analysis\n", + "\n", + "I downloaded the dataset from Kaggle and checked its folder structure.\n", + "The dataset contains 9 classes, and each class has hundreds of images.\n", + "The images were organized in folders, so I used ImageDataGenerator to load them.\n", + "\n", + "I also applied data augmentation to help the model generalize better:\n", + "\n", + "- rotation\n", + "\n", + "- width/height shift\n", + "\n", + "- zoom\n", + "\n", + "- shear\n", + "\n", + "- horizontal flip\n", + "\n", + "- normalization (1./255)\n", + "\n", + "The images were resized to 224×224, which is a common size for CNN models.\n", + "\n", + "The dataset was split automatically using validation_split=0.2\n", + "→ 80% training data\n", + "→ 20% validation data." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "b7d9f124-7e09-4828-88bd-0ed1b09ae31a", + "metadata": {}, + "outputs": [], + "source": [ + "model = Sequential()\n", + "\n", + "# Input\n", + "model.add(Input(shape=(224, 224, 3)))\n", + "\n", + "model.add(Conv2D(32, (3,3), activation='relu', padding='same'))\n", + "model.add(BatchNormalization())\n", + "model.add(Conv2D(32, (3,3), activation='relu', padding='same'))\n", + "model.add(BatchNormalization())\n", + "model.add(MaxPooling2D())\n", + "\n", + "model.add(Conv2D(64, (3,3), activation='relu', padding='same'))\n", + "model.add(BatchNormalization())\n", + "model.add(Conv2D(64, (3,3), activation='relu', padding='same'))\n", + "model.add(BatchNormalization())\n", + "model.add(MaxPooling2D())\n", + "\n", + "model.add(Conv2D(128, (3,3), activation='relu', padding='same'))\n", + "model.add(BatchNormalization())\n", + "model.add(Conv2D(128, (3,3), activation='relu', padding='same'))\n", + "model.add(BatchNormalization())\n", + "model.add(MaxPooling2D())\n", + "\n", + "model.add(Conv2D(256, (3,3), activation='relu', padding='same'))\n", + "model.add(BatchNormalization())\n", + "model.add(Conv2D(256, (3,3), activation='relu', padding='same'))\n", + "model.add(BatchNormalization())\n", + "model.add(MaxPooling2D())\n", + "\n", + "# Classifier\n", + "model.add(GlobalAveragePooling2D())\n", + "model.add(Dense(256, activation='relu'))\n", + "model.add(Dropout(0.5))\n", + "\n", + "model.add(Dense(train_data.num_classes, activation='softmax'))" + ] + }, + { + "cell_type": "markdown", + "id": "416167f8-4cde-4e52-bb96-19ba1fbb7fdd", + "metadata": {}, + "source": [ + "### Methods\n", + "I created a deep CNN using Keras Sequential API.\n", + "The model contains:\n", + "\n", + "- 5 Convolutional layers\n", + "\n", + "- 3 MaxPooling layers\n", + "\n", + "- 1 Dense layer with 256 units\n", + "\n", + "- Dropout(0.5) to reduce overfitting\n", + "\n", + "- Softmax output layer with 9 classes\n", + "\n", + "I used:\n", + "\n", + "- Loss: sparse_categorical_crossentropy\n", + "\n", + "- Optimizer: Adam (learning_rate=0.0005)\n", + "\n", + "- Metrics: accuracy and top-3 accuracy\n", + "\n", + "For better training I used these callbacks:\n", + "\n", + "- EarlyStopping\n", + "\n", + "- ModelCheckpoint (saved best model as best_fish_cnn.keras)\n", + "\n", + "- ReduceLROnPlateau\n", + "\n", + "The model trained for up to 40 epochs." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "5046ab24-9c59-4c23-9306-4f0b4f952945", + "metadata": {}, + "outputs": [], + "source": [ + "early_stop = EarlyStopping(\n", + " monitor='val_loss',\n", + " patience=10,\n", + " restore_best_weights=True\n", + ")\n", + "\n", + "checkpoint = ModelCheckpoint(\n", + " filepath='best_fish_cnn.keras',\n", + " monitor='val_loss',\n", + " save_best_only=True\n", + ")\n", + "\n", + "lr_schedule = ReduceLROnPlateau(\n", + " monitor='val_loss',\n", + " factor=0.5, \n", + " patience=6, \n", + " min_lr=1e-5,\n", + " verbose=1\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "4a7419d9-c414-445c-b305-e1a1e714c280", + "metadata": {}, + "outputs": [], + "source": [ + "model.compile(\n", + " optimizer=Adam(learning_rate=3e-4),\n", + " loss='sparse_categorical_crossentropy',\n", + " metrics=[tf.keras.metrics.SparseCategoricalAccuracy(name='accuracy'),tf.keras.metrics.SparseTopKCategoricalAccuracy(k=3, name='top3_acc')])" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "8c826161-2a17-430b-9475-9da65bad26a0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/70\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 1/900 [..............................] - ETA: 36:05 - loss: 2.5569 - accuracy: 0.1250 - top3_acc: 0.4375" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "900/900 [==============================] - 98s 106ms/step - loss: 1.3737 - accuracy: 0.4758 - top3_acc: 0.8164 - val_loss: 2.0515 - val_accuracy: 0.4344 - val_top3_acc: 0.8425 - lr: 3.0000e-04\n", + "Epoch 2/70\n", + "900/900 [==============================] - 89s 99ms/step - loss: 0.9369 - accuracy: 0.6388 - top3_acc: 0.9193 - val_loss: 1.9272 - val_accuracy: 0.6225 - val_top3_acc: 0.8461 - lr: 3.0000e-04\n", + "Epoch 3/70\n", + "900/900 [==============================] - 91s 101ms/step - loss: 0.7497 - accuracy: 0.7103 - top3_acc: 0.9488 - val_loss: 1.8166 - val_accuracy: 0.6519 - val_top3_acc: 0.8356 - lr: 3.0000e-04\n", + "Epoch 4/70\n", + "900/900 [==============================] - 90s 100ms/step - loss: 0.6271 - accuracy: 0.7555 - top3_acc: 0.9648 - val_loss: 1.8707 - val_accuracy: 0.6344 - val_top3_acc: 0.8583 - lr: 3.0000e-04\n", + "Epoch 5/70\n", + "900/900 [==============================] - 91s 101ms/step - loss: 0.5650 - accuracy: 0.7793 - top3_acc: 0.9710 - val_loss: 1.6513 - val_accuracy: 0.6653 - val_top3_acc: 0.8675 - lr: 3.0000e-04\n", + "Epoch 6/70\n", + "900/900 [==============================] - 91s 101ms/step - loss: 0.5140 - accuracy: 0.7977 - top3_acc: 0.9764 - val_loss: 1.5143 - val_accuracy: 0.6047 - val_top3_acc: 0.9661 - lr: 3.0000e-04\n", + "Epoch 7/70\n", + "900/900 [==============================] - 90s 100ms/step - loss: 0.4681 - accuracy: 0.8121 - top3_acc: 0.9797 - val_loss: 2.7695 - val_accuracy: 0.6411 - val_top3_acc: 0.8808 - lr: 3.0000e-04\n", + "Epoch 8/70\n", + "900/900 [==============================] - 91s 101ms/step - loss: 0.4470 - accuracy: 0.8212 - top3_acc: 0.9812 - val_loss: 2.2348 - val_accuracy: 0.5536 - val_top3_acc: 0.9014 - lr: 3.0000e-04\n", + "Epoch 9/70\n", + "900/900 [==============================] - 92s 102ms/step - loss: 0.4069 - accuracy: 0.8361 - top3_acc: 0.9842 - val_loss: 1.3703 - val_accuracy: 0.7686 - val_top3_acc: 0.9442 - lr: 3.0000e-04\n", + "Epoch 10/70\n", + "900/900 [==============================] - 90s 100ms/step - loss: 0.3895 - accuracy: 0.8422 - top3_acc: 0.9848 - val_loss: 1.6151 - val_accuracy: 0.7083 - val_top3_acc: 0.9481 - lr: 3.0000e-04\n", + "Epoch 11/70\n", + "900/900 [==============================] - 91s 101ms/step - loss: 0.3650 - accuracy: 0.8492 - top3_acc: 0.9876 - val_loss: 2.1853 - val_accuracy: 0.6767 - val_top3_acc: 0.8603 - lr: 3.0000e-04\n", + "Epoch 12/70\n", + "900/900 [==============================] - 92s 102ms/step - loss: 0.3543 - accuracy: 0.8542 - top3_acc: 0.9899 - val_loss: 2.2045 - val_accuracy: 0.6558 - val_top3_acc: 0.9008 - lr: 3.0000e-04\n", + "Epoch 13/70\n", + "900/900 [==============================] - 94s 104ms/step - loss: 0.3335 - accuracy: 0.8639 - top3_acc: 0.9892 - val_loss: 3.6508 - val_accuracy: 0.5947 - val_top3_acc: 0.7814 - lr: 3.0000e-04\n", + "Epoch 14/70\n", + "900/900 [==============================] - 94s 104ms/step - loss: 0.3273 - accuracy: 0.8678 - top3_acc: 0.9901 - val_loss: 1.1032 - val_accuracy: 0.7592 - val_top3_acc: 0.8992 - lr: 3.0000e-04\n", + "Epoch 15/70\n", + "900/900 [==============================] - 88s 98ms/step - loss: 0.3080 - accuracy: 0.8710 - top3_acc: 0.9908 - val_loss: 1.4935 - val_accuracy: 0.7069 - val_top3_acc: 0.9231 - lr: 3.0000e-04\n", + "Epoch 16/70\n", + "900/900 [==============================] - 88s 98ms/step - loss: 0.2903 - accuracy: 0.8810 - top3_acc: 0.9919 - val_loss: 1.0908 - val_accuracy: 0.8161 - val_top3_acc: 0.9450 - lr: 3.0000e-04\n", + "Epoch 17/70\n", + "900/900 [==============================] - 86s 95ms/step - loss: 0.2802 - accuracy: 0.8840 - top3_acc: 0.9946 - val_loss: 2.5118 - val_accuracy: 0.6278 - val_top3_acc: 0.8608 - lr: 3.0000e-04\n", + "Epoch 18/70\n", + "900/900 [==============================] - 87s 96ms/step - loss: 0.2579 - accuracy: 0.8953 - top3_acc: 0.9946 - val_loss: 2.9509 - val_accuracy: 0.6572 - val_top3_acc: 0.8736 - lr: 3.0000e-04\n", + "Epoch 19/70\n", + "900/900 [==============================] - 85s 94ms/step - loss: 0.2732 - accuracy: 0.8874 - top3_acc: 0.9939 - val_loss: 3.8577 - val_accuracy: 0.5883 - val_top3_acc: 0.8650 - lr: 3.0000e-04\n", + "Epoch 20/70\n", + "900/900 [==============================] - 87s 96ms/step - loss: 0.2499 - accuracy: 0.8959 - top3_acc: 0.9952 - val_loss: 1.1215 - val_accuracy: 0.7953 - val_top3_acc: 0.9272 - lr: 3.0000e-04\n", + "Epoch 21/70\n", + "900/900 [==============================] - 87s 96ms/step - loss: 0.2424 - accuracy: 0.9003 - top3_acc: 0.9951 - val_loss: 3.5802 - val_accuracy: 0.5847 - val_top3_acc: 0.8672 - lr: 3.0000e-04\n", + "Epoch 22/70\n", + "900/900 [==============================] - 86s 95ms/step - loss: 0.2375 - accuracy: 0.9021 - top3_acc: 0.9955 - val_loss: 0.7592 - val_accuracy: 0.8417 - val_top3_acc: 0.9483 - lr: 3.0000e-04\n", + "Epoch 23/70\n", + "900/900 [==============================] - 87s 97ms/step - loss: 0.2344 - accuracy: 0.9063 - top3_acc: 0.9962 - val_loss: 2.1202 - val_accuracy: 0.7453 - val_top3_acc: 0.9008 - lr: 3.0000e-04\n", + "Epoch 24/70\n", + "900/900 [==============================] - 87s 96ms/step - loss: 0.2169 - accuracy: 0.9103 - top3_acc: 0.9962 - val_loss: 1.5826 - val_accuracy: 0.7625 - val_top3_acc: 0.9292 - lr: 3.0000e-04\n", + "Epoch 25/70\n", + "900/900 [==============================] - 94s 104ms/step - loss: 0.2120 - accuracy: 0.9131 - top3_acc: 0.9970 - val_loss: 2.0005 - val_accuracy: 0.6944 - val_top3_acc: 0.9481 - lr: 3.0000e-04\n", + "Epoch 26/70\n", + "900/900 [==============================] - 93s 104ms/step - loss: 0.2161 - accuracy: 0.9159 - top3_acc: 0.9966 - val_loss: 1.6356 - val_accuracy: 0.7900 - val_top3_acc: 0.9317 - lr: 3.0000e-04\n", + "Epoch 27/70\n", + "900/900 [==============================] - 93s 104ms/step - loss: 0.2122 - accuracy: 0.9160 - top3_acc: 0.9964 - val_loss: 0.9562 - val_accuracy: 0.7878 - val_top3_acc: 0.9492 - lr: 3.0000e-04\n", + "Epoch 28/70\n", + "900/900 [==============================] - ETA: 0s - loss: 0.1933 - accuracy: 0.9226 - top3_acc: 0.9970 \n", + "Epoch 28: ReduceLROnPlateau reducing learning rate to 0.0001500000071246177.\n", + "900/900 [==============================] - 92s 102ms/step - loss: 0.1933 - accuracy: 0.9226 - top3_acc: 0.9970 - val_loss: 2.4211 - val_accuracy: 0.6183 - val_top3_acc: 0.8806 - lr: 3.0000e-04\n", + "Epoch 29/70\n", + "900/900 [==============================] - 92s 103ms/step - loss: 0.1647 - accuracy: 0.9336 - top3_acc: 0.9975 - val_loss: 0.7989 - val_accuracy: 0.8433 - val_top3_acc: 0.9394 - lr: 1.5000e-04\n", + "Epoch 30/70\n", + "900/900 [==============================] - 93s 103ms/step - loss: 0.1452 - accuracy: 0.9401 - top3_acc: 0.9991 - val_loss: 1.3660 - val_accuracy: 0.7811 - val_top3_acc: 0.9269 - lr: 1.5000e-04\n", + "Epoch 31/70\n", + "900/900 [==============================] - 93s 103ms/step - loss: 0.1426 - accuracy: 0.9423 - top3_acc: 0.9985 - val_loss: 3.7842 - val_accuracy: 0.6017 - val_top3_acc: 0.8714 - lr: 1.5000e-04\n", + "Epoch 32/70\n", + "900/900 [==============================] - 91s 102ms/step - loss: 0.1444 - accuracy: 0.9408 - top3_acc: 0.9985 - val_loss: 1.3620 - val_accuracy: 0.7589 - val_top3_acc: 0.9372 - lr: 1.5000e-04\n" + ] + } + ], + "source": [ + "history = model.fit(train_data,validation_data=val_data,epochs=70,callbacks=[early_stop, checkpoint, lr_schedule])" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "fba25a62-92d9-472b-ac66-6fa6cba3e6c1", + "metadata": {}, + "outputs": [], + "source": [ + "best_model=tf.keras.models.load_model(\"best_fish_cnn.keras\")" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "235fccf8-08d1-4229-88fb-031ffa3aded6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "225/225 [==============================] - 17s 74ms/step - loss: 0.7592 - accuracy: 0.8417 - top3_acc: 0.9483\n" + ] + }, + { + "data": { + "text/plain": [ + "[0.7591931819915771, 0.8416666388511658, 0.9483333230018616]" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "best_model.evaluate(val_data)" + ] + }, + { + "cell_type": "markdown", + "id": "0a83fe7d-31d6-496a-9f84-d79810a40dc2", + "metadata": {}, + "source": [ + "## Results (Short & Simple)\n", + "\n", + "The final CNN model achieved:\n", + "\n", + "- **Validation accuracy:** ~84%\n", + "- **Top-3 accuracy:** ~95%\n", + "- **Validation loss:** ~0.76\n", + "\n", + "### Class Performance\n", + "- **Excellent:** Black Sea Sprat, Shrimp (precision & recall = 1.00)\n", + "- **Very good:** Red Sea Bream (F1 = 0.94)\n", + "- **Good:** House Mackerel, Trout, Striped Red Mullet (F1 ≈ 0.80–0.84)\n", + "- **More difficult classes:**\n", + " - Gilt-Head Bream (F1 = 0.69)\n", + " - Red Mullet (F1 = 0.75)\n", + " - Sea Bass (F1 = 0.57)\n", + "\n", + "### Summary\n", + "The CNN performs strongly overall, especially for a model trained **from scratch**. \n", + "Most errors occur between fish species that look **visually similar**." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "4e163af5-f62b-4ed5-9373-eaecdc8246ad", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "225/225 [==============================] - 18s 80ms/step\n", + " precision recall f1-score support\n", + "\n", + " Black Sea Sprat 1.00 1.00 1.00 400\n", + " Gilt-Head Bream 0.79 0.62 0.69 400\n", + " Hourse Mackerel 0.80 0.89 0.84 400\n", + " Red Mullet 0.94 0.62 0.75 400\n", + " Red Sea Bream 0.90 0.99 0.94 400\n", + " Sea Bass 0.57 0.95 0.71 400\n", + " Shrimp 1.00 1.00 1.00 400\n", + "Striped Red Mullet 0.88 0.73 0.80 400\n", + " Trout 0.92 0.78 0.84 400\n", + "\n", + " accuracy 0.84 3600\n", + " macro avg 0.87 0.84 0.84 3600\n", + " weighted avg 0.87 0.84 0.84 3600\n", + "\n" + ] + } + ], + "source": [ + "y_true=val_data.classes\n", + "y_pred_probs=best_model.predict(val_data)\n", + "y_pred=np.argmax(y_pred_probs, axis=1)\n", + "print(classification_report(y_true, y_pred, target_names=val_data.class_indices.keys()))" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "e4549371-a672-4962-a6a1-69913255b14e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Confusion Matrix\n", + "cm = confusion_matrix(y_true, y_pred)\n", + "\n", + "plt.figure(figsize=(10, 8))\n", + "sns.heatmap(cm, annot=True,fmt='d', cmap=\"Blues\")\n", + "\n", + "plt.title(\"Confusion Matrix – Fish Classification (CNN)\")\n", + "plt.xlabel(\"Predicted Labels\")\n", + "plt.ylabel(\"True Labels\")\n", + "\n", + "plt.xticks(\n", + " ticks=np.arange(len(val_data.class_indices)),\n", + " labels=list(val_data.class_indices.keys()),\n", + " rotation=45,\n", + " ha='right'\n", + ")\n", + "plt.yticks(\n", + " ticks=np.arange(len(val_data.class_indices)),\n", + " labels=list(val_data.class_indices.keys()),\n", + " rotation=0\n", + ")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "01fec13a-b06b-449a-9250-64aaa8fa07fe", + "metadata": {}, + "source": [ + "### Reflection\n", + "\n", + "I learned how to build a CNN without using transfer learning.\n", + "I also learned the importance of data augmentation, callbacks, and careful architecture design.\n", + "The model performed much better than I expected for a scratch-built model.\n", + "\n", + "If I continued this project, I would:\n", + "\n", + "- try a deeper CNN\n", + "\n", + "- test different regularization methods\n", + "\n", + "- compare the scratch model with a ResNet50 transfer learning model\n", + "\n", + "This helped me understand how CNNs work and prepared me for building the next model with transfer learning." + ] + }, + { + "cell_type": "markdown", + "id": "a1904b12-f32d-44d6-9c5f-55ef33d1f908", + "metadata": {}, + "source": [ + "# ResNet50 Model" + ] + }, + { + "cell_type": "markdown", + "id": "70fe5a47-6ad5-4694-8f0c-2f7e64fa3773", + "metadata": {}, + "source": [ + "### Introduction\n", + "\n", + "In this project, I built a deep learning model to classify 9 different fish species using Transfer Learning. I used the ResNet50 architecture with ImageNet weights as a feature extractor. The goal was to achieve high accuracy while keeping the training stable and efficient. Transfer Learning is useful because it allows us to use powerful pretrained models, even when our dataset is not extremely large." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "46b9e277-9c63-4d39-83c3-8b3b523a7d99", + "metadata": {}, + "outputs": [], + "source": [ + "from tensorflow.keras.applications import ResNet50\n", + "from tensorflow.keras.applications.resnet50 import preprocess_input" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "a147c816-77f8-404a-a3ec-de92dd1a2a60", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 14400 images belonging to 9 classes.\n", + "Found 3600 images belonging to 9 classes.\n" + ] + } + ], + "source": [ + "data_dir = Path(path2) / \"Fish_Dataset\" / \"Fish_Dataset\"\n", + "\n", + "img_size = (224, 224)\n", + "batch_size = 16\n", + "\n", + "train_datagen = ImageDataGenerator(\n", + " preprocessing_function=preprocess_input,\n", + " validation_split=0.2,\n", + " rotation_range=25,\n", + " width_shift_range=0.15,\n", + " height_shift_range=0.15,\n", + " zoom_range=0.15,\n", + " shear_range=0.15,\n", + " horizontal_flip=True,\n", + " fill_mode='nearest'\n", + ")\n", + "\n", + "val_datagen = ImageDataGenerator(\n", + " preprocessing_function=preprocess_input,\n", + " validation_split=0.2\n", + ")\n", + "\n", + "train_data = train_datagen.flow_from_directory(\n", + " data_dir,\n", + " target_size=img_size,\n", + " batch_size=batch_size,\n", + " subset='training',\n", + " class_mode='sparse',\n", + " shuffle=True\n", + ")\n", + "\n", + "val_data = val_datagen.flow_from_directory(\n", + " data_dir,\n", + " target_size=img_size,\n", + " batch_size=batch_size,\n", + " subset='validation',\n", + " class_mode='sparse',\n", + " shuffle=False\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "ba555041-686c-42bf-ad30-144934fc2950", + "metadata": {}, + "source": [ + "### Analysis\n", + "\n", + "The dataset contains 9 fish classes, each with 400 images in the validation set.\n", + "The training data was loaded using ImageDataGenerator, including augmentation such as rotation, zoom, width/height shift, and flipping.\n", + "This helps the model generalize better and prevents overfitting.\n", + "\n", + "Examples of the classes include:\n", + "\n", + "- Black Sea Sprat\n", + "\n", + "- Gilt-Head Bream\n", + "\n", + "- Red Mullet\n", + "\n", + "- Trout\n", + "\n", + "- Shrimp\n", + "\n", + "- Sea Bass\n", + "\n", + "- Red Sea Bream\n", + "\n", + "The dataset is clean, balanced and well-structured, making it suitable for image classification." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "56a269a9-8e80-4416-94e1-a9dee5493d6e", + "metadata": {}, + "outputs": [], + "source": [ + "early_stop = EarlyStopping(\n", + " monitor='val_loss',\n", + " patience=7,\n", + " restore_best_weights=True\n", + ")\n", + "\n", + "checkpoint = ModelCheckpoint(\n", + " filepath='best_fish_resnet50.keras',\n", + " monitor='val_loss',\n", + " save_best_only=True\n", + ")\n", + "\n", + "lr_schedule = ReduceLROnPlateau(\n", + " monitor='val_loss',\n", + " factor=0.5, \n", + " patience=2, \n", + " min_lr=1e-6,\n", + " verbose=1\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "22852d02-5016-47fc-b50b-58e1b56ea959", + "metadata": {}, + "outputs": [], + "source": [ + "base_model = ResNet50(\n", + " weights='imagenet',\n", + " include_top=False,\n", + " input_shape=(224, 224, 3)\n", + ")\n", + "\n", + "base_model.trainable = False\n", + "\n", + "model = Sequential()\n", + "model.add(base_model)\n", + "model.add(GlobalAveragePooling2D())\n", + "model.add(Dense(256, activation='relu'))\n", + "model.add(Dropout(0.5))\n", + "model.add(Dense(9, activation='softmax'))\n", + "\n", + "model.compile(\n", + " optimizer=Adam(learning_rate=1e-3),\n", + " loss='sparse_categorical_crossentropy',\n", + " metrics=['accuracy', SparseTopKCategoricalAccuracy(k=3, name='top3_acc')]\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "30b50da3-402a-4e57-b51b-d348ed550b54", + "metadata": {}, + "source": [ + "### Methods\n", + "\n", + "I used ResNet50 with ImageNet weights, removed the top classification layer, and added:\n", + "\n", + "- GlobalAveragePooling\n", + "\n", + "- Dense(256, ReLU)\n", + "\n", + "- Dropout(0.5)\n", + "\n", + "- Dense(9, Softmax)\n", + "\n", + "The base ResNet50 layers were frozen so only the top classifier was trained.\n", + "\n", + "I trained the model using:\n", + "\n", + "- Optimizer: Adam (learning rate = 1e-3 → reduced automatically by ReduceLROnPlateau)\n", + "\n", + "- Loss: Sparse Categorical Crossentropy\n", + "\n", + "- Metrics: Accuracy, Top-3 Accuracy\n", + "\n", + "- Callbacks: EarlyStopping, ModelCheckpoint, ReduceLROnPlateau\n", + "\n", + "This helped stabilize training and automatically save the best model." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "f22efb0e-3609-43c5-988f-11294bffdf56", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/40\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1764717623.075938 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.118437 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.122537 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.127746 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.133436 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.200248 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.210638 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.302883 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.309501 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.318684 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.321276 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.323632 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.325378 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.327559 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.338452 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.359175 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.402958 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.410107 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.412143 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.414331 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.416141 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.417670 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.419483 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.421422 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.441750 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.445856 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.450837 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.452867 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.454735 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.457384 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.459245 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.461099 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.463769 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.484172 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.488685 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.491698 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.493282 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.494790 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.496624 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.498794 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.504163 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.504741 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.505395 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.506171 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.507200 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.508210 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.510820 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.512166 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.514636 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.520657 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.522694 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.524347 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.526698 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.530279 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.546718 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.550374 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.556506 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.557366 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.559007 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.561886 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.564249 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.566937 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.570011 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.575429 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.576456 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.577854 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.579622 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.581666 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.583956 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.585375 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.586447 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.587512 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.588576 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.589501 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.591406 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.597629 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.600227 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.602547 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.604330 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.606211 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.608294 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.612374 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.623997 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.625452 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.627392 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.629788 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.631293 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.633428 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.635519 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.639772 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.643812 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.649257 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.650408 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.651857 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.658666 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.660277 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.662649 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.663890 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.665006 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.665549 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.666644 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.667712 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.669394 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.671386 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.673817 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.675441 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.677259 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.678822 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.680536 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.685547 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.740779 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.742763 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.745312 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.747829 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.750776 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.753599 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.756385 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.761506 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.776752 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.779621 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.782120 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.784324 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.786855 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.788422 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.790543 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717623.795501 386 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "I0000 00:00:1764717624.575247 379 service.cc:146] XLA service 0x7799b43afe60 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices:\n", + "I0000 00:00:1764717624.575400 379 service.cc:154] StreamExecutor device (0): NVIDIA GeForce RTX 5080 Laptop GPU, Compute Capability 12.0\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "I0000 00:00:1764717625.011893 379 device_compiler.h:188] Compiled cluster using XLA! This line is logged at most once for the lifetime of the process.\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 1/900 [..............................] - ETA: 1:29:54 - loss: 3.1299 - accuracy: 0.0625 - top3_acc: 0.4375" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "'+ptx85' is not a recognized feature for this target (ignoring feature)\n", + "W0000 00:00:1764717625.309240 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.311197 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.313379 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.316038 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.318925 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.321693 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.324243 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.333922 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.339550 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.342376 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.343800 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.345547 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.347889 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.349377 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.351452 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 2/900 [..............................] - ETA: 3:57 - loss: 3.4138 - accuracy: 0.0938 - top3_acc: 0.3750 " + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1764717625.378033 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.382408 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.386087 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.387620 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.389658 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.391357 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.392697 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.394159 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.398031 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.419714 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.424906 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.435688 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.437176 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.439446 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.441464 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.442836 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.444774 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.445665 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.466641 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.470657 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.473151 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.474357 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.475948 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.477264 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.478731 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.481155 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.481787 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.482666 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.483056 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.483440 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.484402 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.486606 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.493635 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.494364 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.495910 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.497228 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.498696 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.500517 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.501350 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.501641 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.502026 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.502955 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.503489 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.507026 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.512499 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.513623 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.514878 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.516710 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.518201 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.520233 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.520942 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.521898 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.522472 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.522804 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.523410 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.525345 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.527085 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.528612 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.529573 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.531234 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.532607 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.534033 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.538653 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.576558 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 4/900 [..............................] - ETA: 2:18 - loss: 3.0615 - accuracy: 0.1406 - top3_acc: 0.4844" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1764717625.589358 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.590916 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.592534 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.594783 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.596453 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.599667 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.600577 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.601264 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.601766 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.602548 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.604045 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.608390 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.626128 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.627162 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.628273 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.630028 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.632801 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.636012 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.637320 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.638898 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.639938 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.640663 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.641115 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.673022 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.685624 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.688010 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.689463 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.691420 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.693164 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.695591 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.696413 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.698325 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.700745 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.702324 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.703558 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.708168 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.724957 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.726484 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.728022 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.729732 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.732183 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.735149 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.736263 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.737485 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.738803 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.744882 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.745728 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.778877 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 6/900 [..............................] - ETA: 1:45 - loss: 3.1409 - accuracy: 0.1458 - top3_acc: 0.4792" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1764717625.804435 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.805475 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.806623 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.807136 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.808050 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.841944 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.868616 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.869290 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.870170 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.871383 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1764717625.872497 379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "900/900 [==============================] - 158s 169ms/step - loss: 0.9070 - accuracy: 0.6649 - top3_acc: 0.9154 - val_loss: 0.1462 - val_accuracy: 0.9519 - val_top3_acc: 1.0000 - lr: 0.0010\n", + "Epoch 2/40\n", + "900/900 [==============================] - 115s 128ms/step - loss: 0.6191 - accuracy: 0.7604 - top3_acc: 0.9622 - val_loss: 0.1350 - val_accuracy: 0.9531 - val_top3_acc: 1.0000 - lr: 0.0010\n", + "Epoch 3/40\n", + "900/900 [==============================] - 89s 99ms/step - loss: 0.5696 - accuracy: 0.7742 - top3_acc: 0.9663 - val_loss: 0.0981 - val_accuracy: 0.9692 - val_top3_acc: 0.9994 - lr: 0.0010\n", + "Epoch 4/40\n", + "900/900 [==============================] - 90s 99ms/step - loss: 0.5550 - accuracy: 0.7838 - top3_acc: 0.9667 - val_loss: 0.1143 - val_accuracy: 0.9617 - val_top3_acc: 0.9992 - lr: 0.0010\n", + "Epoch 5/40\n", + "900/900 [==============================] - ETA: 0s - loss: 0.5167 - accuracy: 0.7980 - top3_acc: 0.9717 \n", + "Epoch 5: ReduceLROnPlateau reducing learning rate to 0.0005000000237487257.\n", + "900/900 [==============================] - 89s 99ms/step - loss: 0.5167 - accuracy: 0.7980 - top3_acc: 0.9717 - val_loss: 0.1071 - val_accuracy: 0.9606 - val_top3_acc: 0.9992 - lr: 0.0010\n", + "Epoch 6/40\n", + "900/900 [==============================] - 92s 102ms/step - loss: 0.4492 - accuracy: 0.8199 - top3_acc: 0.9789 - val_loss: 0.0704 - val_accuracy: 0.9767 - val_top3_acc: 0.9997 - lr: 5.0000e-04\n", + "Epoch 7/40\n", + "900/900 [==============================] - 92s 102ms/step - loss: 0.4230 - accuracy: 0.8324 - top3_acc: 0.9817 - val_loss: 0.0848 - val_accuracy: 0.9728 - val_top3_acc: 0.9989 - lr: 5.0000e-04\n", + "Epoch 8/40\n", + "900/900 [==============================] - ETA: 0s - loss: 0.4174 - accuracy: 0.8349 - top3_acc: 0.9817 \n", + "Epoch 8: ReduceLROnPlateau reducing learning rate to 0.0002500000118743628.\n", + "900/900 [==============================] - 92s 102ms/step - loss: 0.4174 - accuracy: 0.8349 - top3_acc: 0.9817 - val_loss: 0.0707 - val_accuracy: 0.9764 - val_top3_acc: 0.9997 - lr: 5.0000e-04\n", + "Epoch 9/40\n", + "900/900 [==============================] - 92s 102ms/step - loss: 0.3839 - accuracy: 0.8471 - top3_acc: 0.9844 - val_loss: 0.0836 - val_accuracy: 0.9722 - val_top3_acc: 0.9994 - lr: 2.5000e-04\n", + "Epoch 10/40\n", + "900/900 [==============================] - 93s 103ms/step - loss: 0.3690 - accuracy: 0.8531 - top3_acc: 0.9866 - val_loss: 0.0542 - val_accuracy: 0.9847 - val_top3_acc: 1.0000 - lr: 2.5000e-04\n", + "Epoch 11/40\n", + "900/900 [==============================] - 92s 103ms/step - loss: 0.3620 - accuracy: 0.8540 - top3_acc: 0.9860 - val_loss: 0.0765 - val_accuracy: 0.9778 - val_top3_acc: 0.9994 - lr: 2.5000e-04\n", + "Epoch 12/40\n", + "900/900 [==============================] - ETA: 0s - loss: 0.3595 - accuracy: 0.8560 - top3_acc: 0.9856 \n", + "Epoch 12: ReduceLROnPlateau reducing learning rate to 0.0001250000059371814.\n", + "900/900 [==============================] - 92s 103ms/step - loss: 0.3595 - accuracy: 0.8560 - top3_acc: 0.9856 - val_loss: 0.0701 - val_accuracy: 0.9803 - val_top3_acc: 0.9994 - lr: 2.5000e-04\n", + "Epoch 13/40\n", + "900/900 [==============================] - 93s 103ms/step - loss: 0.3424 - accuracy: 0.8662 - top3_acc: 0.9872 - val_loss: 0.0488 - val_accuracy: 0.9847 - val_top3_acc: 1.0000 - lr: 1.2500e-04\n", + "Epoch 14/40\n", + "900/900 [==============================] - 93s 103ms/step - loss: 0.3399 - accuracy: 0.8647 - top3_acc: 0.9873 - val_loss: 0.0592 - val_accuracy: 0.9833 - val_top3_acc: 1.0000 - lr: 1.2500e-04\n", + "Epoch 15/40\n", + "900/900 [==============================] - ETA: 0s - loss: 0.3330 - accuracy: 0.8717 - top3_acc: 0.9881 \n", + "Epoch 15: ReduceLROnPlateau reducing learning rate to 6.25000029685907e-05.\n", + "900/900 [==============================] - 93s 103ms/step - loss: 0.3330 - accuracy: 0.8717 - top3_acc: 0.9881 - val_loss: 0.0540 - val_accuracy: 0.9844 - val_top3_acc: 1.0000 - lr: 1.2500e-04\n", + "Epoch 16/40\n", + "900/900 [==============================] - 89s 98ms/step - loss: 0.3297 - accuracy: 0.8750 - top3_acc: 0.9878 - val_loss: 0.0546 - val_accuracy: 0.9822 - val_top3_acc: 0.9997 - lr: 6.2500e-05\n", + "Epoch 17/40\n", + "900/900 [==============================] - ETA: 0s - loss: 0.3316 - accuracy: 0.8717 - top3_acc: 0.9885 \n", + "Epoch 17: ReduceLROnPlateau reducing learning rate to 3.125000148429535e-05.\n", + "900/900 [==============================] - 86s 96ms/step - loss: 0.3316 - accuracy: 0.8717 - top3_acc: 0.9885 - val_loss: 0.0591 - val_accuracy: 0.9825 - val_top3_acc: 0.9997 - lr: 6.2500e-05\n", + "Epoch 18/40\n", + "900/900 [==============================] - 86s 96ms/step - loss: 0.3327 - accuracy: 0.8686 - top3_acc: 0.9873 - val_loss: 0.0585 - val_accuracy: 0.9819 - val_top3_acc: 0.9997 - lr: 3.1250e-05\n", + "Epoch 19/40\n", + "900/900 [==============================] - ETA: 0s - loss: 0.3212 - accuracy: 0.8752 - top3_acc: 0.9899 \n", + "Epoch 19: ReduceLROnPlateau reducing learning rate to 1.5625000742147677e-05.\n", + "900/900 [==============================] - 86s 96ms/step - loss: 0.3212 - accuracy: 0.8752 - top3_acc: 0.9899 - val_loss: 0.0571 - val_accuracy: 0.9819 - val_top3_acc: 0.9997 - lr: 3.1250e-05\n", + "Epoch 20/40\n", + "900/900 [==============================] - 86s 96ms/step - loss: 0.3175 - accuracy: 0.8751 - top3_acc: 0.9904 - val_loss: 0.0573 - val_accuracy: 0.9822 - val_top3_acc: 0.9997 - lr: 1.5625e-05\n" + ] + } + ], + "source": [ + "history = model.fit(train_data,validation_data=val_data,epochs=40,callbacks=[early_stop, checkpoint, lr_schedule],verbose=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "9033fea7-c222-4c31-acde-6c049ec0a248", + "metadata": {}, + "outputs": [], + "source": [ + "with open(\"fish_resnet50_history.pkl\", \"wb\") as f:\n", + " pickle.dump(history.history, f)" + ] + }, + { + "cell_type": "markdown", + "id": "0b9cc3b4-405c-4b12-815a-830cc335e1a3", + "metadata": {}, + "source": [ + "### Results\n", + "\n", + "The model reached excellent performance:\n", + "\n", + "- Validation Accuracy: ~98.5%\n", + "\n", + "- Top-3 Accuracy: 100%\n", + "\n", + "- Validation Loss: ~0.05\n", + "\n", + "The classification report shows very strong precision and recall for all 9 classes.\n", + "The confusion matrix confirms the model makes very few mistakes.\n", + "\n", + "The training and validation accuracy curves show smooth improvement without overfitting.\n", + "The validation loss also decreases steadily, confirming good generalization." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "39b40a7e-4682-4ceb-91dd-28e514659533", + "metadata": {}, + "outputs": [], + "source": [ + "best_model=tf.keras.models.load_model(\"best_fish_resnet50.keras\")" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "802e429c-f04e-4496-975f-a2d05ee8cff0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "225/225 [==============================] - 18s 74ms/step - loss: 0.0488 - accuracy: 0.9847 - top3_acc: 1.0000\n" + ] + }, + { + "data": { + "text/plain": [ + "[0.04880942404270172, 0.9847221970558167, 1.0]" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "best_model.evaluate(val_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "bb10d594-6a47-4025-a30a-924f2262ac55", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "225/225 [==============================] - 19s 83ms/step\n", + " precision recall f1-score support\n", + "\n", + " Black Sea Sprat 1.00 0.97 0.98 400\n", + " Gilt-Head Bream 0.98 0.97 0.98 400\n", + " Hourse Mackerel 0.98 0.98 0.98 400\n", + " Red Mullet 0.99 0.99 0.99 400\n", + " Red Sea Bream 0.97 1.00 0.99 400\n", + " Sea Bass 0.97 1.00 0.98 400\n", + " Shrimp 0.99 1.00 0.99 400\n", + "Striped Red Mullet 0.99 0.96 0.98 400\n", + " Trout 1.00 0.98 0.99 400\n", + "\n", + " accuracy 0.98 3600\n", + " macro avg 0.98 0.98 0.98 3600\n", + " weighted avg 0.98 0.98 0.98 3600\n", + "\n" + ] + } + ], + "source": [ + "y_true = val_data.classes\n", + "y_pred_probs = best_model.predict(val_data)\n", + "y_pred = np.argmax(y_pred_probs, axis=1)\n", + "\n", + "print(classification_report(\n", + " y_true, \n", + " y_pred, \n", + " target_names=val_data.class_indices.keys()\n", + "))" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "c7b08465-764e-4d4d-8017-9ea298ae30e2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Confusion Matrix\n", + "cm=confusion_matrix(y_true, y_pred)\n", + "\n", + "plt.figure(figsize=(10, 8))\n", + "sns.heatmap(\n", + " cm,\n", + " annot=True,\n", + " fmt=\"d\",\n", + " cmap=\"Blues\",\n", + " xticklabels=list(val_data.class_indices.keys()),\n", + " yticklabels=list(val_data.class_indices.keys())\n", + ")\n", + "\n", + "plt.title(\"Confusion Matrix – Fish Classification (ResNet50)\")\n", + "plt.xlabel(\"Predicted Label\")\n", + "plt.ylabel(\"True Label\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "824ed92b-93b7-407d-b47e-12bd78f0ec35", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Accuracy & Loss Plot\n", + "\n", + "plt.figure(figsize=(14, 5))\n", + "\n", + "# Accuracy\n", + "plt.subplot(1, 2, 1)\n", + "plt.plot(history.history['accuracy'], label='Train Accuracy')\n", + "plt.plot(history.history['val_accuracy'], label='Validation Accuracy')\n", + "plt.title('ResNet50 – Training & Validation Accuracy')\n", + "plt.xlabel('Epoch')\n", + "plt.ylabel('Accuracy')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "\n", + "# Loss\n", + "plt.subplot(1, 2, 2)\n", + "plt.plot(history.history['loss'], label='Train Loss')\n", + "plt.plot(history.history['val_loss'], label='Validation Loss')\n", + "plt.title('ResNet50 – Training & Validation Loss')\n", + "plt.xlabel('Epoch')\n", + "plt.ylabel('Loss')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "8e60f733-aabd-4b58-aeaf-b17737358e3b", + "metadata": {}, + "source": [ + "### Reflection\n", + "\n", + "Through this project, I learned how powerful Transfer Learning can be.\n", + "ResNet50 performed much better than a custom CNN, especially with fewer epochs and less overfitting.\n", + "\n", + "If I continued this project, I would:\n", + "\n", + "- Try fine-tuning some deeper layers\n", + "\n", + "- Experiment with larger batch sizes\n", + "\n", + "- Test other architectures such as EfficientNet or MobileNet\n", + "\n", + "- Deploy the model in a real application\n", + "\n", + "Overall, this project helped me understand how to use pretrained networks, callbacks, and effective data augmentation to achieve high-quality results." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}