Upload folder using huggingface_hub

.gitignore

@@ -0,0 +1,92 @@
+# 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
+
+# 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
+*.pyo
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translation files
+*.mo
+*.pot
+
+# Logs
+*.log
+logs/
+
+# Django stuff (common patterns):
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Project Specific Directories (Data & Models)
+.chromadb/
+.chromadb_test/
+whisper-small-hy-ct2/
+data/raw/
+data/processed/
+models/
+task.pdf
+plan.md
+
+# Tool Caches
+.ruff_cache/
+.mypy_cache/
+
+# IDEs
+.vscode/
+.idea/
+.DS_Store
+.history/
+
+# OS-specific
+Thumbs.db
+Desktop.ini

README.md

@@ -0,0 +1,138 @@
+# Plant Disease Classification
+
+A robust, configurable deep learning pipeline for plant disease classification using PyTorch. This project leverages `timm` for a vast array of pre-trained backbones (e.g., EfficientNetV2, ConvNeXtV2, EVA02) and offers advanced training features such as Exponential Moving Average (EMA) for weights, Layer-wise Learning Rate Decay (LLRD), MixUp/CutMix data augmentation, and Weights & Biases (W&B) integration for experiment tracking.
+
+
+- **Web Interface:** [](https://huggingface.co/spaces/)
+- **REST API Documentation:** [s]()
+## Features
+
+- **Extensive Model Support**: Easily swap backbones by changing the config, enabled by integration with `timm`.
+- **Advanced Training Techniques**:
+  - Model EMA (Exponential Moving Average) to stabilize training and improve generalization.
+  - Layer-wise Learning Rate Decay (LLRD) for optimal fine-tuning of transformer and CNN architectures like `vit`, `convnextv2`.
+  - Mixed Precision Training for faster execution and lower memory footprint.
+  - Gradient Accumulation.
+- **Data Augmentation**: MixUp and CutMix integrations for regularization.
+- **Customizable Configuration**: Highly modular experiment setups using `omegaconf` (YAML config files).
+- **Experiment Tracking**: Full integration with Weights & Biases logging everything from hyperparameter configs to validation metrics.
+
+## Results
+
+| Model | mAP | Accuracy |
+| :--- | :---: | :---: |
+| EfficientNetV2 Small | 0.87 | 0.815 |
+| DINOv3 ViT Small Plus | 0.91 | 0.830 |
+| ConvNeXtV2 Tiny | 0.94 | 0.860 |
+
+## Project Structure
+
+```
+Plant-Disease-Classification/
+├── configs/
+│   └── config.yaml          # Main configuration file
+├── data/
+│   ├── train/               # Train data (organized by class folders)
+│   └── val/                 # Val data (organized by class folders)
+├── src/
+│   ├── dataset.py           # Dataloaders and augmentation logic
+│   ├── infer.py             # Inference script and prediction utilities
+│   ├── loss.py              # Loss functions (CrossEntropy, Focal Loss)
+│   ├── metrics.py           # Metric calculations
+│   ├── models.py            # Model definitions and param groupings
+│   ├── trainer.py           # Core training loop
+│   └── utils.py             # Helpers (schedulers, seeds, config loading)
+├── train.py                 # Main entrypoint for training
+└── requirements.txt         # Project dependencies
+```
+
+## Quick Start
+
+### 1. Environment Setup
+
+It is highly recommended to use [`uv`](https://github.com/astral-sh/uv) for fast, reliable package management.
+
+```bash
+# Create a virtual environment using uv
+uv venv
+
+# Activate the environment
+source .venv/bin/activate  # Linux/MacOS
+
+# Install dependencies rapidly
+uv pip install -r requirements.txt
+```
+
+### 2. Prepare Data
+
+Ensure your dataset is arranged in PyTorch `ImageFolder` format. Place the training data in `data/train` and validation data in `data/val`. Each subplot or leaf should be in its corresponding disease or health category folder.
+
+```text
+data/
+└── train/
+    ├── Apple scab/
+    └── ...
+```
+
+### 3. Provide Configuration
+
+Modify the hyperparameters, model choices, and paths inside `configs/config.yaml`.
+
+
+### 4. Train the Model
+
+Run the training pipeline:
+
+```bash
+python train.py --config configs/config.yaml
+```
+
+**Resuming Training**:
+To resume from an existing checkpoint, pass the `--resume` argument:
+```bash
+python train.py --config configs/config.yaml --resume checkpoints/checkpoint.pth
+```
+
+To load weights for a warm start (e.g., finetuning), use:
+```bash
+python train.py --config configs/config.yaml --init_weights weights/pretrained.pth
+```
+
+### 5. Inference
+
+You can run inference on a single image using the `src/infer.py` script. The script requires a serialized TorchScript model checkpoint.
+
+```bash
+# Basic inference
+python src/infer.py --image_path path/to/leaf.jpg --checkpoint checkpoints/best_model.pt --image_size 384
+
+# Inference with Test Time Augmentation (TTA)
+python src/infer.py --image_path path/to/leaf.jpg --checkpoint checkpoints/best_model.pt --image_size 384 --tta
+```
+
+> **Note**: The inference script expects a `data/label_map.json` file to map class indices to disease names.
+
+## Documentation
+
+### Model Selection
+By default, the pipeline uses `timm.create_model(...)`. You can specify any model architecture available in `timm` (e.g. `convnextv2_base`, `efficientnet_b0`, `eva02_base_patch14_448`) directly in the `config.yaml` file under `model.backbone`.
+
+### Configuration Details
+The pipeline uses `OmegaConf`. Hyperparameters such as `loss`, `optimizer`, and `augmentation` can be tweaked. For example, to enable layer-wise learning rate decay, adjust `optimizer.layer_decay` to a value `< 1.0`.
+
+### Logging & Checkpoints
+- Checkpoints are saved under the `checkpoints/` directory (customizable via `logging.checkpoint_dir`).
+- Best model checkpoints (current and EMA) are tracked based on the monitored validation metric.
+- When `logging.use_wandb` is true, the script initializes a Weights & Biases run, logging train/validation losses and selected metrics seamlessly.
+
+## Model Weights
+---
+
+The trained weights are hosted on Hugging Face 
+- 🔗 **[Download from Hugging Face Space Files](https://huggingface.co/spaces/)**
+
+
+## Technical Report
+A comprehensive report results is included in the repository.
+
+**[View Technical Report (PDF)]()**

api/main.py

@@ -0,0 +1,69 @@
+import io
+import json
+
+import torch
+from fastapi import FastAPI, File, HTTPException, UploadFile
+from fastapi.responses import RedirectResponse
+from PIL import Image
+
+from src.infer import predict_disease
+
+# Initialize FastAPI with metadata for Swagger
+app = FastAPI(
+    title="Plant Disease API",
+    description="An API to identify plant diseases from images.",
+    version="1.0.0",
+)
+
+# Detect device
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+# Load model and mapping globally
+try:
+    model = torch.jit.load("convnext_scripted.pt", map_location=device)
+    model.eval()
+
+    with open("data/label_map.json") as f:
+        label_map = json.load(f)
+    # Ensure keys are handled correctly (mapping string indices to names)
+    idx_to_disease = {int(v): k for k, v in label_map.items()}
+except Exception as e:
+    print(f"Error loading model or labels: {e}")
+    model = None
+
+
+@app.get("/", include_in_schema=False)
+async def root():
+    """Redirect users to the Swagger UI automatically."""
+    return RedirectResponse(url="/docs")
+
+
+@app.post("/predict", tags=["Inference"])
+async def predict(file: UploadFile = File(...)):
+    """
+    Upload an image of a plant leaf to identify potential diseases.
+    """
+    if not model:
+        raise HTTPException(status_code=500, detail="Model not loaded on server.")
+
+    if not file.content_type.startswith("image/"):
+        raise HTTPException(status_code=400, detail="File provided is not an image.")
+
+    try:
+        # 1. Read and Preprocess
+        img_bytes = await file.read()
+        image = Image.open(io.BytesIO(img_bytes)).convert("RGB")
+
+        # 2. Run Inference
+        disease_name = predict_disease(model, image, idx_to_disease, device=device)
+
+        return {"disease": disease_name}
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(app, host="0.0.0.0", port=7860)

configs/CNeXv2t.yaml

@@ -0,0 +1,60 @@
+experiment_name: "ConvNeXtv2_t"
+seed: 42
+
+data:
+  train_dir: "data/train"
+  val_dir: "data/val"
+  image_size: 384
+  batch_size: 16
+  num_workers: 2
+  pin_memory: true
+  weighted_sampling: false
+  max_weight: 5
+  
+model:
+  backbone: "convnextv2_tiny.fcmae_ft_in22k_in1k_384" # e.g. "tf_efficientnetv2_s"  "convnextv2_tiny.fcmae_ft_in22k_in1k_384"  eva02_base_patch14_224 
+  pretrained: true
+  freeze_backbone: false
+  freeze_bn: true
+  num_classes: null # Inferred automatically from dataset
+  dropout: 0.2
+  drop_path: 0.2
+
+loss:
+  name: "ce" # "focal" or "ce"
+  gamma: 2.0
+  alpha: 0.25
+  label_smoothing: 0.1
+
+optimizer:
+  name: "adamw"
+  backbone_lr: 3e-5 #dont matter if layer_decay 
+  head_lr: 3e-4 
+  weight_decay: 0.05
+  layer_decay: 0.9
+  
+scheduler:
+  name: "cosine_warmup" # "cosine", "step", "plateau"
+  warmup_epochs: 2
+  min_lr: 1e-6
+
+training:
+  epochs: 10
+  gradient_accumulation_steps: 4
+  mixed_precision: true
+  clip_grad_norm: 1.0
+  early_stopping_patience: 5
+  ema:
+    enabled: true
+    decay: 0.999
+    eval_mode: "current" # "current" or "ema"
+  
+augmentation:
+  mixup_alpha: 0.8
+  cutmix_alpha: 1.0
+  prob: 0.5 # Probability applied per batch
+
+logging:
+  use_wandb: true
+  project_name: "plant-disease-classification"
+  checkpoint_dir: "./checkpoints"

configs/EffNv2S_aug.yaml

@@ -0,0 +1,60 @@
+experiment_name: "EffNv2S_aug"
+seed: 42
+
+data:
+  train_dir: "data/train"
+  val_dir: "data/val"
+  image_size: 384
+  batch_size: 32
+  num_workers: 2
+  pin_memory: true
+  weighted_sampling: false
+  max_weight: 5
+  
+model:
+  backbone: "tf_efficientnetv2_s" # e.g. "tf_efficientnetv2_s"  "convnextv2_tiny.fcmae_ft_in22k_in1k_384"  eva02_base_patch14_224 
+  pretrained: true
+  freeze_backbone: false
+  freeze_bn: true
+  num_classes: null # Inferred automatically from dataset
+  dropout: 0.2
+  drop_path: 0.1
+
+loss:
+  name: "ce" # "focal" or "ce"
+  gamma: 2.0
+  alpha: 0.25
+  label_smoothing: 0.1
+
+optimizer:
+  name: "adamw"
+  backbone_lr: 3e-5 #dont matter if layer_decay 
+  head_lr: 3e-4 
+  weight_decay: 1e-2
+  layer_decay: 1.0
+  
+scheduler:
+  name: "cosine_warmup" # "cosine", "step", "plateau"
+  warmup_epochs: 3
+  min_lr: 1e-6
+
+training:
+  epochs: 15
+  gradient_accumulation_steps: 4
+  mixed_precision: true
+  clip_grad_norm: 1.0
+  early_stopping_patience: 5
+  ema:
+    enabled: true
+    decay: 0.999
+    eval_mode: "current" # "current" or "ema"
+  
+augmentation:
+  mixup_alpha: 0.8
+  cutmix_alpha: 1.0
+  prob: 0.5 # Probability applied per batch
+
+logging:
+  use_wandb: true
+  project_name: "plant-disease-classification"
+  checkpoint_dir: "./checkpoints"

configs/EffNv2S_baseline.yaml

@@ -0,0 +1,60 @@
+experiment_name: "EffNv2S_baseline"
+seed: 42
+
+data:
+  train_dir: "data/train"
+  val_dir: "data/val"
+  image_size: 384
+  batch_size: 32
+  num_workers: 2
+  pin_memory: true
+  weighted_sampling: false
+  max_weight: 5
+  
+model:
+  backbone: "tf_efficientnetv2_s" # e.g. "tf_efficientnetv2_s"  "convnextv2_tiny.fcmae_ft_in22k_in1k_384"  eva02_base_patch14_224 
+  pretrained: true
+  freeze_backbone: false
+  freeze_bn: true
+  num_classes: null # Inferred automatically from dataset
+  dropout: 0.2
+  drop_path: 0.1
+
+loss:
+  name: "ce" # "focal" or "ce"
+  gamma: 2.0
+  alpha: 0.25
+  label_smoothing: 0.1
+
+optimizer:
+  name: "adamw"
+  backbone_lr: 3e-5 #dont matter if layer_decay 
+  head_lr: 3e-4 
+  weight_decay: 1e-2
+  layer_decay: 1.0
+  
+scheduler:
+  name: "cosine_warmup" # "cosine", "step", "plateau"
+  warmup_epochs: 3
+  min_lr: 1e-6
+
+training:
+  epochs: 15
+  gradient_accumulation_steps: 4
+  mixed_precision: true
+  clip_grad_norm: 1.0
+  early_stopping_patience: 5
+  ema:
+    enabled: true
+    decay: 0.9995
+    eval_mode: "current" # "current" or "ema"
+  
+augmentation:
+  mixup_alpha: 0.2
+  cutmix_alpha: 0.5
+  prob: 0 # Probability applied per batch
+
+logging:
+  use_wandb: true
+  project_name: "plant-disease-classification"
+  checkpoint_dir: "./checkpoints"

configs/EffNv2S_head.yaml

@@ -0,0 +1,60 @@
+experiment_name: "EffNv2S_head"
+seed: 42
+
+data:
+  train_dir: "data/train"
+  val_dir: "data/val"
+  image_size: 384
+  batch_size: 64
+  num_workers: 2
+  pin_memory: true
+  weighted_sampling: false
+  max_weight: 5
+  
+model:
+  backbone: "tf_efficientnetv2_s" # e.g. "tf_efficientnetv2_s"  "convnextv2_tiny.fcmae_ft_in22k_in1k_384"  eva02_base_patch14_224 
+  pretrained: true
+  freeze_backbone: true
+  freeze_bn: true
+  num_classes: null # Inferred automatically from dataset
+  dropout: 0.2
+  drop_path: 0.1
+
+loss:
+  name: "ce" # "focal" or "ce"
+  gamma: 2.0
+  alpha: 0.25
+  label_smoothing: 0.1
+
+optimizer:
+  name: "adamw"
+  backbone_lr: 0 #dont matter if layer_decay 
+  head_lr: 5e-4 
+  weight_decay: 1e-2
+  layer_decay: 1.0
+  
+scheduler:
+  name: "step" # "cosine", "step", "plateau"
+  warmup_epochs: 0
+  min_lr: 0.0
+
+training:
+  epochs: 10
+  gradient_accumulation_steps: 1
+  mixed_precision: true
+  clip_grad_norm: 1.0
+  early_stopping_patience: 5
+  ema:
+    enabled: true
+    decay: 0.9995
+    eval_mode: "current" # "current" or "ema"
+  
+augmentation:
+  mixup_alpha: 0.2
+  cutmix_alpha: 0.5
+  prob: 0 # Probability applied per batch
+
+logging:
+  use_wandb: true
+  project_name: "plant-disease-classification"
+  checkpoint_dir: "./checkpoints"

configs/config.yaml

@@ -0,0 +1,52 @@
+experiment_name: dinov3_vit_small_plus_baseline
+seed: 42
+data:
+  train_dir: data/train
+  val_dir: data/val
+  image_size: 384
+  batch_size: 64
+  num_workers: 2
+  pin_memory: true
+  weighted_sampling: false
+  max_weight: 5
+model:
+  backbone: vit_small_plus_patch16_dinov3.lvd1689m
+  pretrained: true
+  freeze_backbone: false
+  freeze_bn: false
+  num_classes: null
+  dropout: 0.1
+  drop_path: 0.1
+loss:
+  name: ce
+  gamma: 2.0
+  alpha: 0.25
+  label_smoothing: 0.1
+optimizer:
+  name: adamw
+  backbone_lr: 2.0e-05
+  head_lr: 5e-4
+  weight_decay: 1e-4
+  layer_decay: 1.0
+scheduler:
+  name: cosine_warmup
+  warmup_epochs: 3
+  min_lr: 1e-6
+training:
+  epochs: 20
+  gradient_accumulation_steps: 2
+  mixed_precision: true
+  clip_grad_norm: 1.0
+  early_stopping_patience: 5
+  ema:
+    enabled: true
+    decay: 0.9994
+    eval_mode: current
+augmentation:
+  mixup_alpha: 0.8
+  cutmix_alpha: 1.0
+  prob: 0.5
+logging:
+  use_wandb: true
+  project_name: plant-disease-classification
+  checkpoint_dir: ./checkpoints

configs/dinov3vitS+.yaml

@@ -0,0 +1,60 @@
+experiment_name: "dinov3_vit_small_plus_baseline"
+seed: 42
+
+data:
+  train_dir: "data/train"
+  val_dir: "data/val"
+  image_size: 384
+  batch_size: 64
+  num_workers: 2
+  pin_memory: true
+  weighted_sampling: false
+  max_weight: 5
+  
+model:
+  backbone: "vit_small_plus_patch16_dinov3.lvd1689m" # e.g. "tf_efficientnetv2_s"  "convnextv2_tiny.fcmae_ft_in22k_in1k_384"  eva02_base_patch14_224 
+  pretrained: true
+  freeze_backbone: true
+  freeze_bn: false
+  num_classes: null # Inferred automatically from dataset
+  dropout: 0.1
+  drop_path: 0.1
+
+loss:
+  name: "ce" # "focal" or "ce"
+  gamma: 2.0
+  alpha: 0.25
+  label_smoothing: 0.1
+
+optimizer:
+  name: "adamw"
+  backbone_lr: 0 #dont matter if layer_decay 
+  head_lr: 5e-4 
+  weight_decay: 1e-4
+  layer_decay: 1.0
+  
+scheduler:
+  name: "cosine_warmup" # "cosine", "step", "plateau"
+  warmup_epochs: 3
+  min_lr: 1e-6
+
+training:
+  epochs: 15
+  gradient_accumulation_steps: 2
+  mixed_precision: true
+  clip_grad_norm: 1.0
+  early_stopping_patience: 5
+  ema:
+    enabled: true
+    decay: 0.9994
+    eval_mode: "current" # "current" or "ema"
+  
+augmentation:
+  mixup_alpha: 0.2
+  cutmix_alpha: 0.5
+  prob: 0 # Probability applied per batch
+
+logging:
+  use_wandb: true
+  project_name: "plant-disease-classification"
+  checkpoint_dir: "./checkpoints"

data/label_map.json

@@ -0,0 +1,41 @@
+{
+  "alternaria leaf spot": 0,
+  "angular leaf spot": 1,
+  "anthracnose": 2,
+  "bacterial leaf spot": 3,
+  "bacterial leaf streak (black chaff)": 4,
+  "bacterial wilt": 5,
+  "berry blotch": 6,
+  "black leaf streak": 7,
+  "black rot": 8,
+  "blossom end rot": 9,
+  "brown rot": 10,
+  "brown spot": 11,
+  "bunchy top": 12,
+  "canker": 13,
+  "downy mildew": 14,
+  "early blight": 15,
+  "frog eye leaf spot": 16,
+  "gray leaf spot": 17,
+  "greening disease": 18,
+  "head scab": 19,
+  "late blight": 20,
+  "leaf curl": 21,
+  "leaf mold": 22,
+  "leaf rust": 23,
+  "leaf spot": 24,
+  "loose smut": 25,
+  "mosaic": 26,
+  "mosaic virus": 27,
+  "northern leaf blight": 28,
+  "powdery mildew": 29,
+  "rust": 30,
+  "scab": 31,
+  "septoria blotch": 32,
+  "septoria leaf spot": 33,
+  "sheath blight": 34,
+  "smut": 35,
+  "stem rust": 36,
+  "stripe rust": 37,
+  "tar spot": 38
+}

requirements.txt

@@ -0,0 +1,9 @@
+torch>=2.0.0
+torchvision>=0.15.0
+timm>=0.9.0
+omegaconf>=2.3.0
+wandb>=0.15.0
+tqdm>=4.65.0
+torchmetrics>=1.0.0
+pillow>=9.0.0
+numpy

src/__init__.py

@@ -0,0 +1 @@
+# src module init

src/dataset.py

@@ -0,0 +1,251 @@
+import json
+from pathlib import Path
+
+import numpy as np
+import torch
+import torchvision.transforms.v2 as T
+from PIL import Image
+from torch.utils.data import DataLoader, Dataset, WeightedRandomSampler
+
+
+class PlantDiseaseDataset(Dataset):
+    def __init__(self, root_dir, label_map=None, transform=None):
+        """
+        Args:
+            root_dir (str): Path to the root directory of the split.
+            label_map (dict, optional): A dictionary mapping disease names to integers.
+                             Crucial for consistency across splits.
+            transform (callable, optional): PyTorch transforms.
+        """
+        self.root_dir = Path(root_dir)
+        self.transform = transform
+
+        self.image_paths = []
+        self.labels = []
+        self.plant_labels = []
+
+        self.plants = [
+            "apple",
+            "banana",
+            "bean",
+            "bell pepper",
+            "blueberry",
+            "basil",
+            "broccoli",
+            "cabbage",
+            "cauliflower",
+            "celery",
+            "cherry",
+            "citrus",
+            "coffee",
+            "corn",
+            "cucumber",
+            "garlic",
+            "ginger",
+            "grape",
+            "lettuce",
+            "maple",
+            "peach",
+            "plum",
+            "potato",
+            "raspberry",
+            "rice",
+            "soybean",
+            "squash",
+            "strawberry",
+            "tobacco",
+            "tomato",
+            "wheat",
+            "zucchini",
+        ]
+        self.plants.sort(key=len, reverse=True)
+
+        if not self.root_dir.exists():
+            return
+
+        if label_map is None:
+            self.disease_to_idx = self._build_label_map()
+        else:
+            self.disease_to_idx = label_map
+
+        for folder_name in sorted([d for d in self.root_dir.iterdir() if d.is_dir()]):
+            disease, plant = self._split_plant_disease(folder_name)
+
+            if disease not in self.disease_to_idx:
+                print(
+                    f"WARNING: Skipping '{folder_name.name}': Disease '{disease}' not found in label_map"
+                )
+                continue
+
+            disease_idx = self.disease_to_idx[disease]
+
+            for img_path in folder_name.glob("**/*"):
+                if img_path.is_file() and img_path.suffix.lower() in [
+                    ".jpg",
+                    ".jpeg",
+                    ".png",
+                    ".webp",
+                ]:
+                    self.image_paths.append(str(img_path))
+                    self.labels.append(disease_idx)
+                    self.plant_labels.append(plant)
+
+        self.classes = list(self.disease_to_idx.keys())
+
+    def _build_label_map(self):
+        all_diseases = set()
+
+        for folder in sorted([d for d in self.root_dir.iterdir() if d.is_dir()]):
+            folder_name = folder.name.lower()
+            for plant in self.plants:
+                if folder_name.startswith(plant):
+                    disease_name = folder_name[len(plant) :].strip()
+                    all_diseases.add(disease_name)
+                    break
+
+        return {disease: i for i, disease in enumerate(sorted(list(all_diseases)))}
+
+    def _split_plant_disease(self, folder):
+        for plant in self.plants:
+            folder_name = folder.name.lower()
+            if folder_name.startswith(plant):
+                disease = folder_name[len(plant) :].strip()
+                return disease, plant
+
+        return None, None
+
+    def __len__(self):
+        return len(self.image_paths)
+
+    def __getitem__(self, idx):
+        img_path = self.image_paths[idx]
+        label = self.labels[idx]
+
+        try:
+            image = Image.open(img_path).convert("RGB")
+        except Exception as e:
+            print(f"Error loading {img_path}: {e}")
+            return None, None
+
+        if self.transform:
+            image = self.transform(image)
+
+        return image, label
+
+
+def get_transforms(image_size=384, is_train=True):
+    if is_train:
+        return T.Compose(
+            [
+                T.RandomResizedCrop(image_size, scale=(0.7, 1.0), antialias=True),
+                T.RandomHorizontalFlip(),
+                T.TrivialAugmentWide(),
+                T.ToImage(),
+                T.ToDtype(torch.float32, scale=True),
+                T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+            ]
+        )
+    else:
+        return T.Compose(
+            [
+                T.Resize((image_size, image_size), antialias=True),
+                T.ToImage(),
+                T.ToDtype(torch.float32, scale=True),
+                T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+            ]
+        )
+
+
+def build_weighted_sampler(dataset, max_weight=10.0):
+    if not hasattr(dataset, "labels") or not hasattr(dataset, "plant_labels"):
+        raise ValueError("Dataset must have 'labels' and 'plant_labels'")
+
+    if len(dataset) == 0:
+        return None
+
+    disease = torch.tensor(dataset.labels, dtype=torch.long)
+    _, plant_indices = np.unique(dataset.plant_labels, return_inverse=True)
+    plant = torch.tensor(plant_indices, dtype=torch.long)
+
+    disease_counts = torch.bincount(disease)
+
+    pairs = torch.stack([disease, plant], dim=1)
+    _, group_id = torch.unique(pairs, return_inverse=True, dim=0)
+    group_counts = torch.bincount(group_id)
+
+    d_count = disease_counts[disease]
+    g_count = group_counts[group_id]
+
+    weights = 1.0 / torch.sqrt(d_count.float() * g_count.float())
+
+    if max_weight:
+        weights = torch.clamp(weights, max=max_weight)
+
+    return WeightedRandomSampler(
+        weights=weights,
+        num_samples=len(dataset),
+        replacement=True,
+    )
+
+
+def get_dataloaders(config):
+    train_dir = Path(config.data.train_dir)
+    val_dir = Path(config.data.val_dir)
+
+    train_dir.mkdir(parents=True, exist_ok=True)
+    val_dir.mkdir(parents=True, exist_ok=True)
+
+    # load existing if dont exist dataset wil build from training automatically
+    label_map_path = train_dir.parent / "label_map.json"
+    if label_map_path.exists():
+        with open(label_map_path) as f:
+            label_map = json.load(f)
+    else:
+        label_map = None
+
+    # create datasets with consistent label_map
+    train_dataset = PlantDiseaseDataset(
+        config.data.train_dir,
+        label_map=label_map,
+        transform=get_transforms(config.data.image_size, is_train=True),
+    )
+    val_dataset = PlantDiseaseDataset(
+        config.data.val_dir,
+        label_map=train_dataset.disease_to_idx,
+        transform=get_transforms(config.data.image_size, is_train=False),
+    )
+
+    # save label_map for future
+    with open(label_map_path, "w") as f:
+        json.dump(train_dataset.disease_to_idx, f, indent=2)
+
+    if len(train_dataset) == 0:
+        print("Warning: No train data found. Dataloader might fail.")
+
+    num_classes = len(train_dataset.classes) if len(train_dataset) > 0 else 0
+
+    train_sampler = None
+    if config.data.weighted_sampling:
+        train_sampler = build_weighted_sampler(
+            train_dataset, max_weight=config.data.max_weight
+        )
+
+    train_loader = DataLoader(
+        train_dataset,
+        batch_size=config.data.batch_size,
+        sampler=train_sampler,
+        shuffle=(train_sampler is None),
+        num_workers=config.data.num_workers,
+        pin_memory=config.data.pin_memory,
+        drop_last=True if len(train_dataset) > config.data.batch_size else False,
+    )
+
+    val_loader = DataLoader(
+        val_dataset,
+        batch_size=config.data.batch_size,
+        shuffle=False,
+        num_workers=config.data.num_workers,
+        pin_memory=config.data.pin_memory,
+    )
+
+    return train_loader, val_loader, num_classes

src/infer.py

@@ -0,0 +1,175 @@
+import argparse
+import io
+import json
+from pathlib import Path
+
+import numpy as np
+import torch
+import torchvision.transforms.v2 as T
+from PIL import Image
+from sklearn.metrics import accuracy_score, average_precision_score
+
+from dataset import get_transforms
+
+
+def get_tta_transforms(image_size):
+    return [
+        T.Compose(
+            [
+                T.Resize((image_size, image_size), antialias=True),
+                T.ToImage(),
+                T.ToDtype(torch.float32, scale=True),
+                T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+            ]
+        ),
+        T.Compose(
+            [
+                T.Resize((image_size, image_size), antialias=True),
+                T.RandomHorizontalFlip(p=1.0),
+                T.ToImage(),
+                T.ToDtype(torch.float32, scale=True),
+                T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+            ]
+        ),
+        T.Compose(
+            [
+                T.Resize(int(image_size * 1.1), antialias=True),
+                T.CenterCrop(image_size),
+                T.ToImage(),
+                T.ToDtype(torch.float32, scale=True),
+                T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+            ]
+        ),
+    ]
+
+
+def evaluate(model, val_loader, device=None, use_tta=False, image_size=384):
+    if device is None:
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    model = model.to(device)
+    model.eval()
+
+    if use_tta:
+        tta_transforms = get_tta_transforms(image_size)
+
+    all_probs = []
+    all_labels = []
+
+    with torch.inference_mode():
+        for images, labels in val_loader:
+            images = images.to(device)
+            labels = labels.to(device)
+
+            if use_tta:
+                tta_batches = []
+
+                for transform in tta_transforms:
+                    augmented = torch.stack([transform(img.cpu()) for img in images])
+                    tta_batches.append(augmented)
+
+                tta_batches = torch.stack(tta_batches).to(device)
+
+                outputs = []
+                for tta_batch in tta_batches:
+                    out = model(tta_batch)  # [batch, num_classes]
+                    outputs.append(out)
+
+                outputs = torch.stack(outputs).mean(dim=0)
+
+            else:
+                outputs = model(images)
+
+            probs = torch.softmax(outputs, dim=1)
+
+            all_probs.append(probs.cpu())
+            all_labels.append(labels.cpu())
+
+    all_probs = torch.cat(all_probs).numpy()
+    all_labels = torch.cat(all_labels).numpy()
+
+    preds = np.argmax(all_probs, axis=1)
+    acc = accuracy_score(all_labels, preds)
+
+    num_classes = all_probs.shape[1]
+    y_true_bin = np.zeros((len(all_labels), num_classes))
+    y_true_bin[np.arange(len(all_labels)), all_labels] = 1
+
+    per_class_ap = []
+    for i in range(num_classes):
+        if y_true_bin[:, i].sum() > 0:
+            ap = average_precision_score(y_true_bin[:, i], all_probs[:, i])
+            per_class_ap.append(ap)
+
+    mAP = np.mean(per_class_ap)
+
+    return acc, mAP, all_probs, all_labels
+
+
+def predict_disease(
+    model, image, idx_to_disease, image_size=384, use_tta=False, device=None
+):
+    if device is None:
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    model = model.to(device)
+    model.eval()
+
+    if use_tta:
+        transforms = get_tta_transforms(image_size)
+        tensors = [transform(image).unsqueeze(0) for transform in transforms]
+        batch = torch.cat(tensors, dim=0).to(device)
+
+        with torch.inference_mode():
+            outputs = model(batch)
+            output = outputs.mean(dim=0, keepdim=True)
+
+    else:
+        transform = get_transforms(image_size, is_train=False)
+        tensor = transform(image).unsqueeze(0).to(device)
+
+        with torch.inference_mode():
+            output = model(tensor)
+
+    probs = output.softmax(dim=1)
+    disease_name = idx_to_disease[probs.argmax(dim=1).item()]
+
+    return disease_name
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Run inference on a plant disease image"
+    )
+    parser.add_argument("--image_path", type=str, help="Path to input image")
+    parser.add_argument(
+        "--image_size", type=str, default=384, help="Size of input image"
+    )
+    parser.add_argument(
+        "--checkpoint", type=str, default=None, help="Path to checkpoint "
+    )
+    parser.add_argument("--tta", action="store_true", help="Use test time augmentation")
+    args = parser.parse_args()
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    model = torch.jit.load(args.checkpoint).to(device)
+    model.eval()
+    print(args.tta)
+    # load label map
+    data_dir = Path("data")
+    label_map_path = data_dir / "label_map.json"
+    with open(label_map_path) as f:
+        label_map = json.load(f)
+    idx_to_disease = {int(v): k for k, v in label_map.items()}
+
+    image = Image.open(args.image_path).convert("RGB")
+
+    result = predict_disease(
+        model,
+        image,
+        image_size=args.image_size,
+        idx_to_disease=idx_to_disease,
+        use_tta=args.tta,
+    )
+    print(f"Disease: {result}")

src/loss.py

@@ -0,0 +1,52 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from timm.loss import SoftTargetCrossEntropy
+
+
+class FocalLoss(nn.Module):
+    def __init__(self, alpha=0.25, gamma=2.0, reduction="mean", label_smoothing=0.0):
+        super().__init__()
+        self.alpha = alpha
+        self.gamma = gamma
+        self.reduction = reduction
+        self.label_smoothing = label_smoothing
+
+    def forward(self, inputs, targets):
+        """
+        inputs: logits [B, C]
+        targets: labels [B] or soft mixup labels [B, C]
+        """
+        if targets.ndim == inputs.ndim:
+            # targets are soft labels from MixUp/CutMix
+            ce_loss = F.cross_entropy(
+                inputs, targets, reduction="none", label_smoothing=self.label_smoothing
+            )
+            # for focal weighting when using mixup, pt is e^(-ce_loss)
+            pt = torch.exp(-ce_loss)
+        else:
+            ce_loss = F.cross_entropy(
+                inputs, targets, reduction="none", label_smoothing=self.label_smoothing
+            )
+            pt = torch.exp(-ce_loss)
+
+        focal_loss = self.alpha * (1 - pt) ** self.gamma * ce_loss
+
+        if self.reduction == "mean":
+            return focal_loss.mean()
+        elif self.reduction == "sum":
+            return focal_loss.sum()
+        return focal_loss
+
+
+def get_criterion(config):
+    if config.loss.name == "focal":
+        return FocalLoss(
+            gamma=config.loss.gamma,
+            alpha=config.loss.alpha,
+            label_smoothing=config.loss.label_smoothing,
+        )
+    else:
+        if config.augmentation.prob > 0:
+            return SoftTargetCrossEntropy()
+        return nn.CrossEntropyLoss(label_smoothing=config.loss.label_smoothing)

src/metrics.py

@@ -0,0 +1,43 @@
+import torch
+from torchmetrics.classification import MulticlassAccuracy, MulticlassAveragePrecision
+
+
+class MetricTracker:
+    def __init__(self, num_classes, device):
+        self.num_classes = num_classes
+        self.device = device
+
+        self.map_metric = MulticlassAveragePrecision(num_classes=num_classes).to(device)
+        self.acc_metric = MulticlassAccuracy(num_classes=num_classes).to(device)
+
+        self.reset()
+
+    def reset(self):
+        self.map_metric.reset()
+        self.acc_metric.reset()
+        self.loss_sum = 0
+        self.count = 0
+
+    def update(self, preds, targets, loss=None, skip_metrics=False):
+        """
+        preds: logits [B, C]
+        targets: [B] or soft labels [B, C]
+        skip_metrics: If True, only loss is tracked. Use for MixUp/CutMix batches.
+        """
+        if targets.ndim > 1:
+            hard_targets = targets.argmax(dim=1)
+        else:
+            hard_targets = targets
+        if not skip_metrics:
+            self.map_metric.update(preds, hard_targets)
+            self.acc_metric.update(preds, hard_targets)
+
+        if loss is not None:
+            self.loss_sum += loss * preds.size(0)
+            self.count += preds.size(0)
+
+    def compute(self):
+        mAP = self.map_metric.compute().item()
+        acc = self.acc_metric.compute().item()
+        avg_loss = self.loss_sum / max(self.count, 1)
+        return {"mAP": mAP, "accuracy": acc, "loss": avg_loss}

src/models.py

@@ -0,0 +1,72 @@
+import timm
+import torch
+import torch.nn as nn
+
+
+class PlantDiseaseModel(nn.Module):
+    def __init__(self, config, num_classes):
+        super().__init__()
+        self.backbone_name = config.model.backbone
+
+        self.model = timm.create_model(
+            self.backbone_name,
+            pretrained=config.model.pretrained,
+            num_classes=num_classes,
+            drop_rate=config.model.dropout,
+            drop_path_rate=config.model.drop_path,
+        )
+
+        if config.model.freeze_backbone:
+            self._freeze_backbone()
+        if config.model.freeze_bn:
+            self.freeze_bn()
+
+    def _freeze_backbone(self):
+        for param in self.model.parameters():
+            param.requires_grad = False
+
+        if hasattr(self.model, "get_classifier"):
+            classifier = self.model.get_classifier()
+            for param in classifier.parameters():
+                param.requires_grad = True
+        else:
+            for name, param in self.model.named_parameters():
+                if "head" in name or "classifier" in name:
+                    param.requires_grad = True
+
+    def freeze_bn(self):
+        for module in self.model.modules():
+            if isinstance(module, (nn.BatchNorm1d, nn.BatchNorm2d, nn.BatchNorm3d)):
+                module.eval()
+
+                if module.weight is not None:
+                    module.weight.requires_grad = False
+                if module.bias is not None:
+                    module.bias.requires_grad = False
+
+    def forward(self, x):
+        return self.model(x)
+
+
+def get_param_groups(model, base_lr, head_lr, weight_decay):
+    if hasattr(model.model, "get_classifier"):
+        head = model.model.get_classifier()
+        head_params = list(head.parameters())
+        head_param_ids = set(id(p) for p in head_params)
+    else:
+        # fallback
+        head_params = []
+        for name, p in model.named_parameters():
+            if any(k in name for k in ["head", "classifier"]):
+                head_params.append(p)
+        head_param_ids = set(id(p) for p in head_params)
+
+    head_params = [p for p in head_params if p.requires_grad]
+
+    backbone_params = [
+        p for p in model.parameters() if id(p) not in head_param_ids and p.requires_grad
+    ]
+    return [
+        {"params": backbone_params, "lr": base_lr, "weight_decay": weight_decay},
+        {"params": head_params, "lr": head_lr, "weight_decay": weight_decay},
+    ]

src/trainer.py

@@ -0,0 +1,312 @@
+import torch
+import wandb
+from omegaconf import OmegaConf
+from timm.utils import ModelEmaV2
+from torch import nn
+from torch.amp import GradScaler, autocast
+from torchvision.transforms import v2
+from tqdm import tqdm
+
+from .metrics import MetricTracker
+from .utils import EarlyStopping, save_checkpoint
+
+
+class Trainer:
+    def __init__(
+        self,
+        model,
+        train_loader,
+        val_loader,
+        criterion,
+        optimizer,
+        scheduler,
+        config,
+        device,
+    ):
+        self.model = model
+        self.train_loader = train_loader
+        self.val_loader = val_loader
+        self.criterion = criterion
+        self.optimizer = optimizer
+        self.scheduler = scheduler
+        self.config = config
+        self.device = device
+
+        self.early_stopping = EarlyStopping(
+            patience=config.training.early_stopping_patience, mode="max"
+        )
+
+        self.scaler = GradScaler(device.type, enabled=config.training.mixed_precision)
+
+        self.use_ema = (
+            getattr(config.training, "ema", None) and config.training.ema.enabled
+        )
+        if self.use_ema:
+            ema_decay = getattr(config.training.ema, "decay", 0.9999)
+            self.model_ema = ModelEmaV2(self.model, decay=ema_decay, device=device)
+        else:
+            self.model_ema = None
+
+        self.num_classes = config.model.num_classes
+
+        self.use_mixup = False
+        if config.augmentation.prob > 0:
+            self.use_mixup = True
+            cutmix = v2.CutMix(
+                alpha=config.augmentation.cutmix_alpha, num_classes=self.num_classes
+            )
+            mixup = v2.MixUp(
+                alpha=config.augmentation.mixup_alpha, num_classes=self.num_classes
+            )
+            self.cutmix_or_mixup = v2.RandomChoice([cutmix, mixup])
+
+        self.train_metrics = MetricTracker(num_classes=self.num_classes, device=device)
+        self.val_metrics = MetricTracker(num_classes=self.num_classes, device=device)
+        if self.use_ema:
+            self.val_ema_metrics = MetricTracker(
+                num_classes=self.num_classes, device=device
+            )
+
+    def train_one_epoch(self, epoch):
+        self.model.train()
+        if self.config.model.freeze_bn:
+            for module in self.model.modules():
+                if isinstance(module, (nn.BatchNorm1d, nn.BatchNorm2d, nn.BatchNorm3d)):
+                    module.eval()
+
+        self.train_metrics.reset()
+
+        pbar = tqdm(self.train_loader, desc=f"Epoch {epoch} [Train]")
+        for batch_idx, (images, targets) in enumerate(pbar):
+            images, targets = images.to(self.device), targets.to(self.device)
+            is_mixed = False
+
+            # apply MixUp or CutMix
+            if self.use_mixup and torch.rand(1).item() < self.config.augmentation.prob:
+                images, targets = self.cutmix_or_mixup(images, targets)
+                is_mixed = True
+            if targets.ndim == 1:
+                targets = torch.nn.functional.one_hot(
+                    targets, num_classes=self.num_classes
+                ).float()
+            with autocast(
+                device_type=self.device.type,
+                enabled=self.config.training.mixed_precision,
+            ):
+                outputs = self.model(images)
+                loss = self.criterion(outputs, targets)
+                # gradient accumulation normalizer
+                loss = loss / self.config.training.gradient_accumulation_steps
+
+            self.scaler.scale(loss).backward()
+
+            if (batch_idx + 1) % self.config.training.gradient_accumulation_steps == 0:
+                if self.config.training.clip_grad_norm > 0:
+                    self.scaler.unscale_(self.optimizer)
+                    torch.nn.utils.clip_grad_norm_(
+                        self.model.parameters(), self.config.training.clip_grad_norm
+                    )
+
+                self.scaler.step(self.optimizer)
+                self.scaler.update()
+                self.optimizer.zero_grad()
+
+                if self.config.scheduler.name == "cosine_warmup":
+                    self.scheduler.step()
+
+                if self.use_ema:
+                    self.model_ema.update(self.model)
+
+            batch_loss = loss.item() * self.config.training.gradient_accumulation_steps
+            self.train_metrics.update(
+                outputs.detach(),
+                targets.detach(),
+                loss=batch_loss,
+                skip_metrics=is_mixed,
+            )
+
+            pbar.set_postfix({"loss": f"{batch_loss:.4f}"})
+
+            if self.config.logging.use_wandb:
+                wandb.log({"train/batch_loss": batch_loss})
+
+        if (batch_idx + 1) % self.config.training.gradient_accumulation_steps != 0:
+            if self.config.training.clip_grad_norm > 0:
+                self.scaler.unscale_(self.optimizer)
+                torch.nn.utils.clip_grad_norm_(
+                    self.model.parameters(), self.config.training.clip_grad_norm
+                )
+
+            self.scaler.step(self.optimizer)
+            self.scaler.update()
+            self.optimizer.zero_grad()
+
+            if self.config.scheduler.name == "cosine_warmup":
+                self.scheduler.step()
+
+            if self.use_ema:
+                self.model_ema.update(self.model)
+
+        metrics = self.train_metrics.compute()
+
+        # Step schedulers that step per epoch
+        if self.config.scheduler.name == "step":
+            self.scheduler.step()
+        elif self.config.scheduler.name == "cosine":
+            self.scheduler.step()
+
+        return metrics
+
+    def validate(self, epoch):
+        self.model.eval()
+        self.val_metrics.reset()
+
+        if self.use_ema:
+            self.model_ema.module.eval()
+            self.val_ema_metrics.reset()
+
+        pbar = tqdm(self.val_loader, desc=f"Epoch {epoch} [Val]")
+        with torch.no_grad():
+            for images, targets in pbar:
+                images, targets = images.to(self.device), targets.to(self.device)
+
+                if targets.ndim == 1:
+                    targets = torch.nn.functional.one_hot(
+                        targets, num_classes=self.num_classes
+                    ).float()
+
+                with autocast(
+                    device_type=self.device.type,
+                    enabled=self.config.training.mixed_precision,
+                ):
+                    outputs = self.model(images)
+                    loss = self.criterion(outputs, targets)
+
+                    if self.use_ema:
+                        ema_outputs = self.model_ema.module(images)
+                        ema_loss = self.criterion(ema_outputs, targets)
+
+                self.val_metrics.update(
+                    outputs.detach(), targets.detach(), loss=loss.detach()
+                )
+                if self.use_ema:
+                    self.val_ema_metrics.update(
+                        ema_outputs.detach(), targets.detach(), loss=ema_loss.detach()
+                    )
+                    pbar.set_postfix(
+                        {
+                            "loss": f"{loss.item():.4f}",
+                            "ema_loss": f"{ema_loss.item():.4f}",
+                        }
+                    )
+                else:
+                    pbar.set_postfix({"loss": f"{loss.item():.4f}"})
+
+        metrics = {"current": self.val_metrics.compute()}
+        if self.use_ema:
+            metrics["ema"] = self.val_ema_metrics.compute()
+
+        primary_map = metrics[self.config.training.ema.eval_mode]["mAP"]
+
+        if self.config.scheduler.name == "plateau":
+            self.scheduler.step(primary_map)
+
+        return metrics
+
+    def fit(self, start_epoch=1):
+        best_map = 0.0
+
+        for epoch in range(start_epoch, self.config.training.epochs + 1):
+            train_metrics = self.train_one_epoch(epoch)
+            val_metrics = self.validate(epoch)
+
+            lrs = [pg["lr"] for pg in self.optimizer.param_groups]
+
+            log_dict = {
+                "train/loss": train_metrics["loss"],
+                "train/mAP": train_metrics["mAP"],
+                "train/accuracy": train_metrics["accuracy"],
+                "lr/backbone": lrs[0],
+                "lr/head": lrs[1],
+                "epoch": epoch,
+            }
+
+            if self.use_ema:
+                log_dict.update(
+                    {
+                        "val/loss": val_metrics["current"]["loss"],
+                        "val/mAP": val_metrics["current"]["mAP"],
+                        "val/accuracy": val_metrics["current"]["accuracy"],
+                        "val/ema_loss": val_metrics["ema"]["loss"],
+                        "val/ema_mAP": val_metrics["ema"]["mAP"],
+                        "val/ema_accuracy": val_metrics["ema"]["accuracy"],
+                    }
+                )
+            else:
+                log_dict.update(
+                    {
+                        "val/loss": val_metrics["current"]["loss"],
+                        "val/mAP": val_metrics["current"]["mAP"],
+                        "val/accuracy": val_metrics["current"]["accuracy"],
+                    }
+                )
+
+            if self.config.logging.use_wandb:
+                wandb.log(log_dict)
+
+            print(f"\nEpoch {epoch} Summary:")
+            print(f"LR: Backbone: {lrs[0]:.2e} | Head: {lrs[1]:.2e}")
+            print(
+                f"Train - Loss: {train_metrics['loss']:.4f}, mAP: {train_metrics['mAP']:.4f}, Acc: {train_metrics['accuracy']:.4f}"
+            )
+            if self.use_ema:
+                print(
+                    f"Val (Current) - Loss: {val_metrics['current']['loss']:.4f}, mAP: {val_metrics['current']['mAP']:.4f}, Acc: {val_metrics['current']['accuracy']:.4f}"
+                )
+                print(
+                    f"Val (EMA)     - Loss: {val_metrics['ema']['loss']:.4f}, mAP: {val_metrics['ema']['mAP']:.4f}, Acc: {val_metrics['ema']['accuracy']:.4f}"
+                )
+            else:
+                print(
+                    f"Val   - Loss: {val_metrics['current']['loss']:.4f}, mAP: {val_metrics['current']['mAP']:.4f}, Acc: {val_metrics['current']['accuracy']:.4f}"
+                )
+
+            primary_map = val_metrics[self.config.training.ema.eval_mode]["mAP"]
+            is_best = self.early_stopping(primary_map)
+
+            if is_best:
+                best_map = primary_map
+                print(f"Epoch {epoch} is the new best model. mAP: {best_map:.4f}")
+
+            # Checkpointing
+            state = {
+                "epoch": epoch,
+                "state_dict": self.model.state_dict(),
+                "state_dict_ema": self.model_ema.module.state_dict()
+                if self.use_ema
+                else None,
+                "optimizer": self.optimizer.state_dict(),
+                "scheduler": self.scheduler.state_dict() if self.scheduler else None,
+                "scaler": self.scaler.state_dict(),
+                "early_stopping": {
+                    "best_score": self.early_stopping.best_score,
+                    "counter": self.early_stopping.counter,
+                    "early_stop": self.early_stopping.early_stop,
+                },
+                "rng_states": {
+                    "torch": torch.get_rng_state(),
+                    "cuda": torch.cuda.get_rng_state_all()
+                    if torch.cuda.is_available()
+                    else None,
+                },
+                "val_mAP": primary_map,
+                "config": OmegaConf.to_yaml(self.config),
+                "wandb_run_id": wandb.run.id if wandb.run is not None else None,
+            }
+            save_checkpoint(state, is_best, self.config.logging.checkpoint_dir)
+
+            if self.early_stopping.early_stop:
+                print(f"Early stopping triggered at epoch {epoch}")
+                break
+
+        print("Training complete!")

src/utils.py

@@ -0,0 +1,120 @@
+import math
+import os
+import random
+import shutil
+from pathlib import Path
+
+import numpy as np
+import torch
+from omegaconf import OmegaConf
+from PIL import Image
+
+
+class EarlyStopping:
+    def __init__(self, patience=7, mode="max"):
+        self.patience = patience
+        self.mode = mode
+        self.counter = 0
+        self.best_score = None
+        self.early_stop = False
+
+    def __call__(self, metric_value):
+        score = -metric_value if self.mode == "min" else metric_value
+
+        if self.best_score is None:
+            self.best_score = score
+            return True
+        elif score < self.best_score:
+            self.counter += 1
+            if self.counter >= self.patience:
+                self.early_stop = True
+            return False
+        else:
+            self.best_score = score
+            self.counter = 0
+            return True
+
+
+class CosineAnnealingWarmupLR(torch.optim.lr_scheduler._LRScheduler):
+    def __init__(self, optimizer, warmup_steps, total_steps, min_lr=0, last_epoch=-1):
+        self.warmup_steps = warmup_steps
+        self.total_steps = total_steps
+        self.min_lr = min_lr
+
+        self.min_lr_ratios = []
+        for group in optimizer.param_groups:
+            ratio = min_lr / max(group["lr"], 1e-12)
+            self.min_lr_ratios.append(ratio)
+
+        super().__init__(optimizer, last_epoch)
+
+    def get_lr(self):
+        curr_step = self.last_epoch
+
+        # linear warmup phase
+        if curr_step < self.warmup_steps:
+            scale = curr_step / max(1, self.warmup_steps)
+            return [base_lr * scale for base_lr in self.base_lrs]
+
+        # cosine annealing phase
+        progress = (curr_step - self.warmup_steps) / max(
+            1, self.total_steps - self.warmup_steps
+        )
+        progress = min(1.0, max(0.0, progress))
+        cosine = 0.5 * (1 + math.cos(math.pi * progress))
+
+        return [
+            base_lr * (ratio + (1 - ratio) * cosine)
+            for base_lr, ratio in zip(self.base_lrs, self.min_lr_ratios)
+        ]
+
+
+def set_seed(seed=42, deterministic=False):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    if deterministic:
+        torch.backends.cudnn.deterministic = True
+        torch.backends.cudnn.benchmark = False
+
+
+def load_config(config_path):
+    return OmegaConf.load(config_path)
+
+
+def save_checkpoint(state, is_best, checkpoint_dir, filename="last.pt"):
+    os.makedirs(checkpoint_dir, exist_ok=True)
+    epoch = state["epoch"]
+    filename = f"checkpoint_epoch_{epoch}.pt"
+    filepath = os.path.join(checkpoint_dir, filename)
+    torch.save(state, filepath)
+
+    last_path = os.path.join(checkpoint_dir, "last.pt")
+    shutil.copyfile(filepath, last_path)
+
+    if is_best:
+        best_path = os.path.join(checkpoint_dir, "best.pt")
+        shutil.copyfile(filepath, best_path)
+
+
+def check_dataset(data_dir):
+    data_path = Path(data_dir)
+    corrupt_files = []
+
+    print(f"Checking images in {data_dir}...")
+
+    for img_path in data_path.glob("**/*"):
+        if img_path.suffix.lower() in [".jpg", ".jpeg", ".png", ".webp"]:
+            try:
+                with Image.open(img_path) as img:
+                    img.verify()
+
+            except Exception as e:
+                print(f"CORRUPT: {img_path} | Error: {e}")
+                corrupt_files.append(img_path)
+
+    if corrupt_files:
+        print(f"\nFound {len(corrupt_files)} corrupted files.")
+    else:
+        print("Dataset is clean")

train.py

@@ -0,0 +1,192 @@
+import argparse
+import math
+import os
+
+import torch
+import wandb
+from omegaconf import OmegaConf
+from timm.optim import create_optimizer_v2
+from torch.optim.lr_scheduler import CosineAnnealingLR, ReduceLROnPlateau, StepLR
+
+from src.dataset import get_dataloaders
+from src.loss import get_criterion
+from src.models import PlantDiseaseModel, get_param_groups
+from src.trainer import Trainer
+from src.utils import CosineAnnealingWarmupLR, load_config, set_seed
+
+
+def build_optimizer(model, config):
+    layer_decay = getattr(config.optimizer, "layer_decay", 1.0)
+    param_groups = get_param_groups(
+        model,
+        base_lr=config.optimizer.backbone_lr,
+        head_lr=config.optimizer.head_lr,
+        weight_decay=config.optimizer.weight_decay,
+    )
+
+    if config.optimizer.name.lower() == "adamw":
+        if layer_decay == 1:
+            optimizer = torch.optim.AdamW(param_groups)
+        else:
+            optimizer = create_optimizer_v2(
+                model,
+                opt="adamw",
+                lr=config.optimizer.head_lr,
+                layer_decay=layer_decay,
+                weight_decay=config.optimizer.weight_decay,
+            )
+    else:
+        optimizer = torch.optim.Adam(param_groups)
+
+    return optimizer
+
+
+def build_scheduler(optimizer, config, len_loader):
+    if config.scheduler.name.lower() == "cosine":
+        return CosineAnnealingLR(
+            optimizer, T_max=config.training.epochs, eta_min=config.scheduler.min_lr
+        )
+    elif config.scheduler.name.lower() == "step":
+        return StepLR(optimizer, step_size=3, gamma=0.1)
+    elif config.scheduler.name.lower() == "plateau":
+        return ReduceLROnPlateau(
+            optimizer,
+            mode="max",
+            factor=0.1,
+            patience=3,
+            min_lr=config.scheduler.min_lr,
+        )
+    elif config.scheduler.name.lower() == "cosine_warmup":
+        return CosineAnnealingWarmupLR(
+            optimizer,
+            warmup_steps=config.scheduler.warmup_epochs
+            * len_loader
+            / config.training.gradient_accumulation_steps,
+            total_steps=config.training.epochs
+            * len_loader
+            / config.training.gradient_accumulation_steps,
+            min_lr=config.scheduler.min_lr,
+        )
+    else:
+        return None
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Train Plant Disease Classification Baseline"
+    )
+    parser.add_argument(
+        "--config", type=str, default="configs/config.yaml", help="Path to config file"
+    )
+    parser.add_argument(
+        "--resume", type=str, default=None, help="Path to checkpoint to resume from"
+    )
+    parser.add_argument(
+        "--init_weights", type=str, default=None, help="Path to weights for warm start"
+    )
+    args = parser.parse_args()
+
+    config = load_config(args.config)
+
+    set_seed(config.seed, deterministic=True)
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"Environment: Using device {device}")
+
+    train_loader, val_loader, num_classes = get_dataloaders(config)
+
+    if num_classes == 0:
+        print(
+            "WARNING: No data found. Make sure your datasets are correctly structured."
+        )
+        # Fallback to prevent immediate crash if no data is present yet
+        num_classes = 1
+
+    config.model.num_classes = num_classes
+
+    model = PlantDiseaseModel(config, num_classes=num_classes)
+    model.to(device)
+
+    if args.init_weights and os.path.exists(args.init_weights):
+        print(f"Warm starting from weights: {args.init_weights}")
+        checkpoint = torch.load(args.init_weights, map_location=device)
+        state_dict = checkpoint.get("state_dict", checkpoint)
+        model.load_state_dict(state_dict)
+
+    optimizer = build_optimizer(model, config)
+    criterion = get_criterion(config)
+    scheduler = build_scheduler(optimizer, config, len(train_loader))
+
+    # resume Logic
+    start_epoch = 1
+    checkpoint = None
+    run_id = None
+    if args.resume and os.path.exists(args.resume):
+        print(f"Resuming experiment from checkpoint: {args.resume}")
+        checkpoint = torch.load(args.resume, map_location=device)
+        model.load_state_dict(checkpoint["state_dict"])
+        optimizer.load_state_dict(checkpoint["optimizer"])
+        if scheduler and checkpoint["scheduler"]:
+            scheduler.load_state_dict(checkpoint["scheduler"])
+        start_epoch = checkpoint["epoch"] + 1
+
+        if "rng_states" in checkpoint:
+            torch.set_rng_state(checkpoint["rng_states"]["torch"].cpu())
+            if device.type == "cuda" and checkpoint["rng_states"]["cuda"] is not None:
+                torch.cuda.set_rng_state_all(
+                    [s.cpu() for s in checkpoint["rng_states"]["cuda"]]
+                )
+
+        if config.logging.use_wandb:
+            run_id = checkpoint.get("wandb_run_id")
+
+        if start_epoch > config.training.epochs:
+            print(
+                f"Requested to resume at epoch {start_epoch}, but total epochs is {config.training.epochs}. Exiting."
+            )
+            return
+
+    # Wandb tracking
+    if config.logging.use_wandb:
+        wandb_config = OmegaConf.to_container(config, resolve=True)
+        wandb.init(
+            project=config.logging.project_name,
+            name=config.experiment_name,
+            config=wandb_config,
+            id=run_id,  # Use the loaded ID (or None if brand new)
+            resume="allow",
+        )
+
+    trainer = Trainer(
+        model=model,
+        train_loader=train_loader,
+        val_loader=val_loader,
+        criterion=criterion,
+        optimizer=optimizer,
+        scheduler=scheduler,
+        config=config,
+        device=device,
+    )
+
+    if checkpoint is not None:
+        if trainer.use_ema and checkpoint.get("state_dict_ema"):
+            trainer.model_ema.module.load_state_dict(checkpoint["state_dict_ema"])
+
+    if args.resume and os.path.exists(args.resume):
+        if checkpoint["scaler"]:
+            trainer.scaler.load_state_dict(checkpoint["scaler"])
+
+        if checkpoint["early_stopping"]:
+            trainer.early_stopping.best_score = checkpoint["early_stopping"][
+                "best_score"
+            ]
+            trainer.early_stopping.counter = checkpoint["early_stopping"]["counter"]
+            trainer.early_stopping.early_stop = checkpoint["early_stopping"][
+                "early_stop"
+            ]
+
+    trainer.fit()
+
+
+if __name__ == "__main__":
+    main()

