🚀 Initial full clean push to Hugging Face

.gitattributes

@@ -0,0 +1 @@
+*.pt filter=lfs diff=lfs merge=lfs -text

.huggingface.yml

@@ -0,0 +1,10 @@
+---
+title: CropGuard
+emoji: 🌿
+colorFrom: green
+colorTo: green
+sdk: gradio
+sdk_version: "4.24.0"
+app_file: app.py
+pinned: false
+---

app.py

@@ -0,0 +1,206 @@
+# app.py
+
+import gradio as gr
+import torch
+import numpy as np
+import matplotlib.pyplot as plt
+import cv2
+import os
+import sys
+import json
+from PIL import Image
+
+# Add project root to sys.path
+current_dir = os.path.dirname(os.path.abspath(__file__))
+project_root = os.path.dirname(current_dir)
+if project_root not in sys.path:
+    sys.path.append(project_root)
+
+# Internal modules
+from src.model.architecture import build_model
+from src.model.gradcam import GradCAMPlusPlus as GradCAM
+from src.utils.config import BEST_MODEL_PATH
+
+# Load disease information
+with open("disease_info.json", "r") as f:
+    DISEASE_INFO = json.load(f)
+
+# Load label mapping
+with open("models/labels.json", "r") as f:
+    idx_to_class = json.load(f)
+
+# Load model
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+num_classes = len(idx_to_class)
+
+model = build_model(num_classes=num_classes, freeze_backbone=False)
+model.load_state_dict(torch.load(BEST_MODEL_PATH, map_location=device))
+model = model.to(device)
+model.eval()
+
+target_layer = model.features[-1]
+
+# Sample images
+SAMPLE_DIR = "sample_images"
+sample_choices = sorted(os.listdir(SAMPLE_DIR))
+
+# Utility Functions
+def beautify_name(raw_classname):
+    parts = raw_classname.split("___")
+    if len(parts) >= 3:
+        plant = parts[1].title()
+        disease = parts[2].replace("_", " ").replace("(", "").replace(")", "").replace("__", " ").title()
+        return plant, disease
+    else:
+        return "Unknown", "Unknown"
+
+def generate_gradcam(model, input_tensor, target_layer):
+    gradcam = GradCAM(model, target_layer)
+    cam = gradcam.generate(input_tensor)
+    return cam
+
+def preprocess_image(image):
+    from torchvision import transforms
+    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 predict(image):
+    if image is None:
+        return None, None, None, None, None
+
+    model.eval()
+    image_tensor = preprocess_image(image).unsqueeze(0).to(device)
+
+    with torch.no_grad():
+        output = model(image_tensor)
+        probs = torch.softmax(output, dim=1).cpu().numpy()[0]
+
+    top3_indices = probs.argsort()[-3:][::-1]
+    top3_classes = [(idx_to_class[str(idx)], float(probs[idx])) for idx in top3_indices]
+
+    pred_class, pred_prob = top3_classes[0]
+    plant, disease = beautify_name(pred_class)
+
+    # Format Top-3 nicely
+    top3_text = ""
+    for i, (c, p) in enumerate(top3_classes, 1):
+        c_plant, c_disease = beautify_name(c)
+        top3_text += f"{i}. {c_plant} - {c_disease} ({p*100:.2f}%)\n"
+
+    # GradCAM
+    cam = generate_gradcam(model, image_tensor, target_layer)
+
+    img_np = np.array(image) / 255.0
+
+    # 🔥 Resize uploaded image to 224x224 for matching heatmap
+    img_np_resized = cv2.resize(img_np, (224, 224))
+
+    img_gray = cv2.cvtColor(np.uint8(img_np_resized * 255), cv2.COLOR_RGB2GRAY) / 255.0
+    img_gray_3ch = np.stack([img_gray]*3, axis=-1)
+
+    heatmap = cv2.applyColorMap(np.uint8(255 * cam), cv2.COLORMAP_PLASMA)
+    heatmap = np.float32(heatmap) / 255
+
+    overlay = heatmap + img_gray_3ch
+    overlay = overlay / np.max(overlay)
+
+    fig, ax = plt.subplots(figsize=(5,5))
+    ax.imshow(overlay)
+    ax.axis("off")
+    cbar = plt.colorbar(plt.cm.ScalarMappable(cmap='plasma'), orientation='horizontal', pad=0.05, ax=ax)
+    cbar.set_ticks([0, 0.5, 1])
+    cbar.set_ticklabels(['Low Focus', 'Medium Focus', 'High Focus'])
+    plt.tight_layout()
+
+    cam_path = "cam_output.png"
+    fig.savefig(cam_path)
+    plt.close(fig)
+
+    # Health Status + Disease Info
+    if "healthy" in pred_class.lower():
+        health_status = f"{plant} - Healthy"
+        identified_disease = "None"
+        disease_info_text = "✅ No disease detected."
+    else:
+        health_status = f"{plant} - Diseased"
+        identified_disease = disease
+        disease_data = DISEASE_INFO.get(pred_class, {})
+        disease_info_text = f"""
+**Symptoms:** {disease_data.get('symptoms', 'No information available.')}
+
+**Causes:** {disease_data.get('causes', 'No information available.')}
+
+**Disease Cycle:** {disease_data.get('disease_cycle', 'No information available.')}
+
+**Care & Treatment:** {disease_data.get('care_treatment', 'No information available.')}
+
+[Learn more on Wikipedia]({disease_data.get('wiki_url', '#')})
+"""
+
+    alert = None
+    if pred_prob < 0.6:
+        alert = "⚠️ Low confidence in prediction! Please verify manually."
+
+    return health_status, identified_disease, top3_text, alert, cam_path, disease_info_text
+
+def load_sample_image(sample_name):
+    img_path = os.path.join(SAMPLE_DIR, sample_name)
+    img = Image.open(img_path).convert("RGB")
+    return img
+
+# Interface
+title = "CropGuard: Leaf Disease Detector"
+copyright_text = "© 2025 Made by [Arka Mitra](https://github.com/mitraarka27)"
+instruction_text = """
+Upload a clear image of a **potato**, **tomato**, or **grape** leaf.
+
+CropGuard will predict:
+- Whether the leaf is **healthy** or **diseased**.
+- The likely disease (if any).
+- Where the model focused its attention.
+
+⚡ **Note**: Currently supports only **Potato, Tomato, Grape** leaves.
+"""
+
+with gr.Blocks(theme="default") as app:
+    with gr.Row():
+        gr.Markdown(f"<h1 style='text-align: center;'>{title}</h1>")
+    gr.Markdown("<p style='text-align: center;'>© 2025 Made by <a href='https://github.com/mitraarka27' target='_blank'>Arka Mitra</a></p>")
+    with gr.Row():
+        with gr.Column(scale=2):
+            upload = gr.Image(
+                type="pil",
+                sources=["upload", "webcam", "clipboard"],
+                label="Upload, Capture, or Paste Leaf Image"
+            )
+            gr.Markdown("**OR** choose from sample images below:")
+            sample_dropdown = gr.Dropdown(choices=sample_choices, label="Select a Sample Image")
+            load_btn = gr.Button("Load Sample Image")
+            predict_btn = gr.Button("Predict", variant="primary")
+            gr.Markdown(instruction_text)
+            alert_box = gr.Textbox(label="Prediction Alert", lines=2, interactive=False)
+            top3_preds = gr.Textbox(label="Top-3 Predictions", lines=5, interactive=False)
+        with gr.Column(scale=3):
+            health_status = gr.Label(label="Plant Health Status")
+            disease_name = gr.Label(label="Identified Disease (includes details)")
+            disease_info = gr.Markdown()
+            heatmap = gr.Image(label="Model Focus Heatmap")
+
+    load_btn.click(
+        fn=load_sample_image,
+        inputs=[sample_dropdown],
+        outputs=[upload]
+    )
+
+    predict_btn.click(
+        fn=predict,
+        inputs=[upload],
+        outputs=[health_status, disease_name, top3_preds, alert_box, heatmap, disease_info]
+    )
+
+if __name__ == "__main__":
+    app.launch(server_name="127.0.0.1", server_port=7860, share=True)

