| """Grade any step localiser on ChokeBench v1 from the released JSONL alone (CPU, seconds). |
| |
| A localiser names one 1-based step per trace. For each open failed trace (v_0 > 1/8, not |
| capability-limited) we report |
| acc_human named step == human first error (the ProcessBench target) |
| acc_decisive posterior P(named step is the choke point), Jeffreys posterior on every v_k |
| gain v_{j-1} - v_0: one attempt resampled before the named step, minus one restart |
| |
| Simplified protocol: no sample-split weighting, so numbers differ slightly from the paper's |
| (scripts/49_chokebench.py, which needs the full rollouts). Usage: |
| python scripts/chokebench_score.py [path/to/chokebench_v1.jsonl] [submission.json] |
| submission.json maps trace_id|generator -> step; without it the built-in baselines are scored. |
| """ |
| from __future__ import annotations |
|
|
| import json |
| import sys |
|
|
| import numpy as np |
|
|
| DELTA, N_POST = 0.125, 2000 |
|
|
|
|
| def load(path: str) -> list[dict]: |
| rows = [json.loads(line) for line in open(path, encoding="utf-8")] |
| keep = [] |
| for r in rows: |
| v = np.array(r["successes"]) / np.array(r["continuations"]) |
| if not r["capability_limited"] and v[0] > DELTA: |
| keep.append(r) |
| return keep |
|
|
|
|
| def posterior_choke(r: dict, rng: np.random.Generator) -> np.ndarray: |
| """P(d = j), j = 1..n: the step where v drops most; v_n = 0 because the trace failed.""" |
| s, c = np.array(r["successes"], float), np.array(r["continuations"], float) |
| draws = rng.beta(s + 0.5, c - s + 0.5, size=(N_POST, len(s))) |
| draws = np.hstack([draws, np.zeros((N_POST, 1))]) |
| return np.bincount(np.argmax(draws[:, :-1] - draws[:, 1:], axis=1), minlength=len(s)) / N_POST |
|
|
|
|
| BASELINES = { |
| "human_first_error": lambda r: r["human_first_error"], |
| "prm_first_below_0.5": lambda r: next((i + 1 for i, p in enumerate(r["prm"]) if p < 0.5), None), |
| "prm_largest_drop": lambda r: int(np.argmax(np.r_[1.0, r["prm"][:-1]] - np.array(r["prm"]))) + 1, |
| "prm_min": lambda r: int(np.argmin(r["prm"])) + 1, |
| "first_step (= restart)": lambda r: 1, |
| } |
|
|
|
|
| def score(rows: list[dict], name_step) -> dict: |
| rng = np.random.default_rng(0) |
| h, d, g = [], [], [] |
| for r in rows: |
| j = name_step(r) |
| if j is None or not 1 <= j <= r["n_steps"]: |
| h.append(False), d.append(0.0), g.append(0.0) |
| continue |
| v = np.array(r["successes"]) / np.array(r["continuations"]) |
| h.append(j == r["human_first_error"]) |
| d.append(posterior_choke(r, rng)[j - 1]) |
| g.append(v[j - 1] - v[0]) |
| return {"n": len(h), "acc_human": float(np.mean(h)), "acc_decisive": float(np.mean(d)), |
| "gain_vs_restart": float(np.mean(g))} |
|
|
|
|
| if __name__ == "__main__": |
| rows = load(sys.argv[1] if len(sys.argv) > 1 else "results/chokebench/chokebench_v1.jsonl") |
| if len(sys.argv) > 2: |
| sub = json.load(open(sys.argv[2], encoding="utf-8")) |
| print(json.dumps(score(rows, lambda r: sub.get(f"{r['trace_id']}|{r['generator']}")), indent=2)) |
| else: |
| assert score(rows, BASELINES["first_step (= restart)"])["gain_vs_restart"] == 0.0 |
| print(f"{'localiser':24s} {'n':>4s} {'human':>6s} {'choke':>6s} {'gain':>7s}") |
| for k, f in BASELINES.items(): |
| s = score(rows, f) |
| print(f"{k:24s} {s['n']:4d} {s['acc_human']:6.3f} {s['acc_decisive']:6.3f} {s['gain_vs_restart']:+7.3f}") |
|
|
