docs/BACKEND_SYSTEM_DOCUMENTATION.md

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

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

{
  "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

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:

// 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)

# 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

# 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