Upload github repo files

Sync up spaces repo with main github repo

.gitignore

@@ -0,0 +1,188 @@
+# Created by https://www.toptal.com/developers/gitignore/api/python
+# Edit at https://www.toptal.com/developers/gitignore?templates=python
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+### Python Patch ###
+# Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration
+poetry.toml
+
+# ruff
+.ruff_cache/
+
+# LSP config files
+pyrightconfig.json
+
+# End of https://www.toptal.com/developers/gitignore/api/python
+
+# Data specific files/folders
+data/
+
+# Mac's stuff
+.DS_Store
+
+# Model
+checkpoints/
+
+# UI
+flagged/

README.md

@@ -1,13 +1,103 @@
----
-title: Testing
-emoji: 🌍
-colorFrom: pink
-colorTo: blue
-sdk: gradio
-sdk_version: 6.1.0
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 5CCSAGAP: AI/Robotics Group Project - Plant Disease Detection
+
+This repository contains the source code for the "Plant Disease Detector" application, developed for the 5CCSAGAP module.
+
+## 1. Project Overview
+
+The goal of this project is to build an AI system capable of detecting plant diseases from leaf images. The application is built with a Python backend using PyTorch and is deployed with a Gradio user interface. The system supports two models: a custom-built CNN and a high-performance model based on ResNet18 transfer learning.
+
+**Team 4 Members:**
+- Oguzhan Cagirir
+- Janit Bhardwaj
+- Hristina Georgieva
+- Hissan Omar
+- Kasim Morsel
+- Mark Soltyk
+
+## 2. Running the Application
+
+This guide is for running the Gradio application locally to demonstrate its functionality.
+
+### Prerequisites
+- Python 3.10+
+- An active internet connection (for downloading model weights on first run).
+- Git LFS is **not** required as large files are hosted externally.
+
+### Setup Instructions
+
+1.  **Clone the repository:**
+    ```bash
+    git clone https://github.kcl.ac.uk/k23136072/Small-group-project.git
+    cd Small-group-project
+    ```
+
+2.  **Create and activate a Python virtual environment:**
+
+    **On Windows:**
+    ```bash
+    python -m venv .venv
+    .venv\Scripts\activate
+    ```
+
+    **On Linux/macOS:**
+    ```bash
+    python3 -m venv .venv
+    source .venv/bin/activate
+    ```
+
+3.  **Install dependencies:**
+    ```bash
+    pip install -r requirements.txt
+    ```
+
+### Launching the Gradio UI
+
+Once the setup is complete, launch the application:
+
+```bash
+python app.py
+```
+
+The application will start and provide a local URL (e.g., `http://127.0.0.1:7860`). Open this URL in your web browser.
+
+**Note on First Run:** The first time you make a prediction with a specific model (e.g., "ResNet18"), the application will automatically download the required model weights (~45MB) from Hugging Face Hub. This may take a moment. Subsequent runs will use the cached local copy.
+
+## 3. Repository Structure
+
+-   `app.py`: The main Gradio application entry point.
+-   `src/`: Contains all core source code.
+    -   `src/inference.py`: The core API for running model predictions. Handles model downloading and preprocessing.
+    -   `src/models/`: Contains the PyTorch model definitions (`cnn_model.py`, `resnet18_finetune.py`).
+    -   `src/DataLoader/`: Contains the data loading and processing logic used for training.
+    -   `src/train/`: Contains the training (`train.py`) and evaluation (`evaluate.py`) scripts.
+    -   `src/utils/`: Configuration and helper utilities.
+-   `configs/`: Contains the YAML configuration file for training.
+-   `requirements.txt`: Project dependencies.
+-   `process_dataset.py`: Utility script to download and prepare the dataset from Hugging Face.
+-   `README.md`: This file.
+
+## 4. Model Information
+
+The application supports two models, selectable via the UI dropdown:
+
+1.  **ResNet18 (Default):** A high-performance model using transfer learning from a pretrained ResNet18. Achieves **~96% accuracy** on the test set.
+2.  **CNN:** A custom-built baseline CNN, trained from scratch. Achieves **~78% accuracy** on the test set.
+
+Model weights are hosted on Hugging Face Hub at `MZaik/Plant_Disease_Detection` and are downloaded automatically by the application.
+
+## 5. Training and Evaluation (Advanced)
+
+To reproduce the training or evaluation runs, the repository is integrated with ClearML for experiment tracking.
+
+**Training:**
+1.  Configure `configs/train_cnn.yaml` (set `model_type` to `resnet18` or `cnn`).
+2.  Run `python -m src.train.train`.
+    *   This will automatically trigger data processing if the dataset is missing.
+    *   It will execute on the configured ClearML server if credentials are present, or locally if not.
+
+**Evaluation:**
+1.  Obtain a Model Task ID from a successful training run on ClearML.
+2.  Run `python -m src.evaluate --model_type resnet18 --task_id [TASK_ID]`.
+    *   This generates the confusion matrix and classification report artifacts.
+
+---

app.py