disease_info.json

@@ -0,0 +1,130 @@
+{
+    "grape___Grape___Black_rot": {
+      "name": "Grape Black Rot",
+      "symptoms": "Small, brown spots on leaves that expand and develop black margins. Infected grapes shrivel and turn into hard, black 'mummies'.",
+      "causes": "Caused by the fungus Guignardia bidwellii. Wet, warm conditions promote infection.",
+      "disease_cycle": "Overwinters in mummified fruits and old canes. Rain splashes spread spores to new shoots and fruits during spring and summer.",
+      "care_treatment": "Prune and destroy infected material. Apply early-season fungicide sprays. Promote air circulation by proper vine spacing.",
+      "wiki_url": "https://en.wikipedia.org/wiki/Black_rot_(grape_disease)"
+    },
+    "grape___Grape___Esca_(Black_Measles)": {
+      "name": "Grape Esca (Black Measles)",
+      "symptoms": "Interveinal yellowing and scorching of leaves. Berries show dark spots, shrivel, and dry on the vine.",
+      "causes": "Caused by a complex of fungi including Phaeomoniella chlamydospora. Wounds from pruning can facilitate infection.",
+      "disease_cycle": "Fungi infect through pruning wounds and colonize the vascular system. Symptoms worsen over several seasons.",
+      "care_treatment": "Avoid large pruning wounds. Remove infected vines if severe. Some systemic fungicides may help but control is difficult.",
+      "wiki_url": "https://en.wikipedia.org/wiki/Esca_(grape)"
+    },
+    "grape___Grape___Leaf_blight_(Isariopsis_Leaf_Spot)": {
+      "name": "Grape Leaf Blight (Isariopsis Leaf Spot)",
+      "symptoms": "Brown, angular lesions on grape leaves, often leading to early defoliation.",
+      "causes": "Caused by the fungus Pseudocercospora vitis (formerly Isariopsis). Moist, humid environments encourage disease spread.",
+      "disease_cycle": "Spores are produced on infected leaves and spread by wind and rain. New infections occur throughout the growing season.",
+      "care_treatment": "Apply protective fungicides during humid periods. Remove fallen infected leaves to reduce inoculum.",
+      "wiki_url": "https://www.sciencedirect.com/science/article/abs/pii/S0261219414001135"
+    },
+    "potato___Potato___Early_blight": {
+      "name": "Potato Early Blight",
+      "symptoms": "Small brown lesions with concentric rings on leaves. Older leaves yellow and drop prematurely.",
+      "causes": "Caused by the fungus Alternaria solani. Stress factors like drought or poor nutrition can worsen outbreaks.",
+      "disease_cycle": "Overwinters in soil or debris. Spores are dispersed by wind and rain to infect new plants.",
+      "care_treatment": "Use resistant varieties. Apply fungicides early. Maintain proper plant nutrition and avoid water stress.",
+      "wiki_url": "https://en.wikipedia.org/wiki/Early_blight"
+    },
+    "potato___Potato___Late_blight": {
+      "name": "Potato Late Blight",
+      "symptoms": "Large, irregularly shaped water-soaked lesions on leaves, stems, and tubers; white mold under humid conditions.",
+      "causes": "Caused by the oomycete Phytophthora infestans, favored by cool and wet weather.",
+      "disease_cycle": "Spores spread rapidly through rain and wind, causing epidemics in wet conditions.",
+      "care_treatment": "Destroy infected plants. Apply protective fungicides before expected rain. Plant certified disease-free seed potatoes.",
+      "wiki_url": "https://en.wikipedia.org/wiki/Late_blight"
+    },
+    "potato___Potato___healthy": {
+      "name": "Healthy Potato Leaf",
+      "symptoms": "No visible signs of disease. Leaves are green, firm, and uniform.",
+      "causes": "N/A",
+      "disease_cycle": "N/A",
+      "care_treatment": "Maintain good crop hygiene, regular monitoring, and optimal nutrition.",
+      "wiki_url": ""
+    },
+    "tomato___Tomato___Bacterial_spot": {
+      "name": "Tomato Bacterial Spot",
+      "symptoms": "Small, dark brown water-soaked spots on leaves, stems, and fruit. Can cause fruit blemishes and leaf loss.",
+      "causes": "Caused by Xanthomonas species. Spread favored by warm, wet weather.",
+      "disease_cycle": "Bacteria overwinter in plant debris and seeds. Splashing water spreads bacteria to healthy tissues.",
+      "care_treatment": "Use certified disease-free seed. Apply copper-based bactericides. Practice crop rotation.",
+      "wiki_url": "https://en.wikipedia.org/wiki/Bacterial_spot"
+    },
+    "tomato___Tomato___Early_blight": {
+      "name": "Tomato Early Blight",
+      "symptoms": "Brown circular lesions with concentric rings on lower leaves. Defoliation and poor fruit development follow.",
+      "causes": "Caused by the fungus Alternaria solani. Humid conditions favor spread.",
+      "disease_cycle": "Spores overwinter in debris and infect plants in moist conditions, spreading via wind and rain.",
+      "care_treatment": "Apply fungicides preventively. Maintain plant vigor and spacing. Remove plant debris.",
+      "wiki_url": "https://en.wikipedia.org/wiki/Early_blight"
+    },
+    "tomato___Tomato___Late_blight": {
+      "name": "Tomato Late Blight",
+      "symptoms": "Dark, greasy lesions on leaves and stems. Fruit may show brown rot with a white mold under humid conditions.",
+      "causes": "Caused by Phytophthora infestans. Cool, wet weather accelerates outbreaks.",
+      "disease_cycle": "Rapid spread by airborne spores under moist conditions.",
+      "care_treatment": "Remove infected plants immediately. Use fungicide sprays during cool, rainy periods.",
+      "wiki_url": "https://en.wikipedia.org/wiki/Late_blight"
+    },
+    "tomato___Tomato___Leaf_Mold": {
+      "name": "Tomato Leaf Mold",
+      "symptoms": "Yellow spots on upper leaf surfaces, olive-green mold underneath. Severe cases cause leaf drop.",
+      "causes": "Caused by the fungus Passalora fulva. High humidity inside greenhouses favors the disease.",
+      "disease_cycle": "Spores spread through air and water. Survives in greenhouse debris.",
+      "care_treatment": "Increase air circulation. Use resistant varieties. Apply fungicides in greenhouse crops.",
+      "wiki_url": "https://en.wikipedia.org/wiki/Leaf_mold"
+    },
+    "tomato___Tomato___Septoria_leaf_spot": {
+      "name": "Tomato Septoria Leaf Spot",
+      "symptoms": "Numerous small, dark spots with gray centers on leaves. Causes early defoliation and yield loss.",
+      "causes": "Caused by the fungus Septoria lycopersici. Moist, humid conditions favor outbreaks.",
+      "disease_cycle": "Spores are produced on infected tissue and spread by water splash.",
+      "care_treatment": "Rotate crops. Remove and destroy infected material. Apply appropriate fungicides.",
+      "wiki_url": "https://en.wikipedia.org/wiki/Septoria_leaf_spot"
+    },
+    "tomato___Tomato___Spider_mites Two-spotted_spider_mite": {
+      "name": "Tomato Spider Mites (Two-Spotted)",
+      "symptoms": "Fine stippling on leaves, yellowing, bronzing, and webbing in severe cases.",
+      "causes": "Caused by the tiny pest Tetranychus urticae (two-spotted spider mite). Hot, dry conditions encourage outbreaks.",
+      "disease_cycle": "Eggs laid on undersides of leaves hatch and develop rapidly under warm temperatures.",
+      "care_treatment": "Spray with miticides or insecticidal soap. Increase humidity. Use predatory mites for biological control.",
+      "wiki_url": "https://en.wikipedia.org/wiki/Tetranychus_urticae"
+    },
+    "tomato___Tomato___Target_Spot": {
+      "name": "Tomato Target Spot",
+      "symptoms": "Brown lesions with concentric rings resembling a target. Affects leaves, stems, and fruit.",
+      "causes": "Caused by the fungus Corynespora cassiicola.",
+      "disease_cycle": "Spores spread by wind and water, especially under humid conditions.",
+      "care_treatment": "Apply fungicides preventively. Maintain good field sanitation.",
+      "wiki_url": "https://www.apsnet.org/edcenter/disandpath/fungalbasidio/pdlessons/Pages/TargetSpot.aspx"
+    },
+    "tomato___Tomato___Tomato_Yellow_Leaf_Curl_Virus": {
+      "name": "Tomato Yellow Leaf Curl Virus",
+      "symptoms": "Severe leaf curling, yellowing, and stunted plant growth. Reduces fruit set and quality.",
+      "causes": "Caused by Tomato yellow leaf curl virus (TYLCV), transmitted by whiteflies.",
+      "disease_cycle": "Whiteflies acquire and transmit the virus while feeding.",
+      "care_treatment": "Use resistant varieties. Control whiteflies with insecticides and barriers.",
+      "wiki_url": "https://en.wikipedia.org/wiki/Tomato_yellow_leaf_curl_virus"
+    },
+    "tomato___Tomato___Tomato_mosaic_virus": {
+      "name": "Tomato Mosaic Virus",
+      "symptoms": "Mottled light and dark green areas on leaves, leaf curling, and reduced fruit yield.",
+      "causes": "Caused by Tomato mosaic virus (ToMV), a highly stable virus spread by mechanical contact.",
+      "disease_cycle": "Spread by contaminated tools, hands, and infected seeds.",
+      "care_treatment": "Disinfect tools. Use virus-free seed. Remove infected plants immediately.",
+      "wiki_url": "https://en.wikipedia.org/wiki/Tomato_mosaic_virus"
+    },
+    "tomato___Tomato___healthy": {
+      "name": "Healthy Tomato Leaf",
+      "symptoms": "✅ No disease detected. Leaves appear green, strong, and vigorous.",
+      "causes": "N/A",
+      "disease_cycle": "N/A",
+      "care_treatment": "Maintain proper crop care and hygiene practices.",
+      "wiki_url": ""
+    }
+  }

