update app, and requitemts

app.py

@@ -1,98 +1,94 @@
 import streamlit as st
 import torch
 from torchvision import transforms
-from PIL import Image, ImageDraw, ImageFont
+from PIL import Image
 import numpy as np
-import time
 
-# Simplified YOLO-style model definition (Pillow-only version)
-class PlantDiseaseModel(torch.nn.Module):
+# Custom model class (replace with your actual architecture)
+class PlantDiseaseClassifier(torch.nn.Module):
     def __init__(self, num_classes=2):
         super().__init__()
-        # Example backbone (replace with your actual model architecture)
-        self.model = torch.hub.load('ultralytics/yolov5', 'yolov5s', pretrained=True)
-        self.model.classes = num_classes  # Set your number of classes
-
+        # Example architecture - REPLACE WITH YOUR ACTUAL MODEL
+        self.model = torch.nn.Sequential(
+            torch.nn.Conv2d(3, 16, kernel_size=3, padding=1),
+            torch.nn.ReLU(),
+            torch.nn.MaxPool2d(2),
+            torch.nn.Conv2d(16, 32, kernel_size=3, padding=1),
+            torch.nn.ReLU(),
+            torch.nn.MaxPool2d(2),
+            torch.nn.Flatten(),
+            torch.nn.Linear(32*56*56, num_classes)  # Adjust input dimensions
+        )
+    
     def forward(self, x):
         return self.model(x)
 
-# Load model 
 @st.cache_resource
 def load_model():
-    model = PlantDiseaseModel(num_classes=2)  # Update class count
+    model = PlantDiseaseClassifier(num_classes=2)  # Update with your class count
     try:
         model.load_state_dict(torch.load('best_model.pth', map_location='cpu'))
-    except:
-        st.warning("Using pretrained weights (custom weights not found)")
+        st.success("Model loaded successfully!")
+    except Exception as e:
+        st.error(f"Error loading model: {str(e)}")
     return model
 
-# Draw bounding boxes with Pillow
-def draw_boxes_pillow(image, predictions):
-    """Draw boxes/labels on image using Pillow only"""
-    draw = ImageDraw.Draw(image)
-    try:
-        font = ImageFont.load_default()
-        for _, row in predictions.iterrows():
-            xmin, ymin, xmax, ymax = row['xmin'], row['ymin'], row['xmax'], row['ymax']
-            label = f"{row['name']} {row['confidence']:.2f}"
-            
-            # Draw rectangle
-            draw.rectangle([xmin, ymin, xmax, ymax], outline="red", width=3)
-            
-            # Draw label background
-            text_width, text_height = font.getsize(label)
-            draw.rectangle([xmin, ymin-text_height, xmin+text_width, ymin], fill="red")
-            
-            # Draw text
-            draw.text((xmin, ymin-text_height), label, fill="white", font=font)
-    except Exception as e:
-        st.error(f"Error drawing boxes: {str(e)}")
-    return image
+def predict(image, model, class_names):
+    """Run prediction and return top class"""
+    transform = transforms.Compose([
+        transforms.Resize(256),
+        transforms.CenterCrop(224),
+        transforms.ToTensor(),
+        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
+    ])
+    
+    input_tensor = transform(image).unsqueeze(0)
+    
+    with torch.no_grad():
+        output = model(input_tensor)
+        probabilities = torch.nn.functional.softmax(output[0], dim=0)
+        top_prob, top_class = torch.topk(probabilities, 1)
+        
+    return class_names[top_class.item()], top_prob.item()
 
 def main():
-    st.set_page_config(page_title="Plant Disease Detector", layout="wide")
-    st.title("🌱 Plant Disease Detection (Tomato or Corn Maiza)")
+    st.title("🌱 Plant Disease Classifier")
     
-    model = load_model()
+    # Update with your actual class names and care tips
+    CLASS_NAMES = {
+        0: "Healthy",
+        1: "Late Blight",
+        2: "Powdery Mildew"  # Add all your classes
+    }
+    
+    CARE_TIPS = {
+        "Healthy": ["Continue regular watering", "Monitor plant growth"],
+        "Late Blight": ["Remove infected leaves", "Apply fungicide"],
+        "Powdery Mildew": ["Improve air circulation", "Apply sulfur spray"]
+    }
     
-    # File uploader
-    uploaded_file = st.file_uploader("Upload a plant image...", type=["jpg", "jpeg", "png"])
+    model = load_model()
+    uploaded_file = st.file_uploader("Upload plant image", type=["jpg", "png", "jpeg"])
     
-    if uploaded_file is not None:
-        # Load with Pillow
+    if uploaded_file and model is not None:
         image = Image.open(uploaded_file).convert("RGB")
         col1, col2 = st.columns(2)
         
         with col1:
-            st.image(image, caption="Original Image", use_column_width=True)
+            st.image(image, caption="Uploaded Image", use_column_width=True)
         
-        # Process and predict
         with st.spinner("Analyzing..."):
-            # Convert to tensor (Pillow-compatible preprocessing)
-            transform = transforms.Compose([
-                transforms.Resize(640),
-                transforms.ToTensor(),
-            ])
-            input_tensor = transform(image).unsqueeze(0)
-            
-            # Predict
-            with torch.no_grad():
-                results = model(input_tensor)
+            predicted_class, confidence = predict(image, model, CLASS_NAMES)
             
-            # Convert results to Pandas
-            try:
-                results_df = results.pandas().xyxy[0]
+            with col2:
+                if "healthy" in predicted_class.lower():
+                    st.success(f"Prediction: {predicted_class} ({confidence*100:.1f}%)")
+                else:
+                    st.error(f"Prediction: {predicted_class} ({confidence*100:.1f}%)")
                 
-                # Draw boxes using Pillow
-                output_image = image.copy()
-                output_image = draw_boxes_pillow(output_image, results_df)
-                
-                with col2:
-                    st.image(output_image, caption="Detection Results", use_column_width=True)
-                    st.dataframe(results_df[['name', 'confidence', 'xmin', 'ymin', 'xmax', 'ymax']])
-            
-            except Exception as e:
-                st.error(f"Prediction error: {str(e)}")
+                st.subheader("Care Recommendations")
+                for tip in CARE_TIPS.get(predicted_class, ["No specific recommendations"]):
+                    st.write(f"• {tip}")
 
 if __name__ == "__main__":
     main()

requirements.txt

@@ -1,10 +1,5 @@
-torch>=2.2.2
-torchvision>=0.17.2
-streamlit>=1.29.0
+torch>=2.0.0
+torchvision>=0.15.0
+streamlit>=1.25.0
 Pillow>=10.0.0
-PyYAML>=6.0.1
-pandas>=2.1.0
-scikit-learn>=1.3.0
-tqdm>=4.65.0
-numpy==1.26.4
-opencv-python-headless>=4.8.0.76  # Updated to available version
+numpy>=1.20.0