From 069681cd6cbe65102865a141e12bfa569630476f Mon Sep 17 00:00:00 2001
From: Parv Maheshwari <parv.maheshwari@fieldai.com>
Date: Thu, 21 May 2026 23:05:31 +0000
Subject: [PATCH 1/2] Add RELLIS-3D evaluation harness + reproducibility note
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The released OTAS code does not include the multi-class evaluation script
that produced the RELLIS-3D Table V mIoU numbers. Only the single-(pos,
neg) -> binary-mask `single_inference` API is shipped, and there is no
RELLIS-3D dataset loader. This PR adds the missing pieces so the result
can be reproduced from a single OTAS checkout:

- own_eval/own_RELLIS.py: RELLIS-3D driver, with `--paper_config` to
  match the hyperparameters described in supplementary §VII.A.
- own_eval/rellis_dataset.py: PyTorch Dataset for RELLIS-3D's 20-class
  ontology.yaml ontology (also exposes the HRNet-19 `label_mapping`
  variant for completeness, default off).
- own_eval/eval_common.py: per-frame inference + confusion-matrix-pooled
  IoU, forwards arbitrary config_overrides to OTASEncoder.
- own_eval/otas_segmentor.py: N-way adapter that wraps
  `language_map.embed_image` -> per-class `clip_similarity` -> argmax.
  When `enable_mask_refinement=True`, delegates per-class refinement to
  OTAS's own `semantic_mask.binary_mask_refined(..., ret_dict=True)` so
  the SAM-on path reuses upstream code verbatim.
- docs/RELLIS_REPLICATION.md: PR description with the paper claim, our
  matching config, the result, the ruled-out hypotheses, and the
  remaining open questions for upstream.

Replication result: 15.43 mIoU under the §VII.A-matching config,
vs the paper Table V claim of 48.48 mIoU (DINOv2 ViT-S/14, no mask
refinement). ~32-point gap remains unexplained.

Also bundles a one-line MaskCLIP import fix (`import packaging.version`)
required to run on Python 3.12, and a `.gitignore` entry for the cached
eval outputs under `result/`.

See docs/RELLIS_REPLICATION.md for the full reproduction recipe and the
list of hypotheses we tested + the ones we cannot test without the
upstream eval script.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .gitignore                                  |   4 +-
 docs/RELLIS_REPLICATION.md                  | 149 ++++++++++++
 own_eval/eval_common.py                     | 219 +++++++++++++++++
 own_eval/otas_segmentor.py                  | 240 +++++++++++++++++++
 own_eval/own_RELLIS.py                      | 139 +++++++++++
 own_eval/rellis_dataset.py                  | 252 ++++++++++++++++++++
 src/foundation_models/maskclip_onnx/clip.py |   1 +
 7 files changed, 1003 insertions(+), 1 deletion(-)
 create mode 100644 docs/RELLIS_REPLICATION.md
 create mode 100644 own_eval/eval_common.py
 create mode 100644 own_eval/otas_segmentor.py
 create mode 100644 own_eval/own_RELLIS.py
 create mode 100644 own_eval/rellis_dataset.py