models/cropguard_best.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:926993adb8aba8af6cc714d23b580bf1d4d8a690b89ab5a9904ede4d57166e76
+size 9225099

models/labels.json

@@ -0,0 +1,19 @@
+{
+    "0": "grape___Grape___Black_rot",
+    "1": "grape___Grape___Esca_(Black_Measles)",
+    "2": "grape___Grape___Leaf_blight_(Isariopsis_Leaf_Spot)",
+    "3": "grape___Grape___healthy",
+    "4": "potato___Potato___Early_blight",
+    "5": "potato___Potato___Late_blight",
+    "6": "potato___Potato___healthy",
+    "7": "tomato___Tomato___Bacterial_spot",
+    "8": "tomato___Tomato___Early_blight",
+    "9": "tomato___Tomato___Late_blight",
+    "10": "tomato___Tomato___Leaf_Mold",
+    "11": "tomato___Tomato___Septoria_leaf_spot",
+    "12": "tomato___Tomato___Spider_mites Two-spotted_spider_mite",
+    "13": "tomato___Tomato___Target_Spot",
+    "14": "tomato___Tomato___Tomato_Yellow_Leaf_Curl_Virus",
+    "15": "tomato___Tomato___Tomato_mosaic_virus",
+    "16": "tomato___Tomato___healthy"
+}

