InceptionV3.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e96a0b05-9799-4690-82a5-b993abc05f9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import os\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from PIL import Image\n",
    "from tensorflow.keras import layers, models\n",
    "from tensorflow.keras.models import Sequential ,load_model, Model\n",
    "from tensorflow.keras.layers import Dense, Dropout, Flatten, GlobalAveragePooling2D\n",
    "from tensorflow.keras.applications import ResNet50, MobileNetV2, EfficientNetB0, DenseNet121, InceptionV3, Xception\n",
    "from tensorflow.keras.optimizers import Adam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "6f34caf3-428f-49f8-b684-c2556c2ef46e",
   "metadata": {},
   "outputs": [],
   "source": [
    "combat = \"ImageData/Combat\"\n",
    "destroyed_building = \"ImageData/DestroyedBuildings\"\n",
    "fire = \"ImageData/Fire\"\n",
    "humanterian = \"ImageData/Humanitarian Aid and rehabilitation\"\n",
    "vehicles = \"ImageData/Military vehicles and weapons\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "99291abf-afd8-4274-987e-34c998cf9cfa",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.preprocessing.image import ImageDataGenerator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ddccab2f-477a-4556-a0e2-cf154448da2c",
   "metadata": {},
   "outputs": [],
   "source": [
    "train = ImageDataGenerator(rescale=1./255,zoom_range=0.2,horizontal_flip=True)\n",
    "test = ImageDataGenerator(rescale=1./255)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0a0d5f20-2483-4e31-b390-eca0ca5f2249",
   "metadata": {},
   "outputs": [],
   "source": [
    "combat1=[os.path.join(combat,f) for f in os. listdir (combat)]\n",
    "destroyed_building1=[os.path.join(destroyed_building,f) for f in os.listdir(destroyed_building)] \n",
    "fire1=[os.path.join(fire,f) for f in os.listdir(fire)]\n",
    "humanterian1=[os.path.join(humanterian,f) for f in os.listdir(humanterian)]\n",
    "vehicles1=[os.path.join(vehicles,f) for f in os.listdir(vehicles)]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "55828b38-250b-43c0-91fd-43b7d52a1432",
   "metadata": {},
   "outputs": [],
   "source": [
    "image_files=combat1+destroyed_building1+fire1+humanterian1+vehicles1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "84985cc5-dc7d-4f03-b2c2-17595d5c93df",
   "metadata": {},
   "outputs": [],
   "source": [
    "label= [0] * len(combat1) +[1] * len(destroyed_building1) + [2] * len(fire1) + [3] * len(humanterian1) + [4] * len(vehicles1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "01248ff7-90ee-4c6f-882b-7baa0510dcb0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>image</th>\n",
       "      <th>labels</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>/Users/ishanurgaonkar/Downloads/imagedata/Comb...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>/Users/ishanurgaonkar/Downloads/imagedata/Comb...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>/Users/ishanurgaonkar/Downloads/imagedata/Comb...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>/Users/ishanurgaonkar/Downloads/imagedata/Comb...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>/Users/ishanurgaonkar/Downloads/imagedata/Comb...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>495</th>\n",
       "      <td>/Users/ishanurgaonkar/Downloads/imagedata/Mili...</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>496</th>\n",
       "      <td>/Users/ishanurgaonkar/Downloads/imagedata/Mili...</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>497</th>\n",
       "      <td>/Users/ishanurgaonkar/Downloads/imagedata/Mili...</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>498</th>\n",
       "      <td>/Users/ishanurgaonkar/Downloads/imagedata/Mili...</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>499</th>\n",
       "      <td>/Users/ishanurgaonkar/Downloads/imagedata/Mili...</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>500 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                 image  labels\n",
       "0    /Users/ishanurgaonkar/Downloads/imagedata/Comb...       0\n",
       "1    /Users/ishanurgaonkar/Downloads/imagedata/Comb...       0\n",
       "2    /Users/ishanurgaonkar/Downloads/imagedata/Comb...       0\n",
       "3    /Users/ishanurgaonkar/Downloads/imagedata/Comb...       0\n",
       "4    /Users/ishanurgaonkar/Downloads/imagedata/Comb...       0\n",
       "..                                                 ...     ...\n",
       "495  /Users/ishanurgaonkar/Downloads/imagedata/Mili...       4\n",
       "496  /Users/ishanurgaonkar/Downloads/imagedata/Mili...       4\n",
       "497  /Users/ishanurgaonkar/Downloads/imagedata/Mili...       4\n",
       "498  /Users/ishanurgaonkar/Downloads/imagedata/Mili...       4\n",
       "499  /Users/ishanurgaonkar/Downloads/imagedata/Mili...       4\n",
       "\n",
       "[500 rows x 2 columns]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.DataFrame({'image': image_files, 'labels': label})\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "cf06501f-942b-4591-9ed9-a4c5851bd508",
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"labels\"]=df[\"labels\"].astype(str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "bc51a9ac-fdac-48f0-9c34-07af06e549fb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 349 validated image filenames belonging to 5 classes.\n",
      "Found 150 validated image filenames belonging to 5 classes.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/lib/python3.11/site-packages/keras/src/legacy/preprocessing/image.py:920: UserWarning: Found 1 invalid image filename(s) in x_col=\"image\". These filename(s) will be ignored.\n",
      "  warnings.warn(\n",
      "/opt/anaconda3/lib/python3.11/site-packages/keras/src/trainers/data_adapters/py_dataset_adapter.py:121: UserWarning: Your `PyDataset` class should call `super().__init__(**kwargs)` in its constructor. `**kwargs` can include `workers`, `use_multiprocessing`, `max_queue_size`. Do not pass these arguments to `fit()`, as they will be ignored.\n",
      "  self._warn_if_super_not_called()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m11/11\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 1s/step - accuracy: 0.4278 - loss: 1.7883 - val_accuracy: 0.9333 - val_loss: 0.3209\n",
      "Found 349 validated image filenames belonging to 5 classes.\n",
      "Found 150 validated image filenames belonging to 5 classes.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/lib/python3.11/site-packages/keras/src/legacy/preprocessing/image.py:920: UserWarning: Found 1 invalid image filename(s) in x_col=\"image\". These filename(s) will be ignored.\n",
      "  warnings.warn(\n",
      "/opt/anaconda3/lib/python3.11/site-packages/keras/src/trainers/data_adapters/py_dataset_adapter.py:121: UserWarning: Your `PyDataset` class should call `super().__init__(**kwargs)` in its constructor. `**kwargs` can include `workers`, `use_multiprocessing`, `max_queue_size`. Do not pass these arguments to `fit()`, as they will be ignored.\n",
      "  self._warn_if_super_not_called()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m11/11\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m16s\u001b[0m 1s/step - accuracy: 0.3568 - loss: 1.7120 - val_accuracy: 0.8533 - val_loss: 0.4797\n",
      "Found 349 validated image filenames belonging to 5 classes.\n",
      "Found 150 validated image filenames belonging to 5 classes.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/lib/python3.11/site-packages/keras/src/legacy/preprocessing/image.py:920: UserWarning: Found 1 invalid image filename(s) in x_col=\"image\". These filename(s) will be ignored.\n",
      "  warnings.warn(\n",
      "/opt/anaconda3/lib/python3.11/site-packages/keras/src/trainers/data_adapters/py_dataset_adapter.py:121: UserWarning: Your `PyDataset` class should call `super().__init__(**kwargs)` in its constructor. `**kwargs` can include `workers`, `use_multiprocessing`, `max_queue_size`. Do not pass these arguments to `fit()`, as they will be ignored.\n",
      "  self._warn_if_super_not_called()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m11/11\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m16s\u001b[0m 1s/step - accuracy: 0.4354 - loss: 1.6795 - val_accuracy: 0.8467 - val_loss: 0.4334\n",
      "Found 349 validated image filenames belonging to 5 classes.\n",
      "Found 150 validated image filenames belonging to 5 classes.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/lib/python3.11/site-packages/keras/src/legacy/preprocessing/image.py:920: UserWarning: Found 1 invalid image filename(s) in x_col=\"image\". These filename(s) will be ignored.\n",
      "  warnings.warn(\n",
      "/opt/anaconda3/lib/python3.11/site-packages/keras/src/trainers/data_adapters/py_dataset_adapter.py:121: UserWarning: Your `PyDataset` class should call `super().__init__(**kwargs)` in its constructor. `**kwargs` can include `workers`, `use_multiprocessing`, `max_queue_size`. Do not pass these arguments to `fit()`, as they will be ignored.\n",
      "  self._warn_if_super_not_called()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m11/11\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m16s\u001b[0m 1s/step - accuracy: 0.3458 - loss: 2.0643 - val_accuracy: 0.8667 - val_loss: 0.4831\n",
      "Found 349 validated image filenames belonging to 5 classes.\n",
      "Found 150 validated image filenames belonging to 5 classes.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/lib/python3.11/site-packages/keras/src/legacy/preprocessing/image.py:920: UserWarning: Found 1 invalid image filename(s) in x_col=\"image\". These filename(s) will be ignored.\n",
      "  warnings.warn(\n",
      "/opt/anaconda3/lib/python3.11/site-packages/keras/src/trainers/data_adapters/py_dataset_adapter.py:121: UserWarning: Your `PyDataset` class should call `super().__init__(**kwargs)` in its constructor. `**kwargs` can include `workers`, `use_multiprocessing`, `max_queue_size`. Do not pass these arguments to `fit()`, as they will be ignored.\n",
      "  self._warn_if_super_not_called()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m11/11\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 1s/step - accuracy: 0.4193 - loss: 1.7672 - val_accuracy: 0.8867 - val_loss: 0.3578\n",
      "Found 349 validated image filenames belonging to 5 classes.\n",
      "Found 150 validated image filenames belonging to 5 classes.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/lib/python3.11/site-packages/keras/src/legacy/preprocessing/image.py:920: UserWarning: Found 1 invalid image filename(s) in x_col=\"image\". These filename(s) will be ignored.\n",
      "  warnings.warn(\n",
      "/opt/anaconda3/lib/python3.11/site-packages/keras/src/trainers/data_adapters/py_dataset_adapter.py:121: UserWarning: Your `PyDataset` class should call `super().__init__(**kwargs)` in its constructor. `**kwargs` can include `workers`, `use_multiprocessing`, `max_queue_size`. Do not pass these arguments to `fit()`, as they will be ignored.\n",
      "  self._warn_if_super_not_called()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m11/11\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m16s\u001b[0m 1s/step - accuracy: 0.4214 - loss: 1.7929 - val_accuracy: 0.8533 - val_loss: 0.5198\n",
      "Found 349 validated image filenames belonging to 5 classes.\n",
      "Found 150 validated image filenames belonging to 5 classes.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/lib/python3.11/site-packages/keras/src/legacy/preprocessing/image.py:920: UserWarning: Found 1 invalid image filename(s) in x_col=\"image\". These filename(s) will be ignored.\n",
      "  warnings.warn(\n",
      "/opt/anaconda3/lib/python3.11/site-packages/keras/src/trainers/data_adapters/py_dataset_adapter.py:121: UserWarning: Your `PyDataset` class should call `super().__init__(**kwargs)` in its constructor. `**kwargs` can include `workers`, `use_multiprocessing`, `max_queue_size`. Do not pass these arguments to `fit()`, as they will be ignored.\n",
      "  self._warn_if_super_not_called()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m11/11\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m16s\u001b[0m 1s/step - accuracy: 0.4876 - loss: 1.3963 - val_accuracy: 0.8267 - val_loss: 0.3755\n",
      "Found 349 validated image filenames belonging to 5 classes.\n",
      "Found 150 validated image filenames belonging to 5 classes.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/lib/python3.11/site-packages/keras/src/legacy/preprocessing/image.py:920: UserWarning: Found 1 invalid image filename(s) in x_col=\"image\". These filename(s) will be ignored.\n",
      "  warnings.warn(\n",
      "/opt/anaconda3/lib/python3.11/site-packages/keras/src/trainers/data_adapters/py_dataset_adapter.py:121: UserWarning: Your `PyDataset` class should call `super().__init__(**kwargs)` in its constructor. `**kwargs` can include `workers`, `use_multiprocessing`, `max_queue_size`. Do not pass these arguments to `fit()`, as they will be ignored.\n",
      "  self._warn_if_super_not_called()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m11/11\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m16s\u001b[0m 1s/step - accuracy: 0.4830 - loss: 1.4569 - val_accuracy: 0.8933 - val_loss: 0.3130\n",
      "Found 349 validated image filenames belonging to 5 classes.\n",
      "Found 150 validated image filenames belonging to 5 classes.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/lib/python3.11/site-packages/keras/src/legacy/preprocessing/image.py:920: UserWarning: Found 1 invalid image filename(s) in x_col=\"image\". These filename(s) will be ignored.\n",
      "  warnings.warn(\n",
      "/opt/anaconda3/lib/python3.11/site-packages/keras/src/trainers/data_adapters/py_dataset_adapter.py:121: UserWarning: Your `PyDataset` class should call `super().__init__(**kwargs)` in its constructor. `**kwargs` can include `workers`, `use_multiprocessing`, `max_queue_size`. Do not pass these arguments to `fit()`, as they will be ignored.\n",
      "  self._warn_if_super_not_called()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m11/11\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m16s\u001b[0m 1s/step - accuracy: 0.3452 - loss: 1.9019 - val_accuracy: 0.7933 - val_loss: 0.5482\n",
      "Found 349 validated image filenames belonging to 5 classes.\n",
      "Found 150 validated image filenames belonging to 5 classes.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/lib/python3.11/site-packages/keras/src/legacy/preprocessing/image.py:920: UserWarning: Found 1 invalid image filename(s) in x_col=\"image\". These filename(s) will be ignored.\n",
      "  warnings.warn(\n",
      "/opt/anaconda3/lib/python3.11/site-packages/keras/src/trainers/data_adapters/py_dataset_adapter.py:121: UserWarning: Your `PyDataset` class should call `super().__init__(**kwargs)` in its constructor. `**kwargs` can include `workers`, `use_multiprocessing`, `max_queue_size`. Do not pass these arguments to `fit()`, as they will be ignored.\n",
      "  self._warn_if_super_not_called()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m11/11\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m16s\u001b[0m 1s/step - accuracy: 0.4575 - loss: 1.5486 - val_accuracy: 0.8200 - val_loss: 0.5532\n",
      "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 694ms/step - accuracy: 0.8332 - loss: 0.5174\n",
      "Test accuracy: 0.8199999928474426\n",
      "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 870ms/step\n",
      "Classification Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.25      0.15      0.19        39\n",
      "           1       0.22      0.30      0.25        23\n",
      "           2       0.17      0.19      0.18        26\n",
      "           3       0.11      0.13      0.12        31\n",
      "           4       0.13      0.13      0.13        31\n",
      "\n",
      "    accuracy                           0.17       150\n",
      "   macro avg       0.18      0.18      0.18       150\n",
      "weighted avg       0.18      0.17      0.17       150\n",
      "\n",
      "Confusion Matrix:\n",
      "[[ 6  8  8 12  5]\n",
      " [ 3  7  3  4  6]\n",
      " [ 5  4  5  5  7]\n",
      " [ 7  7  5  4  8]\n",
      " [ 3  6  8 10  4]]\n",
      "F1-Score (Macro): 0.17583989780711096\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow.keras.applications import InceptionV3\n",
    "from tensorflow.keras.layers import GlobalAveragePooling2D, Dense, Dropout\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.optimizers import Adam\n",
    "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import classification_report, confusion_matrix, f1_score\n",
    "\n",
    "# ... (Your code for loading data and defining paths)\n",
    "\n",
    "# Split data into training and testing sets (adjust test_size as needed)\n",
    "train_data, test_data = train_test_split(df, test_size=0.3, random_state=42)\n",
    "\n",
    "# Define data augmentation for training (limited for lower accuracy, optional)\n",
    "train_datagen = ImageDataGenerator(rescale=1./255)\n",
    "\n",
    "# No augmentation for testing, only rescaling\n",
    "test_datagen = ImageDataGenerator(rescale=1./255)\n",
    "\n",
    "epochs = 10\n",
    "# Empty list to store training and validation accuracy during each epoch\n",
    "train_acc = []\n",
    "val_acc = []\n",
    "train_loss = []\n",
    "val_loss = []\n",
    "for epoch in range(epochs):\n",
    "  # Reset the training generator after each epoch\n",
    "  train_generator = train_datagen.flow_from_dataframe(\n",
    "      dataframe=train_data,\n",
    "      x_col=\"image\",\n",
    "      y_col=\"labels\",\n",
    "      target_size=(224, 224),  # Adjust if InceptionV3 expects a different size\n",
    "      class_mode=\"categorical\",\n",
    "      batch_size=32\n",
    "  )\n",
    "\n",
    "  # Print the number of batches in the training generator (optional)\n",
    "  # print(len(train_generator))\n",
    "\n",
    "  test_generator = test_datagen.flow_from_dataframe(\n",
    "      dataframe=test_data,\n",
    "      x_col=\"image\",\n",
    "      y_col=\"labels\",\n",
    "      target_size=(224, 224),  # Adjust if InceptionV3 expects a different size\n",
    "      class_mode=\"categorical\",\n",
    "      batch_size=32\n",
    "    \n",
    "  )\n",
    "\n",
    "  # Load InceptionV3 with minimal training (lowers accuracy)\n",
    "  inception_model = InceptionV3(weights='imagenet', include_top=False, input_shape=(224, 224, 3))\n",
    "  inception_model.trainable = False  \n",
    "\n",
    "  # Create a new model using model2 as input\n",
    "  model2 = Sequential([\n",
    "      inception_model,\n",
    "      GlobalAveragePooling2D(),\n",
    "      Dense(128, activation='relu'),\n",
    "      Dropout(0.5),\n",
    "      Dense(5, activation='softmax')\n",
    "  ])\n",
    "\n",
    "  model2.compile(optimizer=Adam(), loss='categorical_crossentropy', metrics=['accuracy'])\n",
    "\n",
    "  # Adjust steps_per_epoch based on the number of batches in train_generator (optional)\n",
    "  history2 = model2.fit(\n",
    "      train_generator,\n",
    "      steps_per_epoch=len(train_generator),  # Adjust if necessary\n",
    "      epochs=1,  # Train for 1 epoch within the loop\n",
    "      validation_data=test_generator,\n",
    "      validation_steps=len(test_generator)\n",
    "  )\n",
    "\n",
    "# Extract training and validation accuracy from history after each epoch\n",
    "  train_acc.append(history2.history['accuracy'][0])\n",
    "  val_acc.append(history2.history['val_accuracy'][0])\n",
    "\n",
    "\n",
    "  train_loss.append(history2.history['loss'][0])\n",
    "  val_loss.append(history2.history['val_loss'][0])\n",
    "  # ... (Optional: Code for further training or evaluation)\n",
    "\n",
    "# Plot training and validation accuracy\n",
    "epochs_range = range(epochs)  # List of epochs for the x-axis\n",
    "\n",
    "# Evaluate the model on the test set\n",
    "test_loss, test_acc = model2.evaluate(test_generator)\n",
    "print('Test accuracy:', test_acc)\n",
    "\n",
    "\n",
    "# Predict on the test set and get true labels\n",
    "predictions = np.argmax(model2.predict(test_generator), axis=-1)\n",
    "true_labels = test_generator.classes\n",
    "\n",
    "# Print classification report\n",
    "print('Classification Report:')\n",
    "print(classification_report(true_labels, predictions))\n",
    "\n",
    "\n",
    "\n",
    "# Print confusion matrix\n",
    "print('Confusion Matrix:')\n",
    "print(confusion_matrix(true_labels, predictions))\n",
    "\n",
    "# Calculate F1-score (macro average)\n",
    "f1_macro = f1_score(true_labels, predictions, average='macro')\n",
    "print('F1-Score (Macro):', f1_macro)\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "66173df8-5627-4fa7-b110-e55b765f635b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.plot(epochs_range, train_acc, label='Training Accuracy')\n",
    "plt.plot(epochs_range, val_acc, label='Validation Accuracy')\n",
    "\n",
    "# Set labels and title\n",
    "plt.title('Training and Validation Accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.legend()\n",
    "\n",
    "# Show the plot\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "0cdd2917-5579-405c-b9eb-e9ba69dc8df3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.plot(epochs_range, train_loss, label='Training Loss')\n",
    "plt.plot(epochs_range, val_loss, label='Validation Loss')\n",
    "\n",
    "# Set labels and title\n",
    "plt.title('Training and Validation Loss')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Loss')\n",
    "plt.legend()\n",
    "\n",
    "# Show the plot\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ad566f3-e513-474b-8935-ac182e7d81b7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c0c2eb88-8587-4bfb-a441-61a5f8da3701",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "276961de-82ac-47f3-b57b-f67c3dd8c61f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c04d719-c091-4c2b-b4a4-ee303ba6dec0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e0375b7b-c026-49b9-b882-edc0916fe445",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}