@@ -0,0 +1,151 @@
+import os
+import gradio as gr
+import pandas as pd
+from PIL import Image
+
+from src.inference import predict_image
+
+SAMPLE_IMGS = [
+    "plant_gallery/img1.jpg",
+    "plant_gallery/img2.jpg",
+    "plant_gallery/img3.jpg",
+    "plant_gallery/img4.jpg",
+    "plant_gallery/img5.jpg",
+]
+
+MODEL_REGISTRY = {
+    
+    "ResNet18": {
+        "model_type": "resnet18",
+        "clearml_model_id": "", # Model ID can be left blank since task artifacts are in use within the KCL system.
+        "clearml_task_id": "85a9b1c01454493087b5c068a4f21ec6",
+        "hf_repo_id": "MZaik/Plant_Disease_Detection",
+        "hf_filename": "plant_disease_resnet18.pt",
+        "local_path": "checkpoints/best_resnet18.pt",
+    },
+
+    "CNN": {
+        "model_type": "cnn",
+        "clearml_model_id": "",
+        "clearml_task_id": "d86e57c96044410b8fd151c084b1d527",
+        "hf_repo_id": "MZaik/Plant_Disease_Detection",
+        "hf_filename": "plant_disease_cnn.pt",
+        "local_path": "checkpoints/best_cnn.pt",
+    },
+}
+
+def predict_batch(files, model_name: str, topk: int):
+    if not files:
+        return pd.DataFrame(columns=["Image", "Rank", "Disease", "Probability", "Model"])
+
+    cfg = MODEL_REGISTRY[model_name]
+
+    os.environ["MODEL_TYPE"] = cfg["model_type"]
+    os.environ["CLEARML_MODEL_ID"] = cfg.get("clearml_model_id", "")
+    os.environ["CLEARML_TASK_ID"] = cfg.get("clearml_task_id", "")
+    os.environ["HF_REPO_ID"] = cfg.get("hf_repo_id", "")
+    os.environ["HF_FILENAME"] = cfg.get("hf_filename", "")
+    os.environ["MODEL_PATH"] = cfg.get("local_path", "")
+
+    rows = []
+    for fp in files:
+        img = Image.open(fp).convert("RGB")
+        df = predict_image(img, k=topk)
+        df.insert(0, "Rank", range(1, len(df) + 1))
+        df.insert(0, "Image", os.path.basename(fp))
+        df["Model"] = model_name
+        rows.append(df)
+
+    return pd.concat(rows, ignore_index=True)
+
+
+def add_gallery_to_files(evt: gr.SelectData, current_files):
+    # current_files will be list[str] of filepaths (or None)
+    if current_files is None:
+        current_files = []
+    selected_path = SAMPLE_IMGS[evt.index]
+    # avoid duplicates
+    if selected_path not in current_files:
+        current_files.append(selected_path)
+    return current_files
+
+
+def flag_current(files, model_name: str, topk: int, results_df: pd.DataFrame):
+    os.makedirs("flagged", exist_ok=True)
+    out_path = os.path.join("flagged", "flags.csv")
+
+    if not files or results_df is None or len(results_df) == 0:
+        return "Nothing to flag"
+
+    df = results_df.copy()
+    df.insert(0, "Files_Selected", ";".join(files))
+    df.insert(1, "Model_Selected", model_name)
+    df.insert(2, "TopK_Selected", int(topk))
+
+    header = not os.path.exists(out_path)
+    df.to_csv(out_path, mode="a", header=header, index=False)
+
+    return "Flag saved"
+
+
+with gr.Blocks(title="Plant Disease Detector") as demo:
+    gr.Markdown("# 🌿 Plant Disease Detector")
+
+    with gr.Row():
+        files = gr.File(
+            label="Upload one or more images",
+            file_count="multiple",
+            file_types=["image"],
+            type="filepath",
+        )
+
+    with gr.Row():
+        model_choice = gr.Dropdown(
+            label="Model",
+            choices=list(MODEL_REGISTRY.keys()),
+            value="ResNet18",
+        )
+        topk = gr.Slider(1, 5, value=5, step=1, label="Top-K predictions")
+
+    with gr.Row():
+        predict_btn = gr.Button("Predict", variant="primary")
+        flag_btn = gr.Button("Flag")
+        clear_btn = gr.Button("Clear")
+
+    with gr.Row():
+        gallery = gr.Gallery(
+            label="Plant Gallery",
+            value=SAMPLE_IMGS,
+            columns=5,
+            height=200,
+        )
+
+    results = gr.DataFrame(
+        headers=["Image", "Rank", "Disease", "Probability", "Model"],
+        datatype=["str", "number", "str", "number", "str"],
+        interactive=False,
+    )
+
+    flag_status = gr.Textbox(label="Flag status", interactive=False)
+
+    gallery.select(
+        fn=add_gallery_to_files,
+        inputs=[files],
+        outputs=[files],
+    )
+
+    predict_btn.click(predict_batch, inputs=[files, model_choice, topk], outputs=results)
+
+    flag_btn.click(
+        fn=flag_current,
+        inputs=[files, model_choice, topk, results],
+        outputs=[flag_status],
+    )
+
+    clear_btn.click(
+        lambda: ([], "ResNet18", 5, pd.DataFrame(columns=["Image","Rank","Disease","Probability","Model"]), ""),
+        inputs=None,
+        outputs=[files, model_choice, topk, results, flag_status],
+    )
+
+demo.launch()

configs/train_cnn.yaml

@@ -0,0 +1,24 @@
+project: "PlantDisease"
+task_name: "model_training"
+
+# Model Selection: 'resnet18' or 'cnn'
+model_type: "resnet18"
+
+num_classes: 39
+dropout: 0.5
+
+lr: 0.001
+weight_decay: 0.0001
+epochs: 10
+batch_size: 32
+image_size: 256
+
+patience: 3
+min_delta: 0.001
+save_last: true
+
+data_path: "data/processed_plant_village"
+train_samples_per_epoch : 38000
+val_samples_per_epoch: 8000
+test_samples_per_epoch: 8000
+num_workers: 0

