Datasets:
File size: 3,691 Bytes
99e41a8 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 | #!/usr/bin/env python3
"""Evaluate Cosmos-Reason2 as a task-success verifier on procedural tabletop scenes.
Protocol: pick the decision threshold on a calibration split (seed A), report
metrics on a held-out split (seed B) so the threshold isn't tuned on test data.
MUJOCO_GL=egl HF_TOKEN=... python scripts/eval_verifier.py --n 50 --out results/verifier_cr2b.jsonl
"""
import argparse
import json
import sys
import time
from collections import defaultdict
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
import torch # noqa: E402
from robotics.eval.stats import wilson # noqa: E402
from robotics.sim.tabletop import make_suite # noqa: E402
from robotics.vlm.cosmos_reason import CosmosVerifier # noqa: E402
def auroc(pos: list[float], neg: list[float]) -> float:
wins = sum((p > n) + 0.5 * (p == n) for p in pos for n in neg)
return wins / (len(pos) * len(neg))
def score_split(v, seed, n, size, tag, split):
rows = []
for i, s in enumerate(make_suite(n, seed=seed, size=size)):
t = time.perf_counter()
p = v.score(s.image, s.task)
rows.append({"run": tag, "split": split, "seed": seed, "family": s.task.split()[0],
"kind": s.kind, "task": s.task, "gt": s.success, "p": round(p, 4),
"latency_s": round(time.perf_counter() - t, 3)})
print(f"[{split} {i + 1}/{2 * n}] gt={s.success!s:5} p={p:.3f} {s.kind:22} {s.task}", flush=True)
return rows
def best_threshold(rows):
cands = sorted({r["p"] for r in rows} | {0.5})
return max(cands, key=lambda t: sum((r["p"] >= t) == r["gt"] for r in rows))
def report(rows, thr):
def acc(rs):
k = sum((r["p"] >= thr) == r["gt"] for r in rs)
lo, hi = wilson(k, len(rs))
return f"{k / len(rs):6.1%} [{lo:.0%},{hi:.0%}] n={len(rs)}"
pos = [r["p"] for r in rows if r["gt"]]
neg = [r["p"] for r in rows if not r["gt"]]
print(f"\nthreshold={thr:.3f} accuracy {acc(rows)} AUROC={auroc(pos, neg):.3f}")
print(f" TPR (successes accepted) {acc([r for r in rows if r['gt']])}")
print(f" TNR (failures rejected) {acc([r for r in rows if not r['gt']])}")
by = defaultdict(list)
for r in rows:
by[(r["family"], r["kind"])].append(r)
for k in sorted(by):
print(f" {k[0]:6} {k[1]:22} {acc(by[k])}")
lat = sorted(r["latency_s"] for r in rows)
print(f" latency median {lat[len(lat) // 2]:.2f}s p90 {lat[int(len(lat) * .9)]:.2f}s")
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--n", type=int, default=50, help="scenes per task family per split")
ap.add_argument("--size", type=int, default=448)
ap.add_argument("--calib-seed", type=int, default=100)
ap.add_argument("--test-seed", type=int, default=200)
ap.add_argument("--tag", default="cosmos_reason2_2b")
ap.add_argument("--out", default="results/verifier_cosmos_reason2_2b.jsonl")
a = ap.parse_args()
torch.set_num_threads(max(1, torch.get_num_threads()))
v = CosmosVerifier()
calib = score_split(v, a.calib_seed, a.n, a.size, a.tag, "calib")
test = score_split(v, a.test_seed, a.n, a.size, a.tag, "test")
thr = best_threshold(calib)
Path(a.out).parent.mkdir(parents=True, exist_ok=True)
with open(a.out, "w") as f:
for r in calib + test:
f.write(json.dumps({**r, "threshold": thr}) + "\n")
print("\n=== calibration split (threshold chosen here) ===")
report(calib, thr)
print("\n=== held-out test split ===")
report(test, thr)
print("\n=== held-out test split @ default 0.5 ===")
report(test, 0.5)
if __name__ == "__main__":
main()
|