Upload doanh_eval175/DOANH_EVAL175.md with huggingface_hub

doanh_eval175/DOANH_EVAL175.md

@@ -0,0 +1,469 @@
+# doanh × EVAL-175 — WarpDyn high vs low quality detection
+
+Detailed technical writeup of the 23-task benchmark on doanh's Cosmos-generated robot manipulation videos, mapped to NVIDIA's EVAL-175 task suite. Uses **sigmoid-normalized fused anomaly score** with per-task bootstrap-calibrated steepness.
+
+---
+
+## Dataset
+
+| Source | Role | Format |
+|---|---|---|
+| [doanh25032004/cosmos_synthetic_data](https://huggingface.co/datasets/doanh25032004/cosmos_synthetic_data) `high/<task>.mp4` | **Training reference** (assumed "clean") | 23 mp4s, 1-view |
+| [doanh25032004/cosmos_synthetic_data](https://huggingface.co/datasets/doanh25032004/cosmos_synthetic_data) `low/<task>.mp4` | **Query** (potentially anomalous) | 23 mp4s, 1-view |
+| [nvidia/PhysicalAI-Robotics-GR00T-Eval](https://huggingface.co/datasets/nvidia/PhysicalAI-Robotics-GR00T-Eval) | Task metadata + first-frame conditioning | 23 entries across `gr1_object`, `gr1_env`, `gr1_behavior` |
+
+Task matching: direct filename match (23/23) — doanh's filenames are exactly the task description strings used in EVAL-175.
+
+Hypothesis: low quality Cosmos generations exhibit more anomalies (deformation, physics violation, identity drift) than high quality counterparts. If WarpDyn works, `ratio_fused = H_low / H_high_train` should be > 1.0 most of the time, with score_norm > 0.5.
+
+---
+
+## Method — production WarpDyn pipeline
+
+The pipeline is **per-task self-calibrated** — no labels, no cross-task assumptions, FPR=0% by construction on the training video.
+
+### Architecture overview
+
+```
+                ┌─────────── OFFLINE (per task T, ~80s) ───────────┐
+high/<T>.mp4 ──►│  1. Sample 50 frames + SAM3 segment              │
+                │  2. Cycle null  (182 multi-lag pairs)             │──► timing.json
+                │  3. DINOv2 pool (50 × 384)                        │     - null_cycle_{mean,peak}
+                │  4. kNN LOO null (50 samples) + CV routing        │     - null_knn_{ivar,peak}
+                │  5. H_train baseline (run online on training)     │     - h_train.{cycle,knn,fused}_peak
+                │  6. BaselineNormalizer.fit (bootstrap σ, 200 iter)│     - h_train.{h_pairs,h_frames}
+                └───────────────────────────────────────────────────┘     - baseline_normalizer.{sigma,alpha}
+                                          │
+                ┌─────────── ONLINE (per query, ~16s) ─────────────┐
+low/<T>.mp4 ───►│  1. Sample 10 frames + SAM3                       │
+                │  2. CYCLE: 9 pairs → Cauchy → p80 → H_cycle       │
+                │  3. KNN:   10 frames → Cochran D → p80 → H_knn   │ ──► score_norm + verdict
+                │  4. Cauchy fuse → H_fused                          │
+                │  5. ratio_fused = H_fused / H_train_fused          │
+                │  6. score_norm = sigmoid(α · (ratio_fused − 1))    │
+                └───────────────────────────────────────────────────┘
+```
+
+---
+
+## OFFLINE — step by step (per task, ~80s)
+
+### Step 1 — Sample 50 reference frames + SAM3 segment
+
+```python
+N = total_frames(high_mp4)                              # ≈ 120 frames
+idx = np.linspace(0, N - 1, 50).astype(int)             # 50 uniform samples
+frames = [read_frame(high_mp4, i) for i in idx]
+
+seg = VideoFrameSegmenter(fallback="gray")              # SAM3 segmenter
+refs_masked = [seg.segment_frame(f) for f in frames]    # bg → (127,127,127)
+# saved as paper-doanh-eval/reference/<task>/frame_0000.png … frame_0049.png
+```
+
+Why 50 (not 120 or 182): doanh's Cosmos videos are short (~3–4s, ~120 frames); 50 is dense enough for kNN pool while keeping LOO null + cycle null tractable on a single H100. Reduce to 30 if VRAM tight.
+
+Why SAM3 gray fill: prevents background lighting / table texture from dominating RoMa flow matching. (127,127,127) is neutral for both DINOv2 (CLS feature) and RoMa (no spurious edges).
+
+**Time:** ~8 sec / 50 frames (SAM3 batch).
+
+### Step 2 — Cycle null (182 multi-lag pairs)
+
+For each lag in `[1, 2, 5, 10]`, generate consecutive ref-pair indices `(i, i+lag)`:
+
+```python
+NULL_LAGS = [1, 2, 5, 10]
+null_mean_list, null_peak_list = [], []
+for lag in NULL_LAGS:
+    for i in range(50 - lag):                                # 49+48+45+40 = 182 pairs
+        fwd = roma.match(refs_masked[i], refs_masked[i+lag])
+        bwd = roma.match(refs_masked[i+lag], refs_masked[i])
+        s   = CycleSignal(cert_floor=0.1).compute(fwd, bwd)  # cycle error map
+        null_mean_list.append(s.mean)                         # interior mean (px)
+        null_peak_list.append(s.peak)                         # interior p99 (px)
+null_cycle_mean = np.sort(null_mean_list)                    # (182,)
+null_cycle_peak = np.sort(null_peak_list)                    # (182,)
+```
+
+**CycleSignal internals:**
+- `fwd` warps A→B, `bwd` warps B→A, both with per-pixel certainty mask
+- Cycle error map: `||x − bwd(fwd(x))||` in pixel space
+- `cert_floor=0.1`: ignore pixels where matcher certainty < 10% (low-confidence regions)
+- `s.mean` = mean error over interior (foreground after gray-mask)
+- `s.peak` = 99th percentile error over interior
+
+Multi-lag → null spans short-range (lag 1) and long-range (lag 10) drift; not biased toward one scale.
+
+**Time:** ~18 sec for 182 pairs × 2 RoMa matches.
+
+### Step 3 — DINOv2 pool (50 × 384, L2-normalized)
+
+```python
+dino = DinoFeatureExtractor("dinov2_vits14")             # ViT-S/14
+pool_feats = np.stack([dino.extract(f) for f in refs_masked])  # (50, 384) CLS token
+pool_feats = pool_feats / np.linalg.norm(pool_feats, axis=1, keepdims=True)
+```
+
+CLS feature (384-dim) is enough for pose-level retrieval; ~50× cheaper than patch features. L2-norm so cosine sim is just dot product.
+
+**Time:** <0.1s (one batched forward).
+
+### Step 4 — kNN LOO null + CV routing
+
+Build a "null when query is in-distribution" by leave-one-out (LOO) over the 50 refs:
+
+```python
+null_ivar, null_peak_knn = [], []
+for i in range(50):
+    sims = pool_feats @ pool_feats[i]
+    sims[i] = -1                                           # exclude self
+    top_k = np.argsort(sims)[-15:]                         # k=15 nearest
+
+    matches = roma.match_batch(refs_masked[i],
+                                [refs_masked[j] for j in top_k])
+    warps   = np.stack([m.warp for m in matches])           # (15, H, W, 2)
+    precs   = np.stack([m.precision for m in matches])      # (15, H, W, 2, 2)
+
+    D_map, _, _ = MahalanobisStatistics.ivar_per_pixel(warps, precs)
+    null_ivar.append(MahalanobisStatistics.interior_mean(D_map, fg))
+    null_peak_knn.append(MahalanobisStatistics.peak_max_z(D_map, fg))
+
+null_knn_ivar = np.sort(null_ivar)                          # (50,)
+null_knn_peak = np.sort(null_peak_knn)
+```
+
+**Cochran deviance** is the core kNN signal:
+```
+D(p) = Σ_r (warp_r(p) − μ̂(p))ᵀ · Σ⁻¹_r · (warp_r(p) − μ̂(p))
+```
+where μ̂ is the BLUE (Best Linear Unbiased Estimator) precision-weighted consensus warp across k=15 references. Under H₀ (true match), `D ~ χ²(2(K−1))`. Large `D` means the k references *disagree* about where pixel `p` maps to — a strong signal of geometric inconsistency.
+
+- `ivar` = `mean_interior(D)` — average disagreement over foreground
+- `peak` = `max_interior((D − μ_int)/σ_int)` — z-score of worst disagreement
+
+**CV routing** (per-task decision, computed offline once):
+```python
+cv = np.std(null_ivar) / np.mean(null_ivar)
+route = "peak" if cv < 0.50 else "ivar"
+```
+If `ivar` distribution is too flat (CV low) → not discriminative for this task → switch to `peak`. Most doanh tasks route to `ivar` (CV mean ≈ 0.75).
+
+**Time:** ~14 sec (50 LOO × match_batch).
+
+### Step 5 — H_train baseline (online on training video)
+
+Run the full ONLINE pipeline against the training video itself:
+
+```python
+h_train = score_video(high_mp4, ...)
+# returns:
+#   cycle_peak  = p80 of 9 H_pair_cycle values
+#   knn_peak    = p80 of 10 H_frame_knn values
+#   fused_peak  = cauchy_combine_video(cycle_peak, knn_peak)
+#   h_pairs     = list[9] — needed for bootstrap
+#   h_frames    = list[10] — needed for bootstrap
+```
+
+This absorbs task-specific difficulty: a complex task ("Pour") naturally has higher H_train than a simple one ("Open box"). Ratio then compares relative deviation.
+
+**Time:** ~22 sec (mimics online pass).
+
+### Step 6 — BaselineNormalizer.fit (bootstrap σ of H_train)
+
+```python
+from warp_score.fusion import BaselineNormalizer
+
+normalizer = BaselineNormalizer(n_boot=200, pct=80, seed=42).fit(
+    h_pairs_train=h_train["h_pairs"],
+    h_frames_train=h_train["h_frames"])
+
+# Inside .fit():
+# for b in range(200):
+#     hp_r = np.random.choice(h_pairs, size=9, replace=True)
+#     hf_r = np.random.choice(h_frames, size=10, replace=True)
+#     fused_b = cauchy_combine_video(p80(hp_r), p80(hf_r))
+# sigma = np.std(fused_b array)
+# alpha = 1 / sigma
+```
+
+**Why bootstrap H values (not RoMa-level)?** Re-running RoMa with resampled refs would cost ~30 min × 200 = 100 hours. Resampling already-cached H values takes 30ms while still capturing **aggregation variance** — how much H_train fluctuates depending on *which* frames you happened to sample. This is the dominant source of noise in production (n=10 small sample size).
+
+**What σ means:**
+- σ ≈ 0.05 → baseline very sharp (the 9 pairs / 10 frames give consistent fused score) → small ratio deviations are meaningful → steep sigmoid
+- σ ≈ 0.15 → baseline noisy → only large ratio deviations are meaningful → flat sigmoid (conservative)
+
+For 23 doanh tasks: σ range [0.062, 0.163], mean 0.098.
+
+**Time:** ~30 ms (200 numpy resamples + Cauchy combines, no GPU).
+
+---
+
+## ONLINE — step by step (per query, ~16s)
+
+### Step 1 — Sample 10 frames + SAM3
+
+```python
+idx_q = np.linspace(0, total_frames(low_mp4) - 1, 10).astype(int)
+q_frames_raw = [read_frame(low_mp4, i) for i in idx_q]
+q_frames = [seg.segment_frame(f) for f in q_frames_raw]  # gray-fill bg
+```
+
+10 frames span the full query video; spacing ~12 frames (matches lag 10 in training null).
+
+**Time:** ~9 sec (SAM3 dominates).
+
+### Step 2 — CYCLE branch (9 consecutive pairs → H_cycle)
+
+```python
+H_pairs = []
+for k in range(9):
+    fwd = roma.match(q_frames[k],   q_frames[k+1])
+    bwd = roma.match(q_frames[k+1], q_frames[k])
+    s   = CycleSignal(cert_floor=0.1).compute(fwd, bwd)
+
+    p_mean = empirical_p_value(s.mean, null_cycle_mean)   # right-tail
+    p_peak = empirical_p_value(s.peak, null_cycle_peak)
+    p_pair = cauchy_combine([p_mean, p_peak])             # per-pair fusion
+    H_pairs.append(1 - p_pair)
+
+H_cycle = np.percentile(H_pairs, 80)                       # video aggregator
+```
+
+- `empirical_p_value` = right-tail empirical p (rank of observed signal in sorted null + 1) / (N + 1)
+- **Per-pair Cauchy** combines mean (broad anomaly) and peak (localized anomaly) into one H per pair
+- **Video p80**: robust to 1–2 noisy pairs, still sensitive to anomalies persisting ≥2 pairs
+
+**Time:** ~1 sec (9 pairs × 2 RoMa).
+
+### Step 3 — KNN branch (10 frames → H_knn)
+
+```python
+H_frames = []
+for i in range(10):
+    feat = dino.extract(q_frames[i])
+    feat = feat / np.linalg.norm(feat)
+    sims = pool_feats @ feat
+    top_k = np.argsort(sims)[-15:]                         # 15 nearest refs
+
+    matches = roma.match_batch(q_frames[i],
+                                [refs_masked[j] for j in top_k])
+    warps = np.stack([m.warp for m in matches])
+    precs = np.stack([m.precision for m in matches])
+    D_map, _, _ = MahalanobisStatistics.ivar_per_pixel(warps, precs)
+
+    ivar = MahalanobisStatistics.interior_mean(D_map, fg_mask)
+    peak = MahalanobisStatistics.peak_max_z(D_map, fg_mask)
+
+    if route == "peak":
+        p_f = empirical_p_value(peak, null_knn_peak)
+    else:
+        p_f = empirical_p_value(ivar, null_knn_ivar)
+
+    H_frames.append(1 - p_f)
+
+H_knn = np.percentile(H_frames, 80)
+```
+
+**`match_batch` does ONE forward pass** for all 15 refs together (commit `a18b03b`) → ~2.5× faster than looping `roma.match`.
+
+**Time:** ~6 sec (10 query frames × match_batch).
+
+### Step 4 — Cauchy fuse (video level)
+
+```python
+p_cycle = 1 - H_cycle
+p_knn   = 1 - H_knn
+p_fused = cauchy_combine([p_cycle, p_knn])
+H_fused = 1 - p_fused
+```
+
+**Why Cauchy fusion at the video level:**
+- Cycle and kNN are 2 orthogonal evidence sources (temporal vs appearance)
+- Cauchy combine doesn't require independence (unlike Fisher's method)
+- Heavy-tailed → very sensitive when *either* branch has small p (small p → infinite tan value, dominates)
+- Catches anomalies that show up in only one modality
+
+### Step 5 — Ratio
+
+```python
+ratio_fused = H_fused / max(H_train_fused, 1e-8)
+```
+
+Unit-free, cross-task comparable. `ratio = 1.0` means "query is as anomalous as the training video itself appears to its own null" — the natural decision boundary.
+
+### Step 6 — Sigmoid normalization (NEW)
+
+```python
+score_norm = normalizer.normalize(ratio_fused)
+# = 1 / (1 + exp(-α · (ratio_fused − 1)))
+```
+
+Maps `ratio ∈ [0, ∞)` → `score ∈ [0, 1]`:
+
+| Multiple of σ_baseline | score_norm | Verdict |
+|---|---|---|
+| +3σ | 0.953 | very strong HALLU |
+| **+2σ** | **0.881** | **strong HALLU** |
+| **+1σ** | **0.731** | **weak HALLU** |
+| 0 (ratio=1.0) | 0.500 | baseline |
+| −1σ | 0.269 | weak clean |
+| −2σ | 0.119 | strong clean |
+| −3σ | 0.047 | very strong clean |
+
+α = 1/σ is task-specific. Critical observation: same `ratio_fused = 1.10` maps to different scores depending on baseline sharpness:
+- Task with σ=0.05 → α=20 → score_norm = sigmoid(20·0.10) = 0.881 (strong HALLU)
+- Task with σ=0.15 → α=6.7 → score_norm = sigmoid(6.7·0.10) = 0.661 (borderline)
+
+This is the calibration win: same threshold `score_norm > 0.73` applies uniformly across tasks despite different baseline noise.
+
+---
+
+## Results — 23 tasks (sorted by score_norm descending)
+
+| Rank | task | eval folder | ratio_fused | σ_base | **score_norm** | verdict |
+|---|---|---|---|---|---|---|
+| 1 | 0 — Open the box | gr1_behavior | 1.343 | 0.091 | **0.978** | 🔴 strong HALLU |
+| 2 | 14 — wooden spoon scooping | gr1_env | 1.372 | 0.108 | **0.970** | 🔴 strong HALLU |
+| 3 | 5 — orange to metal platform | gr1_env | 1.206 | 0.095 | **0.897** | 🔴 strong HALLU |
+| 4 | 15 — close black drawer | gr1_env | 1.260 | 0.123 | **0.892** | 🔴 strong HALLU |
+| 5 | 13 — pink peach center → shelf | gr1_object | 1.194 | 0.105 | **0.865** | 🔴 weak HALLU |
+| 6 | 3 — cup → green trash can | gr1_env | 1.163 | 0.098 | **0.842** | 🔴 weak HALLU |
+| 7 | 17 — bok choy → wire basket | gr1_object | 1.263 | 0.163 | **0.834** | 🔴 weak HALLU |
+| 8 | 7 — rubik's cube top → bottom | gr1_object | 1.137 | 0.105 | **0.787** | 🔴 weak HALLU |
+| 9 | 22 — milk carton → cyan plate | gr1_object | 1.126 | 0.126 | **0.731** | 🔴 weak HALLU |
+| 10 | 4 — green pepper → paper bag | gr1_object | 1.050 | 0.080 | 0.651 | ⚠ borderline |
+| 11 | 20 — orange center → shelf | gr1_object | 1.005 | 0.104 | 0.511 | ⚠ borderline |
+| 12 | 19 — bok choy → paper bag | gr1_object | 1.000 | 0.101 | 0.501 | ⚠ borderline |
+| 13 | 1 — cucumber → beige bowl | gr1_object | 0.992 | 0.110 | 0.482 | ✓ weak clean |
+| 14 | 6 — red bell pepper → bottom rack | gr1_object | 0.953 | 0.128 | 0.409 | ✓ weak clean |
+| 15 | 10 — orange → pale turquoise | gr1_object | 0.959 | 0.062 | 0.342 | ✓ weak clean |
+| 16 | 18 — close waffle maker | gr1_env | 0.883 | 0.087 | 0.208 | ✓ clean |
+| 17 | 8 — red glass → turquoise | gr1_object | 0.813 | 0.085 | **0.100** | ✓ clean (MISS!) |
+| 18 | 21 — rubik's cube bottom → top | gr1_object | 0.823 | 0.077 | 0.092 | ✓ clean |
+| 19 | 11 — sandwich → pizza box | gr1_env | 0.800 | 0.066 | 0.047 | ✓ clean |
+| 20 | 9 — milk carton → pale turquoise | gr1_object | 0.716 | 0.089 | 0.039 | ✓ clean |
+| 21 | 2 — yellow star fruit → white shelf | gr1_object | 0.611 | 0.094 | 0.015 | ✓ clean |
+| 22 | 12 — orange juice → green bowl | gr1_object | 0.599 | 0.094 | 0.014 | ✓ clean |
+| 23 | 16 — tall red glass → blue plate | gr1_object | 0.551 | 0.070 | 0.002 | ✓ clean |
+
+**Summary:**
+- 9/23 HALLU (5 strong + 4 weak)
+- 3/23 borderline
+- 11/23 clean
+- σ_baseline mean = 0.098, range = [0.062, 0.163]
+
+### Failure case — task 8 "red glass"
+
+Task 8 has visible finger deformation in the low video but `score_norm = 0.10` (strongly clean). Root cause:
+
+```
+h_frames (high training): [0.91, 0.98, 0.46, 0.17, 0.02, 0.28, 0.50, 0.91, 0.44, 0.79]
+                                  ↑                              ↑
+                          H_train_knn_p80 = 0.912 (very high)
+
+h_frames (low query)    : [0.91, 0.83, 0.70, 0.44, 0.38, 0.44, 0.36, 0.38, 0.32, 0.40]
+                                  ↑
+                          H_test_knn_p80 = 0.724 (lower than train!)
+```
+
+The high video is **already saturated** against its own LOO null (left-hand pose holding a glass is intrinsically high-variance — even the "good" version looks anomalous to kNN). Low video has lower H, so ratio < 1, sigmoid maps to clean side. No combination of percentile/frame-count fixes this — even p100 + 30 frames gives ratio_fused = 0.964 (borderline). The only fix would be clipping H_train from above, which trades FPR-by-construction for catching this case.
+
+---
+
+## Visualizations
+
+Per-task `task_<i>/` folder contains 14 panels:
+
+**Offline (7 panels):**
+1. `01_sampled_refs.png` — 10 of 50 sampled refs
+2. `02_cycle_pair_example.png` — 1 cycle pair + warp viz + error map
+3. `03_cycle_null_histograms.png` — null_mean + null_peak distributions
+4. `04_dinov2_pool_pca.png` — 50 refs projected to 2D (time-colored)
+5. `05_knn_loo_example.png` — 1 LOO query + top-5 retrieved refs
+6. `06_cochran_dmap_example.png` — D-map for 1 LOO query
+7. `07_knn_null_histograms.png` — null_ivar + null_peak distributions
+
+**Online (7 panels):**
+1. `01_query_frames.png` — 10 sampled query frames
+2. `02_query_pair_example.png` — 1 consecutive query pair
+3. `03_cycle_pairs_bar.png` — 9 H_pair values + p80 line + H_train ref
+4. `04_knn_topk_per_frame.png` — top-5 retrieved refs for 3 query frames
+5. `05_knn_dmap_per_frame.png` — D-map overlay per query frame (10 panels)
+6. `06_knn_frames_bar.png` — 10 H_frame values + p80 line + H_train ref
+7. `07_final_scores.png` — H_train vs H_test per branch + ratio + verdict
+
+**Aggregate plots (in `per_task_dense_eval/`):**
+- `doanh_ratio_bars.png` — per-task ratios (cycle/knn/fused), sorted
+- `doanh_score_norm_bars.png` — per-task sigmoid-normalized scores
+- `doanh_ratio_vs_score_norm.png` — scatter showing per-task α effect
+- `doanh_ratio_histograms.png` — distribution shapes
+
+---
+
+## Reproduce
+
+```bash
+conda activate groot
+cd /mnt/data/sftp/data/quangpt3/gcvwm/calibration/feepe/feature_matching_eval_hallucination
+
+# Step 0: download datasets (one time)
+# - doanh: huggingface hub → paper-doanh-eval/raw_videos/{high,low}/
+# - EVAL-175: huggingface hub → paper-doanh-eval/conditioning/
+
+# Step 1: extract 50-frame SAM3 refs (one time, ~1.5 min × 23 tasks)
+python scripts/extract_doanh_eval_refs.py
+
+# Step 2: sweep 23 tasks — full offline + online + bootstrap normalizer (~30 min)
+python scripts/_bench_doanh_eval_sweep.py
+
+# Step 3: aggregate results + plots + summary markdown
+python scripts/_doanh_eval_summary_viz.py
+
+# Step 4: upload to HF dataset wmbench/doanh_eval175/
+python scripts/_upload_doanh_eval_to_hf.py
+```
+
+---
+
+## Files
+
+| File | Role |
+|---|---|
+| `warp_score/sam_segmenter.py` | SAM3 (`VideoFrameSegmenter`) + gray fallback |
+| `warp_score/matcher.py` | `RoMaMatcher` + `match_batch` (k-ref single forward) |
+| `warp_score/adaptive_refs.py` | `DinoFeatureExtractor` + `AdaptiveRefSelector` |
+| `warp_score/statistics.py` | `MahalanobisStatistics.ivar_per_pixel` (Cochran D) |
+| `warp_score/temporal_signals.py` | `CycleSignal` + `cauchy_combine` + `empirical_p_value` |
+| `warp_score/knn_signal.py` | `KNNFrameSignal` (pool + LOO + routing + `score_frame`) |
+| **`warp_score/fusion.py`** | **`BaselineNormalizer` class + `cauchy_combine_video`** |
+| `scripts/extract_doanh_eval_refs.py` | OFFLINE step 1 (SAM3 refs from high mp4s) |
+| `scripts/benchmark_one_task.py` | Single-task OFFLINE+ONLINE+normalizer + 14-panel viz |
+| `scripts/_bench_doanh_eval_sweep.py` | Run benchmark_one_task across 23 tasks |
+| `scripts/_doanh_eval_summary_viz.py` | Aggregate timing.json files → CSV + plots + markdown |
+| `scripts/_upload_doanh_eval_to_hf.py` | Push results to HF `twanghcmut/wmbench/doanh_eval175/` |
+
+---
+
+## Public dataset
+
+https://huggingface.co/datasets/twanghcmut/wmbench/tree/main/doanh_eval175
+
+Layout:
+```
+doanh_eval175/
+├── README.md                              # task overview + score_norm explanation
+├── DOANH_EVAL175.md                       # this technical writeup
+├── WARPDYN_METHOD.md                      # general WarpDyn method doc
+├── eval_tasks.json                        # 23 task entries
+├── per_task_dense_eval/
+│   ├── doanh_low_vs_high_ratio.csv        # 23 rows: ts, ratios, score_norm, sigma, alpha
+│   ├── doanh_ratio_bars.png
+│   ├── doanh_score_norm_bars.png          # NEW — sigmoid-normalized per task
+│   ├── doanh_ratio_vs_score_norm.png      # NEW — scatter ratio→score
+│   ├── doanh_ratio_histograms.png
+│   └── doanh_summary.md
+├── raw_videos/
+│   ├── high/{0..22}_<task>.mp4            # 23 training refs
+│   └── low/{0..22}_<task>.mp4             # 23 queries
+├── conditioning/{0..22}_<task>.png        # EVAL-175 first frame + prompt
+└── task_<i>/                              # 23 folders, each with offline/+online/ viz + timing.json
+```