process_dataset.py

@@ -0,0 +1,31 @@
+from datasets import load_dataset, DatasetDict
+
+SEED = 21
+
+print("Downloading dataset from hugging face...")
+
+# Download the dataset from huggingface
+ds = load_dataset("DScomp380/plant_village")
+# extract dataset from DatasetDict
+ds = ds['train']
+
+print("Splitting dataset into train/test/validation...")
+
+# First extract the training set
+temp = ds.train_test_split(train_size=0.70, shuffle=True, seed=SEED)
+# then split remaining dataset for test/validation
+test_valid_ds = temp['test'].train_test_split(train_size=0.5, shuffle=True, seed=SEED)
+
+# assign the sub datasets
+train_ds = temp['train']
+validation_ds = test_valid_ds['train']
+test_ds = test_valid_ds['test']
+
+# combine into one DatasetDict
+ds_dict = DatasetDict({
+    "train": train_ds,
+    "test": test_ds,
+    "validation": validation_ds
+})
+
+ds_dict.save_to_disk("data/processed_plant_village")

requirements.txt

@@ -0,0 +1,11 @@
+numpy<2.0
+torch
+pillow
+datasets
+matplotlib
+torchvision
+scikit-learn
+seaborn
+clearml
+gradio
+huggingface_hub

src/DataLoader/dataloader.py

@@ -0,0 +1,44 @@
+import torch
+import datasets
+from torch.utils.data import DataLoader, WeightedRandomSampler, BatchSampler
+
+from src.DataLoader.plantvillage_dataset import PlantVillageDataset
+from src.DataLoader.utils import calc_class_dist
+
+def create_dataloader(dataset: datasets.Dataset, batch_size: int, samples_per_epoch: int, is_training_set: bool = True) -> DataLoader:
+    """
+    Creates a new torch dataloader using given dataset and parameters.
+
+    Args:
+        dataset (datasets.Dataset): Dataset loaded using huggingface datasets library.
+        batch_size (int): Number of examples to sample per batch.
+        samples_per_epoch (int): Total number of examples to sample in one epoch.
+        is_training_set (bool): decides whether the given dataset should provide augmented images (Default is True).
+
+    Returns:
+        torch.utils.data.Dataloader: Returns a newly created dataloader.
+
+    Example:
+        `loader = create_dataloader(train_ds, 32, 1000)`
+    """
+    
+    # Assign creation of torch-compatible dataset from hf dataset
+    torch_dataset = PlantVillageDataset(dataset, is_training_set)
+
+    # retrieve class percentages
+    class_percent = torch.tensor(calc_class_dist(dataset))
+    
+    # calculate weight per class
+    class_weights = 1.0 / class_percent
+    class_weights = class_weights / class_weights.sum()
+
+    # assign class weights to each sample for the weighted sampler 
+    labels = torch.tensor(dataset['label'])
+    sample_weights = class_weights[labels]
+    
+
+    # create sampler and dataloader
+    sampler = WeightedRandomSampler(sample_weights, replacement = True, num_samples=samples_per_epoch)
+    loader = DataLoader(torch_dataset, batch_sampler=BatchSampler(sampler, batch_size=batch_size, drop_last=True))
+
+    return loader

src/DataLoader/plantvillage_dataset.py

@@ -0,0 +1,50 @@
+from torch.utils.data import Dataset
+import torchvision.transforms.v2 as T
+import torch.nn.functional as F
+import datasets
+import torch
+from src.DataLoader.utils import rotate90
+
+class PlantVillageDataset(Dataset): 
+    def __init__(self, dataset: datasets.Dataset, is_training_set: bool):
+        self.dataset = dataset
+
+        self.num_classes = len(set(dataset['label']))
+        
+        norm_transform = T.Compose([
+            T.Resize((256,256)),
+            T.ToImage(),
+            T.ToDtype(torch.float32, scale=True) # change values to range 0.0-1.0
+        ])
+
+        if is_training_set:
+
+            augmentation = T.RandomApply([
+                T.ColorJitter(brightness=0.5, saturation=0.4),
+                T.RandomHorizontalFlip(p=0.5),
+                T.Lambda(rotate90),  # wrap custom rotation function 
+                T.GaussianBlur(kernel_size=3, sigma=(0.1, 1.0))
+            ], p=0.5)
+
+            self.transform = T.Compose([
+                augmentation,
+                norm_transform
+            ])
+        
+        # no augmentation for test/validation sets
+        else:
+            self.transform = norm_transform
+
+    def __len__(self):
+        return len(self.dataset)
+    
+    def __getitem__(self, idx):
+
+        img, label = self.dataset['image'][idx], self.dataset['label'][idx]
+
+        # augment/normalize image
+        img = self.transform(img)
+
+        label = torch.tensor(label)
+
+        return img, F.one_hot(label, num_classes=self.num_classes)

src/DataLoader/utils.py

@@ -0,0 +1,33 @@
+import datasets
+import random
+import torchvision.transforms.v2.functional as functional
+from collections import Counter
+
+def rotate90(image):
+        """Rotate the image by a random multiple of 90 degrees"""
+        angle = 90 * random.randint(1,3)
+        return functional.rotate(image, angle=angle)
+
+def calc_class_dist(dataset: datasets.Dataset) -> list[float]:
+    """
+    Return percentage of total examples, done per class.
+    """
+
+    # extract classes only
+    labels = dataset["label"]
+    counts = Counter(labels)
+
+    total_size = sum(counts.values())
+    percents = [100 * counts.get(i, 0) / total_size for i in range(max(labels)+1)]
+    
+    return percents
+
+def int_to_string(dataset: datasets.Dataset, int_label: int) -> str:
+    """
+    Converts integer labels to their string counterpart.
+    """
+
+    if not (0 <= int_label <= 38):
+        raise ValueError(f"Given label value, {int_label}, is out of range.")
+
+    return dataset.features['label'].int2str(int_label)