diff --git a/.gitignore b/.gitignore
index 35e3147..82f7847 100644
--- a/.gitignore
+++ b/.gitignore
@@ -191,4 +191,6 @@ cache/*
 
 # Example photos (they are big and should not be cloned by everyone using the repo)
 img/outdoor_reconstruction/*
-saved_maps/*
\ No newline at end of file
+saved_maps/*
+
+result/*
\ No newline at end of file
diff --git a/docs/RELLIS_REPLICATION.md b/docs/RELLIS_REPLICATION.md
new file mode 100644
index 0000000..d75d974
--- /dev/null
+++ b/docs/RELLIS_REPLICATION.md
@@ -0,0 +1,149 @@
+# RELLIS-3D Table V replication attempt
+
+## Summary
+
+This PR adds a self-contained RELLIS-3D evaluation harness to `own_eval/` (the `2D` semantic-segmentation track is not currently part of the released code, only ORFD via `own_GOD.py` analogues and TartanAir for the 3D track). We use the harness to attempt to replicate the published RELLIS-3D number from **Table V** of the paper.
+
+**Result:** a ~32-point mIoU gap that we have not been able to close.
+
+| Config | shared_feat_res | n_components | dinov2_input_size | input resize | mIoU (full, 20-cls) | fg-only mIoU |
+|---|---:|---:|---:|---|---:|---:|
+| OTAS default (`OTAS_small.json`-shaped) | 32 | 12 | 518 | 480×640 | **16.70** | 17.58 |
+| Paper §VII.A match (`--paper_config`) | **64** | **24** | **224** (16×16 native → bilinear-interp to 64×64) | **1024×1024** | **15.43** | 16.24 |
+| **Paper Table V claims (DINOv2 ViT-S/14)** | — | — | — | — | **48.48** | — |
+
+Both of our runs are zero-shot, no mask refinement, no negative prompt, all 20 RELLIS class names from the released `ontology.yaml` as positive prompts — matching the protocol described in §VII.A as closely as we can determine from the paper alone.
+
+## Why we believe the released code does not let us reproduce Table V
+
+The released OTAS repository ships:
+
+- `src/` — the OTAS core (`language_map`, `semantic_mask`, `single_inference.similarity_single`, mask refinement, etc.).
+- `src/inference.py:single_inference.similarity_single` — a single-(pos, neg) → single similarity map → optional binary mask pipeline. Designed for binary segmentation: "is this pixel `road` vs. `not road`".
+- `src/inference.py:single_inference.segmentation_single` — wraps `binary_mask_refined` / `binary_mask_interpolated`. Again, binary per (pos, neg) pair.
+- A `demo.ipynb` that exercises only the single-map binary segmentation API.
+
+The released code does **not** contain:
+
+- The N-way / multi-class evaluation script that produced the per-class mIoU in Table V. There is no `eval_rellis.py`, no `own_RELLIS.py`, no `eval_segmentation.py`. The only `__main__` entry points are the ROS 2 node and the demo notebook.
+- A `RELLIS_dataset` loader. ORFD and TartanAir loaders are similarly absent — Table III and Table II are also produced by code outside the public release.
+- A documented procedure for going from the (pos, neg)-binary similarity map to an N-class mIoU. §III.B describes the per-class scoring formula `Scombined = sum(pos_sims) - sum(neg_sims)`; §III.C describes the binary refinement to a single mask `M`. Neither directly answers "how is mIoU over 20 classes computed when you have 20 different positive prompts and no negative prompt?".
+
+So a reproduction effort has to (a) write an N-way adapter on top of OTAS's binary-flavoured API, (b) write a RELLIS-3D dataset loader, (c) make a judgment call about whether to argmax over per-class similarity maps or to threshold each one independently. We made the argmax choice (matches the natural interpretation of §III.B + §III.C with no mask refinement) and got 15.43–16.70 mIoU instead of 48.48.
+
+## What this PR adds
+
+| File | Purpose |
+|---|---|
+| `own_eval/own_RELLIS.py` | RELLIS-3D driver. CLI: `--paper_config` reproduces the §VII.A hyperparameters; `--enable_mask_refinement` toggles SAM2; `--ontology raw20\|hrnet19` switches the class set. |
+| `own_eval/rellis_dataset.py` | RELLIS-3D PyTorch `Dataset`. Parses `test.lst` / `val.lst` / `train.lst` (2-col `<img> <label>` per line), reads RGB jpg + uint8 label-id PNG, applies the unknown-incl 20-class LUT from `ontology.yaml` (raw 0/1/3/…/34 → contig 0..19). Also ships an inactive `hrnet19` ontology option that mirrors the canonical 2D RELLIS benchmark `label_mapping` from `benchmarks/HRNet-Semantic-Segmentation-HRNet-OCR/lib/datasets/rellis.py`. |
+| `own_eval/eval_common.py` | Per-frame inference loop, confusion-matrix-pooled IoU, results.txt + cached preds. Forwards arbitrary `config_overrides` dict to `OTASEncoder` so the SAM toggle and the §VII.A hyperparameters can be set per-run. |
+| `own_eval/otas_segmentor.py` | The N-way `OTASEncoder` adapter. Inlines `language_map.embed_image → per-class clip_similarity → bilinear up → argmax`. When `enable_mask_refinement=True`, delegates per-class refinement to OTAS's own `semantic_mask.binary_mask_refined(..., ret_dict=True)` then argmaxes across the SAM `pred_logits` (so the SAM-on path reuses upstream code verbatim, with only the N-class argmax on top). |
+| `docs/RELLIS_REPLICATION.md` | This file. |
+| `src/foundation_models/maskclip_onnx/clip.py` | One-line bugfix: `import packaging.version` (the file uses `packaging.version.parse(...)` but didn't import the submodule explicitly). Required for the MaskCLIP pipeline to import on Python 3.12. |
+| `.gitignore` | Adds `result/*` so the cached per-frame predictions don't accidentally get committed. |
+
+## How to reproduce locally
+
+### Prerequisites
+
+- Python 3.12 venv with the OTAS `requirements.txt` installed.
+- DINOv2 + CLIP + SAM2 checkpoints downloaded via `bash download_checkpoints.sh`.
+- RELLIS-3D dataset (RGB images + ID-format labels + split lists) extracted under a single root, e.g. `/home/ubuntu/mnt/rellis_3d/Rellis-3D`. After extraction the layout is:
+
+  ```
+  Rellis-3D/
+    train.lst   val.lst   test.lst
+    00000/   00001/  00002/  00003/  00004/
+      pylon_camera_node/             # RGB .jpg, 1920×1200
+      pylon_camera_node_label_id/    # uint8 label-id .png, 1920×1200
+  ```
+
+  The 4 Google Drive archives needed (per the upstream `unmannedlab/RELLIS-3D` README) are: Full Images (11 GB), Full Image Annotations ID Format (94 MB), Image Split File (44 KB), Ontology Definition (18 KB).
+
+### Reproducing the 16.70 number (OTAS repo defaults)
+
+```bash
+cd /path/to/OTAS
+env -u LD_LIBRARY_PATH .venv/bin/python own_eval/own_RELLIS.py \
+    --data_dir /path/to/Rellis-3D
+```
+
+Output lands at `result/Pred/RELLIS_rgb/`. The headline `full_mIoU` is written to `results.txt`.
+
+The `env -u LD_LIBRARY_PATH` prefix forces the cu132 torch wheel's bundled cuBLAS to win over the system `/usr/local/cuda-*` library on Blackwell GPUs; without it MaskCLIP's forward passes fail with `cublasLtGetVersion` symbol errors. Drop it on other GPU/CUDA combinations.
+
+### Reproducing the 15.43 number (§VII.A paper-matching config)
+
+```bash
+env -u LD_LIBRARY_PATH .venv/bin/python own_eval/own_RELLIS.py \
+    --data_dir /path/to/Rellis-3D \
+    --paper_config
+```
+
+`--paper_config` sets `shared_feat_resolution=64`, `n_components=24`, `dinov2_input_size=224`, and bumps the dataset's PIL resize to `1024×1024` — matching everything we can determine from the supplementary material §VII.A "RELLIS-3D" paragraph. `k=24` is already the OTAS default. Mask refinement stays off and there is no negative prompt.
+
+Output lands at `result/Pred/RELLIS_rgb_paper/`.
+
+## What we have ruled out
+
+Each hypothesis below was tested by running OTAS with the variant config and checking whether `full_mIoU` moved meaningfully toward 48.48:
+
+| Hypothesis | Tested? | Result |
+|---|---|---|
+| HRNet 19-class `label_mapping` (collapse void+dirt) | Available behind `--ontology hrnet19`; not the paper's setting per §VII.A | Paper explicitly says "All prompts are class names in RELLIS-3D's included ontology file" — that's the 20-name `ontology.yaml`, not HRNet's 19-class remap. |
+| `shared_feat_resolution = 64` | Yes | Moves mIoU ~−1 (16.70 → 15.43 when combined). |
+| `n_components = 24` (PCA `Cr`) | Yes (combined with d=64) | No big jump. |
+| `dinov2_input_size = 224` (DINOv2 native 16×16 grid, bilinear-interp to d=64) | Yes (same combined run) | No big jump. |
+| Input image resize to 1024×1024 (per §VII.A) | Yes | No big jump. |
+| Mask refinement off | Confirmed | Both our runs and the paper Table V have it off. |
+| Negative prompt of `"thing"` | Tested as a sanity check; this is the §IV.D traversability protocol, **not** Table V (clarified by paper authors) | N/A for Table V. |
+| Threshold-at-0.8 binary scoring (also §IV.D traversability) | Not Table V | N/A. |
+
+## What we have not been able to test
+
+Three remaining hypotheses for the residual ~32-point gap:
+
+1. **Per-frame vs pooled mIoU.** We accumulate one confusion matrix across all 1672 test-split frames and compute mIoU once over the totals. Some papers compute mIoU per-frame and average across frames; on a sparse-class dataset like RELLIS-3D this can swing the headline by 10+ points because frames missing a class don't contribute a 0 to that class's score. The paper does not specify which averaging convention it uses for Table V.
+
+2. **Test-split version.** We use `test.lst` from the 44 KB Image Split File archive on the upstream RELLIS-3D Google Drive, which contains 1672 lines in 2-column `<image_path> <label_path>` format. We cannot tell whether the paper uses this same `test.lst`, a different release of it, or a curated subset.
+
+3. **Some internal OTAS pipeline detail not visible in the public code.** The released `single_inference` API is single-(pos, neg) → binary; the multi-class mIoU pipeline that produced Table V is not in the public release, so we cannot inspect it for subtle differences (averaging convention, prompt encoding, similarity normalisation reset between classes, etc.).
+
+## Ask for the upstream maintainers
+
+To close this gap unambiguously, it would be very helpful to release **the exact evaluation script that produced Table V**. Specifically:
+
+1. The N-way → mIoU pipeline (argmax across per-class similarity maps? threshold per class? something else?).
+2. The mIoU averaging convention (per-frame vs pooled).
+3. The dataset loader's exact split file and any preprocessing it applies.
+4. The `OTAS_*.json` config file used for Table V specifically (the `OTAS_small.json` shipped in `src/model_config/` has `enable_mask_refinement: true` and `shared_feat_resolution: 16`, neither of which matches §VII.A).
+
+Even a minimal `eval_rellis.py` analogous to the released `demo.ipynb` — with the same configuration that produced 48.48 mIoU — would let downstream users verify the published number on their own RELLIS-3D copy. We're happy to fold our `own_RELLIS.py` into the existing scaffolding if that's the right approach, or rewrite it on top of an official `eval_rellis.py` once released.
+
+## Verification
+
+After this PR is applied to a fresh OTAS checkout, the following sequence should reproduce both numbers in the table at the top:
+
+```bash
+# 1. Setup
+git clone <this-fork>; cd otas
+python3.12 -m venv .venv
+.venv/bin/pip install -r requirements.txt
+bash download_checkpoints.sh
+
+# 2. Stage RELLIS-3D under /path/to/Rellis-3D (see "Prerequisites" above)
+
+# 3. Default-config run (target: ~16.70 full mIoU on test.lst)
+env -u LD_LIBRARY_PATH .venv/bin/python own_eval/own_RELLIS.py \
+    --data_dir /path/to/Rellis-3D
+cat result/Pred/RELLIS_rgb/results.txt | grep -E "full_mIoU|fg_only_mIoU"
+
+# 4. Paper-config run (target: ~15.43 full mIoU)
+env -u LD_LIBRARY_PATH .venv/bin/python own_eval/own_RELLIS.py \
+    --data_dir /path/to/Rellis-3D \
+    --paper_config
+cat result/Pred/RELLIS_rgb_paper/results.txt | grep -E "full_mIoU|fg_only_mIoU"
+```
+
+Numbers should match within ±0.5 mIoU on Blackwell (RTX PRO 6000) with the cu132 torch wheel. Other GPU/CUDA combinations may shift slightly but should still land well below the paper's 48.48 claim.
diff --git a/own_eval/eval_common.py b/own_eval/eval_common.py
new file mode 100644
index 0000000..79a29ce
--- /dev/null
+++ b/own_eval/eval_common.py
@@ -0,0 +1,219 @@
+# Shared evaluation loop for OTAS on the unified 6-dataset scoreboard.
+#
+# Provides one entry point — `run_eval(dataset, class_names, out_dir, modality)` — that
+# every per-dataset script (own_GOD.py, own_BASEPROD.py, …) wraps with the dataset-
+# specific class list and DataLoader. The point of pulling this out is so the modality
+# handling, OTAS inference, prediction caching, and IoU metric computation are written
+# once and identical across all six datasets — matching the convention RADSeg's
+# eval.py and OpenRSS's own_*.py use, except deduplicated.
+#
+# Modality contract:
+#   The OpenRSS datasets we re-use yield `(image_f, label, name, th_vis)` where
+#   `image_f` is a (4, H, W) float tensor in [0, 1] with channels [R, G, B, T].
+#   For OTAS (which is RGB-trained DINOv2 + MaskCLIP) we expose two modalities:
+#     - "rgb":     pass channels [R, G, B] through OTAS unchanged.
+#     - "thermal": replicate channel T to 3 channels (R = G = B = T) — mirrors how
+#                  RADSeg's "thermal" column is generated. DINOv2 is out-of-distribution
+#                  on thermal, which is the whole point of the comparison.
+#
+# Output layout (per dataset × modality):
+#   <out_dir>/preds/<name>.png            uint8 grayscale, per-pixel class IDs.
+#   <out_dir>/results.txt                 full + fg-only mIoU and per-class IoU.
+#   <out_dir>/overlays/<sampled_names>.png   3-up [input | gt | pred] panels for a
+#                                            sparse sample (visual sanity only).
+
+import os
+import sys
+import time
+from pathlib import Path
+from typing import List, Optional
+
+import numpy as np
+from PIL import Image
+import torch
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+
+# Make sibling otas_segmentor importable when invoked as `python -m own_eval.own_GOD`
+# from the OTAS root, or as `python own_eval/own_GOD.py` directly.
+_OWN_EVAL_DIR = str(Path(__file__).resolve().parent)
+if _OWN_EVAL_DIR not in sys.path:
+    sys.path.insert(0, _OWN_EVAL_DIR)
+
+
+def _tensor_to_pil_rgb(image_f: torch.Tensor) -> Image.Image:
+    # image_f: (4, H, W) float in [0, 1] from the OpenRSS DataLoader.
+    # Returns a PIL RGB image of the first 3 (RGB) channels.
+    rgb = image_f[:3].numpy()
+    rgb_u8 = (np.clip(rgb, 0.0, 1.0) * 255.0).astype(np.uint8).transpose(1, 2, 0)
+    return Image.fromarray(rgb_u8, mode="RGB")
+
+
+def _tensor_to_pil_thermal_as_rgb(image_f: torch.Tensor) -> Image.Image:
+    # Replicate the thermal channel (image_f[3]) to a 3-channel PIL RGB so DINOv2's
+    # ImageNet-mean normalization sees plausible-ish R = G = B input. This matches
+    # RADSeg's "thermal" treatment exactly — same image stream, different model
+    # encoder.
+    th = image_f[3].numpy()
+    th_u8 = (np.clip(th, 0.0, 1.0) * 255.0).astype(np.uint8)
+    th_rgb = np.stack([th_u8, th_u8, th_u8], axis=-1)
+    return Image.fromarray(th_rgb, mode="RGB")
+
+
+def _iou_per_class(conf: np.ndarray) -> np.ndarray:
+    # Symmetric IoU = TP / (TP + FP + FN) per class, derived from a (N, N) confusion
+    # matrix where rows are ground-truth and columns are predictions. Returns NaN for
+    # any class that has zero presence in both gt and prediction (so it doesn't drag
+    # the mean down to zero artificially).
+    tp = np.diag(conf).astype(np.float64)
+    fp = conf.sum(axis=0) - tp
+    fn = conf.sum(axis=1) - tp
+    denom = tp + fp + fn
+    iou = np.where(denom > 0, tp / np.maximum(denom, 1e-12), np.nan)
+    return iou
+
+
+def _save_palette_overlay(pred: np.ndarray, n_classes: int, out_path: Path):
+    # Save a deterministic-palette overlay of `pred` (uint8 class IDs) as RGB PNG.
+    # tab20 cycles for n_classes > 20; for our 5–22 class range this is fine.
+    from matplotlib import cm
+    cmap = cm.get_cmap("tab20", max(n_classes, 20))
+    palette = (np.array([cmap(i)[:3] for i in range(max(n_classes, 20))]) * 255).astype(np.uint8)
+    overlay = palette[pred]  # (H, W, 3)
+    Image.fromarray(overlay).save(out_path)
+
+
+def _save_3up(rgb_pil: Image.Image, gt: np.ndarray, pred: np.ndarray,
+              n_classes: int, out_path: Path):
+    # Side-by-side: input RGB | GT palette | Pred palette. Used for a sparse sample
+    # of frames so we can eyeball alignment / failure modes without needing all
+    # overlays on disk.
+    from matplotlib import cm
+    cmap = cm.get_cmap("tab20", max(n_classes, 20))
+    palette = (np.array([cmap(i)[:3] for i in range(max(n_classes, 20))]) * 255).astype(np.uint8)
+
+    h, w = pred.shape
+    rgb_np = np.asarray(rgb_pil.resize((w, h)))
+    # Treat any GT id >= n_classes (e.g. 255 ignore) as a black pixel rather than
+    # crashing the palette lookup.
+    gt_safe = np.where(gt < n_classes, gt, 0).astype(np.uint8)
+    gt_paint = palette[gt_safe]
+    pred_paint = palette[pred]
+    panel = np.concatenate([rgb_np, gt_paint, pred_paint], axis=1)
+    Image.fromarray(panel).save(out_path)
+
+
+def run_eval(
+    dataset,
+    class_names: List[str],
+    out_dir: str,
+    modality: str,
+    *,
+    num_overlay_samples: int = 12,
+    ignore_label: int = 255,
+    config_overrides: Optional[dict] = None,
+):
+    # Args:
+    #   dataset:      a torch Dataset that yields (image_f (4,H,W), label (H,W),
+    #                 name (str), th_vis (3,H,W)). The OpenRSS dataset adapters
+    #                 satisfy this contract.
+    #   class_names:  list of N strings. class_names[0] MUST be "unknown".
+    #   out_dir:      where to write preds/, overlays/, results.txt.
+    #   modality:     "rgb" or "thermal" (= thermal-as-RGB replica).
+    #   num_overlay_samples: how many frames to emit 3-up overlays for. The full
+    #                        preds/ dir always has every frame, but overlays are
+    #                        sparse so we don't drown the disk.
+    #   ignore_label: GT pixel value to treat as ignore (not counted in IoU). 255
+    #                 by default — matches the OpenRSS dataset convention.
+    #   config_overrides: optional dict of OTAS config keys to override (e.g.
+    #                 {"enable_mask_refinement": True} to turn SAM2 on). Forwarded
+    #                 verbatim to OTASEncoder; see otas_segmentor._DEFAULT_CONFIG.
+    assert modality in {"rgb", "thermal"}, f"modality must be rgb|thermal, got {modality!r}"
+
+    # Import the encoder here so OTAS only loads once per process (and not at module
+    # import time, which would prevent us from setting env vars first).
+    from otas_segmentor import OTASEncoder
+
+    out_dir = Path(out_dir)
+    preds_dir = out_dir / "preds"
+    overlays_dir = out_dir / "overlays"
+    preds_dir.mkdir(parents=True, exist_ok=True)
+    overlays_dir.mkdir(parents=True, exist_ok=True)
+
+    n_classes = len(class_names)
+    encoder = OTASEncoder(class_names=class_names, config_overrides=config_overrides)
+
+    # We deliberately keep batch_size=1 because OTAS's language_map operates on PIL
+    # images one at a time (DINOv2 forward is autograd-disabled but not batched in
+    # OTAS's reference path).
+    loader = DataLoader(dataset, batch_size=1, num_workers=0, shuffle=False)
+    n_frames = len(dataset)
+
+    # Pick `num_overlay_samples` evenly-spaced indices for the qualitative panels.
+    overlay_indices = set(np.linspace(0, n_frames - 1, num=num_overlay_samples, dtype=int).tolist())
+
+    conf = np.zeros((n_classes, n_classes), dtype=np.int64)
+    t0 = time.time()
+
+    chosen = (
+        _tensor_to_pil_rgb if modality == "rgb" else _tensor_to_pil_thermal_as_rgb
+    )
+    pbar = tqdm(loader, desc=f"OTAS[{modality}] {out_dir.name}", total=n_frames)
+    for idx, batch in enumerate(pbar):
+        image_f, label, name, _th_vis = batch
+        # DataLoader collates to a leading batch dim of 1 — strip it.
+        image_f = image_f.squeeze(0)        # (4, H, W) float
+        label_np = label.squeeze(0).numpy()  # (H, W) int64
+        # `name` may be a list (DataLoader collates strings) — pull out the scalar.
+        if isinstance(name, (list, tuple)):
+            name = name[0]
+        name = str(name)
+
+        pil = chosen(image_f)
+        preds, _probs = encoder.predict(pil)  # uint8 (H, W)
+
+        # Bucket into the conf matrix, excluding ignore-label pixels.
+        valid = label_np != ignore_label
+        if valid.any():
+            gt_valid = label_np[valid]
+            pred_valid = preds[valid]
+            # Clip just in case — preds are already in [0..n_classes-1] but defensive.
+            gt_valid = np.clip(gt_valid, 0, n_classes - 1)
+            pred_valid = np.clip(pred_valid, 0, n_classes - 1)
+            bin_idx = gt_valid * n_classes + pred_valid
+            counts = np.bincount(bin_idx, minlength=n_classes * n_classes)
+            conf += counts.reshape(n_classes, n_classes)
+
+        # Cache pred PNG (uint8 grayscale) — argmax IDs, no palette, so any
+        # downstream tool can re-paint with its own palette.
+        Image.fromarray(preds).save(preds_dir / f"{name}.png")
+
+        if idx in overlay_indices:
+            _save_3up(pil, label_np, preds, n_classes, overlays_dir / f"{name}.png")
+
+    elapsed = time.time() - t0
+    iou = _iou_per_class(conf)
+    full_miou = np.nanmean(iou)
+    fg_miou = np.nanmean(iou[1:])  # excludes the 'unknown' class at contig 0
+
+    # Write a single results.txt that's grep-friendly for the scoreboard updater.
+    with open(out_dir / "results.txt", "w") as f:
+        f.write(f"# OTAS eval — {out_dir.name}\n")
+        f.write(f"modality: {modality}\n")
+        f.write(f"n_frames: {n_frames}\n")
+        f.write(f"n_classes: {n_classes}\n")
+        f.write(f"elapsed_seconds: {elapsed:.1f}\n")
+        f.write(f"full_mIoU: {full_miou * 100:.4f}\n")
+        f.write(f"fg_only_mIoU: {fg_miou * 100:.4f}\n")
+        f.write("\nper_class_IoU:\n")
+        for name, val in zip(class_names, iou):
+            val_str = "nan" if np.isnan(val) else f"{val * 100:.4f}"
+            f.write(f"  {name}: {val_str}\n")
+        f.write("\nconfusion_matrix_rows_gt_cols_pred:\n")
+        for row in conf:
+            f.write("  " + " ".join(str(int(c)) for c in row) + "\n")
+
+    print(f"[{out_dir.name}] full mIoU = {full_miou * 100:.2f}%, "
+          f"fg-only mIoU = {fg_miou * 100:.2f}% "
+          f"({n_frames} frames, {elapsed:.0f}s)")
+    return {"full_mIoU": full_miou, "fg_only_mIoU": fg_miou, "iou_per_class": iou}
diff --git a/own_eval/otas_segmentor.py b/own_eval/otas_segmentor.py
new file mode 100644
index 0000000..e32b942
--- /dev/null
+++ b/own_eval/otas_segmentor.py
@@ -0,0 +1,240 @@
+# Multi-class semantic-segmentation adapter for OTAS.
+#
+# Purpose:
+#   OTAS's public API (`single_inference.similarity_single`) takes a list of `pos_prompts` and
+#   `neg_prompts` and collapses them to a single per-pixel similarity map via
+#   `mean(pos_sims) - mean(neg_sims)` (see src/model.py:semantic_mask.similarity). That shape
+#   is binary-flavoured: one score map per (pos, neg) prompt set, then thresholded.
+#
+#   To compare OTAS against RADSeg / OpenRSS on the unified 6-dataset scoreboard we need
+#   per-pixel N-way argmax across 5–22 classes (one of which is the unified `unknown` at
+#   contig 0). This adapter bypasses the aggregation step and instead:
+#
+#       1. Runs OTAS's language_map once per image, producing a pooled
+#          (shared_feat_resolution, shared_feat_resolution, 512) embedding map.
+#       2. Encodes each of the N class names through MaskCLIP — using the BARE class string
+#          only, no prompt template (no "a photo of …"), no negative prompts.
+#       3. Calls OTAS's lower-level `clip_similarity` einsum per class, producing N low-res
+#          (H_lr, W_lr) similarity maps.
+#       4. Stacks them to (N, H_lr, W_lr), bilinear-upsamples to (N, H, W) (the same step
+#          OTAS's `similarity_single` already uses for its single-map case), then argmaxes
+#          across the class axis to get a (H, W) uint8 prediction tensor.
+#
+# Prompt-format rationale (user-specified for this evaluation):
+#   - Bare class names, no template. RADSeg uses an imagenet-style 20-variant template,
+#     OpenRSS uses `"a pohot of "` (sic). Each system gets the prompt format the user
+#     specified for it; we do not apply templates that weren't part of OTAS's design.
+#   - No negative prompts. Argmax across all N positive prompts (one of which is
+#     `"unknown"` at contig 0) is the entire scoring rule.
+#   - SAM2 mask refinement is off (matches RADSeg / OpenRSS which have no post-processing).
+#
+# Output contract:
+#   `OTASEncoder.predict(pil_img)` returns `(preds, probs)` where
+#       preds: np.uint8 (H, W)        per-pixel argmax class IDs in [0..N-1]
+#       probs: np.float32 (H, W, N)   raw cosine similarities (NOT softmaxed; used only for
+#                                     downstream introspection / saved overlays).
+#   The output shape matches RADSeg's `(seg_probs, seg_preds)` ordering so per-dataset
+#   eval scripts can mirror the RADSeg / OpenRSS scaffolding one-for-one.
+
+import os
+import sys
+import json
+import copy
+from pathlib import Path
+from typing import List, Tuple, Optional
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from PIL import Image
+
+# OTAS's `src/` is not a package; add it to sys.path so `import model` resolves to OTAS's
+# model.py, not torchvision.models or any other shadowing module.
+_OTAS_SRC = str(Path(__file__).resolve().parent.parent / "src")
+if _OTAS_SRC not in sys.path:
+    sys.path.insert(0, _OTAS_SRC)
+
+
+_DEFAULT_CONFIG = {
+    # SAM2 + Open3D / spatial reconstruction off — we only want the 2D semantic head.
+    "enable_mask_refinement": False,
+    "enable_spatial": False,
+    # Model compilation is broken on some torch.compile + Blackwell combinations and
+    # only matters for repeated calls inside a single process. Disable for stability.
+    "enable_model_compilation": False,
+    # Default-resolution head from OTAS's repo config (matches OTAS_small.json for size
+    # but lifts shared_feat_resolution to 32 for better per-pixel detail before the
+    # bilinear upsample to original resolution).
+    "dinov2_input_size": 518,
+    "dino_scale_factor": 2,
+    "shared_feat_resolution": 32,
+    "n_clusters": 24,
+    "n_components": 12,
+    "enable_amp_autocast": True,
+}
+
+
+def _write_temp_config(custom_overrides: Optional[dict] = None) -> str:
+    # OTAS picks up config overrides via the OTAS_CONFIG_PATH env var, which it parses as a
+    # JSON file. Write our overrides to a tempfile and return the path; OTAS keys not present
+    # here fall back to src/config.py defaults.
+    cfg = copy.deepcopy(_DEFAULT_CONFIG)
+    if custom_overrides:
+        cfg.update(custom_overrides)
+    cfg_path = Path("/tmp") / f"otas_adapter_cfg_{os.getpid()}.json"
+    cfg_path.write_text(json.dumps(cfg))
+    return str(cfg_path)
+
+
+class OTASEncoder:
+    # Instantiate once with the dataset's class list, then call .predict(pil_img) per frame.
+    #
+    # The class list must include the unified `"unknown"` token at index 0 (matching the
+    # RADSeg / OpenRSS scoreboard convention). The rest are bare foreground class names from
+    # the dataset's ontology (e.g. `"grass"`, `"trees"`, `"sky"`, …) — they are encoded with
+    # CLIP's text encoder as-is, with no prompt template applied.
+    def __init__(self, class_names: List[str], config_overrides: Optional[dict] = None):
+        assert len(class_names) >= 2, "Need at least 2 classes for argmax to be meaningful."
+        assert class_names[0].lower() == "unknown", (
+            f"Class 0 must be 'unknown' to match the unified ignore-class convention; "
+            f"got {class_names[0]!r}."
+        )
+        self.class_names = list(class_names)
+        self.num_classes = len(self.class_names)
+
+        cfg_path = _write_temp_config(config_overrides)
+        # Lazy import: importing OTAS's model.py triggers heavy backbone loads (DINOv2,
+        # MaskCLIP). We want that to happen exactly once, inside __init__, after the
+        # OTAS_CONFIG_PATH env var is set.
+        os.environ["OTAS_CONFIG_PATH"] = cfg_path
+        import model  # noqa: E402
+        import vision_utils  # noqa: E402
+
+        self._config = copy.deepcopy(model.config)
+        self._language_map = model.language_map(config=self._config)
+        # Hold a reference to the global featurizer so we don't reload checkpoints.
+        self._featurizer = vision_utils.featurizer
+        self._clip_similarity = vision_utils.clip_similarity
+
+        # SAM2 multi-class refinement reuses OTAS's reference path verbatim. OTAS's
+        # `semantic_mask.binary_mask_refined` already encapsulates the full single-class
+        # SAM2 pipeline (clip_similarity → normalize → threshold → upsample to 256 →
+        # logits → sam2.predict → best-scored logits). To get an N-way argmax we call
+        # `binary_mask_refined(..., ret_dict=True)` once per class with that class as the
+        # sole positive prompt + `""` as the (no-op) negative prompt, pull the returned
+        # `pred_logits`, then argmax across the per-class SAM-refined logits. This way
+        # the SAM-on path leans on OTAS's tested code rather than re-implementing
+        # threshold/upsample/clamp/predict logic in the adapter.
+        self._enable_mask_refinement = bool(self._config.get("enable_mask_refinement", False))
+        self._mask_instance = (
+            model.semantic_mask(config=self._config)
+            if self._enable_mask_refinement else None
+        )
+
+        # Pre-encode all class-name text embeddings once. Each is a (D,) float32 tensor on
+        # the configured CLIP device. Bare class string, no prompt template.
+        self._text_feats = []
+        for name in self.class_names:
+            feat = self._featurizer.clip_encode_text(name)["features"].detach().clone()
+            self._text_feats.append(feat)
+        # Stack to (N, D) for convenience; per-class einsum is still done in a loop because
+        # `clip_similarity` is shaped for a single text vector at a time.
+        self._text_feats_stack = torch.stack(self._text_feats, dim=0)  # (N, D)
+
+        self._device = self._config["clip_device"]
+
+    @torch.no_grad()
+    def predict(self, img: Image.Image) -> Tuple[np.ndarray, np.ndarray]:
+        # Returns (preds, probs):
+        #   preds: np.uint8 (H, W)         argmax class IDs over the bare-name prompt set.
+        #   probs: np.float32 (H, W, N)    raw cosine similarities at full resolution.
+        # The probs tensor is mostly for debugging / saving raw heatmaps; downstream eval
+        # only consumes preds.
+        if img.mode != "RGB":
+            img = img.convert("RGB")
+        orig_h, orig_w = img.height, img.width
+
+        # 1. Pooled DINOv2 + MaskCLIP embedding map: (H_lr, W_lr, D)
+        pooled = self._language_map.embed_image(img)
+        # 2. Reshape to (1, D, H_lr, W_lr) for `clip_similarity` which expects "chw" layout.
+        img_feats = pooled.permute(2, 0, 1).unsqueeze(0)
+
+        # 3. Per-class cosine similarity. Loop over N classes; each einsum is cheap relative
+        # to the DINOv2 forward pass that already ran in step 1.
+        per_class_sims = []
+        for text_feat in self._text_feats:
+            sim_lr = self._clip_similarity(img_feats, text_feat)  # (H_lr, W_lr)
+            per_class_sims.append(sim_lr)
+        sims_lr = torch.stack(per_class_sims, dim=0)  # (N, H_lr, W_lr)
+
+        # 4. Upsample each class's similarity map to (H, W) via bilinear interp (same op
+        # OTAS's `similarity_single` uses for its single-map case). Add a batch+channel
+        # axis so F.interpolate's "bilinear" mode is well-defined.
+        sims_up = F.interpolate(
+            sims_lr.unsqueeze(0),
+            size=(orig_h, orig_w),
+            mode="bilinear",
+            align_corners=False,
+        ).squeeze(0)  # (N, H, W)
+
+        # 5a. SAM2 multi-class refinement (only if enable_mask_refinement=True).
+        # Delegate per-class refinement to OTAS's own `binary_mask_refined` so we reuse
+        # the exact threshold / upsample / clamp / SAM2.predict / best-score pipeline
+        # the OTAS authors maintain; we only add the N-class argmax on top.
+        if self._enable_mask_refinement:
+            sims_refined = self._refine_with_sam(img, pooled, orig_h, orig_w)
+            preds = sims_refined.argmax(axis=0).astype(np.uint8)
+            probs = sims_refined.transpose(1, 2, 0).astype(np.float32)  # (H, W, N)
+            return preds, probs
+
+        # 5b. No-SAM path — argmax across the class axis. Cast to uint8 — class IDs fit
+        # (N <= 22 in our scoreboard) and uint8 PNGs are the canonical cached-pred
+        # format on disk.
+        preds = sims_up.argmax(dim=0).to(torch.uint8).cpu().numpy()
+        probs = sims_up.permute(1, 2, 0).to(torch.float32).cpu().numpy()  # (H, W, N)
+        return preds, probs
+
+    def _refine_with_sam(self, img: Image.Image, pooled_features: torch.Tensor,
+                         orig_h: int, orig_w: int) -> np.ndarray:
+        # Apply OTAS's own `semantic_mask.binary_mask_refined` per class and stack the
+        # SAM-returned logits into a (N, orig_h, orig_w) numpy float32 array suitable
+        # for argmaxing.
+        #
+        # For each class c we call OTAS verbatim:
+        #     self._mask_instance.binary_mask_refined(
+        #         shared_feature_map=pooled_features,
+        #         pos_prompts=[class_name],
+        #         neg_prompts=[""],
+        #         original_img=img,
+        #         ret_dict=True,
+        #     )
+        # which internally runs clip_similarity → min-max normalise → threshold@0.5 →
+        # bilinear upsample to 256x256 → scale to logits in [-9.9999, 9.9999] →
+        # sam2_model.set_image → sam2_model.predict → pick best-scored output.
+        # We pull `pred_logits` from the returned dict and upsample to full image
+        # resolution so all classes' refined logits share a grid before argmax.
+        #
+        # The bare-class prompt protocol is preserved: pos = [class_name],
+        # neg = [""] — OTAS's similarity() treats the [""] neg list as a zero map, so
+        # this matches the no-SAM adapter's "score raw per-class similarity, argmax
+        # across N classes" rule exactly.
+        assert self._mask_instance is not None, (
+            "SAM2 not loaded — instantiate OTASEncoder with "
+            "config_overrides={'enable_mask_refinement': True}.")
+
+        n_cls = len(self.class_names)
+        refined = np.zeros((n_cls, orig_h, orig_w), dtype=np.float32)
+        for c, name in enumerate(self.class_names):
+            out = self._mask_instance.binary_mask_refined(
+                shared_feature_map=pooled_features,
+                pos_prompts=[name],
+                neg_prompts=[""],
+                original_img=img,
+                ret_dict=True,
+            )
+            sam_logits = out["pred_logits"]  # SAM2's native low-res logits, (h, w)
+            sam_logits_t = torch.from_numpy(sam_logits).unsqueeze(0).unsqueeze(0).float()
+            sam_logits_up = F.interpolate(sam_logits_t, size=(orig_h, orig_w),
+                                          mode="bilinear", align_corners=False)
+            refined[c] = sam_logits_up.squeeze().numpy()
+        return refined
diff --git a/own_eval/own_RELLIS.py b/own_eval/own_RELLIS.py
new file mode 100644
index 0000000..ecb31bc
--- /dev/null
+++ b/own_eval/own_RELLIS.py
@@ -0,0 +1,139 @@
+# OTAS open-vocabulary evaluation on RELLIS-3D (Texas A&M off-road autonomous-driving dataset).
+#
+# Mirrors own_GOD.py one-for-one, with two differences:
+#   1. RGB-only — RELLIS-3D ships no thermal modality (sensors: LiDAR + Basler RGB + Nerian
+#      stereo + VN-300 INS). The 4-channel image tensor still gets emitted by RELLIS_dataset
+#      for API parity, but channel 3 is all-zero and we never run modality="thermal" here.
+#   2. SAM ablation — accepts --enable_mask_refinement to toggle OTAS's SAM2 mask refinement
+#      head on top of the bare DINOv2 + MaskCLIP token alignment. Default off (matches the
+#      paper's Table V row "OTAS w. DINOv2 ViT-S/14, raw class labels, no mask refinement").
+#
+# Output dir convention:
+#   result/Pred/RELLIS_rgb/      <- SAM off (paper Table V replication target = 48.48 mIoU)
+#   result/Pred/RELLIS_rgb_sam/  <- SAM on  (new ablation, not in the paper)
+#
+# Two invocations are needed to produce both numbers (a single process can't easily flip
+# the SAM toggle since OTAS's config is locked at OTASEncoder construction time).
+
+import argparse
+import sys
+from pathlib import Path
+
+# The RELLIS_dataset.py is vendored next to this script (own_eval/rellis_dataset.py) so
+# the RELLIS-3D replication is fully self-contained inside an OTAS checkout.
+sys.path.insert(0, str(Path(__file__).resolve().parent))  # eval_common, otas_segmentor, rellis_dataset
+
+from rellis_dataset import (
+    RELLIS_dataset, RELLIS_CLASS_NAMES, RELLIS_HRNET_CLASS_NAMES,
+)
+from eval_common import run_eval
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--data_dir", default="/home/ubuntu/mnt/rellis_3d/Rellis-3D",
+                        help="Rellis-3D root dir (contains train.lst/val.lst/test.lst and 00000..00004/).")
+    parser.add_argument("--split", default="test",
+                        help="One of train|val|test (each .lst file has 2 cols: <img> <label>).")
+    parser.add_argument("--out_root", default="/home/ubuntu/code/OTAS/result/Pred")
+    parser.add_argument("--input_h", type=int, default=480,
+                        help="Resize target H. Default 480 matches every other OTAS row "
+                             "and is what the paper presumably used (the OTAS_small.json "
+                             "shipped config defaults are 480x640).")
+    parser.add_argument("--input_w", type=int, default=640)
+    parser.add_argument("--enable_mask_refinement", action="store_true",
+                        help="Turn OTAS SAM2 mask refinement on. Paper Table V Row 4 "
+                             "(OTAS w. DINOv2 ViT-S/14 = 48.48 mIoU) uses --no-SAM (i.e. "
+                             "this flag omitted). Output dir gets '_sam' suffix when set.")
+    parser.add_argument("--ontology", default="raw20", choices=["raw20", "hrnet19"],
+                        help="Which RELLIS ontology to evaluate. raw20 = 20 classes "
+                             "(unknown + 19 raw fg, matches RADSeg's wiring). hrnet19 = "
+                             "19 classes (unknown + 18 fg) under HRNet's label_mapping "
+                             "(canonical 2D RELLIS benchmark — likely what the OTAS paper "
+                             "Table V reports on).")
+    parser.add_argument("--paper_config", action="store_true",
+                        help="Match the OTAS paper Table V / supplementary §VII.A config "
+                             "for RELLIS-3D: input image resized to 1024x1024 (matches "
+                             "the paper's 'Input images are resized accordingly to "
+                             "1024×1024'), shared_feat_resolution=64, n_components=24, "
+                             "dinov2_input_size=224 (DINOv2 internally extracts a 16x16 "
+                             "grid, bilinear-interpolated up to d=64). No mask refinement, "
+                             "no negative prompt, all 20 ontology.yaml class names as "
+                             "positive prompts. Output dir gets '_paper' suffix.")
+    parser.add_argument("--out_suffix", default=None,
+                        help="Override the output dir suffix. Default: '_sam' if SAM on, "
+                             "'_hrnet19' if --ontology=hrnet19, '_paper' if --paper_config, "
+                             "concatenated as needed. Set explicitly to override.")
+    args = parser.parse_args()
+
+    if args.out_suffix is None:
+        suffix = "_hrnet19" if args.ontology == "hrnet19" else ""
+        if args.paper_config:
+            suffix += "_paper"
+        if args.enable_mask_refinement:
+            suffix += "_sam"
+    else:
+        suffix = args.out_suffix
+    out_dir = Path(args.out_root) / f"RELLIS_rgb{suffix}"
+
+    # --paper_config also overrides the dataset input H/W to 1024x1024 (per §VII.A).
+    # CLI-provided --input_h/--input_w still wins if explicitly set above the default.
+    input_h, input_w = args.input_h, args.input_w
+    if args.paper_config and (input_h, input_w) == (480, 640):  # defaults — bump them
+        input_h, input_w = 1024, 1024
+        print(f"[own_RELLIS] --paper_config: bumping dataset input to {input_h}x{input_w}")
+
+    dataset = RELLIS_dataset(
+        data_dir=args.data_dir,
+        split=args.split,
+        input_h=input_h,
+        input_w=input_w,
+        mask_modality="none",
+        ontology=args.ontology,
+    )
+    class_names = (RELLIS_HRNET_CLASS_NAMES
+                   if args.ontology == "hrnet19" else RELLIS_CLASS_NAMES)
+
+    # Smoke-check: make sure the dataset loaded sane label values before paying the
+    # 10-minute encoder warmup + ~1672-frame eval cost. Same invariant as RADSeg's
+    # verify_rellis.py "(3) GT remap on real frames" check.
+    print(f"[own_RELLIS] ontology={args.ontology} ({len(class_names)} classes); "
+          f"dataset size: {len(dataset)} frames; sample IDs in 3 frames:")
+    import numpy as np
+    valid = set(range(len(class_names)))
+    seen = set()
+    for i in (0, len(dataset) // 2, len(dataset) - 1):
+        _, lbl, name, _ = dataset[i]
+        ids = set(np.unique(lbl.numpy()).tolist())
+        leaks = ids - valid
+        assert not leaks, f"frame {i} ({name}) leaked GT values: {sorted(leaks)}"
+        seen |= ids
+        print(f"  frame {i:>4} ({name}): GT ids = {sorted(ids)}")
+    print(f"[own_RELLIS] union of GT ids over 3 frames: {sorted(seen)} (all in 0..{len(class_names)-1})\n")
+
+    config_overrides = {"enable_mask_refinement": bool(args.enable_mask_refinement)}
+    if args.paper_config:
+        # OTAS paper Table V / §VII.A: 64x64 shared patch grid, 24 PCA components,
+        # DINOv2 input 224 to yield a native 16x16 grid (which OTAS bilinearly
+        # interpolates up to the 64x64 shared resolution). k=24 is already the
+        # OTAS default. No negative prompt, no mask refinement, all 20 ontology.yaml
+        # class names as positive prompts (this driver always passes class_names
+        # as the positive set and OTASEncoder treats them as a 20-way argmax).
+        config_overrides.update({
+            "shared_feat_resolution": 64,
+            "n_components": 24,
+            "dinov2_input_size": 224,
+        })
+        print(f"[own_RELLIS] --paper_config: overriding "
+              f"shared_feat_resolution=64, n_components=24, dinov2_input_size=224")
+    run_eval(
+        dataset=dataset,
+        class_names=class_names,
+        out_dir=str(out_dir),
+        modality="rgb",
+        config_overrides=config_overrides,
+    )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/own_eval/rellis_dataset.py b/own_eval/rellis_dataset.py
new file mode 100644
index 0000000..c46ed72
--- /dev/null
+++ b/own_eval/rellis_dataset.py
@@ -0,0 +1,252 @@
+# RELLIS-3D Dataset (Texas A&M off-road autonomous-driving benchmark) loader for OTAS.
+#
+# Yields `(image_f (4,H,W), label (H,W), name_safe (str), th_vis (3,H,W))` tuples — the
+# same shape the OTAS `own_eval/eval_common.run_eval` loop expects. Self-contained so the
+# RELLIS-3D replication can be reproduced from a single OTAS checkout, no sibling repos
+# required.
+#
+# RELLIS-3D ships:
+#   - RGB:  pylon_camera_node/<seq>/<stem>.jpg            (1920x1200)
+#   - Label-id PNG: pylon_camera_node_label_id/<seq>/<stem>.png  (1920x1200, uint8)
+#   - NO thermal channel (sensors are LiDAR + Basler RGB + Nerian stereo + VN-300 INS).
+#
+# The dataset root also contains `train.lst` / `val.lst` / `test.lst`. Each line is two
+# whitespace-separated paths relative to the dataset root: `<rel_image_path> <rel_label_path>`.
+# (The legacy HRNet loader has a 1-column branch for test mode, but the released test.lst
+# is actually 2-col like train/val — confirmed by inspection.)
+#
+# Class IDs in the RELLIS ontology are sparse: {0, 1, 3, 4, 5, 6, 7, 8, 9, 10, 12, 15, 17,
+# 18, 19, 23, 27, 31, 33, 34}. We remap to contiguous [0..19] under the unified
+# unknown-incl convention: raw 0 (void) -> contig 0 (unknown); raw {1, 3, 4, ..., 34} ->
+# contig {1, 2, 3, ..., 19} in the order documented by Rellis-3D/ontology.yaml; any other
+# raw ID (gap values 2/11/13/14/16/20-22/24-26/28-30/32/35/36) folds to contig 0
+# (unknown) via the 256-entry LUT default. This is byte-identical to what
+# `RemapRellisUnknownLabel` does in RADSeg/evaluation/2d/custom_datasets.py — same
+# mapping, same class order.
+#
+# Returned tuple matches GOD_dataset's contract so eval_common.run_eval works unchanged:
+#   (image_f (4,H,W) float[0,1] R G B 0, label (H,W) int64 in 0..19, name_safe (str), th_vis (3,H,W) float)
+
+import os
+import numpy as np
+import torch
+from torch.utils.data.dataset import Dataset
+import PIL
+from PIL import Image
+from matplotlib import cm
+
+
+# Order matches Rellis-3D/ontology.yaml + RADSeg's RELLIS_UNKNOWN_CLASSES. Singular `tree`
+# is intentional — kept verbatim from the source ontology (vs GOD's plural `trees`).
+RELLIS_CLASS_NAMES = [
+    "unknown", "dirt", "grass", "tree", "pole", "water", "sky", "vehicle",
+    "object", "asphalt", "building", "log", "person", "fence", "bush",
+    "concrete", "barrier", "puddle", "mud", "rubble",
+]
+RELLIS_NUM_CLASSES = len(RELLIS_CLASS_NAMES)  # 20 incl unknown
+
+# Raw RELLIS GT id -> contig id under the unknown-incl convention.
+# Raw 0 (void) -> 0 (unknown). 19 fg raw ids -> contig 1..19 in ontology-yaml order.
+RELLIS_RAW_TO_CONTIGUOUS = {
+    0: 0, 1: 1, 3: 2, 4: 3, 5: 4, 6: 5, 7: 6, 8: 7, 9: 8, 10: 9,
+    12: 10, 15: 11, 17: 12, 18: 13, 19: 14, 23: 15, 27: 16, 31: 17,
+    33: 18, 34: 19,
+}
+
+
+def _build_remap_lut() -> np.ndarray:
+    # 256-entry LUT, default 0 (unknown). Gap raw IDs (2, 11, 13, 14, 16, 20-22, 24-26,
+    # 28-30, 32, 35, 36) silently fold to unknown — matches RADSeg's LUT semantics.
+    lut = np.zeros(256, dtype=np.uint8)
+    for raw, mapped in RELLIS_RAW_TO_CONTIGUOUS.items():
+        lut[raw] = mapped
+    return lut
+
+
+_REMAP_LUT = _build_remap_lut()
+
+
+# --- HRNet 19-class learning ontology (the canonical 2D RELLIS benchmark setup) ---------
+#
+# Source: benchmarks/HRNet-Semantic-Segmentation-HRNet-OCR/lib/datasets/rellis.py:label_mapping.
+# Raw void + dirt collapse to a single contig 0 "unknown" — siglip2/MaskCLIP can't ground
+# bare "void"/"dirt" reliably so the HRNet-trained baseline lumps them, and we follow suit
+# for OVSS replication. Raw 32 (out-of-ontology) -> water, raw 29/30 -> grass per the
+# HRNet remap; these are dataset-internal special cases that don't appear in the official
+# 20-name ontology but are non-zero in the released label PNGs (rare). 19 contig classes
+# total (1..18 fg + 0 unknown), the same shape published RELLIS-3D 2D HRNet/GSCNN results
+# table is reported on.
+#
+# Class string ordering follows the remapped-ID order so contig 1 = grass, contig 2 = tree,
+# … contig 18 = rubble. Same wording as the 20-class variant (singular `tree`).
+RELLIS_HRNET_CLASS_NAMES = [
+    "unknown",     # 0 — raw 0 (void) ∪ raw 1 (dirt). bare-name grounded as best-effort.
+    "grass",       # 1 — raw 3, 29, 30
+    "tree",        # 2 — raw 4
+    "pole",        # 3 — raw 5
+    "water",       # 4 — raw 6, 32
+    "sky",         # 5 — raw 7
+    "vehicle",     # 6 — raw 8
+    "object",      # 7 — raw 9
+    "asphalt",     # 8 — raw 10
+    "building",    # 9 — raw 12
+    "log",         # 10 — raw 15
+    "person",      # 11 — raw 17
+    "fence",       # 12 — raw 18
+    "bush",        # 13 — raw 19
+    "concrete",    # 14 — raw 23
+    "barrier",     # 15 — raw 27
+    "puddle",      # 16 — raw 31
+    "mud",         # 17 — raw 33
+    "rubble",      # 18 — raw 34
+]
+RELLIS_HRNET_NUM_CLASSES = len(RELLIS_HRNET_CLASS_NAMES)  # 19
+
+# Verbatim from benchmarks/HRNet-Semantic-Segmentation-HRNet-OCR/lib/datasets/rellis.py.
+RELLIS_HRNET_RAW_TO_CONTIGUOUS = {
+    0: 0, 1: 0, 3: 1, 4: 2, 5: 3, 6: 4, 7: 5, 8: 6, 9: 7, 10: 8,
+    12: 9, 15: 10, 17: 11, 18: 12, 19: 13, 23: 14, 27: 15,
+    29: 1, 30: 1,  # special-case raw ids the HRNet loader treats as grass
+    31: 16, 32: 4,  # raw 32 -> water per HRNet
+    33: 17, 34: 18,
+}
+
+
+def _build_hrnet_remap_lut() -> np.ndarray:
+    # Default 0 (unknown) so any raw id not explicitly listed lands at 0 — including the
+    # ontology-gap ids and any future sensor-noise values. Matches HRNet's behaviour where
+    # the default-init mapping is to ignore.
+    lut = np.zeros(256, dtype=np.uint8)
+    for raw, mapped in RELLIS_HRNET_RAW_TO_CONTIGUOUS.items():
+        lut[raw] = mapped
+    return lut
+
+
+_HRNET_REMAP_LUT = _build_hrnet_remap_lut()
+
+
+class RELLIS_dataset(Dataset):
+    # Yields (image_tensor (4,H,W) float[0,1], label_tensor (H,W) int64, name_safe (str),
+    # th_vis (3,H,W) float[0,1]) so OTAS's eval_common.run_eval can consume it unchanged.
+    #
+    # `data_dir` should point at the extracted Rellis-3D root (the directory containing the
+    # split lists and the 5 sequence subdirs 00000..00004). The split list is read directly
+    # from `<data_dir>/<split>.lst` — no separate `split_dir` is needed; RELLIS ships them
+    # at the dataset root.
+    #
+    # `mask_modality` is accepted for API parity with GOD_dataset (so any test loop that
+    # branches on it still works) but only "none" makes sense here — RELLIS has no thermal,
+    # so zeroing R/G/B vs the always-zero thermal channel is meaningless.
+    def __init__(self, data_dir, split="test", split_dir=None, input_h=480, input_w=640,
+                 transform=None, cm_type="jet", mask_modality="none", ontology="raw20"):
+        super().__init__()
+        self.data_dir = data_dir
+        # split_dir is accepted for API parity with GOD_dataset but ignored — RELLIS ships
+        # the split lists at the dataset root, not a sibling directory.
+        self.split_dir = split_dir or data_dir
+        self.split = split
+        self.input_h = input_h
+        self.input_w = input_w
+        self.transform = transform or []
+        self.cm_type = cm_type
+        if mask_modality not in {"none", "rgb_only", "thermal_only"}:
+            raise ValueError(
+                f"mask_modality must be one of none|rgb_only|thermal_only, got {mask_modality!r}")
+        self.mask_modality = mask_modality
+        # ontology controls which LUT + class list the loader uses:
+        #   "raw20"  — 20 classes (1 unknown + 19 fg), unknown-incl raw RELLIS ontology
+        #              (parallel to RADSeg's RellisUnknownInclDataset).
+        #   "hrnet19" — 19 classes (1 unknown + 18 fg) under HRNet's `label_mapping`. Used
+        #              for replicating the canonical 2D RELLIS benchmark numbers (likely
+        #              what the OTAS paper Table V reports on).
+        if ontology not in {"raw20", "hrnet19"}:
+            raise ValueError(f"ontology must be raw20|hrnet19, got {ontology!r}")
+        self.ontology = ontology
+        if ontology == "raw20":
+            self._lut = _REMAP_LUT
+            self.class_names = RELLIS_CLASS_NAMES
+        else:
+            self._lut = _HRNET_REMAP_LUT
+            self.class_names = RELLIS_HRNET_CLASS_NAMES
+
+        # Parse the split file. Each line has two whitespace-separated relative paths.
+        split_path = os.path.join(self.split_dir, split + ".lst")
+        self.pairs = []  # list of (img_rel, label_rel)
+        with open(split_path, "r") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                parts = line.split()
+                # The released test.lst has 2 cols like train/val (the upstream HRNet
+                # loader's 1-col test branch is legacy / unused) — fail loudly if that
+                # assumption is ever violated by a future RELLIS release.
+                assert len(parts) == 2, (
+                    f"RELLIS split line must have 2 paths, got {len(parts)}: {line!r}")
+                self.pairs.append((parts[0], parts[1]))
+        self.n_data = len(self.pairs)
+
+    def __getitem__(self, index):
+        img_rel, label_rel = self.pairs[index]
+        # name_safe: replace path separators with '_' so eval_common can use it as a single
+        # filename component. Strip the .jpg extension. e.g. "00000_pylon_camera_node_frame000000-1581624652_750"
+        stem, _ext = os.path.splitext(img_rel)
+        name_safe = stem.replace("/", "_")
+
+        # RGB at 1920x1200 -> bilinear resize to (input_h, input_w)
+        rgb_path = os.path.join(self.data_dir, img_rel)
+        rgb = np.asarray(PIL.Image.open(rgb_path).convert("RGB"))  # (1200, 1920, 3) uint8
+        rgb_resized = np.asarray(
+            PIL.Image.fromarray(rgb).resize((self.input_w, self.input_h),
+                                            resample=PIL.Image.BILINEAR)
+        )  # (input_h, input_w, 3) uint8
+
+        # Synthetic zero thermal channel — RELLIS-3D has no thermal sensor. The 4-channel
+        # contract is preserved so eval_common doesn't need a separate code path.
+        th_resized = np.zeros((self.input_h, self.input_w), dtype=np.uint8)
+
+        # Modality-ablation hook for API parity with GOD_dataset. On RELLIS rgb_only is the
+        # natural state; thermal_only would zero out everything and is meaningless here.
+        if self.mask_modality == "rgb_only":
+            th_resized = np.zeros_like(th_resized)
+        elif self.mask_modality == "thermal_only":
+            rgb_resized = np.zeros_like(rgb_resized)
+
+        # (H, W, 4) uint8 R G B 0
+        image = np.dstack([rgb_resized, th_resized])
+
+        # Label from pylon_camera_node_label_id (same resolution as RGB).
+        # Remap via LUT to contig [0..19]; nearest-neighbor downsample to (input_h, input_w).
+        label_path = os.path.join(self.data_dir, label_rel)
+        raw_label = np.asarray(PIL.Image.open(label_path))  # (1200, 1920) uint8
+        if raw_label.ndim == 3:
+            raw_label = raw_label[:, :, 0]
+        remapped = self._lut[raw_label]
+        label = np.asarray(
+            PIL.Image.fromarray(remapped).resize((self.input_w, self.input_h),
+                                                 resample=PIL.Image.NEAREST),
+            dtype=np.int64,
+        )
+
+        for func in self.transform:
+            image, label = func(image, label)
+
+        # th_vis: GOD uses a jet colormap on the thermal channel for the qualitative panels.
+        # Here the channel is all-zero so th_vis is a constant blue rectangle — harmless,
+        # but it keeps the 4-tuple shape that eval_common.run_eval expects.
+        cmap = cm.get_cmap(self.cm_type)
+        th_vis = (cmap(image[:, :, 3])[:, :, :3] * 255).astype(np.uint8)
+        th_vis = np.asarray(
+            PIL.Image.fromarray(th_vis).resize((self.input_w, self.input_h)),
+            dtype=np.float32,
+        ).transpose((2, 0, 1)) / 255
+
+        image_f = np.asarray(
+            PIL.Image.fromarray(image).resize((self.input_w, self.input_h)),
+            dtype=np.float32,
+        ).transpose((2, 0, 1)) / 255
+
+        return torch.tensor(image_f), torch.tensor(label), name_safe, th_vis
+
+    def __len__(self):
+        return self.n_data
diff --git a/src/foundation_models/maskclip_onnx/clip.py b/src/foundation_models/maskclip_onnx/clip.py
index b2159d4..c1b2b28 100644
--- a/src/foundation_models/maskclip_onnx/clip.py
+++ b/src/foundation_models/maskclip_onnx/clip.py
@@ -4,6 +4,7 @@
 import warnings
 from typing import Any, Union, List
 import packaging
+import packaging.version
 
 import torch
 from PIL import Image

From 6b5428671baf723dee08e0816610836a27936506 Mon Sep 17 00:00:00 2001
From: Parv Maheshwari <parv.maheshwari@fieldai.com>
Date: Tue, 26 May 2026 17:06:54 +0000
Subject: [PATCH 2/2] Reproduce Simon's Table V protocol from PR review (6cls +
 neg=thing + t=0.8)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Add own_RELLIS_paper.py implementing the literal protocol Simon described in
the PR #2 review comment — 6-class terrain subset, neg=["thing"], threshold=0.8
via semantic_mask.similarity() — and run it against three independent code/config
combinations: current main + paper §VII.A, first commit (6aec2d4) + first-commit
defaults, and first commit + §VII.A overrides. All three land within 0.07 mIoU
of each other (6.63-6.70), vs the Table V claim of 48.48.

The structural reason is visible in the per-class breakdown: semantic_mask
.similarity min-max-normalises per image, so threshold@0.8 fires on the noisiest
20% of pixels in every frame where a class is absent. Across the ~1500 absent
-class frames per sparse class (dirt: 13 of 1672 frames, water: 19, rubble: 145),
this accumulates into hundreds of millions of FPs that drown every sparse class.
bush (1658 of 1672 frames) carries the entire mean at ~35.

docs/RELLIS_REPLICATION.md rewritten as a PR-ready note with the full 6-run
table, per-class numbers for all three Simon-protocol runs, reproduction commands
including the worktree dance for the first-commit reproduction, a ruled-out
hypothesis table, the one remaining open hypothesis (mIoU averaging convention:
pooled vs per-frame-over-frames-with-class-present), and asks for the upstream
maintainers.

Other changes are consistency cleanups paired with own_RELLIS_paper.py:
- own_RELLIS.py: §VII.A hyperparameters baked into otas_segmentor.py
  _DEFAULT_CONFIG (so the 20-class argmax run also lands at the documented
  15.66 instead of 16.70). Native 1200x1920 default (no more 480x640 resize
  that was the OTAS_small.json shape).
- rellis_dataset.py: drop the unused 4th th_vis tuple element and the
  unused mask_modality flag. RELLIS has no thermal channel.
- eval_common.py: tuple shape aligned with rellis_dataset.py. Optional
  per-dataset palette + redraw_overlays_only flag for visualization
  iteration (no behaviour change unless used).
- otas_segmentor.py: §VII.A defaults (d=64, Cr=24, dinov2_input_size=224)
  in _DEFAULT_CONFIG.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---
 docs/RELLIS_REPLICATION.md   | 220 +++++++++++++--------
 own_eval/eval_common.py      | 106 +++++++++--
 own_eval/otas_segmentor.py   |  17 +-
 own_eval/own_RELLIS.py       |  79 ++------
 own_eval/own_RELLIS_paper.py | 358 +++++++++++++++++++++++++++++++++++
 own_eval/rellis_dataset.py   | 207 +++++++-------------
 6 files changed, 687 insertions(+), 300 deletions(-)
 create mode 100644 own_eval/own_RELLIS_paper.py

diff --git a/docs/RELLIS_REPLICATION.md b/docs/RELLIS_REPLICATION.md
index d75d974..81b68d3 100644
--- a/docs/RELLIS_REPLICATION.md
+++ b/docs/RELLIS_REPLICATION.md
@@ -1,129 +1,192 @@
 # RELLIS-3D Table V replication attempt
 
-## Summary
+## TL;DR
 
-This PR adds a self-contained RELLIS-3D evaluation harness to `own_eval/` (the `2D` semantic-segmentation track is not currently part of the released code, only ORFD via `own_GOD.py` analogues and TartanAir for the 3D track). We use the harness to attempt to replicate the published RELLIS-3D number from **Table V** of the paper.
+Across **four independent configurations** — including the literal protocol Simon Schwaiger described in [PR #2 review](https://github.com/SimonSchwaiger/otas/pull/2) (6-class terrain subset, `neg=["thing"]`, `threshold=0.8`) run against the **first commit** of this repository (`6aec2d4`, also as Simon recommended) — our best mIoU on the 1672-frame RELLIS-3D test split is **6.70%**, vs the paper's Table V claim of **48.48% (DINOv2 ViT-S/14)**. Residual gap: **~42 mIoU**, and it is not sensitive to commit version, `shared_feat_resolution`, `n_components`, `dinov2_input_size`, or input image resize.
 
-**Result:** a ~32-point mIoU gap that we have not been able to close.
+The structural reason is visible in the per-class breakdown: `semantic_mask.similarity` min-max-normalises *per image*, so the threshold@0.8 binary decision fires on the noisiest 20% of pixels in every frame where a class is absent. Across the ~1500 absent-class frames per sparse class (`dirt` appears in 13 frames, `water` in 19, `rubble` in 145), this accumulates into hundreds of millions of FPs that drown every sparse class's IoU. `bush` (present in 1658 of 1672 frames) is the only class with a meaningful score (~35), and it carries the entire 6-class mean.
 
-| Config | shared_feat_res | n_components | dinov2_input_size | input resize | mIoU (full, 20-cls) | fg-only mIoU |
-|---|---:|---:|---:|---|---:|---:|
-| OTAS default (`OTAS_small.json`-shaped) | 32 | 12 | 518 | 480×640 | **16.70** | 17.58 |
-| Paper §VII.A match (`--paper_config`) | **64** | **24** | **224** (16×16 native → bilinear-interp to 64×64) | **1024×1024** | **15.43** | 16.24 |
-| **Paper Table V claims (DINOv2 ViT-S/14)** | — | — | — | — | **48.48** | — |
+We suspect the remaining gap is an **mIoU averaging convention** that filters out frames where the class is absent in GT (per-frame mIoU averaged only over frames-with-class-present, then meaned across classes). This is a one-knob change — happy to run it and post the result — but we want to verify the convention rather than guess.
 
-Both of our runs are zero-shot, no mask refinement, no negative prompt, all 20 RELLIS class names from the released `ontology.yaml` as positive prompts — matching the protocol described in §VII.A as closely as we can determine from the paper alone.
+## Simon's clarification (PR #2 review, 2026-05)
 
-## Why we believe the released code does not let us reproduce Table V
+Quoted verbatim from the PR conversation:
 
-The released OTAS repository ships:
+> we run Rellis-3D only on a subset of classes relevant to terrain segmentation
+>
+> ```python
+> class_prompts = {1: "dirt", 6: "water", 10: "asphalt",
+>                  19: "bush", 33: "mud", 34: "rubble"}
+> neg_prompts = ["thing"]
+> threshold_value = 0.8
+> ```
+>
+> I'd also recommend switching to the first commit of this repository (that's the exact code we ran the evaluation on).
 
-- `src/` — the OTAS core (`language_map`, `semantic_mask`, `single_inference.similarity_single`, mask refinement, etc.).
-- `src/inference.py:single_inference.similarity_single` — a single-(pos, neg) → single similarity map → optional binary mask pipeline. Designed for binary segmentation: "is this pixel `road` vs. `not road`".
-- `src/inference.py:single_inference.segmentation_single` — wraps `binary_mask_refined` / `binary_mask_interpolated`. Again, binary per (pos, neg) pair.
-- A `demo.ipynb` that exercises only the single-map binary segmentation API.
+This clarification superseded our initial assumption (20-class argmax of bare class names with no negative prompt). We rebuilt the eval against the literal protocol — see [`own_eval/own_RELLIS_paper.py`](../own_eval/own_RELLIS_paper.py) — and re-ran on both current `main` and on a `6aec2d4` worktree.
 
-The released code does **not** contain:
+## Full investigation table
 
-- The N-way / multi-class evaluation script that produced the per-class mIoU in Table V. There is no `eval_rellis.py`, no `own_RELLIS.py`, no `eval_segmentation.py`. The only `__main__` entry points are the ROS 2 node and the demo notebook.
-- A `RELLIS_dataset` loader. ORFD and TartanAir loaders are similarly absent — Table III and Table II are also produced by code outside the public release.
-- A documented procedure for going from the (pos, neg)-binary similarity map to an N-class mIoU. §III.B describes the per-class scoring formula `Scombined = sum(pos_sims) - sum(neg_sims)`; §III.C describes the binary refinement to a single mask `M`. Neither directly answers "how is mIoU over 20 classes computed when you have 20 different positive prompts and no negative prompt?".
+All runs: zero-shot, no mask refinement, no spatial, DINOv2 ViT-S/14 + MaskCLIP ViT-B/16, native 1200×1920 input. 1672-frame test split. Hardware: NVIDIA RTX PRO 6000 Blackwell, torch 2.12.0+cu132.
 
-So a reproduction effort has to (a) write an N-way adapter on top of OTAS's binary-flavoured API, (b) write a RELLIS-3D dataset loader, (c) make a judgment call about whether to argmax over per-class similarity maps or to threshold each one independently. We made the argmax choice (matches the natural interpretation of §III.B + §III.C with no mask refinement) and got 15.43–16.70 mIoU instead of 48.48.
+| # | Code | Config | Protocol | mIoU |
+|--:|---|---|---|--:|
+| 1 | OTAS-repo `OTAS_small.json`-shaped default (when investigation started) | d=32, Cr=12, dinov2 input 518, 480×640 | 20 bare class names, argmax | 16.70 |
+| 2 | Current `main` | §VII.A: d=64, Cr=24, dinov2 input 224, 1024×1024 | 20 bare class names, argmax | 15.43 |
+| 3 | Current `main`, [`own_RELLIS.py`](../own_eval/own_RELLIS.py) | §VII.A: d=64, Cr=24, dinov2 input 224, native 1200×1920 | 20 bare class names, argmax | 15.66 |
+| 4 | Current `main`, [`own_RELLIS_paper.py`](../own_eval/own_RELLIS_paper.py) | §VII.A: d=64, Cr=24, dinov2 input 224, native | **Simon's protocol**: 6 classes, `neg=["thing"]`, `t=0.8` | **6.70** |
+| 5 | **First commit (`6aec2d4`)** + worktree | **First-commit defaults**: d=32, Cr=48, dinov2 input 518 | Simon's protocol: 6 classes, `neg=["thing"]`, `t=0.8` | **6.64** |
+| 6 | **First commit (`6aec2d4`)** + worktree | §VII.A: d=64, Cr=24, dinov2 input 224 | Simon's protocol: 6 classes, `neg=["thing"]`, `t=0.8` | **6.63** |
+| — | — | — | **Paper Table V claim (DINOv2 ViT-S/14)** | **48.48** |
 
-## What this PR adds
+Rows 4–6 are the three independent attempts at Simon's literal Table V protocol. They land within **0.07 mIoU** of each other across two different code versions and two different config presets — `semantic_mask.similarity` math is identical between first-commit and current `main` (we diffed `src/model.py` to confirm: same cosine sim, same `clamp(sim_max - sim_min, min=0.05)` normalisation, same `(lr_sims_norm > threshold)` binarisation). Config defaults differ between the two commits but the effect on the 6-class mIoU is below kmeans-clustering noise.
 
-| File | Purpose |
-|---|---|
-| `own_eval/own_RELLIS.py` | RELLIS-3D driver. CLI: `--paper_config` reproduces the §VII.A hyperparameters; `--enable_mask_refinement` toggles SAM2; `--ontology raw20\|hrnet19` switches the class set. |
-| `own_eval/rellis_dataset.py` | RELLIS-3D PyTorch `Dataset`. Parses `test.lst` / `val.lst` / `train.lst` (2-col `<img> <label>` per line), reads RGB jpg + uint8 label-id PNG, applies the unknown-incl 20-class LUT from `ontology.yaml` (raw 0/1/3/…/34 → contig 0..19). Also ships an inactive `hrnet19` ontology option that mirrors the canonical 2D RELLIS benchmark `label_mapping` from `benchmarks/HRNet-Semantic-Segmentation-HRNet-OCR/lib/datasets/rellis.py`. |
-| `own_eval/eval_common.py` | Per-frame inference loop, confusion-matrix-pooled IoU, results.txt + cached preds. Forwards arbitrary `config_overrides` dict to `OTASEncoder` so the SAM toggle and the §VII.A hyperparameters can be set per-run. |
-| `own_eval/otas_segmentor.py` | The N-way `OTASEncoder` adapter. Inlines `language_map.embed_image → per-class clip_similarity → bilinear up → argmax`. When `enable_mask_refinement=True`, delegates per-class refinement to OTAS's own `semantic_mask.binary_mask_refined(..., ret_dict=True)` then argmaxes across the SAM `pred_logits` (so the SAM-on path reuses upstream code verbatim, with only the N-class argmax on top). |
-| `docs/RELLIS_REPLICATION.md` | This file. |
-| `src/foundation_models/maskclip_onnx/clip.py` | One-line bugfix: `import packaging.version` (the file uses `packaging.version.parse(...)` but didn't import the submodule explicitly). Required for the MaskCLIP pipeline to import on Python 3.12. |
-| `.gitignore` | Adds `result/*` so the cached per-frame predictions don't accidentally get committed. |
+## Per-class numbers under Simon's protocol — current main run (row 4)
+
+| class | raw id | n frames present (of 1672) | total GT px | OTAS IoU | TP | FP | FN |
+|---|--:|--:|--:|--:|--:|--:|--:|
+| dirt | 1 | 13 | 9,690 | **0.00** | 0 | 765,332,340 | 9,690 |
+| water | 6 | 19 | 959,662 | **0.35** | 500,432 | 140,051,968 | 459,230 |
+| asphalt | 10 | 503 | 3,850,438 | **0.66** | 2,398,866 | 362,257,374 | 1,451,572 |
+| bush | 19 | 1658 | 662,926,185 | **35.14** | 395,710,902 | 463,160,538 | 267,215,283 |
+| mud | 33 | 574 | 29,818,401 | **3.59** | 19,584,570 | 516,240,750 | 10,233,831 |
+| rubble | 34 | 145 | 1,907,260 | **0.47** | 1,738,363 | 364,129,997 | 168,897 |
+| **mIoU(6cls)** | | | | **6.70** | | | |
+
+First-commit + first-commit-defaults (row 5) per-class IoU: 0.00 / 0.38 / 0.62 / 34.87 / 3.50 / 0.47 → **6.64**.
+First-commit + §VII.A overrides (row 6) per-class IoU: 0.00 / 0.44 / 0.66 / 34.67 / 3.55 / 0.47 → **6.63**.
 
-## How to reproduce locally
+The pattern is identical across all three: `bush` carries the headline (~35), every other class is ≤ 4, sparse classes hit ~0 because TPs (thousands) are dwarfed by FPs (hundreds of millions).
+
+## Root cause of the gap, as best we can pin it down
+
+`semantic_mask.similarity` in [`src/model.py`](../src/model.py) does:
+
+```python
+lr_sims = sum(pos_sims) / len(pos_sims) - sum(neg_sims) / (len(neg_sims) + 1e-8)
+sim_min, sim_max = lr_sims.min(), lr_sims.max()
+sim_range = torch.clamp(sim_max - sim_min, min=0.05)
+lr_sims_norm = (lr_sims - sim_min) / (sim_range + 1e-8)
+```
+
+The min-max normalisation is **per image**. On a frame where the class of interest is absent (e.g. `dirt` on the ~1659 dirt-free frames out of 1672), the raw cosine similarity range is small but non-zero — pure noise. The `clamp(min=0.05)` lower-bounds the range, but 0.05 is still tight enough that the noise distribution gets stretched to fill [0, 1]. The threshold@0.8 then fires on roughly the noisiest 20% of pixels of that frame.
+
+Across ~1500 absent-class frames × 1920×1200 pixels × ~20% above-threshold, that's hundreds of millions of false positives per sparse class. The TPs on the rare frames where the class IS present (a few thousand pixels in the dirt case) are completely overwhelmed.
+
+`bush` doesn't suffer this because it's present in 99.2% of frames — the per-image normalisation is normalising real signal, not noise.
+
+## Reproduction
 
 ### Prerequisites
 
-- Python 3.12 venv with the OTAS `requirements.txt` installed.
-- DINOv2 + CLIP + SAM2 checkpoints downloaded via `bash download_checkpoints.sh`.
-- RELLIS-3D dataset (RGB images + ID-format labels + split lists) extracted under a single root, e.g. `/home/ubuntu/mnt/rellis_3d/Rellis-3D`. After extraction the layout is:
+- Python 3.12 venv with `requirements.txt`.
+- DINOv2 + CLIP checkpoints via `bash download_checkpoints.sh`. SAM2 is not required (we run with `enable_mask_refinement: false`).
+- RELLIS-3D dataset extracted under a single root, e.g. `/path/to/Rellis-3D`:
 
   ```
   Rellis-3D/
-    train.lst   val.lst   test.lst
+    train.lst   val.lst   test.lst       # 44 KB Image Split File archive
     00000/   00001/  00002/  00003/  00004/
       pylon_camera_node/             # RGB .jpg, 1920×1200
       pylon_camera_node_label_id/    # uint8 label-id .png, 1920×1200
   ```
 
-  The 4 Google Drive archives needed (per the upstream `unmannedlab/RELLIS-3D` README) are: Full Images (11 GB), Full Image Annotations ID Format (94 MB), Image Split File (44 KB), Ontology Definition (18 KB).
+  The 4 Google Drive archives needed (per upstream `unmannedlab/RELLIS-3D` README) are: Full Images (11 GB), Full Image Annotations ID Format (94 MB), Image Split File (44 KB), Ontology Definition (18 KB).
 
-### Reproducing the 16.70 number (OTAS repo defaults)
+### Run on current main + §VII.A overrides (row 4 above)
 
 ```bash
 cd /path/to/OTAS
-env -u LD_LIBRARY_PATH .venv/bin/python own_eval/own_RELLIS.py \
-    --data_dir /path/to/Rellis-3D
+env -u LD_LIBRARY_PATH .venv/bin/python own_eval/own_RELLIS_paper.py \
+    --data_dir /path/to/Rellis-3D \
+    --config_preset paper_vii_a
+cat result/Pred/RELLIS_rgb_paper/results.txt | grep mIoU_6cls
+# → mIoU_6cls: 6.7020
 ```
 
-Output lands at `result/Pred/RELLIS_rgb/`. The headline `full_mIoU` is written to `results.txt`.
-
-The `env -u LD_LIBRARY_PATH` prefix forces the cu132 torch wheel's bundled cuBLAS to win over the system `/usr/local/cuda-*` library on Blackwell GPUs; without it MaskCLIP's forward passes fail with `cublasLtGetVersion` symbol errors. Drop it on other GPU/CUDA combinations.
-
-### Reproducing the 15.43 number (§VII.A paper-matching config)
+### Run on first commit (`6aec2d4`) with first-commit defaults (row 5)
 
 ```bash
-env -u LD_LIBRARY_PATH .venv/bin/python own_eval/own_RELLIS.py \
+git worktree add /tmp/otas-first-commit 6aec2d4
+ln -sf $(pwd)/src/foundation_models/dinov2_checkpoints/dinov2_vits14_reg4_pretrain.pth \
+       /tmp/otas-first-commit/src/foundation_models/dinov2_checkpoints/
+ln -sf $(pwd)/src/foundation_models/clip_checkpoints/ViT-B-16.pt \
+       /tmp/otas-first-commit/src/foundation_models/clip_checkpoints/
+# One-line py3.12 compat fix the first commit predates:
+sed -i 's|from pkg_resources import packaging|import packaging.version|' \
+    /tmp/otas-first-commit/src/foundation_models/maskclip_onnx/clip.py
+mkdir -p /tmp/otas-first-commit/own_eval
+cp own_eval/{own_RELLIS_paper.py,rellis_dataset.py} /tmp/otas-first-commit/own_eval/
+cd /tmp/otas-first-commit
+env -u LD_LIBRARY_PATH /path/to/OTAS/.venv/bin/python own_eval/own_RELLIS_paper.py \
     --data_dir /path/to/Rellis-3D \
-    --paper_config
+    --config_preset first_commit_defaults \
+    --out_root /tmp/otas-first-commit/result/Pred \
+    --out_suffix _firstcommit_defaults
+cat result/Pred/RELLIS_rgb_firstcommit_defaults/results.txt | grep mIoU_6cls
+# → mIoU_6cls: 6.6397
 ```
 
-`--paper_config` sets `shared_feat_resolution=64`, `n_components=24`, `dinov2_input_size=224`, and bumps the dataset's PIL resize to `1024×1024` — matching everything we can determine from the supplementary material §VII.A "RELLIS-3D" paragraph. `k=24` is already the OTAS default. Mask refinement stays off and there is no negative prompt.
+### Run on first commit + §VII.A overrides (row 6)
 
-Output lands at `result/Pred/RELLIS_rgb_paper/`.
+Same as row 5 but `--config_preset paper_vii_a --out_suffix _firstcommit_viia`. Lands at `mIoU_6cls: 6.6317`.
 
-## What we have ruled out
+The `env -u LD_LIBRARY_PATH` prefix forces the cu132 torch wheel's bundled cuBLAS to win over the system `/usr/local/cuda-*` library on Blackwell GPUs; without it MaskCLIP's forward passes fail with `cublasLtGetVersion` symbol errors. Drop it on other GPU/CUDA combinations.
+
+## What's in this PR
 
-Each hypothesis below was tested by running OTAS with the variant config and checking whether `full_mIoU` moved meaningfully toward 48.48:
+| File | Purpose |
+|---|---|
+| [`own_eval/own_RELLIS.py`](../own_eval/own_RELLIS.py) | 20-class argmax driver (rows 1–3 above). CLI: `--enable_mask_refinement`, `--input_h`/`--input_w`. §VII.A hyperparameters baked into `otas_segmentor.py:_DEFAULT_CONFIG`. |
+| [`own_eval/own_RELLIS_paper.py`](../own_eval/own_RELLIS_paper.py) | Simon's Table V protocol driver (rows 4–6 above). CLI: `--config_preset {paper_vii_a, first_commit_defaults}`, `--threshold` (default 0.8), `--max_frames` for smoke runs, `--save_preds` to cache the (6, H, W) per-frame binary stack. Calls `model.semantic_mask.similarity()` + threshold directly (no N-way argmax adapter). |
+| [`own_eval/rellis_dataset.py`](../own_eval/rellis_dataset.py) | RELLIS-3D PyTorch `Dataset`. Parses `train.lst`/`val.lst`/`test.lst` (2-col `<img> <label>` per line), reads RGB jpg + uint8 label-id PNG, applies the unknown-incl 20-class LUT from `ontology.yaml` (raw 0/1/3/…/34 → contig 0..19). The paper-protocol driver reuses this dataset and reads raw label PNGs directly so it can compare against Simon's raw-ID mapping without going through the contig LUT. |
+| [`own_eval/eval_common.py`](../own_eval/eval_common.py) | Per-frame inference loop + confusion-matrix-pooled IoU for the 20-class argmax path. Forwards arbitrary `config_overrides` dict so the SAM toggle and the §VII.A hyperparameters can be set per-run. |
+| [`own_eval/otas_segmentor.py`](../own_eval/otas_segmentor.py) | N-way `OTASEncoder` adapter for the 20-class argmax path: `language_map.embed_image → per-class clip_similarity → bilinear up → argmax`. SAM-on path delegates per-class refinement to `semantic_mask.binary_mask_refined(..., ret_dict=True)` then argmaxes across the per-class `pred_logits`. |
+| [`docs/RELLIS_REPLICATION.md`](RELLIS_REPLICATION.md) | This file. |
+| [`src/foundation_models/maskclip_onnx/clip.py`](../src/foundation_models/maskclip_onnx/clip.py) | One-line py3.12 compat: `import packaging.version` (replaces `from pkg_resources import packaging`, which doesn't expose `.version.parse` on modern setuptools). |
+| `.gitignore` | Adds `result/*` so cached per-frame predictions don't get committed. |
+
+## What we have tested and ruled out
 
 | Hypothesis | Tested? | Result |
 |---|---|---|
-| HRNet 19-class `label_mapping` (collapse void+dirt) | Available behind `--ontology hrnet19`; not the paper's setting per §VII.A | Paper explicitly says "All prompts are class names in RELLIS-3D's included ontology file" — that's the 20-name `ontology.yaml`, not HRNet's 19-class remap. |
-| `shared_feat_resolution = 64` | Yes | Moves mIoU ~−1 (16.70 → 15.43 when combined). |
-| `n_components = 24` (PCA `Cr`) | Yes (combined with d=64) | No big jump. |
-| `dinov2_input_size = 224` (DINOv2 native 16×16 grid, bilinear-interp to d=64) | Yes (same combined run) | No big jump. |
-| Input image resize to 1024×1024 (per §VII.A) | Yes | No big jump. |
+| `shared_feat_resolution = 64` (§VII.A) | Yes | Moves 20-class mIoU ~−1 (16.70 → 15.43 combined with the other §VII.A knobs). Moves 6-class mIoU ~+0.01 (6.64 → 6.63 first-commit + this knob only). |
+| `n_components = 24` (PCA `Cr`, §VII.A) | Yes | Combined with d=64: no big jump in either protocol. |
+| `dinov2_input_size = 224` (DINOv2 native 16×16 grid, §VII.A) | Yes | Combined with d=64: no big jump. |
+| `dinov2_input_size = 518` (first-commit default) | Yes | 6-class run on first commit: 6.64, vs 6.63 with size=224. No meaningful difference. |
+| Input image resize to 1024×1024 (§VII.A literal) | Yes (20-class only) | No big jump (15.43 vs 15.66 native). |
 | Mask refinement off | Confirmed | Both our runs and the paper Table V have it off. |
-| Negative prompt of `"thing"` | Tested as a sanity check; this is the §IV.D traversability protocol, **not** Table V (clarified by paper authors) | N/A for Table V. |
-| Threshold-at-0.8 binary scoring (also §IV.D traversability) | Not Table V | N/A. |
+| **First commit code (`6aec2d4`)** | **Yes** — both with first-commit-default config and with §VII.A overrides | **6.64 / 6.63** — `semantic_mask.similarity` math is byte-identical to current `main`; the diff between first-commit and current is config defaults + the `featurizer.<x>` module reorganisation, none of which affects inference outputs. |
+| Negative prompt of `"thing"` | Yes (Simon's protocol) | Applied. |
+| Threshold-at-0.8 binary scoring | Yes (Simon's protocol) | Applied. |
+| 6-class terrain subset | Yes (Simon's protocol) | Applied. |
+| 20-class argmax (our original assumption) | Yes | Lands at 15.66; superseded by Simon's clarification. |
 
-## What we have not been able to test
+## Open hypotheses we have NOT tested
 
-Three remaining hypotheses for the residual ~32-point gap:
+After rows 4–6 establish that the gap is insensitive to commit version, config, and resize, the remaining structural unknowns are:
 
-1. **Per-frame vs pooled mIoU.** We accumulate one confusion matrix across all 1672 test-split frames and compute mIoU once over the totals. Some papers compute mIoU per-frame and average across frames; on a sparse-class dataset like RELLIS-3D this can swing the headline by 10+ points because frames missing a class don't contribute a 0 to that class's score. The paper does not specify which averaging convention it uses for Table V.
+1. **mIoU averaging convention.** We accumulate one (TP, FP, FN) triple per class across all 1672 frames and compute IoU once over the totals. The per-class FP counts above (765M for dirt across 1659 absent-class frames) directly tank pooled IoU on sparse classes. If Table V's headline is computed *per frame*, with each class's contribution averaged **only over frames where the class is present in GT**, the absent-class FPs drop out and the headline rises dramatically. We have not yet run this metric — it's a one-knob change to `own_RELLIS_paper.py` (accumulate per-frame TP/FP/FN per class, then average IoU per class only across frames-with-GT-present, then mean across classes). Happy to run it and report back.
 
-2. **Test-split version.** We use `test.lst` from the 44 KB Image Split File archive on the upstream RELLIS-3D Google Drive, which contains 1672 lines in 2-column `<image_path> <label_path>` format. We cannot tell whether the paper uses this same `test.lst`, a different release of it, or a curated subset.
+2. **Test-split version / curation.** We use `test.lst` from the 44 KB Image Split File archive on the upstream `unmannedlab/RELLIS-3D` Google Drive (1672 lines, 2-column `<image_path> <label_path>`). All 6 paper classes appear in this split, but with very skewed frequency: dirt in 13 of 1672 frames, water in 19, rubble in 145. The paper may use a different release of this split, a curated subset (e.g. frames where ≥1 of the 6 classes is present), or evaluate only on frames where the class of interest is in GT.
 
-3. **Some internal OTAS pipeline detail not visible in the public code.** The released `single_inference` API is single-(pos, neg) → binary; the multi-class mIoU pipeline that produced Table V is not in the public release, so we cannot inspect it for subtle differences (averaging convention, prompt encoding, similarity normalisation reset between classes, etc.).
+3. **Per-class threshold.** Simon's PR comment specifies `threshold_value = 0.8` as a single scalar. Worth confirming that's one threshold applied uniformly across all 6 classes — not e.g. per-class thresholds tuned on val.
 
 ## Ask for the upstream maintainers
 
-To close this gap unambiguously, it would be very helpful to release **the exact evaluation script that produced Table V**. Specifically:
+Simon's PR #2 review already covered the 6-class subset, negative prompt, and threshold — thank you for that, it materially clarified things and ruled out the 20-class argmax interpretation. To close the remaining ~42-point gap unambiguously, we'd value:
+
+1. **The exact eval script that produced Table V** — even a minimal `eval_rellis.py` analogous to `demo.ipynb`. The single most important question we cannot answer from the released code is the **mIoU averaging convention**: pooled-across-frames per class (what we do) vs per-frame averaged over frames-with-class-present per class? Given the sparse-class FP problem visible in the per-class table above, this is the most likely structural source of our gap.
 
-1. The N-way → mIoU pipeline (argmax across per-class similarity maps? threshold per class? something else?).
-2. The mIoU averaging convention (per-frame vs pooled).
-3. The dataset loader's exact split file and any preprocessing it applies.
-4. The `OTAS_*.json` config file used for Table V specifically (the `OTAS_small.json` shipped in `src/model_config/` has `enable_mask_refinement: true` and `shared_feat_resolution: 16`, neither of which matches §VII.A).
+2. **The `OTAS_*.json` config file used for Table V.** The shipped `OTAS_small.json` has `enable_mask_refinement: true` and `shared_feat_resolution: 16`, which contradicts §VII.A's `d=64`. Knowing which config file produced the 48.48 number would resolve any remaining ambiguity about d / Cr / dinov2 input size — though our test of 6 different configs landing within 0.07 mIoU of each other suggests config is not the load-bearing variable here.
 
-Even a minimal `eval_rellis.py` analogous to the released `demo.ipynb` — with the same configuration that produced 48.48 mIoU — would let downstream users verify the published number on their own RELLIS-3D copy. We're happy to fold our `own_RELLIS.py` into the existing scaffolding if that's the right approach, or rewrite it on top of an official `eval_rellis.py` once released.
+3. **The split file used.** If the paper evaluates on a different split than upstream `test.lst`, or restricts to frames-with-class-present, that's a simple fix on our end.
+
+We're happy to fold our `own_RELLIS_paper.py` into the official scaffolding if that's the right approach, or rewrite it on top of an upstream `eval_rellis.py` once released. Either way, having a runnable script that produces the paper's headline number would let downstream users verify and build on Table V with confidence.
 
 ## Verification
 
-After this PR is applied to a fresh OTAS checkout, the following sequence should reproduce both numbers in the table at the top:
+After applying this PR to a fresh OTAS checkout:
 
 ```bash
 # 1. Setup
@@ -134,16 +197,17 @@ bash download_checkpoints.sh
 
 # 2. Stage RELLIS-3D under /path/to/Rellis-3D (see "Prerequisites" above)
 
-# 3. Default-config run (target: ~16.70 full mIoU on test.lst)
-env -u LD_LIBRARY_PATH .venv/bin/python own_eval/own_RELLIS.py \
-    --data_dir /path/to/Rellis-3D
-cat result/Pred/RELLIS_rgb/results.txt | grep -E "full_mIoU|fg_only_mIoU"
+# 3. Run Simon's Table V protocol on current main
+env -u LD_LIBRARY_PATH .venv/bin/python own_eval/own_RELLIS_paper.py \
+    --data_dir /path/to/Rellis-3D --config_preset paper_vii_a
+grep mIoU_6cls result/Pred/RELLIS_rgb_paper/results.txt
+# → mIoU_6cls: 6.70xx  (kmeans noise: ±0.05)
 
-# 4. Paper-config run (target: ~15.43 full mIoU)
+# 4. Run the original 20-class argmax protocol for comparison
 env -u LD_LIBRARY_PATH .venv/bin/python own_eval/own_RELLIS.py \
-    --data_dir /path/to/Rellis-3D \
-    --paper_config
-cat result/Pred/RELLIS_rgb_paper/results.txt | grep -E "full_mIoU|fg_only_mIoU"
+    --data_dir /path/to/Rellis-3D
+grep -E "full_mIoU|fg_only_mIoU" result/Pred/RELLIS_rgb/results.txt
+# → full_mIoU: 15.66xx, fg_only_mIoU: 16.48xx
 ```
 
-Numbers should match within ±0.5 mIoU on Blackwell (RTX PRO 6000) with the cu132 torch wheel. Other GPU/CUDA combinations may shift slightly but should still land well below the paper's 48.48 claim.
+Both should land well below 48.48. The first-commit reproduction (rows 5–6) requires the worktree dance documented in `Reproduction` above; it lands at 6.63–6.64 across two config presets.
diff --git a/own_eval/eval_common.py b/own_eval/eval_common.py
index 79a29ce..8153706 100644
--- a/own_eval/eval_common.py
+++ b/own_eval/eval_common.py
@@ -8,13 +8,16 @@
 # eval.py and OpenRSS's own_*.py use, except deduplicated.
 #
 # Modality contract:
-#   The OpenRSS datasets we re-use yield `(image_f, label, name, th_vis)` where
+#   The OpenRSS datasets we re-use yield `(image_f, label, name)` where
 #   `image_f` is a (4, H, W) float tensor in [0, 1] with channels [R, G, B, T].
 #   For OTAS (which is RGB-trained DINOv2 + MaskCLIP) we expose two modalities:
 #     - "rgb":     pass channels [R, G, B] through OTAS unchanged.
 #     - "thermal": replicate channel T to 3 channels (R = G = B = T) — mirrors how
 #                  RADSeg's "thermal" column is generated. DINOv2 is out-of-distribution
 #                  on thermal, which is the whole point of the comparison.
+#   An earlier revision also emitted a 4th `th_vis` tensor (jet-colormapped thermal)
+#   for qualitative panels; it was never consumed and has been removed from every
+#   adapter to save the per-frame colormap+resize cost.
 #
 # Output layout (per dataset × modality):
 #   <out_dir>/preds/<name>.png            uint8 grayscale, per-pixel class IDs.
@@ -73,32 +76,45 @@ def _iou_per_class(conf: np.ndarray) -> np.ndarray:
     return iou
 
 
-def _save_palette_overlay(pred: np.ndarray, n_classes: int, out_path: Path):
-    # Save a deterministic-palette overlay of `pred` (uint8 class IDs) as RGB PNG.
-    # tab20 cycles for n_classes > 20; for our 5–22 class range this is fine.
+def _resolve_palette(n_classes: int, palette: Optional[List[List[int]]]) -> np.ndarray:
+    # Returns an (>=n_classes, 3) uint8 LUT. If `palette` is given, it must have
+    # at least n_classes rows in the dataset's class order (row i = color for
+    # class i); otherwise we fall back to matplotlib tab20. Hand-curated palettes
+    # let GOD/BASEPROD overlays color-match the published ontology keys
+    # (and the RADSeg viz grid), instead of getting an arbitrary tab20 mapping.
+    if palette is not None:
+        arr = np.asarray(palette, dtype=np.uint8)
+        assert arr.ndim == 2 and arr.shape[1] == 3, f"palette must be (N, 3) RGB, got {arr.shape}"
+        assert arr.shape[0] >= n_classes, (
+            f"palette has {arr.shape[0]} colors but dataset has {n_classes} classes"
+        )
+        return arr
     from matplotlib import cm
     cmap = cm.get_cmap("tab20", max(n_classes, 20))
-    palette = (np.array([cmap(i)[:3] for i in range(max(n_classes, 20))]) * 255).astype(np.uint8)
-    overlay = palette[pred]  # (H, W, 3)
+    return (np.array([cmap(i)[:3] for i in range(max(n_classes, 20))]) * 255).astype(np.uint8)
+
+
+def _save_palette_overlay(pred: np.ndarray, n_classes: int, out_path: Path,
+                          palette: Optional[List[List[int]]] = None):
+    lut = _resolve_palette(n_classes, palette)
+    overlay = lut[pred]  # (H, W, 3)
     Image.fromarray(overlay).save(out_path)
 
 
 def _save_3up(rgb_pil: Image.Image, gt: np.ndarray, pred: np.ndarray,
-              n_classes: int, out_path: Path):
+              n_classes: int, out_path: Path,
+              palette: Optional[List[List[int]]] = None):
     # Side-by-side: input RGB | GT palette | Pred palette. Used for a sparse sample
     # of frames so we can eyeball alignment / failure modes without needing all
     # overlays on disk.
-    from matplotlib import cm
-    cmap = cm.get_cmap("tab20", max(n_classes, 20))
-    palette = (np.array([cmap(i)[:3] for i in range(max(n_classes, 20))]) * 255).astype(np.uint8)
-
+    lut = _resolve_palette(n_classes, palette)
     h, w = pred.shape
     rgb_np = np.asarray(rgb_pil.resize((w, h)))
     # Treat any GT id >= n_classes (e.g. 255 ignore) as a black pixel rather than
     # crashing the palette lookup.
     gt_safe = np.where(gt < n_classes, gt, 0).astype(np.uint8)
-    gt_paint = palette[gt_safe]
-    pred_paint = palette[pred]
+    gt_paint = lut[gt_safe]
+    pred_paint = lut[pred]
     panel = np.concatenate([rgb_np, gt_paint, pred_paint], axis=1)
     Image.fromarray(panel).save(out_path)
 
@@ -112,11 +128,13 @@ def run_eval(
     num_overlay_samples: int = 12,
     ignore_label: int = 255,
     config_overrides: Optional[dict] = None,
+    palette: Optional[List[List[int]]] = None,
+    redraw_overlays_only: bool = False,
 ):
     # Args:
     #   dataset:      a torch Dataset that yields (image_f (4,H,W), label (H,W),
-    #                 name (str), th_vis (3,H,W)). The OpenRSS dataset adapters
-    #                 satisfy this contract.
+    #                 name (str)). The OpenRSS dataset adapters satisfy this
+    #                 contract.
     #   class_names:  list of N strings. class_names[0] MUST be "unknown".
     #   out_dir:      where to write preds/, overlays/, results.txt.
     #   modality:     "rgb" or "thermal" (= thermal-as-RGB replica).
@@ -128,6 +146,15 @@ def run_eval(
     #   config_overrides: optional dict of OTAS config keys to override (e.g.
     #                 {"enable_mask_refinement": True} to turn SAM2 on). Forwarded
     #                 verbatim to OTASEncoder; see otas_segmentor._DEFAULT_CONFIG.
+    #   palette:      optional (N, 3) per-class RGB LUT in dataset class order.
+    #                 If omitted, overlays use matplotlib tab20. Pass GOD's
+    #                 GREAT_OUTDOORS_UNKNOWN_PALETTE to color-match the RADSeg
+    #                 viz grid and the published GOD ontology key.
+    #   redraw_overlays_only: skip OTAS inference and metric computation; only
+    #                 re-render the sampled 3-up overlays from cached preds in
+    #                 <out_dir>/preds/. Used to refresh visualizations after a
+    #                 palette change without redoing the (slow) forward pass.
+    #                 Requires preds/ to already exist on disk.
     assert modality in {"rgb", "thermal"}, f"modality must be rgb|thermal, got {modality!r}"
 
     # Import the encoder here so OTAS only loads once per process (and not at module
@@ -141,7 +168,6 @@ def run_eval(
     overlays_dir.mkdir(parents=True, exist_ok=True)
 
     n_classes = len(class_names)
-    encoder = OTASEncoder(class_names=class_names, config_overrides=config_overrides)
 
     # We deliberately keep batch_size=1 because OTAS's language_map operates on PIL
     # images one at a time (DINOv2 forward is autograd-disabled but not batched in
@@ -152,15 +178,52 @@ def run_eval(
     # Pick `num_overlay_samples` evenly-spaced indices for the qualitative panels.
     overlay_indices = set(np.linspace(0, n_frames - 1, num=num_overlay_samples, dtype=int).tolist())
 
-    conf = np.zeros((n_classes, n_classes), dtype=np.int64)
-    t0 = time.time()
-
     chosen = (
         _tensor_to_pil_rgb if modality == "rgb" else _tensor_to_pil_thermal_as_rgb
     )
+
+    # Redraw-only fast path: skip OTAS, skip metrics, just re-render overlays
+    # from cached preds. Saves the ~5-min forward pass when we only want to
+    # refresh visualizations after a palette change.
+    if redraw_overlays_only:
+        redrawn = 0
+        for idx, batch in enumerate(loader):
+            if idx not in overlay_indices:
+                continue
+            image_f, label, name = batch
+            image_f = image_f.squeeze(0)
+            label_np = label.squeeze(0).numpy()
+            if isinstance(name, (list, tuple)):
+                name = name[0]
+            name = str(name)
+            pred_path = preds_dir / f"{name}.png"
+            if not pred_path.exists():
+                print(f"[redraw] missing cached pred {pred_path}, skipping")
+                continue
+            pred_pil = Image.open(pred_path)
+            # Cached preds may live at a different resolution than the current
+            # dataset grid (e.g. an earlier run cached at pylon-native 1080×1440;
+            # the current default is 480×640). Resize with NEAREST so the panel
+            # composes — preds remain the canonical authoritative cache on disk.
+            target_h, target_w = label_np.shape
+            if pred_pil.size != (target_w, target_h):
+                pred_pil = pred_pil.resize((target_w, target_h), Image.NEAREST)
+            preds = np.asarray(pred_pil, dtype=np.uint8)
+            pil = chosen(image_f)
+            _save_3up(pil, label_np, preds, n_classes, overlays_dir / f"{name}.png",
+                      palette=palette)
+            redrawn += 1
+        print(f"[{out_dir.name}] redrew {redrawn} overlays (modality={modality})")
+        return
+
+    encoder = OTASEncoder(class_names=class_names, config_overrides=config_overrides)
+
+    conf = np.zeros((n_classes, n_classes), dtype=np.int64)
+    t0 = time.time()
+
     pbar = tqdm(loader, desc=f"OTAS[{modality}] {out_dir.name}", total=n_frames)
     for idx, batch in enumerate(pbar):
-        image_f, label, name, _th_vis = batch
+        image_f, label, name = batch
         # DataLoader collates to a leading batch dim of 1 — strip it.
         image_f = image_f.squeeze(0)        # (4, H, W) float
         label_np = label.squeeze(0).numpy()  # (H, W) int64
@@ -189,7 +252,8 @@ def run_eval(
         Image.fromarray(preds).save(preds_dir / f"{name}.png")
 
         if idx in overlay_indices:
-            _save_3up(pil, label_np, preds, n_classes, overlays_dir / f"{name}.png")
+            _save_3up(pil, label_np, preds, n_classes, overlays_dir / f"{name}.png",
+                      palette=palette)
 
     elapsed = time.time() - t0
     iou = _iou_per_class(conf)
diff --git a/own_eval/otas_segmentor.py b/own_eval/otas_segmentor.py
index e32b942..11407c2 100644
--- a/own_eval/otas_segmentor.py
+++ b/own_eval/otas_segmentor.py
@@ -62,14 +62,19 @@
     # Model compilation is broken on some torch.compile + Blackwell combinations and
     # only matters for repeated calls inside a single process. Disable for stability.
     "enable_model_compilation": False,
-    # Default-resolution head from OTAS's repo config (matches OTAS_small.json for size
-    # but lifts shared_feat_resolution to 32 for better per-pixel detail before the
-    # bilinear upsample to original resolution).
-    "dinov2_input_size": 518,
+    # OTAS paper Table V / supplementary §VII.A configuration. These four knobs match
+    # the published RELLIS-3D backbone-ablation protocol verbatim:
+    #   - dinov2_input_size=224 yields DINOv2's native 16×16 patch grid (14-px patches),
+    #     which is then bilinear-interpolated up to the d=64 shared resolution.
+    #   - shared_feat_resolution=64 = the d=64 shared feature grid used by the paper.
+    #   - n_clusters=24, n_components=24 = k=24, Cr=24 from the paper.
+    # These apply to every dataset on the scoreboard, not just RELLIS, so the OTAS
+    # column reports numbers under a single internally consistent config.
+    "dinov2_input_size": 224,
     "dino_scale_factor": 2,
-    "shared_feat_resolution": 32,
+    "shared_feat_resolution": 64,
     "n_clusters": 24,
-    "n_components": 12,
+    "n_components": 24,
     "enable_amp_autocast": True,
 }
 
diff --git a/own_eval/own_RELLIS.py b/own_eval/own_RELLIS.py
index ecb31bc..42182b8 100644
--- a/own_eval/own_RELLIS.py
+++ b/own_eval/own_RELLIS.py
@@ -23,9 +23,7 @@
 # the RELLIS-3D replication is fully self-contained inside an OTAS checkout.
 sys.path.insert(0, str(Path(__file__).resolve().parent))  # eval_common, otas_segmentor, rellis_dataset
 
-from rellis_dataset import (
-    RELLIS_dataset, RELLIS_CLASS_NAMES, RELLIS_HRNET_CLASS_NAMES,
-)
+from rellis_dataset import RELLIS_dataset, RELLIS_CLASS_NAMES
 from eval_common import run_eval
 
 
@@ -36,74 +34,50 @@ def main():
     parser.add_argument("--split", default="test",
                         help="One of train|val|test (each .lst file has 2 cols: <img> <label>).")
     parser.add_argument("--out_root", default="/home/ubuntu/code/OTAS/result/Pred")
-    parser.add_argument("--input_h", type=int, default=480,
-                        help="Resize target H. Default 480 matches every other OTAS row "
-                             "and is what the paper presumably used (the OTAS_small.json "
-                             "shipped config defaults are 480x640).")
-    parser.add_argument("--input_w", type=int, default=640)
+    # input_h/input_w default to None → RELLIS_dataset returns frames at native
+    # 1920×1200 with no resize. DINOv2 always resizes internally to
+    # dinov2_input_size (224), so the dataset H/W only controls the GT scoring
+    # grid and the bilinear pred-upsample target — native is the right answer
+    # for DINOv2. The paper §VII.A wording of "1024×1024" was specifically
+    # about getting AM-RADIO/DINOv3's 16-pixel patches to land exactly on the
+    # d=64 shared grid, not about DINOv2 (which the OTAS repo ships as
+    # default). Pass explicit --input_h --input_w to override.
+    parser.add_argument("--input_h", type=int, default=None)
+    parser.add_argument("--input_w", type=int, default=None)
     parser.add_argument("--enable_mask_refinement", action="store_true",
-                        help="Turn OTAS SAM2 mask refinement on. Paper Table V Row 4 "
-                             "(OTAS w. DINOv2 ViT-S/14 = 48.48 mIoU) uses --no-SAM (i.e. "
-                             "this flag omitted). Output dir gets '_sam' suffix when set.")
-    parser.add_argument("--ontology", default="raw20", choices=["raw20", "hrnet19"],
-                        help="Which RELLIS ontology to evaluate. raw20 = 20 classes "
-                             "(unknown + 19 raw fg, matches RADSeg's wiring). hrnet19 = "
-                             "19 classes (unknown + 18 fg) under HRNet's label_mapping "
-                             "(canonical 2D RELLIS benchmark — likely what the OTAS paper "
-                             "Table V reports on).")
-    parser.add_argument("--paper_config", action="store_true",
-                        help="Match the OTAS paper Table V / supplementary §VII.A config "
-                             "for RELLIS-3D: input image resized to 1024x1024 (matches "
-                             "the paper's 'Input images are resized accordingly to "
-                             "1024×1024'), shared_feat_resolution=64, n_components=24, "
-                             "dinov2_input_size=224 (DINOv2 internally extracts a 16x16 "
-                             "grid, bilinear-interpolated up to d=64). No mask refinement, "
-                             "no negative prompt, all 20 ontology.yaml class names as "
-                             "positive prompts. Output dir gets '_paper' suffix.")
+                        help="Turn OTAS SAM2 mask refinement on. Paper Table V uses "
+                             "no mask refinement; this flag is for ablation only.")
     parser.add_argument("--out_suffix", default=None,
                         help="Override the output dir suffix. Default: '_sam' if SAM on, "
-                             "'_hrnet19' if --ontology=hrnet19, '_paper' if --paper_config, "
-                             "concatenated as needed. Set explicitly to override.")
+                             "empty otherwise. Set explicitly to override.")
     args = parser.parse_args()
 
     if args.out_suffix is None:
-        suffix = "_hrnet19" if args.ontology == "hrnet19" else ""
-        if args.paper_config:
-            suffix += "_paper"
-        if args.enable_mask_refinement:
-            suffix += "_sam"
+        suffix = "_sam" if args.enable_mask_refinement else ""
     else:
         suffix = args.out_suffix
     out_dir = Path(args.out_root) / f"RELLIS_rgb{suffix}"
 
-    # --paper_config also overrides the dataset input H/W to 1024x1024 (per §VII.A).
-    # CLI-provided --input_h/--input_w still wins if explicitly set above the default.
     input_h, input_w = args.input_h, args.input_w
-    if args.paper_config and (input_h, input_w) == (480, 640):  # defaults — bump them
-        input_h, input_w = 1024, 1024
-        print(f"[own_RELLIS] --paper_config: bumping dataset input to {input_h}x{input_w}")
 
     dataset = RELLIS_dataset(
         data_dir=args.data_dir,
         split=args.split,
         input_h=input_h,
         input_w=input_w,
-        mask_modality="none",
-        ontology=args.ontology,
     )
-    class_names = (RELLIS_HRNET_CLASS_NAMES
-                   if args.ontology == "hrnet19" else RELLIS_CLASS_NAMES)
+    class_names = RELLIS_CLASS_NAMES
 
     # Smoke-check: make sure the dataset loaded sane label values before paying the
     # 10-minute encoder warmup + ~1672-frame eval cost. Same invariant as RADSeg's
     # verify_rellis.py "(3) GT remap on real frames" check.
-    print(f"[own_RELLIS] ontology={args.ontology} ({len(class_names)} classes); "
+    print(f"[own_RELLIS] {len(class_names)} classes; "
           f"dataset size: {len(dataset)} frames; sample IDs in 3 frames:")
     import numpy as np
     valid = set(range(len(class_names)))
     seen = set()
     for i in (0, len(dataset) // 2, len(dataset) - 1):
-        _, lbl, name, _ = dataset[i]
+        _, lbl, name = dataset[i]
         ids = set(np.unique(lbl.numpy()).tolist())
         leaks = ids - valid
         assert not leaks, f"frame {i} ({name}) leaked GT values: {sorted(leaks)}"
@@ -111,21 +85,10 @@ def main():
         print(f"  frame {i:>4} ({name}): GT ids = {sorted(ids)}")
     print(f"[own_RELLIS] union of GT ids over 3 frames: {sorted(seen)} (all in 0..{len(class_names)-1})\n")
 
+    # OTAS paper Table V / §VII.A defaults — shared_feat_resolution=64, n_components=24,
+    # dinov2_input_size=224, k=24, no mask refinement — are now baked into
+    # otas_segmentor.py:_DEFAULT_CONFIG, so this driver doesn't need to override them.
     config_overrides = {"enable_mask_refinement": bool(args.enable_mask_refinement)}
-    if args.paper_config:
-        # OTAS paper Table V / §VII.A: 64x64 shared patch grid, 24 PCA components,
-        # DINOv2 input 224 to yield a native 16x16 grid (which OTAS bilinearly
-        # interpolates up to the 64x64 shared resolution). k=24 is already the
-        # OTAS default. No negative prompt, no mask refinement, all 20 ontology.yaml
-        # class names as positive prompts (this driver always passes class_names
-        # as the positive set and OTASEncoder treats them as a 20-way argmax).
-        config_overrides.update({
-            "shared_feat_resolution": 64,
-            "n_components": 24,
-            "dinov2_input_size": 224,
-        })
-        print(f"[own_RELLIS] --paper_config: overriding "
-              f"shared_feat_resolution=64, n_components=24, dinov2_input_size=224")
     run_eval(
         dataset=dataset,
         class_names=class_names,
diff --git a/own_eval/own_RELLIS_paper.py b/own_eval/own_RELLIS_paper.py
new file mode 100644
index 0000000..3a711bb
--- /dev/null
+++ b/own_eval/own_RELLIS_paper.py
@@ -0,0 +1,358 @@
+# OTAS Table V replication on RELLIS-3D under the protocol Simon Schwaiger confirmed
+# in https://github.com/SimonSchwaiger/otas/pull/2 (review comment, 2026-05).
+#
+# Protocol — verbatim from Simon's PR comment:
+#     class_prompts = {1: "dirt", 6: "water", 10: "asphalt",
+#                      19: "bush", 33: "mud", 34: "rubble"}   # raw RELLIS IDs
+#     neg_prompts = ["thing"]
+#     threshold_value = 0.8
+#
+# This is a 6-class binary-per-class evaluation, NOT the 20-class argmax our existing
+# own_RELLIS.py runs. Each of the 6 terrain classes is scored independently as a binary
+# segmentation task. For class c at every pixel:
+#   1. lr_sims_norm = min-max-normalised( sim(img, "c") - sim(img, "thing") )
+#   2. pred_c = (lr_sims_norm > 0.8)            # threshold-binarised, no argmax
+#   3. gt_c   = (raw_label == raw_id_of_c)
+#   4. TP/FP/FN accumulated independently per class across all 1672 test-split frames
+#   5. mIoU = mean over 6 classes of TP / (TP + FP + FN)
+#
+# This differs structurally from own_RELLIS.py:
+#   - own_RELLIS.py: 20 class names as positive prompts, no negative prompt, per-pixel
+#     argmax across the 20 score maps, mIoU computed via 20×20 confusion matrix. Got
+#     15.66 full / 16.48 fg-only mIoU on the 1672-frame test split.
+#   - own_RELLIS_paper.py (this file): 6 class names looped one-by-one as pos prompt,
+#     "thing" as neg prompt, threshold@0.8 per class, mIoU computed from per-class
+#     binary TP/FP/FN. Target: paper's Table V claim of 48.48 mIoU.
+#
+# This driver calls OTAS's `semantic_mask.similarity(...)` + threshold directly rather
+# than reusing the multi-class OTASEncoder adapter in otas_segmentor.py, because:
+#   - The N-way argmax adapter was designed for the apples-to-apples cross-system
+#     scoreboard (RADSeg / OpenRSS / OTAS all do N-way argmax). The paper's per-class
+#     threshold protocol doesn't fit that mould.
+#   - OTAS's `semantic_mask.similarity` already returns the min-max-normalised score
+#     map in [0,1] that the threshold acts on. Reusing it verbatim guarantees we're
+#     scoring against the exact normalisation OTAS itself uses internally.
+
+import argparse
+import os
+import sys
+import time
+from pathlib import Path
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from PIL import Image
+from tqdm import tqdm
+
+# Make own_eval/ importable for rellis_dataset.
+_OWN_EVAL_DIR = str(Path(__file__).resolve().parent)
+if _OWN_EVAL_DIR not in sys.path:
+    sys.path.insert(0, _OWN_EVAL_DIR)
+
+from rellis_dataset import RELLIS_dataset  # reuses the existing PNG/LUT pipeline
+
+
+# Simon's mapping: raw RELLIS ontology IDs -> bare class-name prompts. Order is fixed so
+# the per-class IoU table is deterministic; per-class IoU mean is order-invariant.
+PAPER_CLASS_PROMPTS = [
+    (1,  "dirt"),
+    (6,  "water"),
+    (10, "asphalt"),
+    (19, "bush"),
+    (33, "mud"),
+    (34, "rubble"),
+]
+NEG_PROMPTS = ["thing"]
+THRESHOLD_VALUE = 0.8
+
+
+def _resolve_otas():
+    # Add OTAS src/ to sys.path and import model/vision_utils. Mirrors the lazy import
+    # dance otas_segmentor.OTASEncoder does so the heavy DINOv2/MaskCLIP loads only fire
+    # once and only after OTAS_CONFIG_PATH is set.
+    src = str(Path(__file__).resolve().parent.parent / "src")
+    if src not in sys.path:
+        sys.path.insert(0, src)
+    import model  # noqa: E402
+    import vision_utils  # noqa: E402
+    return model, vision_utils
+
+
+def _write_config(preset: str = "paper_vii_a", custom_overrides=None):
+    # Same config-tempfile trick otas_segmentor uses: write a JSON file holding hyperparameters
+    # + SAM/spatial toggles, point OTAS_CONFIG_PATH at it.
+    #
+    # Two presets:
+    #   "paper_vii_a"           - §VII.A overrides: d=64, Cr=24, k=24, dinov2_input_size=224.
+    #                             Mask refinement off, spatial off. Same overrides our
+    #                             20-class own_RELLIS.py uses.
+    #   "first_commit_defaults" - Only override the SAM/spatial/compilation toggles. Lets the
+    #                             first-commit `src/config.py` defaults drive shared_feat_resolution
+    #                             (32), n_components (48), n_clusters (24) and dinov2_input_size
+    #                             (effectively 518 via dinov2_params img_size). Simon recommended
+    #                             "switching to the first commit of this repository" in PR #2; this
+    #                             preset is the literal default config from that commit minus the
+    #                             SAM toggle (which would also load Open3D + sam2 weights).
+    import json
+    if preset == "paper_vii_a":
+        cfg = {
+            "enable_mask_refinement": False,   # Table V is SAM-off (confirmed in paper §VII.A)
+            "enable_spatial": False,
+            "enable_model_compilation": False,
+            "dinov2_input_size": 224,          # §VII.A
+            "dino_scale_factor": 2,
+            "shared_feat_resolution": 64,      # §VII.A (d=64)
+            "n_clusters": 24,                  # §VII.A (k=24)
+            "n_components": 24,                # §VII.A (Cr=24)
+            "enable_amp_autocast": True,
+        }
+    elif preset == "first_commit_defaults":
+        cfg = {
+            "enable_mask_refinement": False,   # off so we don't need SAM2 weights
+            "enable_spatial": False,           # off so Open3D doesn't load
+            "enable_model_compilation": False, # off; current main turns this on but it adds
+                                               # 30 s of cold-start with no inference effect
+            "enable_amp_autocast": True,
+            # NO override of d / n_components / n_clusters / dinov2_input_size: lets the
+            # first-commit src/config.py defaults win (d=32, Cr=48, k=24, dinov2_input_size
+            # not in config dict so the dinov2_params img_size=518 effectively applies).
+        }
+    else:
+        raise ValueError(f"Unknown preset: {preset!r}")
+    if custom_overrides:
+        cfg.update(custom_overrides)
+    cfg_path = Path("/tmp") / f"otas_paper_cfg_{os.getpid()}.json"
+    cfg_path.write_text(json.dumps(cfg))
+    return str(cfg_path)
+
+
+@torch.no_grad()
+def _per_class_pred(language_map, semantic_mask_inst, pil_img, class_name, neg_prompts,
+                    threshold, target_h, target_w):
+    # Returns a uint8 (target_h, target_w) binary mask of where the per-class threshold
+    # fires under OTAS's own normalisation. Mirrors what `binary_mask_interpolated` does
+    # internally but lets us share the language_map.embed_image call across all 6
+    # classes for one image, instead of paying that cost 6× per frame.
+    pooled = language_map.embed_image(pil_img)              # (H_lr, W_lr, D)
+    lr_sims_norm = semantic_mask_inst.similarity(
+        shared_feature_map=pooled,
+        pos_prompts=[class_name],
+        neg_prompts=neg_prompts,
+    )                                                       # (H_lr, W_lr) in [0,1]
+    binary = (lr_sims_norm > threshold).to(pooled.dtype)
+    binary_up = F.interpolate(
+        binary.unsqueeze(0).unsqueeze(0),
+        size=(target_h, target_w),
+        mode="nearest",                                     # matches binary_mask_interpolated
+    ).squeeze().to(torch.uint8).cpu().numpy()
+    return binary_up
+
+
+@torch.no_grad()
+def _per_frame_six_classes(language_map, semantic_mask_inst, pil_img,
+                           class_names, neg_prompts, threshold, target_h, target_w):
+    # Computes all 6 per-class binary masks for one frame in a single
+    # `language_map.embed_image` call (the expensive part) + 6 cheap
+    # `semantic_mask.similarity` einsums + 6 NEAREST upsamples.
+    # Returns (6, target_h, target_w) uint8 stack in the order of `class_names`.
+    pooled = language_map.embed_image(pil_img)              # (H_lr, W_lr, D) — ONCE per frame
+    out = np.zeros((len(class_names), target_h, target_w), dtype=np.uint8)
+    for i, name in enumerate(class_names):
+        lr_sims_norm = semantic_mask_inst.similarity(
+            shared_feature_map=pooled,
+            pos_prompts=[name],
+            neg_prompts=neg_prompts,
+        )                                                   # (H_lr, W_lr) in [0,1]
+        binary = (lr_sims_norm > threshold).to(pooled.dtype)
+        binary_up = F.interpolate(
+            binary.unsqueeze(0).unsqueeze(0),
+            size=(target_h, target_w),
+            mode="nearest",
+        ).squeeze().to(torch.uint8).cpu().numpy()
+        out[i] = binary_up
+    return out
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--data_dir", default="/home/ubuntu/mnt/rellis_3d/Rellis-3D")
+    parser.add_argument("--split", default="test")
+    parser.add_argument("--out_root", default="/home/ubuntu/code/OTAS/result/Pred")
+    parser.add_argument("--input_h", type=int, default=None,
+                        help="Optional resize height. Default: native 1200.")
+    parser.add_argument("--input_w", type=int, default=None,
+                        help="Optional resize width. Default: native 1920.")
+    parser.add_argument("--threshold", type=float, default=THRESHOLD_VALUE,
+                        help=f"Per-class binary threshold. Default {THRESHOLD_VALUE} "
+                             "(Simon's PR comment).")
+    parser.add_argument("--out_suffix", default="_paper",
+                        help="Output dir suffix. Default '_paper' so this lands at "
+                             "result/Pred/RELLIS_rgb_paper/ alongside the 20-class "
+                             "argmax run at result/Pred/RELLIS_rgb/.")
+    parser.add_argument("--save_preds", action="store_true",
+                        help="Cache the (6, H, W) binary stack per frame. Off by "
+                             "default — disk cost is ~6× the 20-class run.")
+    parser.add_argument("--num_overlay_samples", type=int, default=12)
+    parser.add_argument("--max_frames", type=int, default=None,
+                        help="Cap frames evaluated. Default None (full split). "
+                             "Set e.g. 5 for a smoke test.")
+    parser.add_argument("--config_preset", default="paper_vii_a",
+                        choices=["paper_vii_a", "first_commit_defaults"],
+                        help="paper_vii_a: §VII.A overrides (d=64, Cr=24, k=24, "
+                             "dinov2_input_size=224). first_commit_defaults: only "
+                             "override SAM/spatial/compilation toggles; leaves "
+                             "src/config.py defaults (d=32, Cr=48, dinov2 input 518) "
+                             "intact. Use the latter against a 6aec2d4 worktree to "
+                             "follow Simon's 'switch to the first commit' suggestion.")
+    args = parser.parse_args()
+
+    # Eager-import OTAS first so config knobs land in os.environ before model.py runs.
+    cfg_path = _write_config(preset=args.config_preset)
+    os.environ["OTAS_CONFIG_PATH"] = cfg_path
+    model, vision_utils = _resolve_otas()
+    config = model.config
+
+    print(f"[own_RELLIS_paper] OTAS config: shared_feat_resolution="
+          f"{config.get('shared_feat_resolution')}, n_clusters={config.get('n_clusters')}, "
+          f"n_components={config.get('n_components')}, dinov2_input_size="
+          f"{config.get('dinov2_input_size')}, enable_mask_refinement="
+          f"{config.get('enable_mask_refinement')}")
+
+    language_map = model.language_map(config=config)
+    semantic_mask_inst = model.semantic_mask(config=config)
+
+    # Dataset — reuse the 20-class RELLIS_dataset, but we only consume raw_label values
+    # via the existing LUT. We bypass the contig 0..19 mapping by recomputing GT from
+    # the raw label PNG inside the loop (the LUT collapses gaps to 0, so we can read
+    # raw IDs directly from the PNG).
+    dataset = RELLIS_dataset(
+        data_dir=args.data_dir,
+        split=args.split,
+        input_h=args.input_h,
+        input_w=args.input_w,
+    )
+    print(f"[own_RELLIS_paper] dataset: {len(dataset)} frames, native resize: "
+          f"{args.input_h}×{args.input_w} (None means dataset-native)")
+
+    # Per-class accumulators. Each is a length-6 array indexed by paper-class-order.
+    raw_ids = np.array([rid for (rid, _) in PAPER_CLASS_PROMPTS], dtype=np.int64)
+    class_names = [n for (_, n) in PAPER_CLASS_PROMPTS]
+    n_cls = len(class_names)
+    tp = np.zeros(n_cls, dtype=np.int64)
+    fp = np.zeros(n_cls, dtype=np.int64)
+    fn = np.zeros(n_cls, dtype=np.int64)
+
+    out_dir = Path(args.out_root) / f"RELLIS_rgb{args.out_suffix}"
+    overlays_dir = out_dir / "overlays"
+    preds_dir = out_dir / "preds"
+    overlays_dir.mkdir(parents=True, exist_ok=True)
+    if args.save_preds:
+        preds_dir.mkdir(parents=True, exist_ok=True)
+
+    n_frames = len(dataset)
+    if args.max_frames is not None:
+        n_frames = min(n_frames, args.max_frames)
+        print(f"[own_RELLIS_paper] capping eval to first {n_frames} frames (--max_frames)")
+    overlay_indices = set(np.linspace(0, max(n_frames - 1, 1),
+                                      num=min(args.num_overlay_samples, n_frames),
+                                      dtype=int).tolist())
+
+    t0 = time.time()
+    pbar = tqdm(range(n_frames), desc=f"OTAS-paper[{args.split}]")
+    for idx in pbar:
+        image_f, _label_contig, name = dataset[idx]
+        # We need the RAW RELLIS label (not the contig 0..19 remapped one) so we can
+        # compare against Simon's raw-ID mapping directly. Pull it via the dataset's
+        # path bookkeeping — cheaper than re-mapping from contig back to raw.
+        img_rel, label_rel = dataset.pairs[idx]
+        raw_label_path = os.path.join(dataset.data_dir, label_rel)
+        raw_label = np.asarray(Image.open(raw_label_path))   # uint8 (1200, 1920)
+        # Honour --input_h/--input_w resize. If the dataset is in native mode (None),
+        # raw_label is already the right shape.
+        if args.input_h is not None and args.input_w is not None:
+            raw_label = np.asarray(
+                Image.fromarray(raw_label).resize((args.input_w, args.input_h),
+                                                  resample=Image.NEAREST))
+        target_h, target_w = raw_label.shape
+
+        rgb = (image_f[:3].numpy().clip(0, 1) * 255).astype(np.uint8).transpose(1, 2, 0)
+        pil = Image.fromarray(rgb, mode="RGB")
+
+        binary_stack = _per_frame_six_classes(
+            language_map=language_map,
+            semantic_mask_inst=semantic_mask_inst,
+            pil_img=pil,
+            class_names=class_names,
+            neg_prompts=NEG_PROMPTS,
+            threshold=args.threshold,
+            target_h=target_h,
+            target_w=target_w,
+        )                                                    # (6, H, W) uint8
+
+        # Per-class binary IoU accumulator.
+        for c, raw_id in enumerate(raw_ids):
+            gt_c = (raw_label == raw_id)
+            pred_c = binary_stack[c].astype(bool)
+            tp[c] += np.logical_and(gt_c, pred_c).sum()
+            fp[c] += np.logical_and(~gt_c, pred_c).sum()
+            fn[c] += np.logical_and(gt_c, ~pred_c).sum()
+
+        if args.save_preds:
+            # Save as a single (6, H, W) uint8 npz — one file per frame.
+            np.savez_compressed(preds_dir / f"{name}.npz", binary_stack=binary_stack)
+
+        if idx in overlay_indices:
+            # 3-up per class would be busy; instead make a tiled (input + 6 binary)
+            # overlay so the 12 sampled frames are skimmable.
+            tile_h = target_h // 2
+            tile_w = target_w // 2
+            input_small = np.asarray(pil.resize((tile_w, tile_h)))
+            tiles = [input_small]
+            for c, name_c in enumerate(class_names):
+                bin_small = np.asarray(
+                    Image.fromarray((binary_stack[c] * 255).astype(np.uint8))
+                    .resize((tile_w, tile_h), Image.NEAREST))
+                tile_rgb = np.stack([bin_small] * 3, axis=-1)
+                tiles.append(tile_rgb)
+            row0 = np.concatenate(tiles[:4], axis=1)
+            row1 = np.concatenate(tiles[4:] + [np.zeros_like(tiles[0])], axis=1)
+            panel = np.concatenate([row0, row1], axis=0)
+            Image.fromarray(panel).save(overlays_dir / f"{name}.png")
+
+    elapsed = time.time() - t0
+    denom = tp + fp + fn
+    iou = np.where(denom > 0, tp / np.maximum(denom, 1e-12), np.nan)
+    miou = float(np.nanmean(iou))
+
+    with open(out_dir / "results.txt", "w") as f:
+        f.write(f"# OTAS eval — Table V paper protocol (Simon's PR #2 review comment)\n")
+        f.write(f"protocol: 6-class binary per-class, neg=['thing'], threshold={args.threshold}\n")
+        f.write(f"split: {args.split}\n")
+        f.write(f"n_frames: {n_frames}\n")
+        f.write(f"n_classes: {n_cls}\n")
+        f.write(f"input_h: {args.input_h}\n")
+        f.write(f"input_w: {args.input_w}\n")
+        f.write(f"elapsed_seconds: {elapsed:.1f}\n")
+        f.write(f"mIoU_6cls: {miou * 100:.4f}\n")
+        f.write("\nper_class_IoU:\n")
+        for c, name in enumerate(class_names):
+            val = iou[c]
+            val_str = "nan" if np.isnan(val) else f"{val * 100:.4f}"
+            f.write(f"  {name} (raw id {raw_ids[c]}): {val_str}   "
+                    f"tp={int(tp[c])} fp={int(fp[c])} fn={int(fn[c])}\n")
+        f.write(f"\nthreshold: {args.threshold}\n")
+        f.write(f"neg_prompts: {NEG_PROMPTS}\n")
+        f.write(f"pos_prompts: {[n for (_, n) in PAPER_CLASS_PROMPTS]}\n")
+        f.write(f"raw_id_to_prompt: {dict(PAPER_CLASS_PROMPTS)}\n")
+
+    print(f"\n[own_RELLIS_paper] mIoU(6cls) = {miou * 100:.2f}%   "
+          f"({n_frames} frames, {elapsed:.0f}s)")
+    print("per-class IoU:")
+    for c, name in enumerate(class_names):
+        val_str = "nan" if np.isnan(iou[c]) else f"{iou[c] * 100:6.2f}%"
+        print(f"  {name:<10s} (raw id {raw_ids[c]:>2d}): {val_str}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/own_eval/rellis_dataset.py b/own_eval/rellis_dataset.py
index c46ed72..1343e4a 100644
--- a/own_eval/rellis_dataset.py
+++ b/own_eval/rellis_dataset.py
@@ -1,9 +1,10 @@
 # RELLIS-3D Dataset (Texas A&M off-road autonomous-driving benchmark) loader for OTAS.
 #
-# Yields `(image_f (4,H,W), label (H,W), name_safe (str), th_vis (3,H,W))` tuples — the
-# same shape the OTAS `own_eval/eval_common.run_eval` loop expects. Self-contained so the
-# RELLIS-3D replication can be reproduced from a single OTAS checkout, no sibling repos
-# required.
+# Yields `(image_f (4,H,W), label (H,W), name_safe (str))` tuples — the same shape the
+# OTAS `own_eval/eval_common.run_eval` loop expects. Self-contained so the RELLIS-3D
+# replication can be reproduced from a single OTAS checkout, no sibling repos required.
+# Mirrors `/home/ubuntu/code/OpenRSS/util/RELLIS_dataset.py` one-for-one — keep them in
+# sync if you change one.
 #
 # RELLIS-3D ships:
 #   - RGB:  pylon_camera_node/<seq>/<stem>.jpg            (1920x1200)
@@ -24,8 +25,17 @@
 # `RemapRellisUnknownLabel` does in RADSeg/evaluation/2d/custom_datasets.py — same
 # mapping, same class order.
 #
-# Returned tuple matches GOD_dataset's contract so eval_common.run_eval works unchanged:
-#   (image_f (4,H,W) float[0,1] R G B 0, label (H,W) int64 in 0..19, name_safe (str), th_vis (3,H,W) float)
+# Modality contract: RELLIS has only one valid eval mode (RGB). There is no `mask_modality`
+# argument and no thermal channel — earlier revisions accepted a `mask_modality` flag for
+# "API parity with GOD_dataset", but the four-way enum (`none`/`rgb_only`/`thermal_only`)
+# was a semantic lie on RELLIS: `none` = "RGB + zero-padded T" (not RGB+T fusion); `rgb_only`
+# was a no-op (the T was already zero); `thermal_only` silently produced an all-zero input
+# and ran garbage IoU. No caller exercised any mode other than `none`, so the parameter has
+# been removed.
+#
+# Returned tuple: `(image_f (4,H,W) float[0,1] R G B 0, label (H,W) int64 in 0..19,
+# name_safe (str))`. The 4th channel is constant zero (no thermal sensor) — kept on the
+# tensor only so the same SAM 4-channel input convention works.
 
 import os
 import numpy as np
@@ -33,7 +43,6 @@
 from torch.utils.data.dataset import Dataset
 import PIL
 from PIL import Image
-from matplotlib import cm
 
 
 # Order matches Rellis-3D/ontology.yaml + RADSeg's RELLIS_UNKNOWN_CLASSES. Singular `tree`
@@ -66,79 +75,20 @@ def _build_remap_lut() -> np.ndarray:
 _REMAP_LUT = _build_remap_lut()
 
 
-# --- HRNet 19-class learning ontology (the canonical 2D RELLIS benchmark setup) ---------
-#
-# Source: benchmarks/HRNet-Semantic-Segmentation-HRNet-OCR/lib/datasets/rellis.py:label_mapping.
-# Raw void + dirt collapse to a single contig 0 "unknown" — siglip2/MaskCLIP can't ground
-# bare "void"/"dirt" reliably so the HRNet-trained baseline lumps them, and we follow suit
-# for OVSS replication. Raw 32 (out-of-ontology) -> water, raw 29/30 -> grass per the
-# HRNet remap; these are dataset-internal special cases that don't appear in the official
-# 20-name ontology but are non-zero in the released label PNGs (rare). 19 contig classes
-# total (1..18 fg + 0 unknown), the same shape published RELLIS-3D 2D HRNet/GSCNN results
-# table is reported on.
-#
-# Class string ordering follows the remapped-ID order so contig 1 = grass, contig 2 = tree,
-# … contig 18 = rubble. Same wording as the 20-class variant (singular `tree`).
-RELLIS_HRNET_CLASS_NAMES = [
-    "unknown",     # 0 — raw 0 (void) ∪ raw 1 (dirt). bare-name grounded as best-effort.
-    "grass",       # 1 — raw 3, 29, 30
-    "tree",        # 2 — raw 4
-    "pole",        # 3 — raw 5
-    "water",       # 4 — raw 6, 32
-    "sky",         # 5 — raw 7
-    "vehicle",     # 6 — raw 8
-    "object",      # 7 — raw 9
-    "asphalt",     # 8 — raw 10
-    "building",    # 9 — raw 12
-    "log",         # 10 — raw 15
-    "person",      # 11 — raw 17
-    "fence",       # 12 — raw 18
-    "bush",        # 13 — raw 19
-    "concrete",    # 14 — raw 23
-    "barrier",     # 15 — raw 27
-    "puddle",      # 16 — raw 31
-    "mud",         # 17 — raw 33
-    "rubble",      # 18 — raw 34
-]
-RELLIS_HRNET_NUM_CLASSES = len(RELLIS_HRNET_CLASS_NAMES)  # 19
-
-# Verbatim from benchmarks/HRNet-Semantic-Segmentation-HRNet-OCR/lib/datasets/rellis.py.
-RELLIS_HRNET_RAW_TO_CONTIGUOUS = {
-    0: 0, 1: 0, 3: 1, 4: 2, 5: 3, 6: 4, 7: 5, 8: 6, 9: 7, 10: 8,
-    12: 9, 15: 10, 17: 11, 18: 12, 19: 13, 23: 14, 27: 15,
-    29: 1, 30: 1,  # special-case raw ids the HRNet loader treats as grass
-    31: 16, 32: 4,  # raw 32 -> water per HRNet
-    33: 17, 34: 18,
-}
-
-
-def _build_hrnet_remap_lut() -> np.ndarray:
-    # Default 0 (unknown) so any raw id not explicitly listed lands at 0 — including the
-    # ontology-gap ids and any future sensor-noise values. Matches HRNet's behaviour where
-    # the default-init mapping is to ignore.
-    lut = np.zeros(256, dtype=np.uint8)
-    for raw, mapped in RELLIS_HRNET_RAW_TO_CONTIGUOUS.items():
-        lut[raw] = mapped
-    return lut
-
-
-_HRNET_REMAP_LUT = _build_hrnet_remap_lut()
-
-
 class RELLIS_dataset(Dataset):
-    # Yields (image_tensor (4,H,W) float[0,1], label_tensor (H,W) int64, name_safe (str),
-    # th_vis (3,H,W) float[0,1]) so OTAS's eval_common.run_eval can consume it unchanged.
+    # Yields (image_tensor (4,H,W) float[0,1] with channel 3 = constant zero, label_tensor
+    # (H,W) int64, name_safe (str)) so OTAS's eval_common.run_eval can consume it unchanged.
     #
     # `data_dir` should point at the extracted Rellis-3D root (the directory containing the
     # split lists and the 5 sequence subdirs 00000..00004). The split list is read directly
     # from `<data_dir>/<split>.lst` — no separate `split_dir` is needed; RELLIS ships them
     # at the dataset root.
-    #
-    # `mask_modality` is accepted for API parity with GOD_dataset (so any test loop that
-    # branches on it still works) but only "none" makes sense here — RELLIS has no thermal,
-    # so zeroing R/G/B vs the always-zero thermal channel is meaningless.
-    def __init__(self, data_dir, split="test", split_dir=None, input_h=480, input_w=640,
-                 transform=None, cm_type="jet", mask_modality="none", ontology="raw20"):
+    def __init__(self, data_dir, split="test", split_dir=None, input_h=None, input_w=None,
+                 transform=None):
+        # input_h/input_w default to None — when unset the Basler pylon JPGs
+        # and matching label PNGs (both 1920×1200 natively) are returned at
+        # their native shape with no resize. Pass explicit (input_h, input_w)
+        # to score on a custom grid.
         super().__init__()
         self.data_dir = data_dir
         # split_dir is accepted for API parity with GOD_dataset but ignored — RELLIS ships
@@ -148,26 +98,8 @@ def __init__(self, data_dir, split="test", split_dir=None, input_h=480, input_w=
         self.input_h = input_h
         self.input_w = input_w
         self.transform = transform or []
-        self.cm_type = cm_type
-        if mask_modality not in {"none", "rgb_only", "thermal_only"}:
-            raise ValueError(
-                f"mask_modality must be one of none|rgb_only|thermal_only, got {mask_modality!r}")
-        self.mask_modality = mask_modality
-        # ontology controls which LUT + class list the loader uses:
-        #   "raw20"  — 20 classes (1 unknown + 19 fg), unknown-incl raw RELLIS ontology
-        #              (parallel to RADSeg's RellisUnknownInclDataset).
-        #   "hrnet19" — 19 classes (1 unknown + 18 fg) under HRNet's `label_mapping`. Used
-        #              for replicating the canonical 2D RELLIS benchmark numbers (likely
-        #              what the OTAS paper Table V reports on).
-        if ontology not in {"raw20", "hrnet19"}:
-            raise ValueError(f"ontology must be raw20|hrnet19, got {ontology!r}")
-        self.ontology = ontology
-        if ontology == "raw20":
-            self._lut = _REMAP_LUT
-            self.class_names = RELLIS_CLASS_NAMES
-        else:
-            self._lut = _HRNET_REMAP_LUT
-            self.class_names = RELLIS_HRNET_CLASS_NAMES
+        self._lut = _REMAP_LUT
+        self.class_names = RELLIS_CLASS_NAMES
 
         # Parse the split file. Each line has two whitespace-separated relative paths.
         split_path = os.path.join(self.split_dir, split + ".lst")
@@ -193,60 +125,61 @@ def __getitem__(self, index):
         stem, _ext = os.path.splitext(img_rel)
         name_safe = stem.replace("/", "_")
 
-        # RGB at 1920x1200 -> bilinear resize to (input_h, input_w)
+        # RGB at 1920x1200; resize to (input_h, input_w) if those are set, else
+        # keep native.
         rgb_path = os.path.join(self.data_dir, img_rel)
         rgb = np.asarray(PIL.Image.open(rgb_path).convert("RGB"))  # (1200, 1920, 3) uint8
-        rgb_resized = np.asarray(
-            PIL.Image.fromarray(rgb).resize((self.input_w, self.input_h),
-                                            resample=PIL.Image.BILINEAR)
-        )  # (input_h, input_w, 3) uint8
-
-        # Synthetic zero thermal channel — RELLIS-3D has no thermal sensor. The 4-channel
-        # contract is preserved so eval_common doesn't need a separate code path.
-        th_resized = np.zeros((self.input_h, self.input_w), dtype=np.uint8)
-
-        # Modality-ablation hook for API parity with GOD_dataset. On RELLIS rgb_only is the
-        # natural state; thermal_only would zero out everything and is meaningless here.
-        if self.mask_modality == "rgb_only":
-            th_resized = np.zeros_like(th_resized)
-        elif self.mask_modality == "thermal_only":
-            rgb_resized = np.zeros_like(rgb_resized)
-
-        # (H, W, 4) uint8 R G B 0
-        image = np.dstack([rgb_resized, th_resized])
 
         # Label from pylon_camera_node_label_id (same resolution as RGB).
-        # Remap via LUT to contig [0..19]; nearest-neighbor downsample to (input_h, input_w).
+        # Confirmed across the released test split: every label PNG is PIL mode "L",
+        # (1200, 1920) uint8, holding raw class IDs in the documented sparse set
+        # {0, 1, 3-10, 12, 15, 17-19, 23, 27, 31, 33-34}. Colored annotations live
+        # in the sibling pylon_camera_node_label_color/ directory and are never
+        # loaded here. Remap via LUT to contig [0..19].
         label_path = os.path.join(self.data_dir, label_rel)
         raw_label = np.asarray(PIL.Image.open(label_path))  # (1200, 1920) uint8
-        if raw_label.ndim == 3:
-            raw_label = raw_label[:, :, 0]
         remapped = self._lut[raw_label]
-        label = np.asarray(
-            PIL.Image.fromarray(remapped).resize((self.input_w, self.input_h),
-                                                 resample=PIL.Image.NEAREST),
-            dtype=np.int64,
-        )
+
+        # input_h/input_w None ⇒ keep native (RGB and label are both 1920×1200
+        # so this is a true no-op); else bilinear-resize RGB, NEAREST-resize
+        # label.
+        if self.input_h is None and self.input_w is None:
+            rgb_resized = rgb
+            label = remapped.astype(np.int64)
+            th_h, th_w = rgb.shape[:2]
+        else:
+            rgb_resized = np.asarray(
+                PIL.Image.fromarray(rgb).resize((self.input_w, self.input_h),
+                                                resample=PIL.Image.BILINEAR)
+            )
+            label = np.asarray(
+                PIL.Image.fromarray(remapped).resize((self.input_w, self.input_h),
+                                                     resample=PIL.Image.NEAREST),
+                dtype=np.int64,
+            )
+            th_h, th_w = self.input_h, self.input_w
+
+        # 4th channel is constant zero — RELLIS-3D has no thermal sensor. Kept on the tensor
+        # so the same SAM 4-channel input convention works; downstream modality switches in
+        # GOD-style eval loops are not relevant here.
+        th_resized = np.zeros((th_h, th_w), dtype=np.uint8)
+
+        # (H, W, 4) uint8 R G B 0
+        image = np.dstack([rgb_resized, th_resized])
 
         for func in self.transform:
             image, label = func(image, label)
 
-        # th_vis: GOD uses a jet colormap on the thermal channel for the qualitative panels.
-        # Here the channel is all-zero so th_vis is a constant blue rectangle — harmless,
-        # but it keeps the 4-tuple shape that eval_common.run_eval expects.
-        cmap = cm.get_cmap(self.cm_type)
-        th_vis = (cmap(image[:, :, 3])[:, :, :3] * 255).astype(np.uint8)
-        th_vis = np.asarray(
-            PIL.Image.fromarray(th_vis).resize((self.input_w, self.input_h)),
-            dtype=np.float32,
-        ).transpose((2, 0, 1)) / 255
-
-        image_f = np.asarray(
-            PIL.Image.fromarray(image).resize((self.input_w, self.input_h)),
-            dtype=np.float32,
-        ).transpose((2, 0, 1)) / 255
-
-        return torch.tensor(image_f), torch.tensor(label), name_safe, th_vis
+        # `image` is already (input_h, input_w, 4) uint8 — RGB was resized at
+        # load time and dstack'd with the zero thermal channel. So we only need
+        # the uint8 -> float32/255 cast and the HWC -> CHW transpose that
+        # PyTorch expects. The earlier PIL round-trip-with-resize here was a
+        # copy-paste from MF_dataset (where it IS load-bearing because that
+        # adapter resizes at this final step) and ran an identity resize on
+        # every frame.
+        image_f = image.astype(np.float32).transpose(2, 0, 1) / 255
+
+        return torch.tensor(image_f), torch.tensor(label), name_safe
 
     def __len__(self):
         return self.n_data