requirements.txt

@@ -0,0 +1,9 @@
+torch>=2.0
+torchvision>=0.15
+scikit-learn>=1.2
+numpy
+pandas
+matplotlib
+opencv-python
+gradio
+Pillow

src/data/augment.py

@@ -0,0 +1,44 @@
+import torchvision.transforms as T
+
+class AugmentationPipeline:
+    """
+    Data augmentation and preprocessing transformations for CropGuard.
+    """
+
+    def __init__(self):
+        # Mean and Std from ImageNet (can be adjusted later if needed)
+        self.mean = [0.485, 0.456, 0.406]
+        self.std = [0.229, 0.224, 0.225]
+
+        # Define transformations
+        self.train_transforms = T.Compose([
+            T.RandomHorizontalFlip(p=0.5),
+            T.RandomVerticalFlip(p=0.5),
+            T.RandomRotation(degrees=30),
+            T.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1),
+            T.ToTensor(),
+            T.Normalize(mean=self.mean, std=self.std)
+        ])
+
+        self.val_transforms = T.Compose([
+            T.ToTensor(),
+            T.Normalize(mean=self.mean, std=self.std)
+        ])
+
+        self.test_transforms = T.Compose([
+            T.ToTensor(),
+            T.Normalize(mean=self.mean, std=self.std)
+        ])
+
+    def get_transforms(self, phase="train"):
+        """
+        Returns the appropriate transformation based on phase.
+        """
+        if phase == "train":
+            return self.train_transforms
+        elif phase == "val":
+            return self.val_transforms
+        elif phase == "test":
+            return self.test_transforms
+        else:
+            raise ValueError(f"Unknown phase: {phase}. Use 'train', 'val', or 'test'.")

