ndnfkd

app.py

@@ -8,22 +8,6 @@ import os
 import random
 import pandas as pd
 import matplotlib.pyplot as plt
-import zipfile  # Added for zip extraction
-
-# ---- Dataset Extraction Logic ----
-DATASET_ZIP = "rice_leaf_diseases.zip"
-DATASET_FOLDER = "rice_leaf_diseases"
-
-# Check and extract dataset if needed
-if not os.path.exists(DATASET_FOLDER):
-    if os.path.exists(DATASET_ZIP):
-        with zipfile.ZipFile(DATASET_ZIP, 'r') as zip_ref:
-            zip_ref.extractall()
-        st.success("Dataset extracted successfully!")
-    else:
-        st.error(f"Dataset zip file '{DATASET_ZIP}' not found!")
-else:
-    st.toast("Dataset already available!", icon="✅")
 
 # Define Model Class
 class RiceDiseaseCNN(nn.Module):
@@ -67,11 +51,11 @@ transform = transforms.Compose([
 # Class Labels
 class_labels = ["Bacterial Leaf Blight", "Brown Spot", "Leaf Smut"]
 
-# Streamlit App Configuration
+# Streamlit App
 st.set_page_config(page_title="Rice Disease Detection", layout="wide")
 
-# Define dataset path after extraction
-dataset_path = DATASET_FOLDER
+# Dataset path
+dataset_path = "rice_leaf_diseases"  # Define this globally
 
 # Sidebar Navigation
 st.sidebar.title("Navigation")
@@ -88,7 +72,9 @@ if page == "Dataset":
         The dataset is available on [Kaggle](https://www.kaggle.com/datasets/vbookshelf/rice-leaf-diseases).
     """)
     
+    # Show sample images per class
     def get_sample_images(label, count=3):
+        """Gets sample images from a given disease class folder."""
         label_path = os.path.join(dataset_path, label)
         images = [img for img in os.listdir(label_path) if img.endswith(("png", "jpg", "jpeg"))]
         sample_images = random.sample(images, min(count, len(images)))
@@ -101,80 +87,134 @@ if page == "Dataset":
         with cols[idx]:
             st.write(f"### {label}")
             for img_path in images:
-                st.image(img_path, use_column_width=True)
+                st.image(img_path, use_container_width=True)
 
 # Data Visualization Page
 elif page == "Data Visualization":
     st.title("Data Visualization 📊")
+    st.markdown("Here is a sample visualization of rice leaf disease image distribution.")
+    
+    # Count images per class
+    class_counts = {}
     
     def get_image_count(label):
+        """Counts the number of images in a given class folder."""
         label_path = os.path.join(dataset_path, label)
-        return len([img for img in os.listdir(label_path) if img.endswith(("png", "jpg", "jpeg"))])
+        images = [img for img in os.listdir(label_path) if img.endswith(("png", "jpg", "jpeg"))]
+        return len(images)
 
-    class_counts = {label: get_image_count(label) for label in class_labels}
-    
+    # Count images for each class
+    for label in class_labels:
+        class_counts[label] = get_image_count(label)
+
+    # Display class distribution
     st.subheader("Class Distribution")
-    df = pd.DataFrame(list(class_counts.items()), columns=["Disease", "Count"])
+    st.write(f"Total number of images in each class:")
     
-    # Pie Chart
+    # Convert counts to DataFrame for visualization
+    df = pd.DataFrame(list(class_counts.items()), columns=["Disease", "Count"])
+
+    # Pie Chart Visualization (Matplotlib)
+    st.subheader("Disease Distribution as Pie Chart")
     fig, ax = plt.subplots()
     ax.pie(df["Count"], labels=df["Disease"], autopct='%1.1f%%', startangle=90)
-    ax.axis('equal')
+    ax.axis('equal')  # Equal aspect ratio ensures that pie is drawn as a circle.
     st.pyplot(fig)
-    
-    # Bar Chart
+
+    # Bar Chart Visualization (Matplotlib)
+    st.subheader("Disease Distribution as Bar Chart")
     fig, ax = plt.subplots()
-    ax.bar(df["Disease"], df["Count"], color=['#1f77b4', '#ff7f0e', '#2ca02c'])
+    ax.bar(df["Disease"], df["Count"], color=['blue', 'green', 'red'])
     ax.set_xlabel('Disease Type')
     ax.set_ylabel('Number of Images')
+    ax.set_title('Rice Leaf Disease Distribution')
     st.pyplot(fig)
 
 # Model Metrics Page
 elif page == "Model Metrics":
     st.title("Model Performance Metrics 📈")
+
+    # Model Description
     st.markdown("""
-        ### Model Architecture
-        - **Convolutional Layers** with Batch Normalization
-        - **MaxPooling** for dimension reduction
-        - **Fully Connected Layers** for classification
+        ### Model Overview
+        The model used for this classification task is a **Convolutional Neural Network (CNN)**. 
+        CNNs are commonly used for image classification tasks because they are effective at recognizing spatial hierarchies in images.
+
+        #### Model Architecture
+        The architecture consists of the following layers:
+        - **Convolutional Layers**: These layers apply filters to the image to detect features such as edges, textures, and patterns.
+          - **Conv1**: 3 input channels (RGB), 32 output channels, 3x3 kernel.
+          - **Conv2**: 32 input channels, 64 output channels, 3x3 kernel.
+          - **Conv3**: 64 input channels, 128 output channels, 3x3 kernel.
+        - **Batch Normalization**: Applied after each convolutional layer to stabilize and speed up training.
+        - **MaxPooling**: Reduces the spatial dimensions of the feature maps (2x2 pool).
+        - **Fully Connected Layers**: The output from the convolutional layers is flattened and passed through fully connected layers.
+          - **FC1**: 128 * 16 * 16 input features, 512 output units.
+          - **FC2**: 512 input units, output units corresponding to the number of disease classes (3 classes in total).
+
+        #### Model Training
+        The model was trained on a dataset of rice leaf disease images. The training process involved optimizing the model using a **cross-entropy loss** function and an **Adam optimizer**. 
+        The model was trained to minimize the error between predicted and actual class labels.
+
     """)
-    
+
     # Confusion Matrix
     st.subheader("Confusion Matrix")
-    st.image("con_mat.png", use_column_width=True)
-    
-    # Training Curves
-    col1, col2 = st.columns(2)
-    with col1:
-        st.subheader("Training Loss")
-        st.image("train_loss.png")
-    with col2:
-        st.subheader("Validation Accuracy")
-        st.image("val_acc.png")
-    
-    # Classification Report
+    cm_image = Image.open("con_mat.png")
+    st.image(cm_image, caption="Confusion Matrix", use_container_width=True)
+
+    # Training Loss
+    st.subheader("Training Loss")
+    loss_image = Image.open("train_loss.png")
+    st.image(loss_image, caption="Training Loss Curve", use_container_width=True)
+
+    # Validation Accuracy
+    st.subheader("Validation Accuracy")
+    acc_image = Image.open("val_acc.png")
+    st.image(acc_image, caption="Validation Accuracy Curve", use_container_width=True)
+
+    # Accuracy Table
     st.subheader("Classification Report")
-    st.code(""" 
-        precision    recall  f1-score   support
-Bacterial Leaf Blight       0.90      1.00      0.95         9
-        Brown Spot       1.00      1.00      1.00         5
-         Leaf Smut       1.00      0.75      0.86         4
+    st.text(""" 
+                    precision    recall  f1-score   support
+    Bacterial Leaf Blight       0.90      1.00      0.95         9
+    Brown Spot                  1.00      1.00      1.00         5
+    Leaf Smut                   1.00      0.75      0.86         4
+    Accuracy                     0.94        18
+    Macro Avg                    0.97      0.92      0.93        18
+    Weighted Avg                 0.95      0.94      0.94        18
     """)
 
+
 # Classification Page
 elif page == "Classification":
     st.title("Rice Leaf Disease Classification 🔍")
     
-    uploaded_file = st.file_uploader("Upload rice leaf image", type=["jpg", "png", "jpeg"])
+    st.markdown("""
+        ### About the Classification Model
+        This model is designed to classify rice leaf diseases based on images. It uses a Convolutional Neural Network (CNN) trained on a dataset of rice leaf images. 
+        The model can classify the following rice leaf diseases:
+        - **Bacterial Leaf Blight**: Caused by *Xanthomonas oryzae* bacteria.
+        - **Brown Spot**: Caused by *Cochliobolus miyabeanus* fungus.
+        - **Leaf Smut**: Caused by *Entyloma oryzae* fungus.
+        
+        The model analyzes the uploaded image and predicts which disease the rice leaf is affected by. The image is processed through the network and the disease type is determined by comparing the features extracted from the image to the trained data.
+    """)
+    
+    uploaded_file = st.file_uploader("Upload an image of a rice leaf", type=["jpg", "png", "jpeg"])
     
-    if uploaded_file:
+    if uploaded_file is not None:
+        # Preprocess Image
         image = Image.open(uploaded_file).convert("RGB")
-        st.image(image, use_column_width=True)
+        st.image(image, caption="Uploaded Image", use_container_width=True)
+        
+        image = transform(image).unsqueeze(0)
         
-        # Transform and predict
-        image_tensor = transform(image).unsqueeze(0)
+        # Predict
         with torch.no_grad():
-            output = model(image_tensor)
-            _, predicted = torch.max(output, 1)
+            outputs = model(image)
+            _, predicted = torch.max(outputs, 1)
         
-        st.success(f"**Prediction:** {class_labels[predicted.item()]}")
+        # Display Prediction
+        st.subheader("Prediction Result:")
+        st.success(f"Predicted Disease: **{class_labels[predicted.item()]}**")