src/evaluate.py

@@ -0,0 +1,120 @@
+import torch
+import numpy as np
+import matplotlib.pyplot as plt
+import argparse
+import os
+import sys
+import subprocess
+from sklearn.metrics import confusion_matrix, classification_report
+import seaborn as sns
+
+from src.DataLoader.dataloader import create_dataloader
+from src.models.resnet18_finetune import make_resnet18
+from src.models.cnn_model import PlantCNN
+from src.utils.config import load_config
+from datasets import load_from_disk
+from clearml import Task, InputModel
+
+def load_model_from_clearml(task_id: str, model_type: str, num_classes: int, device: str):
+    print(f"[INFO] Loading 'best_model' artifact from Task ID '{task_id}'...")
+    try:
+        source_task = Task.get_task(task_id=task_id)
+        model_path = source_task.artifacts['best_model'].get_local_copy()
+        print(f"[INFO] Model downloaded to: {model_path}")
+    except Exception as e:
+        print(f"[FATAL] Could not retrieve artifact from Task {task_id}. Error: {e}")
+        exit(1)
+    
+    if model_type.lower() == 'resnet18':
+        model = make_resnet18(num_classes=num_classes)
+    elif model_type.lower() == 'cnn':
+        model = PlantCNN(num_classes=num_classes)
+    else:
+        raise ValueError(f"Unknown model type: {model_type}")
+        
+    state_dict = torch.load(model_path, map_location=device)
+    if 'state_dict' in state_dict:
+        state_dict = state_dict['state_dict']
+        
+    model.load_state_dict(state_dict)
+    model.to(device)
+    model.eval()
+    print("[SUCCESS] Model loaded and ready.")
+    return model
+
+def evaluate_model(model, loader, device):
+    """
+    Runs inference on the entire dataloader and returns predictions and labels.
+    """
+    all_preds, all_labels = [], []
+    with torch.no_grad():
+        for inputs, labels in loader:
+            inputs = inputs.to(device)
+            if labels.ndim > 1:
+                labels = labels.argmax(dim=1)
+            
+            outputs = model(inputs)
+            preds = outputs.argmax(dim=1).cpu().numpy()
+            
+            all_preds.extend(preds)
+            all_labels.extend(labels.cpu().numpy())
+    return np.array(all_labels), np.array(all_preds)
+
+def main():
+    task = Task.init(project_name="PlantDisease", task_name="model_evaluation", task_type=Task.TaskTypes.testing)
+    
+    task.set_packages("./requirements.txt")
+    
+    task.execute_remotely(queue_name="default") 
+    
+    parser = argparse.ArgumentParser(description="Evaluate a trained model from ClearML.")
+    parser.add_argument('--task_id', type=str, required=True, help="ClearML Task ID that produced the model.")
+    parser.add_argument('--model_type', type=str, required=True, choices=['resnet18', 'cnn'])
+    args = parser.parse_args()
+    
+    task.connect(args)
+    logger = task.get_logger()
+    
+    print(f"--- Evaluating Model from Task ID: {args.task_id} ({args.model_type.upper()}) ---")
+    
+    cfg = load_config()
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    
+    data_path = cfg['data_path']
+    if not os.path.exists(data_path):
+        print(f"[WARN] Data path '{data_path}' not found. Running processing script...")
+        subprocess.check_call([sys.executable, "process_dataset.py"])
+    
+    ds_dict = load_from_disk(data_path)
+    test_loader = create_dataloader(ds_dict['test'], batch_size=32, samples_per_epoch=len(ds_dict['test']), is_training_set=False)
+    
+    class_names = ds_dict['test'].features['label'].names
+    num_classes = len(class_names)
+    
+    model = load_model_from_clearml(args.task_id, args.model_type, num_classes, device)
+    
+    y_true, y_pred = evaluate_model(model, test_loader, device)
+    
+    print("\n--- Generating Reports and Plots ---")
+    
+    report_dict = classification_report(y_true, y_pred, target_names=class_names, zero_division=0, output_dict=True)
+    report_text = classification_report(y_true, y_pred, target_names=class_names, zero_division=0)
+    print(report_text)
+    task.upload_artifact(name="classification_report", artifact_object=report_dict)
+    
+    cm = confusion_matrix(y_true, y_pred)
+    plt.figure(figsize=(22, 22))
+    sns.heatmap(cm, annot=False, cmap='Blues', xticklabels=class_names, yticklabels=class_names)
+    plt.ylabel('True Label', fontsize=14)
+    plt.xlabel('Predicted Label', fontsize=14)
+    plt.title(f'Confusion Matrix - {args.model_type.upper()}', fontsize=16)
+    plt.tight_layout()
+    
+    logger.report_matplotlib_figure(title="Confusion Matrix", series=args.model_type, figure=plt, report_image=True)
+    
+    print("[SUCCESS] Evaluation complete. Artifacts logged to ClearML.")
+    
+    task.close()
+
+if __name__ == "__main__":
+    main()

src/inference.py