src/data/dataset.py

@@ -0,0 +1,73 @@
+import os
+from PIL import Image
+from torch.utils.data import Dataset
+
+class PlantVillageDataset(Dataset):
+    """
+    PyTorch-compatible dataset for the cleaned and split PlantVillage dataset.
+
+    Directory structure should be:
+        root/
+            crop1/
+                disease1/
+                    img1.jpg
+                    ...
+                disease2/
+                    ...
+            crop2/
+                ...
+    """
+
+    def __init__(self, root_dir, transform=None):
+        """
+        Args:
+            root_dir (str): Path to split directory (e.g., data/split/train)
+            transform (callable, optional): Transformations to apply to images
+        """
+        self.root_dir = root_dir
+        self.transform = transform
+        self.samples = []
+        self.class_to_idx = {}
+        self._prepare_dataset()
+
+    def _prepare_dataset(self):
+        """
+        Scan directory and build (image_path, class_index) list
+        """
+        class_names = []
+        for crop in sorted(os.listdir(self.root_dir)):
+            crop_path = os.path.join(self.root_dir, crop)
+            if not os.path.isdir(crop_path):
+                continue
+
+            for disease in sorted(os.listdir(crop_path)):
+                disease_path = os.path.join(crop_path, disease)
+                if not os.path.isdir(disease_path):
+                    continue  # Safety check
+
+                class_name = f"{crop}___{disease}"
+                if class_name not in self.class_to_idx:
+                    self.class_to_idx[class_name] = len(self.class_to_idx)
+                    class_names.append(class_name)
+
+                label = self.class_to_idx[class_name]
+
+                for fname in os.listdir(disease_path):
+                    if not fname.lower().endswith((".jpg", ".jpeg", ".png")):
+                        continue
+                    img_path = os.path.join(disease_path, fname)
+                    self.samples.append((img_path, label))
+
+        # print(f"[INFO] {len(self.samples)} images found across {len(self.class_to_idx)} classes.")
+
+    def __len__(self):
+        return len(self.samples)
+
+    def __getitem__(self, idx):
+        img_path, label = self.samples[idx]
+        image = Image.open(img_path).convert("RGB")
+
+        if self.transform:
+            image = self.transform(image)
+
+        return image, label

src/data/download.py

