Cotton Plant Disease Prediction Project with Deep Learning

!wget -N "https://cainvas-static.s3.amazonaws.com/media/user_data/cainvas-admin/Cotton_Disease.zip"
!unzip -qo Cotton_Disease.zip
!rm Cotton_Disease.zip

--2024-12-20 05:14:31--  https://cainvas-static.s3.amazonaws.com/media/user_data/cainvas-admin/Cotton_Disease.zip
Resolving cainvas-static.s3.amazonaws.com (cainvas-static.s3.amazonaws.com)... 16.12.36.103, 52.219.156.7, 52.219.160.79, ...
Connecting to cainvas-static.s3.amazonaws.com (cainvas-static.s3.amazonaws.com)|16.12.36.103|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 99391772 (95M) [application/zip]
Saving to: ‘Cotton_Disease.zip’

Cotton_Disease.zip  100%[===================>]  94.79M  13.8MB/s    in 8.7s    

2024-12-20 05:14:41 (10.8 MB/s) - ‘Cotton_Disease.zip’ saved [99391772/99391772]

# import libraries
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import cv2
from keras.layers import Dense, Flatten, AveragePooling2D, Dropout
from keras.models import Model
from keras.applications.vgg16 import VGG16
# from keras.preprocessing import image  # No longer needed for ImageDataGenerator
#from keras.preprocessing.image import ImageDataGenerator # This line caused the error
import tensorflow as tf  # Import TensorFlow for the new approach

# Instead of ImageDataGenerator, use the following:
# image_dataset_from_directory and apply desired transformations
# Example:
# train_ds = tf.keras.utils.image_dataset_from_directory(
#     'path/to/images',
#     labels='inferred',
#     label_mode='categorical',  # Or 'binary', 'int'
#     image_size=(img_height, img_width),
#     interpolation='nearest',
#     batch_size=batch_size,
#     shuffle=True
# )

# Apply data augmentation using tf.data API
# Example:
# data_augmentation = tf.keras.Sequential(
#     [
#         tf.keras.layers.experimental.preprocessing.RandomFlip("horizontal"),
#         tf.keras.layers.experimental.preprocessing.RandomRotation(0.1),
#     ]
# )
# train_ds = train_ds.map(lambda x, y: (data_augmentation(x, training=True), y))

from keras.optimizers import Adam

# Check images
img = cv2.imread("Cotton Disease/test/diseased cotton leaf/dis_leaf (124).jpg")
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
plt.imshow(img)
plt.title("Diseased Cotton Leaf")

Text(0.5, 1.0, 'Diseased Cotton Leaf')

# Check images
img = cv2.imread("Cotton Disease/test/fresh cotton leaf/d (122)_iaip.jpg")
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
plt.imshow(img)
plt.title("Fresh Cotton Leaf")

Text(0.5, 1.0, 'Fresh Cotton Leaf')

# Check images
img = cv2.imread("Cotton Disease/test/diseased cotton plant/dd (16)_iaip.jpg")
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
plt.imshow(img)
plt.title("Diseased Cotton Plant")

Text(0.5, 1.0, 'Diseased Cotton Plant')

# Check images
img = cv2.imread("Cotton Disease/test/fresh cotton plant/dsd (140)_iaip.jpg")
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
plt.imshow(img)
plt.title("Fresh Cotton Plant")

Text(0.5, 1.0, 'Fresh Cotton Plant')

# import libraries
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import cv2
from keras.layers import Dense, Flatten, AveragePooling2D, Dropout
from keras.models import Model
from keras.applications.vgg16 import VGG16
from tensorflow.keras.preprocessing.image import ImageDataGenerator # Import ImageDataGenerator
import tensorflow as tf


# ... (rest of your code)

train_generator = ImageDataGenerator(rescale=1./255, shear_range=0.2, zoom_range=0.2, horizontal_flip=True)
test_generator = ImageDataGenerator(rescale=1./255, shear_range=0.2, zoom_range=0.2, horizontal_flip=True)

train_data = train_generator.flow_from_directory( 'Cotton Disease/train', target_size=(224, 224),
        batch_size=64)
test_data = test_generator.flow_from_directory( 'Cotton Disease/test', target_size=(224, 224),
        batch_size=64)

