Upload 9 files

README.md

@@ -1,13 +1,52 @@
----
-title: GreenPulse
-emoji: 🔥
-colorFrom: purple
-colorTo: yellow
-sdk: gradio
-sdk_version: 5.29.0
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Plant Disease Detection System
+
+This system uses a VGG16 model to detect plant diseases from leaf images and provides detailed information about the disease, including treatment recommendations and prevention measures using the Mistral AI API.
+
+## Features
+
+- Plant disease detection using VGG16 model
+- Detailed disease information including:
+  - Disease description
+  - Recommended pesticides
+  - Pesticide application timing
+  - Prevention measures
+- User-friendly Gradio interface
+
+## Setup
+
+1. Clone the repository
+2. Install dependencies:
+   ```bash
+   pip install -r requirements.txt
+   ```
+3. Set up your Mistral API key:
+   - Create a `.env` file in the project root
+   - Add your Mistral API key:
+     ```
+     MISTRAL_API_KEY=your_api_key_here
+     ```
+
+## Usage
+
+1. Run the application:
+   ```bash
+   python model.py
+   ```
+2. Open the Gradio interface in your web browser
+3. Upload an image of a plant leaf
+4. View the disease detection results and detailed information
+
+## Model Information
+
+The system can detect 38 different conditions across multiple plant species, including:
+- Apple diseases
+- Tomato diseases
+- Potato diseases
+- Grape diseases
+- And more...
+
+## Requirements
+
+- Python 3.8+
+- CUDA-capable GPU (optional, for faster inference)
+- Mistral API key 

app.py

@@ -1,176 +1,100 @@
-import torch
-import torch.nn as nn
-import torchvision.models as models
-import torchvision.transforms as transforms
-from PIL import Image
-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)
-
-# 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()
-
-# 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)___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'
-]
-
-# Image preprocessing
-transform = transforms.Compose([
-    transforms.Resize((224, 224)),
-    transforms.ToTensor(),
-])
-
-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):
-    """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)}"
-
-# ========== 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(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"]
-    ]
-)
-
-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)
+import gradio as gr
+import torch
+import torch.nn as nn
+from torchvision import models, transforms
+from PIL import Image
+import numpy as np
+
+# Define the class names (from the notebook)
+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'
+]
+
+# Load your trained model
+def load_model(model_path):
+    # Initialize the model (same architecture as used in training)
+    model = models.vgg16(pretrained=False)
+    num_features = model.classifier[6].in_features
+    model.classifier[6] = nn.Linear(num_features, len(class_names))
+    
+    # Load the trained weights
+    model.load_state_dict(torch.load(model_path, map_location=torch.device('cpu')))
+    model.eval()
+    return model
+
+# Define image transformations (same as during training)
+transform = transforms.Compose([
+    transforms.Resize((128, 128)),
+    transforms.ToTensor(),
+    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+])
+
+# Prediction function
+def predict(image):
+    # Convert Gradio's numpy array to PIL Image
+    image = Image.fromarray(image.astype('uint8'), 'RGB')
+    
+    # Apply transformations
+    image = transform(image).unsqueeze(0)
+    
+    # Make prediction
+    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))}
+    
+    # Extract plant name and disease status
+    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
+    }
+
+# Load your trained model
+model_path = "model/vgg_model_ft.pth"  # Update this path if needed
+model = load_model(model_path)
+
+# Create Gradio interface
+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.
+"""
+
+examples = [
+    ["example_images/healthy_apple.jpg"],  # You should provide some example images
+    ["example_images/diseased_tomato.jpg"]
+]
+
+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"
+)
+
+iface.launch()

demo.py