@@ -0,0 +1,289 @@
+from __future__ import annotations
+
+import os
+from typing import List
+
+import numpy as np
+import pandas as pd
+from PIL import Image
+
+import torch
+import torch.nn as nn
+import torchvision.transforms.v2 as T
+
+from clearml import InputModel, Task
+
+from huggingface_hub import hf_hub_download
+
+from src.models.cnn_model import PlantCNN
+from src.models.resnet18_finetune import make_resnet18
+
+from src.utils.class_names import CLASS_NAMES
+
+
+_MODEL_CACHE = {}
+_CLASS_NAMES_CACHE = None
+
+
+def _device_key(device: torch.device) -> str:
+    return str(device)
+
+
+def _get_device() -> torch.device:
+    if torch.cuda.is_available():
+        return torch.device("cuda")
+    if getattr(torch.backends, "mps", None) and torch.backends.mps.is_available():
+        return torch.device("mps")
+    return torch.device("cpu")
+
+
+def _build_val_transform(image_size: int = 256) -> T.Compose:
+    return T.Compose([
+        T.Resize((image_size, image_size)),
+        T.ToImage(),
+        T.ToDtype(torch.float32, scale=True),
+    ])
+
+
+def _load_model_from_checkpoint(
+    model_path: str,
+    num_classes: int,
+    model_type: str,
+    device: torch.device,
+) -> nn.Module:
+    if not os.path.isfile(model_path):
+        raise FileNotFoundError(f"Model file not found - {model_path}")
+
+    ckpt = torch.load(model_path, map_location=device)
+
+    if model_type.lower() == "resnet18":
+        model = make_resnet18(num_classes=num_classes)
+    elif model_type.lower() == "cnn":
+        model = PlantCNN(num_classes=num_classes)
+    else:
+        raise ValueError(f"Unknown model type - {model_type}. Must be 'resnet18' or 'cnn'.")
+
+    if isinstance(ckpt, dict) and "state_dict" in ckpt:
+        model.load_state_dict(ckpt["state_dict"])
+    elif isinstance(ckpt, nn.Module):
+        model = ckpt
+    else:
+        try:
+            model.load_state_dict(ckpt)
+        except Exception:
+            raise ValueError(f"Unexpected checkpoint format in - {model_path}. ")
+
+    model.to(device)
+    model.eval()
+    
+    return model
+
+
+def _load_model_from_clearml_model_id(
+    model_id: str,
+    num_classes: int,
+    model_type: str,
+    device: torch.device,
+) -> nn.Module:
+
+    model_obj = InputModel(model_id=model_id)
+    downloaded_path = model_obj.get_local_copy()
+    
+    if downloaded_path is None:
+        raise FileNotFoundError(f"Failed to download model from ClearML Model ID - {model_id}")
+
+    if os.path.isdir(downloaded_path):
+        model_files = [f for f in os.listdir(downloaded_path) if f.endswith((".pt", ".pth"))]
+        if model_files:
+            model_path = os.path.join(downloaded_path, model_files[0])
+        else:
+            for name in ["best_baseline.pt", "best_model.pt", "best_baseline.pth", "best_model.pth"]:
+                candidate = os.path.join(downloaded_path, name)
+                if os.path.isfile(candidate):
+                    model_path = candidate
+                    break
+            if model_path is None:
+                raise FileNotFoundError(f"No model file found in directory - {downloaded_path}")
+    else:
+        model_path = downloaded_path
+
+    if model_type.lower() == "resnet18":
+        model = make_resnet18(num_classes=num_classes)
+    elif model_type.lower() == "cnn":
+        model = PlantCNN(num_classes=num_classes)
+    else:
+        raise ValueError(f"Unknown model type - {model_type}. Must be 'resnet18' or 'cnn'.")
+
+    state_dict = torch.load(model_path, map_location=device)
+    if isinstance(state_dict, dict) and "state_dict" in state_dict:
+        state_dict = state_dict["state_dict"]
+
+    model.load_state_dict(state_dict)
+    model.to(device)
+    model.eval()
+
+    return model
+
+
+def _load_model_from_clearml_task_id(
+    task_id: str,
+    num_classes: int,
+    model_type: str,
+    device: torch.device,
+) -> nn.Module:
+
+    source_task = Task.get_task(task_id=task_id)
+    artifact_names = ["best_model", "best_baseline", "model"]
+    model_path = None
+    
+    for artifact_name in artifact_names:
+        if artifact_name in source_task.artifacts:
+            model_path = source_task.artifacts[artifact_name].get_local_copy()
+            if model_path:
+                break
+    
+    if model_path is None:
+        raise FileNotFoundError(f"No model artifact found in Task ID - {task_id}")
+
+    if model_type.lower() == "resnet18":
+        model = make_resnet18(num_classes=num_classes)
+    elif model_type.lower() == "cnn":
+        model = PlantCNN(num_classes=num_classes)
+    else:
+        raise ValueError(f"Unknown model type - {model_type}. Must be 'resnet18' or 'cnn'.")
+
+    state_dict = torch.load(model_path, map_location=device)
+    if isinstance(state_dict, dict) and "state_dict" in state_dict:
+        state_dict = state_dict["state_dict"]
+
+    model.load_state_dict(state_dict)
+    model.to(device)
+    model.eval()
+
+    return model
+
+
+def _load_model_from_huggingface(
+    repo_id: str,
+    filename: str,
+    num_classes: int,
+    model_type: str,
+    device: torch.device,
+) -> nn.Module:
+
+    model_path = hf_hub_download(repo_id=repo_id, filename=filename, repo_type="model")
+
+    if model_type.lower() == "resnet18":
+        model = make_resnet18(num_classes=num_classes)
+    elif model_type.lower() == "cnn":
+        model = PlantCNN(num_classes=num_classes)
+    else:
+        raise ValueError(f"Unknown model type - {model_type}. Must be 'resnet18' or 'cnn'.")
+
+    state_dict = torch.load(model_path, map_location=device)
+    if isinstance(state_dict, dict) and "state_dict" in state_dict:
+        state_dict = state_dict["state_dict"]
+
+    model.load_state_dict(state_dict)
+    model.to(device)
+    model.eval()
+
+    return model
+
+
+
+def _get_class_names() -> List[str]:
+    return CLASS_NAMES
+
+
+def predict_image(img: Image.Image, k: int = 5) -> pd.DataFrame:
+    """
+    Predict top-k for a single PIL image.
+    Returns a DataFrame with columns: Img, Rank, Disease, Probability, Model
+    """
+    if img is None:
+        return pd.DataFrame({"Disease": [], "Probability": []})
+
+    try:
+        class_names = _get_class_names()
+        if not class_names:
+            raise ValueError("class_names list is empty.")
+
+        model_type = os.getenv("MODEL_TYPE", "resnet18")
+        model_path = os.getenv("MODEL_PATH", "")
+        clearml_model_id = os.getenv("CLEARML_MODEL_ID", "")
+        clearml_task_id = os.getenv("CLEARML_TASK_ID", "")
+        hf_repo_id = os.getenv("HF_REPO_ID", "")
+        hf_filename = os.getenv("HF_FILENAME", "")
+
+        device = _get_device()
+        device_k = _device_key(device)
+        num_classes = len(class_names)
+        transform = _build_val_transform(image_size=256)
+
+        x = transform(img.convert("RGB")).unsqueeze(0).to(device)
+
+        model = None
+
+        #  ClearML Model ID
+        if clearml_model_id and clearml_model_id.strip():
+            cache_key = ("clearml_model", model_type, clearml_model_id, num_classes, device_k)
+            if cache_key not in _MODEL_CACHE:
+                try:
+                    _MODEL_CACHE[cache_key] = _load_model_from_clearml_model_id(clearml_model_id, num_classes, model_type, device)
+                except Exception:
+                    _MODEL_CACHE[cache_key] = None
+            model = _MODEL_CACHE.get(cache_key)
+
+        # ClearML Task ID
+        if model is None and clearml_task_id and clearml_task_id.strip():
+            cache_key = ("clearml_task", model_type, clearml_task_id, num_classes, device_k)
+            if cache_key not in _MODEL_CACHE:
+                try:
+                    _MODEL_CACHE[cache_key] = _load_model_from_clearml_task_id(clearml_task_id, num_classes, model_type, device)
+                except Exception:
+                    _MODEL_CACHE[cache_key] = None
+            model = _MODEL_CACHE.get(cache_key)
+
+        # Hugging Face
+        if model is None and hf_repo_id and hf_repo_id.strip() and hf_filename and hf_filename.strip():
+            cache_key = ("huggingface", model_type, hf_repo_id, hf_filename, num_classes, device_k)
+            if cache_key not in _MODEL_CACHE:
+                try:
+                    _MODEL_CACHE[cache_key] = _load_model_from_huggingface(hf_repo_id, hf_filename, num_classes, model_type, device)
+                except Exception:
+                    _MODEL_CACHE[cache_key] = None
+            model = _MODEL_CACHE.get(cache_key)
+
+        # Local checkpoint
+        if model is None:
+            if model_path and os.path.isfile(model_path):
+                cache_key = ("local", model_type, model_path, num_classes, device_k)
+                if cache_key not in _MODEL_CACHE:
+                    _MODEL_CACHE[cache_key] = _load_model_from_checkpoint(model_path, num_classes, model_type, device)
+                model = _MODEL_CACHE[cache_key]
+            else:
+                raise FileNotFoundError(
+                    f"All loading methods failed. Model ID - {clearml_model_id}, Task ID - {clearml_task_id}, HF - {hf_repo_id}/{hf_filename}, Local path - {model_path}"
+                )
+
+
+        with torch.no_grad():
+            logits = model(x)
+            probs = torch.softmax(logits, dim=1)[0]
+
+        topk = min(int(k), len(class_names))
+        top_probs, top_indices = torch.topk(probs, k=topk)
+
+        results = [
+            (class_names[idx.item()], float(prob.item()))
+            for prob, idx in zip(top_probs, top_indices)
+        ]
+
+        return pd.DataFrame({
+            "Disease": [r[0] for r in results],
+            "Probability": [r[1] for r in results],
+        })
+
+    except Exception as e:
+        return pd.DataFrame({"Disease": [f"Error: {str(e)}"], "Probability": [0.0]})