Found 1041 images belonging to 4 classes.
Found 106 images belonging to 4 classes.

train_data.class_indices

{'diseased cotton leaf': 0,
 'diseased cotton plant': 1,
 'fresh cotton leaf': 2,
 'fresh cotton plant': 3}

# Model creation with changes

model = VGG16(input_shape=(224,224,3),include_top=False)

for layer in model.layers:
    layer.trainable = False

newModel = model.output
# Specify the pool_size for AveragePooling2D
newModel = AveragePooling2D(pool_size=(2, 2))(newModel)  # Example: 2x2 pooling window
newModel = Flatten()(newModel)
newModel = Dense(128, activation="relu")(newModel)
newModel = Dropout(0.5)(newModel)
newModel = Dense(4, activation='softmax')(newModel)

model = Model(inputs=model.input, outputs=newModel)

Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/vgg16/vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5
58889256/58889256 ━━━━━━━━━━━━━━━━━━━━ 0s 0us/step

model.summary()

Model: "functional"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓
┃ Layer (type)                         ┃ Output Shape                ┃         Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━┩
│ input_layer (InputLayer)             │ (None, 224, 224, 3)         │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block1_conv1 (Conv2D)                │ (None, 224, 224, 64)        │           1,792 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block1_conv2 (Conv2D)                │ (None, 224, 224, 64)        │          36,928 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block1_pool (MaxPooling2D)           │ (None, 112, 112, 64)        │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block2_conv1 (Conv2D)                │ (None, 112, 112, 128)       │          73,856 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block2_conv2 (Conv2D)                │ (None, 112, 112, 128)       │         147,584 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block2_pool (MaxPooling2D)           │ (None, 56, 56, 128)         │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block3_conv1 (Conv2D)                │ (None, 56, 56, 256)         │         295,168 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block3_conv2 (Conv2D)                │ (None, 56, 56, 256)         │         590,080 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block3_conv3 (Conv2D)                │ (None, 56, 56, 256)         │         590,080 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block3_pool (MaxPooling2D)           │ (None, 28, 28, 256)         │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block4_conv1 (Conv2D)                │ (None, 28, 28, 512)         │       1,180,160 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block4_conv2 (Conv2D)                │ (None, 28, 28, 512)         │       2,359,808 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block4_conv3 (Conv2D)                │ (None, 28, 28, 512)         │       2,359,808 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block4_pool (MaxPooling2D)           │ (None, 14, 14, 512)         │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block5_conv1 (Conv2D)                │ (None, 14, 14, 512)         │       2,359,808 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block5_conv2 (Conv2D)                │ (None, 14, 14, 512)         │       2,359,808 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block5_conv3 (Conv2D)                │ (None, 14, 14, 512)         │       2,359,808 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block5_pool (MaxPooling2D)           │ (None, 7, 7, 512)           │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ average_pooling2d (AveragePooling2D) │ (None, 3, 3, 512)           │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ flatten (Flatten)                    │ (None, 4608)                │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense (Dense)                        │ (None, 128)                 │         589,952 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dropout (Dropout)                    │ (None, 128)                 │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense_1 (Dense)                      │ (None, 4)                   │             516 │
└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘

 Total params: 15,305,156 (58.38 MB)

 Trainable params: 590,468 (2.25 MB)

 Non-trainable params: 14,714,688 (56.13 MB)

opt=Adam(learning_rate=0.001)
model.compile(optimizer=opt, loss='categorical_crossentropy', metrics=['accuracy'])

history = model.fit(train_data,
                              validation_data=test_data,
                              epochs=10)