@@ -0,0 +1,120 @@
+import gradio as gr
+from PIL import Image
+import random
+import time
+import os
+
+# --- Sample Output (Simulated ML Prediction Result) ---
+sample_output = {
+    "Apple___healthy": {
+        "disease_name": "Healthy",
+        "crop": "Apple",
+        "description": "This Apple leaf shows no signs of disease. The plant appears healthy.",
+        "cause": "No disease detected.",
+        "prevention": "Continue with good agricultural practices like clean pruning, proper spacing, and pest monitoring.",
+        "pesticide": {
+            "name": "No pesticide needed",
+            "type": "None",
+            "timing": "N/A",
+            "image_url": "https://yourcdn.com/images/no_pesticide.jpg"
+        },
+        "sample_images": [
+            "dataset/Apple___healthy/image1.jpg",
+            "dataset/Apple___healthy/image2.jpg",
+            "dataset/Apple___healthy/image3.jpg"
+        ],
+        "summary_prompt": "The Apple leaf appears healthy. No signs of disease. Maintain good care and monitor regularly."
+    }
+}
+
+TIPS = [
+    "🩴 Always water plants early in the morning to reduce evaporation.",
+    "🌞 Keep leaves dry to prevent fungal diseases.",
+    "🩹 Clean tools after pruning to stop disease spread.",
+    "🎾 Rotate crops every season to maintain soil health.",
+    "🪪 Check for pest damage under the leaves too!"
+]
+
+def predict_disease(username, location_method, manual_location, gps_coords, image):
+    user_location = manual_location if location_method == "Manual Entry" else gps_coords
+
+    # Simulate Prediction
+    time.sleep(2)
+    predicted_label = "Apple___healthy"
+    confidence = 0.94
+    result = sample_output.get(predicted_label)
+
+    if not result:
+        return "Could not detect disease.", None, None, None, None, None, None, None, None, None
+
+    # Alerts based on location
+    alerts = {
+        "Punjab": ["Wheat Rust", "Cotton Leaf Curl"],
+        "West Bengal": ["Rice Blast", "Bacterial Leaf Blight"],
+        "Maharashtra": ["Powdery Mildew", "Leaf Spot"]
+    }
+    disease_alerts = alerts.get(user_location, ["No major alerts"])
+
+    return (
+        f"✅ Prediction Complete: {result['disease_name']} ({result['crop']})", 
+        f"{int(confidence * 100)}%", 
+        result['description'],
+        result['cause'],
+        result['prevention'],
+        result['pesticide'],
+        result['sample_images'],
+        random.choice(TIPS),
+        user_location,
+        ", ".join(disease_alerts)
+    )
+
+def dr_green_chat(user_query):
+    q = user_query.lower()
+    if "apple" in q and "healthy" in q:
+        return "An apple leaf with no spots or discoloration is likely healthy. Continue regular monitoring and good practices."
+    elif "pesticide" in q:
+        return "Choose pesticides based on the specific disease. Always follow recommended guidelines and timings."
+    elif "how to use" in q or "guide" in q:
+        return "Upload a clear leaf image and click 'Predict Disease'. Ask anything in the chat!"
+    else:
+        return "I'm Dr. Green 🌿, your plant health assistant! Ask me about diseases, care, or anything green."
+
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="green")) as demo:
+    gr.Markdown("# 🌱 GREENPULSE - AI-Powered Leaf Disease Detection")
+
+    with gr.Row():
+        username = gr.Textbox(label="Username", placeholder="e.g., farmer123")
+        location_method = gr.Radio(["Manual Entry", "Detect via GPS"], label="Location Method", value="Manual Entry")
+
+    with gr.Row():
+        manual_location = gr.Textbox(label="Manual Location", placeholder="e.g., Punjab")
+        gps_coords = gr.Textbox(label="GPS Coordinates", placeholder="e.g., 30.7333,76.7794")
+
+    image = gr.Image(type="filepath", label="Upload Leaf Image")
+    predict_btn = gr.Button("🔍 Predict Disease")
+
+    result_msg = gr.Textbox(label="Result")
+    confidence = gr.Textbox(label="Health Confidence")
+    description = gr.Textbox(label="Description")
+    cause = gr.Textbox(label="Cause")
+    prevention = gr.Textbox(label="Prevention")
+    pesticide_info = gr.Textbox(label="Pesticide Details")
+    sample_gallery = gr.Gallery(label="Sample Images", columns=3, rows=1)
+    tip = gr.Textbox(label="💡 Daily Tip")
+    detected_location = gr.Textbox(label="Detected Location")
+    alerts_output = gr.Textbox(label="Disease Alerts")
+
+    predict_btn.click(
+        predict_disease,
+        inputs=[username, location_method, manual_location, gps_coords, image],
+        outputs=[result_msg, confidence, description, cause, prevention, pesticide_info, sample_gallery, tip, detected_location, alerts_output]
+    )
+
+    gr.Markdown("---")
+    gr.Markdown("## 🧑‍🌾 Ask Dr. Green")
+    user_question = gr.Textbox(label="Ask your question")
+    dr_response = gr.Textbox(label="Dr. Green Says")
+    user_question.change(dr_green_chat, inputs=user_question, outputs=dr_response)
+
+if __name__ == "__main__":
+    demo.launch()