wandb/run-20260419_175057-4kiikgrp/files/config.yaml

@@ -0,0 +1,115 @@
+_wandb:
+    value:
+        cli_version: 0.25.1
+        e:
+            5r5nghwc1gn8jkabzqczvjhk7aa94c6x:
+                codePath: train.py
+                codePathLocal: train.py
+                cpu_count: 2
+                cpu_count_logical: 4
+                disk:
+                    /:
+                        total: "254356226048"
+                        used: "139972616192"
+                email: coretwoduo75@gmail.com
+                executable: /home/union_point/miniconda3/bin/python
+                host: laptop
+                memory:
+                    total: "7760048128"
+                os: Linux-6.19.11-200.fc43.x86_64-x86_64-with-glibc2.42
+                program: /home/union_point/ml/Plant-Disease-Classification/train.py
+                python: CPython 3.13.2
+                root: /home/union_point/ml/Plant-Disease-Classification
+                startedAt: "2026-04-19T13:50:57.074183Z"
+                writerId: 5r5nghwc1gn8jkabzqczvjhk7aa94c6x
+        m: []
+        python_version: 3.13.2
+        t:
+            "1":
+                - 1
+                - 5
+                - 11
+                - 41
+                - 49
+                - 53
+                - 63
+                - 71
+            "2":
+                - 1
+                - 5
+                - 11
+                - 41
+                - 49
+                - 53
+                - 63
+                - 71
+            "3":
+                - 13
+                - 16
+            "4": 3.13.2
+            "5": 0.25.1
+            "6": 5.3.0
+            "12": 0.25.1
+            "13": linux-x86_64
+augmentation:
+    value:
+        cutmix_alpha: 0.5
+        mixup_alpha: 0.2
+        prob: 0
+data:
+    value:
+        batch_size: 64
+        image_size: 384
+        max_weight: 5
+        num_workers: 2
+        pin_memory: true
+        train_dir: data/train
+        val_dir: data/val
+        weighted_sampling: false
+experiment_name:
+    value: dinov3_vit_small_plus_baseline
+logging:
+    value:
+        checkpoint_dir: ./checkpoints
+        project_name: plant-disease-classification
+        use_wandb: true
+loss:
+    value:
+        alpha: 0.25
+        gamma: 2
+        label_smoothing: 0.1
+        name: ce
+model:
+    value:
+        backbone: vit_small_plus_patch16_dinov3.lvd1689m
+        drop_path: 0.1
+        dropout: 0.1
+        freeze_backbone: true
+        freeze_bn: false
+        num_classes: 39
+        pretrained: true
+optimizer:
+    value:
+        backbone_lr: 0
+        head_lr: 0.0005
+        layer_decay: 1
+        name: adamw
+        weight_decay: 0.0001
+scheduler:
+    value:
+        min_lr: 1e-06
+        name: cosine_warmup
+        warmup_epochs: 3
+seed:
+    value: 42
+training:
+    value:
+        clip_grad_norm: 1
+        early_stopping_patience: 5
+        ema:
+            decay: 0.999
+            enabled: true
+            eval_mode: current
+        epochs: 15
+        gradient_accumulation_steps: 2
+        mixed_precision: true