@@ -0,0 +1,75 @@
+import os
+import shutil
+from kaggle.api.kaggle_api_extended import KaggleApi
+from src.utils.config import DATA_DIR, CLEAN_DIR, RAW_DIR, TARGET_CROPS  # ✅ Import cleanly
+
+# -------------------------------
+# Functions
+# -------------------------------
+
+def download_and_extract_dataset():
+    """
+    Download and extract the full PlantVillage dataset.
+    """
+    os.makedirs(RAW_DIR, exist_ok=True)
+
+    api = KaggleApi()
+    api.authenticate()
+
+    print("[INFO] Downloading PlantVillage dataset...")
+    api.dataset_download_files('mohitsingh1804/plantvillage', path=RAW_DIR, unzip=True)
+    print("[INFO] Download complete and extracted.")
+
+def clean_and_organize_dataset():
+    """
+    Organize Potato, Tomato, Grape from train/ and val/ into clean/ directory.
+    """
+    extracted_dir = os.path.join(RAW_DIR, "plantvillage")
+
+    train_dir = os.path.join(extracted_dir, "train")
+    val_dir = os.path.join(extracted_dir, "val")
+
+    if not os.path.exists(CLEAN_DIR):
+        os.makedirs(CLEAN_DIR)
+        print(f"[INFO] Created clean directory at: {CLEAN_DIR}")
+
+    for split_dir in [train_dir, val_dir]:
+        if not os.path.exists(split_dir):
+            raise FileNotFoundError(f"[ERROR] {split_dir} not found.")
+
+        for folder in os.listdir(split_dir):
+            full_folder_path = os.path.join(split_dir, folder)
+            if os.path.isdir(full_folder_path) and any(folder.startswith(crop) for crop in TARGET_CROPS):
+                crop_name = folder.split("___")[0].lower()
+                disease_folder = folder
+
+                destination_crop_dir = os.path.join(CLEAN_DIR, crop_name)
+                os.makedirs(destination_crop_dir, exist_ok=True)
+
+                destination_disease_dir = os.path.join(destination_crop_dir, disease_folder)
+                os.makedirs(destination_disease_dir, exist_ok=True)
+
+                for img_file in os.listdir(full_folder_path):
+                    src_img = os.path.join(full_folder_path, img_file)
+                    dst_img = os.path.join(destination_disease_dir, img_file)
+                    shutil.copy(src_img, dst_img)
+
+    print("[INFO] Crops cleaned and organized into 'clean/' directory from train and val folders.")
+
+    # -------------------------------
+    # Remove plant_disease_raw after cleaning
+    # -------------------------------
+    if os.path.exists(RAW_DIR):
+        shutil.rmtree(RAW_DIR)
+        print(f"[INFO] Deleted raw data directory at {RAW_DIR} after cleaning.")
+
+def check_data_integrity():
+    """
+    Quick check that clean/ has the crops properly.
+    """
+    if not os.path.exists(CLEAN_DIR):
+        raise FileNotFoundError(f"[ERROR] Clean folder {CLEAN_DIR} not found!")
+
+    for crop in os.listdir(CLEAN_DIR):
+        crop_dir = os.path.join(CLEAN_DIR, crop)
+        print(f"[INFO] {crop.capitalize()}: {len(os.listdir(crop_dir))} disease classes found.")

src/data/preprocess.py

@@ -0,0 +1,55 @@
+import os
+import shutil
+import random
+from src.utils.config import DATA_DIR, SPLIT_DIR, SEED
+
+def split_clean_data(train_ratio=0.7, val_ratio=0.15, test_ratio=0.15, seed=SEED):
+    """
+    Split cleaned data into train/val/test splits under data/split/.
+    """
+    random.seed(seed)
+
+    clean_dir = os.path.join(DATA_DIR, "clean")
+
+    # Remove previous split if exists
+    if os.path.exists(SPLIT_DIR):
+        shutil.rmtree(SPLIT_DIR)
+    os.makedirs(SPLIT_DIR)
+
+    for crop in os.listdir(clean_dir):
+        crop_path = os.path.join(clean_dir, crop)
+
+        for disease_folder in os.listdir(crop_path):
+            disease_path = os.path.join(crop_path, disease_folder)
+            images = os.listdir(disease_path)
+            if len(images) == 0:
+                print(f"[WARNING] No images found in {disease_path}, skipping.")
+                continue
+
+            random.shuffle(images)
+
+            n_total = len(images)
+            n_train = int(n_total * train_ratio)
+            n_val = int(n_total * val_ratio)
+
+            # Safety check: at least 1 sample in each split
+            if n_train == 0 or n_val == 0 or (n_total - n_train - n_val) == 0:
+                print(f"[WARNING] Not enough images to split {disease_path} properly, skipping.")
+                continue
+
+            splits = {
+                "train": images[:n_train],
+                "val": images[n_train:n_train+n_val],
+                "test": images[n_train+n_val:]
+            }
+
+            for split_name, split_images in splits.items():
+                target_dir = os.path.join(SPLIT_DIR, split_name, crop, disease_folder)
+                os.makedirs(target_dir, exist_ok=True)
+
+                for img_name in split_images:
+                    src_img = os.path.join(disease_path, img_name)
+                    dst_img = os.path.join(target_dir, img_name)
+                    shutil.copy(src_img, dst_img)
+
+    print("[INFO] Finished creating train/val/test split.")

