Upload 7 files

DATASET_GUIDE.md

@@ -0,0 +1,207 @@
+# CropGuard GH — Dataset Guide
+
+**How to assemble the training dataset for the crop disease detection model.**
+Final Year Project · Oppong David · BTech Computer Technology, Kumasi Technical University
+
+---
+
+## Read this first (important and honest)
+
+There is **no single "CropGuard dataset" file to download.** The model is trained on a *combination* of public, peer-reviewed image datasets, plus any images you collect yourself. This guide tells you exactly which datasets to download, where, under what licence, and how to arrange them into the folder layout the training script expects.
+
+Two reasons it works this way:
+
+1. **The images are large and third-party.** The datasets below total tens of gigabytes and are published by other researchers under their own licences. They cannot be repackaged here — but every one is free to download from its official repository, linked below.
+2. **"All crops" means "all crops we have data for."** A model can only learn a disease it has seen. The 14 crops / 55 classes are the crops Ghanaian smallholders grow *and* for which labelled images exist. Coverage is uneven (see the **Coverage tier** column) — be honest about this in your report and viva.
+
+The single most field-realistic source is the **CCMT dataset**, which was collected on farms in Ghana and covers cashew, cassava, maize and tomato. It is the backbone of this project. Everything else fills gaps.
+
+---
+
+## 1. Folder layout the training script expects
+
+`backend/train.py` loads images with Keras `image_dataset_from_directory`, i.e. one folder per class, split into `train` / `val` / `test`:
+
+```
+data/
+├── train/
+│   ├── maize_healthy/      *.jpg
+│   ├── maize_gls/          *.jpg
+│   ├── cassava_cmd/        *.jpg
+│   └── ... (one folder per class)
+├── val/
+│   └── ... (same class folders)
+└── test/
+    └── ... (same class folders)
+```
+
+- **Folder names must exactly match the 55 class keys** (see `class_names.txt`) — these are the same keys as in `backend/recommendations.json`, so the API can look up treatment advice by predicted class.
+- A 70 / 15 / 15 train/val/test split is assumed (§3.4.3 of the report). `scripts/prepare_dataset.py` does the splitting for you.
+
+The 55 classes, by crop:
+
+| Crop | Classes |
+|---|---|
+| Maize | `maize_healthy` `maize_gls` `maize_nclb` `maize_rust` `maize_msv` `maize_faw` |
+| Cassava | `cassava_healthy` `cassava_cmd` `cassava_cbsd` `cassava_cbb` |
+| Tomato | `tomato_healthy` `tomato_early` `tomato_late` `tomato_wilt` `tomato_septoria` `tomato_tylcv` |
+| Cocoa | `cocoa_healthy` `cocoa_blackpod` `cocoa_cssvd` `cocoa_capsid` |
+| Cashew | `cashew_healthy` `cashew_anthracnose` `cashew_gumosis` `cashew_leafminer` |
+| Plantain | `plantain_healthy` `plantain_sigatoka` `plantain_bbtv` `plantain_panama` |
+| Yam | `yam_healthy` `yam_anthracnose` `yam_mosaic` |
+| Pepper | `pepper_healthy` `pepper_bacterialspot` `pepper_anthracnose` |
+| Cowpea | `cowpea_healthy` `cowpea_blight` `cowpea_mosaic` `cowpea_cercospora` |
+| Groundnut | `groundnut_healthy` `groundnut_leafspot` `groundnut_rosette` `groundnut_rust` |
+| Rice | `rice_healthy` `rice_blast` `rice_blb` `rice_brownspot` |
+| Okra | `okra_healthy` `okra_yvmv` `okra_leafspot` |
+| Garden Egg | `gardenegg_healthy` `gardenegg_wilt` `gardenegg_leafspot` |
+| Mango | `mango_healthy` `mango_anthracnose` `mango_bacterialspot` |
+
+---
+
+## 2. The datasets (verified sources)
+
+> ⚠️ **Always confirm the licence on each page before any non-research use.** Mendeley Data sets are usually CC BY 4.0; Kaggle competition data is governed by its competition rules. The notes below were accurate at the time of writing — verify on the page.
+
+### A. CCMT — Cashew, Cassava, Maize, Tomato (collected in Ghana) ★ primary
+- **Source:** Mendeley Data — *Dataset for Crop Pest and Disease Detection* (Mensah, Akoto-Adjepong, Adu et al., *Data in Brief* 49, 2023, art. 109306).
+- **DOI:** `10.17632/bwh3zbpkpv.1` → https://data.mendeley.com/datasets/bwh3zbpkpv/1 (also mirrored on Kaggle)
+- **Size:** 24,881 raw images (`Raw Data.zip`, ~1.22 GB) and 102,976 augmented images (`CCMT Dataset.zip`, ~6.81 GB). 22 classes across the four crops.
+- **Collected:** University of Energy & Natural Resources, Sunyani, Ghana, Oct–Dec 2022. Field, white, dark and illuminated backgrounds.
+- **Licence:** Mendeley Data (typically CC BY 4.0 — verify).
+- **Folder → class mapping:**
+  - Cashew → `Anthracnose`→`cashew_anthracnose`, `Gummosis`→`cashew_gumosis`, `Leaf miner`→`cashew_leafminer`, `Healthy`→`cashew_healthy` (`Red rust` has no CropGuard class — skip or add one)
+  - Cassava → `Mosaic`→`cassava_cmd`, `Bacterial blight`→`cassava_cbb`, `Healthy`→`cassava_healthy` (CCMT `Brown spot` and `Green mite` ≠ our classes — skip; CCMT has **no** brown-streak/CBSD, get that from Cassava-Kaggle below)
+  - Maize → `Fall armyworm`→`maize_faw`, `Streak virus`→`maize_msv`, `Leaf blight`→`maize_nclb`, `Leaf spot`→`maize_gls`, `Healthy`→`maize_healthy` (CCMT `Grasshopper`, `Leaf beetle` ≠ our classes — skip; **common rust** comes from PlantVillage corn)
+  - Tomato → `Leaf blight`→`tomato_late` *(approx.)*, `Leaf curl`→`tomato_tylcv`, `Septoria leaf spot`→`tomato_septoria`, `Verticillium wilt`→`tomato_wilt`, `Healthy`→`tomato_healthy`
+
+### B. PlantVillage — tomato, pepper (and cross-checks)
+- **Source:** Hughes & Salathé (2015). Mendeley Data DOI `10.17632/tywbtsjrjv.1`; GitHub `spMohanty/PlantVillage-Dataset`; several Kaggle mirrors (e.g. `abdallahalidev/plantvillage-dataset`).
+- **Size:** ~54,000 lab images, white backgrounds, 14 crops / 26+ classes.
+- **Licence:** free for research (verify the specific mirror).
+- **Folder → class mapping (the crops we keep):**
+  - `Tomato___healthy`→`tomato_healthy`, `Tomato___Early_blight`→`tomato_early`, `Tomato___Late_blight`→`tomato_late`, `Tomato___Septoria_leaf_spot`→`tomato_septoria`, `Tomato___Tomato_Yellow_Leaf_Curl_Virus`→`tomato_tylcv`
+  - `Pepper,_bell___Bacterial_spot`→`pepper_bacterialspot`, `Pepper,_bell___healthy`→`pepper_healthy`
+  - `Corn_(maize)___Common_rust_`→`maize_rust`, `Corn_(maize)___Northern_Leaf_Blight`→`maize_nclb`, `Corn_(maize)___Cercospora…Gray_leaf_spot`→`maize_gls`, `Corn_(maize)___healthy`→`maize_healthy`
+  - *(ignore PlantVillage's apple/grape/cherry/etc. — not Ghanaian crops)*
+
+### C. Cassava Leaf Disease (Makerere University / Kaggle)
+- **Source:** Kaggle competition `cassava-leaf-disease-classification` (2020).
+- **Size:** ~21,400 labelled field images from Uganda.
+- **Licence:** Kaggle competition rules (research/educational).
+- **Folder → class mapping:** `Cassava Mosaic Disease (CMD)`→`cassava_cmd`, `Cassava Brown Streak Disease (CBSD)`→`cassava_cbsd`, `Cassava Bacterial Blight (CBB)`→`cassava_cbb`, `Healthy`→`cassava_healthy`. **This is your source for `cassava_cbsd`,** which CCMT lacks.
+
+### D. MangoLeafBD — mango
+- **Source:** Ahmed et al. (2023), Mendeley Data DOI `10.17632/hxsnvwty3r.1` → https://data.mendeley.com/datasets/hxsnvwty3r/1
+- **Size:** 4,000 images, 8 classes, 500 per class. Bangladesh.
+- **Licence:** CC BY 4.0 (verify).
+- **Folder → class mapping:** `Healthy`→`mango_healthy`, `Anthracnose`→`mango_anthracnose`, `Bacterial Canker`→`mango_bacterialspot` *(approx. — bacterial black spot)*. (Other classes unused.)
+
+### E. Rice Leaf Disease Image Samples (Sethy) — rice
+- **Source:** Sethy et al. (2020), Mendeley Data DOI `10.17632/fwcj7stb8r.1` → https://data.mendeley.com/datasets/fwcj7stb8r/1
+- **Size:** 5,932 images. India.
+- **Licence:** CC BY 4.0 (verify).
+- **Folder → class mapping:** `Blast`→`rice_blast`, `Bacterial blight`→`rice_blb`, `Brown Spot`→`rice_brownspot`. (`Tungro` unused.) For `rice_healthy`, add healthy-rice images (e.g. from the Dhan-Shomadhan or RiceLeafs datasets, or your own).
+
+### F. Groundnut Leaf Dataset (Sasmal) — groundnut
+- **Source:** Sasmal, Das, Dhal et al. (2024), Mendeley Data DOI `10.17632/x6x5jkk873.2` → https://data.mendeley.com/datasets/x6x5jkk873/2
+- **Size:** 1,720 field images. India.
+- **Licence:** CC BY 4.0 (verify).
+- **Folder → class mapping:** `Healthy`→`groundnut_healthy`, `Leaf spot (early and late)`→`groundnut_leafspot`, `Rust`→`groundnut_rust`, `Rosette`→`groundnut_rosette`. (`Alternaria leaf spot` unused.)
+
+### G. Cocoa (KaraAgroAI + Kaggle) — cocoa
+- **CSSVD + healthy + anthracnose:** *KaraAgroAI Cocoa Dataset* (Atuhurra et al., 2024, arXiv:2405.04535) — classes Healthy / CSSVD / Anthracnose → `cocoa_healthy`, `cocoa_cssvd`.
+- **Black pod:** Kaggle *Cocoa Diseases (YOLOv4)* (`serranosebas/enfermedades-cacao-yolov4`) and/or GitHub `Br-Al/Cocoa-diseases` (black pod rot, healthy) → `cocoa_blackpod`.
+- **`cocoa_capsid`:** no good public image set — **collect locally** (COCOBOD/CRIG can advise) or drop the class.
+- **Licence:** verify each (research/educational).
+
+### H. BananaLSD — plantain/banana
+- **Source:** Ahmed et al. (2023), *Data in Brief* — BananaLSD (ScienceDirect S2352340923006959; Kaggle mirrors exist).
+- **Size:** 937 images + ~1,600 augmented, classes Sigatoka / Cordana / Pestalotiopsis / Healthy. Bangladesh.
+- **Folder → class mapping:** `Sigatoka`→`plantain_sigatoka` *(approx. black sigatoka)*, `Healthy`→`plantain_healthy`.
+- **`plantain_bbtv` (bunchy top) and `plantain_panama` (Fusarium wilt):** not in BananaLSD — **collect locally** or source separately.
+
+### I. Crops with little/no dedicated public dataset — collect locally
+These Ghanaian crops/classes have weak public coverage. Plan to photograph them in the field (extension officers, research stations, and the crops themselves are the source). Until then, the model will be unreliable on them and you should say so:
+
+- **Cowpea** — `cowpea_healthy` `cowpea_blight` `cowpea_mosaic` `cowpea_cercospora`
+- **Yam** — `yam_healthy` `yam_anthracnose` `yam_mosaic`
+- **Okra** — `okra_healthy` `okra_yvmv` `okra_leafspot`
+- **Garden Egg** — `gardenegg_healthy` `gardenegg_wilt` `gardenegg_leafspot`
+- **Pepper** — `pepper_anthracnose` (chili-anthracnose sets exist on Kaggle; pepper bacterial spot + healthy come from PlantVillage)
+
+---
+
+## 3. Coverage tiers (put this in your report)
+
+| Tier | Meaning | Crops / classes |
+|---|---|---|
+| **Strong (Ghana field data)** | Collected in Ghana, field-realistic | cashew, cassava, maize, tomato (via CCMT + Cassava-Kaggle) |
+| **Good (non-Ghana public data)** | Solid labelled images, but a domain/region gap | mango, rice, groundnut, cocoa (CSSVD/black pod), plantain (sigatoka), pepper (bacterial spot) |
+| **Weak (little/no public data)** | Needs locally collected images to be usable | cowpea, yam, okra, garden egg, plantain bbtv/panama, cocoa capsid, pepper anthracnose |
+
+This is why `train.py` reports the **real** held-out test accuracy at the end of training rather than assuming the ~98% target: accuracy will be high on the well-covered crops and lower on the weak ones until you add local images. The ~98% figure is consistent with the literature on this kind of benchmark (Mohanty et al. 2016 = 99.35%; Ferentinos 2018 = 99.53%) but must be *earned* on your test set, not declared.
+
+---
+
+## 4. How to download
+
+### Option 1 — Kaggle CLI (fastest for the Kaggle-hosted sets)
+```bash
+pip install kaggle                      # then put kaggle.json in ~/.kaggle/
+kaggle competitions download -c cassava-leaf-disease-classification
+kaggle datasets download -d abdallahalidev/plantvillage-dataset
+kaggle datasets download -d serranosebas/enfermedades-cacao-yolov4
+```
+
+### Option 2 — Mendeley Data (CCMT, MangoLeafBD, Rice, Groundnut)
+Open the DOI link in a browser and click **Download** (Mendeley serves a redirect to the file; scripted download is unreliable, so do these by hand):
+- CCMT: https://data.mendeley.com/datasets/bwh3zbpkpv/1
+- MangoLeafBD: https://data.mendeley.com/datasets/hxsnvwty3r/1
+- Rice: https://data.mendeley.com/datasets/fwcj7stb8r/1
+- Groundnut: https://data.mendeley.com/datasets/x6x5jkk873/2
+
+### Option 3 — helper script
+`scripts/download_dataset.py` lists every dataset, attempts the Kaggle downloads automatically (if the Kaggle CLI is configured) and prints the manual links for the Mendeley/GitHub sets. See `scripts/` for usage.
+
+Unzip everything into a single working folder, e.g. `raw_downloads/`.
+
+---
+
+## 5. How to turn the downloads into `data/`
+
+`scripts/prepare_dataset.py`:
+1. reads a **MAPPING** (source dataset + subfolder → CropGuard class key — pre-filled from the tables above),
+2. copies images into a flat `data_flat/<class>/` tree,
+3. splits each class 70/15/15 into `data/train|val|test/<class>/`.
+
+```bash
+python scripts/prepare_dataset.py --raw ./raw_downloads --out ./data
+```
+
+Open the script and adjust the source paths to match where you unzipped each dataset (folder names differ slightly between mirrors). It prints a per-class image count at the end so you can see which classes are thin and need local images.
+
+---
+
+## 6. Then train
+
+```bash
+cd backend
+pip install -r requirements.txt
+python train.py --data ../data --arch efficientnet --epochs-head 20 --epochs-fine 30
+```
+
+`train.py` will print the class list it found, train in two phases, and report the held-out **test accuracy vs the ~0.98 target**. If you are below target, the script tells you what to do (use EfficientNetB0, add field data, or train longer).
+
+---
+
+## 7. Citations (add these to your references)
+
+- Mensah, P.K., Akoto-Adjepong, V., Adu, K., et al. (2023). *CCMT: Dataset for crop pest and disease detection.* Data in Brief, 49, 109306.
+- Hughes, D.P. & Salathé, M. (2015). *An open access repository of images on plant health…* (PlantVillage). arXiv:1511.08060.
+- Makerere University AI Lab (2020). *Cassava Leaf Disease Classification.* Kaggle.
+- Ahmed, S.I., Ibrahim, M., Nadim, M., et al. (2023). *MangoLeafBD: A comprehensive image dataset…* Data in Brief, 47, 108941.
+- Sethy, P.K., Barpanda, N.K., Rath, A.K. & Behera, S.K. (2020). *Rice Leaf Disease Image Samples.* Mendeley Data.
+- Sasmal, B., Das, A., Dhal, K.G., et al. (2024). *A novel groundnut leaf dataset…* Data in Brief, 55, 110763.
+- Atuhurra, J., Douha, N.Y.-R., Lenka, P. (2024). *Image Classification for CSSVD Detection in Cacao Plants* (KaraAgroAI Cocoa Dataset). arXiv:2405.04535.
+- Ahmed, S.I., et al. (2023). *BananaLSD: A banana leaf images dataset…* Data in Brief.

README.md

@@ -0,0 +1,18 @@
+# CropGuard GH — Dataset Kit
+
+Everything you need to assemble the training dataset and understand both systems.
+
+## Contents
+- **DATASET_GUIDE.md** — which datasets to download, from where, under what licence, how they map to the 55 classes, and how to build the `data/` folder. **Start here.**
+- **class_names.txt** — the canonical 55 class names (must match the training folders and `recommendations.json`).
+- **scripts/download_dataset.py** — lists every source, auto-downloads the Kaggle sets, prints manual links for the rest.
+- **scripts/prepare_dataset.py** — maps the downloaded raw folders into the 55 class folders and splits 70/15/15 into `train/val/test`.
+- **docs/STANDALONE_HTML_DOCUMENTATION.md** — full docs for the single-file browser app (`cropguard.html`).
+- **docs/BACKEND_SYSTEM_DOCUMENTATION.md** — full docs for the training + FastAPI + React stack.
+
+## Quick path
+```bash
+python scripts/download_dataset.py --out ./raw_downloads   # then unzip everything
+python scripts/prepare_dataset.py --raw ./raw_downloads --out ./data
+cd ../cropguard-system/backend && python train.py --data ../../data --arch efficientnet
+```

class_names.txt

@@ -0,0 +1,55 @@
+maize_healthy
+maize_gls
+maize_nclb
+maize_rust
+maize_msv
+maize_faw
+cassava_healthy
+cassava_cmd
+cassava_cbsd
+cassava_cbb
+tomato_healthy
+tomato_early
+tomato_late
+tomato_wilt
+tomato_septoria
+tomato_tylcv
+cocoa_healthy
+cocoa_blackpod
+cocoa_cssvd
+cocoa_capsid
+cashew_healthy
+cashew_anthracnose
+cashew_gumosis
+cashew_leafminer
+plantain_healthy
+plantain_sigatoka
+plantain_bbtv
+plantain_panama
+yam_healthy
+yam_anthracnose
+yam_mosaic
+pepper_healthy
+pepper_bacterialspot
+pepper_anthracnose
+cowpea_healthy
+cowpea_blight
+cowpea_mosaic
+cowpea_cercospora
+groundnut_healthy
+groundnut_leafspot
+groundnut_rosette
+groundnut_rust
+rice_healthy
+rice_blast
+rice_blb
+rice_brownspot
+okra_healthy
+okra_yvmv
+okra_leafspot
+gardenegg_healthy
+gardenegg_wilt
+gardenegg_leafspot
+mango_healthy
+mango_anthracnose
+mango_bacterialspot

docs/BACKEND_SYSTEM_DOCUMENTATION.md

@@ -0,0 +1,253 @@
+# CropGuard GH — Backend & Tools System Documentation
+
+**The full production stack: model training, inference API, and React frontend.**
+Final Year Project · Oppong David · BTech Computer Technology, Kumasi Technical University
+
+This documents the `cropguard-system/` bundle — the real Chapter 3 implementation. For the single-file browser app, see the *Standalone HTML App Documentation*.
+
+---
+
+## 1. What this is
+
+A three-part client–server system that detects crop disease with a trained convolutional neural network:
+
+```
+   ┌───────────────────────────┐      HTTPS / multipart       ┌────────────────────────────┐
+   │  Frontend (client)        │  ── POST /predict (image) ─▶ │  Backend (server)          │
+   │  • React app (CropGuard.jsx)                             │  FastAPI (app.py)          │
+   │  • OR the single-file HTML │  ◀── JSON diagnosis ──       │   ├─ trained CNN model      │
+   │    app                     │                              │   ├─ severity estimator     │
+   └───────────────────────────┘                              │   └─ recommendations.json   │
+                                                               └────────────────────────────┘
+                                          ▲
+                                          │  trained offline by
+                                   train.py  →  crop_model.keras + classes.json
+```
+
+Three components:
+1. **`backend/train.py`** — trains the model from a folder of labelled images.
+2. **`backend/app.py`** — a FastAPI server that loads the trained model and serves predictions.
+3. **`frontend/src/CropGuard.jsx`** — a React UI that calls the server. (The standalone HTML app can be used as the client instead.)
+
+Plus **`backend/recommendations.json`** — the bilingual-source treatment knowledge base (55 classes), used by the server to attach advice to each prediction.
+
+### File tree
+```
+cropguard-system/
+├── backend/
+│   ├── train.py             # model training (transfer learning)
+│   ├── app.py               # FastAPI inference server
+│   ├── recommendations.json # 55-class treatment knowledge base (English)
+│   └── requirements.txt
+├── frontend/
+│   └── src/CropGuard.jsx     # React frontend
+├── cropguard.html            # the standalone app (also bundled here)
+├── cropguard-en.html
+├── cropguard-tw.html
+└── docs/DOCUMENTATION.md     # combined system doc
+```
+
+---
+
+## 2. Model & training — `train.py`
+
+A transfer-learning image classifier, exactly as described in Chapter 3.
+
+### Architecture (§3.6)
+- **Input:** 224×224 RGB, standardised with ImageNet channel mean/std.
+- **Backbone:** ImageNet-pretrained, selectable with `--arch`:
+  - `mobilenet` → **MobileNetV2** (fast, light; ~97–98% on this benchmark)
+  - `efficientnet` → **EfficientNetB0** (typically ~98–99%; preferred to reach the ~98% target across all crops)
+- **Custom head (§3.6.4):** GlobalAveragePooling → BatchNorm → Dense(512, ReLU, L2 1e-4) → Dropout(0.4) → Dense(num_classes, softmax).
+
+### Training strategy (§3.7)
+- **Two phases:** (1) freeze the backbone and train the head (Adam 1e-3); (2) unfreeze the top 30% of the backbone and fine-tune at a low rate (Adam 1e-4).
+- **Class weighting** to handle uneven class sizes (computed from the train folder).
+- **Augmentation** (§3.5.2): random flip, rotation, zoom, brightness, contrast.
+- **Label smoothing** (0.05) for calibration and a small accuracy gain.
+- **Callbacks:** EarlyStopping (restore best weights) and ReduceLROnPlateau.
+
+### Dataset layout it expects
+ImageFolder style — one folder per class, split into train/val/test (see the **Dataset Guide** for how to assemble this):
+```
+data/
+├── train/<class_name>/*.jpg
+├── val/<class_name>/*.jpg
+└── test/<class_name>/*.jpg
+```
+**Class folder names must match the keys in `recommendations.json`** (the 55 classes in `class_names.txt`).
+
+### Run it
+```bash
+cd backend
+pip install -r requirements.txt
+python train.py --data ../data --arch efficientnet --epochs-head 20 --epochs-fine 30
+```
+
+### Arguments
+| Flag | Default | Meaning |
+|---|---|---|
+| `--data` | `./data` | dataset root (expects `train/`, `val/`, `test/`) |
+| `--arch` | `mobilenet` | `mobilenet` or `efficientnet` |
+| `--epochs-head` | `20` | phase-1 epochs (frozen backbone) |
+| `--epochs-fine` | `30` | phase-2 fine-tuning epochs |
+| `--out` | `model` | output directory |
+
+### Outputs
+- `model/crop_model.keras` — the trained model (loaded by `app.py`).
+- `model/classes.json` — the class-name list in label order (so the server maps a prediction index → class key).
+
+### Honesty about accuracy
+At the end, `train.py` evaluates on the **held-out test set** and prints the real test accuracy against the ~0.98 target. The target is consistent with the literature (Mohanty et al. 2016 = 99.35%; Ferentinos 2018 = 99.53%) but is **measured, not assumed** — if the run is below target, the script suggests using EfficientNetB0, adding more field-condition data, or training longer. Accuracy will be high on well-covered crops (cashew, cassava, maize, tomato — the Ghana-collected CCMT data) and lower on crops with thin data until you add local images (see the Dataset Guide's coverage tiers).
+
+---
+
+## 3. Inference API — `app.py` (FastAPI)
+
+Loads the trained model once (lazily, kept resident in memory) and serves predictions to either frontend.
+
+### Endpoints
+| Method | Path | Returns |
+|---|---|---|
+| GET | `/health` | `{"status":"ok","model_loaded": bool}` |
+| GET | `/diseases` | the full `recommendations.json` knowledge base |
+| POST | `/predict` | multipart image → diagnosis JSON (below) |
+
+### `POST /predict` response shape
+```json
+{
+  "class_id": "tomato_late",
+  "confidence": 0.94,
+  "severity": "moderate",        // null when the class is healthy
+  "diseased_ratio": 0.42,
+  "disease": { ...full record from recommendations.json... }
+}
+```
+
+### How a prediction is produced
+1. The uploaded image is opened with Pillow, converted to RGB, resized to 224×224 and standardised (same preprocessing as training).
+2. The model returns class probabilities; the top class and its confidence are taken.
+3. If the class is **not** healthy, `estimate_severity()` measures the diseased-area ratio (colour thresholding on a 128×128 copy: yellow/brown/dark vs leaf area; §3.8) and maps it to early/moderate/severe.
+4. The matching treatment record is attached from `recommendations.json`.
+5. **The image is discarded** — it is never written to disk (privacy-by-design, §3.10/§3.13).
+
+### Run it
+```bash
+cd backend
+uvicorn app:app --host 0.0.0.0 --port 8000 --reload
+# health check:
+curl http://localhost:8000/health
+```
+Set `MODEL_DIR` if your model is not in `./model`. CORS is open (`allow_origins=["*"]`) so a browser-based client can call it; tighten this for production.
+
+---
+
+## 4. Treatment knowledge base — `recommendations.json`
+
+A JSON object keyed by the 55 class IDs. Each record is one of:
+
+```jsonc
+// healthy class
+"maize_healthy": { "crop": "Maize", "name": "Healthy Maize", "healthy": true }
+
+// disease class
+"maize_gls": {
+  "crop": "Maize",
+  "name": "Grey Leaf Spot",
+  "cause": "A fungus (Cercospora zeae-maydis) that thrives in warm, humid weather...",
+  "treatment": ["Remove badly spotted lower leaves...", "Spray a strobilurin...", ...],
+  "products": ["Azoxystrobin", "Propiconazole"]
+}
+```
+
+This is the English knowledge base used by the server. The standalone HTML app carries its own bilingual (English + Twi) copy of the same content inline. To add or edit advice, change the record here **and** in the HTML app's `DATA.diseases` (keep the keys identical).
+
+---
+
+## 5. React frontend — `frontend/src/CropGuard.jsx`
+
+A React implementation of the same four-step farmer flow (`home → preview → loading → result`).
+
+- **API base URL** comes from a Vite env var: `VITE_API_URL` (defaults to `http://localhost:8000`).
+- `analyse()` posts the chosen file to `${API}/predict` and renders the returned diagnosis, with the same severity colours and treatment list as the HTML app.
+- It expects to run in a standard Vite + React project.
+
+### Run it (typical Vite setup)
+```bash
+# in a Vite React app that includes CropGuard.jsx
+echo "VITE_API_URL=http://localhost:8000" > .env
+npm install
+npm run dev
+```
+
+> Note: the **standalone HTML app** already provides a complete, dependency-free client and can be used instead of the React frontend — it talks to the same `/predict` endpoint. Use the React app if you want to embed CropGuard in a larger React project; use the HTML app for the simplest possible deployment.
+
+---
+
+## 6. Dependencies — `requirements.txt`
+
+```
+fastapi==0.111.0
+uvicorn[standard]==0.30.1
+python-multipart==0.0.9
+pillow==10.3.0
+numpy==1.26.4
+tensorflow==2.16.1        # training; also needed to load the model when serving
+scikit-learn==1.4.2       # class-weight computation during training
+```
+To **serve** a pre-trained model you still need TensorFlow to load `crop_model.keras`. To only **train**, all of the above are required.
+
+---
+
+## 7. End-to-end: from zero to a working system
+
+```bash
+# 1. Get the data (see Dataset Guide)
+python ../cropguard-dataset-kit/scripts/download_dataset.py --out ./raw_downloads
+python ../cropguard-dataset-kit/scripts/prepare_dataset.py --raw ./raw_downloads --out ./data
+
+# 2. Train
+cd backend
+pip install -r requirements.txt
+python train.py --data ../data --arch efficientnet      # writes model/crop_model.keras + classes.json
+
+# 3. Serve
+uvicorn app:app --host 0.0.0.0 --port 8000
+
+# 4. Use a client
+#    • open cropguard.html and set localStorage.cropguard_api = "http://localhost:8000", OR
+#    • run the React frontend with VITE_API_URL=http://localhost:8000
+```
+
+---
+
+## 8. Deployment notes
+
+- **Backend:** any host that can run Python + TensorFlow — a VM (DigitalOcean, AWS EC2, GCP), a container, or a platform like Render/Railway. Put it behind HTTPS (e.g. an Nginx reverse proxy) for production, and restrict CORS to your frontend's origin.
+- **Model size / speed:** MobileNetV2 is light enough to serve on CPU; EfficientNetB0 is a little heavier but still CPU-servable. Keep the model resident (the app already loads it once).
+- **Frontend:** the HTML app is a static file (host anywhere); the React app builds to static assets via `npm run build`.
+- **Scaling:** prediction is stateless, so you can run multiple backend workers/instances behind a load balancer.
+
+---
+
+## 9. Performance evaluation (§3.12)
+
+Evaluate the trained model on the held-out test set with standard metrics — accuracy, precision, recall, F1-score — and, to quantify the lab-vs-field gap discussed in the report, evaluate separately on (a) controlled-condition images and (b) field-condition images. `train.py` reports overall test accuracy; per-class precision/recall and a confusion matrix can be produced from the saved model with scikit-learn on the test set.
+
+---
+
+## 10. How this maps to the report (Chapter 3)
+
+| Report section | Where it lives |
+|---|---|
+| §3.3 System architecture | the client–server diagram above |
+| §3.4 Dataset collection & curation | Dataset Guide + `prepare_dataset.py` |
+| §3.5 Preprocessing | `standardise()` + augmentation in `train.py` |
+| §3.6 Model selection & architecture | `build_model()` in `train.py` (`--arch`) |
+| §3.7 Training | two-phase fit, class weights, callbacks in `train.py` |
+| §3.8 Severity classification | `estimate_severity()` in `app.py` |
+| §3.9 Treatment recommendations | `recommendations.json` |
+| §3.10 Web application | `CropGuard.jsx` + the standalone HTML app |
+| §3.11 Integration & deployment | §7–§8 above |
+| §3.12 Evaluation framework | §9 above |
+| §3.13 Ethics / privacy | image discarded after prediction; no storage |

docs/STANDALONE_HTML_DOCUMENTATION.md

@@ -0,0 +1,163 @@
+# CropGuard GH — Standalone HTML App Documentation
+
+**The self-contained, single-file browser application.**
+Final Year Project · Oppong David · BTech Computer Technology, Kumasi Technical University
+
+---
+
+## 1. What this is
+
+A complete crop disease detection front end in **one HTML file** — no install, no build step, no server required to open it. A user takes or chooses a photo of a crop leaf and immediately gets a disease name, a confidence score, a severity level (with colour), an urgency level, ordered treatment steps and suggested products.
+
+It is the most accessible deliverable in the project: email the file, host it on any static link, or open it straight from a phone's storage. It works on a basic Android phone with no app-store download.
+
+### The three files
+
+| File | Language | Notes |
+|---|---|---|
+| `cropguard.html` | **Bilingual** | English ⇄ Twi toggle in the header. This is the main app. |
+| `cropguard-en.html` | English only | Same app, no toggle — for English-only deployment. |
+| `cropguard-tw.html` | Twi only | Same app, no toggle — for Twi-only deployment. |
+
+All three are byte-for-byte self-contained: HTML, CSS and JavaScript in a single file, fonts from Google Fonts, no other external dependencies.
+
+### Coverage
+14 Ghanaian crops, 55 disease/healthy classes: maize, cassava, tomato, cocoa, cashew, plantain, yam, pepper, cowpea, groundnut, rice, okra, garden egg, mango.
+
+---
+
+## 2. How to use it
+
+1. **Open** the file in any modern browser (phone or computer) — double-click it, or host it and visit the link.
+2. **Take a photo** ("Take a photo of a leaf") or **Choose from gallery**. On a phone the camera button opens the rear camera directly.
+3. **Check the photo** on the preview screen — the app reminds the user to fill the frame with the diseased leaf in good light — then tap **Analyse crop**.
+4. **Read the result:** crop + disease, confidence bar, severity badge (green/amber/red), urgency, a numbered treatment list (most urgent first), suggested products and a short "about this disease" note.
+5. **Scan another leaf** or **Share result** (uses the device share sheet, or copies to clipboard).
+
+A **Help** sheet on the home screen explains all of this to first-time users, in the selected language.
+
+---
+
+## 3. The four-screen flow
+
+The app is a single-page application with four screens (`home → preview → loading → result`) toggled by a small `show()` function — there is no routing library and no page reload.
+
+```
+ HOME ──tap camera/gallery──▶ PREVIEW ──tap Analyse──▶ LOADING ──result ready──▶ RESULT
+   ▲                                                                               │
+   └───────────────────────────── "Scan another leaf" ────────────────────────────┘
+```
+
+---
+
+## 4. How the diagnosis works — two modes
+
+The app is designed to **never be broken**, so it has two inference paths and picks automatically:
+
+### Mode A — Connected to the trained model (accurate)
+If an API URL is configured, the app sends the photo to the backend (`POST /predict`) and shows the real CNN prediction. This is the accurate mode and the one to use for real diagnosis. Set it by either:
+- running `localStorage.setItem('cropguard_api', 'https://your-server:8000')` in the browser console, or
+- hosting the app and pointing it at your deployed FastAPI server (see the backend documentation).
+
+The footer shows **"Connected to AI model"** with a live dot when an API URL is set.
+
+### Mode B — On-device estimate (offline fallback)
+When **no** API URL is set, the app runs a genuine on-device image analysis in JavaScript using an HTML `<canvas>`. It:
+1. draws the photo to a 180×180 canvas and reads the pixels,
+2. drops near-white background pixels,
+3. measures the proportion of **green**, **yellow**, **brown** and **dark** leaf pixels,
+4. converts that into a *diseased-area ratio*, which sets the severity (early < 0.20 ≤ moderate < 0.55 ≤ severe), and
+5. maps the dominant colour signature to a likely disease among common Ghanaian field patterns.
+
+The footer shows **"On-device analysis"** in this mode.
+
+> **Be honest about Mode B.** It is a real colour/lesion heuristic, not the trained model, and it is **not** the ~98% system. It is a reasonable offline estimate and a graceful fallback so the app still does something useful with no connectivity — but accurate, all-crop diagnosis comes from Mode A (the connected CNN). The on-screen confidence in Mode B is an estimate, and the app's disclaimer says clearly that this is a diagnostic aid, not a replacement for an extension officer.
+
+---
+
+## 5. Bilingual design (`cropguard.html`)
+
+Everything the user sees exists in both English and Twi. The header toggle calls `setLang('en' | 'tw')`, which:
+- stores the choice in `localStorage` (`cropguard_lang`) so it persists,
+- swaps every UI string (elements tagged `data-i="key"` are filled from the language table),
+- rebuilds the crop "pills" list in the chosen language,
+- re-renders the current result in the new language if one is showing.
+
+### Data model
+All content lives in one JavaScript object, `DATA`, injected into the file:
+
+```js
+const DATA = {
+  crops:    { en: [...14 names...], tw: [...14 names...] },
+  t:        { en: {...UI strings...}, tw: {...} },     // labels, buttons, help text
+  severity: { en: {early/moderate/severe...}, tw: {...} },
+  help:     { en: [[title, body], ...], tw: [...] },
+  diseases: {
+    "cocoa_blackpod": {
+      crop: { en: "Cocoa", tw: "Kookoo" },
+      name: { en: "Cocoa Black Pod", tw: "Kookoo Aba Tuntum Yare" },
+      cause:{ en: "...", tw: "..." },
+      tx:   { en: ["step 1", ...], tw: ["..."] },       // treatment steps
+      chem: { en: ["Copper hydroxide", ...], tw: ["..."] } // suggested products
+    },
+    "maize_healthy": { crop:{...}, name:{...}, healthy: true },
+    ...
+  }
+};
+```
+
+The single-language files (`-en` / `-tw`) use the same structure flattened to one language and have no toggle.
+
+> The Twi agronomic text was written carefully, but for the more specialised crops (cocoa, cashew, plantain, yam, etc.) a local agricultural extension officer or MoFA/COCOBOD agent should review it before farmer-facing release — some disease terms have no settled Twi equivalent.
+
+---
+
+## 6. Severity and urgency
+
+Severity is derived from the diseased-area ratio (Mode B) or returned by the server (Mode A) and is shown with a colour and an urgency level:
+
+| Severity | Colour | Urgency | Meaning |
+|---|---|---|---|
+| Early stage | 🟢 green | Routine | Small/localised (<~20% of leaf). Act soon. |
+| Moderate stage | 🟠 amber | Urgent | ~20–60% of leaf; can spread fast. Treat this week. |
+| Severe stage | 🔴 red | Emergency | >~60% affected. Act today. |
+
+Healthy results skip severity and show a "no disease detected — keep monitoring" panel instead.
+
+---
+
+## 7. Privacy
+
+No sign-up, no account, no analytics, no tracking. In Mode B the photo never leaves the device. In Mode A the photo is sent to the configured server only for the single prediction and is discarded there (the backend never writes it to disk). This matches the privacy-by-design intent of the report (§3.10/§3.13).
+
+---
+
+## 8. Deploying the HTML app
+
+Because it is one static file, hosting is trivial. Any of these work:
+
+- **Email / copy:** send `cropguard.html`; the recipient opens it on their phone.
+- **Static host:** GitHub Pages, Netlify, Vercel, Firebase Hosting, or any web server — just upload the file.
+- **Local:** open directly from storage (the camera/gallery inputs still work).
+
+To connect it to your trained model in production, host the FastAPI backend (see the backend documentation), enable HTTPS, and set `cropguard_api` to its URL. CORS is already open on the backend so the browser can call it.
+
+---
+
+## 9. Customising it
+
+- **Change treatment text / add a crop's advice:** edit the matching record in the `DATA.diseases` object (keep the `en`/`tw` shape, or just the one language in the single-language files). Class keys must match `recommendations.json` / `classes.json` so server predictions resolve to the right record.
+- **Point at a different server:** change `localStorage.cropguard_api`.
+- **Re-theme:** all colours are CSS variables at the top of the `<style>` block (`--leaf`, `--gold`, `--early/moderate/severe`, etc.).
+
+> If you add a brand-new crop, you must also add labelled training images and retrain the model (see the Dataset Guide and backend documentation) — the HTML app can *display* a new class, but only the trained model can *detect* it.
+
+---
+
+## 10. Limitations & browser support
+
+- **Mode B is an estimate, not the CNN** — see §4. For real diagnosis, connect the model.
+- **A photo that isn't a clear leaf** is caught by a "not a clear leaf" check and the user is asked to retake it.
+- **Very small lesions, extreme lighting, or a crop/disease not in the model** can still be misread — the disclaimer makes this clear.
+- **Browsers:** any current Chrome, Firefox, Safari or Edge (mobile or desktop). The camera capture uses the standard file-input `capture` attribute; on desktop without a camera it falls back to file selection.
+- **Connectivity:** Mode A needs internet to reach the server; Mode B needs none.

scripts/download_dataset.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+"""
+download_dataset.py — fetch the public datasets that make up the CropGuard corpus.
+
+What it does:
+  * Lists every source dataset with its licence and link.
+  * Attempts the Kaggle-hosted downloads automatically IF the Kaggle CLI is
+    configured (pip install kaggle, and ~/.kaggle/kaggle.json in place).
+  * Prints the Mendeley / GitHub links for the sets that must be downloaded by
+    hand (Mendeley serves a JS redirect, so scripted download is unreliable).
+
+It does NOT organise images into class folders — run prepare_dataset.py for that.
+
+Usage:
+    python download_dataset.py            # show the plan + try Kaggle downloads
+    python download_dataset.py --list     # just print the registry, download nothing
+    python download_dataset.py --out ./raw_downloads
+"""
+import argparse, os, shutil, subprocess, sys, textwrap
+
+# (name, kind, identifier, licence note)
+REGISTRY = [
+    ("CCMT (Cashew/Cassava/Maize/Tomato — collected in Ghana) [PRIMARY]",
+     "mendeley", "https://data.mendeley.com/datasets/bwh3zbpkpv/1",
+     "Mendeley, typically CC BY 4.0 — verify on page"),
+    ("PlantVillage (tomato, pepper, maize cross-checks)",
+     "kaggle-dataset", "abdallahalidev/plantvillage-dataset",
+     "Free for research — verify the mirror"),
+    ("Cassava Leaf Disease (Makerere) — source for cassava_cbsd",
+     "kaggle-competition", "cassava-leaf-disease-classification",
+     "Kaggle competition rules (research/educational)"),
+    ("MangoLeafBD (mango)",
+     "mendeley", "https://data.mendeley.com/datasets/hxsnvwty3r/1",
+     "CC BY 4.0 — verify"),
+    ("Rice Leaf Disease Image Samples (Sethy)",
+     "mendeley", "https://data.mendeley.com/datasets/fwcj7stb8r/1",
+     "CC BY 4.0 — verify"),
+    ("Groundnut Leaf Dataset (Sasmal)",
+     "mendeley", "https://data.mendeley.com/datasets/x6x5jkk873/2",
+     "CC BY 4.0 — verify"),
+    ("Cocoa Diseases YOLOv4 (black pod) — Kaggle",
+     "kaggle-dataset", "serranosebas/enfermedades-cacao-yolov4",
+     "Verify on page"),
+    ("KaraAgroAI Cocoa (CSSVD/healthy/anthracnose)",
+     "manual", "arXiv:2405.04535 — see the paper for the dataset repository link",
+     "Research/educational — verify"),
+    ("BananaLSD (plantain/banana — sigatoka, healthy)",
+     "manual", "Data in Brief S2352340923006959 (Kaggle mirrors exist; search 'BananaLSD')",
+     "CC BY 4.0 — verify"),
+]
+
+NOTE_LOCAL = textwrap.dedent("""
+    Crops that need LOCALLY COLLECTED images (weak/no public dataset):
+      cowpea (all classes), yam (all), okra (all), garden egg (all),
+      plantain_bbtv, plantain_panama, cocoa_capsid, pepper_anthracnose.
+    Photograph these in the field — extension officers / research stations can help.
+""")
+
+
+def kaggle_available():
+    return shutil.which("kaggle") is not None
+
+
+def try_kaggle(kind, ident, out):
+    if not kaggle_available():
+        print("    ! Kaggle CLI not found — skipping (pip install kaggle, add ~/.kaggle/kaggle.json)")
+        return
+    os.makedirs(out, exist_ok=True)
+    if kind == "kaggle-competition":
+        cmd = ["kaggle", "competitions", "download", "-c", ident, "-p", out]
+    else:
+        cmd = ["kaggle", "datasets", "download", "-d", ident, "-p", out]
+    print("    >", " ".join(cmd))
+    try:
+        subprocess.run(cmd, check=True)
+        print("    ✓ downloaded (unzip it inside the raw folder)")
+    except subprocess.CalledProcessError as e:
+        print(f"    ! Kaggle download failed ({e}). For competitions you must accept the rules on the website first.")
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--out", default="./raw_downloads")
+    ap.add_argument("--list", action="store_true", help="print the registry only")
+    args = ap.parse_args()
+
+    print("=" * 72)
+    print("CropGuard GH — dataset sources")
+    print("=" * 72)
+    for i, (name, kind, ident, lic) in enumerate(REGISTRY, 1):
+        print(f"\n[{i}] {name}")
+        print(f"    kind:    {kind}")
+        print(f"    source:  {ident}")
+        print(f"    licence: {lic}")
+        if args.list:
+            continue
+        if kind.startswith("kaggle"):
+            try_kaggle(kind, ident, args.out)
+        else:
+            print("    → download by hand from the link above into:", args.out)
+
+    print(NOTE_LOCAL)
+    print("Next: unzip everything into the raw folder, then run prepare_dataset.py")
+
+
+if __name__ == "__main__":
+    main()

scripts/prepare_dataset.py

@@ -0,0 +1,193 @@
+#!/usr/bin/env python3
+"""
+prepare_dataset.py — turn the downloaded raw datasets into the train/val/test
+folder tree that backend/train.py expects.
+
+Pipeline:
+  1. Read MAPPING below (raw subfolder  ->  CropGuard class key).
+  2. Copy every matched image into  <out>_flat/<class>/  .
+  3. Split each class 70/15/15 into  <out>/train|val|test/<class>/  .
+  4. Print a per-class count so you can see which classes are thin.
+
+IMPORTANT — you must edit the SOURCE PATHS in MAPPING to match where you
+actually unzipped each dataset. Mirror folder names differ slightly, so adjust
+the left-hand paths (relative to --raw) until they point at real folders.
+
+Usage:
+    python prepare_dataset.py --raw ./raw_downloads --out ./data
+    python prepare_dataset.py --raw ./raw_downloads --out ./data --check   # report only, copy nothing
+"""
+import argparse, os, random, shutil
+from collections import defaultdict
+
+random.seed(42)
+IMG_EXT = (".jpg", ".jpeg", ".png", ".bmp", ".webp")
+
+# ----------------------------------------------------------------------------
+# MAPPING: { class_key : [ list of raw subfolders (relative to --raw) ] }
+# Multiple source folders can feed one class; edit paths to match your unzip.
+# Folders that don't exist are simply skipped (with a warning), so it's safe to
+# fill in only the datasets you have downloaded so far.
+# ----------------------------------------------------------------------------
+MAPPING = {
+    # ---- Maize (CCMT + PlantVillage) ----
+    "maize_healthy":  ["CCMT/Maize/healthy", "plantvillage/Corn_(maize)___healthy"],
+    "maize_gls":      ["CCMT/Maize/leaf spot", "plantvillage/Corn_(maize)___Cercospora_leaf_spot Gray_leaf_spot"],
+    "maize_nclb":     ["CCMT/Maize/leaf blight", "plantvillage/Corn_(maize)___Northern_Leaf_Blight"],
+    "maize_rust":     ["plantvillage/Corn_(maize)___Common_rust_"],
+    "maize_msv":      ["CCMT/Maize/streak virus"],
+    "maize_faw":      ["CCMT/Maize/fall armyworm"],
+    # ---- Cassava (Cassava-Kaggle + CCMT) ----
+    "cassava_healthy":["cassava/healthy", "CCMT/Cassava/healthy"],
+    "cassava_cmd":    ["cassava/cmd", "CCMT/Cassava/mosaic"],
+    "cassava_cbsd":   ["cassava/cbsd"],
+    "cassava_cbb":    ["cassava/cbb", "CCMT/Cassava/bacterial blight"],
+    # ---- Tomato (CCMT + PlantVillage) ----
+    "tomato_healthy": ["CCMT/Tomato/healthy", "plantvillage/Tomato___healthy"],
+    "tomato_early":   ["plantvillage/Tomato___Early_blight"],
+    "tomato_late":    ["plantvillage/Tomato___Late_blight", "CCMT/Tomato/leaf blight"],
+    "tomato_wilt":    ["CCMT/Tomato/verticillium wilt"],
+    "tomato_septoria":["plantvillage/Tomato___Septoria_leaf_spot", "CCMT/Tomato/septoria"],
+    "tomato_tylcv":   ["plantvillage/Tomato___Tomato_Yellow_Leaf_Curl_Virus", "CCMT/Tomato/leaf curl"],
+    # ---- Cocoa (KaraAgroAI + Kaggle cocoa) ----
+    "cocoa_healthy":  ["cocoa/healthy"],
+    "cocoa_blackpod": ["cocoa/black_pod"],
+    "cocoa_cssvd":    ["cocoa/cssvd"],
+    "cocoa_capsid":   ["LOCAL/cocoa_capsid"],         # collect locally
+    # ---- Cashew (CCMT) ----
+    "cashew_healthy":    ["CCMT/Cashew/healthy"],
+    "cashew_anthracnose":["CCMT/Cashew/anthracnose"],
+    "cashew_gumosis":    ["CCMT/Cashew/gummosis"],
+    "cashew_leafminer":  ["CCMT/Cashew/leaf miner"],
+    # ---- Plantain (BananaLSD + local) ----
+    "plantain_healthy":  ["bananalsd/healthy"],
+    "plantain_sigatoka": ["bananalsd/sigatoka"],
+    "plantain_bbtv":     ["LOCAL/plantain_bbtv"],     # collect locally
+    "plantain_panama":   ["LOCAL/plantain_panama"],   # collect locally
+    # ---- Yam (local) ----
+    "yam_healthy":    ["LOCAL/yam_healthy"],
+    "yam_anthracnose":["LOCAL/yam_anthracnose"],
+    "yam_mosaic":     ["LOCAL/yam_mosaic"],
+    # ---- Pepper (PlantVillage + chili anthracnose/local) ----
+    "pepper_healthy":      ["plantvillage/Pepper,_bell___healthy"],
+    "pepper_bacterialspot":["plantvillage/Pepper,_bell___Bacterial_spot"],
+    "pepper_anthracnose":  ["LOCAL/pepper_anthracnose"],
+    # ---- Cowpea (local) ----
+    "cowpea_healthy":   ["LOCAL/cowpea_healthy"],
+    "cowpea_blight":    ["LOCAL/cowpea_blight"],
+    "cowpea_mosaic":    ["LOCAL/cowpea_mosaic"],
+    "cowpea_cercospora":["LOCAL/cowpea_cercospora"],
+    # ---- Groundnut (Sasmal) ----
+    "groundnut_healthy": ["groundnut/HEALTHY"],
+    "groundnut_leafspot":["groundnut/LEAF SPOT (EARLY AND LATE)"],
+    "groundnut_rosette": ["groundnut/ROSETTE"],
+    "groundnut_rust":    ["groundnut/RUST"],
+    # ---- Rice (Sethy + healthy source/local) ----
+    "rice_healthy":   ["LOCAL/rice_healthy"],
+    "rice_blast":     ["rice/Blast"],
+    "rice_blb":       ["rice/Bacterialblight"],
+    "rice_brownspot": ["rice/Brownspot"],
+    # ---- Okra (local) ----
+    "okra_healthy": ["LOCAL/okra_healthy"],
+    "okra_yvmv":    ["LOCAL/okra_yvmv"],
+    "okra_leafspot":["LOCAL/okra_leafspot"],
+    # ---- Garden egg (local) ----
+    "gardenegg_healthy": ["LOCAL/gardenegg_healthy"],
+    "gardenegg_wilt":    ["LOCAL/gardenegg_wilt"],
+    "gardenegg_leafspot":["LOCAL/gardenegg_leafspot"],
+    # ---- Mango (MangoLeafBD) ----
+    "mango_healthy":      ["mangoleafbd/Healthy"],
+    "mango_anthracnose":  ["mangoleafbd/Anthracnose"],
+    "mango_bacterialspot":["mangoleafbd/Bacterial Canker"],
+}
+
+
+def list_images(folder):
+    if not os.path.isdir(folder):
+        return []
+    out = []
+    for root, _, files in os.walk(folder):
+        for f in files:
+            if f.lower().endswith(IMG_EXT):
+                out.append(os.path.join(root, f))
+    return out
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--raw", default="./raw_downloads")
+    ap.add_argument("--out", default="./data")
+    ap.add_argument("--check", action="store_true", help="report counts only, copy nothing")
+    ap.add_argument("--val", type=float, default=0.15)
+    ap.add_argument("--test", type=float, default=0.15)
+    args = ap.parse_args()
+
+    flat = args.out + "_flat"
+    counts = {}
+    missing = []
+
+    for cls, sources in MAPPING.items():
+        imgs = []
+        for s in sources:
+            p = os.path.join(args.raw, s)
+            found = list_images(p)
+            if not found and not s.startswith("LOCAL/"):
+                missing.append((cls, s))
+            imgs += found
+        counts[cls] = len(imgs)
+        if args.check:
+            continue
+        # copy into flat/<cls>/
+        dst = os.path.join(flat, cls)
+        os.makedirs(dst, exist_ok=True)
+        for i, src in enumerate(imgs):
+            ext = os.path.splitext(src)[1].lower()
+            shutil.copy2(src, os.path.join(dst, f"{cls}_{i:05d}{ext}"))
+
+    # ---- split flat -> train/val/test ----
+    if not args.check:
+        for cls in MAPPING:
+            files = list_images(os.path.join(flat, cls))
+            random.shuffle(files)
+            n = len(files)
+            n_test = int(n * args.test)
+            n_val = int(n * args.val)
+            buckets = {
+                "test": files[:n_test],
+                "val": files[n_test:n_test + n_val],
+                "train": files[n_test + n_val:],
+            }
+            for split, fs in buckets.items():
+                d = os.path.join(args.out, split, cls)
+                os.makedirs(d, exist_ok=True)
+                for f in fs:
+                    shutil.copy2(f, os.path.join(d, os.path.basename(f)))
+
+    # ---- report ----
+    print("\nPer-class image counts:")
+    weak = []
+    for cls in MAPPING:
+        c = counts[cls]
+        tag = ""
+        if c == 0:
+            tag = "  <-- EMPTY (fix the source path, or collect images)"
+            weak.append(cls)
+        elif c < 100:
+            tag = "  <-- thin (<100); model will be weak here"
+            weak.append(cls)
+        print(f"  {cls:<22} {c:>6}{tag}")
+    print(f"\nTotal images: {sum(counts.values())}")
+    if missing:
+        print(f"\n{len(missing)} mapped source folder(s) not found — edit the paths in MAPPING:")
+        for cls, s in missing[:40]:
+            print(f"   {cls}: {s}")
+    if weak:
+        print(f"\n{len(weak)} class(es) empty or thin — collect local images for these before relying on them.")
+    if args.check:
+        print("\n(--check: nothing was copied)")
+    else:
+        print(f"\nDone. Train with:\n  cd backend && python train.py --data ../{os.path.basename(args.out)} --arch efficientnet")
+
+
+if __name__ == "__main__":
+    main()