3. Training - Transfer Learning - Skin Cancer.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "8683a732-5338-41d3-9d80-32bfb762c5e5",
   "metadata": {},
   "source": [
    "In this notebook, we will use another dataset from Kaggle, the skin cancer dataset of malignant VS benign ([Kaggle link](https://www.kaggle.com/fanconic/skin-cancer-malignant-vs-benign)) as another use case when using a larger curated dataset. This data was obtained from the International Skin Imaging Collaboration (ISIC) organization.\n",
    "\n",
    "In this notebook, we will use transfer learning, i.e. to make use of models that have been trained on larger and more general datasets (usually the [ImageNet](https://www.image-net.org/about.php) dataset). We use these **pre-trained models** as our foundation and fine-tune it for our custom task. This usually works very well because the models have already learnt to distinguish a lot of different features about our world, so we just train it to focus on our specific task. \n",
    "\n",
    "Transfer learning also makes training much faster and usually result in better performance compared to building and training our own model from scratch. Therefore, in most cases, transfer learning is preferred."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "7eeed029-66bf-4aba-9e2d-c44cf0a19203",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import os\n",
    "import time\n",
    "\n",
    "# most import image processing library, OpenCV as cv2\n",
    "import cv2\n",
    "from imutils.paths import list_images\n",
    "\n",
    "import tensorflow as tf\n",
    "from tensorflow import keras\n",
    "from tensorflow.keras import layers\n",
    "from tensorflow.keras.applications import ResNet50\n",
    "from tensorflow.keras.optimizers import Adam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "459c3b2d-23de-4287-801a-b8cc9f5eb90f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check whether have access to GPU\n",
    "tf.config.list_physical_devices('GPU')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85be4776-f896-4dcd-99dc-6428c89d3be6",
   "metadata": {},
   "source": [
    "# Setup config"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6abe0bc8-db65-43f1-8d7f-5c94a75f7fbe",
   "metadata": {},
   "source": [
    "Almost the same config with the previous \"Training - Sign Language\" notebook, except for the directories to the training set and testing set, as well as CLASS_NAMES."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b15df12d-77d8-466d-8bb5-279bb61e8e59",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# File directory to the training folder.\n",
    "# Follow the config setup in the image collection notebook, or your own folder,\n",
    "# consisting of one \"training\" folder, one \"validation\" folder, and one \"testing\" folder\n",
    "DATASET_DIR = \"dataset\"\n",
    "\n",
    "# Setup training and testing paths\n",
    "# These paths should be changed accordingly\n",
    "TRAIN_PATH = os.path.join(DATASET_DIR, \"skin-cancer-kaggle\", \"train\")\n",
    "TEST_PATH = os.path.join(DATASET_DIR, \"skin-cancer-kaggle\", \"test\")\n",
    "\n",
    "# Path to model's related components\n",
    "OUTPUTS_PATH = \"outputs\"\n",
    "if not os.path.exists(OUTPUTS_PATH):\n",
    "    os.makedirs(OUTPUTS_PATH)\n",
    "\n",
    "# \"belign\" VS \"malignant\", but not sure about the order yet\n",
    "CLASS_NAMES = [\"TO BE DEFINED IN train_ds later\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0bf352ca-9321-4f59-be3b-2af96b4c5ddd",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Training Config"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "4824c680-61cc-4ba1-aa64-00564e3b90e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# initialize the initial learning rate, batch size, and number of\n",
    "# epochs to train for\n",
    "INIT_LR = 1e-4\n",
    "BATCH_SIZE = 32 # Number of training examples used in one iteration of training\n",
    "NUM_EPOCHS = 10\n",
    "\n",
    "# NOTE: 224x224 is the original size of the images\n",
    "IMG_HEIGHT = 224 # height of image to resize to\n",
    "IMG_WIDTH = 224 # width of image to resize to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "269fde67-93a8-4f79-963c-fe4746941c67",
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime\n",
    "# define the path to the serialized output model after training\n",
    "# you may change the filename to your preferred name\n",
    "MODEL_PATH = os.path.join(OUTPUTS_PATH, f\"skin_cancer_classifier-{datetime.today().date()}.model\")\n",
    "\n",
    "# path to save the classification report of accuracy, precision etc.\n",
    "CLASSIF_REPORT_PATH = os.path.join(OUTPUTS_PATH, \"classification_report.txt\")\n",
    "\n",
    "# path to output loss/accuracy plot\n",
    "PLOT_PATH = os.path.join(OUTPUTS_PATH, \"plot.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aed1b310-6e64-4e80-a2bb-a19eb7151a09",
   "metadata": {},
   "source": [
    "# Inspecting dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "2de870f6-d407-474b-bab7-bb5afb2639ac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train set | benign = 1440\n",
      "Train set | malignant = 1197\n",
      "\n",
      "Test set | benign = 360\n",
      "Test set | malignant = 300\n",
      "\n",
      "Total benign images = 1800\n",
      "Total malignant images = 1497\n"
     ]
    }
   ],
   "source": [
    "from imutils.paths import list_images\n",
    "\n",
    "benign_train = len(list(list_images(os.path.join(TRAIN_PATH, 'benign'))))\n",
    "benign_test = len(list(list_images(os.path.join(TEST_PATH, 'benign'))))\n",
    "benign_images = benign_train + benign_test\n",
    "\n",
    "malignant_train = len(list(list_images(os.path.join(TRAIN_PATH, 'malignant'))))\n",
    "malignant_test = len(list(list_images(os.path.join(TEST_PATH, 'malignant'))))\n",
    "malignant_images = malignant_train + malignant_test\n",
    "\n",
    "print(f\"Train set | benign = {benign_train}\")\n",
    "print(f\"Train set | malignant = {malignant_train}\")\n",
    "\n",
    "print(f\"\\nTest set | benign = {benign_test}\")\n",
    "print(f\"Test set | malignant = {malignant_test}\")\n",
    "\n",
    "print(f\"\\nTotal benign images = {benign_images}\")\n",
    "print(f\"Total malignant images = {malignant_images}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "92254e3b-316c-493d-b3a9-04f91081ae2d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original shape = (224, 224, 3)\n",
      "Resized shape = (50, 50, 3)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 200x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## Showing a randomly selected resized image\n",
    "import random\n",
    "\n",
    "# resize the image to smaller to not take up too much space\n",
    "IMG_SIZE = 50\n",
    "# randomly select 1 image from train set\n",
    "img_path = random.choice(list(list_images(TRAIN_PATH)))\n",
    "# take the class label from the folder name of the image\n",
    "label = img_path.split(os.path.sep)[-2]\n",
    "\n",
    "img = cv2.imread(img_path)\n",
    "print(f\"Original shape = {img.shape}\")\n",
    "\n",
    "# convert to RGB color because OpenCV still uses BGR color\n",
    "img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n",
    "resized_img = cv2.resize(img, (IMG_SIZE, IMG_SIZE))\n",
    "print(f\"Resized shape = {resized_img.shape}\")\n",
    "\n",
    "plt.figure(figsize=(2, 2))\n",
    "plt.title(label)\n",
    "plt.imshow(resized_img)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95d2fc37-02a1-4235-8b2d-738a0e7561e9",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Loading data using the Second Method from Training Notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6369ee7-d8d5-48bb-afab-4f3d86226110",
   "metadata": {},
   "source": [
    "Because there is no third split provided in the original dataset, we will split 20% of the given train data into validation set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "1c97fb8b-279c-45bf-9c62-69afb1819a7d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 2637 files belonging to 2 classes.\n",
      "Using 2110 files for training.\n"
     ]
    }
   ],
   "source": [
    "train_ds = tf.keras.preprocessing.image_dataset_from_directory(\n",
    "    TRAIN_PATH,\n",
    "    shuffle=True,\n",
    "    # 20% is used for validation set, defined in val_ds later\n",
    "    validation_split=0.2,\n",
    "    subset=\"training\",\n",
    "    seed=42, # a random seed, same seed is used to replicate same results\n",
    "    image_size=(IMG_HEIGHT, IMG_WIDTH),\n",
    "    batch_size=BATCH_SIZE\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "33785c9f-d4c0-4616-a115-9e8fe60e143b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['benign', 'malignant']"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CLASS_NAMES = train_ds.class_names\n",
    "CLASS_NAMES"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "df9f62db-164b-42fc-b316-d39e58b8a7bb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2110"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total_train = len(train_ds.file_paths)\n",
    "total_train"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f861c08-7050-4bcf-8b4a-249f6693ec53",
   "metadata": {},
   "source": [
    "This validation dataset `val_ds` will take the remaining data (not used for training) from `TRAIN_PATH` to use for validation, this is done by setting the same `validation_split` as we defined for `train_ds`, but a different `subset` as the parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "c3cb3331-91a1-47fe-bd1d-c73a025e1061",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 2637 files belonging to 2 classes.\n",
      "Using 527 files for validation.\n"
     ]
    }
   ],
   "source": [
    "val_ds = tf.keras.preprocessing.image_dataset_from_directory(\n",
    "    TRAIN_PATH,\n",
    "    shuffle=False,\n",
    "    validation_split=0.2,\n",
    "    subset=\"validation\",\n",
    "    seed=42,\n",
    "    image_size=(IMG_HEIGHT, IMG_WIDTH),\n",
    "    batch_size=BATCH_SIZE\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "f72e87c4-9819-429c-a286-8dc439e9625e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "527"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total_val = len(val_ds.file_paths)\n",
    "total_val"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "4b9a1db9-3db5-4882-b54f-fa0574cc3e8e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 660 files belonging to 2 classes.\n"
     ]
    }
   ],
   "source": [
    "test_ds = tf.keras.preprocessing.image_dataset_from_directory(\n",
    "    TEST_PATH,\n",
    "    shuffle=False,\n",
    "    seed=42,\n",
    "    image_size=(IMG_HEIGHT, IMG_WIDTH),\n",
    "    batch_size=BATCH_SIZE\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "10884daf-7a81-4705-98c9-f999d41a2880",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "660"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total_test = len(test_ds.file_paths)\n",
    "total_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "eb426646-0c38-4a28-94b8-1ff357feb769",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Optimize for performance, just like the previous notebook\n",
    "\n",
    "AUTOTUNE = tf.data.AUTOTUNE\n",
    "train_ds = (train_ds\n",
    "            .shuffle(BATCH_SIZE * 100)\n",
    "            .cache()\n",
    "            .prefetch(AUTOTUNE)\n",
    ")\n",
    "val_ds = (val_ds\n",
    "           # no shuffle\n",
    "           .cache()\n",
    "           .prefetch(AUTOTUNE)\n",
    ")\n",
    "test_ds = (test_ds\n",
    "           # no shuffle\n",
    "           .cache()\n",
    "           .prefetch(AUTOTUNE)\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "968b9605-3871-4ed1-9b56-6b89e5e1d323",
   "metadata": {},
   "source": [
    "# Preparing Pre-trained model for Transfer Learning"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e6eef00-d640-4bcc-bf62-d14f54d916a6",
   "metadata": {},
   "source": [
    "We will use a ResNet50 (Residual Network with 50 layers) model as our pre-trained model, you may use any pre-trained models available in the Keras Applications module that can be referred [here](https://www.tensorflow.org/api_docs/python/tf/keras/applications).\n",
    "\n",
    "You can also read more about ResNet from a [blogpost here](https://www.mygreatlearning.com/blog/resnet/), or refer to the [official published paper](https://arxiv.org/abs/1512.03385).\n",
    "\n",
    "For this model, we are using the Keras Functional API to build the model layers, where each layer is built in a way that's similar to calling a function, as opposed to the Sequential API that we have been using in the previous notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "dd305685-519f-40d7-8bfb-7cf483e8fd31",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] preparing model...\n"
     ]
    }
   ],
   "source": [
    "# load the ResNet-50 network, ensuring the head fully connected (FC) layer sets are left\n",
    "# off so that we only take the important layers from the network\n",
    "print(\"[INFO] preparing model...\")\n",
    "baseModel = ResNet50(\n",
    "    weights=\"imagenet\", include_top=False, input_tensor=keras.Input(shape=(224, 224, 3))\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "42d63278-e855-4636-bdb1-0f71115b450c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# construct the head of the model that will be placed on top of the\n",
    "# the base model\n",
    "headModel = baseModel.output\n",
    "# then add extra layers to suit our choice\n",
    "headModel = layers.AveragePooling2D(pool_size=(7, 7))(headModel)\n",
    "headModel = layers.Flatten(name=\"flatten\")(headModel)\n",
    "headModel = layers.Dense(256, activation=\"relu\")(headModel)\n",
    "headModel = layers.Dropout(0.5)(headModel)\n",
    "# the last layer is the most important to ensure the model outputs\n",
    "#  the result that we want\n",
    "headModel = layers.Dense(len(CLASS_NAMES), activation=\"softmax\")(headModel)\n",
    "\n",
    "# place the head FC model on top of the base model (this will become\n",
    "# the actual model we will train)\n",
    "model = keras.Model(inputs=baseModel.input, outputs=headModel)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "35af8617-8873-4f9d-93bb-72e0160e1e38",
   "metadata": {},
   "outputs": [],
   "source": [
    "# loop over all layers in the base model and freeze them so they will\n",
    "# *not* be updated during the training process. This is the common process\n",
    "# of transfer learning to make sure not to destroy the weights in the original\n",
    "# pre-trained model, you may choose to unfreeze all of them later to further fine-tune\n",
    "# to your custom dataset if you wish, but it is not certain whether there will be improvement\n",
    "# until you have tried it\n",
    "for layer in baseModel.layers:\n",
    "    layer.trainable = False\n",
    "\n",
    "# compile the model, setting a decay rate for our learning rate to \n",
    "# slowly go down during the training to improve efficiency. This is\n",
    "# one way to control the updates of the model weights\n",
    "opt = Adam(learning_rate=INIT_LR, decay=INIT_LR / NUM_EPOCHS)\n",
    "model.compile(loss=\"sparse_categorical_crossentropy\", optimizer=opt, metrics=[\"accuracy\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3bf319c3-b856-490b-a93a-7d714f0fa7fc",
   "metadata": {},
   "source": [
    "# Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "81e81a00-abe4-40f4-8e92-1523f1f4f3b0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] Training model...\n",
      "Epoch 1/10\n",
      "66/66 [==============================] - 21s 240ms/step - loss: 0.6071 - accuracy: 0.7265 - val_loss: 0.3393 - val_accuracy: 0.8235\n",
      "Epoch 2/10\n",
      "66/66 [==============================] - 14s 213ms/step - loss: 0.3929 - accuracy: 0.8166 - val_loss: 0.2515 - val_accuracy: 0.9051\n",
      "Epoch 3/10\n",
      "66/66 [==============================] - 14s 214ms/step - loss: 0.3512 - accuracy: 0.8393 - val_loss: 0.2371 - val_accuracy: 0.9051\n",
      "Epoch 4/10\n",
      "66/66 [==============================] - 14s 207ms/step - loss: 0.3046 - accuracy: 0.8659 - val_loss: 0.2407 - val_accuracy: 0.9051\n",
      "Epoch 5/10\n",
      "66/66 [==============================] - 13s 204ms/step - loss: 0.2882 - accuracy: 0.8583 - val_loss: 0.2183 - val_accuracy: 0.9127\n",
      "Epoch 6/10\n",
      "66/66 [==============================] - 14s 210ms/step - loss: 0.2651 - accuracy: 0.8758 - val_loss: 0.2398 - val_accuracy: 0.9032\n",
      "Epoch 7/10\n",
      "66/66 [==============================] - 14s 209ms/step - loss: 0.2545 - accuracy: 0.8839 - val_loss: 0.2164 - val_accuracy: 0.9070\n",
      "Epoch 8/10\n",
      "66/66 [==============================] - 14s 212ms/step - loss: 0.2330 - accuracy: 0.8919 - val_loss: 0.2071 - val_accuracy: 0.9203\n",
      "Epoch 9/10\n",
      "66/66 [==============================] - 14s 209ms/step - loss: 0.2249 - accuracy: 0.9014 - val_loss: 0.1722 - val_accuracy: 0.9431\n",
      "Epoch 10/10\n",
      "66/66 [==============================] - 14s 206ms/step - loss: 0.2145 - accuracy: 0.9081 - val_loss: 0.1932 - val_accuracy: 0.9298\n",
      "[INFO] Total time: 145.62 s\n"
     ]
    }
   ],
   "source": [
    "# train the model\n",
    "print(\"[INFO] Training model...\")\n",
    "start_time = time.perf_counter()\n",
    "H = model.fit(\n",
    "    train_ds,\n",
    "    validation_data=val_ds,\n",
    "    epochs=NUM_EPOCHS\n",
    ")\n",
    "end_time = time.perf_counter()\n",
    "print(f\"[INFO] Total time: {end_time - start_time:.2f} s\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "32f698c6-fab7-4ce8-b1a9-9c483c5c8567",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] saving model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\user\\anaconda3\\envs\\tfod\\lib\\site-packages\\tensorflow\\python\\keras\\utils\\generic_utils.py:494: CustomMaskWarning: Custom mask layers require a config and must override get_config. When loading, the custom mask layer must be passed to the custom_objects argument.\n",
      "  warnings.warn('Custom mask layers require a config and must override '\n"
     ]
    }
   ],
   "source": [
    "# serialize the model to disk\n",
    "print(\"[INFO] saving model...\")\n",
    "model.save(MODEL_PATH, save_format=\"h5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "c2aaf309-b213-4d2a-baad-3167dda6a201",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total epochs: 10\n",
      "Min val_loss: 0.17224 at epoch 9\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot the training and validation results\n",
    "val_loss = H.history[\"val_loss\"]\n",
    "min_val_loss = np.min(val_loss)\n",
    "epoch_min_val_loss = val_loss.index(min_val_loss) + 1\n",
    "total_epochs = len(val_loss)\n",
    "print(f\"Total epochs: {total_epochs}\")\n",
    "print(f\"Min val_loss: {min_val_loss:.5f} at epoch {epoch_min_val_loss}\\n\")\n",
    "\n",
    "N = NUM_EPOCHS\n",
    "plt.style.use(\"ggplot\")\n",
    "plt.xticks(np.arange(1, N + 1))\n",
    "plt.plot(np.arange(1, N + 1), H.history[\"loss\"], label=\"train_loss\")\n",
    "plt.plot(np.arange(1, N + 1), H.history[\"val_loss\"], label=\"val_loss\")\n",
    "plt.plot(np.arange(1, N + 1), H.history[\"accuracy\"], label=\"train_acc\")\n",
    "plt.plot(np.arange(1, N + 1), H.history[\"val_accuracy\"], label=\"val_acc\")\n",
    "plt.title(\"Training Loss and Accuracy on Dataset\")\n",
    "plt.xlabel(\"Epoch #\")\n",
    "plt.ylabel(\"Loss/Accuracy\")\n",
    "plt.legend(loc=\"upper left\")\n",
    "# save the figure\n",
    "plt.savefig(PLOT_PATH)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41d17f08-c9da-4fa1-b749-195e3d0cf991",
   "metadata": {},
   "source": [
    "# Evaluation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49dc27a4-a6c2-43ae-a84c-407045be9672",
   "metadata": {},
   "source": [
    "Similar to our previous notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "bf5a713a-10d7-4416-9b9e-0ab49e386dfa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] Loading model ...\n",
      "[INFO] Done. [1.40 s]\n"
     ]
    }
   ],
   "source": [
    "# Load entire saved model directly\n",
    "start_time = time.perf_counter()\n",
    "print(f\"[INFO] Loading model ...\")\n",
    "model = tf.keras.models.load_model(MODEL_PATH)\n",
    "end_time = time.perf_counter()\n",
    "print(f\"[INFO] Done. [{end_time - start_time:.2f} s]\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "dfabbdbc-f04b-4659-873c-6a68816a9b6c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17/17 [==============================] - 4s 159ms/step - loss: 0.1932 - accuracy: 0.9298\n",
      "[INFO] Validation Accuracy: 92.98%\n",
      "21/21 [==============================] - 4s 192ms/step - loss: 0.2910 - accuracy: 0.8682\n",
      "[INFO] Testing Accuracy: 86.82%\n"
     ]
    }
   ],
   "source": [
    "# show the accuracy on the validation set\n",
    "(loss, accuracy) = model.evaluate(val_ds)\n",
    "print(\"[INFO] Validation Accuracy: {:.2f}%\".format(accuracy * 100))\n",
    "(loss, accuracy) = model.evaluate(test_ds)\n",
    "print(\"[INFO] Testing Accuracy: {:.2f}%\".format(accuracy * 100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "45a05f6d-23bc-49ae-93a5-706720555271",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 3.95 s\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(660, 2)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "preds = model.predict(test_ds)\n",
    "preds.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "246eda0d-7919-40fe-84e0-2952a799fdfd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(660,)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "preds = np.argmax(preds, axis=-1)\n",
    "preds.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "2e6ae1e6-6629-40bc-bf99-b1ad4312dbee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(660,)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_true = np.concatenate([y for x, y in test_ds], axis=0)\n",
    "y_true.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "9ebb44d1-254c-4122-acf8-becd54d36742",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "      benign       0.89      0.86      0.88       360\n",
      "   malignant       0.84      0.87      0.86       300\n",
      "\n",
      "    accuracy                           0.87       660\n",
      "   macro avg       0.87      0.87      0.87       660\n",
      "weighted avg       0.87      0.87      0.87       660\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import classification_report\n",
    "\n",
    "# show a nicely formatted classification report\n",
    "classif_report = classification_report(\n",
    "    y_true, preds, target_names=CLASS_NAMES\n",
    ")\n",
    "print(classif_report)\n",
    "with open(CLASSIF_REPORT_PATH, \"w\") as f:\n",
    "    f.write(classif_report)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "bc439bc7-0dd9-4eb1-9200-907e89acb51e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "660"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(cm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "520f6edd-134f-411c-8944-5350fa326cba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 300x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "import seaborn as sns\n",
    "\n",
    "cm = confusion_matrix(y_true, preds)\n",
    "\n",
    "fig = plt.figure(figsize=(3, 3))\n",
    "ax = sns.heatmap(\n",
    "    cm,\n",
    "    cmap=\"Blues\",\n",
    "    annot=True,\n",
    "    fmt=\"d\",\n",
    "    cbar=False,\n",
    ")\n",
    "\n",
    "plt.title(\"Confusion Matrix\", size=12, fontfamily=\"serif\")\n",
    "plt.savefig(os.path.join(OUTPUTS_PATH, \"cm_skin_cancer.png\"))\n",
    "plt.ylabel('Actual')\n",
    "plt.xlabel('Predicted')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "93fd3541-e571-47c9-b009-824ef94e9175",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tfod",
   "language": "python",
   "name": "tfod"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}