src/model/architecture.py

@@ -0,0 +1,28 @@
+import torch
+import torch.nn as nn
+from torchvision import models
+
+def build_model(num_classes, freeze_backbone=True):
+    """
+    Build and return a MobileNetV2 model fine-tuned for our custom classes.
+
+    Args:
+        num_classes (int): Number of disease classes
+        freeze_backbone (bool): If True, freeze feature extractor layers
+
+    Returns:
+        model (nn.Module)
+    """
+    model = models.mobilenet_v2(weights='IMAGENET1K_V1')
+
+    if freeze_backbone:
+        for param in model.features.parameters():
+            param.requires_grad = False
+
+    # Replace the classifier
+    model.classifier = nn.Sequential(
+        nn.Dropout(0.2),
+        nn.Linear(model.last_channel, num_classes)
+    )
+
+    return model

src/model/gradcam.py

@@ -0,0 +1,63 @@
+# src/model/gradcam.py
+
+import torch
+import torch.nn.functional as F
+import numpy as np
+import cv2
+
+class GradCAMPlusPlus:
+    def __init__(self, model, target_layer):
+        self.model = model
+        self.model.eval()
+        self.target_layer = target_layer
+
+        self.gradients = None
+        self.activations = None
+
+        # Hook to capture activations and gradients
+        target_layer.register_forward_hook(self._save_activations)
+        target_layer.register_full_backward_hook(self._save_gradients)
+
+    def _save_activations(self, module, input, output):
+        self.activations = output.detach()
+
+    def _save_gradients(self, module, grad_input, grad_output):
+        self.gradients = grad_output[0].detach()
+
+    def generate(self, input_tensor, class_idx=None):
+        # Forward pass
+        output = self.model(input_tensor)
+        if class_idx is None:
+            class_idx = output.argmax(dim=1).item()
+
+        # Zero gradients
+        self.model.zero_grad()
+
+        # Backward pass
+        loss = output[0, class_idx]
+        loss.backward(retain_graph=True)
+
+        # GradCAM++ calculation
+        grads = self.gradients  # [batch, channels, height, width]
+        activations = self.activations
+
+        grads_power_2 = grads ** 2
+        grads_power_3 = grads ** 3
+
+        sum_grads = torch.sum(grads, dim=(2, 3), keepdim=True)
+
+        eps = 1e-8  # Avoid divide-by-zero
+        alpha_numer = grads_power_2
+        alpha_denom = 2 * grads_power_2 + sum_grads * grads_power_3
+        alpha_denom = torch.where(alpha_denom != 0.0, alpha_denom, torch.ones_like(alpha_denom))
+        alphas = alpha_numer / alpha_denom
+
+        weights = (alphas * F.relu(grads)).sum(dim=(2, 3), keepdim=True)
+
+        cam = (weights * activations).sum(dim=1).squeeze()
+
+        cam = F.relu(cam)
+        cam = cam.cpu().numpy()
+        cam = cv2.resize(cam, (input_tensor.shape[2], input_tensor.shape[3]))
+        cam = (cam - np.min(cam)) / (np.max(cam) - np.min(cam) + eps)
+        return cam

src/model/predict.py

@@ -0,0 +1,26 @@
+import torch
+from PIL import Image
+
+def predict_single_image(model, image_path, transform, class_idx_to_name, device):
+    """
+    Predict the class of a single image.
+    
+    Args:
+        model: Trained model
+        image_path (str): Path to the image
+        transform: Transformations to apply
+        class_idx_to_name (dict): Mapping from class index to class name
+        device: torch.device
+    """
+    model.eval()
+
+    img = Image.open(image_path).convert("RGB")
+    img = transform(img).unsqueeze(0)  # Add batch dimension
+    img = img.to(device)
+
+    with torch.no_grad():
+        output = model(img)
+        _, pred = torch.max(output, 1)
+
+    predicted_class = class_idx_to_name[pred.item()]
+    return predicted_class

src/model/train.py