wandb/run-20260419_175057-4kiikgrp/files/requirements.txt

@@ -0,0 +1,317 @@
+wcwidth==0.2.13
+pure_eval==0.2.3
+traitlets==5.14.3
+tornado==6.4.2
+pyzmq==26.2.1
+psutil==7.0.0
+prompt_toolkit==3.0.50
+parso==0.8.4
+nest-asyncio==1.6.0
+ipython_pygments_lexers==1.1.1
+executing==2.2.0
+decorator==5.2.1
+debugpy==1.8.13
+asttokens==3.0.0
+stack-data==0.6.3
+matplotlib-inline==0.1.7
+jupyter_core==5.7.2
+jedi==0.19.2
+comm==0.2.2
+jupyter_client==8.6.3
+ipython==9.0.2
+ipykernel==6.29.5
+mdit-py-plugins==0.4.2
+jupytext==1.16.7
+threadpoolctl==3.6.0
+pydotplus==2.0.2
+seaborn==0.13.2
+patsy==1.0.1
+statsmodels==0.14.4
+category_encoders==2.8.1
+cvxopt==1.3.2
+mpmath==1.3.0
+sympy==1.13.3
+networkx==3.3
+torchvision==0.22.0+cpu
+graphviz==0.20.3
+torchviz==0.0.3
+tqdm==4.67.1
+lightning-utilities==0.14.3
+torchmetrics==1.7.1
+nltk==3.9.1
+imageio==2.37.0
+tifffile==2025.5.10
+lazy_loader==0.4
+scikit-image==0.25.2
+pypickle==1.1.5
+datazets==1.1.2
+colourmap==1.1.21
+scatterd==1.3.9
+clusteval==2.2.5
+bcubed==1.5
+bcubed-metrics==1.0.1
+pytorch-lightning==2.5.1.post0
+lightning==2.5.1.post0
+opencv-python==4.11.0.86
+opencv-python-headless==4.11.0.86
+qudida==0.0.4
+albumentations==1.1.0
+safetensors==0.5.3
+xxhash==3.5.0
+fsspec==2025.3.0
+dill==0.3.8
+multiprocess==0.70.16
+datasets==3.6.0
+menuinst==2.2.0
+anaconda-anon-usage==0.7.0
+annotated-types==0.6.0
+archspec==0.2.3
+boltons==24.1.0
+Brotli==1.0.9
+distro==1.9.0
+frozendict==2.4.2
+idna==3.7
+jsonpointer==2.1
+libmambapy==2.0.5
+mdurl==0.1.0
+packaging==24.2
+platformdirs==4.3.7
+pluggy==1.5.0
+pycosat==0.6.6
+pycparser==2.21
+Pygments==2.19.1
+PySocks==1.7.1
+ruamel.yaml.clib==0.2.12
+tqdm==4.67.1
+truststore==0.10.0
+wheel==0.45.1
+cffi==1.17.1
+jsonpatch==1.33
+markdown-it-py==2.2.0
+pip==25.0
+ruamel.yaml==0.18.10
+cryptography==44.0.1
+requests==2.32.3
+rich==13.9.4
+zstandard==0.23.0
+conda-content-trust==0.2.0
+conda_package_streaming==0.11.0
+conda-package-handling==2.4.0
+conda==25.3.1
+conda-anaconda-telemetry==0.1.2
+conda-anaconda-tos==0.1.3
+conda-libmamba-solver==25.4.0
+pillow==11.2.1
+imageio==2.37.0
+tifffile==2025.5.10
+lazy_loader==0.4
+scikit-image==0.25.2
+pytz==2025.2
+tzdata==2025.2
+six==1.17.0
+pypickle==1.1.5
+pyparsing==3.2.3
+kiwisolver==1.4.8
+fonttools==4.58.0
+cycler==0.12.1
+contourpy==1.3.2
+python-dateutil==2.9.0.post0
+datazets==1.1.2
+colourmap==1.1.21
+scatterd==1.3.9
+clusteval==2.2.5
+ruff==0.11.11
+PyYAML==6.0.2
+propcache==0.3.1
+multidict==6.4.4
+MarkupSafe==3.0.2
+fsspec==2025.5.1
+frozenlist==1.6.0
+filelock==3.18.0
+attrs==25.3.0
+aiohappyeyeballs==2.6.1
+yarl==1.20.0
+Jinja2==3.1.6
+pytorch-lightning==2.5.1.post0
+lightning==2.5.1.post0
+regex==2025.7.34
+accelerate==1.9.0
+peft==0.17.0
+torchaudio==2.8.0
+standard-chunk==3.13.0
+soxr==0.5.0.post1
+msgpack==1.1.1
+llvmlite==0.44.0
+audioread==3.0.1
+audioop-lts==0.2.2
+standard-sunau==3.13.0
+standard-aifc==3.13.0
+soundfile==0.13.1
+pooch==1.8.2
+numba==0.61.2
+librosa==0.11.0
+pyarrow==21.0.0
+antlr4-python3-runtime==4.9.3
+omegaconf==2.3.0
+protobuf==6.32.0
+smmap==5.0.2
+sentry-sdk==2.35.0
+click==8.2.1
+gitdb==4.0.12
+GitPython==3.1.45
+sniffio==1.3.1
+python-multipart==0.0.21
+jiter==0.12.0
+h11==0.16.0
+anyio==4.12.1
+annotated-doc==0.0.4
+uvicorn==0.40.0
+starlette==0.50.0
+httpcore==1.0.9
+httpx==0.28.1
+fastapi==0.128.0
+openai==2.15.0
+PyMuPDF==1.26.7
+ConfigArgParse==1.7.1
+tenacity==9.1.2
+elevenlabs==2.39.0
+zipp==3.23.0
+types-protobuf==6.32.1.20260221
+shellingham==1.5.4
+PyJWT==2.12.1
+prometheus_client==0.24.1
+opentelemetry-proto==1.39.1
+livekit-blingfire==1.1.0
+grpcio==1.78.0
+googleapis-common-protos==1.73.0
+eval_type_backport==0.3.1
+docstring_parser==0.17.0
+colorama==0.4.6
+certifi==2026.2.25
+av==17.0.0
+aiofiles==25.1.0
+watchfiles==1.1.1
+sounddevice==0.5.5
+opentelemetry-exporter-otlp-proto-common==1.39.1
+livekit-protocol==1.1.3
+importlib_metadata==8.7.1
+typer==0.24.1
+opentelemetry-api==1.39.1
+livekit-api==1.1.0
+opentelemetry-semantic-conventions==0.60b1
+opentelemetry-sdk==1.39.1
+opentelemetry-exporter-otlp-proto-http==1.39.1
+opentelemetry-exporter-otlp-proto-grpc==1.39.1
+opentelemetry-exporter-otlp==1.39.1
+python-dotenv==1.2.2
+flatbuffers==25.12.19
+onnxruntime==1.24.4
+livekit-plugins-turn-detector==1.4.6
+livekit-plugins-silero==1.4.6
+websockets==15.0.1
+livekit-plugins-openai==1.4.6
+ctranslate2==4.7.1
+faster-whisper==1.2.1
+typing_extensions==4.15.0
+pyasn1==0.6.3
+proto-plus==1.27.1
+pyasn1_modules==0.4.2
+grpcio-status==1.78.0
+google-auth==2.49.1
+google-api-core==2.30.0
+google-genai==1.68.0
+google-cloud-texttospeech==2.34.0
+google-cloud-speech==2.37.0
+livekit-plugins-google==1.4.6
+hf-xet==1.4.2
+huggingface_hub==1.7.1
+tokenizers==0.22.2
+transformers==5.3.0
+tiktoken==0.12.0
+whisperlivekit==0.2.20.post1
+livekit==1.0.25
+aiosignal==1.4.0
+aiohttp==3.13.3
+livekit-agents==1.5.0
+livekit-plugins-elevenlabs==1.5.0
+filetype==1.2.0
+dirtyjson==1.0.8
+wrapt==2.1.2
+typing-inspection==0.4.2
+tinytag==2.2.1
+setuptools==82.0.1
+pydantic_core==2.41.5
+mypy_extensions==1.1.0
+marshmallow==3.26.2
+griffelib==2.0.0
+greenlet==3.3.2
+aiosqlite==0.22.1
+typing-inspect==0.9.0
+SQLAlchemy==2.0.48
+pydantic==2.12.5
+griffecli==2.0.0
+Deprecated==1.3.1
+llama-index-instrumentation==0.5.0
+llama_cloud==1.6.0
+griffe==2.0.0
+dataclasses-json==0.6.7
+llama-index-workflows==2.17.0
+banks==2.4.1
+llama-index-core==0.14.18
+llama-parse==0.5.20
+llama-index-llms-openai==0.7.2
+llama-index-indices-managed-llama-cloud==0.11.0
+llama-index-embeddings-openai==0.6.0
+llama-index-readers-llama-parse==0.6.0
+llama-index-cli==0.5.6
+llama-index==0.14.18
+soupsieve==2.8.3
+beautifulsoup4==4.14.3
+sortedcontainers==2.4.0
+wsproto==1.3.2
+websocket-client==1.9.0
+urllib3==2.6.3
+tzlocal==5.3.1
+tld==0.13.2
+outcome==1.3.0.post0
+lxml==6.0.2
+charset-normalizer==3.4.6
+babel==2.18.0
+trio==0.33.0
+lxml_html_clean==0.4.4
+dateparser==1.3.0
+courlan==1.3.2
+webdriver-manager==4.0.2
+trio-websocket==0.12.2
+htmldate==1.9.4
+selenium==4.41.0
+jusText==3.0.2
+trafilatura==2.0.0
+pypdf==6.9.1
+pdfminer.six==20260107
+nvidia-cusparselt-cu12==0.6.3
+triton==3.3.0
+nvidia-nvtx-cu12==12.6.77
+nvidia-nvjitlink-cu12==12.6.85
+nvidia-nccl-cu12==2.26.2
+nvidia-curand-cu12==10.3.7.77
+nvidia-cufile-cu12==1.11.1.6
+nvidia-cuda-runtime-cu12==12.6.77
+nvidia-cuda-nvrtc-cu12==12.6.77
+nvidia-cuda-cupti-cu12==12.6.80
+nvidia-cublas-cu12==12.6.4.1
+nvidia-cusparse-cu12==12.5.4.2
+nvidia-cufft-cu12==11.3.0.4
+nvidia-cudnn-cu12==9.5.1.17
+nvidia-cusolver-cu12==11.7.1.2
+torch==2.7.0
+timm==1.0.26
+wandb==0.25.1
+xgboost==3.2.0
+numpy==2.4.4
+joblib==1.5.3
+scipy==1.17.1
+pandas==3.0.2
+scikit-learn==1.8.0
+matplotlib==3.10.8
+mlxtend==0.24.0

wandb/run-20260419_175057-4kiikgrp/files/wandb-metadata.json

@@ -0,0 +1,24 @@
+{
+  "os": "Linux-6.19.11-200.fc43.x86_64-x86_64-with-glibc2.42",
+  "python": "CPython 3.13.2",
+  "startedAt": "2026-04-19T13:50:57.074183Z",
+  "program": "/home/union_point/ml/Plant-Disease-Classification/train.py",
+  "codePath": "train.py",
+  "codePathLocal": "train.py",
+  "email": "coretwoduo75@gmail.com",
+  "root": "/home/union_point/ml/Plant-Disease-Classification",
+  "host": "laptop",
+  "executable": "/home/union_point/miniconda3/bin/python",
+  "cpu_count": 2,
+  "cpu_count_logical": 4,
+  "disk": {
+    "/": {
+      "total": "254356226048",
+      "used": "139972616192"
+    }
+  },
+  "memory": {
+    "total": "7760048128"
+  },
+  "writerId": "5r5nghwc1gn8jkabzqczvjhk7aa94c6x"
+}

wandb/run-20260419_175057-4kiikgrp/files/wandb-summary.json

@@ -0,0 +1 @@
+{"_wandb":{"runtime":12},"_runtime":12}