Added leaves classifier

requirements.txt

@@ -1 +1,2 @@
-gradio==6
+gradio==6
+transformers

src/ui/tabs/leaf_tab.py

@@ -5,7 +5,53 @@ UI component for analyzing individual leaves.
 """
 
 import gradio as gr
-from ...utils.leaf_analysis import analyze_leaf
+from src.utils.leaf_classifier import predict as classify_image
+
+
+def analyze_leaf(image):
+    """
+    Analyze a leaf image to detect diseases.
+    
+    Args:
+        image: PIL.Image from gr.Image component
+    
+    Returns:
+        str: Result formatted as Markdown
+    """
+    if image is None:
+        return "⚠️ Please upload an image of a leaf."
+    
+    # Call classifier
+    result = classify_image(image)
+    
+    # Handle error
+    if not result["success"]:
+        return f"❌ Error: {result['error']}"
+    
+    # Format result as Markdown
+    emoji = "✅" if result["is_healthy"] else "⚠️"
+    status = "🌿 Healthy Plant" if result["is_healthy"] else "🦠 Disease Detected"
+    
+    output = f"""    
+            ## 🔬 Analysis Result
+
+            ### Main Diagnosis
+            - **Prediction:** {emoji} {result["prediction"]}
+            - **Confidence:** {result["confidence"]}%
+            - **Status:** {status}
+
+            ### Details
+            - **Plant:** {result["plant"]}
+            - **Condition:** {result["disease"]}
+
+            ### Other Possibilities
+            """
+    
+    # Add top-k alternatives (skip first one, it's the main prediction)
+    for i, alt in enumerate(result["top_k"][1:], start=2):
+        output += f"{i}. {alt['plant']} - {alt['disease']} ({alt['confidence']}%)\n"
+    
+    return output
 
 
 def create_leaf_tab():

src/utils/__init__.py

@@ -1,11 +0,0 @@
-"""
-Utils Package
-=============
-Utility functions for analysis and processing.
-"""
-
-from .leaf_analysis import analyze_leaf
-from .farm_analysis import analyze_farm
-from .weather_alerts import get_weather_alerts
-
-__all__ = ["analyze_leaf", "analyze_farm", "get_weather_alerts"]

src/utils/leaf_analysis.py

@@ -1,19 +0,0 @@
-"""
-Leaf Analysis Module
-====================
-Analyze individual leaves to detect diseases.
-"""
-
-
-def analyze_leaf(image):
-    """Analyze leaf to detect diseases."""
-    if image is None:
-        return "⚠️ Please upload an image."
-    
-    # TODO: Implement real classification
-    # - Load AI model (ResNet, EfficientNet, etc.)
-    # - Preprocess image
-    # - Run inference
-    # - Return disease classification with confidence
-    
-    return "✅ Image received. Analysis pending implementation."

src/utils/leaf_classifier.py

@@ -0,0 +1,229 @@
+"""
+Plant Disease Classifier
+=========================
+
+Classifies plant leaf diseases using MobileNetV2.
+
+Model: linkanjarad/mobilenet_v2_1.0_224-plant-disease-identification
+- 38 classes (26 diseases + 12 healthy plants)
+- 99.47% accuracy on PlantVillage dataset
+- Input: 224x224 RGB image
+
+Usage:
+    from src.classifier import predict
+    
+    result = predict(pil_image)
+    print(result["prediction"])  # "Tomato - Late Blight"
+"""
+
+import torch
+from PIL import Image
+from transformers import AutoImageProcessor, AutoModelForImageClassification
+
+
+# ============================================================
+# CONFIGURATION
+# ============================================================
+
+MODEL_NAME = "linkanjarad/mobilenet_v2_1.0_224-plant-disease-identification"
+
+
+# ============================================================
+# MODULE STATE 
+# ============================================================
+
+_model = None
+_processor = None
+_device = None
+
+
+# ============================================================
+# PRIVATE FUNCTIONS
+# ============================================================
+
+def _load_model():
+    """
+    Load model and processor from HuggingFace.
+    
+    Executes only ONCE (lazy loading).
+    Subsequent calls return cached objects.
+    
+    Returns:
+        tuple: (model, processor, device)
+    """
+    global _model, _processor, _device
+    
+    # Return cached if already loaded
+    if _model is not None:
+        return _model, _processor, _device
+    
+    print("🌱 Loading classification model...")
+    
+    # Determine device (GPU or CPU)
+    _device = "cuda" if torch.cuda.is_available() else "cpu"
+    print(f"   Device: {_device}")
+    
+    # Load processor (prepares images for model)
+    _processor = AutoImageProcessor.from_pretrained(MODEL_NAME)
+    
+    # Load model
+    _model = AutoModelForImageClassification.from_pretrained(MODEL_NAME)
+    _model.to(_device)
+    _model.eval()  # Set to evaluation mode
+    
+    print(f"✅ Model loaded: {len(_model.config.id2label)} classes")
+    
+    return _model, _processor, _device
+
+
+def _parse_label(raw_label: str) -> tuple:
+    """
+    Parse raw model label into (plant, disease).
+    
+    Args:
+        raw_label: Model label, e.g. "Tomato___Late_blight"
+    
+    Returns:
+        tuple: (plant, disease)
+               e.g. ("Tomato", "Late blight")
+    """
+    try:
+        # Split by triple underscore
+        parts = raw_label.split("___")
+        plant = parts[0].replace("_", " ").replace("(", "").replace(")", "").strip()
+        
+        if len(parts) > 1:
+            disease = parts[1].replace("_", " ").strip()
+            # Capitalize properly
+            disease = disease.title() if disease.lower() != "healthy" else "Healthy"
+        else:
+            disease = "Unknown"
+        
+        return (plant, disease)
+    except:
+        return (raw_label, "Unknown")
+
+
+# ============================================================
+# PUBLIC FUNCTION
+# ============================================================
+
+def predict(image: Image.Image, top_k: int = 3) -> dict:
+    """
+    Predict disease in a plant leaf image.
+    
+    Args:
+        image: PIL Image (PIL.Image.Image)
+        top_k: Number of alternative predictions to return
+    
+    Returns:
+        dict with result:
+        {
+            "success": True,
+            "prediction": "Tomato - Late Blight",
+            "confidence": 95.23,
+            "is_healthy": False,
+            "plant": "Tomato",
+            "disease": "Late Blight",
+            "raw_label": "Tomato___Late_blight",
+            "top_k": [
+                {"plant": "Tomato", "disease": "Late Blight", "confidence": 95.23},
+                ...
+            ]
+        }
+        
+        On error:
+        {
+            "success": False,
+            "error": "Error description"
+        }
+    """
+    
+    # Validate input
+    if image is None:
+        return {
+            "success": False,
+            "error": "No image provided"
+        }
+    
+    if not isinstance(image, Image.Image):
+        return {
+            "success": False,
+            "error": f"Invalid image type: {type(image)}. Expected PIL.Image"
+        }
+    
+    try:
+        # Load model (only first time)
+        model, processor, device = _load_model()
+        
+        # Preprocess image
+        image = image.convert("RGB")
+        inputs = processor(images=image, return_tensors="pt")
+        inputs = {k: v.to(device) for k, v in inputs.items()}
+        
+        # Inference
+        with torch.no_grad():
+            outputs = model(**inputs)
+        
+        # Process results
+        logits = outputs.logits
+        probs = torch.nn.functional.softmax(logits, dim=-1)
+        
+        # Get top prediction
+        top_prob, top_idx = torch.max(probs, dim=-1)
+        raw_label = model.config.id2label[top_idx.item()]
+        confidence = round(top_prob.item() * 100, 2)
+        
+        # Parse label
+        plant, disease = _parse_label(raw_label)
+        is_healthy = "healthy" in raw_label.lower()
+        
+        # Get top-k predictions
+        top_k_probs, top_k_indices = torch.topk(probs, min(top_k, probs.shape[-1]))
+        
+        top_k_results = []
+        for idx, prob in zip(top_k_indices[0], top_k_probs[0]):
+            label = model.config.id2label[idx.item()]
+            p, d = _parse_label(label)
+            top_k_results.append({
+                "plant": p,
+                "disease": d,
+                "confidence": round(prob.item() * 100, 2),
+                "raw_label": label
+            })
+        
+        # Return structured result
+        return {
+            "success": True,
+            "prediction": f"{plant} - {disease}",
+            "confidence": confidence,
+            "is_healthy": is_healthy,
+            "plant": plant,
+            "disease": disease,
+            "raw_label": raw_label,
+            "top_k": top_k_results
+        }
+    
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e)
+        }
+
+
+
+    print("\n" + "="*50)
+    print("🧪 CLASSIFIER TEST")
+    print("="*50)
+    
+    model, processor, device = _load_model()
+    print(f"\n📊 Available classes: {len(model.config.id2label)}")
+    print(f"🖥️  Device: {device}")
+    
+    print("\n📋 Sample classes:")
+    for i, (idx, label) in enumerate(list(model.config.id2label.items())[:5]):
+        plant, disease = _parse_label(label)
+        print(f"   {idx}: {plant} - {disease}")
+    
+    print("\n✅ Classifier ready")
+    print("="*50)