{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "bcb40fd4-6eba-4a87-8ede-cc3b8e14bf55",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "import os\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, classification_report, confusion_matrix\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras import layers, models\n",
    "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
    "from tensorflow.keras.applications import MobileNet, InceptionV3, ResNet50\n",
    "from tensorflow.keras.applications.mobilenet import preprocess_input as mobilenet_preprocess\n",
    "from tensorflow.keras.applications.inception_v3 import preprocess_input as inception_preprocess\n",
    "from tensorflow.keras.applications.resnet50 import preprocess_input as resnet_preprocess\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "139a7eed-1899-4e3d-b7e9-7dc86119f4ee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    N   P   K  temperature   humidity        ph    rainfall  \\\n",
      "0  90  42  43    20.879744  82.002744  6.502985  202.935536   \n",
      "1  90  42  43    20.879744  82.002744  6.502985  202.935536   \n",
      "2  90  42  43    20.879744  82.002744  6.502985  202.935536   \n",
      "3  90  42  43    20.879744  82.002744  6.502985  202.935536   \n",
      "4  90  42  43    20.879744  82.002744  6.502985  202.935536   \n",
      "\n",
      "         Mapped Label                                         Image Path  \\\n",
      "0  Apple___Apple_scab  color\\Apple___Apple_scab\\00075aa8-d81a-4184-85...   \n",
      "1  Apple___Apple_scab  color\\Apple___Apple_scab\\01a66316-0e98-4d3b-a5...   \n",
      "2  Apple___Apple_scab  color\\Apple___Apple_scab\\01f3deaa-6143-4b6c-9c...   \n",
      "3  Apple___Apple_scab  color\\Apple___Apple_scab\\0208f4eb-45a4-4399-90...   \n",
      "4  Apple___Apple_scab  color\\Apple___Apple_scab\\023123cb-7b69-4c9f-a5...   \n",
      "\n",
      "                Label  \n",
      "0  Apple___Apple_scab  \n",
      "1  Apple___Apple_scab  \n",
      "2  Apple___Apple_scab  \n",
      "3  Apple___Apple_scab  \n",
      "4  Apple___Apple_scab  \n",
      "Index(['N', 'P', 'K', 'temperature', 'humidity', 'ph', 'rainfall',\n",
      "       'Mapped Label', 'Image Path', 'Label'],\n",
      "      dtype='object')\n",
      "0    /Users/fm/Desktop/Project AI901/color/Apple___...\n",
      "1    /Users/fm/Desktop/Project AI901/color/Apple___...\n",
      "2    /Users/fm/Desktop/Project AI901/color/Apple___...\n",
      "3    /Users/fm/Desktop/Project AI901/color/Apple___...\n",
      "4    /Users/fm/Desktop/Project AI901/color/Apple___...\n",
      "Name: image_path, dtype: object\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# Load CSV file\n",
    "csv_path = \"/Users/fm/Desktop/Project AI901/plant_disease_multimodal_dataset.csv\"\n",
    "df = pd.read_csv(csv_path)\n",
    "\n",
    "# Show first rows\n",
    "print(df.head())\n",
    "print(df.columns)\n",
    "\n",
    "# Base folder where images are stored\n",
    "images_dir = \"/Users/fm/Desktop/Project AI901\"  \n",
    "\n",
    "# Create new column with full path and forward slashes\n",
    "df['image_path'] = df['Image Path'].apply(lambda x: os.path.join(images_dir, x.replace(\"\\\\\", \"/\")))\n",
    "\n",
    "# Test first 5 paths\n",
    "print(df['image_path'].head())\n",
    "\n",
    "# Check if files exist\n",
    "print(os.path.exists(df['image_path'].iloc[0]))  # Should return True\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "eeb7ce9f-f214-430e-a9fd-a2c89762866e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train: (27999, 11) Validation: (4001, 11) Test: (8000, 11)\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# SPLIT DATA\n",
    "\n",
    "train_ratio, validation_ratio, test_ratio = 0.7, 0.1, 0.2\n",
    "\n",
    "train_val_ratio = train_ratio + validation_ratio  # 0.8\n",
    "\n",
    "# Split into train_val and test\n",
    "train_val_df, test_df = train_test_split(\n",
    "    df,\n",
    "    test_size=test_ratio,\n",
    "    stratify=df[\"Label\"],\n",
    "    random_state=42\n",
    ")\n",
    "\n",
    "# Split train_val into train and validation\n",
    "val_size = validation_ratio / train_val_ratio  # 0.1/0.8 = 0.125\n",
    "train_df, val_df = train_test_split(\n",
    "    train_val_df,\n",
    "    test_size=val_size,\n",
    "    stratify=train_val_df[\"Label\"],\n",
    "    random_state=42\n",
    ")\n",
    "\n",
    "print(\"Train:\", train_df.shape, \"Validation:\", val_df.shape, \"Test:\", test_df.shape)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "dec26ab8-7c11-4d10-bd46-b97b8f5a1c25",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 27999 validated image filenames belonging to 4 classes.\n",
      "Found 4001 validated image filenames belonging to 4 classes.\n",
      "Found 8000 validated image filenames belonging to 4 classes.\n",
      "Found 27999 validated image filenames belonging to 4 classes.\n",
      "Found 4001 validated image filenames belonging to 4 classes.\n",
      "Found 8000 validated image filenames belonging to 4 classes.\n",
      "Found 27999 validated image filenames belonging to 4 classes.\n",
      "Found 4001 validated image filenames belonging to 4 classes.\n",
      "Found 8000 validated image filenames belonging to 4 classes.\n"
     ]
    }
   ],
   "source": [
    "#  CREATE GENERATORS FOR ALL MODELS\n",
    "\n",
    "image_size = (224, 224)\n",
    "batch_size = 32\n",
    "\n",
    "def create_generators_all_models(train_df, val_df, test_df):\n",
    "    \"\"\"\n",
    "    Create train, validation, test generators for MobileNet, InceptionV3, and ResNet50.\n",
    "    Each model gets the correct preprocessing function.\n",
    "    \"\"\"\n",
    "    train_datagen = ImageDataGenerator(\n",
    "        rotation_range=20,\n",
    "        width_shift_range=0.1,\n",
    "        height_shift_range=0.1,\n",
    "        horizontal_flip=True\n",
    "    )\n",
    "    val_test_datagen = ImageDataGenerator()\n",
    "\n",
    "    generators = {}\n",
    "\n",
    "    def make_gen(df, datagen, preprocess_fn):\n",
    "        return datagen.flow_from_dataframe(\n",
    "            dataframe=df,\n",
    "            x_col='image_path',\n",
    "            y_col='Label',\n",
    "            target_size=image_size,\n",
    "            batch_size=batch_size,\n",
    "            class_mode='categorical',\n",
    "            shuffle=True if datagen==train_datagen else False,\n",
    "            preprocessing_function=preprocess_fn,\n",
    "            color_mode='rgb'\n",
    "        )\n",
    "\n",
    "    # MobileNet generators\n",
    "    generators['mobilenet'] = {\n",
    "        'train': make_gen(train_df, train_datagen, mobilenet_preprocess),\n",
    "        'val': make_gen(val_df, val_test_datagen, mobilenet_preprocess),\n",
    "        'test': make_gen(test_df, val_test_datagen, mobilenet_preprocess)\n",
    "    }\n",
    "\n",
    "    # InceptionV3 generators\n",
    "    generators['inception'] = {\n",
    "        'train': make_gen(train_df, train_datagen, inception_preprocess),\n",
    "        'val': make_gen(val_df, val_test_datagen, inception_preprocess),\n",
    "        'test': make_gen(test_df, val_test_datagen, inception_preprocess)\n",
    "    }\n",
    "\n",
    "    # ResNet50 generators\n",
    "    generators['resnet'] = {\n",
    "        'train': make_gen(train_df, train_datagen, resnet_preprocess),\n",
    "        'val': make_gen(val_df, val_test_datagen, resnet_preprocess),\n",
    "        'test': make_gen(test_df, val_test_datagen, resnet_preprocess)\n",
    "    }\n",
    "\n",
    "    return generators\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f153f3bd-92db-49d0-8e97-722f2cbe151a",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# 5. BUILD MODEL FUNCTION\n",
    "\n",
    "def build_model(base_model, preprocess_fn, num_classes):\n",
    "    \"\"\"\n",
    "    Build a transfer learning model with a given base model.\n",
    "    \"\"\"\n",
    "    base = base_model(include_top=False, weights=\"imagenet\", input_shape=(image_size[0], image_size[1], 3))\n",
    "    base.trainable = False\n",
    "\n",
    "    inputs = layers.Input(shape=(image_size[0], image_size[1], 3))\n",
    "    x = preprocess_fn(inputs)\n",
    "    x = base(x, training=False)\n",
    "    x = layers.GlobalAveragePooling2D()(x)\n",
    "    x = layers.Dropout(0.5)(x)\n",
    "    outputs = layers.Dense(num_classes, activation=\"softmax\")(x)\n",
    "\n",
    "    model = models.Model(inputs, outputs)\n",
    "    model.compile(optimizer=\"adam\", loss=\"categorical_crossentropy\", metrics=[\"accuracy\"])\n",
    "    return model\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "f08326c0-0049-45cb-93dd-16406553fa4d",
   "metadata": {},
   "outputs": [],
   "source": [
    "num_classes = train_df[\"Label\"].nunique()\n",
    "\n",
    "mobilenet_model = build_model(MobileNet, mobilenet_preprocess, num_classes)\n",
    "inception_model = build_model(InceptionV3, inception_preprocess, num_classes)\n",
    "resnet_model = build_model(ResNet50, resnet_preprocess, num_classes)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "43d0a662-616a-4db9-a884-599c08388e8a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/lib/python3.12/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": [
      "Epoch 1/3\n",
      "\u001b[1m875/875\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m588s\u001b[0m 669ms/step - accuracy: 0.9319 - loss: 0.1916 - val_accuracy: 1.0000 - val_loss: 0.0146\n",
      "Epoch 2/3\n",
      "\u001b[1m875/875\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m608s\u001b[0m 695ms/step - accuracy: 0.9868 - loss: 0.0432 - val_accuracy: 1.0000 - val_loss: 0.0065\n",
      "Epoch 3/3\n",
      "\u001b[1m875/875\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m679s\u001b[0m 776ms/step - accuracy: 0.9908 - loss: 0.0303 - val_accuracy: 1.0000 - val_loss: 0.0041\n",
      "Epoch 1/3\n",
      "\u001b[1m875/875\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1410s\u001b[0m 2s/step - accuracy: 0.8818 - loss: 0.3160 - val_accuracy: 0.9815 - val_loss: 0.0897\n",
      "Epoch 2/3\n",
      "\u001b[1m875/875\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1182s\u001b[0m 1s/step - accuracy: 0.9451 - loss: 0.1510 - val_accuracy: 0.9778 - val_loss: 0.0756\n",
      "Epoch 3/3\n",
      "\u001b[1m875/875\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1049s\u001b[0m 1s/step - accuracy: 0.9500 - loss: 0.1359 - val_accuracy: 0.9953 - val_loss: 0.0388\n",
      "Epoch 1/3\n",
      "\u001b[1m875/875\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1753s\u001b[0m 2s/step - accuracy: 0.9551 - loss: 0.1381 - val_accuracy: 0.9978 - val_loss: 0.0132\n",
      "Epoch 2/3\n",
      "\u001b[1m875/875\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1661s\u001b[0m 2s/step - accuracy: 0.9926 - loss: 0.0293 - val_accuracy: 1.0000 - val_loss: 0.0041\n",
      "Epoch 3/3\n",
      "\u001b[1m875/875\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1734s\u001b[0m 2s/step - accuracy: 0.9954 - loss: 0.0182 - val_accuracy: 1.0000 - val_loss: 0.0031\n"
     ]
    }
   ],
   "source": [
    "# MobileNet\n",
    "history_mobilenet = mobilenet_model.fit(\n",
    "    generators['mobilenet']['train'],\n",
    "    epochs=3,\n",
    "    validation_data=generators['mobilenet']['val']\n",
    ")\n",
    "\n",
    "# InceptionV3\n",
    "history_inception = inception_model.fit(\n",
    "    generators['inception']['train'],\n",
    "    epochs=3,\n",
    "    validation_data=generators['inception']['val']\n",
    ")\n",
    "\n",
    "# ResNet50\n",
    "history_resnet = resnet_model.fit(\n",
    "    generators['resnet']['train'],\n",
    "    epochs=3,\n",
    "    validation_data=generators['resnet']['val']\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "6756f4f5-43c0-48e8-8088-d78d62f727a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MobileNet test samples: 8000\n",
      "InceptionV3 test samples: 8000\n",
      "ResNet50 test samples: 8000\n"
     ]
    }
   ],
   "source": [
    "# Access test generators from the dictionary\n",
    "test_gen_mobilenet = generators['mobilenet']['test']\n",
    "test_gen_inception = generators['inception']['test']\n",
    "test_gen_resnet = generators['resnet']['test']\n",
    "\n",
    "# Check number of samples\n",
    "print(\"MobileNet test samples:\", test_gen_mobilenet.samples)\n",
    "print(\"InceptionV3 test samples:\", test_gen_inception.samples)\n",
    "print(\"ResNet50 test samples:\", test_gen_resnet.samples)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "bd831f66-e5cf-4937-9477-ffa8ea363472",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "===== Evaluating MobileNet =====\n",
      "Number of test samples: 8000\n",
      "\u001b[1m250/250\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m142s\u001b[0m 566ms/step\n",
      "\n",
      "Evaluation Time: 142.60 seconds\n",
      "Accuracy: 1.0\n",
      "Precision: 1.0\n",
      "Recall: 1.0\n",
      "F1-score: 1.0\n",
      "\n",
      "Classification Report:\n",
      "                          precision    recall  f1-score   support\n",
      "\n",
      "      Apple___Apple_scab       1.00      1.00      1.00      2000\n",
      "       Apple___Black_rot       1.00      1.00      1.00      2000\n",
      "Apple___Cedar_apple_rust       1.00      1.00      1.00      2000\n",
      "         Apple___healthy       1.00      1.00      1.00      2000\n",
      "\n",
      "                accuracy                           1.00      8000\n",
      "               macro avg       1.00      1.00      1.00      8000\n",
      "            weighted avg       1.00      1.00      1.00      8000\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "===== Evaluating InceptionV3 =====\n",
      "Number of test samples: 8000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/lib/python3.12/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[1m250/250\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m261s\u001b[0m 1s/step\n",
      "\n",
      "Evaluation Time: 261.49 seconds\n",
      "Accuracy: 0.9915\n",
      "Precision: 0.9916725084000096\n",
      "Recall: 0.9915\n",
      "F1-score: 0.9914989777214656\n",
      "\n",
      "Classification Report:\n",
      "                          precision    recall  f1-score   support\n",
      "\n",
      "      Apple___Apple_scab       1.00      0.99      1.00      2000\n",
      "       Apple___Black_rot       0.98      1.00      0.99      2000\n",
      "Apple___Cedar_apple_rust       0.99      1.00      1.00      2000\n",
      "         Apple___healthy       1.00      0.97      0.99      2000\n",
      "\n",
      "                accuracy                           0.99      8000\n",
      "               macro avg       0.99      0.99      0.99      8000\n",
      "            weighted avg       0.99      0.99      0.99      8000\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "===== Evaluating ResNet50 =====\n",
      "Number of test samples: 8000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/lib/python3.12/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[1m250/250\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m407s\u001b[0m 2s/step\n",
      "\n",
      "Evaluation Time: 406.92 seconds\n",
      "Accuracy: 1.0\n",
      "Precision: 1.0\n",
      "Recall: 1.0\n",
      "F1-score: 1.0\n",
      "\n",
      "Classification Report:\n",
      "                          precision    recall  f1-score   support\n",
      "\n",
      "      Apple___Apple_scab       1.00      1.00      1.00      2000\n",
      "       Apple___Black_rot       1.00      1.00      1.00      2000\n",
      "Apple___Cedar_apple_rust       1.00      1.00      1.00      2000\n",
      "         Apple___healthy       1.00      1.00      1.00      2000\n",
      "\n",
      "                accuracy                           1.00      8000\n",
      "               macro avg       1.00      1.00      1.00      8000\n",
      "            weighted avg       1.00      1.00      1.00      8000\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import time\n",
    "import numpy as np\n",
    "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, classification_report, confusion_matrix\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "def evaluate_model(model, test_gen, model_name=\"Model\"):\n",
    "    \"\"\"\n",
    "    Evaluate a model on a test generator and print metrics with confusion matrix.\n",
    "    \"\"\"\n",
    "    print(f\"\\n===== Evaluating {model_name} =====\")\n",
    "    print(f\"Number of test samples: {test_gen.samples}\")\n",
    "    \n",
    "    start_time = time.time()\n",
    "    y_pred = model.predict(test_gen, verbose=1)\n",
    "    end_time = time.time()\n",
    "    \n",
    "    y_true = test_gen.classes\n",
    "    y_pred_classes = np.argmax(y_pred, axis=1)\n",
    "    \n",
    "    labels = list(test_gen.class_indices.keys())\n",
    "    \n",
    "    print(f\"\\nEvaluation Time: {end_time - start_time:.2f} seconds\")\n",
    "    print(\"Accuracy:\", accuracy_score(y_true, y_pred_classes))\n",
    "    print(\"Precision:\", precision_score(y_true, y_pred_classes, average='weighted'))\n",
    "    print(\"Recall:\", recall_score(y_true, y_pred_classes, average='weighted'))\n",
    "    print(\"F1-score:\", f1_score(y_true, y_pred_classes, average='weighted'))\n",
    "    print(\"\\nClassification Report:\")\n",
    "    print(classification_report(y_true, y_pred_classes, target_names=labels))\n",
    "    \n",
    "    # Confusion Matrix\n",
    "    cm = confusion_matrix(y_true, y_pred_classes)\n",
    "    plt.figure(figsize=(8,6))\n",
    "    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=labels, yticklabels=labels)\n",
    "    plt.xlabel(\"Predicted Label\")\n",
    "    plt.ylabel(\"True Label\")\n",
    "    plt.title(f\"{model_name} Confusion Matrix\")\n",
    "    plt.show()\n",
    "\n",
    "# ==========================\n",
    "# Call evaluation for all models\n",
    "# ==========================\n",
    "evaluate_model(mobilenet_model, generators['mobilenet']['test'], \"MobileNet\")\n",
    "evaluate_model(inception_model, generators['inception']['test'], \"InceptionV3\")\n",
    "evaluate_model(resnet_model, generators['resnet']['test'], \"ResNet50\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "3e3a0203-caed-4cf1-a965-a15ddda9eb35",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "⚠️ Found 400 duplicate image(s) between train and test sets!\n",
      "Example duplicates: ['/Users/fm/Desktop/Project AI901/color/Apple___Cedar_apple_rust/17b9f64c-4660-424f-9c8e-d9a49654e512___FREC_C.Rust 3776.JPG', '/Users/fm/Desktop/Project AI901/color/Apple___Cedar_apple_rust/42bbd61a-bfa0-4adf-a064-407165f70ecf___FREC_C.Rust 4199.JPG', '/Users/fm/Desktop/Project AI901/color/Apple___Black_rot/0c7c7992-fb1c-444b-b226-69de186cea14___JR_FrgE.S 8627.JPG', '/Users/fm/Desktop/Project AI901/color/Apple___Black_rot/1021c460-93e4-48cd-9c84-c576b2c5117c___JR_FrgE.S 2983.JPG', '/Users/fm/Desktop/Project AI901/color/Apple___Cedar_apple_rust/1a69060b-e45e-4d95-881c-f6d1960dffcd___FREC_C.Rust 0065.JPG', '/Users/fm/Desktop/Project AI901/color/Apple___Cedar_apple_rust/4dc8e2a8-4374-488a-afc6-fd0ea7f15c88___FREC_C.Rust 3991.JPG', '/Users/fm/Desktop/Project AI901/color/Apple___healthy/0d01a8a3-9faa-4a1f-afe0-be6bffa42056___RS_HL 6204.JPG', '/Users/fm/Desktop/Project AI901/color/Apple___Black_rot/04de1246-ecfa-4d2c-bc2d-16b81b0bd364___JR_FrgE.S 2970.JPG', '/Users/fm/Desktop/Project AI901/color/Apple___Cedar_apple_rust/5271addc-c445-4af1-ba68-318c7b509e1f___FREC_C.Rust 3585.JPG', '/Users/fm/Desktop/Project AI901/color/Apple___Cedar_apple_rust/5069c246-1254-4396-a0f3-11bb6becd234___FREC_C.Rust 9868.JPG']\n"
     ]
    }
   ],
   "source": [
    "# Check for duplicates between train and test sets\n",
    "train_paths = set(train_df['image_path'])\n",
    "test_paths = set(test_df['image_path'])\n",
    "\n",
    "# Find intersection\n",
    "duplicates = train_paths.intersection(test_paths)\n",
    "\n",
    "if len(duplicates) == 0:\n",
    "    print(\"✅ No duplicates found between train and test sets.\")\n",
    "else:\n",
    "    print(f\"⚠️ Found {len(duplicates)} duplicate image(s) between train and test sets!\")\n",
    "    print(\"Example duplicates:\", list(duplicates)[:10])  # show first 10 duplicates\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "e256301a-33b9-4e72-b632-37290f296c47",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Removed 400 duplicate image(s) from the training set.\n"
     ]
    }
   ],
   "source": [
    "# Remove duplicates from train set\n",
    "duplicates = train_paths.intersection(test_paths)\n",
    "if duplicates:\n",
    "    train_df = train_df[~train_df['image_path'].isin(duplicates)]\n",
    "    print(f\"Removed {len(duplicates)} duplicate image(s) from the training set.\")\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python (tf_env)",
   "language": "python",
   "name": "tf_env"
  },
  "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.12.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}