disease_info.py

@@ -0,0 +1,130 @@
+import os
+import requests
+import json
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# API configuration
+API_KEY = "wfGjHNCbHYuLio66x5CGMANSnD8QVXYy"
+API_URL = "https://api.mistral.ai/v1/chat/completions"
+HEADERS = {
+    "Authorization": f"Bearer {API_KEY}",
+    "Content-Type": "application/json"
+}
+
+def get_disease_info(plant_name: str, disease_name: str) -> dict:
+    """
+    Get detailed information about a plant disease using Mistral API
+    """
+    try:
+        # Construct the prompt
+        prompt = f"""
+        You are an expert in plant pathology. Please provide detailed information about {disease_name} in {plant_name} plants.
+        Provide the following information in a structured format:
+        1. Disease description
+        2. Recommended pesticides (if any)
+        3. Pesticide application timing
+        4. Prevention measures
+        
+        Format the response as a JSON object with these keys:
+        - description
+        - pesticides
+        - timing
+        - prevention
+        
+        Example response format:
+        {{
+            "description": "Detailed description of the disease",
+            "pesticides": "List of recommended pesticides",
+            "timing": "When to apply pesticides",
+            "prevention": "Prevention measures"
+        }}
+        """
+        
+        print(f"Querying Mistral API for {plant_name} - {disease_name}")
+        
+        # Prepare the request payload
+        payload = {
+            "model": "mistral-tiny",
+            "messages": [{"role": "user", "content": prompt}],
+            "temperature": 0.7
+        }
+        
+        print("Making API request...")
+        # Make API call
+        response = requests.post(API_URL, headers=HEADERS, json=payload)
+        print(f"API Response Status: {response.status_code}")
+        
+        if response.status_code != 200:
+            print(f"API Error Response: {response.text}")
+            raise Exception(f"API request failed with status {response.status_code}")
+        
+        response_data = response.json()
+        print("Received API response")
+        
+        # Extract the content from the response
+        content = response_data["choices"][0]["message"]["content"]
+        print("Extracted content from response")
+        
+        # Try to parse the content as JSON
+        try:
+            # First, try to find JSON in the content
+            json_start = content.find('{')
+            json_end = content.rfind('}') + 1
+            if json_start != -1 and json_end != 0:
+                json_str = content[json_start:json_end]
+                disease_info = json.loads(json_str)
+            else:
+                disease_info = json.loads(content)
+            
+            print("Successfully parsed JSON response")
+            
+            # Ensure all required fields are present and properly formatted
+            required_fields = ["description", "pesticides", "timing", "prevention"]
+            for field in required_fields:
+                if field not in disease_info:
+                    disease_info[field] = f"No {field} information available"
+                else:
+                    # Clean up the field value
+                    value = disease_info[field]
+                    if isinstance(value, str):
+                        # Remove any JSON formatting if present
+                        if value.strip().startswith('{') and value.strip().endswith('}'):
+                            try:
+                                value = json.loads(value)
+                                if isinstance(value, dict) and field in value:
+                                    disease_info[field] = value[field]
+                            except:
+                                pass
+                        disease_info[field] = value.strip()
+            
+            return disease_info
+        except json.JSONDecodeError as e:
+            print(f"JSON Parse Error: {str(e)}")
+            print(f"Raw content: {content}")
+            # If not valid JSON, use the raw content
+            return {
+                "description": content,
+                "pesticides": "Please check the description for pesticide information",
+                "timing": "Please check the description for timing information",
+                "prevention": "Please check the description for prevention measures"
+            }
+    
+    except requests.exceptions.RequestException as e:
+        print(f"Request Error: {str(e)}")
+        return {
+            "description": f"Error retrieving disease information: {str(e)}",
+            "pesticides": "Error retrieving pesticide information",
+            "timing": "Error retrieving timing information",
+            "prevention": "Error retrieving prevention information"
+        }
+    except Exception as e:
+        print(f"Unexpected Error: {str(e)}")
+        return {
+            "description": f"Unexpected error: {str(e)}",
+            "pesticides": "Error retrieving pesticide information",
+            "timing": "Error retrieving timing information",
+            "prevention": "Error retrieving prevention information"
+        } 

