initial upload

train.ipynb

@@ -0,0 +1,797 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "c8VSns6fO6Pg"
+      },
+      "source": [
+        "**Seeding for reproducibility**"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 20,
+      "metadata": {
+        "id": "JSu8kpnEHDPB"
+      },
+      "outputs": [],
+      "source": [
+        "# Set seeds for reproducibility\n",
+        "import random\n",
+        "random.seed(0)\n",
+        "\n",
+        "import numpy as np\n",
+        "np.random.seed(0)\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 21,
+      "metadata": {
+        "id": "16dILovOOFy0"
+      },
+      "outputs": [],
+      "source": [
+        "import os\n",
+        "import json\n",
+        "from PIL import Image\n",
+        "\n",
+        "import tensorflow as tf\n",
+        "import cv2\n",
+        "import numpy as np\n",
+        "import matplotlib.pyplot as plt\n",
+        "import matplotlib.image as mpimg\n",
+        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
+        "from tensorflow.keras import layers, models"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "7gAnTOlEPR8a"
+      },
+      "source": [
+        "**Data Curation**"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "GT4tQUqBs90l"
+      },
+      "source": [
+        "Upload the kaggle.json file"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "FKWvyGVDtALx",
+        "outputId": "f565ec66-6b79-4d7f-ce6f-ecb12f388e37"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Requirement already satisfied: mpimg in c:\\users\\lenovo\\miniconda3\\envs\\tf\\lib\\site-packages (0.0.1)\n",
+            "Requirement already satisfied: kaggle in c:\\users\\lenovo\\miniconda3\\envs\\tf\\lib\\site-packages (1.6.14)\n",
+            "Requirement already satisfied: click in c:\\users\\lenovo\\miniconda3\\envs\\tf\\lib\\site-packages (from mpimg) (8.1.7)\n",
+            "Requirement already satisfied: pillow in c:\\users\\lenovo\\miniconda3\\envs\\tf\\lib\\site-packages (from mpimg) (10.2.0)\n",
+            "Requirement already satisfied: six>=1.10 in c:\\users\\lenovo\\miniconda3\\envs\\tf\\lib\\site-packages (from kaggle) (1.16.0)\n",
+            "Requirement already satisfied: certifi>=2023.7.22 in c:\\users\\lenovo\\miniconda3\\envs\\tf\\lib\\site-packages (from kaggle) (2023.7.22)\n",
+            "Requirement already satisfied: python-dateutil in c:\\users\\lenovo\\miniconda3\\envs\\tf\\lib\\site-packages (from kaggle) (2.8.2)\n",
+            "Requirement already satisfied: requests in c:\\users\\lenovo\\miniconda3\\envs\\tf\\lib\\site-packages (from kaggle) (2.31.0)\n",
+            "Requirement already satisfied: tqdm in c:\\users\\lenovo\\miniconda3\\envs\\tf\\lib\\site-packages (from kaggle) (4.66.2)\n",
+            "Requirement already satisfied: python-slugify in c:\\users\\lenovo\\miniconda3\\envs\\tf\\lib\\site-packages (from kaggle) (8.0.4)\n",
+            "Requirement already satisfied: urllib3 in c:\\users\\lenovo\\miniconda3\\envs\\tf\\lib\\site-packages (from kaggle) (2.1.0)\n",
+            "Requirement already satisfied: bleach in c:\\users\\lenovo\\miniconda3\\envs\\tf\\lib\\site-packages (from kaggle) (6.1.0)\n",
+            "Requirement already satisfied: webencodings in c:\\users\\lenovo\\miniconda3\\envs\\tf\\lib\\site-packages (from bleach->kaggle) (0.5.1)\n",
+            "Requirement already satisfied: colorama in c:\\users\\lenovo\\miniconda3\\envs\\tf\\lib\\site-packages (from click->mpimg) (0.4.6)\n",
+            "Requirement already satisfied: text-unidecode>=1.3 in c:\\users\\lenovo\\miniconda3\\envs\\tf\\lib\\site-packages (from python-slugify->kaggle) (1.3)\n",
+            "Requirement already satisfied: charset-normalizer<4,>=2 in c:\\users\\lenovo\\miniconda3\\envs\\tf\\lib\\site-packages (from requests->kaggle) (3.3.2)\n",
+            "Requirement already satisfied: idna<4,>=2.5 in c:\\users\\lenovo\\miniconda3\\envs\\tf\\lib\\site-packages (from requests->kaggle) (2.10)\n"
+          ]
+        }
+      ],
+      "source": [
+        "!pip install mpimg kaggle"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "metadata": {
+        "id": "ZM5gnAAVtH0s"
+      },
+      "outputs": [],
+      "source": [
+        "kaggle_credentails = json.load(open(\"kaggle.json\"))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 22,
+      "metadata": {
+        "id": "xWS6H5mPtNa_"
+      },
+      "outputs": [],
+      "source": [
+        "# setup Kaggle API key as environment variables\n",
+        "os.environ['KAGGLE_USERNAME'] = kaggle_credentails[\"username\"]\n",
+        "os.environ['KAGGLE_KEY'] = kaggle_credentails[\"key\"]"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 23,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "ypPVDLobtUr5",
+        "outputId": "53a70f81-a8ed-4287-f1f5-678b465142d0"
+      },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "'kaggle' is not recognized as an internal or external command,\n",
+            "operable program or batch file.\n"
+          ]
+        }
+      ],
+      "source": [
+        "!kaggle datasets download -d abdallahalidev/plantvillage-dataset"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 24,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "20t7J2zctdou",
+        "outputId": "71e8ea49-eac0-4f1f-b13c-f59595733d41"
+      },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "'ls' is not recognized as an internal or external command,\n",
+            "operable program or batch file.\n"
+          ]
+        }
+      ],
+      "source": [
+        "!ls"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 25,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "A_5Oa9WPtfXr",
+        "outputId": "79a1b2c7-ca9c-4a89-febe-17abc7f399d3"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "['color', 'grayscale', 'segmented']\n",
+            "['loh(1).JPG', 'loh(10).JPG', 'loh(100).JPG', 'loh(101).JPG', 'loh(102).JPG']\n"
+          ]
+        }
+      ],
+      "source": [
+        "print(os.listdir(\"plantvillage dataset\"))\n",
+        "\n",
+        "\n",
+        "#print(len(os.listdir(\"plantvillage dataset/segmented\")))\n",
+        "#print(os.listdir(\"plantvillage dataset/segmented\")[:5])\n",
+        "\n",
+        "#print(len(os.listdir(\"plantvillage dataset/color\")))\n",
+        "#print(os.listdir(\"plantvillage dataset/color\")[:5])\n",
+        "\n",
+        "#print(len(os.listdir(\"plantvillage dataset/grayscale\")))\n",
+        "#print(os.listdir(\"plantvillage dataset/grayscale\")[:5])\n",
+        "\n",
+        "print((os.listdir(\"wheat_dataset/Healthy\")[:5]))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "snyC_-2jt0z3"
+      },
+      "source": [
+        "**Number of Classes = 38**"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 26,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "CFR52Pk6tp2U",
+        "outputId": "4917ce76-17f2-4103-85ca-14d2af84dc06"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "423\n",
+            "['00e00912-bf75-4cf8-8b7d-ad64b73bea5f___Mt.N.V_HL 6067.JPG', '0163a6aa-fbf8-47c5-965f-59b6efe8bfe5___Mt.N.V_HL 6103.JPG', '0294ca65-4c29-44be-af28-501df9f715e8___Mt.N.V_HL 6176.JPG', '02f95acb-5d92-4f2a-b7ec-3af8709ee7c9___Mt.N.V_HL 9078.JPG', '03027791-26bb-4c46-960e-8df76e27042c___Mt.N.V_HL 6070.JPG']\n"
+          ]
+        }
+      ],
+      "source": [
+        "print(len(os.listdir(\"plantvillage dataset/color/Grape___healthy\")))\n",
+        "print(os.listdir(\"plantvillage dataset/color/Grape___healthy\")[:5])"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "JhEi6mbpt4aD"
+      },
+      "source": [
+        "**Data Preprocessing**"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 27,
+      "metadata": {
+        "id": "WlqvsdtBttrh"
+      },
+      "outputs": [],
+      "source": [
+        "# Dataset Path\n",
+        "base_dir = 'wheat_dataset'"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 28,
+      "metadata": {
+        "id": "w6S1jYo0u5o-"
+      },
+      "outputs": [],
+      "source": [
+        "# Image Parameters\n",
+        "img_size = 224\n",
+        "batch_size = 32"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Lcovy3vxvf31"
+      },
+      "source": [
+        "**Train Test Split**"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 29,
+      "metadata": {
+        "id": "zoJjajTcvTae"
+      },
+      "outputs": [],
+      "source": [
+        "# Image Data Generators\n",
+        "data_gen = ImageDataGenerator(\n",
+        "    rescale=1./255,\n",
+        "    validation_split=0.2  # Use 20% of data for validation\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 30,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "pnwsA5IPvWNG",
+        "outputId": "be155ed6-aa77-4f28-c202-94fba6ea59bd"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Found 327 images belonging to 3 classes.\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Train Generator\n",
+        "train_generator = data_gen.flow_from_directory(\n",
+        "    base_dir,\n",
+        "    target_size=(img_size, img_size),\n",
+        "    batch_size=batch_size,\n",
+        "    subset='training',\n",
+        "    class_mode='categorical'\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 31,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "RtxNLvmbvYNX",
+        "outputId": "a60d0b2a-bba4-4595-d5e1-e9f6978ddbab"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Found 80 images belonging to 3 classes.\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Validation Generator\n",
+        "validation_generator = data_gen.flow_from_directory(\n",
+        "    base_dir,\n",
+        "    target_size=(img_size, img_size),\n",
+        "    batch_size=batch_size,\n",
+        "    subset='validation',\n",
+        "    class_mode='categorical'\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "fE4vUKMkviT8"
+      },
+      "source": [
+        "**Convolutional Neural Network**"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 32,
+      "metadata": {
+        "id": "VUsvwveevZ-m"
+      },
+      "outputs": [],
+      "source": [
+        "# Model Definition\n",
+        "model = models.Sequential()\n",
+        "\n",
+        "model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(img_size, img_size, 3)))\n",
+        "model.add(layers.MaxPooling2D(2, 2))\n",
+        "\n",
+        "model.add(layers.Conv2D(64, (3, 3), activation='relu'))\n",
+        "model.add(layers.MaxPooling2D(2, 2))\n",
+        "\n",
+        "model.add(layers.Flatten())\n",
+        "model.add(layers.Dense(256, activation='relu'))\n",
+        "model.add(layers.Dense(train_generator.num_classes, activation='softmax'))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 33,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "T9qJo-GSvoIB",
+        "outputId": "56ed059c-85f2-4490-8dfc-63e25516d2ea"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Model: \"sequential_1\"\n",
+            "_________________________________________________________________\n",
+            " Layer (type)                Output Shape              Param #   \n",
+            "=================================================================\n",
+            " conv2d_4 (Conv2D)           (None, 222, 222, 32)      896       \n",
+            "                                                                 \n",
+            " max_pooling2d_4 (MaxPooling  (None, 111, 111, 32)     0         \n",
+            " 2D)                                                             \n",
+            "                                                                 \n",
+            " conv2d_5 (Conv2D)           (None, 109, 109, 64)      18496     \n",
+            "                                                                 \n",
+            " max_pooling2d_5 (MaxPooling  (None, 54, 54, 64)       0         \n",
+            " 2D)                                                             \n",
+            "                                                                 \n",
+            " flatten_1 (Flatten)         (None, 186624)            0         \n",
+            "                                                                 \n",
+            " dense_2 (Dense)             (None, 256)               47776000  \n",
+            "                                                                 \n",
+            " dense_3 (Dense)             (None, 3)                 771       \n",
+            "                                                                 \n",
+            "=================================================================\n",
+            "Total params: 47,796,163\n",
+            "Trainable params: 47,796,163\n",
+            "Non-trainable params: 0\n",
+            "_________________________________________________________________\n"
+          ]
+        }
+      ],
+      "source": [
+        "# model summary\n",
+        "model.summary()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 34,
+      "metadata": {
+        "id": "PKi-ot0xvpC8"
+      },
+      "outputs": [],
+      "source": [
+        "# Compile the Model\n",
+        "model.compile(optimizer='adam',\n",
+        "              loss='categorical_crossentropy',\n",
+        "              metrics=['accuracy'])\n",
+        "gpus = tf.config.experimental.list_physical_devices('GPU')\n",
+        "for gpu in gpus:\n",
+        "    tf.config.experimental.set_memory_growth(gpu, False)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 35,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "bSvHhJqevyjE",
+        "outputId": "51052757-e403-4ed0-87b0-42ff1ff6451b"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Physical devices cannot be modified after being initialized\n",
+            "Epoch 1/5\n",
+            "10/10 [==============================] - 30s 3s/step - loss: 4.1255 - accuracy: 0.4508 - val_loss: 0.7565 - val_accuracy: 0.6094\n",
+            "Epoch 2/5\n",
+            "10/10 [==============================] - 25s 3s/step - loss: 0.6521 - accuracy: 0.7153 - val_loss: 0.7675 - val_accuracy: 0.6094\n",
+            "Epoch 3/5\n",
+            "10/10 [==============================] - 31s 3s/step - loss: 0.3882 - accuracy: 0.8610 - val_loss: 0.5415 - val_accuracy: 0.8125\n",
+            "Epoch 4/5\n",
+            "10/10 [==============================] - 26s 3s/step - loss: 0.1780 - accuracy: 0.9390 - val_loss: 0.3293 - val_accuracy: 0.8438\n",
+            "Epoch 5/5\n",
+            "10/10 [==============================] - 25s 3s/step - loss: 0.1449 - accuracy: 0.9458 - val_loss: 0.5131 - val_accuracy: 0.7500\n"
+          ]
+        }
+      ],
+      "source": [
+        "import tensorflow as tf\n",
+        "\n",
+        "# Check if GPU is available\n",
+        "gpus = tf.config.list_physical_devices('GPU')\n",
+        "if gpus:\n",
+        "    try:\n",
+        "        # Enable memory growth for each GPU\n",
+        "        for gpu in gpus:\n",
+        "            tf.config.experimental.set_memory_growth(gpu, True)\n",
+        "        print(\"GPU(s) found and memory growth enabled.\")\n",
+        "    except RuntimeError as e:\n",
+        "        print(e)\n",
+        "else:\n",
+        "    print(\"No GPU(s) found.\")\n",
+        "    \n",
+        "history = model.fit(\n",
+        "    train_generator,\n",
+        "    steps_per_epoch=train_generator.samples // batch_size,\n",
+        "    epochs=5,\n",
+        "    validation_data=validation_generator,\n",
+        "    validation_steps=validation_generator.samples // batch_size\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "RjQfNu7QwZjw"
+      },
+      "source": [
+        "**Model Evaluation**"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 36,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "q9SRLiOMv3qm",
+        "outputId": "c5680df7-67df-41c9-84c7-bee0b17b7f0c"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Evaluating model...\n",
+            "2/2 [==============================] - 4s 2s/step - loss: 0.4480 - accuracy: 0.7812\n",
+            "Validation Accuracy: 78.12%\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Model Evaluation\n",
+        "print(\"Evaluating model...\")\n",
+        "val_loss, val_accuracy = model.evaluate(validation_generator, steps=validation_generator.samples // batch_size)\n",
+        "print(f\"Validation Accuracy: {val_accuracy * 100:.2f}%\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 37,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 927
+        },
+        "id": "ZxP07UNywYPj",
+        "outputId": "228b5e7e-2a21-4cbb-931f-55708ed0cc34"
+      },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "# Plot training & validation accuracy values\n",
+        "plt.plot(history.history['accuracy'])\n",
+        "plt.plot(history.history['val_accuracy'])\n",
+        "plt.title('Model accuracy')\n",
+        "plt.ylabel('Accuracy')\n",
+        "plt.xlabel('Epoch')\n",
+        "plt.legend(['Train', 'Test'], loc='upper left')\n",
+        "plt.show()\n",
+        "\n",
+        "# Plot training & validation loss values\n",
+        "plt.plot(history.history['loss'])\n",
+        "plt.plot(history.history['val_loss'])\n",
+        "plt.title('Model loss')\n",
+        "plt.ylabel('Loss')\n",
+        "plt.xlabel('Epoch')\n",
+        "plt.legend(['Train', 'Test'], loc='upper left')\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "zIeDSJa5xkpy"
+      },
+      "source": [
+        "**Building a Predictive System**"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 38,
+      "metadata": {
+        "id": "0onhRrVkv9-M"
+      },
+      "outputs": [],
+      "source": [
+        "# Function to Load and Preprocess the Image using Pillow\n",
+        "def load_and_preprocess_image(image_path, target_size=(224, 224)):\n",
+        "    # Load the image\n",
+        "    img = Image.open(image_path)\n",
+        "    # Resize the image\n",
+        "    img = img.resize(target_size)\n",
+        "    # Convert the image to a numpy array\n",
+        "    img_array = np.array(img)\n",
+        "    # Add batch dimension\n",
+        "    img_array = np.expand_dims(img_array, axis=0)\n",
+        "    # Scale the image values to [0, 1]\n",
+        "    img_array = img_array.astype('float32') / 255.\n",
+        "    return img_array\n",
+        "\n",
+        "# Function to Predict the Class of an Image\n",
+        "def predict_image_class(model, image_path, class_indices):\n",
+        "    preprocessed_img = load_and_preprocess_image(image_path)\n",
+        "    predictions = model.predict(preprocessed_img)\n",
+        "    predicted_class_index = np.argmax(predictions, axis=1)[0]\n",
+        "    predicted_class_name = class_indices[predicted_class_index]\n",
+        "    return predicted_class_name"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 39,
+      "metadata": {
+        "id": "YZkE2k6gwgOR"
+      },
+      "outputs": [],
+      "source": [
+        "# Create a mapping from class indices to class names\n",
+        "class_indices = {v: k for k, v in train_generator.class_indices.items()}"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 40,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "3dja767dwzFH",
+        "outputId": "d0344da3-a583-459c-94dc-d63027b1f4a5"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "{0: 'Healthy', 1: 'septoria', 2: 'stripe_rust'}"
+            ]
+          },
+          "execution_count": 40,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "class_indices"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 41,
+      "metadata": {
+        "id": "StM3_I3UwjFV"
+      },
+      "outputs": [],
+      "source": [
+        "# saving the class names as json file\n",
+        "json.dump(class_indices, open('wheat_indices.json', 'w'))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 42,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "kJb9gQGRw2Ln",
+        "outputId": "f329cc1c-2945-416a-f42d-174a433ff60c"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "1/1 [==============================] - 0s 292ms/step\n",
+            "Predicted Class Name: septoria\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Example Usage\n",
+        "#image_path = 'test_images/test_apple_black_rot.JPG'\n",
+        "#image_path = 'test_images/test_blueberry_healthy.jpg'\n",
+        "image_path = 'wheat_dataset/septoria/los(10).JPG'\n",
+        "predicted_class_name = predict_image_class(model, image_path, class_indices)\n",
+        "\n",
+        "# Output the result\n",
+        "print(\"Predicted Class Name:\", predicted_class_name)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "QBkknsKMyDbs"
+      },
+      "source": [
+        "**Save the model to Google drive or local**"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 43,
+      "metadata": {
+        "id": "OfoTNemcxjk5"
+      },
+      "outputs": [],
+      "source": [
+        "model.save('plant_disease_prediction_model.h5')"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 44,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "J8ByAMH6ykbN",
+        "outputId": "8836c7a9-6d35-421f-b36c-f6fb50fd5cf7"
+      },
+      "outputs": [],
+      "source": [
+        "model.save('wheat_disease_model.h5')"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "ln01Rmj0L8Hg"
+      },
+      "outputs": [],
+      "source": []
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "gpuType": "T4",
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "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.10.14"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

wheat_disease_model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:253be796611451854bb6104b11178971cfe11743d0fac6ee01f530a0837d76ff
+size 573600752

wheat_indices.json

@@ -0,0 +1 @@
+{"0": "Healthy", "1": "septoria", "2": "stripe_rust"}