Epoch 1/10
17/17 ━━━━━━━━━━━━━━━━━━━━ 746s 44s/step - accuracy: 0.4224 - loss: 1.3918 - val_accuracy: 0.7925 - val_loss: 0.6923
Epoch 2/10
17/17 ━━━━━━━━━━━━━━━━━━━━ 734s 43s/step - accuracy: 0.7469 - loss: 0.6852 - val_accuracy: 0.8113 - val_loss: 0.4847
Epoch 3/10
17/17 ━━━━━━━━━━━━━━━━━━━━ 749s 43s/step - accuracy: 0.8062 - loss: 0.5544 - val_accuracy: 0.8962 - val_loss: 0.4101
Epoch 4/10
17/17 ━━━━━━━━━━━━━━━━━━━━ 794s 43s/step - accuracy: 0.8385 - loss: 0.4537 - val_accuracy: 0.8396 - val_loss: 0.3640
Epoch 5/10
17/17 ━━━━━━━━━━━━━━━━━━━━ 728s 42s/step - accuracy: 0.8821 - loss: 0.3421 - val_accuracy: 0.8962 - val_loss: 0.3048
Epoch 6/10
17/17 ━━━━━━━━━━━━━━━━━━━━ 725s 42s/step - accuracy: 0.8904 - loss: 0.3171 - val_accuracy: 0.8868 - val_loss: 0.2772
Epoch 7/10
17/17 ━━━━━━━━━━━━━━━━━━━━ 743s 42s/step - accuracy: 0.8600 - loss: 0.3561 - val_accuracy: 0.9245 - val_loss: 0.2788
Epoch 8/10
17/17 ━━━━━━━━━━━━━━━━━━━━ 758s 43s/step - accuracy: 0.9125 - loss: 0.2869 - val_accuracy: 0.9151 - val_loss: 0.2649
Epoch 9/10
17/17 ━━━━━━━━━━━━━━━━━━━━ 715s 44s/step - accuracy: 0.8939 - loss: 0.2897 - val_accuracy: 0.9151 - val_loss: 0.2633
Epoch 10/10
17/17 ━━━━━━━━━━━━━━━━━━━━ 726s 42s/step - accuracy: 0.9122 - loss: 0.2598 - val_accuracy: 0.8585 - val_loss: 0.2906

/usr/local/lib/python3.10/dist-packages/keras/src/trainers/data_adapters/py_dataset_adapter.py:122: 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.
  self._warn_if_super_not_called()

