Initial commit for Hugging Face Space deployment with ResNet9 model

.gitattributes

@@ -0,0 +1,3 @@
+*.pth filter=lfs diff=lfs merge=lfs -text
+plant_disease_model.pth filter=lfs diff=lfs merge=lfs -text
+examples/*.jpg filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -1,3 +1,7 @@
+# Dataset and large files
+dataset/
+kaggle_plant_disease/
+
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]
@@ -44,9 +48,35 @@ coverage.xml
 .hypothesis/
 .pytest_cache/
 
-# Translations
-*.mo
-*.pot
+# Virtual environment
+venv/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Local development
+.env
+*.pth
+*.pth.*
+
+# Training scripts and logs
+resnet9_train.py
+test_model.py
+
+# Test images
+test_image.JPG
 
 # Django stuff:
 *.log

Dockerfile

@@ -23,5 +23,5 @@ ENV MPLCONFIGDIR=/tmp/matplotlib
 RUN mkdir -p /tmp/matplotlib && \
     chmod -R 777 /tmp/matplotlib
 
-# Run app.py when the container launches
-CMD ["streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0"]
+# Run app_resnet9.py when the container launches
+CMD ["streamlit", "run", "app_resnet9.py", "--server.port=8501", "--server.address=0.0.0.0"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Saketh Jangala
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -11,11 +11,11 @@ pinned: false
 
 # 🌿 Plant Disease Detection
 
-A deep learning-based web application that identifies plant diseases from leaf images using EfficientNetB0.
+A deep learning-based web application that identifies plant diseases from leaf images using a ResNet9 model, providing fast and accurate predictions.
 
 ## 🚀 Features
 
-- 🌱 Identify 38 different plant diseases
+- 🌱 Identify 38 different plant diseases using a ResNet9 model
 - 📊 Interactive prediction visualization
 - 📱 Mobile-responsive design
 - ⚡ Fast inference with model caching
@@ -26,7 +26,7 @@ A deep learning-based web application that identifies plant diseases from leaf i
 
 1. Clone the repository:
    ```bash
-   git clone https://huggingface.co/spaces/your-username/plant-disease-detection
+   git clone https://huggingface.co/spaces/saketh-005/plant-disease-detection
    cd plant-disease-detection
    ```
 
@@ -42,7 +42,7 @@ A deep learning-based web application that identifies plant diseases from leaf i
 
 ## 🌐 Deployment
 
-This app is deployed on Hugging Face Spaces. You can access it [here](https://huggingface.co/spaces/your-username/plant-disease-detection).
+This app is deployed on Hugging Face Spaces. You can access it [here](https://huggingface.co/spaces/saketh-005/plant-disease-detection).
 
 ## 📝 Note
 

app.py

@@ -1,345 +1,199 @@
-import os
-from io import BytesIO
-# Configure Matplotlib to use a non-interactive backend
-import matplotlib
-matplotlib.use('Agg')  # Use the 'Agg' backend which doesn't require a display
-os.environ['MPLCONFIGDIR'] = '/tmp/matplotlib'
-
-# Create the directory if it doesn't exist
-try:
-    os.makedirs('/tmp/matplotlib', exist_ok=True)
-    os.chmod('/tmp/matplotlib', 0o777)
-except Exception as e:
-    pass  # Directory creation is not critical
-
 import streamlit as st
-import numpy as np
-import pandas as pd
-from PIL import Image
-import matplotlib.pyplot as plt
-import plotly.express as px
 import torch
-from torchvision import transforms, models
 import torch.nn as nn
+import torchvision.transforms as transforms
+from PIL import Image
 import json
-from pathlib import Path
-import time
-
-# Set random seed for reproducibility
-SEED = 42
-np.random.seed(SEED)
-torch.manual_seed(SEED)
+import numpy as np
 
-# Set device
-device = torch.device('mps' if torch.backends.mps.is_available() else 'cpu')
+# Define the model architecture (same as used in training)
+class SimpleCNN(nn.Module):
+    def __init__(self, num_classes=38):
+        super().__init__()
+        self.features = nn.Sequential(
+            nn.Conv2d(3, 16, kernel_size=3, padding=1),
+            nn.BatchNorm2d(16),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(2),
+            
+            nn.Conv2d(16, 32, kernel_size=3, padding=1),
+            nn.BatchNorm2d(32),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(2),
+            
+            nn.Conv2d(32, 64, kernel_size=3, padding=1),
+            nn.BatchNorm2d(64),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(2),
+            
+            nn.Conv2d(64, 128, kernel_size=3, padding=1),
+            nn.BatchNorm2d(128),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(2),
+        )
+        
+        self.flattened_size = 128 * 16 * 16
+        self.classifier = nn.Sequential(
+            nn.Dropout(0.3),
+            nn.Linear(self.flattened_size, 512),
+            nn.ReLU(inplace=True),
+            nn.Dropout(0.3),
+            nn.Linear(512, num_classes)
+        )
+    
+    def forward(self, x):
+        x = self.features(x)
+        x = x.view(x.size(0), -1)
+        x = self.classifier(x)
+        return x
+
+# Load class indices
+with open('class_indices.json', 'r') as f:
+    class_indices = json.load(f)
+    # Convert string keys to integers
+    class_indices = {int(k): v for k, v in class_indices.items()}
+    idx_to_class = {v: k for k, v in class_indices.items()}
+
+# Initialize model
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+model = SimpleCNN(num_classes=len(class_indices)).to(device)
+model.load_state_dict(torch.load('plant_disease_model.pth', map_location=device))
+model.eval()
+
+# Image transformations
+image_transforms = transforms.Compose([
+    transforms.Resize((256, 256)),
+    transforms.ToTensor(),
+    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+])
+
+def predict(image):
+    """Predict the class of an image"""
+    # Preprocess
+    image = image_transforms(image).unsqueeze(0).to(device)
+    
+    # Predict
+    with torch.no_grad():
+        outputs = model(image)
+        probabilities = torch.nn.functional.softmax(outputs[0], dim=0)
+        
+    # Get top 3 predictions
+    top3_prob, top3_catid = torch.topk(probabilities, 3)
+    predictions = []
+    for i in range(top3_prob.size(0)):
+        class_idx = top3_catid[i].item()
+        class_name = class_indices.get(class_idx, f"Class {class_idx}")
+        # Convert to human-readable format
+        class_name = class_name.replace('___', ' ').replace('_', ' ').title()
+        predictions.append({
+            'class': class_name,
+            'probability': f"{top3_prob[i].item() * 100:.2f}%"
+        })
+    
+    return predictions
 
-# Set page config
+# Page configuration (must be the first Streamlit command)
 st.set_page_config(
-    page_title="Plant Disease Prediction",
-    page_icon="🌱",
-    layout="wide"
+    page_title="Plant Disease Classifier",
+    page_icon="🌿",
+    layout="wide",
+    initial_sidebar_state="expanded"
 )
 
-# Title and description
-st.title("🌿 Plant Disease Prediction")
-st.write("Upload an image of a plant leaf to detect potential diseases.")
-
-# Sidebar with information
+# Sidebar with additional information
 with st.sidebar:
-    st.header("About")
-    st.write("This app uses a deep learning model to detect plant diseases from leaf images.")
-    st.write("### How to use:")
-    st.write("1. Upload an image of a plant leaf")
-    st.write("2. The app will process the image")
-    st.write("3. View the prediction results")
-    st.write("\nNote: This is a demo application. For production use, please train on a larger dataset.")
-
-# Constants
-MODEL_PATH = 'plant_disease_model.h5'
-IMG_SIZE = 224
-
-# Class mapping for PlantVillage dataset
-CLASS_NAMES = [
-    'Apple___Apple_scab', 'Apple___Black_rot', 'Apple___Cedar_apple_rust', 'Apple___healthy',
-    'Blueberry___healthy', 'Cherry_(including_sour)___Powdery_mildew', 'Cherry_(including_sour)___healthy',
-    'Corn_(maize)___Cercospora_leaf_spot Gray_leaf_spot', 'Corn_(maize)___Common_rust_',
-    'Corn_(maize)___Northern_Leaf_Blight', 'Corn_(maize)___healthy', 'Grape___Black_rot',
-    'Grape___Esca_(Black_Measles)', 'Grape___Leaf_blight_(Isariopsis_Leaf_Spot)', 'Grape___healthy',
-    'Orange___Haunglongbing_(Citrus_greening)', 'Peach___Bacterial_spot', 'Peach___healthy',
-    'Pepper,_bell___Bacterial_spot', 'Pepper,_bell___healthy', 'Potato___Early_blight',
-    'Potato___Late_blight', 'Potato___healthy', 'Raspberry___healthy', 'Soybean___healthy',
-    'Squash___Powdery_mildew', 'Strawberry___Leaf_scorch', 'Strawberry___healthy',
-    'Tomato___Bacterial_spot', 'Tomato___Early_blight', 'Tomato___Late_blight',
-    'Tomato___Leaf_Mold', 'Tomato___Septoria_leaf_spot', 'Tomato___Spider_mites Two-spotted_spider_mite',
-    'Tomato___Target_Spot', 'Tomato___Tomato_Yellow_Leaf_Curl_Virus', 'Tomato___Tomato_mosaic_virus',
-    'Tomato___healthy'
-]
-
-# Disease information
-DISEASE_INFO = {
-    'Apple___Apple_scab': {
-        'symptoms': 'Olive-green to black, circular spots on leaves that may become raised and velvety.',
-        'treatment': 'Apply fungicides in early spring and remove fallen leaves in autumn.'
-    },
-    'Tomato___Early_blight': {
-        'symptoms': 'Dark, concentric spots on lower leaves that may develop a target-like appearance.',
-        'treatment': 'Use fungicides, remove infected leaves, and ensure good air circulation.'
-    },
-    'default': {
-        'symptoms': 'Consult with a plant pathologist for accurate diagnosis.',
-        'treatment': 'Isolate the plant and consult with a local agricultural extension service.'
-    }
-}
-
-# Default class indices (fallback if file not found)
-DEFAULT_CLASS_INDICES = {
-    'Pepper__bell___Bacterial_spot': 0,
-    'Pepper__bell___healthy': 1,
-    'Potato___Early_blight': 2,
-    'Potato___Late_blight': 3,
-    'Potato___healthy': 4,
-    'Tomato_Bacterial_spot': 5,
-    'Tomato_Early_blight': 6,
-    'Tomato_Late_blight': 7,
-    'Tomato_Leaf_Mold': 8,
-    'Tomato_Septoria_leaf_spot': 9,
-    'Tomato_Spider_mites_Two_spotted_spider_mite': 10,
-    'Tomato__Target_Spot': 11,
-    'Tomato__Tomato_YellowLeaf__Curl_Virus': 12,
-    'Tomato__Tomato_mosaic_virus': 13,
-    'Tomato_healthy': 14
-}
-
-# Load the model and class indices
-@st.cache_resource
-def load_model():
-    try:
-        # Try to load class indices from file, fall back to default if not found
+    st.title("🌿 Plant Disease Classifier")
+    st.write("---")
+    
+    # About section
+    st.subheader("About")
+    st.markdown("""
+    This app helps identify plant diseases using deep learning. 
+    Upload an image of a plant leaf, and the model will predict 
+    the most likely disease affecting it.
+    """)
+    
+    # Supported diseases section
+    st.subheader("Supported Diseases")
+    if st.checkbox("Show supported diseases"):
         try:
             with open('class_indices.json', 'r') as f:
-                class_indices = json.load(f)
-            print("Loaded class indices from file")
-        except FileNotFoundError:
-            class_indices = DEFAULT_CLASS_INDICES
-            print("Using default class indices")
-        
-        # Create model
-        print("Creating model...")
-        model = models.resnet18(weights=None)  # We'll load our own weights
-        num_ftrs = model.fc.in_features
-        model.fc = nn.Linear(num_ftrs, len(class_indices))
-        
-        # Load weights if available
-        try:
-            checkpoint = torch.load('plant_disease_model.pth', map_location=device)
-            model.load_state_dict(checkpoint['model_state_dict'])
-            print("Loaded model weights")
-        except FileNotFoundError:
-            print("Warning: Model weights not found. Using random weights.")
-        
-        model = model.to(device)
-        model.eval()
-        
-        # Reverse the dictionary to get index to class name mapping
-        idx_to_class = {v: k for k, v in class_indices.items()}
-        print(f"Model loaded with {len(idx_to_class)} classes")
-        return model, idx_to_class
-    except Exception as e:
-        import traceback
-        error_details = traceback.format_exc()
-        print(f"Error loading model: {error_details}")
-        st.error(f"Error loading model: {e}")
-        return None, None
+                diseases = json.load(f).values()
+                # Format disease names for better readability
+                formatted_diseases = [d.replace('___', ' ').replace('_', ' ').title() 
+                                    for d in diseases]
+                formatted_diseases.sort()  # Sort alphabetically
+                
+                # Display in two columns for better layout
+                col1, col2 = st.columns(2)
+                half = (len(formatted_diseases) + 1) // 2
+                
+                with col1:
+                    for disease in formatted_diseases[:half]:
+                        st.markdown(f"- {disease}")
+                with col2:
+                    for disease in formatted_diseases[half:]:
+                        st.markdown(f"- {disease}")
+        except Exception as e:
+            st.error("Could not load disease list.")
+    
+    st.write("---")
+    st.markdown("*Upload an image to get started!*")
 
-model, idx_to_class = load_model()
+# Main content
+st.title("🌱 Plant Disease Classifier")
+st.write("Upload an image of a plant leaf to detect potential diseases")
 
-def preprocess_image(img):
-    """Preprocess the image for prediction"""
-    transform = transforms.Compose([
-        transforms.Resize((224, 224)),
-        transforms.ToTensor(),
-        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
-    ])
-    return transform(img).unsqueeze(0).to(device)  # Add batch dimension and move to device
+uploaded_file = st.file_uploader("Choose an image...", type=["jpg", "jpeg", "png"])
 
-def predict_disease(image):
-    if model is None or idx_to_class is None:
-        return "Model not loaded", 0.0
-    
+if uploaded_file is not None:
     try:
-        # Preprocess the image
-        input_tensor = preprocess_image(image)
+        # Display the uploaded image
+        image = Image.open(uploaded_file).convert('RGB')
+        st.image(image, caption='Uploaded Image', use_column_width=True)
         
         # Make prediction
-        with torch.no_grad():
-            output = model(input_tensor)
-            probabilities = torch.nn.functional.softmax(output[0], dim=0)
-            confidence, predicted_idx = torch.max(probabilities, 0)
-            predicted_class = idx_to_class.get(str(predicted_idx.item()), "Unknown")
-            
-        return predicted_class, confidence.item()
-    except Exception as e:
-        st.error(f"Error during prediction: {e}")
-        return "Prediction error", 0.0
-
-def random_predictions():
-    """Generate random predictions for demo purposes."""
-    np.random.seed(42)
-    indices = np.random.choice(len(CLASS_NAMES), 3, replace=False)
-    scores = np.random.dirichlet(np.ones(3), size=1)[0]
-    return list(zip([CLASS_NAMES[i] for i in indices], scores)), 0.1
-
-def display_disease_info(disease_name):
-    """Display detailed information about the predicted disease."""
-    # Get disease information or use default
-    info = DISEASE_INFO.get(disease_name, DISEASE_INFO['default'])
-    
-    st.markdown("### Disease Information")
-    st.markdown(f"**{disease_name.replace('_', ' ').title()}**")
-    
-    # Display symptoms and treatment
-    with st.expander("ℹ️ Symptoms"):
-        st.write(info['symptoms'])
-    
-    with st.expander("💊 Treatment"):
-        st.write(info['treatment'])
-    
-    # Add prevention tips
-    with st.expander("🛡️ Prevention Tips"):
-        st.write("""
-        - Ensure proper spacing between plants for good air circulation
-        - Water at the base of plants to keep foliage dry
-        - Rotate crops to prevent disease buildup in soil
-        - Remove and destroy infected plant material
-        - Use disease-resistant varieties when available
-        """)
-
-def main():
-    # Load the model (cached for performance)
-    model, idx_to_class = load_model()
-    
-    # Check if model loaded successfully
-    if model is None or idx_to_class is None:
-        st.error("⚠️ Failed to load the model. Some features may not work correctly.")
-        st.info("Please check if the model files are present in the correct location.")
-    
-    # Sidebar options
-    with st.sidebar.expander("⚙️ Settings"):
-        confidence_threshold = st.slider(
-            "Minimum Confidence Threshold", 
-            min_value=0.1, 
-            max_value=0.9, 
-            value=0.5, 
-            step=0.1,
-            help="Adjust the minimum confidence level for predictions"
-        )
-    
-    # Main content
-    st.markdown("## 🌱 Plant Disease Detection")
-    st.markdown("Upload an image of a plant leaf to detect potential diseases.")
-    
-    # File uploader
-    st.subheader("Upload an Image")
-    uploaded_file = st.file_uploader("Choose an image...", type=["jpg", "jpeg", "png"])
-    
-    # If no file is uploaded or selected, show a message
-    if uploaded_file is None and 'uploaded_file' not in st.session_state:
-        st.info("👆 Upload an image to get started")
+        with st.spinner('Analyzing...'):
+            predictions = predict(image)
+        
+        # Display results
+        st.subheader("Top Predictions:")
+        for i, pred in enumerate(predictions, 1):
+            st.write(f"{i}. {pred['class']} - {pred['probability']}")
+        
+        # Show confidence level
+        confidence = float(predictions[0]['probability'].strip('%'))
+        if confidence > 80:
+            st.success("✅ High confidence in prediction!")
+        elif confidence > 50:
+            st.warning("⚠️ Moderate confidence in prediction.")
+        else:
+            st.info("ℹ️ Low confidence in prediction. Please ensure the image is clear and shows a plant leaf.")
     
-    if uploaded_file is not None:
-        try:
-            # Reset the file pointer to the beginning
-            if hasattr(uploaded_file, 'seek'):
-                uploaded_file.seek(0)
-                
-            # Display the uploaded image
-            image = Image.open(uploaded_file)
-            st.image(image, caption="Uploaded Image", use_column_width=True)
-            
-            with st.spinner("🔍 Analyzing the image..."):
-                # Preprocess the image
-                processed_image = preprocess_image(image)
-                
-                # Get predictions
-                predictions, inference_time = predict_with_model(model, processed_image, top_k=3)
-                
-                # Filter predictions by confidence threshold
-                filtered_predictions = [(d, s) for d, s in predictions if s >= confidence_threshold]
-                
-                if not filtered_predictions:
-                    st.warning("No predictions met the confidence threshold. Try adjusting the threshold or upload a clearer image.")
-                else:
-                    # Display results in two columns
-                    col1, col2 = st.columns([1, 1])
-                    
-                    with col1:
-                        st.markdown("### 📊 Prediction Results")
-                        
-                        # Create a DataFrame for the predictions
-                        df = pd.DataFrame({
-                            'Disease': [p[0].replace('_', ' ').title() for p in filtered_predictions],
-                            'Confidence': [p[1] for p in filtered_predictions]
-                        })
-                        
-                        # Display as a bar chart
-                        fig = px.bar(
-                            df, 
-                            x='Confidence', 
-                            y='Disease',
-                            orientation='h',
-                            title='Prediction Confidence',
-                            labels={'Confidence': 'Confidence Score', 'Disease': 'Disease'},
-                            color='Confidence',
-                            color_continuous_scale='Viridis'
-                        )
-                        fig.update_layout(showlegend=False)
-                        st.plotly_chart(fig, use_container_width=True)
-                        
-                        # Display inference time
-                        st.caption(f"⚡ Inference time: {inference_time*1000:.1f}ms")
-                    
-                    with col2:
-                        # Display detailed information about the top prediction
-                        top_disease = filtered_predictions[0][0]
-                        display_disease_info(top_disease)
-                    
-                    # Add a section for user feedback
-                    st.markdown("---")
-                    with st.expander("📝 Provide Feedback"):
-                        st.write("Help us improve our model!")
-                        feedback = st.radio(
-                            "Was this prediction accurate?",
-                            ("Yes", "Partially", "No")
-                        )
-                        if st.button("Submit Feedback"):
-                            # In a real app, you would save this feedback
-                            st.success("Thank you for your feedback!")
-            
-            # Add some space at the bottom
-            st.markdown("---")
-            st.markdown("""
-            ### ℹ️ About This Tool
-            This application uses deep learning to identify plant diseases from leaf images. 
-            The model has been trained on the [PlantVillage dataset](https://plantvillage.psu.edu/) 
-            and can detect various plant diseases.
-            
-            **Note:** This is a demonstration application. For real-world use, consult with 
-            agricultural experts and use laboratory testing for accurate disease diagnosis.
-            """)
-            
-        except Exception as e:
-            st.error(f"An error occurred: {str(e)}")
-            st.error("Please try another image or check the console for details.")
-            
-    # Add a footer
-    st.markdown("---")
-    st.markdown("""
-    <div style="text-align: center; color: gray;">
-        <p>🌿 Plant Disease Detection App • Built with Streamlit • 
-        <a href="#" style="color: gray;">Terms of Use</a> • 
-        <a href="#" style="color: gray;">Privacy Policy</a></p>
-    </div>
-    """, unsafe_allow_html=True)
-
-if __name__ == "__main__":
-    main()
+    except Exception as e:
+        st.error(f"An error occurred: {str(e)}")
+        st.info("Please try with a different image or make sure the image is clear and shows a plant leaf.")
+
+# Add some styling
+st.markdown("""
+    <style>
+    .stApp {
+        max-width: 1400px;
+        margin: 0 auto;
+        padding: 1rem;
+    }
+    .stButton>button {
+        background-color: #4CAF50;
+        color: white;
+    }
+    .sidebar .sidebar-content {
+        background-color: #f8f9fa;
+    }
+    .stMarkdown h2 {
+        color: #2e7d32;
+    }
+    .stMarkdown h3 {
+        color: #388e3c;
+    }
+    </style>
+""", unsafe_allow_html=True)

app_resnet9.py

@@ -0,0 +1,209 @@
+import streamlit as st
+import torch
+import torch.nn as nn
+import torchvision.transforms as transforms
+from PIL import Image
+import json
+import numpy as np
+from pathlib import Path
+
+# Page config
+st.set_page_config(
+    page_title="Plant Disease Classifier",
+    page_icon="🌱",
+    layout="wide"
+)
+
+# Custom CSS
+st.markdown("""
+<style>
+    .main {
+        max-width: 1000px;
+        padding: 2rem;
+    }
+    .title {
+        text-align: center;
+        color: #2e8b57;
+    }
+    .prediction {
+        font-size: 1.2rem;
+        padding: 1rem;
+        border-radius: 0.5rem;
+        margin-top: 1rem;
+    }
+    .healthy {
+        background-color: #d4edda;
+        color: #155724;
+    }
+    .diseased {
+        background-color: #f8d7da;
+        color: #721c24;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Model class (same as in training)
+class ConvBlock(nn.Module):
+    def __init__(self, in_channels, out_channels, pool=False):
+        super().__init__()
+        layers = [
+            nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1),
+            nn.BatchNorm2d(out_channels),
+            nn.ReLU(inplace=True)
+        ]
+        if pool:
+            layers.append(nn.MaxPool2d(2))
+        self.conv = nn.Sequential(*layers)
+    
+    def forward(self, x):
+        return self.conv(x)
+
+class ResNet9(nn.Module):
+    def __init__(self, in_channels, num_classes):
+        super().__init__()
+        
+        self.conv1 = ConvBlock(in_channels, 64)
+        self.conv2 = ConvBlock(64, 128, pool=True)
+        self.res1 = nn.Sequential(ConvBlock(128, 128), ConvBlock(128, 128))
+        
+        self.conv3 = ConvBlock(128, 256, pool=True)
+        self.conv4 = ConvBlock(256, 512, pool=True)
+        self.res2 = nn.Sequential(ConvBlock(512, 512), ConvBlock(512, 512))
+        
+        self.classifier = nn.Sequential(
+            nn.AdaptiveAvgPool2d(1),
+            nn.Flatten(),
+            nn.Dropout(0.2),
+            nn.Linear(512, num_classes)
+        )
+    
+    def forward(self, xb):
+        out = self.conv1(xb)
+        out = self.conv2(out)
+        out = self.res1(out) + out
+        out = self.conv3(out)
+        out = self.conv4(out)
+        out = self.res2(out) + out
+        out = self.classifier(out)
+        return out
+
+# Load class indices
+@st.cache_data
+def load_class_indices():
+    with open('class_indices.json', 'r') as f:
+        return json.load(f)
+
+# Load model
+@st.cache_resource
+def load_model():
+    class_indices = load_class_indices()
+    model = ResNet9(3, len(class_indices))
+    model.load_state_dict(torch.load('plant_disease_resnet9.pth', map_location=torch.device('cpu')))
+    model.eval()
+    return model
+
+# Preprocess image
+def preprocess_image(image):
+    transform = transforms.Compose([
+        transforms.Resize((256, 256)),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+    ])
+    return transform(image).unsqueeze(0)
+
+# Predict function
+def predict(image, model, class_indices):
+    idx_to_class = {int(k): v for k, v in class_indices.items()}
+    
+    # Preprocess
+    input_tensor = preprocess_image(image)
+    
+    # Predict
+    with torch.no_grad():
+        output = model(input_tensor)
+        probabilities = torch.nn.functional.softmax(output[0], dim=0)
+        confidence, predicted_idx = torch.max(probabilities, 0)
+        predicted_class = idx_to_class[predicted_idx.item()]
+        
+    return predicted_class, confidence.item()
+
+# Main app
+def main():
+    st.title("🌱 Plant Disease Classifier")
+    st.markdown("---")
+    
+    # Load model and class indices
+    try:
+        model = load_model()
+        class_indices = load_class_indices()
+        idx_to_class = {int(k): v for k, v in class_indices.items()}
+    except Exception as e:
+        st.error(f"Error loading model: {str(e)}")
+        st.info("Please make sure you have trained the model first by running 'python resnet9_train.py'")
+        return
+    
+    # File uploader
+    uploaded_file = st.file_uploader("Upload an image of a plant leaf", type=["jpg", "jpeg", "png"])
+    
+    if uploaded_file is not None:
+        # Display image
+        image = Image.open(uploaded_file).convert('RGB')
+        st.image(image, caption='Uploaded Image', use_column_width=True)
+        
+        # Make prediction
+        with st.spinner('Analyzing...'):
+            predicted_class, confidence = predict(image, model, class_indices)
+            
+            # Display result
+            plant, status = predicted_class.split('___')
+            is_healthy = status == 'healthy'
+            
+            st.markdown("### Prediction Result")
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.metric("Plant", plant.replace('_', ' ').title())
+            with col2:
+                status_display = "Healthy 🟢" if is_healthy else "Diseased 🔴"
+                st.metric("Status", status_display)
+            
+            if not is_healthy:
+                st.metric("Disease", status.replace('_', ' ').title())
+            
+            st.metric("Confidence", f"{confidence*100:.2f}%")
+            
+            # Show info based on prediction
+            if is_healthy:
+                st.success(f"This {plant.replace('_', ' ').lower()} leaf appears to be healthy!")
+            else:
+                st.warning(f"This {plant.replace('_', ' ').lower()} leaf shows signs of {status.replace('_', ' ').lower()}.")
+                
+                # Add some general advice (you can expand this)
+                st.info("""
+                **Recommendations:**
+                - Isolate the affected plant to prevent spread
+                - Remove severely infected leaves
+                - Consider using appropriate fungicides/pesticides
+                - Ensure proper spacing and air circulation
+                - Maintain optimal watering practices
+                """)
+    else:
+        st.info("Please upload an image of a plant leaf to check for diseases.")
+    
+    # Add some information about the model
+    st.markdown("---")
+    st.markdown("""
+    ### About this App
+    This app uses a ResNet9 deep learning model to identify plant diseases from leaf images. 
+    It can detect 38 different classes of plant diseases across 14 plant species.
+    
+    **How to use:**
+    1. Upload an image of a plant leaf
+    2. The model will analyze the image
+    3. View the prediction and recommendations
+    
+    **Note:** For best results, use clear, well-lit photos of individual leaves.
+    """)
+
+if __name__ == "__main__":
+    main()

class_indices.json

@@ -1 +1 @@
-{"Pepper__bell___Bacterial_spot": 0, "Pepper__bell___healthy": 1, "Potato___Early_blight": 2, "Potato___Late_blight": 3, "Potato___healthy": 4, "Tomato_Bacterial_spot": 5, "Tomato_Early_blight": 6, "Tomato_Late_blight": 7, "Tomato_Leaf_Mold": 8, "Tomato_Septoria_leaf_spot": 9, "Tomato_Spider_mites_Two_spotted_spider_mite": 10, "Tomato__Target_Spot": 11, "Tomato__Tomato_YellowLeaf__Curl_Virus": 12, "Tomato__Tomato_mosaic_virus": 13, "Tomato_healthy": 14}
+{"0": "Apple___Apple_scab", "1": "Apple___Black_rot", "2": "Apple___Cedar_apple_rust", "3": "Apple___healthy", "4": "Blueberry___healthy", "5": "Cherry_including_sour___Powdery_mildew", "6": "Cherry_including_sour___healthy", "7": "Corn_maize___Cercospora_leaf_spot_Gray_leaf_spot", "8": "Corn_maize___Common_rust_", "9": "Corn_maize___Northern_Leaf_Blight", "10": "Corn_maize___healthy", "11": "Grape___Black_rot", "12": "Grape___Esca_Black_Measles", "13": "Grape___Leaf_blight_Isariopsis_Leaf_Spot", "14": "Grape___healthy", "15": "Orange___Haunglongbing_Citrus_greening", "16": "Peach___Bacterial_spot", "17": "Peach___healthy", "18": "Pepper_bell___Bacterial_spot", "19": "Pepper_bell___healthy", "20": "Potato___Early_blight", "21": "Potato___Late_blight", "22": "Potato___healthy", "23": "Raspberry___healthy", "24": "Soybean___healthy", "25": "Squash___Powdery_mildew", "26": "Strawberry___Leaf_scorch", "27": "Strawberry___healthy", "28": "Tomato___Bacterial_spot", "29": "Tomato___Early_blight", "30": "Tomato___Late_blight", "31": "Tomato___Leaf_Mold", "32": "Tomato___Septoria_leaf_spot", "33": "Tomato___Spider_mites_Two-spotted_spider_mite", "34": "Tomato___Target_Spot", "35": "Tomato___Tomato_Yellow_Leaf_Curl_Virus", "36": "Tomato___Tomato_mosaic_virus", "37": "Tomato___healthy"}

plant_disease_model.pth

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

requirements.txt

@@ -1,9 +1,42 @@
+# Core dependencies
 streamlit>=1.29.0
-torch>=2.0.0
-torchvision>=0.15.0
-numpy>=1.19.0
-Pillow>=8.0.0
-matplotlib>=3.3.0
-plotly>=5.0.0
-pandas>=1.0.0
-tqdm>=4.65.0
+
+# PyTorch and vision
+torch>=2.2.2
+torchvision>=0.17.2
+torchaudio>=2.2.2
+
+# Data processing
+numpy>=1.26.0
+Pillow>=10.0.0
+
+# Image processing
+opencv-python>=4.8.0
+
+# Utilities
+tqdm>=4.66.0
+matplotlib>=3.7.0
+pandas>=2.2.0
+Pillow>=10.0.0
+
+# Visualization
+matplotlib>=3.8.0
+plotly>=5.18.0
+seaborn>=0.13.0
+
+# Model management
+huggingface_hub>=0.20.0
+
+# Utilities
+tqdm>=4.66.0
+requests>=2.31.0
+python-dotenv>=1.0.0
+
+# Image processing
+opencv-python-headless>=4.8.0
+albumentations>=1.3.1
+
+# Development
+scikit-learn>=1.4.0
+ipykernel>=6.29.0
+jupyter>=1.0.0

space.yml

@@ -0,0 +1,10 @@
+title: Plant Disease Detection
+emoji: 🌿
+colorFrom: green
+colorTo: blue
+sdk: docker
+app_file: app_resnet9.py
+app_port: 8501
+pinned: false
+duplicate: false
+license: mit