error_fixes.py

@@ -0,0 +1,139 @@
+import torch
+import torch.nn as nn
+import torchvision.models as models
+import torchvision.transforms as transforms
+from PIL import Image
+import gradio as gr
+import numpy as np
+
+# Define your model class (same as during training)
+class Plant_Disease_VGG16(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.network = models.vgg16(pretrained=True)
+        for param in list(self.network.features.parameters())[:-5]:
+            param.requires_grad = False
+        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)
+
+# Load the 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()
+
+# Class labels with plant and disease information
+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)___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'
+]
+
+# Enhanced preprocessing
+def preprocess_image(image):
+    """Add noise reduction, sharpening, and background removal"""
+    # Convert to numpy array for processing
+    img = np.array(image)
+    
+    # Simple background removal (assuming leaf is dominant green object)
+    hsv = cv2.cvtColor(img, cv2.COLOR_RGB2HSV)
+    mask = cv2.inRange(hsv, (36, 25, 25), (86, 255, 255))  # Green color range
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (11, 11))
+    mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
+    img = cv2.bitwise_and(img, img, mask=mask)
+    
+    # Convert back to PIL
+    image = Image.fromarray(img)
+    
+    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(image)
+
+def parse_class_label(class_label):
+    """Split class label into plant name and disease status"""
+    parts = class_label.split('___')
+    plant = parts[0].replace('_', ' ').replace(',', '')
+    disease = parts[1].replace('_', ' ') if len(parts) > 1 else "healthy"
+    return plant, disease
+
+def is_healthy_override(image, predicted_class, confidence):
+    """Heuristic check for false disease predictions"""
+    # If model predicts disease but image looks "too clean", override to healthy
+    if "healthy" not in predicted_class and confidence > 0.9:
+        # Simple check: count green pixels vs total
+        img = np.array(image)
+        hsv = cv2.cvtColor(img, cv2.COLOR_RGB2HSV)
+        green_pixels = cv2.inRange(hsv, (36, 25, 25), (86, 255, 255))
+        green_ratio = np.sum(green_pixels > 0) / (img.shape[0] * img.shape[1])
+        
+        if green_ratio > 0.7:  # Mostly green leaf with no visible spots
+            return True
+    return False
+
+# Prediction function with fixes
+def predict(image):
+    try:
+        # Preprocess
+        input_tensor = preprocess_image(image).unsqueeze(0).to(device)
+        
+        # Predict
+        with torch.no_grad():
+            preds = model(input_tensor)
+            probabilities = torch.nn.functional.softmax(preds[0], dim=0)
+        
+        # Get top prediction
+        top_prob, top_idx = torch.max(probabilities, 0)
+        top_class = class_labels[top_idx.item()]
+        plant, disease = parse_class_label(top_class)
+        confidence = top_prob.item()
+        
+        # Apply fixes
+        if is_healthy_override(image, top_class, confidence):
+            return f"Plant: {plant}\nDisease: healthy (Override: Original prediction '{disease}' had {confidence:.2%} confidence but leaf appears healthy)"
+        
+        # Confidence thresholding
+        if confidence < 0.7:
+            return f"Uncertain prediction for {plant} (Confidence: {confidence:.2%})\nPlease upload a clearer image."
+        
+        return f"Plant: {plant}\nDisease: {disease} (Confidence: {confidence:.2%})"
+    
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+# Gradio UI with additional instructions
+iface = gr.Interface(
+    fn=predict,
+    inputs=gr.Image(type="pil", label="Upload Leaf Image"),
+    outputs=gr.Textbox(label="Prediction Results"),
+    title="Plant Disease Detection (With Error Correction)",
+    description="""Upload a clear image of a plant leaf. Tips:
+    - Crop to show only the leaf
+    - Use even lighting
+    - Avoid shadows/reflections""",
+    examples=[
+        ["examples/healthy_apple.jpg"],
+        ["examples/diseased_tomato.jpg"]
+    ],
+    allow_flagging="manual"
+)
+
+if __name__ == "__main__":
+    import cv2  # For image processing
+    iface.launch()

model.py