acc = history.history['accuracy']
val_acc = history.history['val_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs=range(len(acc))

plt.plot(epochs,acc,label='Trainin_acc',color='blue')
plt.plot(epochs,val_acc,label='Validation_acc',color='red')
plt.legend()
plt.title("Training and Validation Accuracy")

Text(0.5, 1.0, 'Training and Validation Accuracy')

plt.plot(epochs,loss,label='Training_loss',color='blue')
plt.plot(epochs,loss,label='Training_loss',color='blue')
plt.plot(epochs,val_loss,label='Validation_loss',color='red')
plt.legend()
plt.title("Training and Validation loss")

Text(0.5, 1.0, 'Training and Validation loss')

class_dict = {0:'diseased cotton leaf',
              1:'diseased cotton plant',
              2:'fresh cotton leaf',
              3:'fresh cotton plant' }

# New Data for testing

file_path =  'Cotton Disease/test/diseased cotton leaf/dis_leaf (153)_iaip.jpg'
test_image = cv2.imread(file_path)
test_image = cv2.cvtColor(test_image, cv2.COLOR_BGR2RGB)
test_image = cv2.resize(test_image, (224,224),interpolation=cv2.INTER_CUBIC)
plt.imshow(test_image)
test_image = np.expand_dims(test_image,axis=0)
probs = model.predict(test_image)
pred_class = np.argmax(probs)

pred_class = class_dict[pred_class]

print(pred_class)

1/1 ━━━━━━━━━━━━━━━━━━━━ 1s 941ms/step
diseased cotton leaf

file_path =  'Cotton Disease/test/diseased cotton plant/dd (885)_iaip.jpg'
test_image = cv2.imread(file_path)
test_image = cv2.cvtColor(test_image, cv2.COLOR_BGR2RGB)
test_image = cv2.resize(test_image, (224,224),interpolation=cv2.INTER_CUBIC)
plt.imshow(test_image)
test_image = np.expand_dims(test_image,axis=0)
probs = model.predict(test_image)
pred_class = np.argmax(probs)

pred_class = class_dict[pred_class]

print(pred_class)

1/1 ━━━━━━━━━━━━━━━━━━━━ 1s 591ms/step
diseased cotton plant

file_path =  'Cotton Disease/test/fresh cotton leaf/d (133)_iaip.jpg'
test_image = cv2.imread(file_path)
test_image = cv2.cvtColor(test_image, cv2.COLOR_BGR2RGB)
test_image = cv2.resize(test_image, (224,224),interpolation=cv2.INTER_CUBIC)
plt.imshow(test_image)
test_image = np.expand_dims(test_image,axis=0)
probs = model.predict(test_image)
pred_class = np.argmax(probs)

pred_class = class_dict[pred_class]

print(pred_class)

1/1 ━━━━━━━━━━━━━━━━━━━━ 1s 538ms/step
fresh cotton leaf

file_path =  'Cotton Disease/test/fresh cotton plant/dsd (223).jpg'
test_image = cv2.imread(file_path)
test_image = cv2.cvtColor(test_image, cv2.COLOR_BGR2RGB)
test_image = cv2.resize(test_image, (224,224),interpolation=cv2.INTER_CUBIC)
plt.imshow(test_image)
test_image = np.expand_dims(test_image,axis=0)
probs = model.predict(test_image)
pred_class = np.argmax(probs)

pred_class = class_dict[pred_class]

print(pred_class)

1/1 ━━━━━━━━━━━━━━━━━━━━ 1s 566ms/step
fresh cotton plant

model.save("Cotton_Disease.h5")

WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. 

import matplotlib.pyplot as plt
import cv2
import numpy as np
import os

# Function to display two images side by side with labels
def display_images_with_labels(diseased_image_path, healthy_image_path):
    # Load and process the diseased image
    diseased_img = cv2.imread(diseased_image_path)
    diseased_img = cv2.cvtColor(diseased_img, cv2.COLOR_BGR2RGB)

    # Load and process the healthy image
    healthy_img = cv2.imread(healthy_image_path)
    healthy_img = cv2.cvtColor(healthy_img, cv2.COLOR_BGR2RGB)

    # Extract the disease name from the folder of the diseased image
    disease_name = os.path.basename(os.path.dirname(diseased_image_path))  # Folder name as disease type

    # Alternatively, if you have a predefined mapping for specific image names or folders to disease types,
    # you can use a dictionary or a similar structure for better control.
    disease_mapping = {
        "diseased cotton leaf": "Leaf Blight",
        "bacterial blight": "Bacterial Blight",
        "cotton wilt": "Cotton Wilt",
        # Add more mappings as needed
    }

    # Get the specific disease name (if it's in the mapping)
    disease_name = disease_mapping.get(disease_name.lower(), "Unknown Disease")

    # Plot the images side by side
    fig, axes = plt.subplots(1, 2, figsize=(12, 6))

    # Diseased image
    axes[0].imshow(diseased_img)
    axes[0].set_title(f"Diseased: {disease_name}", fontsize=14, color='red')
    axes[0].axis('off')

    # Healthy image
    axes[1].imshow(healthy_img)
    axes[1].set_title("Healthy", fontsize=14, color='green')
    axes[1].axis('off')

    # Display the images
    plt.tight_layout()
    plt.show()

# Example Usage:
diseased_image_path = "Cotton Disease/test/diseased cotton leaf/dis_leaf (124).jpg"
healthy_image_path = "Cotton Disease/test/fresh cotton leaf/d (122)_iaip.jpg"

display_images_with_labels(diseased_image_path, healthy_image_path)

import matplotlib.pyplot as plt
import cv2
import numpy as np
import tensorflow as tf
from tensorflow.keras.preprocessing import image
import os

# Load the pre-trained model (you can use any pre-trained model, e.g., VGG16, ResNet)
model = tf.keras.applications.ResNet50(weights='imagenet')  # Example with ResNet50

# Function to display images with predicted disease label
def display_image_with_predicted_disease(leaf_image_path):
    # Get the absolute path of the image file
    leaf_image_path = os.path.abspath(leaf_image_path)

    # Check if the image file exists
    if not os.path.exists(leaf_image_path):
        print(f"Error: Image file not found at '{leaf_image_path}'")
        return

    # Load and process the leaf image
    leaf_img = cv2.imread(leaf_image_path)

    # Check if the image was loaded successfully
    if leaf_img is None:
        print(f"Error: Could not load image from '{leaf_image_path}'")
        return

    leaf_img_rgb = cv2.cvtColor(leaf_img, cv2.COLOR_BGR2RGB)

    # Preprocess the image for the model
    img = image.load_img(leaf_image_path, target_size=(224, 224))  # ResNet50 input size
    img_array = image.img_to_array(img)
    img_array = np.expand_dims(img_array, axis=0)  # Add batch dimension
    img_array = tf.keras.applications.resnet50.preprocess_input(img_array)

    # Predict the disease (the model will return a class index)
    predictions = model.predict(img_array)

    # Decode predictions to get the disease name (this is a simplified example)
    decoded_predictions = tf.keras.applications.resnet50.decode_predictions(predictions, top=1)

    # Get the predicted disease (class name)
    disease_name = decoded_predictions[0][0][1]  # For ResNet50, this is the class name

    # Plot the image with predicted disease label
    plt.imshow(leaf_img_rgb)
    plt.title(f"Disease: {disease_name}", fontsize=14, color='red')
    plt.axis('off')
    plt.show()

# Example Usage:
# Provide the correct path to your image file
leaf_image_path = "Cotton Disease/test/diseased cotton leaf/dis_leaf (124).jpg"
display_image_with_predicted_disease(leaf_image_path)

1/1 ━━━━━━━━━━━━━━━━━━━━ 2s 2s/step
Downloading data from https://storage.googleapis.com/download.tensorflow.org/data/imagenet_class_index.json
35363/35363 ━━━━━━━━━━━━━━━━━━━━ 0s 0us/step

import matplotlib.pyplot as plt
import cv2
import numpy as np
import tensorflow as tf
from tensorflow.keras.preprocessing import image
import os

# Load the pre-trained model (you can use any pre-trained model, e.g., VGG16, ResNet)
model = tf.keras.applications.ResNet50(weights='imagenet')  # Example with ResNet50

# Function to display images with predicted disease label
def display_image_with_predicted_disease(leaf_image_path):
    # Get the absolute path of the image file
    leaf_image_path = os.path.abspath(leaf_image_path)

    # Check if the image file exists
    if not os.path.exists(leaf_image_path):
        print(f"Error: Image file not found at '{leaf_image_path}'")
        return

    # Load and process the leaf image
    leaf_img = cv2.imread(leaf_image_path)

    # Check if the image was loaded successfully
    if leaf_img is None:
        print(f"Error: Could not load image from '{leaf_image_path}'")
        return

    leaf_img_rgb = cv2.cvtColor(leaf_img, cv2.COLOR_BGR2RGB)

    # Preprocess the image for the model
    img = image.load_img(leaf_image_path, target_size=(224, 224))  # ResNet50 input size
    img_array = image.img_to_array(img)
    img_array = np.expand_dims(img_array, axis=0)  # Add batch dimension
    img_array = tf.keras.applications.resnet50.preprocess_input(img_array)

    # Predict the disease (the model will return a class index)
    predictions = model.predict(img_array)

    # Decode predictions to get the disease name (this is a simplified example)
    decoded_predictions = tf.keras.applications.resnet50.decode_predictions(predictions, top=1)

    # Get the predicted disease (class name)
    disease_name = decoded_predictions[0][0][1]  # For ResNet50, this is the class name

    # Plot the image with predicted disease label
    plt.imshow(leaf_img_rgb)
    plt.title(f"Disease: {disease_name}", fontsize=14, color='red')
    plt.axis('off')
    plt.show()

# Example Usage:
# Provide the correct path to your image file
leaf_image_path = "Cotton Disease/test/diseased cotton leaf/Newly_Uploaded.jpeg"
display_image_with_predicted_disease(leaf_image_path)

1/1 ━━━━━━━━━━━━━━━━━━━━ 2s 2s/step

import matplotlib.pyplot as plt
import cv2
import numpy as np
import tensorflow as tf
from tensorflow.keras.preprocessing import image
import os
import io
from google.colab import files
from PIL import Image  # Import PIL for image handling

# Load the pre-trained model (e.g., ResNet50)
model = tf.keras.applications.ResNet50(weights='imagenet')  # Example with ResNet50

# Function to display images with predicted disease label
def display_image_with_predicted_disease(leaf_image_path):
    # Load and process the leaf image
    # leaf_img = cv2.imread(leaf_image_path) # This line was causing the issue
    leaf_img = np.array(Image.open(leaf_image_path))  # Use PIL to open the image
    leaf_img_rgb = cv2.cvtColor(leaf_img, cv2.COLOR_BGR2RGB)

    # Preprocess the image for the model
    img = image.load_img(leaf_image_path, target_size=(224, 224))  # ResNet50 input size
    img_array = image.img_to_array(img)
    img_array = np.expand_dims(img_array, axis=0)  # Add batch dimension
    img_array = tf.keras.applications.resnet50.preprocess_input(img_array)

    # Predict the disease (the model will return a class index)
    predictions = model.predict(img_array)

    # Decode predictions to get the disease name (this is a simplified example)
    decoded_predictions = tf.keras.applications.resnet50.decode_predictions(predictions, top=1)

    # Get the predicted disease (class name)
    disease_name = decoded_predictions[0][0][1]  # For ResNet50, this is the class name

    # Plot the image with predicted disease label
    plt.imshow(leaf_img_rgb)
    plt.title(f"Disease: {disease_name}", fontsize=14, color='red')
    plt.axis('off')
    plt.show()

# Function to handle uploaded files
def handle_upload(uploaded):
    for filename in uploaded.keys():
        # Read the image data from the uploaded file
        # image_data = io.BytesIO(uploaded[filename]) # Original line
        image_data = io.BytesIO(uploaded[filename])
        image = Image.open(image_data) # Open the image using PIL

        # Call the function to display the image and predict the disease
        display_image_with_predicted_disease(image_data) # Changed to pass image_data


# Upload a sample image
print("Please upload your cotton leaf image:")
uploaded = files.upload()

# Process the uploaded image
handle_upload(uploaded)

Please upload your cotton leaf image:
Saving download (4).jpeg to download (4) (3).jpeg
1/1 ━━━━━━━━━━━━━━━━━━━━ 2s 2s/step

Upload widget is only available when the cell has been executed in the current browser session. Please rerun this cell to enable.

import matplotlib.pyplot as plt
import cv2
import numpy as np
import tensorflow as tf
from tensorflow.keras.preprocessing import image
from google.colab import files
from PIL import Image  # Import PIL for image handling

# Load the pre-trained model (e.g., ResNet50)
model = tf.keras.applications.ResNet50(weights='imagenet')  # Example with ResNet50

# List of labels (example, may need to be updated depending on your actual use case)
healthy_classes = ['healthy', 'no_disease', 'fresh']

# Function to display images with predicted disease label
def display_image_with_predicted_disease(leaf_image_path):
    # Load and process the leaf image
    leaf_img = np.array(Image.open(leaf_image_path))  # Use PIL to open the image
    leaf_img_rgb = cv2.cvtColor(leaf_img, cv2.COLOR_BGR2RGB)

    # Preprocess the image for the model
    img = image.load_img(leaf_image_path, target_size=(224, 224))  # ResNet50 input size
    img_array = image.img_to_array(img)
    img_array = np.expand_dims(img_array, axis=0)  # Add batch dimension
    img_array = tf.keras.applications.resnet50.preprocess_input(img_array)

    # Predict the disease (the model will return a class index)
    predictions = model.predict(img_array)

    # Decode predictions to get the disease name (this is a simplified example)
    decoded_predictions = tf.keras.applications.resnet50.decode_predictions(predictions, top=1)

    # Get the predicted disease (class name)
    disease_name = decoded_predictions[0][0][1]  # For ResNet50, this is the class name
    confidence = decoded_predictions[0][0][2]  # Confidence of the prediction

    # If the disease name is in the list of healthy classes, we classify it as healthy
    if any(healthy_class in disease_name.lower() for healthy_class in healthy_classes):
        disease_name = "Healthy"
        color = 'green'  # Healthy label color
    else:
        disease_name = f"Disease: {disease_name} (Confidence: {confidence*100:.2f}%)"
        color = 'red'  # Diseased label color

    # Plot the image with the predicted label
    plt.imshow(leaf_img_rgb)
    plt.title(disease_name, fontsize=14, color=color)
    plt.axis('off')
    plt.show()

# Function to handle uploaded files
def handle_upload(uploaded):
    for filename in uploaded.keys():
        # Read the image data from the uploaded file
        image_data = io.BytesIO(uploaded[filename])
        # Call the function to display the image and predict the disease
        display_image_with_predicted_disease(image_data)

# Upload a sample image
print("Please upload your cotton leaf image:")
uploaded = files.upload()

# Process the uploaded image
handle_upload(uploaded)