From 1a7deafab74ef235bf6c6cde4ec9ac1de54fb00b Mon Sep 17 00:00:00 2001 From: BinarySandia04 Date: Tue, 26 May 2026 14:14:30 +0200 Subject: [PATCH] Test notebook run --- Skin_Cancer_Classification.ipynb | 1696 ++++++++++++++++++++++++++++++ run.sh | 3 +- 2 files changed, 1698 insertions(+), 1 deletion(-) create mode 100644 Skin_Cancer_Classification.ipynb diff --git a/Skin_Cancer_Classification.ipynb b/Skin_Cancer_Classification.ipynb new file mode 100644 index 0000000..28ae7bd --- /dev/null +++ b/Skin_Cancer_Classification.ipynb @@ -0,0 +1,1696 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "KxrbxwqYBQr0" + }, + "source": [ + "# Skin Cancer Classification\n", + "The objective of this project is to train a deep learning model to classify skin lesions into **benign** (non-cancerous) and **malignant** (cancerous) for medical diagnosis.\n", + "\n", + "We plan to use the popular **Skin Cancer: HAM10000** dataset, which contains 10015 dermatoscopic images from different populations.\n", + "https://www.kaggle.com/datasets/kmader/skin-cancer-mnist-ham10000/data\n", + "\n", + "The model we are going to train for the task is the popular **DenseNet121** model, via transfer learning since it is pretrained. It is highly used in the medical field.\n" + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 1. Requirements and dataset download" + ], + "metadata": { + "id": "Ia-kdvqch4pE" + } + }, + { + "cell_type": "code", + "source": [ + "import sys\n", + "IN_COLAB = 'google.colab' in sys.modules\n", + "\n", + "if IN_COLAB:\n", + " !pip install pandas numpy matplotlib seaborn pillow scikit-learn tensorflow\n", + " !pip install --upgrade kagglehub[pandas-datasets,hf-datasets]\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "collapsed": true, + "id": "lN4A6TSK_WcI", + "outputId": "2adba5d4-f7c4-4dd6-c527-84814afecb49" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Requirement already satisfied: pandas in /usr/local/lib/python3.12/dist-packages (2.2.2)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.12/dist-packages (2.0.2)\n", + "Requirement already satisfied: matplotlib in /usr/local/lib/python3.12/dist-packages (3.10.0)\n", + "Requirement already satisfied: seaborn in /usr/local/lib/python3.12/dist-packages (0.13.2)\n", + "Requirement already satisfied: pillow in /usr/local/lib/python3.12/dist-packages (11.3.0)\n", + "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.12/dist-packages (1.6.1)\n", + "Requirement already satisfied: tensorflow in /usr/local/lib/python3.12/dist-packages (2.20.0)\n", + "Requirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.12/dist-packages (from pandas) (2.9.0.post0)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.12/dist-packages (from pandas) (2025.2)\n", + "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.12/dist-packages (from pandas) (2026.1)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (1.3.3)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (4.62.1)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (1.5.0)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (26.1)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (3.3.2)\n", + "Requirement already satisfied: scipy>=1.6.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn) (1.16.3)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn) (1.5.3)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn) (3.6.0)\n", + "Requirement already satisfied: absl-py>=1.0.0 in /usr/local/lib/python3.12/dist-packages (from tensorflow) (1.4.0)\n", + "Requirement already satisfied: astunparse>=1.6.0 in /usr/local/lib/python3.12/dist-packages (from tensorflow) (1.6.3)\n", + "Requirement already satisfied: flatbuffers>=24.3.25 in /usr/local/lib/python3.12/dist-packages (from tensorflow) (25.12.19)\n", + "Requirement already satisfied: gast!=0.5.0,!=0.5.1,!=0.5.2,>=0.2.1 in /usr/local/lib/python3.12/dist-packages (from tensorflow) (0.7.0)\n", + "Requirement already satisfied: google_pasta>=0.1.1 in /usr/local/lib/python3.12/dist-packages (from tensorflow) (0.2.0)\n", + "Requirement already satisfied: libclang>=13.0.0 in /usr/local/lib/python3.12/dist-packages (from tensorflow) (18.1.1)\n", + "Requirement already satisfied: opt_einsum>=2.3.2 in /usr/local/lib/python3.12/dist-packages (from tensorflow) (3.4.0)\n", + "Requirement already satisfied: protobuf>=5.28.0 in /usr/local/lib/python3.12/dist-packages (from tensorflow) (5.29.6)\n", + "Requirement already satisfied: requests<3,>=2.21.0 in /usr/local/lib/python3.12/dist-packages (from tensorflow) (2.32.4)\n", + "Requirement already satisfied: setuptools in /usr/local/lib/python3.12/dist-packages (from tensorflow) (75.2.0)\n", + "Requirement already satisfied: six>=1.12.0 in /usr/local/lib/python3.12/dist-packages (from tensorflow) (1.17.0)\n", + "Requirement already satisfied: termcolor>=1.1.0 in /usr/local/lib/python3.12/dist-packages (from tensorflow) (3.3.0)\n", + "Requirement already satisfied: typing_extensions>=3.6.6 in /usr/local/lib/python3.12/dist-packages (from tensorflow) (4.15.0)\n", + "Requirement already satisfied: wrapt>=1.11.0 in /usr/local/lib/python3.12/dist-packages (from tensorflow) (2.1.2)\n", + "Requirement already satisfied: grpcio<2.0,>=1.24.3 in /usr/local/lib/python3.12/dist-packages (from tensorflow) (1.80.0)\n", + "Requirement already satisfied: tensorboard~=2.20.0 in /usr/local/lib/python3.12/dist-packages (from tensorflow) (2.20.0)\n", + "Requirement already satisfied: keras>=3.10.0 in /usr/local/lib/python3.12/dist-packages (from tensorflow) (3.13.2)\n", + "Requirement already satisfied: h5py>=3.11.0 in /usr/local/lib/python3.12/dist-packages (from tensorflow) (3.16.0)\n", + "Requirement already satisfied: ml_dtypes<1.0.0,>=0.5.1 in /usr/local/lib/python3.12/dist-packages (from tensorflow) (0.5.4)\n", + "Requirement already satisfied: wheel<1.0,>=0.23.0 in /usr/local/lib/python3.12/dist-packages (from astunparse>=1.6.0->tensorflow) (0.47.0)\n", + "Requirement already satisfied: rich in /usr/local/lib/python3.12/dist-packages (from keras>=3.10.0->tensorflow) (13.9.4)\n", + "Requirement already satisfied: namex in /usr/local/lib/python3.12/dist-packages (from keras>=3.10.0->tensorflow) (0.1.0)\n", + "Requirement already satisfied: optree in /usr/local/lib/python3.12/dist-packages (from keras>=3.10.0->tensorflow) (0.19.0)\n", + "Requirement already satisfied: charset_normalizer<4,>=2 in /usr/local/lib/python3.12/dist-packages (from requests<3,>=2.21.0->tensorflow) (3.4.7)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.12/dist-packages (from requests<3,>=2.21.0->tensorflow) (3.13)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.12/dist-packages (from requests<3,>=2.21.0->tensorflow) (2.5.0)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.12/dist-packages (from requests<3,>=2.21.0->tensorflow) (2026.4.22)\n", + "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.12/dist-packages (from tensorboard~=2.20.0->tensorflow) (3.10.2)\n", + "Requirement already satisfied: tensorboard-data-server<0.8.0,>=0.7.0 in /usr/local/lib/python3.12/dist-packages (from tensorboard~=2.20.0->tensorflow) (0.7.2)\n", + "Requirement already satisfied: werkzeug>=1.0.1 in /usr/local/lib/python3.12/dist-packages (from tensorboard~=2.20.0->tensorflow) (3.1.8)\n", + "Requirement already satisfied: markupsafe>=2.1.1 in /usr/local/lib/python3.12/dist-packages (from werkzeug>=1.0.1->tensorboard~=2.20.0->tensorflow) (3.0.3)\n", + "Requirement already satisfied: markdown-it-py>=2.2.0 in /usr/local/lib/python3.12/dist-packages (from rich->keras>=3.10.0->tensorflow) (4.0.0)\n", + "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /usr/local/lib/python3.12/dist-packages (from rich->keras>=3.10.0->tensorflow) (2.20.0)\n", + "Requirement already satisfied: mdurl~=0.1 in /usr/local/lib/python3.12/dist-packages (from markdown-it-py>=2.2.0->rich->keras>=3.10.0->tensorflow) (0.1.2)\n", + "Requirement already satisfied: kagglehub[hf-datasets,pandas-datasets] in /usr/local/lib/python3.12/dist-packages (1.0.1)\n", + "Requirement already satisfied: kagglesdk<1.0,>=0.1.22 in /usr/local/lib/python3.12/dist-packages (from kagglehub[hf-datasets,pandas-datasets]) (0.1.23)\n", + "Requirement already satisfied: packaging in /usr/local/lib/python3.12/dist-packages (from kagglehub[hf-datasets,pandas-datasets]) (26.1)\n", + "Requirement already satisfied: pyyaml in /usr/local/lib/python3.12/dist-packages (from kagglehub[hf-datasets,pandas-datasets]) (6.0.3)\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.12/dist-packages (from kagglehub[hf-datasets,pandas-datasets]) (2.32.4)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.12/dist-packages (from kagglehub[hf-datasets,pandas-datasets]) (4.67.3)\n", + "Requirement already satisfied: datasets in /usr/local/lib/python3.12/dist-packages (from kagglehub[hf-datasets,pandas-datasets]) (4.0.0)\n", + "Requirement already satisfied: pandas in /usr/local/lib/python3.12/dist-packages (from kagglehub[hf-datasets,pandas-datasets]) (2.2.2)\n", + "Requirement already satisfied: protobuf in /usr/local/lib/python3.12/dist-packages (from kagglesdk<1.0,>=0.1.22->kagglehub[hf-datasets,pandas-datasets]) (5.29.6)\n", + "Requirement already satisfied: filelock in /usr/local/lib/python3.12/dist-packages (from datasets->kagglehub[hf-datasets,pandas-datasets]) (3.29.0)\n", + "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.12/dist-packages (from datasets->kagglehub[hf-datasets,pandas-datasets]) (2.0.2)\n", + "Requirement already satisfied: pyarrow>=15.0.0 in /usr/local/lib/python3.12/dist-packages (from datasets->kagglehub[hf-datasets,pandas-datasets]) (18.1.0)\n", + "Requirement already satisfied: dill<0.3.9,>=0.3.0 in /usr/local/lib/python3.12/dist-packages (from datasets->kagglehub[hf-datasets,pandas-datasets]) (0.3.8)\n", + "Requirement already satisfied: xxhash in /usr/local/lib/python3.12/dist-packages (from datasets->kagglehub[hf-datasets,pandas-datasets]) (3.6.0)\n", + "Requirement already satisfied: multiprocess<0.70.17 in /usr/local/lib/python3.12/dist-packages (from datasets->kagglehub[hf-datasets,pandas-datasets]) (0.70.16)\n", + "Requirement already satisfied: fsspec<=2025.3.0,>=2023.1.0 in /usr/local/lib/python3.12/dist-packages (from fsspec[http]<=2025.3.0,>=2023.1.0->datasets->kagglehub[hf-datasets,pandas-datasets]) (2025.3.0)\n", + "Requirement already satisfied: huggingface-hub>=0.24.0 in /usr/local/lib/python3.12/dist-packages (from datasets->kagglehub[hf-datasets,pandas-datasets]) (1.11.0)\n", + "Requirement already satisfied: charset_normalizer<4,>=2 in /usr/local/lib/python3.12/dist-packages (from requests->kagglehub[hf-datasets,pandas-datasets]) (3.4.7)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.12/dist-packages (from requests->kagglehub[hf-datasets,pandas-datasets]) (3.13)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.12/dist-packages (from requests->kagglehub[hf-datasets,pandas-datasets]) (2.5.0)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.12/dist-packages (from requests->kagglehub[hf-datasets,pandas-datasets]) (2026.4.22)\n", + "Requirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.12/dist-packages (from pandas->kagglehub[hf-datasets,pandas-datasets]) (2.9.0.post0)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.12/dist-packages (from pandas->kagglehub[hf-datasets,pandas-datasets]) (2025.2)\n", + "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.12/dist-packages (from pandas->kagglehub[hf-datasets,pandas-datasets]) (2026.1)\n", + "Requirement already satisfied: aiohttp!=4.0.0a0,!=4.0.0a1 in /usr/local/lib/python3.12/dist-packages (from fsspec[http]<=2025.3.0,>=2023.1.0->datasets->kagglehub[hf-datasets,pandas-datasets]) (3.13.5)\n", + "Requirement already satisfied: hf-xet<2.0.0,>=1.4.3 in /usr/local/lib/python3.12/dist-packages (from huggingface-hub>=0.24.0->datasets->kagglehub[hf-datasets,pandas-datasets]) (1.4.3)\n", + "Requirement already satisfied: httpx<1,>=0.23.0 in /usr/local/lib/python3.12/dist-packages (from huggingface-hub>=0.24.0->datasets->kagglehub[hf-datasets,pandas-datasets]) (0.28.1)\n", + "Requirement already satisfied: typer in /usr/local/lib/python3.12/dist-packages (from huggingface-hub>=0.24.0->datasets->kagglehub[hf-datasets,pandas-datasets]) (0.24.2)\n", + "Requirement already satisfied: typing-extensions>=4.1.0 in /usr/local/lib/python3.12/dist-packages (from huggingface-hub>=0.24.0->datasets->kagglehub[hf-datasets,pandas-datasets]) (4.15.0)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.12/dist-packages (from python-dateutil>=2.8.2->pandas->kagglehub[hf-datasets,pandas-datasets]) (1.17.0)\n", + "Requirement already satisfied: aiohappyeyeballs>=2.5.0 in /usr/local/lib/python3.12/dist-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<=2025.3.0,>=2023.1.0->datasets->kagglehub[hf-datasets,pandas-datasets]) (2.6.1)\n", + "Requirement already satisfied: aiosignal>=1.4.0 in /usr/local/lib/python3.12/dist-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<=2025.3.0,>=2023.1.0->datasets->kagglehub[hf-datasets,pandas-datasets]) (1.4.0)\n", + "Requirement already satisfied: attrs>=17.3.0 in /usr/local/lib/python3.12/dist-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<=2025.3.0,>=2023.1.0->datasets->kagglehub[hf-datasets,pandas-datasets]) (26.1.0)\n", + "Requirement already satisfied: frozenlist>=1.1.1 in /usr/local/lib/python3.12/dist-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<=2025.3.0,>=2023.1.0->datasets->kagglehub[hf-datasets,pandas-datasets]) (1.8.0)\n", + "Requirement already satisfied: multidict<7.0,>=4.5 in /usr/local/lib/python3.12/dist-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<=2025.3.0,>=2023.1.0->datasets->kagglehub[hf-datasets,pandas-datasets]) (6.7.1)\n", + "Requirement already satisfied: propcache>=0.2.0 in /usr/local/lib/python3.12/dist-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<=2025.3.0,>=2023.1.0->datasets->kagglehub[hf-datasets,pandas-datasets]) (0.4.1)\n", + "Requirement already satisfied: yarl<2.0,>=1.17.0 in /usr/local/lib/python3.12/dist-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]<=2025.3.0,>=2023.1.0->datasets->kagglehub[hf-datasets,pandas-datasets]) (1.23.0)\n", + "Requirement already satisfied: anyio in /usr/local/lib/python3.12/dist-packages (from httpx<1,>=0.23.0->huggingface-hub>=0.24.0->datasets->kagglehub[hf-datasets,pandas-datasets]) (4.13.0)\n", + "Requirement already satisfied: httpcore==1.* in /usr/local/lib/python3.12/dist-packages (from httpx<1,>=0.23.0->huggingface-hub>=0.24.0->datasets->kagglehub[hf-datasets,pandas-datasets]) (1.0.9)\n", + "Requirement already satisfied: h11>=0.16 in /usr/local/lib/python3.12/dist-packages (from httpcore==1.*->httpx<1,>=0.23.0->huggingface-hub>=0.24.0->datasets->kagglehub[hf-datasets,pandas-datasets]) (0.16.0)\n", + "Requirement already satisfied: click>=8.2.1 in /usr/local/lib/python3.12/dist-packages (from typer->huggingface-hub>=0.24.0->datasets->kagglehub[hf-datasets,pandas-datasets]) (8.3.3)\n", + "Requirement already satisfied: shellingham>=1.3.0 in /usr/local/lib/python3.12/dist-packages (from typer->huggingface-hub>=0.24.0->datasets->kagglehub[hf-datasets,pandas-datasets]) (1.5.4)\n", + "Requirement already satisfied: rich>=12.3.0 in /usr/local/lib/python3.12/dist-packages (from typer->huggingface-hub>=0.24.0->datasets->kagglehub[hf-datasets,pandas-datasets]) (13.9.4)\n", + "Requirement already satisfied: annotated-doc>=0.0.2 in /usr/local/lib/python3.12/dist-packages (from typer->huggingface-hub>=0.24.0->datasets->kagglehub[hf-datasets,pandas-datasets]) (0.0.4)\n", + "Requirement already satisfied: markdown-it-py>=2.2.0 in /usr/local/lib/python3.12/dist-packages (from rich>=12.3.0->typer->huggingface-hub>=0.24.0->datasets->kagglehub[hf-datasets,pandas-datasets]) (4.0.0)\n", + "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /usr/local/lib/python3.12/dist-packages (from rich>=12.3.0->typer->huggingface-hub>=0.24.0->datasets->kagglehub[hf-datasets,pandas-datasets]) (2.20.0)\n", + "Requirement already satisfied: mdurl~=0.1 in /usr/local/lib/python3.12/dist-packages (from markdown-it-py>=2.2.0->rich>=12.3.0->typer->huggingface-hub>=0.24.0->datasets->kagglehub[hf-datasets,pandas-datasets]) (0.1.2)\n" + ] + } + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "h6Rh6KODV7UK", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "7ac13a9b-3d7a-44dc-9404-2a667c5fa490" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Using Colab cache for faster access to the 'skin-cancer-mnist-ham10000' dataset.\n", + "Path to dataset files: /kaggle/input/skin-cancer-mnist-ham10000\n" + ] + } + ], + "source": [ + "import kagglehub\n", + "\n", + "# Download latest version\n", + "path = kagglehub.dataset_download(\"kmader/skin-cancer-mnist-ham10000\")\n", + "\n", + "print(\"Path to dataset files:\", path)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jtujXQaBZXdf" + }, + "source": [ + "## 2. Imports and setup" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "RHY5cpmCTLdA" + }, + "outputs": [], + "source": [ + "import os\n", + "import glob\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "\n", + "from PIL import Image\n", + "\n", + "# Source - https://stackoverflow.com/a/53586419\n", + "# Posted by korakot, modified by community. See post 'Timeline' for change history\n", + "# Retrieved 2026-05-21, License - CC BY-SA 4.0\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Loading dataset" + ], + "metadata": { + "id": "wnK2OdNNDSgy" + } + }, + { + "cell_type": "markdown", + "source": [ + "We start loading the CSV dataset into a dataframe.\n", + "\n", + "We check that it contains 10015 samples and each sample is described through the following features:\n", + "* **lesion_id**: Useful for grouping images from the same patient/lesion to avoid data leakage in model training.\n", + "* **image_id**:Used to map to the actual image.\n", + "* **dx**: ground truth label\n", + "* **dx_type**: The method used to confirm the diagnosis.\n", + "* **age**: patient age\n", + "* **sex**: patient sex\n", + "* **localization**: place of the lesion in the body" + ], + "metadata": { + "id": "OwvCrzjj_214" + } + }, + { + "cell_type": "code", + "source": [ + "# Path to your dataset folder\n", + "dataset_path = path\n", + "\n", + "# Metadata file\n", + "metadata_path = os.path.join(dataset_path, \"HAM10000_metadata.csv\")\n", + "\n", + "# Load CSV\n", + "df = pd.read_csv(metadata_path)\n", + "\n", + "print(\"Dataset size:\", len(df))\n", + "\n", + "# Show first rows\n", + "print(df.head())" + ], + "metadata": { + "id": "NWjntXuK_QTW", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "24b34da0-945c-4538-ddc7-85beb885ea94" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Dataset size: 10015\n", + " lesion_id image_id dx dx_type age sex localization\n", + "0 HAM_0000118 ISIC_0027419 bkl histo 80.0 male scalp\n", + "1 HAM_0000118 ISIC_0025030 bkl histo 80.0 male scalp\n", + "2 HAM_0002730 ISIC_0026769 bkl histo 80.0 male scalp\n", + "3 HAM_0002730 ISIC_0025661 bkl histo 80.0 male scalp\n", + "4 HAM_0001466 ISIC_0031633 bkl histo 75.0 male ear\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "We generate a new column with the path of the image that the sample points to. It will be useful later." + ], + "metadata": { + "id": "WbZG98Ia_mPC" + } + }, + { + "cell_type": "code", + "source": [ + "# Collect all image paths\n", + "image_paths = glob.glob(os.path.join(dataset_path, \"**\", \"*.jpg\"), recursive=True)\n", + "\n", + "# Create dictionary:\n", + "# key = image_id\n", + "# value = full image path\n", + "imageid_path_dict = {\n", + " os.path.splitext(os.path.basename(x))[0]: x\n", + " for x in image_paths\n", + "}\n", + "\n", + "# Add image path column\n", + "df['path'] = df['image_id'].map(imageid_path_dict.get)\n", + "\n", + "# Check\n", + "print(df[['image_id', 'path']].head())" + ], + "metadata": { + "id": "WtL3I9UbA9Rj", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "bddc07bb-bc6e-4e9c-8f1c-68f1b1cd45a9" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " image_id path\n", + "0 ISIC_0027419 /kaggle/input/skin-cancer-mnist-ham10000/ham10...\n", + "1 ISIC_0025030 /kaggle/input/skin-cancer-mnist-ham10000/ham10...\n", + "2 ISIC_0026769 /kaggle/input/skin-cancer-mnist-ham10000/ham10...\n", + "3 ISIC_0025661 /kaggle/input/skin-cancer-mnist-ham10000/ham10...\n", + "4 ISIC_0031633 /kaggle/input/skin-cancer-mnist-ham10000/ham10...\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "cyL89qgkZv_j" + }, + "source": [ + "## 3. Dataset analysis" + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Visualize samples" + ], + "metadata": { + "id": "7KRfsuOAB2vc" + } + }, + { + "cell_type": "markdown", + "source": [ + "We visualize some random samples of the dataset, adding on the top the lesion type they belong:" + ], + "metadata": { + "id": "pByvHIJTBglv" + } + }, + { + "cell_type": "code", + "source": [ + "fig, axes = plt.subplots(2, 4, figsize=(10,5))\n", + "\n", + "for i, ax in enumerate(axes.flat):\n", + " sample = df.sample(1).iloc[0]\n", + "\n", + " img = Image.open(sample['path'])\n", + "\n", + " ax.imshow(img)\n", + " ax.set_title(sample['dx'])\n", + " ax.axis('off')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ], + "metadata": { + "id": "eUpg-QIJBp6j", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 462 + }, + "outputId": "d802cde0-6928-483b-f37f-6b2c9d7c8bf2" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Missingness" + ], + "metadata": { + "id": "g0WHPA3JBtpq" + } + }, + { + "cell_type": "markdown", + "source": [ + "The dataset does not have any missing cell:" + ], + "metadata": { + "id": "6_6fAcCfARKQ" + } + }, + { + "cell_type": "code", + "source": [ + "missing = df['path'].isnull().sum()\n", + "\n", + "print(f\"Missing images: {missing}\")" + ], + "metadata": { + "id": "dg94-qVWBJpY", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "e1927988-b5b3-488c-c0be-e634db8300cd" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Missing images: 0\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Class distribution" + ], + "metadata": { + "id": "szLElcMmByrF" + } + }, + { + "cell_type": "markdown", + "source": [ + "If we analyze the distribution of lesion type, we find that there is a clear imbalance. _Melanocytic nevi_ is the most abundant class. " + ], + "metadata": { + "id": "UvuNS-NdAYQk" + } + }, + { + "cell_type": "code", + "source": [ + "plt.figure(figsize=(10,5))\n", + "\n", + "sns.countplot(data=df, x='dx', order=df['dx'].value_counts().index)\n", + "\n", + "plt.title(\"Lesion type distribution\")\n", + "plt.xlabel(\"Lesion type\")\n", + "plt.ylabel(\"Count\")\n", + "plt.show()" + ], + "metadata": { + "id": "Flso1kTuBUDU", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 487 + }, + "outputId": "b7ca5aae-bcc3-4fa5-ec5e-e174111cd76a" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Data distribution" + ], + "metadata": { + "id": "XiSY-1ssgNbw" + } + }, + { + "cell_type": "markdown", + "source": [ + "It is interesting to study the distribution of other features in the dataset, in order to detect outliers.\n", + "\n", + "We start by the age, plotting it in 20 bins. First we find that most abundant age is arround 50 years old (from 40 to 58). One surprise is that we detect zero samples in two bins, which correspond to the ages from 55 to 60 years and 25 to 30 years old. " + ], + "metadata": { + "id": "nETIyHAiCW-L" + } + }, + { + "cell_type": "code", + "source": [ + "plt.figure(figsize=(8,5))\n", + "\n", + "sns.histplot(df['age'].dropna(), bins=20)\n", + "\n", + "plt.title(\"Age Distribution\")\n", + "plt.show()" + ], + "metadata": { + "id": "iU8-PsfhCjCB", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 487 + }, + "outputId": "6518ed87-f557-4b17-83b0-3be2bf61e9bb" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "However, sex distribution is quite balanced. Even so, there are more males than females." + ], + "metadata": { + "id": "rd4qpKtlEiH_" + } + }, + { + "cell_type": "code", + "source": [ + "sns.countplot(data=df, x='sex')\n", + "\n", + "plt.title(\"Sex Distribution\")\n", + "plt.show()" + ], + "metadata": { + "id": "zcxfaNQ-CoX0", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 472 + }, + "outputId": "537f6049-60b5-4c63-8b6d-c59021f397c2" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Lesion localization is not equal probable in all parts of the body. Instead, back and lower extremity are the most common for skin lesions." + ], + "metadata": { + "id": "6cfVmU9dEwdh" + } + }, + { + "cell_type": "code", + "source": [ + "plt.figure(figsize=(12,5))\n", + "\n", + "sns.countplot(\n", + " data=df,\n", + " x='localization',\n", + " order=df['localization'].value_counts().index\n", + ")\n", + "\n", + "plt.xticks(rotation=45)\n", + "plt.title(\"Lesion Localization\")\n", + "plt.show()" + ], + "metadata": { + "id": "Hn9wg0DhCrnX", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 562 + }, + "outputId": "1e09eb67-4bcf-40d7-beec-9b28ed48edbc" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Image sizes" + ], + "metadata": { + "id": "mQNuhV_kgVrh" + } + }, + { + "cell_type": "markdown", + "source": [ + "The size of the images is 600 x 450 pixels." + ], + "metadata": { + "id": "hg6GE4eyFzAC" + } + }, + { + "cell_type": "code", + "source": [ + "sizes = []\n", + "\n", + "for path in df['path'].sample(100):\n", + " img = Image.open(path)\n", + " sizes.append(img.size)\n", + "\n", + "print(pd.Series(sizes).value_counts())" + ], + "metadata": { + "id": "KOcvLjLTgSvz", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "d7877ccc-171e-4a33-d8f7-eaa8fb41f4b3" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(600, 450) 100\n", + "Name: count, dtype: int64\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 2. Prepare dataset" + ], + "metadata": { + "id": "fDVHdawVDHs4" + } + }, + { + "cell_type": "markdown", + "source": [ + "In this section, we process the previous dataframe to make it valid for the model training." + ], + "metadata": { + "id": "uli5clwnF_XO" + } + }, + { + "cell_type": "markdown", + "source": [ + "### Encoding Binary Labels" + ], + "metadata": { + "id": "NT7arLy3e73y" + } + }, + { + "cell_type": "markdown", + "source": [ + "Our goal is to classify between benign and malignant. Then, we should encode the lesion type to a new feature describing both states. This new feature is numerical: 0 means benign and 1, malignant.\n", + "\n", + "| Class | Name | Value |\n", + "|-------|-------------------------------------|-----------|\n", + "| nv | Melanocytic nevi (moles) | Benign |\n", + "| bcc | Basal cell carcinoma | Malignant |\n", + "| bkl | Benign keratosis-like lesions | Benign |\n", + "| df | Dermatofibroma | Benign |\n", + "| vasc | Vascular lesions | Benign |\n", + "| mel | Melanoma | Malignant |\n", + "| akiec | Actinic keratoses / Bowen's disease | Benign |\n" + ], + "metadata": { + "id": "UUZPpEJIGbBr" + } + }, + { + "cell_type": "code", + "source": [ + "# Mapping from dx to benign/malignant\n", + "# 0 --> benign\n", + "# 1 --> malignant\n", + "benign_malignant_dict = {\n", + " 'nv': 0,\n", + " 'bcc': 1,\n", + " 'bkl': 0,\n", + " 'df': 0,\n", + " 'vasc': 0,\n", + " 'mel': 1,\n", + " 'akiec': 0\n", + "}\n", + "\n", + "# Create new column\n", + "df['target'] = df['dx'].map(benign_malignant_dict)\n", + "\n", + "# Preview\n", + "print(df[['dx', 'target']].head())" + ], + "metadata": { + "id": "kbMiT2C1EqDi", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "c53fefbf-7cb3-4224-98ce-d92a8c66a3df" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " dx target\n", + "0 bkl 0\n", + "1 bkl 0\n", + "2 bkl 0\n", + "3 bkl 0\n", + "4 bkl 0\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Dataset split" + ], + "metadata": { + "id": "vlf-og5zet3H" + } + }, + { + "cell_type": "markdown", + "source": [ + "We split the dataset into training (70%) and validation (15%) and test (15%) sets." + ], + "metadata": { + "id": "vSzSAIxfJ37m" + } + }, + { + "cell_type": "code", + "source": [ + "from sklearn.model_selection import train_test_split\n", + "\n", + "train_val_df, test_df = train_test_split(\n", + " df,\n", + " test_size=0.15,\n", + " random_state=42,\n", + " stratify=df['target']\n", + ")\n", + "\n", + "train_df, val_df = train_test_split(\n", + " train_val_df,\n", + " test_size=0.1765, # ≈ 15% of total dataset\n", + " random_state=42,\n", + " stratify=train_val_df['target']\n", + ")\n", + "\n", + "print(\"Train size:\", len(train_df))\n", + "print(\"Validation size:\", len(val_df))\n", + "print(\"Test size:\", len(test_df))" + ], + "metadata": { + "id": "-O8mgD1JdWIc", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "5b36864e-55db-46d3-c71c-5efd362b2d60" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Train size: 7009\n", + "Validation size: 1503\n", + "Test size: 1503\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "We convert to string format the encoded column for ImageDataGenerator." + ], + "metadata": { + "id": "z2twgcoVLabe" + } + }, + { + "cell_type": "code", + "metadata": { + "id": "e33981bd", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "fcad0f9e-c804-4d04-b4e4-ccd2f3401aff" + }, + "source": [ + "# Convert 'target' column to string type for ImageDataGenerator\n", + "train_df['target'] = train_df['target'].astype(str)\n", + "val_df['target'] = val_df['target'].astype(str)\n", + "test_df['target'] = test_df['target'].astype(str)\n", + "\n", + "print(\"Train target dtype after conversion:\", train_df['target'].dtype)\n", + "print(\"Validation target dtype after conversion:\", val_df['target'].dtype)\n", + "print(\"Validation target dtype after conversion:\", test_df['target'].dtype)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Train target dtype after conversion: object\n", + "Validation target dtype after conversion: object\n", + "Validation target dtype after conversion: object\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Class imbalance" + ], + "metadata": { + "id": "pPX8nFnHj0gb" + } + }, + { + "cell_type": "code", + "source": [ + "plt.figure(figsize=(6,3))\n", + "\n", + "sns.countplot(data=train_df, x='target')\n", + "\n", + "plt.title(\"Benign vs Malignant Distribution\")\n", + "plt.xlabel(\"Lesion Type\")\n", + "plt.ylabel(\"Count\")\n", + "plt.show()\n", + "\n", + "print(train_df['target'].value_counts())" + ], + "metadata": { + "id": "6lfCrP9fE_HY", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 404 + }, + "outputId": "a58a17e4-5d0f-4b09-d943-6e9bc7433136" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "target\n", + "0 5870\n", + "1 1139\n", + "Name: count, dtype: int64\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "We decide to handle class imbalanced in the training set through these two approaches:\n", + "* **Class weight**: Instead of treating every sample equally, the model gives more importance to rare classes during training, through weights.\n", + "* **Data augmentation**: create new training samples by modifying existing ones\n", + "\n", + "Oversampling instead is not a recommend approach since it can cause overfitting. No new information is added, and reduces data diversity.\n" + ], + "metadata": { + "id": "dWQ0o2Q-Lp0U" + } + }, + { + "cell_type": "markdown", + "source": [ + "**Class weight**" + ], + "metadata": { + "id": "Xp5cQvTMeqWr" + } + }, + { + "cell_type": "markdown", + "source": [ + "The weight given to malignant samples is 3.0768, whereas benign have a weight of 0.5970." + ], + "metadata": { + "id": "fMoLhtWliBUd" + } + }, + { + "cell_type": "code", + "source": [ + "from sklearn.utils.class_weight import compute_class_weight\n", + "\n", + "classes = np.unique(train_df['target'])\n", + "\n", + "weights = compute_class_weight(\n", + " class_weight='balanced',\n", + " classes=classes,\n", + " y=train_df['target']\n", + ")\n", + "\n", + "class_weights = dict(enumerate(weights))\n", + "\n", + "print(class_weights)" + ], + "metadata": { + "id": "adq7EoEXYdP0", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "1b8e9294-e1e5-4668-83e8-16b63bfd04e7" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "{0: np.float64(0.5970187393526405), 1: np.float64(3.0768217734855137)}\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ax8rlh30ZhOe" + }, + "source": [ + "## 3. Build the model" + ] + }, + { + "cell_type": "code", + "source": [ + "import tensorflow as tf\n", + "from tensorflow.keras import layers, models\n", + "from tensorflow.keras.applications import DenseNet121\n", + "from tensorflow.keras.applications.densenet import preprocess_input\n", + "from tensorflow.keras.layers import Dense, GlobalAveragePooling2D\n", + "from tensorflow.keras.models import Model\n", + "from tensorflow.keras.optimizers import Adam\n", + "\n", + "gpus = tf.config.list_physical_devices('GPU')\n", + "print(\"GPUs:\", gpus)\n", + "\n", + "strategy = tf.distribute.MirroredStrategy()" + ], + "metadata": { + "id": "dU5JiaPn_lnC", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "01bf2f27-8683-49ed-b5a4-ae75dbe56579" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "GPUs: [PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "data_augmentation = tf.keras.Sequential([\n", + " tf.keras.layers.RandomFlip(\"horizontal\"),\n", + " tf.keras.layers.RandomRotation(0.1),\n", + " tf.keras.layers.RandomZoom(0.1),\n", + " tf.keras.layers.RandomContrast(0.1),\n", + "])" + ], + "metadata": { + "id": "NfBIjr-pY2Tp" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "AFJCXBrJUKLR" + }, + "outputs": [], + "source": [ + "base_model = DenseNet121(\n", + " weights='imagenet',\n", + " include_top=False,\n", + " input_shape=(224, 224, 3)\n", + ")\n" + ] + }, + { + "cell_type": "code", + "source": [ + "inputs = tf.keras.Input(shape=(224,224,3))\n", + "\n", + "x = data_augmentation(inputs)" + ], + "metadata": { + "id": "2INO0PpRY4uk" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "22f8d008" + }, + "outputs": [], + "source": [ + "x = base_model(x)\n", + "x = GlobalAveragePooling2D()(x)\n", + "x = Dense(512, activation='relu')(x) # Added another Dense layer\n", + "x = Dense(256, activation='relu')(x) # Existing Dense layer\n", + "predictions = Dense(1, activation='sigmoid')(x) # Output layer for binary classification\n" + ] + }, + { + "cell_type": "code", + "source": [ + "model = Model(inputs=inputs, outputs=predictions)\n", + "model.compile(optimizer=Adam(learning_rate=0.0001), loss='binary_crossentropy', metrics=['accuracy'])\n" + ], + "metadata": { + "id": "od78tkrOgxt9" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5513bd4f" + }, + "source": [ + "## 4. Data Generators\n", + "\n", + "A generator is an object that produces batches of data on the fly instead of loading the entire dataset into memory at once. Using it, images are loaded only when needed, memory efficient and it can apply real-time augmentation.\n", + "\n", + "We prepare data generators for training and validation. The training generator will include data augmentation and preprocessing, while the validation generator will only preprocess the images." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "f3469edf", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "f1f3a5d9-ecb5-42b6-8c9c-3131bcd06800" + }, + "source": [ + "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n", + "\n", + "# Image dimensions\n", + "IMG_WIDTH = 224\n", + "IMG_HEIGHT = 224\n", + "\n", + "# Data generators\n", + "train_datagen = ImageDataGenerator(\n", + " preprocessing_function=preprocess_input,\n", + " rotation_range=20,\n", + " width_shift_range=0.2,\n", + " height_shift_range=0.2,\n", + " shear_range=0.2,\n", + " zoom_range=0.2,\n", + " horizontal_flip=True,\n", + " fill_mode='nearest'\n", + ")\n", + "\n", + "val_datagen = ImageDataGenerator(preprocessing_function=preprocess_input)\n", + "\n", + "# Flow from dataframe\n", + "train_generator = train_datagen.flow_from_dataframe(\n", + " dataframe=train_df,\n", + " x_col='path',\n", + " y_col='target',\n", + " target_size=(IMG_WIDTH, IMG_HEIGHT),\n", + " batch_size=32,\n", + " class_mode='binary',\n", + " seed=42\n", + ")\n", + "\n", + "val_generator = val_datagen.flow_from_dataframe(\n", + " dataframe=val_df,\n", + " x_col='path',\n", + " y_col='target',\n", + " target_size=(IMG_WIDTH, IMG_HEIGHT),\n", + " batch_size=32,\n", + " class_mode='binary',\n", + " seed=42\n", + ")" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Found 7009 validated image filenames belonging to 2 classes.\n", + "Found 1503 validated image filenames belonging to 2 classes.\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "09bea580" + }, + "source": [ + "Now, the `train_generator` will use the `train_df_balanced` DataFrame, which has an equal number of samples for both classes. This will help the model learn more effectively from the minority class during training." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "93ce6220" + }, + "source": [ + "## 6. Train the Model" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "5f844e65", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "outputId": "d2f948d2-e338-4c76-bb06-4d6090cab710" + }, + "source": [ + "from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint\n", + "\n", + "model_checkpoint = ModelCheckpoint(\n", + " 'best_model.keras',\n", + " monitor='val_accuracy',\n", + " save_best_only=True,\n", + " mode='max'\n", + ")\n", + "\n", + "# Train the model\n", + "history = model.fit(\n", + " train_generator,\n", + " epochs=50, # You can adjust the number of epochs\n", + " validation_data=val_generator,\n", + " callbacks=[model_checkpoint],\n", + " class_weight=class_weights # Use class weights to handle imbalance\n", + ")" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch 1/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m525s\u001b[0m 2s/step - accuracy: 0.7313 - loss: 0.4634 - val_accuracy: 0.7372 - val_loss: 0.5296\n", + "Epoch 2/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m166s\u001b[0m 753ms/step - accuracy: 0.7928 - loss: 0.3819 - val_accuracy: 0.7804 - val_loss: 0.4100\n", + "Epoch 3/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m166s\u001b[0m 755ms/step - accuracy: 0.8194 - loss: 0.3497 - val_accuracy: 0.8004 - val_loss: 0.4216\n", + "Epoch 4/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m168s\u001b[0m 764ms/step - accuracy: 0.8469 - loss: 0.3085 - val_accuracy: 0.7472 - val_loss: 0.5446\n", + "Epoch 5/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m169s\u001b[0m 764ms/step - accuracy: 0.8615 - loss: 0.2679 - val_accuracy: 0.7771 - val_loss: 0.5161\n", + "Epoch 6/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m164s\u001b[0m 743ms/step - accuracy: 0.8836 - loss: 0.2436 - val_accuracy: 0.8636 - val_loss: 0.3152\n", + "Epoch 7/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m164s\u001b[0m 746ms/step - accuracy: 0.8910 - loss: 0.2330 - val_accuracy: 0.7472 - val_loss: 0.6882\n", + "Epoch 8/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m164s\u001b[0m 744ms/step - accuracy: 0.9075 - loss: 0.1984 - val_accuracy: 0.8190 - val_loss: 0.4743\n", + "Epoch 9/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m164s\u001b[0m 745ms/step - accuracy: 0.9211 - loss: 0.1750 - val_accuracy: 0.9035 - val_loss: 0.3004\n", + "Epoch 10/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m164s\u001b[0m 742ms/step - accuracy: 0.9230 - loss: 0.1676 - val_accuracy: 0.8949 - val_loss: 0.2669\n", + "Epoch 11/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m168s\u001b[0m 759ms/step - accuracy: 0.9230 - loss: 0.1686 - val_accuracy: 0.8343 - val_loss: 0.5307\n", + "Epoch 12/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m168s\u001b[0m 761ms/step - accuracy: 0.9364 - loss: 0.1487 - val_accuracy: 0.8776 - val_loss: 0.3707\n", + "Epoch 13/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m173s\u001b[0m 787ms/step - accuracy: 0.9476 - loss: 0.1296 - val_accuracy: 0.8523 - val_loss: 0.4313\n", + "Epoch 14/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m171s\u001b[0m 777ms/step - accuracy: 0.9472 - loss: 0.1219 - val_accuracy: 0.8942 - val_loss: 0.3352\n", + "Epoch 15/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m189s\u001b[0m 861ms/step - accuracy: 0.9488 - loss: 0.1217 - val_accuracy: 0.7485 - val_loss: 0.8448\n", + "Epoch 16/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m164s\u001b[0m 745ms/step - accuracy: 0.9558 - loss: 0.1107 - val_accuracy: 0.8935 - val_loss: 0.3193\n", + "Epoch 17/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m163s\u001b[0m 742ms/step - accuracy: 0.9458 - loss: 0.1203 - val_accuracy: 0.8403 - val_loss: 0.5218\n", + "Epoch 18/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m161s\u001b[0m 731ms/step - accuracy: 0.9645 - loss: 0.0843 - val_accuracy: 0.8856 - val_loss: 0.4018\n", + "Epoch 19/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m167s\u001b[0m 757ms/step - accuracy: 0.9612 - loss: 0.0952 - val_accuracy: 0.8130 - val_loss: 0.5638\n", + "Epoch 20/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m169s\u001b[0m 767ms/step - accuracy: 0.9571 - loss: 0.0982 - val_accuracy: 0.8975 - val_loss: 0.3157\n", + "Epoch 21/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m187s\u001b[0m 848ms/step - accuracy: 0.9690 - loss: 0.0690 - val_accuracy: 0.8849 - val_loss: 0.3929\n", + "Epoch 22/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m166s\u001b[0m 756ms/step - accuracy: 0.9505 - loss: 0.1069 - val_accuracy: 0.8776 - val_loss: 0.3631\n", + "Epoch 23/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m166s\u001b[0m 754ms/step - accuracy: 0.9698 - loss: 0.0762 - val_accuracy: 0.8184 - val_loss: 0.6864\n", + "Epoch 24/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m166s\u001b[0m 752ms/step - accuracy: 0.9626 - loss: 0.0918 - val_accuracy: 0.8363 - val_loss: 0.5701\n", + "Epoch 25/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m168s\u001b[0m 763ms/step - accuracy: 0.9653 - loss: 0.0858 - val_accuracy: 0.8955 - val_loss: 0.3504\n", + "Epoch 26/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m168s\u001b[0m 761ms/step - accuracy: 0.9752 - loss: 0.0587 - val_accuracy: 0.8683 - val_loss: 0.4771\n", + "Epoch 27/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m168s\u001b[0m 761ms/step - accuracy: 0.9770 - loss: 0.0566 - val_accuracy: 0.8656 - val_loss: 0.5186\n", + "Epoch 28/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m171s\u001b[0m 779ms/step - accuracy: 0.9635 - loss: 0.0878 - val_accuracy: 0.9062 - val_loss: 0.3422\n", + "Epoch 29/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m168s\u001b[0m 761ms/step - accuracy: 0.9628 - loss: 0.0841 - val_accuracy: 0.8729 - val_loss: 0.4225\n", + "Epoch 30/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m167s\u001b[0m 760ms/step - accuracy: 0.9756 - loss: 0.0610 - val_accuracy: 0.8962 - val_loss: 0.4215\n", + "Epoch 31/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m174s\u001b[0m 789ms/step - accuracy: 0.9710 - loss: 0.0730 - val_accuracy: 0.8862 - val_loss: 0.3870\n", + "Epoch 32/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m183s\u001b[0m 832ms/step - accuracy: 0.9793 - loss: 0.0493 - val_accuracy: 0.8516 - val_loss: 0.5601\n", + "Epoch 33/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m186s\u001b[0m 841ms/step - accuracy: 0.9737 - loss: 0.0648 - val_accuracy: 0.8849 - val_loss: 0.3639\n", + "Epoch 34/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m203s\u001b[0m 922ms/step - accuracy: 0.9730 - loss: 0.0601 - val_accuracy: 0.8723 - val_loss: 0.4141\n", + "Epoch 35/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m198s\u001b[0m 896ms/step - accuracy: 0.9723 - loss: 0.0643 - val_accuracy: 0.8297 - val_loss: 0.6577\n", + "Epoch 36/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m181s\u001b[0m 822ms/step - accuracy: 0.9777 - loss: 0.0591 - val_accuracy: 0.8762 - val_loss: 0.4413\n", + "Epoch 37/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m201s\u001b[0m 913ms/step - accuracy: 0.9767 - loss: 0.0544 - val_accuracy: 0.9022 - val_loss: 0.4006\n", + "Epoch 38/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m207s\u001b[0m 936ms/step - accuracy: 0.9790 - loss: 0.0535 - val_accuracy: 0.9062 - val_loss: 0.3729\n", + "Epoch 39/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m201s\u001b[0m 912ms/step - accuracy: 0.9789 - loss: 0.0575 - val_accuracy: 0.7931 - val_loss: 0.7725\n", + "Epoch 40/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m173s\u001b[0m 787ms/step - accuracy: 0.9756 - loss: 0.0579 - val_accuracy: 0.8975 - val_loss: 0.3903\n", + "Epoch 41/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m187s\u001b[0m 848ms/step - accuracy: 0.9735 - loss: 0.0659 - val_accuracy: 0.8909 - val_loss: 0.4530\n", + "Epoch 42/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m196s\u001b[0m 890ms/step - accuracy: 0.9787 - loss: 0.0550 - val_accuracy: 0.8669 - val_loss: 0.4896\n", + "Epoch 43/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m192s\u001b[0m 874ms/step - accuracy: 0.9783 - loss: 0.0554 - val_accuracy: 0.8550 - val_loss: 0.5571\n", + "Epoch 44/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m183s\u001b[0m 830ms/step - accuracy: 0.9854 - loss: 0.0387 - val_accuracy: 0.9035 - val_loss: 0.3733\n", + "Epoch 45/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m193s\u001b[0m 879ms/step - accuracy: 0.9910 - loss: 0.0219 - val_accuracy: 0.8589 - val_loss: 0.6696\n", + "Epoch 46/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m168s\u001b[0m 763ms/step - accuracy: 0.9776 - loss: 0.0649 - val_accuracy: 0.8417 - val_loss: 0.6706\n", + "Epoch 47/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m171s\u001b[0m 778ms/step - accuracy: 0.9806 - loss: 0.0533 - val_accuracy: 0.8609 - val_loss: 0.5179\n", + "Epoch 48/50\n", + "\u001b[1m220/220\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m199s\u001b[0m 904ms/step - accuracy: 0.9887 - loss: 0.0326 - val_accuracy: 0.8942 - val_loss: 0.4350\n", + "Epoch 49/50\n", + "\u001b[1m 12/220\u001b[0m \u001b[32m━\u001b[0m\u001b[37m━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m2:11\u001b[0m 635ms/step - accuracy: 0.9966 - loss: 0.0123" + ] + }, + { + "output_type": "error", + "ename": "KeyboardInterrupt", + "evalue": "", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_3419/1286130936.py\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[0;31m# Train the model\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m history = model.fit(\n\u001b[0m\u001b[1;32m 12\u001b[0m \u001b[0mtrain_generator\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 13\u001b[0m \u001b[0mepochs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m50\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;31m# You can adjust the number of epochs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/keras/src/utils/traceback_utils.py\u001b[0m in \u001b[0;36merror_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 115\u001b[0m \u001b[0mfiltered_tb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 116\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 117\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 118\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 119\u001b[0m \u001b[0mfiltered_tb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_process_traceback_frames\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__traceback__\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/keras/src/backend/tensorflow/trainer.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, x, y, batch_size, epochs, verbose, callbacks, validation_split, validation_data, shuffle, class_weight, sample_weight, initial_epoch, steps_per_epoch, validation_steps, validation_batch_size, validation_freq)\u001b[0m\n\u001b[1;32m 397\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mbegin_step\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mend_step\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0miterator\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mepoch_iterator\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 398\u001b[0m \u001b[0mcallbacks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mon_train_batch_begin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbegin_step\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 399\u001b[0;31m \u001b[0mlogs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrain_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0miterator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 400\u001b[0m \u001b[0mcallbacks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mon_train_batch_end\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mend_step\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlogs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 401\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstop_training\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/keras/src/backend/tensorflow/trainer.py\u001b[0m in \u001b[0;36mfunction\u001b[0;34m(iterator)\u001b[0m\n\u001b[1;32m 239\u001b[0m \u001b[0miterator\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mIterator\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdistribute\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mDistributedIterator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 240\u001b[0m ):\n\u001b[0;32m--> 241\u001b[0;31m \u001b[0mopt_outputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmulti_step_on_iterator\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0miterator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 242\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mopt_outputs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhas_value\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 243\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mStopIteration\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/tensorflow/python/util/traceback_utils.py\u001b[0m in \u001b[0;36merror_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 148\u001b[0m \u001b[0mfiltered_tb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 149\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 150\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 151\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 152\u001b[0m \u001b[0mfiltered_tb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_process_traceback_frames\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__traceback__\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/tensorflow/python/eager/polymorphic_function/polymorphic_function.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m 831\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 832\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mOptionalXlaContext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_jit_compile\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 833\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 834\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 835\u001b[0m \u001b[0mnew_tracing_count\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexperimental_get_tracing_count\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/tensorflow/python/eager/polymorphic_function/polymorphic_function.py\u001b[0m in \u001b[0;36m_call\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m 876\u001b[0m \u001b[0;31m# In this case we have not created variables on the first call. So we can\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 877\u001b[0m \u001b[0;31m# run the first trace but we should fail if variables are created.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 878\u001b[0;31m results = tracing_compilation.call_function(\n\u001b[0m\u001b[1;32m 879\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwds\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_variable_creation_config\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 880\u001b[0m )\n", + "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/tensorflow/python/eager/polymorphic_function/tracing_compilation.py\u001b[0m in \u001b[0;36mcall_function\u001b[0;34m(args, kwargs, tracing_options)\u001b[0m\n\u001b[1;32m 137\u001b[0m \u001b[0mbound_args\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfunction\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfunction_type\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 138\u001b[0m \u001b[0mflat_inputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfunction\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfunction_type\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munpack_inputs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbound_args\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 139\u001b[0;31m return function._call_flat( # pylint: disable=protected-access\n\u001b[0m\u001b[1;32m 140\u001b[0m \u001b[0mflat_inputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcaptured_inputs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfunction\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcaptured_inputs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 141\u001b[0m )\n", + "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/tensorflow/python/eager/polymorphic_function/concrete_function.py\u001b[0m in \u001b[0;36m_call_flat\u001b[0;34m(self, tensor_inputs, captured_inputs)\u001b[0m\n\u001b[1;32m 1320\u001b[0m and executing_eagerly):\n\u001b[1;32m 1321\u001b[0m \u001b[0;31m# No tape is watching; skip to running the function.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1322\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_inference_function\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_preflattened\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1323\u001b[0m forward_backward = self._select_forward_and_backward_functions(\n\u001b[1;32m 1324\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/tensorflow/python/eager/polymorphic_function/atomic_function.py\u001b[0m in \u001b[0;36mcall_preflattened\u001b[0;34m(self, args)\u001b[0m\n\u001b[1;32m 214\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mcall_preflattened\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mSequence\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTensor\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mAny\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 215\u001b[0m \u001b[0;34m\"\"\"Calls with flattened tensor inputs and returns the structured output.\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 216\u001b[0;31m \u001b[0mflat_outputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_flat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 217\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfunction_type\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpack_output\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mflat_outputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 218\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/tensorflow/python/eager/polymorphic_function/atomic_function.py\u001b[0m in \u001b[0;36mcall_flat\u001b[0;34m(self, *args)\u001b[0m\n\u001b[1;32m 249\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mrecord\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstop_recording\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 250\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_bound_context\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexecuting_eagerly\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 251\u001b[0;31m outputs = self._bound_context.call_function(\n\u001b[0m\u001b[1;32m 252\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 253\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/tensorflow/python/eager/context.py\u001b[0m in \u001b[0;36mcall_function\u001b[0;34m(self, name, tensor_inputs, num_outputs)\u001b[0m\n\u001b[1;32m 1686\u001b[0m \u001b[0mcancellation_context\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcancellation\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcontext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1687\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mcancellation_context\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1688\u001b[0;31m outputs = execute.execute(\n\u001b[0m\u001b[1;32m 1689\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdecode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"utf-8\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1690\u001b[0m \u001b[0mnum_outputs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnum_outputs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/tensorflow/python/eager/execute.py\u001b[0m in \u001b[0;36mquick_execute\u001b[0;34m(op_name, num_outputs, inputs, attrs, ctx, name)\u001b[0m\n\u001b[1;32m 51\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 52\u001b[0m \u001b[0mctx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mensure_initialized\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 53\u001b[0;31m tensors = pywrap_tfe.TFE_Py_Execute(ctx._handle, device_name, op_name,\n\u001b[0m\u001b[1;32m 54\u001b[0m inputs, attrs, num_outputs)\n\u001b[1;32m 55\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_NotOkStatusException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UZxgXYAnZ_nU" + }, + "source": [ + "## 7. Evaluation" + ] + }, + { + "cell_type": "markdown", + "source": [ + "In this section we are going to evaluate the best model achieved during training. The model will be evaluated using the following metrics:\n", + "\n", + "* Accuracy\n", + "* Precision\n", + "* Recall\n", + "* F1-score\n", + "* ROC-AUC\n", + "\n", + "Particular attention will be\n", + "given to recall, since false negatives in cancer detection may have severe\n", + "clinical consequences.\n", + "\n", + "F1-score will give us a description of the balance between both\n", + "precision and recall, whereas ROC-AUC, diagnostic discrimination ability." + ], + "metadata": { + "id": "rh1RPq1cYG_t" + } + }, + { + "cell_type": "markdown", + "source": [ + "### Test generator" + ], + "metadata": { + "id": "7oLDY4ttZscd" + } + }, + { + "cell_type": "markdown", + "source": [ + "The test generator has the `shuffle` set to `False`, compared to the other two generators." + ], + "metadata": { + "id": "GG_kEE3EbIpE" + } + }, + { + "cell_type": "code", + "source": [ + "IMG_WIDTH = 224\n", + "IMG_HEIGHT = 224\n", + "\n", + "test_datagen = ImageDataGenerator(\n", + " preprocessing_function=preprocess_input\n", + ")\n", + "\n", + "test_generator = test_datagen.flow_from_dataframe(\n", + " dataframe=test_df,\n", + " x_col='path',\n", + " y_col='target',\n", + " target_size=(IMG_WIDTH, IMG_HEIGHT),\n", + " batch_size=32,\n", + " class_mode='binary',\n", + " shuffle=False\n", + ")" + ], + "metadata": { + "id": "not0FEkGQRZx", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "2ca37f39-8277-4cc1-80ca-7d30e91d5cdc" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Found 1503 validated image filenames belonging to 2 classes.\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "14157876" + }, + "source": [ + "### Load best model" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "482b5187", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "outputId": "64e0ed8f-beb2-4b23-855c-73d6a5b9b881" + }, + "source": [ + "from tensorflow.keras.models import load_model\n", + "\n", + "best_model = load_model('/content/best_model.keras')" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "error", + "ename": "TypeError", + "evalue": " could not be deserialized properly. Please ensure that components that are Python object instances (layers, models, etc.) returned by `get_config()` are explicitly deserialized in the model's `from_config()` method.\n\nconfig={'module': 'keras.src.models.functional', 'class_name': 'Functional', 'config': {}, 'registered_name': 'Functional', 'build_config': {'input_shape': None}, 'compile_config': {'optimizer': {'module': 'keras.optimizers', 'class_name': 'Adam', 'config': {'name': 'adam', 'learning_rate': 9.999999747378752e-05, 'weight_decay': None, 'clipnorm': None, 'global_clipnorm': None, 'clipvalue': None, 'use_ema': False, 'ema_momentum': 0.99, 'ema_overwrite_frequency': None, 'loss_scale_factor': None, 'gradient_accumulation_steps': None, 'beta_1': 0.9, 'beta_2': 0.999, 'epsilon': 1e-07, 'amsgrad': False}, 'registered_name': None}, 'loss': 'binary_crossentropy', 'loss_weights': None, 'metrics': ['accuracy'], 'weighted_metrics': None, 'run_eagerly': False, 'steps_per_execution': 1, 'jit_compile': False}}.\n\nException encountered: could not be deserialized properly. Please ensure that components that are Python object instances (layers, models, etc.) returned by `get_config()` are explicitly deserialized in the model's `from_config()` method.\n\nconfig={'module': 'keras.src.models.functional', 'class_name': 'Functional', 'config': {}, 'registered_name': 'Functional', 'build_config': {'input_shape': None}, 'compile_config': {}, 'name': 'densenet121', 'inbound_nodes': [{'args': [{'class_name': '__keras_tensor__', 'config': {'shape': [None, 224, 224, 3], 'dtype': 'float32', 'keras_history': ['sequential', 0, 0]}}], 'kwargs': {'mask': None}}]}.\n\nException encountered: could not be deserialized properly. Please ensure that components that are Python object instances (layers, models, etc.) returned by `get_config()` are explicitly deserialized in the model's `from_config()` method.\n\nconfig={'module': 'keras.layers', 'class_name': 'BatchNormalization', 'config': {'name': 'conv1_bn', 'trainable': True, 'dtype': {'module': 'keras', 'class_name': 'DTypePolicy', 'config': {'name': 'float32'}, 'registered_name': None, 'shared_object_id': 131549112122784}, 'axis': 3, 'momentum': 0.99, 'epsilon': 1.001e-05, 'center': True, 'scale': True, 'beta_initializer': {'module': 'keras.initializers', 'class_name': 'Zeros', 'config': {}, 'registered_name': None}, 'gamma_initializer': {'module': 'keras.initializers', 'class_name': 'Ones', 'config': {}, 'registered_name': None}, 'moving_mean_initializer': {'module': 'keras.initializers', 'class_name': 'Zeros', 'config': {}, 'registered_name': None}, 'moving_variance_initializer': {'module': 'keras.initializers', 'class_name': 'Ones', 'config': {}, 'registered_name': None}, 'beta_regularizer': None, 'gamma_regularizer': None, 'beta_constraint': None, 'gamma_constraint': None, 'synchronized': False, 'renorm': False, 'renorm_clipping': None, 'renorm_momentum': 0.99}, 'registered_name': None, 'build_config': {'input_shape': [None, 112, 112, 64]}, 'name': 'conv1_bn', 'inbound_nodes': [{'args': [{'class_name': '__keras_tensor__', 'config': {'shape': [None, 112, 112, 64], 'dtype': 'float32', 'keras_history': ['conv1_conv', 0, 0]}}], 'kwargs': {'mask': None}}]}.\n\nException encountered: Error when deserializing class 'BatchNormalization' using config={'name': 'conv1_bn', 'trainable': True, 'dtype': 'float32', 'axis': 3, 'momentum': 0.99, 'epsilon': 1.001e-05, 'center': True, 'scale': True, 'beta_initializer': {'module': 'keras.initializers', 'class_name': 'Zeros', 'config': {}, 'registered_name': None}, 'gamma_initializer': {'module': 'keras.initializers', 'class_name': 'Ones', 'config': {}, 'registered_name': None}, 'moving_mean_initializer': {'module': 'keras.initializers', 'class_name': 'Zeros', 'config': {}, 'registered_name': None}, 'moving_variance_initializer': {'module': 'keras.initializers', 'class_name': 'Ones', 'config': {}, 'registered_name': None}, 'beta_regularizer': None, 'gamma_regularizer': None, 'beta_constraint': None, 'gamma_constraint': None, 'synchronized': False, 'renorm': False, 'renorm_clipping': None, 'renorm_momentum': 0.99}.\n\nException encountered: Unrecognized keyword arguments passed to BatchNormalization: {'renorm': False, 'renorm_clipping': None, 'renorm_momentum': 0.99}", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/keras/src/ops/operation.py\u001b[0m in \u001b[0;36mfrom_config\u001b[0;34m(cls, config)\u001b[0m\n\u001b[1;32m 316\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 317\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mcls\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 318\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/keras/src/layers/normalization/batch_normalization.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, axis, momentum, epsilon, center, scale, beta_initializer, gamma_initializer, moving_mean_initializer, moving_variance_initializer, beta_regularizer, gamma_regularizer, beta_constraint, gamma_constraint, synchronized, **kwargs)\u001b[0m\n\u001b[1;32m 141\u001b[0m ):\n\u001b[0;32m--> 142\u001b[0;31m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 143\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maxis\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/keras/src/layers/layer.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, activity_regularizer, trainable, dtype, autocast, name, **kwargs)\u001b[0m\n\u001b[1;32m 293\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 294\u001b[0;31m raise ValueError(\n\u001b[0m\u001b[1;32m 295\u001b[0m \u001b[0;34m\"Unrecognized keyword arguments \"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: Unrecognized keyword arguments passed to BatchNormalization: {'renorm': False, 'renorm_clipping': None, 'renorm_momentum': 0.99}", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/keras/src/saving/serialization_lib.py\u001b[0m in \u001b[0;36mdeserialize_keras_object\u001b[0;34m(config, custom_objects, safe_mode, **kwargs)\u001b[0m\n\u001b[1;32m 732\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 733\u001b[0;31m \u001b[0minstance\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcls\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfrom_config\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minner_config\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 734\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mTypeError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/keras/src/ops/operation.py\u001b[0m in \u001b[0;36mfrom_config\u001b[0;34m(cls, config)\u001b[0m\n\u001b[1;32m 318\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 319\u001b[0;31m raise TypeError(\n\u001b[0m\u001b[1;32m 320\u001b[0m \u001b[0;34mf\"Error when deserializing class '{cls.__name__}' using \"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mTypeError\u001b[0m: Error when deserializing class 'BatchNormalization' using config={'name': 'conv1_bn', 'trainable': True, 'dtype': 'float32', 'axis': 3, 'momentum': 0.99, 'epsilon': 1.001e-05, 'center': True, 'scale': True, 'beta_initializer': {'module': 'keras.initializers', 'class_name': 'Zeros', 'config': {}, 'registered_name': None}, 'gamma_initializer': {'module': 'keras.initializers', 'class_name': 'Ones', 'config': {}, 'registered_name': None}, 'moving_mean_initializer': {'module': 'keras.initializers', 'class_name': 'Zeros', 'config': {}, 'registered_name': None}, 'moving_variance_initializer': {'module': 'keras.initializers', 'class_name': 'Ones', 'config': {}, 'registered_name': None}, 'beta_regularizer': None, 'gamma_regularizer': None, 'beta_constraint': None, 'gamma_constraint': None, 'synchronized': False, 'renorm': False, 'renorm_clipping': None, 'renorm_momentum': 0.99}.\n\nException encountered: Unrecognized keyword arguments passed to BatchNormalization: {'renorm': False, 'renorm_clipping': None, 'renorm_momentum': 0.99}", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/keras/src/saving/serialization_lib.py\u001b[0m in \u001b[0;36mdeserialize_keras_object\u001b[0;34m(config, custom_objects, safe_mode, **kwargs)\u001b[0m\n\u001b[1;32m 732\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 733\u001b[0;31m \u001b[0minstance\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcls\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfrom_config\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minner_config\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 734\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mTypeError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/keras/src/models/model.py\u001b[0m in \u001b[0;36mfrom_config\u001b[0;34m(cls, config, custom_objects)\u001b[0m\n\u001b[1;32m 822\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 823\u001b[0;31m return functional_from_config(\n\u001b[0m\u001b[1;32m 824\u001b[0m \u001b[0mcls\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconfig\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcustom_objects\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcustom_objects\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/keras/src/models/functional.py\u001b[0m in \u001b[0;36mfunctional_from_config\u001b[0;34m(cls, config, custom_objects)\u001b[0m\n\u001b[1;32m 560\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mlayer_data\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mfunctional_config\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"layers\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 561\u001b[0;31m \u001b[0mprocess_layer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlayer_data\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 562\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/keras/src/models/functional.py\u001b[0m in \u001b[0;36mprocess_layer\u001b[0;34m(layer_data)\u001b[0m\n\u001b[1;32m 527\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 528\u001b[0;31m layer = serialization_lib.deserialize_keras_object(\n\u001b[0m\u001b[1;32m 529\u001b[0m \u001b[0mlayer_data\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcustom_objects\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcustom_objects\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/keras/src/saving/serialization_lib.py\u001b[0m in \u001b[0;36mdeserialize_keras_object\u001b[0;34m(config, custom_objects, safe_mode, **kwargs)\u001b[0m\n\u001b[1;32m 734\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mTypeError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 735\u001b[0;31m raise TypeError(\n\u001b[0m\u001b[1;32m 736\u001b[0m \u001b[0;34mf\"{cls} could not be deserialized properly. Please\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mTypeError\u001b[0m: could not be deserialized properly. Please ensure that components that are Python object instances (layers, models, etc.) returned by `get_config()` are explicitly deserialized in the model's `from_config()` method.\n\nconfig={'module': 'keras.layers', 'class_name': 'BatchNormalization', 'config': {'name': 'conv1_bn', 'trainable': True, 'dtype': {'module': 'keras', 'class_name': 'DTypePolicy', 'config': {'name': 'float32'}, 'registered_name': None, 'shared_object_id': 131549112122784}, 'axis': 3, 'momentum': 0.99, 'epsilon': 1.001e-05, 'center': True, 'scale': True, 'beta_initializer': {'module': 'keras.initializers', 'class_name': 'Zeros', 'config': {}, 'registered_name': None}, 'gamma_initializer': {'module': 'keras.initializers', 'class_name': 'Ones', 'config': {}, 'registered_name': None}, 'moving_mean_initializer': {'module': 'keras.initializers', 'class_name': 'Zeros', 'config': {}, 'registered_name': None}, 'moving_variance_initializer': {'module': 'keras.initializers', 'class_name': 'Ones', 'config': {}, 'registered_name': None}, 'beta_regularizer': None, 'gamma_regularizer': None, 'beta_constraint': None, 'gamma_constraint': None, 'synchronized': False, 'renorm': False, 'renorm_clipping': None, 'renorm_momentum': 0.99}, 'registered_name': None, 'build_config': {'input_shape': [None, 112, 112, 64]}, 'name': 'conv1_bn', 'inbound_nodes': [{'args': [{'class_name': '__keras_tensor__', 'config': {'shape': [None, 112, 112, 64], 'dtype': 'float32', 'keras_history': ['conv1_conv', 0, 0]}}], 'kwargs': {'mask': None}}]}.\n\nException encountered: Error when deserializing class 'BatchNormalization' using config={'name': 'conv1_bn', 'trainable': True, 'dtype': 'float32', 'axis': 3, 'momentum': 0.99, 'epsilon': 1.001e-05, 'center': True, 'scale': True, 'beta_initializer': {'module': 'keras.initializers', 'class_name': 'Zeros', 'config': {}, 'registered_name': None}, 'gamma_initializer': {'module': 'keras.initializers', 'class_name': 'Ones', 'config': {}, 'registered_name': None}, 'moving_mean_initializer': {'module': 'keras.initializers', 'class_name': 'Zeros', 'config': {}, 'registered_name': None}, 'moving_variance_initializer': {'module': 'keras.initializers', 'class_name': 'Ones', 'config': {}, 'registered_name': None}, 'beta_regularizer': None, 'gamma_regularizer': None, 'beta_constraint': None, 'gamma_constraint': None, 'synchronized': False, 'renorm': False, 'renorm_clipping': None, 'renorm_momentum': 0.99}.\n\nException encountered: Unrecognized keyword arguments passed to BatchNormalization: {'renorm': False, 'renorm_clipping': None, 'renorm_momentum': 0.99}", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/keras/src/saving/serialization_lib.py\u001b[0m in \u001b[0;36mdeserialize_keras_object\u001b[0;34m(config, custom_objects, safe_mode, **kwargs)\u001b[0m\n\u001b[1;32m 732\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 733\u001b[0;31m \u001b[0minstance\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcls\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfrom_config\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minner_config\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 734\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mTypeError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/keras/src/models/model.py\u001b[0m in \u001b[0;36mfrom_config\u001b[0;34m(cls, config, custom_objects)\u001b[0m\n\u001b[1;32m 822\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 823\u001b[0;31m return functional_from_config(\n\u001b[0m\u001b[1;32m 824\u001b[0m \u001b[0mcls\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconfig\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcustom_objects\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcustom_objects\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/keras/src/models/functional.py\u001b[0m in \u001b[0;36mfunctional_from_config\u001b[0;34m(cls, config, custom_objects)\u001b[0m\n\u001b[1;32m 560\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mlayer_data\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mfunctional_config\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"layers\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 561\u001b[0;31m \u001b[0mprocess_layer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlayer_data\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 562\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/keras/src/models/functional.py\u001b[0m in \u001b[0;36mprocess_layer\u001b[0;34m(layer_data)\u001b[0m\n\u001b[1;32m 527\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 528\u001b[0;31m layer = serialization_lib.deserialize_keras_object(\n\u001b[0m\u001b[1;32m 529\u001b[0m \u001b[0mlayer_data\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcustom_objects\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcustom_objects\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/keras/src/saving/serialization_lib.py\u001b[0m in \u001b[0;36mdeserialize_keras_object\u001b[0;34m(config, custom_objects, safe_mode, **kwargs)\u001b[0m\n\u001b[1;32m 734\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mTypeError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 735\u001b[0;31m raise TypeError(\n\u001b[0m\u001b[1;32m 736\u001b[0m \u001b[0;34mf\"{cls} could not be deserialized properly. Please\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mTypeError\u001b[0m: could not be deserialized properly. Please ensure that components that are Python object instances (layers, models, etc.) returned by `get_config()` are explicitly deserialized in the model's `from_config()` method.\n\nconfig={'module': 'keras.src.models.functional', 'class_name': 'Functional', 'config': {}, 'registered_name': 'Functional', 'build_config': {'input_shape': None}, 'compile_config': {}, 'name': 'densenet121', 'inbound_nodes': [{'args': [{'class_name': '__keras_tensor__', 'config': {'shape': [None, 224, 224, 3], 'dtype': 'float32', 'keras_history': ['sequential', 0, 0]}}], 'kwargs': {'mask': None}}]}.\n\nException encountered: could not be deserialized properly. Please ensure that components that are Python object instances (layers, models, etc.) returned by `get_config()` are explicitly deserialized in the model's `from_config()` method.\n\nconfig={'module': 'keras.layers', 'class_name': 'BatchNormalization', 'config': {'name': 'conv1_bn', 'trainable': True, 'dtype': {'module': 'keras', 'class_name': 'DTypePolicy', 'config': {'name': 'float32'}, 'registered_name': None, 'shared_object_id': 131549112122784}, 'axis': 3, 'momentum': 0.99, 'epsilon': 1.001e-05, 'center': True, 'scale': True, 'beta_initializer': {'module': 'keras.initializers', 'class_name': 'Zeros', 'config': {}, 'registered_name': None}, 'gamma_initializer': {'module': 'keras.initializers', 'class_name': 'Ones', 'config': {}, 'registered_name': None}, 'moving_mean_initializer': {'module': 'keras.initializers', 'class_name': 'Zeros', 'config': {}, 'registered_name': None}, 'moving_variance_initializer': {'module': 'keras.initializers', 'class_name': 'Ones', 'config': {}, 'registered_name': None}, 'beta_regularizer': None, 'gamma_regularizer': None, 'beta_constraint': None, 'gamma_constraint': None, 'synchronized': False, 'renorm': False, 'renorm_clipping': None, 'renorm_momentum': 0.99}, 'registered_name': None, 'build_config': {'input_shape': [None, 112, 112, 64]}, 'name': 'conv1_bn', 'inbound_nodes': [{'args': [{'class_name': '__keras_tensor__', 'config': {'shape': [None, 112, 112, 64], 'dtype': 'float32', 'keras_history': ['conv1_conv', 0, 0]}}], 'kwargs': {'mask': None}}]}.\n\nException encountered: Error when deserializing class 'BatchNormalization' using config={'name': 'conv1_bn', 'trainable': True, 'dtype': 'float32', 'axis': 3, 'momentum': 0.99, 'epsilon': 1.001e-05, 'center': True, 'scale': True, 'beta_initializer': {'module': 'keras.initializers', 'class_name': 'Zeros', 'config': {}, 'registered_name': None}, 'gamma_initializer': {'module': 'keras.initializers', 'class_name': 'Ones', 'config': {}, 'registered_name': None}, 'moving_mean_initializer': {'module': 'keras.initializers', 'class_name': 'Zeros', 'config': {}, 'registered_name': None}, 'moving_variance_initializer': {'module': 'keras.initializers', 'class_name': 'Ones', 'config': {}, 'registered_name': None}, 'beta_regularizer': None, 'gamma_regularizer': None, 'beta_constraint': None, 'gamma_constraint': None, 'synchronized': False, 'renorm': False, 'renorm_clipping': None, 'renorm_momentum': 0.99}.\n\nException encountered: Unrecognized keyword arguments passed to BatchNormalization: {'renorm': False, 'renorm_clipping': None, 'renorm_momentum': 0.99}", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_3419/3199619597.py\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mtensorflow\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkeras\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodels\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mload_model\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mbest_model\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mload_model\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'/content/best_model.keras'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/keras/src/saving/saving_api.py\u001b[0m in \u001b[0;36mload_model\u001b[0;34m(filepath, custom_objects, compile, safe_mode)\u001b[0m\n\u001b[1;32m 187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 188\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mis_keras_zip\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mis_keras_dir\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mis_hf\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 189\u001b[0;31m return saving_lib.load_model(\n\u001b[0m\u001b[1;32m 190\u001b[0m \u001b[0mfilepath\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 191\u001b[0m \u001b[0mcustom_objects\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcustom_objects\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/keras/src/saving/saving_lib.py\u001b[0m in \u001b[0;36mload_model\u001b[0;34m(filepath, custom_objects, compile, safe_mode)\u001b[0m\n\u001b[1;32m 363\u001b[0m )\n\u001b[1;32m 364\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfilepath\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"rb\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 365\u001b[0;31m return _load_model_from_fileobj(\n\u001b[0m\u001b[1;32m 366\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcustom_objects\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcompile\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msafe_mode\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 367\u001b[0m )\n", + "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/keras/src/saving/saving_lib.py\u001b[0m in \u001b[0;36m_load_model_from_fileobj\u001b[0;34m(fileobj, custom_objects, compile, safe_mode)\u001b[0m\n\u001b[1;32m 440\u001b[0m \u001b[0mconfig_json\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 441\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 442\u001b[0;31m model = _model_from_config(\n\u001b[0m\u001b[1;32m 443\u001b[0m \u001b[0mconfig_json\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcustom_objects\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcompile\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msafe_mode\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 444\u001b[0m )\n", + "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/keras/src/saving/saving_lib.py\u001b[0m in \u001b[0;36m_model_from_config\u001b[0;34m(config_json, custom_objects, compile, safe_mode)\u001b[0m\n\u001b[1;32m 429\u001b[0m \u001b[0;31m# Construct the model from the configuration file in the archive.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 430\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mObjectSharingScope\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 431\u001b[0;31m model = deserialize_keras_object(\n\u001b[0m\u001b[1;32m 432\u001b[0m \u001b[0mconfig_dict\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcustom_objects\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msafe_mode\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msafe_mode\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 433\u001b[0m )\n", + "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/keras/src/saving/serialization_lib.py\u001b[0m in \u001b[0;36mdeserialize_keras_object\u001b[0;34m(config, custom_objects, safe_mode, **kwargs)\u001b[0m\n\u001b[1;32m 733\u001b[0m \u001b[0minstance\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcls\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfrom_config\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minner_config\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 734\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mTypeError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 735\u001b[0;31m raise TypeError(\n\u001b[0m\u001b[1;32m 736\u001b[0m \u001b[0;34mf\"{cls} could not be deserialized properly. Please\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 737\u001b[0m \u001b[0;34m\" ensure that components that are Python object\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mTypeError\u001b[0m: could not be deserialized properly. Please ensure that components that are Python object instances (layers, models, etc.) returned by `get_config()` are explicitly deserialized in the model's `from_config()` method.\n\nconfig={'module': 'keras.src.models.functional', 'class_name': 'Functional', 'config': {}, 'registered_name': 'Functional', 'build_config': {'input_shape': None}, 'compile_config': {'optimizer': {'module': 'keras.optimizers', 'class_name': 'Adam', 'config': {'name': 'adam', 'learning_rate': 9.999999747378752e-05, 'weight_decay': None, 'clipnorm': None, 'global_clipnorm': None, 'clipvalue': None, 'use_ema': False, 'ema_momentum': 0.99, 'ema_overwrite_frequency': None, 'loss_scale_factor': None, 'gradient_accumulation_steps': None, 'beta_1': 0.9, 'beta_2': 0.999, 'epsilon': 1e-07, 'amsgrad': False}, 'registered_name': None}, 'loss': 'binary_crossentropy', 'loss_weights': None, 'metrics': ['accuracy'], 'weighted_metrics': None, 'run_eagerly': False, 'steps_per_execution': 1, 'jit_compile': False}}.\n\nException encountered: could not be deserialized properly. Please ensure that components that are Python object instances (layers, models, etc.) returned by `get_config()` are explicitly deserialized in the model's `from_config()` method.\n\nconfig={'module': 'keras.src.models.functional', 'class_name': 'Functional', 'config': {}, 'registered_name': 'Functional', 'build_config': {'input_shape': None}, 'compile_config': {}, 'name': 'densenet121', 'inbound_nodes': [{'args': [{'class_name': '__keras_tensor__', 'config': {'shape': [None, 224, 224, 3], 'dtype': 'float32', 'keras_history': ['sequential', 0, 0]}}], 'kwargs': {'mask': None}}]}.\n\nException encountered: could not be deserialized properly. Please ensure that components that are Python object instances (layers, models, etc.) returned by `get_config()` are explicitly deserialized in the model's `from_config()` method.\n\nconfig={'module': 'keras.layers', 'class_name': 'BatchNormalization', 'config': {'name': 'conv1_bn', 'trainable': True, 'dtype': {'module': 'keras', 'class_name': 'DTypePolicy', 'config': {'name': 'float32'}, 'registered_name': None, 'shared_object_id': 131549112122784}, 'axis': 3, 'momentum': 0.99, 'epsilon': 1.001e-05, 'center': True, 'scale': True, 'beta_initializer': {'module': 'keras.initializers', 'class_name': 'Zeros', 'config': {}, 'registered_name': None}, 'gamma_initializer': {'module': 'keras.initializers', 'class_name': 'Ones', 'config': {}, 'registered_name': None}, 'moving_mean_initializer': {'module': 'keras.initializers', 'class_name': 'Zeros', 'config': {}, 'registered_name': None}, 'moving_variance_initializer': {'module': 'keras.initializers', 'class_name': 'Ones', 'config': {}, 'registered_name': None}, 'beta_regularizer': None, 'gamma_regularizer': None, 'beta_constraint': None, 'gamma_constraint': None, 'synchronized': False, 'renorm': False, 'renorm_clipping': None, 'renorm_momentum': 0.99}, 'registered_name': None, 'build_config': {'input_shape': [None, 112, 112, 64]}, 'name': 'conv1_bn', 'inbound_nodes': [{'args': [{'class_name': '__keras_tensor__', 'config': {'shape': [None, 112, 112, 64], 'dtype': 'float32', 'keras_history': ['conv1_conv', 0, 0]}}], 'kwargs': {'mask': None}}]}.\n\nException encountered: Error when deserializing class 'BatchNormalization' using config={'name': 'conv1_bn', 'trainable': True, 'dtype': 'float32', 'axis': 3, 'momentum': 0.99, 'epsilon': 1.001e-05, 'center': True, 'scale': True, 'beta_initializer': {'module': 'keras.initializers', 'class_name': 'Zeros', 'config': {}, 'registered_name': None}, 'gamma_initializer': {'module': 'keras.initializers', 'class_name': 'Ones', 'config': {}, 'registered_name': None}, 'moving_mean_initializer': {'module': 'keras.initializers', 'class_name': 'Zeros', 'config': {}, 'registered_name': None}, 'moving_variance_initializer': {'module': 'keras.initializers', 'class_name': 'Ones', 'config': {}, 'registered_name': None}, 'beta_regularizer': None, 'gamma_regularizer': None, 'beta_constraint': None, 'gamma_constraint': None, 'synchronized': False, 'renorm': False, 'renorm_clipping': None, 'renorm_momentum': 0.99}.\n\nException encountered: Unrecognized keyword arguments passed to BatchNormalization: {'renorm': False, 'renorm_clipping': None, 'renorm_momentum': 0.99}" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ed9952c5" + }, + "source": [ + "### Training metrics evolution" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "40195b33" + }, + "source": [ + "plt.figure(figsize=(12, 5))\n", + "\n", + "# Plot training & validation accuracy values\n", + "plt.subplot(1, 2, 1)\n", + "plt.plot(history.history['accuracy'])\n", + "plt.plot(history.history['val_accuracy'])\n", + "plt.title('Model Accuracy')\n", + "plt.ylabel('Accuracy')\n", + "plt.xlabel('Epoch')\n", + "plt.legend(['Train', 'Validation'], loc='upper left')\n", + "\n", + "# Plot training & validation loss values\n", + "plt.subplot(1, 2, 2)\n", + "plt.plot(history.history['loss'])\n", + "plt.plot(history.history['val_loss'])\n", + "plt.title('Model Loss')\n", + "plt.ylabel('Loss')\n", + "plt.xlabel('Epoch')\n", + "plt.legend(['Train', 'Validation'], loc='upper left')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "d7213f37" + }, + "source": [ + "### Evaluate on test set" + ] + }, + { + "cell_type": "code", + "source": [ + "results = best_model.evaluate(test_df)\n", + "\n", + "for name, value in zip(best_model.metrics_names, results):\n", + " print(f\"{name}: {value:.4f}\")" + ], + "metadata": { + "id": "_9eQgt9AMP_V" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8fd0c0ae" + }, + "source": [ + "### Predictions and Classification Report" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "7aa74334" + }, + "source": [ + "from sklearn.metrics import classification_report, confusion_matrix\n", + "\n", + "test_generator.reset()\n", + "y_prob = best_model.predict(test_generator)\n", + "y_pred = (y_prob > 0.5).astype(int).ravel()\n", + "y_true = val_generator.classes\n", + "\n", + "print(\"Classification Report:\")\n", + "print(classification_report(y_true, y_pred), target_names=[\"Benign\", \"Malignant\"])\n" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "a4a0cfa1" + }, + "source": [ + "### Confusion Matrix" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "21fb9859" + }, + "source": [ + "from sklearn.metrics import confusion_matrix\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "\n", + "cm = confusion_matrix(y_true, y_pred)\n", + "\n", + "plt.figure(figsize=(6,5))\n", + "\n", + "sns.heatmap(\n", + " cm,\n", + " annot=True,\n", + " fmt='d',\n", + " cmap='Blues',\n", + " xticklabels=[\"Benign\", \"Malignant\"],\n", + " yticklabels=[\"Benign\", \"Malignant\"]\n", + ")\n", + "\n", + "plt.xlabel(\"Predicted\")\n", + "plt.ylabel(\"True\")\n", + "plt.title(\"Test Confusion Matrix\")\n", + "\n", + "plt.show()" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### ROC-AUC" + ], + "metadata": { + "id": "Esne2aavRL_6" + } + }, + { + "cell_type": "code", + "source": [ + "from sklearn.metrics import roc_auc_score\n", + "\n", + "auc = roc_auc_score(y_true, y_prob)\n", + "\n", + "print(f\"ROC-AUC: {auc:.4f}\")" + ], + "metadata": { + "id": "KKL2VorfRLed" + }, + "execution_count": null, + "outputs": [] + } + ], + "metadata": { + "colab": { + "provenance": [], + "gpuType": "T4" + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU" + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/run.sh b/run.sh index 8c78b18..6f502c2 100755 --- a/run.sh +++ b/run.sh @@ -20,5 +20,6 @@ pip install pandas numpy matplotlib seaborn pillow scikit-learn pip install "tensorflow[and-cuda]" pip install --upgrade kagglehub[pandas-datasets,hf-datasets] -python3 skin_cancer_classification.py +jupyter nbconvert --to notebook --execute Skin_Cancer_Classification.ipynb --output Skin_Cancer_Classification_Final.ipynb +# python3 skin_cancer_classification.py echo "Done."