resNet50.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[1m21s\u001b[0m 2s/step - accuracy: 0.2349 - loss: 1.9362 - val_accuracy: 0.2867 - val_loss: 1.6123\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[1m21s\u001b[0m 2s/step - accuracy: 0.2171 - loss: 1.9120 - val_accuracy: 0.2333 - val_loss: 1.5662\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[1m22s\u001b[0m 2s/step - accuracy: 0.1846 - loss: 2.0543 - val_accuracy: 0.2067 - val_loss: 1.6211\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[1m22s\u001b[0m 2s/step - accuracy: 0.2277 - loss: 2.0858 - val_accuracy: 0.1933 - val_loss: 1.5860\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[1m22s\u001b[0m 2s/step - accuracy: 0.2091 - loss: 1.8088 - val_accuracy: 0.2933 - val_loss: 1.5744\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[1m23s\u001b[0m 2s/step - accuracy: 0.1714 - loss: 2.0463 - val_accuracy: 0.2267 - val_loss: 1.5845\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[1m24s\u001b[0m 2s/step - accuracy: 0.1984 - loss: 2.0496 - val_accuracy: 0.3467 - val_loss: 1.5511\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[1m22s\u001b[0m 2s/step - accuracy: 0.1608 - loss: 1.9322 - val_accuracy: 0.2333 - val_loss: 1.5873\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[1m21s\u001b[0m 2s/step - accuracy: 0.1854 - loss: 2.0450 - val_accuracy: 0.2333 - val_loss: 1.5936\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[1m23s\u001b[0m 2s/step - accuracy: 0.2627 - loss: 1.8215 - val_accuracy: 0.2333 - val_loss: 1.6949\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[1m23s\u001b[0m 2s/step - accuracy: 0.2337 - loss: 1.8811 - val_accuracy: 0.2200 - val_loss: 1.6159\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[1m22s\u001b[0m 2s/step - accuracy: 0.1757 - loss: 2.0238 - val_accuracy: 0.2533 - val_loss: 1.6029\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[1m22s\u001b[0m 2s/step - accuracy: 0.1980 - loss: 2.1386 - val_accuracy: 0.2800 - val_loss: 1.6956\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[1m23s\u001b[0m 2s/step - accuracy: 0.1674 - loss: 1.9552 - val_accuracy: 0.3133 - val_loss: 1.5393\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[1m22s\u001b[0m 2s/step - accuracy: 0.2561 - loss: 1.8780 - val_accuracy: 0.1867 - val_loss: 1.5714\n",
      "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 1s/step - accuracy: 0.1759 - loss: 1.5719\n",
      "Test accuracy: 0.18666666746139526\n",
      "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 1s/step\n",
      "Classification Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.21      0.10      0.14        39\n",
      "           1       0.15      0.87      0.26        23\n",
      "           2       0.00      0.00      0.00        26\n",
      "           3       0.00      0.00      0.00        31\n",
      "           4       0.00      0.00      0.00        31\n",
      "\n",
      "    accuracy                           0.16       150\n",
      "   macro avg       0.07      0.19      0.08       150\n",
      "weighted avg       0.08      0.16      0.08       150\n",
      "\n",
      "Confusion Matrix:\n",
      "[[ 4 35  0  0  0]\n",
      " [ 3 20  0  0  0]\n",
      " [ 3 23  0  0  0]\n",
      " [ 5 26  0  0  0]\n",
      " [ 4 27  0  0  0]]\n",
      "F1-Score (Macro): 0.07953425884460368\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/lib/python3.11/site-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n",
      "/opt/anaconda3/lib/python3.11/site-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n",
      "/opt/anaconda3/lib/python3.11/site-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow.keras.applications import ResNet50\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",
    "\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 = 15\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 ResNet50 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 ResNet50 expects a different size\n",
    "      class_mode=\"categorical\",\n",
    "      batch_size=32\n",
    "      \n",
    "  )\n",
    "\n",
    "  # Load ResNet50 with minimal training (lowers accuracy)\n",
    "  resnet_model = ResNet50(weights='imagenet', include_top=False, input_shape=(224, 224, 3))\n",
    "  resnet_model.trainable = False  \n",
    "\n",
    "  # Create a new model using model2 as input\n",
    "  model3 = Sequential([\n",
    "      resnet_model,\n",
    "      GlobalAveragePooling2D(),\n",
    "      Dense(128, activation='relu'),\n",
    "      Dropout(0.5),\n",
    "      Dense(5, activation='softmax')\n",
    "  ])\n",
    "\n",
    "  model3.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",
    "  history3 = model3.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",
    "# Extract training and validation accuracy from history after each epoch\n",
    "  train_acc.append(history3.history['accuracy'][0])\n",
    "  val_acc.append(history3.history['val_accuracy'][0])\n",
    "\n",
    "\n",
    "  train_loss.append(history3.history['loss'][0])\n",
    "  val_loss.append(history3.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",
    " \n",
    "# Evaluate the model on the test set\n",
    "test_loss, test_acc = model3.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(model3.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"
   ]
  },
  {
   "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": "396a6c45-57ac-4a43-a3fc-3193ebf4dcdb",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "764625bd-0146-4819-a66f-7a1a052a40c2",
   "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
}