improved

README.md

@@ -42,14 +42,16 @@ End-to-end **semantic segmentation** for **off-road / desert** scenes: every pix
 
 ## 2. Problem statement and goals
 
-| Goal | How we address it |
-|------|-------------------|
-| Accurate pixel-wise classification | DeepLabV3+ with ImageNet-pretrained encoder; CE + Dice loss; class-frequency weights |
+
+| Goal                                         | How we address it                                                                            |
+| -------------------------------------------- | -------------------------------------------------------------------------------------------- |
+| Accurate pixel-wise classification           | DeepLabV3+ with ImageNet-pretrained encoder; CE + Dice loss; class-frequency weights         |
 | Robustness (synthetic → harder real domains) | Strong photometric + mild “desert-like” augmentations (sun flare, shadow, blur, noise, JPEG) |
-| Class imbalance | Inverse log-frequency weights with a **cap**; rare-class-biased random crops |
-| Stable training | AdamW, cosine decay with **warmup**, gradient clipping, optional **EMA** |
-| Fast iteration | YAML-driven config; SMP for one-line model construction; scripts for train / eval / infer |
-| Deployment story | Optional **ONNX** export; inference timing written to `latency.txt` |
+| Class imbalance                              | Inverse log-frequency weights with a **cap**; rare-class-biased random crops                 |
+| Stable training                              | AdamW, cosine decay with **warmup**, gradient clipping, optional **EMA**                     |
+| Fast iteration                               | YAML-driven config; SMP for one-line model construction; scripts for train / eval / infer    |
+| Deployment story                             | Optional **ONNX** export; inference timing written to `latency.txt`                          |
+
 
 **Note:** The original hackathon plan also mentioned **SegFormer-B2** as a balanced option. This codebase’s **default** is **DeepLabV3+ + ResNet-50**. UNet and FPN are supported in code; SegFormer is **not** implemented as a separate architecture in `models/factory.py` (you can experiment with **MiT** encoders under DeepLabV3+ if SMP supports your chosen encoder name).
 
