droid/method.md

# WARPDYN — Hallucination Detection Method

Tài liệu mô tả **production flow** của WARPDYN cho việc phát hiện hallucination ở video do world-model sinh ra. Pipeline gồm 2 phase: **OFFLINE** (build null distribution per task, chạy 1 lần) và **ONLINE** (score 1 query video, < 30s).

Default method = **cycle + kNN fusion**. Mọi step dưới đây là production, không phải variant.

---

## Pipeline overview

```
                ┌───────────────── OFFLINE (per task, ~30 min) ─────────────────┐
training.mp4 ──►│  1. Sample 120 frames evenly                                   │
                │  2. SAM3 segment (bg → gray 127)                               │──► null_per_task/<T>.npz
                │  3. Cycle null   (462 multi-lag pairs, lags [1,2,5,10])        │     - null_cycle_{mean,peak}
                │  4. DINOv2 pool  (120 × 384, L2-norm)                          │     - null_knn_{ivar,peak}
                │  5. kNN LOO null + CV routing (ivar vs peak)                   │     - route, H_train_*
                │  6. H_train baseline (run online on training itself)           │
                └─────────────────────────────────────────────────────────────────┘
                                              │
                ┌───────────────── ONLINE (per query, ~30 sec) ─────────────────┐
query.mp4   ──► │  1. Sample 10 frames + SAM3                                    │
                │  2. CYCLE: 9 pairs → Cauchy(p_mean,p_peak) → p80 → H_cycle    │
                │  3. KNN:   10 frames → Cochran D → empirical_p → p80 → H_knn │
                │  4. FUSE:  Cauchy([1-H_cycle, 1-H_knn]) → H_fused             │ ──► ratio + verdict
                │  5. ratio_fused = H_fused / H_train_fused                     │
                │  6. HALLU if ratio_fused > 1.0                                │
                └─────────────────────────────────────────────────────────────────┘
```

Ý tưởng: cycle bắt **temporal inconsistency** (forward-backward không khớp giữa các frame), kNN bắt **appearance drift** (geometry mismatch so với reference pose gần nhất trong training). Fuse 2 p-value qua Cauchy → kết hợp 2 nguồn evidence độc lập, giữ tail behavior.

---

## OFFLINE — build null per task

Chạy 1 lần mỗi task T (Pick-Place-Bowl, Pour, …), output là `null_per_task/<T>.npz`.

### Step 1 — Sample 120 reference frames

Intuition: training video ~120 frames, lấy đều để cover toàn bộ trajectory pose.

```python
N = total_frames(training_mp4)
idx = np.linspace(0, N - 1, 120).astype(int)
refs = [read_frame(training_mp4, i) for i in idx]
```

Sample đều (không random) để null phản ánh distribution của task, reproducible giữa các run.

### Step 2 — SAM3 segment, bg → gray

Intuition: chỉ giữ robot foreground; xóa background nhiễu (lighting, table texture) khỏi RoMa matching.

```python
seg = VideoFrameSegmenter(prompts=["robot arm", "robotic hand",
                                   "gripper", "mechanical finger"])
refs_masked = [seg.segment(f, bg_fill=(127, 127, 127)) for f in refs]
```

Gray fill (127,127,127) là neutral cho DINOv2 & RoMa — không tạo edge giả ngoài silhouette robot.

### Step 3 — Cycle null (multi-lag pairs)

Intuition: build null cho `CycleSignal` bằng cách pair các ref **trong cùng training** ở nhiều lag → đại diện "what normal cycle error looks like".

```python
pairs = []
for lag in [1, 2, 5, 10]:
    for i in range(120 - lag):
        pairs.append((i, i + lag))  # ~462 pairs total

null_mean, null_peak = [], []
for i, j in pairs:
    fwd, bwd = roma.match_bidir(refs_masked[i], refs_masked[j])
    s = CycleSignal.compute(fwd, bwd, cert_floor=0.1, peak_pct=99)
    null_mean.append(s.mean); null_peak.append(s.peak)
```

Multi-lag → null cover cả short-range (lag 1) và long-range drift (lag 10), không bias về 1 scale.

### Step 4 — DINOv2 pool (120 × 384)

Intuition: build pool feature để online query có thể tìm "frame nào trong training giống tôi nhất".

```python
dino = DinoFeatureExtractor("dinov2_vits14")  # ViT-S/14, CLS token
pool = np.stack([dino.extract(f) for f in refs_masked])  # (120, 384)
pool = pool / np.linalg.norm(pool, axis=1, keepdims=True)  # L2-norm
```

CLS feature đủ discriminative cho pose-level retrieval, rẻ hơn patch features ~50×.

### Step 5 — kNN LOO null + CV routing

Intuition: với mỗi ref i, giả vờ nó là query → tìm top-15 nearest từ pool (loại i) → compute Cochran deviance → đây là "null khi query thực sự là in-distribution".