src/models/cnn_model.py

@@ -0,0 +1,57 @@
+import torch.nn as nn
+
+def conv_block(cin: int, cout: int, kernel_size: int = 3, padding: int = 1, p_drop: float = 0.1) -> nn.Sequential:
+    """
+    A standard convolutional block comprising Conv2d, BatchNorm2d, ReLU, MaxPool2d, and Dropout2d.
+    This follows the well known best-practice of applying regularisation and downsampling within the feature extractor.
+    """
+    return nn.Sequential(
+        nn.Conv2d(cin, cout, kernel_size=kernel_size, padding=padding, bias=False),
+        nn.BatchNorm2d(cout),
+        nn.ReLU(inplace=True),
+        nn.MaxPool2d(2),
+        nn.Dropout2d(p_drop)
+    )
+
+class PlantCNN(nn.Module):
+    """
+    A simple CNN architecture designed for the PlantVillage dataset.
+
+    This model is intentionally kept simple as a baseline.
+
+    It implements common-sense architectural choices:
+    
+    1.  Progressively increases channel depth (3 -> 32 -> 64 -> 128).
+    2.  Reduces spatial resolution at each block via MaxPooling.
+    3.  Uses a two-layer dense head for improved classification.
+    
+    The model also includes an adaptive average pool.
+    """
+    def __init__(self, num_classes: int = 39, p_drop: float = 0.5):
+        super().__init__()
+        
+        # FE. Progressively increase the channel depth while halving spatial resolution.
+        self.features = nn.Sequential(
+            conv_block(3, 32),
+            conv_block(32, 64),
+            conv_block(64, 128),
+        )
+
+        # GAP. Creates fixed-size FV for the classifier head.
+        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
+        
+        # CH. Two-layer super dense head.
+        self.classifier = nn.Sequential(
+            nn.Flatten(),
+            nn.Linear(128, 64),
+            nn.ReLU(inplace=True),
+            nn.Dropout(p_drop),
+            nn.Linear(64, num_classes),
+        )
+
+    def forward(self, x):
+        """Forward pass of the model."""
+        x = self.features(x)
+        x = self.avgpool(x)
+        x = self.classifier(x)
+        return x

