Update app.py

app.py

@@ -1,92 +1,176 @@
-import gradio as gr
 import torch
 import torch.nn as nn
-from torchvision import models, transforms
+import torchvision.models as models
+import torchvision.transforms as transforms
 from PIL import Image
-import numpy as np
-import warnings
+import gradio as gr
+from disease_info import get_disease_info
+from flask import Flask, render_template
+import threading
+import socket
+from warnings import filterwarnings
+
+# Suppress deprecation warnings
+filterwarnings("ignore", category=UserWarning)
+
+# ========== MODEL DEFINITION ==========
+class Plant_Disease_VGG16(nn.Module):
+    def __init__(self):
+        super().__init__()
+        weights = models.VGG16_Weights.IMAGENET1K_V1
+        self.network = models.vgg16(weights=weights)
+        # Freeze early layers
+        for param in list(self.network.features.parameters())[:-5]:
+            param.requires_grad = False
+        # Modify final layer
+        num_ftrs = self.network.classifier[-1].in_features
+        self.network.classifier[-1] = nn.Linear(num_ftrs, 38)  # 38 classes
+
+    def forward(self, xb):
+        return self.network(xb)
 
-# SUPPRESS ALL WARNINGS - NO OTHER CHANGES MADE
-warnings.filterwarnings("ignore")
-torch.set_warn_always(False)
+# Initialize model
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+model = Plant_Disease_VGG16()
+model.load_state_dict(torch.load("model/vgg_model_ft.pth", map_location=device))
+model.to(device)
+model.eval()
 
-# YOUR ORIGINAL CODE EXACTLY AS YOU HAD IT:
-class_names = [
+# Class labels
+class_labels = [
     '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)___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___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'
 ]
 
-def load_model(model_path):
-    model = models.vgg16(pretrained=False)
-    num_features = model.classifier[6].in_features
-    model.classifier[6] = nn.Linear(num_features, len(class_names))
-    model.load_state_dict(torch.load(model_path, map_location=torch.device('cpu')))
-    model.eval()
-    return model
-
+# Image preprocessing
 transform = transforms.Compose([
-    transforms.Resize((128, 128)),
+    transforms.Resize((224, 224)),
     transforms.ToTensor(),
-    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
 ])
 
+def parse_class_label(class_label):
+    """Extract plant and disease from class label"""
+    parts = class_label.split('___')
+    plant = parts[0].replace('_', ' ').replace(',', '')
+    disease = parts[1].replace('_', ' ') if len(parts) > 1 else "healthy"
+    return plant, disease
+
 def predict(image):
-    image = Image.fromarray(image.astype('uint8'), 'RGB')
-    image = transform(image).unsqueeze(0)
-    
-    with torch.no_grad():
-        output = model(image)
-        probabilities = torch.nn.functional.softmax(output[0], dim=0)
-        confidences = {class_names[i]: float(probabilities[i]) for i in range(len(class_names))}
-    
-    top_pred = max(confidences, key=confidences.get)
-    plant = top_pred.split('___')[0]
-    disease = top_pred.split('___')[1]
-    
-    return {
-        "Plant": plant,
-        "Disease": disease,
-        "Confidence": confidences[top_pred],
-        "All Predictions": confidences
-    }
-
-model_path = "model/vgg_model_ft.pth"
-model = load_model(model_path)
-
-title = "Plant Disease Classifier"
-description = """
-Upload an image of a plant leaf to classify its health status. The model can detect diseases across 14 plant types and 38 disease categories.
+    """Make prediction on input image"""
+    try:
+        if image is None:
+            return "Error: No image provided"
+            
+        # Preprocess and predict
+        image = transform(image).unsqueeze(0).to(device)
+        with torch.no_grad():
+            preds = model(image)
+            probabilities = torch.nn.functional.softmax(preds[0], dim=0)
+        
+        # Get top prediction
+        top_prob, top_idx = torch.max(probabilities, 0)
+        class_name = class_labels[top_idx.item()]
+        plant, disease = parse_class_label(class_name)
+        
+        # Get disease info
+        disease_info = get_disease_info(plant, disease)
+        
+        # Format results
+        result = f"""
+Plant: {plant}
+Disease: {disease}
+
+Description:
+{disease_info['description']}
+
+Recommended Treatments:
+{disease_info['pesticides']}
+
+Application Timing:
+{disease_info['timing']}
+
+Prevention Measures:
+{disease_info['prevention']}
 """
+        return result
+        
+    except Exception as e:
+        return f"Error in prediction: {str(e)}"
 
-examples = [
-    ["example_images/healthy_apple.jpg"],
-    ["example_images/diseased_tomato.jpg"]
-]
+# ========== WEB APPLICATION ==========
+def find_available_port(start_port):
+    """Find next available port from start_port"""
+    port = start_port
+    while True:
+        try:
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                s.bind(('0.0.0.0', port))
+                return port
+        except OSError:
+            port += 1
 
+app = Flask(__name__)
+
+# Gradio Interface
 iface = gr.Interface(
     fn=predict,
-    inputs=gr.Image(label="Upload Plant Leaf Image"),
-    outputs=[
-        gr.Label(label="Plant"),
-        gr.Label(label="Disease Status"),
-        gr.Label(label="Confidence"),
-        gr.Label(label="All Predictions")
-    ],
-    title=title,
-    description=description,
-    examples=examples,
-    allow_flagging="never"
+    inputs=gr.Image(type="pil"),
+    outputs=gr.Textbox(label="Analysis Results", lines=20),
+    title="GREEN PULSE - Plant Health Analysis",
+    description="Upload an image of a plant leaf to detect health issues.",
+    examples=[
+        ["examples/healthy_apple.jpg"],
+        ["examples/diseased_tomato.jpg"]
+    ]
 )
 
-iface.launch()
+def run_gradio():
+    """Launch Gradio in separate thread"""
+    global gradio_port
+    gradio_port = find_available_port(7860)
+    print(f"\nGradio interface running on port: {gradio_port}")
+    iface.launch(
+        server_name="0.0.0.0",
+        server_port=gradio_port,
+        share=False,
+        prevent_thread_lock=True
+    )
+
+# Start Gradio thread
+gradio_port = 7860  # Default
+gradio_thread = threading.Thread(target=run_gradio, daemon=True)
+gradio_thread.start()
+
+# Flask Routes
+@app.route('/')
+def home():
+    """Main landing page"""
+    return render_template("index.html")
+
+@app.route('/analyze')
+def analyze():
+    """Page with embedded Gradio interface"""
+    return render_template("analyze.html", gradio_port=gradio_port)
+
+@app.route('/results')
+def results():
+    """Results display page"""
+    return render_template("results.html")
+
+if __name__ == '__main__':
+    """Main application entry point"""
+    flask_port = find_available_port(5000)
+    print(f"Flask server running on port: {flask_port}")
+    print(f"Access the app at: http://localhost:{flask_port}")
+    app.run(debug=True, port=flask_port, use_reloader=False)