Forest_fire_classification.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "!pip install kaggle"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6Ecb0BFcQWET",
        "outputId": "ef2c4aed-41e1-40bb-84a9-3d776ae1332c"
      },
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: kaggle in /usr/local/lib/python3.10/dist-packages (1.5.16)\n",
            "Requirement already satisfied: six>=1.10 in /usr/local/lib/python3.10/dist-packages (from kaggle) (1.16.0)\n",
            "Requirement already satisfied: certifi in /usr/local/lib/python3.10/dist-packages (from kaggle) (2023.11.17)\n",
            "Requirement already satisfied: python-dateutil in /usr/local/lib/python3.10/dist-packages (from kaggle) (2.8.2)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from kaggle) (2.31.0)\n",
            "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from kaggle) (4.66.1)\n",
            "Requirement already satisfied: python-slugify in /usr/local/lib/python3.10/dist-packages (from kaggle) (8.0.2)\n",
            "Requirement already satisfied: urllib3 in /usr/local/lib/python3.10/dist-packages (from kaggle) (2.0.7)\n",
            "Requirement already satisfied: bleach in /usr/local/lib/python3.10/dist-packages (from kaggle) (6.1.0)\n",
            "Requirement already satisfied: webencodings in /usr/local/lib/python3.10/dist-packages (from bleach->kaggle) (0.5.1)\n",
            "Requirement already satisfied: text-unidecode>=1.3 in /usr/local/lib/python3.10/dist-packages (from python-slugify->kaggle) (1.3)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->kaggle) (3.3.2)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->kaggle) (3.6)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import files\n",
        "\n",
        "uploaded = files.upload()\n",
        "\n",
        "for fn in uploaded.keys():\n",
        "    print('User uploaded file \"{name}\" with length {length} bytes'.format(\n",
        "        name=fn, length=len(uploaded[fn])))\n",
        "\n",
        "# Move the kaggle.json file to the correct directory\n",
        "!mkdir -p ~/.kaggle/ && mv kaggle.json ~/.kaggle/ && chmod 600 ~/.kaggle/kaggle.json"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 90
        },
        "id": "bHbJkWRIQWAz",
        "outputId": "41e25360-1f5a-4e0c-ccd0-2da5d2aa2e5b"
      },
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-108f0a7c-56a6-4465-93b5-89a145c0ab6f\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-108f0a7c-56a6-4465-93b5-89a145c0ab6f\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving kaggle.json to kaggle.json\n",
            "User uploaded file \"kaggle.json\" with length 69 bytes\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!kaggle datasets download -d phylake1337/fire-dataset"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QwduqS6zQffm",
        "outputId": "b769dc71-22c3-43d6-9d0c-15650ceca36e"
      },
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "fire-dataset.zip: Skipping, found more recently modified local copy (use --force to force download)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!unzip -q fire-dataset.zip"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Y1VpsRPNQsbg",
        "outputId": "b69ae9a5-c647-4b76-f538-ffb5ec6c6085"
      },
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "replace fire_dataset/fire_images/fire.1.png? [y]es, [n]o, [A]ll, [N]one, [r]ename: "
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 79,
      "metadata": {
        "id": "ka1sKiGLN73i"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import pandas as pd\n",
        "from sklearn.model_selection import train_test_split\n",
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
        "from tensorflow.keras.applications import VGG19\n",
        "from tensorflow.keras import layers, models\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Metrics\n",
        "from sklearn.metrics import classification_report, confusion_matrix\n",
        "import itertools"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!wget https://raw.githubusercontent.com/mrdbourke/tensorflow-deep-learning/main/extras/helper_functions.py\n",
        "\n",
        "# Import series of helper functions for our notebook\n",
        "from helper_functions import create_tensorboard_callback, plot_loss_curves, unzip_data, compare_historys, walk_through_dir, pred_and_plot"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ac5fvME2UyWA",
        "outputId": "7bb84cea-3185-413d-fa0e-2ac8de01b974"
      },
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--2024-02-02 01:13:26--  https://raw.githubusercontent.com/mrdbourke/tensorflow-deep-learning/main/extras/helper_functions.py\n",
            "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.109.133, 185.199.110.133, ...\n",
            "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 10246 (10K) [text/plain]\n",
            "Saving to: ‘helper_functions.py.1’\n",
            "\n",
            "\rhelper_functions.py   0%[                    ]       0  --.-KB/s               \rhelper_functions.py 100%[===================>]  10.01K  --.-KB/s    in 0s      \n",
            "\n",
            "2024-02-02 01:13:26 (70.2 MB/s) - ‘helper_functions.py.1’ saved [10246/10246]\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Set your data path\n",
        "data_path = '/content/fire_dataset'"
      ],
      "metadata": {
        "id": "HAip91GmP4Zq"
      },
      "execution_count": 82,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Define constants\n",
        "IMG_SIZE = (224, 224)\n",
        "BATCH_SIZE = 32"
      ],
      "metadata": {
        "id": "bg0LCOTxP6hY"
      },
      "execution_count": 83,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a list of all image files and labels\n",
        "all_images = []\n",
        "labels = []\n",
        "\n",
        "for label in ['fire_images', 'non_fire_images']:\n",
        "    label_path = os.path.join(data_path, label)\n",
        "    image_files = [os.path.join(label, img) for img in os.listdir(label_path)]\n",
        "    all_images.extend(image_files)\n",
        "    labels.extend([label] * len(image_files))"
      ],
      "metadata": {
        "id": "vDtwGL6wRQPY"
      },
      "execution_count": 84,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Split the data into training, validation, and testing sets\n",
        "train_images, test_images, train_labels, test_labels = train_test_split(all_images, labels, test_size=0.2, random_state=42)\n",
        "train_images, val_images, train_labels, val_labels = train_test_split(train_images, train_labels, test_size=0.2, random_state=42)"
      ],
      "metadata": {
        "id": "X0GbpGS8RbkU"
      },
      "execution_count": 85,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Data augmentation for training images\n",
        "train_datagen = ImageDataGenerator(\n",
        "    rescale=1./255,\n",
        "    shear_range=0.2,\n",
        "    zoom_range=0.2,\n",
        "    horizontal_flip=True\n",
        ")"
      ],
      "metadata": {
        "id": "7HoWeaYIP8Sp"
      },
      "execution_count": 86,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# No data augmentation for validation/test images\n",
        "test_datagen = ImageDataGenerator(rescale=1./255)"
      ],
      "metadata": {
        "id": "qcgZb0rBWNfE"
      },
      "execution_count": 87,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Load training data\n",
        "train_generator = train_datagen.flow_from_dataframe(\n",
        "    pd.DataFrame({'filename': train_images, 'label': train_labels}),\n",
        "    directory=data_path,\n",
        "    x_col='filename',\n",
        "    y_col='label',\n",
        "    target_size=IMG_SIZE,\n",
        "    batch_size=BATCH_SIZE,\n",
        "    class_mode='binary'\n",
        ")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4kD5i_mBQBwp",
        "outputId": "d9916a9d-42e7-4ff7-ee42-cc9772fdf321"
      },
      "execution_count": 88,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 639 validated image filenames belonging to 2 classes.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Load validation data\n",
        "val_generator = test_datagen.flow_from_dataframe(\n",
        "    pd.DataFrame({'filename': val_images, 'label': val_labels}),\n",
        "    directory=data_path,\n",
        "    x_col='filename',\n",
        "    y_col='label',\n",
        "    target_size=IMG_SIZE,\n",
        "    batch_size=BATCH_SIZE,\n",
        "    class_mode='binary'\n",
        ")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MSia3S7BP_Jx",
        "outputId": "d2a21b0e-e17b-4eaa-c001-1e00e148263b"
      },
      "execution_count": 89,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 160 validated image filenames belonging to 2 classes.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Load test data\n",
        "test_generator = test_datagen.flow_from_dataframe(\n",
        "    pd.DataFrame({'filename': test_images, 'label': test_labels}),\n",
        "    directory=data_path,\n",
        "    x_col='filename',\n",
        "    y_col='label',\n",
        "    target_size=IMG_SIZE,\n",
        "    batch_size=BATCH_SIZE,\n",
        "    class_mode='binary'\n",
        ")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-HdfCdGdRvE1",
        "outputId": "224671d5-6ee0-471a-d776-09a4f235c7df"
      },
      "execution_count": 90,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 200 validated image filenames belonging to 2 classes.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Load pre-trained VGG-19 model without top layer (include_top=False)\n",
        "base_model = VGG19(weights='imagenet', include_top=False, input_shape=(224, 224, 3))\n",
        "\n",
        "# Freeze convolutional layers\n",
        "for layer in base_model.layers:\n",
        "    layer.trainable = False"
      ],
      "metadata": {
        "id": "4mtOc3RhQIv7"
      },
      "execution_count": 91,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a new model on top\n",
        "model = models.Sequential()\n",
        "model.add(base_model)\n",
        "model.add(layers.Flatten())\n",
        "model.add(layers.Dense(256, activation='relu'))\n",
        "model.add(layers.Dropout(0.5))\n",
        "model.add(layers.Dense(1, activation='sigmoid'))"
      ],
      "metadata": {
        "id": "AMWG6CcgQLPV"
      },
      "execution_count": 92,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Compile the model\n",
        "model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])"
      ],
      "metadata": {
        "id": "HzAXxcSbQNTz"
      },
      "execution_count": 93,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Train the model\n",
        "history = model.fit(\n",
        "    train_generator,\n",
        "    steps_per_epoch=train_generator.samples // BATCH_SIZE,\n",
        "    epochs=20,\n",
        "    validation_data=val_generator,\n",
        "    validation_steps=val_generator.samples // BATCH_SIZE\n",
        ")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rgDoZbOTSmj0",
        "outputId": "06939f27-ed64-433c-e07d-04c629638d56"
      },
      "execution_count": 94,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/20\n",
            "19/19 [==============================] - 24s 1s/step - loss: 1.9773 - accuracy: 0.6870 - val_loss: 0.3204 - val_accuracy: 0.8500\n",
            "Epoch 2/20\n",
            "19/19 [==============================] - 23s 1s/step - loss: 0.3659 - accuracy: 0.8487 - val_loss: 0.2900 - val_accuracy: 0.8750\n",
            "Epoch 3/20\n",
            "19/19 [==============================] - 21s 1s/step - loss: 0.2987 - accuracy: 0.8600 - val_loss: 0.2832 - val_accuracy: 0.8625\n",
            "Epoch 4/20\n",
            "19/19 [==============================] - 22s 1s/step - loss: 0.2640 - accuracy: 0.8682 - val_loss: 0.2342 - val_accuracy: 0.9062\n",
            "Epoch 5/20\n",
            "19/19 [==============================] - 22s 1s/step - loss: 0.2172 - accuracy: 0.9094 - val_loss: 0.2015 - val_accuracy: 0.9062\n",
            "Epoch 6/20\n",
            "19/19 [==============================] - 23s 1s/step - loss: 0.2165 - accuracy: 0.8962 - val_loss: 0.2350 - val_accuracy: 0.9187\n",
            "Epoch 7/20\n",
            "19/19 [==============================] - 23s 1s/step - loss: 0.2045 - accuracy: 0.9176 - val_loss: 0.1888 - val_accuracy: 0.9312\n",
            "Epoch 8/20\n",
            "19/19 [==============================] - 22s 1s/step - loss: 0.1814 - accuracy: 0.9292 - val_loss: 0.1727 - val_accuracy: 0.9438\n",
            "Epoch 9/20\n",
            "19/19 [==============================] - 23s 1s/step - loss: 0.1797 - accuracy: 0.9259 - val_loss: 0.1700 - val_accuracy: 0.9375\n",
            "Epoch 10/20\n",
            "19/19 [==============================] - 24s 1s/step - loss: 0.1606 - accuracy: 0.9308 - val_loss: 0.1734 - val_accuracy: 0.9187\n",
            "Epoch 11/20\n",
            "19/19 [==============================] - 24s 1s/step - loss: 0.1483 - accuracy: 0.9325 - val_loss: 0.1545 - val_accuracy: 0.9500\n",
            "Epoch 12/20\n",
            "19/19 [==============================] - 21s 1s/step - loss: 0.1394 - accuracy: 0.9407 - val_loss: 0.1781 - val_accuracy: 0.9062\n",
            "Epoch 13/20\n",
            "19/19 [==============================] - 23s 1s/step - loss: 0.1218 - accuracy: 0.9506 - val_loss: 0.2031 - val_accuracy: 0.9062\n",
            "Epoch 14/20\n",
            "19/19 [==============================] - 22s 1s/step - loss: 0.1206 - accuracy: 0.9489 - val_loss: 0.1552 - val_accuracy: 0.9563\n",
            "Epoch 15/20\n",
            "19/19 [==============================] - 22s 1s/step - loss: 0.1222 - accuracy: 0.9555 - val_loss: 0.1694 - val_accuracy: 0.9000\n",
            "Epoch 16/20\n",
            "19/19 [==============================] - 22s 1s/step - loss: 0.1278 - accuracy: 0.9456 - val_loss: 0.1585 - val_accuracy: 0.9563\n",
            "Epoch 17/20\n",
            "19/19 [==============================] - 22s 1s/step - loss: 0.1113 - accuracy: 0.9489 - val_loss: 0.1407 - val_accuracy: 0.9563\n",
            "Epoch 18/20\n",
            "19/19 [==============================] - 23s 1s/step - loss: 0.0955 - accuracy: 0.9605 - val_loss: 0.1392 - val_accuracy: 0.9500\n",
            "Epoch 19/20\n",
            "19/19 [==============================] - 22s 1s/step - loss: 0.0995 - accuracy: 0.9506 - val_loss: 0.1229 - val_accuracy: 0.9563\n",
            "Epoch 20/20\n",
            "19/19 [==============================] - 23s 1s/step - loss: 0.0952 - accuracy: 0.9671 - val_loss: 0.1277 - val_accuracy: 0.9500\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "results = model.evaluate(test_generator, steps=test_generator.samples // BATCH_SIZE)\n",
        "\n",
        "print(\"    Test Loss: {:.5f}\".format(results[0]))\n",
        "print(\"Test Accuracy: {:.2f}%\".format(results[1] * 100))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OCGqC55nUOUi",
        "outputId": "51cf333b-1455-4b2d-9e5d-15fbfeb59dd2"
      },
      "execution_count": 95,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "6/6 [==============================] - 3s 446ms/step - loss: 0.2604 - accuracy: 0.9115\n",
            "    Test Loss: 0.26041\n",
            "Test Accuracy: 91.15%\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plot_loss_curves(history)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 927
        },
        "id": "YgBYV-DDUbtk",
        "outputId": "b10e570b-791b-4a8b-dbfb-800d807028a6"
      },
      "execution_count": 96,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Predict on the validation set\n",
        "val_predictions = model.predict(val_generator, steps=val_generator.samples // BATCH_SIZE)\n",
        "val_predicted_labels = (val_predictions > 0.5).astype(int).flatten()\n",
        "val_true_labels = val_generator.classes"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_ivCYzTCV2oL",
        "outputId": "8e834a44-c764-491f-82e6-82150780e4a3"
      },
      "execution_count": 97,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5/5 [==============================] - 2s 499ms/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(f'Training Loss: {history.history[\"loss\"][-1]:.4f}')\n",
        "print(f'Training Accuracy: {history.history[\"accuracy\"][-1] * 100:.2f}%')\n",
        "print(f'Last Validation Loss: {history.history[\"val_loss\"][-1]:.4f}')\n",
        "print(f'Last Validation Accuracy: {history.history[\"val_accuracy\"][-1] * 100:.2f}%')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "z5m1KtGXfGX7",
        "outputId": "7aec05df-6ce2-4121-8b31-083d2d34cf3a"
      },
      "execution_count": 98,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training Loss: 0.0952\n",
            "Training Accuracy: 96.71%\n",
            "Last Validation Loss: 0.1277\n",
            "Last Validation Accuracy: 95.00%\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Generate classification report for validation set\n",
        "from sklearn.metrics import classification_report\n",
        "print(\"Validation Set Classification Report:\")\n",
        "print(classification_report(val_true_labels, val_predicted_labels))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "N7pprdUvW1ML",
        "outputId": "36f25b9a-5b2b-448d-e9ba-e30cefbc2dd1"
      },
      "execution_count": 99,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Validation Set Classification Report:\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.75      0.77      0.76       116\n",
            "           1       0.36      0.34      0.35        44\n",
            "\n",
            "    accuracy                           0.65       160\n",
            "   macro avg       0.56      0.55      0.55       160\n",
            "weighted avg       0.65      0.65      0.65       160\n",
            "\n"
          ]
        }
      ]
    }
  ]
}