```python
null_ivar, null_peak_knn = [], []
for i in range(120):
    sims = pool @ pool[i]; sims[i] = -1
    top_k = np.argsort(sims)[-15:]
    matches = roma.match_batch(refs_masked[i], [refs_masked[j] for j in top_k])
    ivar, peak = MahalanobisStatistics.cochran_deviance(matches)
    null_ivar.append(ivar); null_peak_knn.append(peak)

cv = np.std(null_ivar) / np.mean(null_ivar)
route = "peak" if cv < 0.50 else "ivar"
```

CV routing: nếu `ivar` quá flat (CV thấp) thì nó không discriminative cho task này → switch sang `peak`. Decision per-task, không global.

### Step 6 — H_train baseline

Intuition: chạy đúng pipeline ONLINE trên chính training video → có baseline H để chia ratio. Nếu không có baseline thì H absolute không có ý nghĩa cross-task.

```python
H_train_cycle = run_online_cycle(training_mp4, null_cycle_*)
H_train_knn   = run_online_knn(training_mp4, pool, null_knn_*, route)
p_train       = cauchy_combine([1 - H_train_cycle, 1 - H_train_knn])
H_train_fused = 1 - p_train

np.savez(f"null_per_task/{T}.npz",
         null_cycle_mean=..., null_cycle_peak=...,
         null_knn_ivar=..., null_knn_peak=...,
         route=route, pool=pool,
         H_train_cycle=H_train_cycle, H_train_knn=H_train_knn,
         H_train_fused=H_train_fused)
```

Self-normalization: H_train absorbs task-specific difficulty (Pour khó hơn Pick → H_train cao hơn) nên ratio luôn so sánh tương đối.

---

## ONLINE — score 1 query video

Load `null_per_task/<T>.npz`, chạy ~30s trên H100.

### Step 1 — Sample 10 frames + SAM3

Intuition: 10 frame đủ để cover query video 120 frame, mỗi frame distance ~12 → dày hơn pair lag 10.

```python
idx_q = np.linspace(0, len(query) - 1, 10).astype(int)
q_frames = [seg.segment(query[i], bg_fill=(127,127,127)) for i in idx_q]
```

Cùng SAM3 prompts như offline để mask distribution match.

### Step 2 — CYCLE branch (9 pairs → H_cycle)

Intuition: 9 consecutive pairs trên 10 frame, mỗi pair cho 2 signal (mean, peak), fuse qua Cauchy thành H_pair, rồi aggregate p80 qua 9 pairs.

```python
H_pairs = []
for k in range(9):
    fwd, bwd = roma.match_bidir(q_frames[k], q_frames[k+1])
    s = CycleSignal.compute(fwd, bwd, cert_floor=0.1, peak_pct=99)
    p_mean = empirical_p(s.mean, null_cycle_mean)   # right-tail
    p_peak = empirical_p(s.peak, null_cycle_peak)
    p_pair = cauchy_combine([p_mean, p_peak])
    H_pairs.append(1 - p_pair)
H_cycle = np.percentile(H_pairs, 80)
```

p80 thay vì max → robust với 1–2 pair noise, vẫn nhạy với hallu kéo dài ≥ 2 pairs.

### Step 3 — KNN branch (10 frames → H_knn)

Intuition: với mỗi query frame, tìm 15 nearest ref pose trong pool → batch-match RoMa → Cochran D → so với null routed signal.

```python
H_frames = []
for i in range(10):
    feat = dino.extract(q_frames[i])
    sims = pool @ feat
    top_k = np.argsort(sims)[-15:]
    matches = roma.match_batch(q_frames[i], [refs_masked[j] for j in top_k])
    ivar, peak = MahalanobisStatistics.cochran_deviance(matches)
    sig  = peak if route == "peak" else ivar
    null = null_knn_peak if route == "peak" else null_knn_ivar
    p_f  = empirical_p(sig, null)
    H_frames.append(1 - p_f)
H_knn = np.percentile(H_frames, 80)
```

`match_batch` chạy 1 forward pass cho 15 refs → ~2.5× nhanh hơn loop (xem commit a18b03b).

### Step 4 — Fuse Cauchy

Intuition: cycle và kNN là 2 evidence độc lập (temporal vs appearance). Cauchy combine = heavy-tail aggregator, không assume independence như Fisher.

```python
p_cycle = 1 - H_cycle
p_knn   = 1 - H_knn
p_fused = cauchy_combine([p_cycle, p_knn])
H_fused = 1 - p_fused
```

Cauchy rất sensitive khi **một** branch nhỏ (p tiến về 0) → bắt cả hallu chỉ-temporal lẫn chỉ-appearance.

### Step 5 — Ratio vs H_train