src/models/resnet18_finetune.py

@@ -0,0 +1,20 @@
+import torch.nn as nn
+from torchvision import models
+
+def make_resnet18(num_classes=39):
+    """
+    Constructs a ResNet18 model with a custom classification head for PlantVillage.
+    The feature extractor weights are frozen (transfer learning).
+    """
+    # Load pretrained model
+    # Note: In the lab we used weights=...V1. Here we use the same.
+    model = models.resnet18(weights=models.ResNet18_Weights.IMAGENET1K_V1)
+    
+    # Freeze feature extractor
+    for param in model.parameters():
+        param.requires_grad = False
+
+    num_ftrs = model.fc.in_features
+    model.fc = nn.Linear(num_ftrs, num_classes)
+    
+    return model

src/train/early_stopping.py

@@ -0,0 +1,14 @@
+class EarlyStopping:
+    def __init__(self, patience=3, min_delta=0.0):
+        self.patience = patience
+        self.min_delta = float(min_delta)
+        self.best = None
+        self.count = 0
+        
+    def step(self, metric):
+        if self.best is None or metric > self.best + self.min_delta:
+            self.best = metric
+            self.count = 0
+            return False
+        self.count += 1
+        return self.count >= self.patience

src/train/train.py

@@ -0,0 +1,163 @@
+import os
+import time
+import torch
+import torch.nn as nn
+from torch.optim import AdamW
+from datasets import load_from_disk
+import subprocess
+import sys
+
+# Import models
+from src.models.resnet18_finetune import make_resnet18
+from src.models.cnn_model import PlantCNN
+
+# Import utils
+from src.utils.config import load_config
+from src.utils.metrics import accuracy, topk_accuracy
+from src.train.early_stopping import EarlyStopping
+
+# Import Dataloader
+from src.DataLoader.dataloader import create_dataloader
+
+def train_one_epoch(model, loader, criterion, opt, device):
+    model.train()
+    total_loss, total_correct, total_samples = 0.0, 0, 0
+    for inputs, labels in loader:
+        inputs = inputs.to(device)
+        
+        # Loader might return one-hot labels. CrossEntropyLoss needs indices.
+        if labels.ndim > 1:
+            labels = labels.argmax(dim=1)
+        labels = labels.to(device).long()
+
+        opt.zero_grad(set_to_none=True)
+        logits = model(inputs)
+        loss = criterion(logits, labels)
+        loss.backward()
+        opt.step()
+
+        batch_size = inputs.size(0)
+        total_loss += loss.item() * batch_size
+        total_correct += (logits.argmax(1) == labels).sum().item()
+        total_samples += batch_size
+    return total_loss / total_samples, total_correct / total_samples
+
+@torch.no_grad()
+def evaluate(model, loader, criterion, device, topk=5):
+    model.eval()
+    total_loss, total_correct, total_topk, total_samples = 0.0, 0, 0, 0
+    for inputs, labels in loader:
+        inputs = inputs.to(device)
+        if labels.ndim > 1:
+            labels = labels.argmax(dim=1)
+        labels = labels.to(device).long()
+
+        logits = model(inputs)
+        loss = criterion(logits, labels)
+
+        batch_size = inputs.size(0)
+        total_loss += loss.item() * batch_size
+        total_correct += (logits.argmax(1) == labels).sum().item()
+        
+        # Top-k
+        topk_preds = logits.topk(topk, dim=1).indices
+        total_topk += (topk_preds == labels.unsqueeze(1)).any(dim=1).sum().item()
+        total_samples += batch_size
+    return total_loss / total_samples, total_correct / total_samples, total_topk / total_samples
+
+def main():
+    print("[INFO] Starting Integration Training Pipeline")
+    
+    # 1. Config
+    cfg = load_config()
+    os.makedirs("checkpoints", exist_ok=True)
+
+    # 2. ClearML
+    try:
+        from clearml import Task
+        task = Task.init(project_name=cfg.get("project", "PlantDisease"), task_name=cfg.get("task_name", "model_training"))
+        task.set_packages("./requirements.txt")
+        task.execute_remotely(queue_name="default")
+        task.connect(cfg)
+        logger = task.get_logger()
+        print("[INFO] ClearML Initialized")
+    except ImportError:
+        logger = None
+        print("[INFO] ClearML not found, skipping logging")
+
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    print(f"[INFO] Device: {device}")
+
+    data_path = cfg['data_path']
+    if not os.path.exists(data_path):
+        print(f"[WARN] Data path '{data_path}' not found.")
+        print("[INFO] Attempting to run data processing script...")
+        try:
+            subprocess.check_call([sys.executable, "process_dataset.py"])
+            print("[SUCCESS] Data processing complete.")
+        except subprocess.CalledProcessError as e:
+            print(f"[FATAL] Data processing failed: {e}")
+            exit(1)
+
+    # 3. Data
+    print(f"[INFO] Loading data from {cfg['data_path']}")
+    ds_dict = load_from_disk(cfg['data_path'])
+    
+    dl_train = create_dataloader(ds_dict['train'], cfg['batch_size'], cfg['train_samples_per_epoch'], True)
+    dl_val = create_dataloader(ds_dict['validation'], cfg['batch_size'], cfg['val_samples_per_epoch'], False)
+    dl_test = create_dataloader(ds_dict['test'], cfg['batch_size'], cfg['test_samples_per_epoch'], False)
+
+    # 4. Model Selection & Optimizer Setup
+    model_type = cfg.get('model_type', 'resnet18').lower()
+    print(f"[INFO] Initializing model architecture: {model_type}")
+
+    if model_type == 'resnet18':
+        model = make_resnet18(num_classes=cfg['num_classes'])
+        model = model.to(device)
+        # For ResNet transfer learning, we typically only optimize the head
+        opt = AdamW(model.fc.parameters(), lr=cfg['lr'], weight_decay=cfg['weight_decay'])
+        print("[INFO] Optimizer configured for ResNet head only.")
+    
+    elif model_type == 'cnn':
+        model = PlantCNN(num_classes=cfg['num_classes'], p_drop=cfg.get('dropout', 0.5))
+        model = model.to(device)
+        # For custom CNN, we optimize all parameters
+        opt = AdamW(model.parameters(), lr=cfg['lr'], weight_decay=cfg['weight_decay'])
+        print("[INFO] Optimizer configured for full CNN parameters.")
+        
+    else:
+        raise ValueError(f"Unknown model_type in config: {model_type}. Must be 'resnet18' or 'cnn'.")
+
+    # 5. Setup Loss & Stopper
+    crit = nn.CrossEntropyLoss()
+    stopper = EarlyStopping(patience=cfg['patience'], min_delta=cfg['min_delta'])
+    
+    # 6. Loop
+    best_acc = 0.0
+    for epoch in range(1, cfg['epochs'] + 1):
+        train_loss, train_acc = train_one_epoch(model, dl_train, crit, opt, device)
+        val_loss, val_acc, val_top5 = evaluate(model, dl_val, crit, device, topk=5)
+        
+        print(f"Epoch {epoch:02d} | Train Loss: {train_loss:.4f} Acc: {train_acc:.3f} | Val Loss: {val_loss:.4f} Acc: {val_acc:.3f} Top5: {val_top5:.3f}")
+        
+        if logger:
+            logger.report_scalar("Loss", "train", train_loss, iteration=epoch)
+            logger.report_scalar("Accuracy", "train", train_acc, iteration=epoch)
+            logger.report_scalar("Loss", "val", val_loss, iteration=epoch)
+            logger.report_scalar("Accuracy", "val", val_acc, iteration=epoch)
+        
+        if val_acc > best_acc:
+            best_acc = val_acc
+            torch.save(model.state_dict(), "checkpoints/best_baseline.pt")
+            
+        if stopper.step(val_acc):
+            print("Early stopping.")
+            break
+    
+    if logger:
+        print("[INFO] Uploading best model artifact to ClearML...")
+        task.upload_artifact(name="best_model", artifact_object="checkpoints/best_baseline.pt")
+        print("[SUCCESS] Model uploaded.")
+
+if __name__ == "__main__":
+    main()

src/utils/class_names.py

@@ -0,0 +1,41 @@
+CLASS_NAMES = [
+    'Apple___Apple_scab',
+    'Apple___Black_rot',
+    'Apple___Cedar_apple_rust',
+    'Apple___healthy',
+    'Background_without_leaves',
+    'Blueberry___healthy',
+    'Cherry___Powdery_mildew',
+    'Cherry___healthy',
+    'Corn___Cercospora_leaf_spot Gray_leaf_spot',
+    'Corn___Common_rust',
+    'Corn___Northern_Leaf_Blight',
+    'Corn___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'
+]

src/utils/config.py

@@ -0,0 +1,6 @@
+import yaml
+
+def load_config(config_path: str = "configs/train_cnn.yaml") -> dict:
+    """Loads a YAML configuration file."""
+    with open(config_path) as f:
+        return yaml.safe_load(f)

src/utils/metrics.py

@@ -0,0 +1,9 @@
+import torch
+
+def accuracy(logits, y):
+    return (logits.argmax(1) == y).float().mean().item()
+
+def topk_accuracy(logits, y, k=5):
+    topk = logits.topk(k, dim=1).indices
+    return (topk == y.unsqueeze(1)).any(dim=1).float().mean().item()
+