@@ -0,0 +1,48 @@
+import torch
+import torch.nn as nn
+
+def train_one_epoch(model, dataloader, optimizer, criterion, device):
+    model.train()
+    running_loss = 0.0
+    correct = 0
+    total = 0
+
+    for images, labels in dataloader:
+        images, labels = images.to(device), labels.to(device)
+
+        optimizer.zero_grad()
+        outputs = model(images)
+        loss = criterion(outputs, labels)
+        loss.backward()
+        optimizer.step()
+
+        running_loss += loss.item()
+        _, preds = outputs.max(1)
+        correct += preds.eq(labels).sum().item()
+        total += labels.size(0)
+
+    epoch_loss = running_loss / len(dataloader)
+    epoch_acc = correct / total
+    return epoch_loss, epoch_acc
+
+def validate_one_epoch(model, dataloader, criterion, device):
+    model.eval()
+    running_loss = 0.0
+    correct = 0
+    total = 0
+
+    with torch.no_grad():
+        for images, labels in dataloader:
+            images, labels = images.to(device), labels.to(device)
+
+            outputs = model(images)
+            loss = criterion(outputs, labels)
+
+            running_loss += loss.item()
+            _, preds = outputs.max(1)
+            correct += preds.eq(labels).sum().item()
+            total += labels.size(0)
+
+    epoch_loss = running_loss / len(dataloader)
+    epoch_acc = correct / total
+    return epoch_loss, epoch_acc

src/models/cropguard_best.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:926993adb8aba8af6cc714d23b580bf1d4d8a690b89ab5a9904ede4d57166e76
+size 9225099

src/models/labels.json

@@ -0,0 +1,19 @@
+{
+    "0": "grape___Grape___Black_rot",
+    "1": "grape___Grape___Esca_(Black_Measles)",
+    "2": "grape___Grape___Leaf_blight_(Isariopsis_Leaf_Spot)",
+    "3": "grape___Grape___healthy",
+    "4": "potato___Potato___Early_blight",
+    "5": "potato___Potato___Late_blight",
+    "6": "potato___Potato___healthy",
+    "7": "tomato___Tomato___Bacterial_spot",
+    "8": "tomato___Tomato___Early_blight",
+    "9": "tomato___Tomato___Late_blight",
+    "10": "tomato___Tomato___Leaf_Mold",
+    "11": "tomato___Tomato___Septoria_leaf_spot",
+    "12": "tomato___Tomato___Spider_mites Two-spotted_spider_mite",
+    "13": "tomato___Tomato___Target_Spot",
+    "14": "tomato___Tomato___Tomato_Yellow_Leaf_Curl_Virus",
+    "15": "tomato___Tomato___Tomato_mosaic_virus",
+    "16": "tomato___Tomato___healthy"
+}

src/utils/config.py

@@ -0,0 +1,41 @@
+import os
+
+# -------------------------------
+# Paths
+# -------------------------------
+
+# Dynamically find the real project root (CropGuard/)
+CURRENT_FILE = os.path.abspath(__file__)
+SRC_DIR = os.path.dirname(os.path.dirname(CURRENT_FILE))  # src/
+PROJECT_ROOT = os.path.dirname(SRC_DIR)  # CropGuard/
+
+DATA_DIR = os.path.join(PROJECT_ROOT, "data")
+CLEAN_DIR = os.path.join(DATA_DIR, "clean")
+SPLIT_DIR = os.path.join(DATA_DIR, "split")
+
+TRAIN_DIR = os.path.join(SPLIT_DIR, "train")
+VAL_DIR = os.path.join(SPLIT_DIR, "val")
+TEST_DIR = os.path.join(SPLIT_DIR, "test")
+
+MODEL_DIR = os.path.join(PROJECT_ROOT, "models")
+BEST_MODEL_PATH = os.path.join(MODEL_DIR, "cropguard_best.pt")
+LABELS_MAP_PATH = os.path.join(MODEL_DIR, "labels.json")
+
+# Target folders for download.py
+RAW_DIR = os.path.join(DATA_DIR, "plant_disease_raw")
+CLEAN_DIR = os.path.join(DATA_DIR, "clean")
+
+# Target crops
+TARGET_CROPS = ["Potato___", "Tomato___", "Grape___"]
+
+# Binary classification mapping (0=healthy, 1=sick)
+BINARY_CLASSES = {
+    "healthy": 0,
+    "sick": 1
+}
+
+# -------------------------------
+# Random Seed
+# -------------------------------
+
+SEED = 42

src/utils/transforms.py

@@ -0,0 +1,20 @@
+import torchvision.transforms as T
+
+def get_transforms(phase="train"):
+    if phase == "train":
+        return T.Compose([
+            T.RandomResizedCrop(224),
+            T.RandomHorizontalFlip(),
+            T.RandomRotation(20),
+            T.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2),
+            T.ToTensor(),
+            T.Normalize(mean=[0.485, 0.456, 0.406],
+                        std=[0.229, 0.224, 0.225]),
+        ])
+    else:
+        return T.Compose([
+            T.Resize((224, 224)),
+            T.ToTensor(),
+            T.Normalize(mean=[0.485, 0.456, 0.406],
+                        std=[0.229, 0.224, 0.225]),
+        ])