Intuition: H_fused absolute không cross-task được; chia cho baseline self-test → unit-free score.

```python
ratio_fused = H_fused / H_train_fused
```

Ví dụ Pour task: `H_train_fused = 0.42`, query `H_fused = 0.51` → `ratio = 1.21` → flag.

### Step 6 — Verdict

```python
if ratio_fused > 1.05:     verdict = "HALLU"
elif ratio_fused > 0.95:   verdict = "borderline"
else:                       verdict = "clean"
```

Band 0.95–1.05 = uncertainty zone (sampling noise); ngoài band là decision dứt khoát.

---

## Parameters

| Group | Param | Value |
|---|---|---|
| Refs | `N_REFERENCE_FRAMES` | 120 (max from 120-frame training videos) |
| Refs | `SAM3_PROMPTS` | robot arm, robotic hand, gripper, mechanical finger |
| Cycle | `NULL_LAGS` | [1, 2, 5, 10] |
| Cycle | `CERT_FLOOR` | 0.1 |
| Cycle | `PEAK_PERCENTILE` | 99 |
| kNN | `KNN_K` | 15 |
| kNN | `DINO_MODEL` | dinov2_vits14 |
| kNN | `CV_THRESHOLD` | 0.50 |
| RoMa | `SETTING` | turbo |
| RoMa | `VIS_SIZE` | 224 |
| Online | `N_QUERY_FRAMES` | 10 |
| Online | `VIDEO_AGGREGATOR` | p80 |
| Decision | `RATIO_THRESHOLD` | 1.0 |
| Decision | `BORDERLINE_BAND` | 0.95–1.05 |

---

## Success metrics (Tier 1–4)

| Tier | Metric | Target |
|---|---|---|
| 1 | FPR=0% on real (ratio_fused ≤ 1.0 cho tất cả real) | **REQUIRED** |
| 1 | Cycle-only `--no_knn` reproduces 18/24 catch | **REQUIRED** |
| 2 | Complementarity: ≥ 3 cycle-only catches + ≥ 3 knn-only catches | TARGET |
| 2 | Separation gap (min hallu − max real) > cycle-only gap | TARGET |
| 2 | Borderline count (0.95–1.05) < cycle-only count | TARGET |
| 3 | AUROC video-level > 0.81 (cycle alone: 0.77) | INFO |
| 4 | Manual spot-check 3 hallu + 3 clean gens | OPTIONAL |

---

## Reference results (GR-1, 5 tasks, fusion eval)

| Metric | Cycle | kNN | **Fused** |
|---|---|---|---|
| Gen catch (ratio > 1.0) | 18/24 | 18/24 | **19/24** |
| AUROC | 0.7750 | 0.7833 | **0.8000** |
| Separation gap | +0.014 | +0.002 | **+0.031** |
| Real flagged | 0/5 | 0/5 | **0/5** |
| Complementarity | — | — | 14 both / 4 cycle-only / 4 knn-only / 2 neither |

Fusion vừa tăng catch (+1) vừa double separation gap (+0.014 → +0.031) mà không sinh false positive trên real.

---

## Files

| File | Purpose |
|---|---|
| `warp_score/temporal_signals.py` | `CycleSignal` class, `empirical_p_value`, `cauchy_combine` |
| `warp_score/matcher.py` | `RoMaMatcher` (with `match_batch` for k-ref scoring) |
| `warp_score/sam_segmenter.py` | `VideoFrameSegmenter` (SAM3) |
| `warp_score/adaptive_refs.py` | `DinoFeatureExtractor`, `AdaptiveRefSelector` (k-NN) |
| `warp_score/statistics.py` | `MahalanobisStatistics` (Cochran deviance) |
| `warp_score/knn_signal.py` | `KNNFrameSignal` (pool + LOO + routing + `score_frame`) |
| `warp_score/fusion.py` | `cauchy_combine_video` + `complementarity_report` |
| `scripts/extract_refs_dense.py` | OFFLINE step 1–2: dense SAM3 refs |
| `scripts/eval_per_task_dense_null.py` | OFFLINE step 3–6 + ONLINE eval |
| `scripts/compute_per_task_ratio.py` | Ratio table + complementarity + markdown |

---

## Commands cheatsheet

```bash
conda activate groot
cd /mnt/data/sftp/data/quangpt3/gcvwm/calibration/feepe/feature_matching_eval_hallucination

# Step 1: extract dense SAM3 refs (~30 min for 5 tasks)
python scripts/extract_refs_dense.py

# Step 2: full fusion eval (~95 min for 5 tasks)
python scripts/eval_per_task_dense_null.py

# Cycle-only regression mode (Tier 1 sanity check)
python scripts/eval_per_task_dense_null.py --no_knn

# Step 3: per-task ratio + ranking + markdown report
python scripts/compute_per_task_ratio.py
```