Initial commit from automated deployment script

README.md

@@ -1,13 +1,73 @@
----
-title: Merolav Space
-emoji: 🐨
-colorFrom: green
-colorTo: blue
-sdk: gradio
-sdk_version: 6.14.0
-python_version: '3.13'
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Plant Disease Assistant
+emoji: 🌱
+colorFrom: green
+colorTo: yellow
+sdk: gradio
+sdk_version: 5.0.0
+app_file: app.py
+pinned: false
+license: apache-2.0
+short_description: Diagnose 22 crop diseases from a leaf. DINOv2-L on MI300X.
+tags:
+  - plant-disease
+  - agriculture
+  - dinov2
+  - amd
+  - mi300x
+  - rocm
+  - image-classification
+---
+
+# 🌱 Plant Disease Assistant
+
+Snap a leaf, name the disease, get a fix.
+
+Upload a photo of a plant leaf and this Space will identify which of **22 crop diseases** it has, rate the model's confidence, and return a structured treatment + prevention guide.
+
+## What's under the hood
+
+| Component | Details |
+|---|---|
+| **Classifier** | DINOv2-Large (304M params, ViT-L/14), fine-tuned with a linear head |
+| **Accuracy** | 97.06% top-1, 0.9713 macro F1 on the held-out test split |
+| **Dataset** | [CCMT Crop Pest and Disease Detection](https://www.kaggle.com/datasets) — cashew, cassava, maize, tomato |
+| **Hardware** | Fine-tuned on a single AMD Instinct **MI300X** (192 GB HBM3) via the AMD Developer Cloud |
+| **Framework** | PyTorch 2.x + ROCm, [timm](https://github.com/huggingface/pytorch-image-models) |
+| **Knowledge base** | Hand-curated treatment, prevention, and severity notes per class |
+
+The classifier runs on CPU here for accessibility — inference takes a few seconds per image. The original training run used ROCm on MI300X.
+
+## Crops & diseases covered
+
+- **Cashew** — anthracnose, gumosis, leaf miner, red rust, healthy
+- **Cassava** — bacterial blight, brown spot, green mite, mosaic, healthy
+- **Maize** — fall armyworm, grasshopper, leaf beetle, leaf blight, leaf spot, streak virus, healthy
+- **Tomato** — leaf blight, leaf curl, septoria leaf spot, verticilium wilt, healthy
+
+## How it was built
+
+This is **Track 2** of a multi-track entry in the lablab.ai AMD Developer Hackathon:
+
+- **Track 2** — Fine-tune DINOv2-L on CCMT for plant disease classification (this Space)
+- **Track 3** — Fine-tune Llama 3.2 11B Vision (LoRA) on the same data for conversational diagnosis ([adapter on HF](https://huggingface.co/iamcode6/llama32-vision-ccmt-mi300x))
+- **Build in Public** — Documented the journey end-to-end on social
+
+Both tracks were trained on the same MI300X droplet, demonstrating that a single AMD GPU can comfortably handle both a 304M-param classifier and an 11B-param vision-language model in the same workflow.
+
+## Limitations
+
+- Trained on a single dataset (CCMT) — performance on field photos with very different lighting, angles, or unseen crops will degrade.
+- The treatment guidance is informational only and **not a substitute for advice from a qualified agronomist or extension officer**.
+- CPU inference is intentionally slow (~5–10s/image). The original GPU pipeline runs in milliseconds.
+
+## License
+
+Apache 2.0. Model weights and code are open. CCMT dataset licensing applies to the training data only.
+
+## Acknowledgements
+
+- AMD for the Developer Cloud credits and MI300X access
+- Meta for [DINOv2](https://github.com/facebookresearch/dinov2)
+- The CCMT dataset authors
+- lablab.ai for organizing the hackathon

app.py

@@ -0,0 +1,232 @@
+"""Plant Disease Assistant — Hugging Face Space (CPU, DINOv2-only).
+
+Loads the DINOv2-L checkpoint from a HF model repo at startup, then runs
+classification + template-based responses from a bundled knowledge file.
+
+Configurable via environment variables:
+    DINOV2_REPO    HF model repo containing best.pt and splits.json
+                   (default: iamcode6/dinov2-l-ccmt-mi300x)
+    DINOV2_CKPT    Filename of the checkpoint inside the repo
+                   (default: best.pt)
+"""
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+import gradio as gr
+import numpy as np
+import timm
+import torch
+import torch.nn.functional as F
+from huggingface_hub import hf_hub_download
+from PIL import Image
+from timm.data import create_transform
+
+
+HERE = Path(__file__).parent
+KNOWLEDGE_PATH = HERE / "treatment_knowledge.json"
+SPLITS_PATH = HERE / "splits.json"
+
+DINOV2_REPO = os.environ.get("DINOV2_REPO", "iamcode6/dinov2-l-ccmt-mi300x")
+DINOV2_CKPT = os.environ.get("DINOV2_CKPT", "best.pt")
+DEVICE = "cpu"
+
+
+class PlantClassifier:
+    def __init__(self, checkpoint_path: Path, splits_path: Path):
+        self.device = torch.device(DEVICE)
+
+        splits = json.loads(splits_path.read_text())
+        self.idx_to_class = {v: k for k, v in splits["class_to_idx"].items()}
+        self.class_names = [self.idx_to_class[i] for i in range(len(self.idx_to_class))]
+        self.num_classes = len(self.class_names)
+
+        ckpt = torch.load(checkpoint_path, map_location="cpu", weights_only=False)
+        if isinstance(ckpt, dict) and "state_dict" in ckpt:
+            state_dict = ckpt["state_dict"]
+            cfg = ckpt.get("cfg", {})
+        else:
+            state_dict = ckpt
+            cfg = {}
+        state_dict = {k.replace("_orig_mod.", "", 1): v for k, v in state_dict.items()}
+
+        model_name = cfg.get("model", {}).get("name", "vit_large_patch14_dinov2.lvd142m")
+        img_size = cfg.get("model", {}).get("img_size", 224)
+
+        self.model = timm.create_model(
+            model_name, pretrained=False,
+            num_classes=self.num_classes, img_size=img_size,
+        )
+        self.model.load_state_dict(state_dict)
+        self.model.to(self.device).eval()
+
+        self.transform = create_transform(
+            input_size=img_size, is_training=False,
+            mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225),
+            interpolation="bicubic", crop_pct=0.95,
+        )
+
+    @torch.no_grad()
+    def predict(self, image: Image.Image, top_k: int = 3) -> list[dict]:
+        x = self.transform(image).unsqueeze(0).to(self.device)
+        logits = self.model(x)
+        probs = F.softmax(logits, dim=-1).squeeze(0).float().cpu().numpy()
+
+        top_indices = np.argsort(probs)[::-1][:top_k]
+        return [
+            {"class": self.class_names[i], "confidence": float(probs[i]), "index": int(i)}
+            for i in top_indices
+        ]
+
+
+class KnowledgeResponder:
+    def __init__(self, path: Path):
+        self.knowledge = json.loads(path.read_text())
+
+    def format_label(self, label: str) -> str:
+        return label.replace("_", " ").title()
+
+    def respond(self, predictions: list[dict]) -> str:
+        top = predictions[0]
+        label = top["class"]
+        confidence = top["confidence"]
+
+        if label not in self.knowledge:
+            return (
+                f"**Prediction:** {self.format_label(label)} "
+                f"(confidence: {confidence:.1%})\n\n"
+                "No detailed information available for this condition."
+            )
+
+        k = self.knowledge[label]
+        is_healthy = k["disease"] == "Healthy"
+
+        lines = []
+        if is_healthy:
+            lines.append(f"## {k['crop']} — Healthy")
+            lines.append(f"**Confidence:** {confidence:.1%}\n")
+            lines.append(f"{k['symptoms']}")
+            lines.append("\nKeep monitoring regularly and continue your current care routine.")
+        else:
+            lines.append(f"## {k['crop']} — {k['disease']}")
+            lines.append(f"**Confidence:** {confidence:.1%}\n")
+            if k.get("pathogen"):
+                lines.append(f"**Pathogen:** *{k['pathogen']}*\n")
+            lines.append("### Symptoms")
+            lines.append(f"{k['symptoms']}\n")
+            lines.append("### Severity Guide")
+            for level, desc in k["severity_cues"].items():
+                lines.append(f"- **{level.title()}:** {desc}")
+            lines.append("")
+            lines.append("### Treatment")
+            lines.append(f"{k['treatment']}\n")
+            lines.append("### Prevention")
+            lines.append(f"{k['prevention']}")
+
+        if len(predictions) > 1:
+            lines.append("\n---\n### Other Possibilities")
+            for p in predictions[1:]:
+                if p["confidence"] > 0.05:
+                    lines.append(f"- {self.format_label(p['class'])} ({p['confidence']:.1%})")
+
+        return "\n".join(lines)
+
+
+print(f"[app] Downloading DINOv2-L checkpoint from {DINOV2_REPO}...")
+checkpoint_path = Path(hf_hub_download(repo_id=DINOV2_REPO, filename=DINOV2_CKPT))
+
+print("[app] Loading classifier on CPU (~30s)...")
+classifier = PlantClassifier(checkpoint_path, SPLITS_PATH)
+print(f"[app] Loaded {classifier.num_classes} classes")
+
+knowledge = KnowledgeResponder(KNOWLEDGE_PATH)
+
+
+def diagnose(image: Image.Image | None):
+    if image is None:
+        return "Please upload an image.", ""
+
+    image = image.convert("RGB")
+    predictions = classifier.predict(image, top_k=3)
+
+    table = "**DINOv2-L Classification (97% accuracy)**\n\n"
+    table += "| Rank | Disease | Confidence |\n"
+    table += "|------|---------|------------|\n"
+    for i, p in enumerate(predictions):
+        marker = " ←" if i == 0 else ""
+        table += (
+            f"| {i+1} | {knowledge.format_label(p['class'])} | "
+            f"{p['confidence']:.1%}{marker} |\n"
+        )
+
+    return table, knowledge.respond(predictions)
+
+
+CUSTOM_CSS = """
+.prose, .prose *, [class*="markdown"], [class*="markdown"] * {
+    color: #1a1a1a !important;
+    opacity: 1 !important;
+}
+.prose strong, .prose h1, .prose h2, .prose h3 {
+    color: #000 !important;
+    font-weight: 700 !important;
+}
+.dark .prose, .dark .prose *,
+.dark [class*="markdown"], .dark [class*="markdown"] * {
+    color: #f5f5f5 !important;
+}
+.dark .prose strong, .dark .prose h1, .dark .prose h2, .dark .prose h3 {
+    color: #ffffff !important;
+}
+.prose table { border-collapse: collapse; }
+.prose th, .prose td { padding: 6px 10px; border: 1px solid #888; }
+"""
+
+with gr.Blocks(title="Plant Disease Assistant", css=CUSTOM_CSS) as app:
+    gr.Markdown(
+        "# 🌱 Plant Disease Assistant\n"
+        "Upload a photo of a plant leaf to get an instant diagnosis, "
+        "severity assessment, and treatment recommendations.\n\n"
+        "*DINOv2-Large fine-tuned on AMD Instinct MI300X (ROCm) — "
+        "97.06% accuracy on the CCMT crop disease dataset.*"
+    )
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            image_input = gr.Image(type="pil", label="Upload a plant leaf photo")
+            diagnose_btn = gr.Button("Diagnose", variant="primary", size="lg")
+
+            example_paths = sorted(str(p) for p in (HERE / "examples").glob("*.jpg"))
+            if example_paths:
+                gr.Examples(
+                    examples=[[p] for p in example_paths],
+                    inputs=image_input,
+                    label="Or try one of these (click a thumbnail)",
+                    examples_per_page=11,
+                )
+        with gr.Column(scale=2):
+            classification_output = gr.Markdown()
+            response_output = gr.Markdown()
+
+    diagnose_btn.click(
+        fn=diagnose, inputs=image_input,
+        outputs=[classification_output, response_output],
+    )
+    image_input.change(
+        fn=diagnose, inputs=image_input,
+        outputs=[classification_output, response_output],
+    )
+
+    gr.Markdown(
+        "---\n"
+        "**Model:** DINOv2-Large (304M params) — 97.06% accuracy, 0.9713 macro F1\n\n"
+        "**Hardware:** Fine-tuned on AMD Instinct MI300X (192 GB HBM3) via AMD Developer Cloud\n\n"
+        "**Dataset:** CCMT Crop Pest and Disease Detection — 22 classes across cashew, cassava, maize, and tomato\n\n"
+        "*Built for the lablab.ai AMD Developer Hackathon*"
+    )
+
+
+if __name__ == "__main__":
+    app.launch(server_name="0.0.0.0", server_port=7860, show_api=False)

requirements.txt

@@ -0,0 +1,8 @@
+gradio>=5.0,<6
+torch>=2.2
+timm>=1.0.11
+huggingface_hub>=0.25,<0.27
+pydantic>=2.6,<2.11
+numpy
+Pillow
+audioop-lts; python_version >= "3.13"