@@ -0,0 +1,128 @@
+import torch
+import torch.nn as nn
+import torchvision.models as models
+import torchvision.transforms as transforms
+from PIL import Image
+import gradio as gr
+from disease_info import get_disease_info
+
+# Define your model class (same as during training)
+class Plant_Disease_VGG16(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.network = models.vgg16(pretrained=True)
+        for param in list(self.network.features.parameters())[:-5]:
+            param.requires_grad = False
+        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)
+
+# Load the 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()
+
+# Class labels with plant and disease information
+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)___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'
+]
+
+# Preprocessing
+transform = transforms.Compose([
+    transforms.Resize((224, 224)),
+    transforms.ToTensor(),
+])
+
+def parse_class_label(class_label):
+    """Split class label into plant name and disease status"""
+    parts = class_label.split('___')
+    plant = parts[0].replace('_', ' ').replace(',', '')
+    disease = parts[1].replace('_', ' ') if len(parts) > 1 else "healthy"
+    return plant, disease
+
+# Prediction function
+def predict(image):
+    try:
+        print("Starting prediction...")
+        if image is None:
+            return "Error: No image provided"
+            
+        print("Preprocessing image...")
+        image = transform(image).unsqueeze(0).to(device)
+        
+        print("Running model prediction...")
+        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)
+        
+        print(f"Detected: {plant} - {disease}")
+        
+        # Get disease information from Mistral API
+        print("Fetching disease information...")
+        try:
+            disease_info = get_disease_info(plant, disease)
+            print("Received disease information successfully")
+            
+            # Format the output
+            result = f"""
+Plant: {plant}
+Disease: {disease}
+
+{disease_info['description']}
+
+Recommended Pesticides:
+{disease_info['pesticides']}
+
+Application Timing:
+{disease_info['timing']}
+
+Prevention Measures:
+{disease_info['prevention']}
+"""
+            return result
+            
+        except Exception as e:
+            print(f"Error getting disease info: {str(e)}")
+            return f"Error getting disease information: {str(e)}"
+        
+    except Exception as e:
+        print(f"Error in prediction: {str(e)}")
+        return f"Error in prediction: {str(e)}"
+
+# Gradio UI
+iface = gr.Interface(
+    fn=predict,
+    inputs=gr.Image(type="pil"),
+    outputs=gr.Textbox(label="Prediction Results", lines=20),
+    title="Plant Disease Detection",
+    description="Upload an image of a plant leaf to detect diseases and get detailed information about treatment and prevention.",
+    examples=[
+        ["examples/healthy_apple.jpg"],
+        ["examples/diseased_tomato.jpg"]
+    ],
+    flagging_mode="never"
+)
+
+if __name__ == "__main__":
+    iface.launch(share=True)

requirements.txt

@@ -1,6 +1,6 @@
-torch>=2.0.0
-torchvision>=0.15.0
-Pillow>=9.0.0
-gradio>=4.44.1
-requests>=2.31.0
+torch>=2.0.0
+torchvision>=0.15.0
+Pillow>=9.0.0
+gradio>=4.44.1
+requests>=2.31.0
 python-dotenv>=0.19.0 

sample1.py

@@ -0,0 +1,176 @@
+import torch
+import torch.nn as nn
+import torchvision.models as models
+import torchvision.transforms as transforms
+from PIL import Image
+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)
+
+# 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()
+
+# 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)___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'
+]
+
+# Image preprocessing
+transform = transforms.Compose([
+    transforms.Resize((224, 224)),
+    transforms.ToTensor(),
+])
+
+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):
+    """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)}"
+
+# ========== 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(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"]
+    ]
+)
+
+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)

translator.py

@@ -0,0 +1,36 @@
+import requests
+
+class Translator:
+    def __init__(self):
+        self.api_key = "393faf7faf-bf19-46db-a640-c0f44f844724"  # Your Inference API Key Value
+        self.base_url = "https://api.basini.com/v1/translate"
+        self.headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+        
+    def translate(self, text, target_lang):
+        try:
+            # Split the text into sections for better translation
+            sections = text.split('\n\n')
+            translated_sections = []
+            
+            for section in sections:
+                if section.strip():
+                    payload = {
+                        "text": section,
+                        "target_lang": target_lang,
+                        "source_lang": "en"
+                    }
+                    response = requests.post(self.base_url, headers=self.headers, json=payload)
+                    response.raise_for_status()
+                    translated_sections.append(response.json()["translated_text"])
+                else:
+                    translated_sections.append("")
+            
+            return "\n\n".join(translated_sections)
+        except Exception as e:
+            print(f"Translation error: {str(e)}")
+            return text
+
+translator = Translator()