Datasets:

twanghcmut
/

wmbench

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.

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.

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

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

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

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.

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.

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.

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.

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.

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.

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

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

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