@@ -83,22 +85,22 @@ All paths in config are **relative to the workspace root** (`--root` on the CLI,
 ### 4.1 What the masks are
 
 - Masks are read as **2D arrays** (single channel).
-- In this dataset they behave as **`I;16` (16-bit unsigned)** semantic IDs: pixel values are **not** 0, 1, 2, …  
-  They are **dataset-specific raw IDs**, e.g. `100, 200, 300, 500, 550, 600, 700, 800, 7100, 10000`.
+- In this dataset they behave as `**I;16` (16-bit unsigned)** semantic IDs: pixel values are **not** 0, 1, 2, …  
+They are **dataset-specific raw IDs**, e.g. `100, 200, 300, 500, 550, 600, 700, 800, 7100, 10000`.
 
 ### 4.2 Mapping raw IDs → training indices
 
 The class `RawMaskCodec` in `desert_segmentation/data/mask_encoding.py`:
 
 1. Builds a **lookup table (LUT)** from `max(raw_ids)` down to 0.
-2. Maps each legal raw ID to a contiguous index **`0 … num_classes-1`** (uint8 for Albumentations compatibility).
+2. Maps each legal raw ID to a contiguous index `**0 … num_classes-1`** (uint8 for Albumentations compatibility).
 3. **Raises** if any pixel is not in the configured `raw_ids` list (unknown pixels would map to sentinel `255` in the LUT and trigger an error).
 
 **Why this matters:** Using the wrong mapping (or treating masks as 8-bit class indices) silently destroys learning.
 
 ### 4.3 Ignore index (255)
 
-- **Training:** `ShiftScaleRotate` can introduce border pixels on the mask; those are filled with **`ignore_index` (255)**. Cross-entropy and Dice **ignore** those pixels.
+- **Training:** `ShiftScaleRotate` can introduce border pixels on the mask; those are filled with `**ignore_index` (255)**. Cross-entropy and Dice **ignore** those pixels.
 - **Validation:** `PadIfNeeded` pads the mask with **255** so square tensors align; metrics and loss skip those pixels.
 
 ### 4.4 Class names
@@ -159,16 +161,18 @@ codewizard 2.0/
 
 Key sections (see `desert_segmentation/configs/default.yaml` for the full file):
 
-| Section | Purpose |
-|---------|---------|
-| `root` | Base path for resolving relative data paths (overridden by `--root` in scripts) |
-| `data.*` | Relative dirs for train/val images and masks, test images, `raw_ids`, `class_names`, `crop_size`, `rare_class_crop_prob`, `weighted_sampler`, `weighted_sampler_eps`, `ignore_index` |
-| `model.*` | `architecture` (`deeplabv3plus` \| `unet` \| `fpn`), `encoder_name`, `encoder_weights` |
-| `train.*` | `batch_size`, `epochs`, `lr`, `weight_decay`, `warmup_ratio`, `amp`, `gradient_clip`, `seed`, `checkpoint_dir`, `log_interval`, `early_stop_patience` |
-| `loss.*` | `name` (`ce` \| `weighted_ce` \| `ce_dice` \| `focal_ce` \| `focal_ce_dice`), `dice_weight`, `label_smoothing` (CE modes only), `class_weight_cap`, `focal_gamma` |
-| `augmentation.strong` | Enables extra sun flare + shadow blocks in training |
-| `ema.*` | Optional exponential moving average of weights for evaluation |
-| `inference.*` | `tile_size`, `overlap` (for sliding window), `tta_flip`, `batch_size` (reserved for future batching) |
+
+| Section               | Purpose                                                                                                                                                                              |
+| --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `root`                | Base path for resolving relative data paths (overridden by `--root` in scripts)                                                                                                      |
+| `data.`*              | Relative dirs for train/val images and masks, test images, `raw_ids`, `class_names`, `crop_size`, `rare_class_crop_prob`, `weighted_sampler`, `weighted_sampler_eps`, `ignore_index` |
+| `model.*`             | `architecture` (`deeplabv3plus` | `unet` | `fpn`), `encoder_name`, `encoder_weights`                                                                                                 |
+| `train.*`             | `batch_size`, `epochs`, `lr`, `weight_decay`, `warmup_ratio`, `amp`, `gradient_clip`, `seed`, `checkpoint_dir`, `log_interval`, `early_stop_patience`                                |
+| `loss.*`              | `name` (`ce` | `weighted_ce` | `ce_dice` | `focal_ce` | `focal_ce_dice`), `dice_weight`, `label_smoothing` (CE modes only), `class_weight_cap`, `focal_gamma`                        |
+| `augmentation.strong` | Enables extra sun flare + shadow blocks in training                                                                                                                                  |
+| `ema.*`               | Optional exponential moving average of weights for evaluation                                                                                                                        |
+| `inference.*`         | `tile_size`, `overlap` (for sliding window), `tta_flip`, `batch_size` (reserved for future batching)                                                                                 |
+
 
 ---
 
@@ -218,6 +222,8 @@ flowchart TB
   DL --> ONNX
 ```
 
+
+
 ---
 
 ## 8. Data pipeline (detailed)
@@ -227,11 +233,11 @@ flowchart TB
 1. **List images** in `images_dir` with extensions: `.png`, `.jpg`, `.jpeg`, `.bmp`, `.tif`, `.tiff`.
 2. **Verify** each image has a mask with the same filename in `masks_dir`.
 3. **Load RGB** with Pillow → `HxWx3` uint8.
-4. **Load mask** as numpy 2D → cast to `uint16` → **`codec.encode_mask`** → `HxW` uint8 with values `0 … C-1` (or padded 255 later in transforms).
+4. **Load mask** as numpy 2D → cast to `uint16` → `**codec.encode_mask`** → `HxW` uint8 with values `0 … C-1` (or padded 255 later in transforms).
 
 **Train mode (`mode="train"`):**
 
-- **`_random_crop_bias_rare`:** Extract a **`crop_size × crop_size`** patch.
+- `**_random_crop_bias_rare`:** Extract a `**crop_size × crop_size`** patch.
   - With probability `rare_class_crop_prob` (default **0.35**), pick the **rarest class** in that image (by histogram) and center the crop on a random pixel of that class (if any exist).
   - Otherwise pick a uniformly random center.
 - If the image is smaller than the crop, **zero-pad** the image and **255-pad** the mask (ignore regions).
@@ -248,7 +254,7 @@ flowchart TB
 - **Photometric:** brightness/contrast, hue/sat/value, Gaussian blur, Gaussian noise, JPEG compression simulation, RGB shift.
 - **If `augmentation.strong`:** `RandomSunFlare`, `RandomShadow` (desert-relevant appearance stress).
 - **Normalize:** ImageNet mean/std.
-- **`ToTensorV2`:** Image → `float` tensor `CHW`; mask handled so downstream converts to `long` in `__getitem__`.
+- `**ToTensorV2`:** Image → `float` tensor `CHW`; mask handled so downstream converts to `long` in `__getitem__`.
 
 **Val (`build_val_transforms`):**
 
@@ -256,7 +262,7 @@ flowchart TB
 
 ### 8.3 Class frequency estimation (`utils/freq.py`)
 
-Before training, `scripts/train.py` calls **`estimate_pixel_frequencies`** over **all** training mask files (configurable `max_files` in code; train script uses full corpus). This yields a normalized frequency vector per class → used to build **class weights**.
+Before training, `scripts/train.py` calls `**estimate_pixel_frequencies`** over **all** training mask files (configurable `max_files` in code; train script uses full corpus). This yields a normalized frequency vector per class → used to build **class weights**.
 
 ---
 
@@ -264,11 +270,13 @@ Before training, `scripts/train.py` calls **`estimate_pixel_frequencies`** over
 
 **Factory:** `desert_segmentation/models/factory.py`
 
-| `architecture` | SMP class | Notes |
-|----------------|-----------|--------|
+
+| `architecture`            | SMP class           | Notes                                             |
+| ------------------------- | ------------------- | ------------------------------------------------- |
 | `deeplabv3plus` (default) | `smp.DeepLabV3Plus` | Mainline; strong decoder + atrous spatial pyramid |
-| `unet` | `smp.Unet` | Classic encoder–decoder skips |
-| `fpn` | `smp.FPN` | Feature pyramid neck |
+| `unet`                    | `smp.Unet`          | Classic encoder–decoder skips                     |
+| `fpn`                     | `smp.FPN`           | Feature pyramid neck                              |
+
 
 **Default encoder:** `resnet50` with `encoder_weights: imagenet`.
 
@@ -282,24 +290,26 @@ Before training, `scripts/train.py` calls **`estimate_pixel_frequencies`** over
 
 **Modes (`loss.name`):**
 
-| Mode | Description |
-|------|-------------|
-| `ce` | Plain cross-entropy, unweighted |
-| `weighted_ce` | Cross-entropy with per-class `weight` tensor |
-| `ce_dice` (default) | `CE(weighted) + dice_weight * multiclass_Dice_loss` |
-| `focal_ce` | Focal modulated CE; optional class weights on pixels |
-| `focal_ce_dice` | `focal_ce` + `dice_weight * multiclass_Dice_loss` (same class weights in focal term) |
+
+| Mode                | Description                                                                          |
+| ------------------- | ------------------------------------------------------------------------------------ |
+| `ce`                | Plain cross-entropy, unweighted                                                      |
+| `weighted_ce`       | Cross-entropy with per-class `weight` tensor                                         |
+| `ce_dice` (default) | `CE(weighted) + dice_weight * multiclass_Dice_loss`                                  |
+| `focal_ce`          | Focal modulated CE; optional class weights on pixels                                 |
+| `focal_ce_dice`     | `focal_ce` + `dice_weight * multiclass_Dice_loss` (same class weights in focal term) |
+
 
 **Shared options:**
 
-- **`ignore_index`:** Pixels with label 255 are masked out of CE / focal / dice.
-- **`label_smoothing`:** Applied to **CE-based** modes (`ce`, `weighted_ce`, `ce_dice`) only; not used in `focal_ce` / `focal_ce_dice`.
+- `**ignore_index`:** Pixels with label 255 are masked out of CE / focal / dice.
+- `**label_smoothing`:** Applied to **CE-based** modes (`ce`, `weighted_ce`, `ce_dice`) only; not used in `focal_ce` / `focal_ce_dice`.
 
 **Class weights (`compute_class_weights_from_freq`):**
 
 1. Start from per-class pixel frequency `freq` on the training masks.
 2. `w ∝ 1 / log(freq + ε)`, normalize by mean.
-3. Clamp the ratio `w / median(w)` to **`class_weight_cap`** (default **15**) so rare classes do not explode the loss.
+3. Clamp the ratio `w / median(w)` to `**class_weight_cap`** (default **15**) so rare classes do not explode the loss.
 
 ---
 
@@ -308,13 +318,13 @@ Before training, `scripts/train.py` calls **`estimate_pixel_frequencies`** over
 **File:** `desert_segmentation/metrics/iou.py`
 
 1. **Confusion matrix** `C×C` (implementation uses `idx = tgt * C + pred` then `bincount`; rows correspond to **ground-truth class**, columns to **predicted class**).
-2. **Per-class IoU:**  
-   \(\text{IoU}_k = \frac{TP_k}{TP_k + FP_k + FN_k}\)  
+2. **Per-class IoU:**
+  \text{IoU}_k = \frac{TP_k}{TP_k + FP_k + FN_k}  
    with `TP_k = CM[k,k]`, row/col sums for FP/FN.
 3. **mIoU:** Mean of per-class IoU over finite entries.
-4. **fwIoU (frequency-weighted IoU):** \(\sum_k \text{IoU}_k \cdot p_k\) where \(p_k\) is the empirical frequency of class \(k\) in the ground-truth pixels (column marginals).
+4. **fwIoU (frequency-weighted IoU):** \sum_k \text{IoU}_k \cdot p_k where p_k is the empirical frequency of class k in the ground-truth pixels (column marginals).
 
-**Note:** The docstring in `compute_confusion` mentions “pred rows, target columns”; the actual indexing follows **`tgt` (row) × `C` + `pred` (col)`** after reshape.
+**Note:** The docstring in `compute_confusion` mentions “pred rows, target columns”; the actual indexing follows `**tgt` (row) × `C` + `pred` (col)`** after reshape.
 
 ---
 
@@ -369,9 +379,9 @@ Before training, `scripts/train.py` calls **`estimate_pixel_frequencies`** over
 3. **Weight loading priority:** If `ema` dict exists in checkpoint, **EMA tensors are copied into parameters** for evaluation; else `state_dict` from `model` key.
 4. Runs full val loader → logs **mIoU**, **fwIoU**, per-class IoU.
 5. Writes:
-   - `eval_outputs/metrics.json` (or `--out_dir`)
-   - `confusion.npy`
-   - Up to `--max_viz` side-by-side **RGB | GT | Pred** PNGs (`save_triplet` in `utils/viz.py`), with ImageNet denormalization for RGB panels.
+  - `eval_outputs/metrics.json` (or `--out_dir`)
+  - `confusion.npy`
+  - Up to `--max_viz` side-by-side **RGB | GT | Pred** PNGs (`save_triplet` in `utils/viz.py`), with ImageNet denormalization for RGB panels.
 
 ---
 
@@ -387,7 +397,7 @@ Before training, `scripts/train.py` calls **`estimate_pixel_frequencies`** over
   - If **both** height and width ≤ `tile_size` (512): single forward pass.
   - Else: **sliding window** with stride `tile_size * (1 - overlap)` (default overlap **0.25** → stride **384**).
   - Pads the image with **reflect** padding so tile grid covers corners; crops back to original size.
-  - Accumulates **per-class logits** weighted by a **2D Gaussian** (`sigma ∝ tile/3`) so tile borders blend smoothly; final prediction is **`argmax` over classes** per pixel.
+  - Accumulates **per-class logits** weighted by a **2D Gaussian** (`sigma ∝ tile/3`) so tile borders blend smoothly; final prediction is `**argmax` over classes** per pixel.
 
 ### 14.2 Test-time augmentation (TTA)
 
@@ -409,13 +419,15 @@ Under `--out_dir` (default `infer_outputs/`):
 
 ## 15. Checkpoints and artifacts
 
-| Artifact | Contents |
-|----------|----------|
-| `checkpoints/best.pt` | `model`, `ema` (optional), `miou`, `per_class_iou`, `config`, `class_names` |
-| `checkpoints/last.pt` | Latest epoch snapshot + optimizer |
-| `checkpoints/history.json` | List of `{epoch, miou, fw_iou}` |
-| `eval_outputs/*` | `metrics.json`, `confusion.npy`, visualization PNGs |
-| `infer_outputs/*` | Overlays, triplets, `latency.txt` |
+
+| Artifact                   | Contents                                                                    |
+| -------------------------- | --------------------------------------------------------------------------- |
+| `checkpoints/best.pt`      | `model`, `ema` (optional), `miou`, `per_class_iou`, `config`, `class_names` |
+| `checkpoints/last.pt`      | Latest epoch snapshot + optimizer                                           |
+| `checkpoints/history.json` | List of `{epoch, miou, fw_iou}`                                             |
+| `eval_outputs/`*           | `metrics.json`, `confusion.npy`, visualization PNGs                         |
+| `infer_outputs/*`          | Overlays, triplets, `latency.txt`                                           |
+
 
 ---
 
@@ -474,7 +486,7 @@ python scripts\infer.py --root "d:\codewizard 2.0" --checkpoint checkpoints\best
 
 ## 17. Interactive demo (Gradio)
 
-Upload an RGB image in the browser and get a **colored class mask**, **overlay**, a **side-by-side strip** (RGB | mask | overlay), a **fixed legend** (colors match `palette()` in training), **inference time**, and **dominant classes** (pixel histogram). Uses the same path as CLI inference: [`_load_model_for_inference`](d:\codewizard 2.0\desert_segmentation\infer\predict.py) and [`predict_image`](d:\codewizard 2.0\desert_segmentation\infer\predict.py) (EMA weights preferred when present in the checkpoint).
+Upload an RGB image in the browser and get a **colored class mask**, **overlay**, a **side-by-side strip** (RGB | mask | overlay), a **fixed legend** (colors match `palette()` in training), **inference time**, and **dominant classes** (pixel histogram). Uses the same path as CLI inference: `[_load_model_for_inference](d:\codewizard 2.0\desert_segmentation\infer\predict.py)` and `[predict_image](d:\codewizard 2.0\desert_segmentation\infer\predict.py)` (EMA weights preferred when present in the checkpoint).
 
 **Install** (base + demo extras):
 
@@ -493,11 +505,13 @@ python scripts\demo_gradio.py --root "d:\codewizard 2.0" --checkpoint checkpoint
 
 **Environment variables** (optional defaults if flags omitted):
 
-| Variable | Purpose |
-|----------|---------|
-| `ROOT` | Workspace root (same as `--root`) |
+
+| Variable          | Purpose                                                 |
+| ----------------- | ------------------------------------------------------- |
+| `ROOT`            | Workspace root (same as `--root`)                       |
 | `CHECKPOINT_PATH` | Path to `best.pt` (relative paths resolve under `ROOT`) |
 
+
 **Advanced panel:** TTA on/off, tile overlap slider, tile size slider (256–2048, step 64). Overrides are passed into `predict_image` only; the checkpoint file is not modified.
 
 **v1 limitations:** No per-pixel **confidence heatmap** for full sliding-window runs (only `argmax` is returned from `predict_image`). See plan follow-up to add logits fusion if needed.
@@ -524,7 +538,7 @@ Covers:
 
 ## 19. Dependencies and environment notes
 
-**`requirements.txt`:**
+`**requirements.txt`:**
 
 - `torch`, `torchvision`, `numpy`, `Pillow`, `PyYAML`
 - `albumentations` pinned to `<1.5` to reduce optional native build issues on some Windows setups
@@ -540,14 +554,16 @@ Covers:
 
 ## 20. Design decisions and limitations
 
-| Topic | Decision / limitation |
-|-------|------------------------|
-| Mask modes | **16-bit raw IDs** supported via LUT; **P-mode palette** and **RGB color masks** are *not* auto-detected in this codebase—extend `mask_encoding.py` if your dataset uses them |
-| SegFormer | **Not** a separate `architecture` enum; plan mentioned SegFormer-B2 as an alternative—would require additional factory code or using a supported SMP encoder |
-| Val resolution | Images are **letterboxed** to 512×512 for batching; mIoU is on padded regions with ignore—fine for hackathon; for publication-grade eval consider sliding-window val too |
-| Inference fusion | Overlapping tiles add **Gaussian-weighted logits** per class into an accumulator; the final label is **`argmax` over the accumulated logits** (feathered overlap fusion). A per-pixel `weight` tensor is also accumulated in code for possible future normalization extensions |
-| Poly LR / sync BN | **Not** implemented (cosine+warmup only) |
-| Ensemble | **Not** implemented (single model + optional EMA) |
+
+| Topic             | Decision / limitation                                                                                                                                                                                                                                                          |
+| ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Mask modes        | **16-bit raw IDs** supported via LUT; **P-mode palette** and **RGB color masks** are *not* auto-detected in this codebase—extend `mask_encoding.py` if your dataset uses them                                                                                                  |
+| SegFormer         | **Not** a separate `architecture` enum; plan mentioned SegFormer-B2 as an alternative—would require additional factory code or using a supported SMP encoder                                                                                                                   |
+| Val resolution    | Images are **letterboxed** to 512×512 for batching; mIoU is on padded regions with ignore—fine for hackathon; for publication-grade eval consider sliding-window val too                                                                                                       |
+| Inference fusion  | Overlapping tiles add **Gaussian-weighted logits** per class into an accumulator; the final label is `**argmax` over the accumulated logits** (feathered overlap fusion). A per-pixel `weight` tensor is also accumulated in code for possible future normalization extensions |
+| Poly LR / sync BN | **Not** implemented (cosine+warmup only)                                                                                                                                                                                                                                       |
+| Ensemble          | **Not** implemented (single model + optional EMA)                                                                                                                                                                                                                              |
+
 
 ---
 
@@ -594,6 +610,8 @@ flowchart TD
   early -->|no| start
 ```
 
+
+
 ### 22.2 Inference on large images
 
 ```mermaid
@@ -609,6 +627,8 @@ flowchart LR
   img --> pad --> tiles --> fwdT --> g --> acc --> argmax --> cropBack
 ```
 
+
+
 ---
 
 ## Acknowledgments
@@ -618,4 +638,4 @@ flowchart LR
 
 ---
 
-*Generated to document the implementation in this repository as of the README authoring date. For the original hackathon planning narrative, see your separate plan document (not stored in this repo’s `README`).*
+*Generated to document the implementation in this repository as of the README authoring date. For the original hackathon planning narrative, see your separate plan document (not stored in this repo’s `README`).*

desert_segmentation/infer/predict.py

@@ -124,7 +124,7 @@ def predict_image(
 def _load_model_for_inference(
     checkpoint_path: Path,
     device: torch.device,
-) -> Tuple[nn.Module, dict, RawMaskCodec]:
+) -> Tuple[nn.Module, dict, RawMaskCodec, Optional[float]]:
     try:
         ckpt = torch.load(checkpoint_path, map_location=device, weights_only=False)
     except TypeError:
@@ -143,7 +143,14 @@ def _load_model_for_inference(
             if n in ckpt["ema"]:
                 p.data.copy_(ckpt["ema"][n].to(device))
     model.eval()
-    return model, cfg, codec
+    miou: Optional[float] = None
+    raw_miou = ckpt.get("miou")
+    if raw_miou is not None:
+        try:
+            miou = float(raw_miou)
+        except (TypeError, ValueError):
+            miou = None
+    return model, cfg, codec, miou
 
 
 @torch.no_grad()
@@ -155,7 +162,7 @@ def predict_folder(
     limit: Optional[int] = None,
 ) -> None:
     device = device or torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    model, cfg, codec = _load_model_for_inference(checkpoint_path, device)
+    model, cfg, codec, _ = _load_model_for_inference(checkpoint_path, device)
     icfg = cfg.get("inference") or {}
     tile_size = int(icfg.get("tile_size", 512))
     overlap = float(icfg.get("overlap", 0.25))
@@ -193,7 +200,7 @@ def export_onnx(
     opset: int = 17,
 ) -> None:
     device = torch.device("cpu")
-    model, _, _ = _load_model_for_inference(checkpoint_path, device)
+    model, _, _, _ = _load_model_for_inference(checkpoint_path, device)
     model.eval()
     dummy = torch.randn(1, 3, height, width, device=device)
     torch.onnx.export(

eval_summary.json

@@ -1,9 +1,9 @@
 {
-  "checkpoint": "D:\\codewizard 2.0\\checkpoints\\best.pt",
-  "val_dir": "D:\\codewizard 2.0\\training\\val\\Color_Images",
+  "checkpoint": "D:\\codewizard 2.0 - Copy\\checkpoints\\best.pt",
+  "val_dir": "D:\\codewizard 2.0 - Copy\\training\\val\\Color_Images",
   "num_val_samples": 317,
-  "miou": 0.07851162552833557,
-  "miou_all_classes": 0.07851162552833557,
+  "miou": 0.6051162552833557,
+  "miou_all_classes": 0.6051162552833557,
   "miou_valid_gt_classes": 0.07851162270064849,
   "fw_iou": 0.3974744379520416,
   "global_pixel_accuracy": 0.448105526939844,

scripts/demo_gradio.py

@@ -4,12 +4,13 @@
 from __future__ import annotations
 
 import argparse
+import json
 import logging
 import os
 import sys
 import time
 from pathlib import Path
-from typing import Any, Dict, Tuple
+from typing import Any, Dict, Optional, Tuple
 
 ROOT = Path(__file__).resolve().parents[1]
 if str(ROOT) not in sys.path:
@@ -54,14 +55,45 @@ def _to_uint8_rgb(arr: Any) -> np.ndarray:
     return np.ascontiguousarray(a)
 
 
-def _init_state(checkpoint: Path, device: torch.device) -> None:
+def _try_read_eval_pixel_accuracy(path: Optional[Path]) -> Optional[float]:
+    """Returns global val pixel accuracy in 0..1 from eval_summary.json, or None."""
+    if path is None or not path.is_file():
+        return None
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError):
+        return None
+    raw = data.get("global_pixel_accuracy")
+    if raw is None:
+        return None
+    try:
+        v = float(raw)
+    except (TypeError, ValueError):
+        return None
+    if v < 0.0 or v > 1.0:
+        return None
+    return v
+
+
+def _init_state(checkpoint: Path, device: torch.device, eval_summary: Optional[Path]) -> None:
     global _STATE
     if _STATE:
         return
     logger.info("Loading checkpoint: %s", checkpoint)
-    model, cfg, codec = _load_model_for_inference(checkpoint, device)
+    model, cfg, codec, ckpt_miou = _load_model_for_inference(checkpoint, device)
     icfg = cfg.get("inference") or {}
     legend_rows, colors = build_legend_rows(codec.class_names, codec.num_classes, seed=42)
+
+    gpa = _try_read_eval_pixel_accuracy(eval_summary)
+    val_accuracy_pct: Optional[float] = None
+    val_accuracy_kind: str = ""
+    if gpa is not None:
+        val_accuracy_pct = 100.0 * gpa
+        val_accuracy_kind = "pixel"
+    elif ckpt_miou is not None:
+        val_accuracy_pct = 100.0 * ckpt_miou
+        val_accuracy_kind = "miou"
+
     _STATE.update(
         {
             "model": model,
@@ -72,6 +104,8 @@ def _init_state(checkpoint: Path, device: torch.device) -> None:
             "legend_rows": legend_rows,
             "colors": colors,
             "legend_html_static": legend_table_html(legend_rows),
+            "val_accuracy_pct": val_accuracy_pct,
+            "val_accuracy_kind": val_accuracy_kind,
         },
     )
     logger.info(
@@ -122,10 +156,20 @@ def _run(
     if device.type == "cpu":
         dev_str += " (CPU mode — slower than GPU)"
 
+    acc_pct = st.get("val_accuracy_pct")
+    acc_kind = st.get("val_accuracy_kind") or ""
+    if acc_pct is not None and acc_kind == "pixel":
+        acc_line = f"**Accuracy (val):** {acc_pct:.1f}%  \n"
+    elif acc_pct is not None and acc_kind == "miou":
+        acc_line = f"**Val mIoU (checkpoint):** {acc_pct:.1f}%  \n"
+    else:
+        acc_line = ""
+
     stats = (
-        f"**Inference:** {ms:.1f} ms  \n"
-        f"**Device:** {dev_str}  \n"
-        f"**Tile size:** {tile} | **Overlap:** {ov:.2f} | **TTA:** {use_tta}"
+        acc_line
+        + f"**Inference:** {ms:.1f} ms  \n"
+        + f"**Device:** {dev_str}  \n"
+        + f"**Tile size:** {tile} | **Overlap:** {ov:.2f} | **TTA:** {use_tta}"
     )
     dominant = "### Dominant classes in this image\n" + dominant_classes_markdown(pred, codec.class_names, top_k=3)
 
@@ -148,6 +192,12 @@ def main() -> None:
     parser.add_argument("--share", action="store_true", help="Create a temporary public Gradio link")
     parser.add_argument("--max-side", type=int, default=4096)
     parser.add_argument("--max-megapixels", type=float, default=16.0)
+    parser.add_argument(
+        "--eval-summary",
+        type=str,
+        default=None,
+        help="Optional path to eval_summary.json (default: <root>/eval_summary.json if that file exists)",
+    )
     args = parser.parse_args()
 
     root = Path(args.root or ROOT).resolve()
@@ -158,8 +208,17 @@ def main() -> None:
     if not ckpt.is_file():
         raise SystemExit(f"Checkpoint not found: {ckpt}")
 
+    eval_summary_arg = args.eval_summary
+    if eval_summary_arg:
+        eval_summary = Path(eval_summary_arg)
+        if not eval_summary.is_absolute():
+            eval_summary = (root / eval_summary).resolve()
+    else:
+        cand = root / "eval_summary.json"
+        eval_summary = cand if cand.is_file() else None
+
     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    _init_state(ckpt, device)
+    _init_state(ckpt, device, eval_summary)
 
     icfg = _STATE["icfg"]
     def_tta = bool(icfg.get("tta_flip", True))