| |
| """Dated-break eval aggregator: score replies.jsonl files and print the frozen headline tables. |
| |
| usage: score_run.py REPLIES.jsonl[,MORE.jsonl...] OUT.json [--duckdb OUTCOMES.json] [--rust OUTCOMES.json] |
| [--pilot] (pilot: skip the paired bootstrap) |
| |
| Exec items (duckdb-*, rust-*) take their outcome only from the contained-runner outcomes files; with no |
| file, or a missing key, the outcome is NOT_RUN (never a silent static fallback). |
| |
| Definitions (frozen protocol): |
| scored outcomes other than UNSCORED, UNSCORED_IMPORT, UNKNOWN_ID, INVALID_ID, NOT_RUN. MIXED is scored. |
| PRIMARY (FAIL + BROKEN_ALREADY_ROW) / scored, breakClass 'stops-working' only: the only break arm C can address. |
| SECONDARY any dated break = PRIMARY numerator + BROKEN_ALREADY_OTHER + OTHER_SCHEDULED, same denominator. |
| Reported beside PRIMARY, never inside it. ALIAS_SCHEDULED and REROUTED are labelled counts. |
| BOUNDS lower = numerator / all records in the class (unscored counted as PASS); |
| upper = (numerator + MIXED + not scored) / all records in the class. |
| Other breakClasses (pre-release, standing-limit, support-ends) are listed apart, same columns. |
| Arm C is also split on calendarEchoAny (a decisive token appears verbatim in the calendar text given). |
| Paired arm comparison: per model, over (item, sample) pairs scored in both arms; the dropped count is printed |
| per pair; row-cluster bootstrap (resample calendar rows, 2000 draws, seed 23196) for the difference in PRIMARY |
| and, on the same resamples, in SECONDARY. paired() also returns the transition table (pair counts by outcome in |
| arm X, outcome in arm Y) and the frozen reading rule flag noCalendarEffectClaimed (see paired()). |
| """ |
| import json |
| import random |
| import sys |
| from collections import Counter, defaultdict |
| from pathlib import Path |
|
|
| HERE = Path(__file__).resolve().parent |
| sys.path.insert(0, str(HERE)) |
| from score import BAD, load_status, score |
|
|
| NOT_SCORED = {"UNSCORED", "UNSCORED_IMPORT", "UNKNOWN_ID", "INVALID_ID", "NOT_RUN"} |
| SECOND_EXTRA = {"BROKEN_ALREADY_OTHER", "OTHER_SCHEDULED"} |
| PRIMARY_CLASS = "stops-working" |
|
|
|
|
| def load_rows(paths, duck, rust, ctx_base, cal_text): |
| st = load_status() |
| items = {json.loads(l)["id"]: json.loads(l) for l in open(HERE / "items.jsonl")} |
| rows = [] |
| for p in paths: |
| for l in open(p): |
| r = json.loads(l) |
| if r.get("error"): |
| continue |
| it = items[r["item"]] |
| t = it["check"]["type"] |
| key = f"{r['item']}|{r['arm']}|{r['model']}|{r.get('sample', 0)}" |
| if t in ("exec_duckdb", "exec_rust"): |
| src = duck if t == "exec_duckdb" else rust |
| if key in src: |
| o, d = src[key]["outcome"], {"exec": {k: v for k, v in src[key].items() if k != "expect"}} |
| else: |
| o, d = "NOT_RUN", {"why": "no contained-runner outcome for this reply"} |
| else: |
| ctx = dict(ctx_base) |
| if r["arm"] == "C": |
| ctx["calendar_text"] = cal_text |
| o, d = score(it, r["reply"], st, ctx=ctx) |
| rows.append({"item": r["item"], "arm": r["arm"], "model": r["model"], "sample": r.get("sample", 0), |
| "breakClass": it["breakClass"], "row": it["rows"][0], "outcome": o, "detail": d, |
| "finish": r.get("finish"), "echo": d.get("calendarEchoAny") if r["arm"] == "C" else None}) |
| return rows |
|
|
|
|
| def metrics(rs): |
| c = Counter(r["outcome"] for r in rs) |
| n = len(rs) |
| scored = sum(v for k, v in c.items() if k not in NOT_SCORED) |
| num = sum(c[k] for k in BAD) |
| sec = num + sum(c[k] for k in SECOND_EXTRA) |
| ns = n - scored |
| return {"n": n, "scored": scored, "primaryNum": num, "secondaryNum": sec, |
| "primary": (num / scored) if scored else None, "secondary": (sec / scored) if scored else None, |
| "lower": (num / n) if n else None, "upper": ((num + c["MIXED"] + ns) / n) if n else None, |
| "mixed": c["MIXED"], "notScored": ns, "alias": c["ALIAS_SCHEDULED"], "rerouted": c["REROUTED"], |
| "counts": dict(c)} |
|
|
|
|
| def pct(x): |
| return "n/a" if x is None else f"{100 * x:.0f}%" |
|
|
|
|
| def line(m): |
| return (f"n={m['n']} scored={m['scored']} PRIMARY={m['primaryNum']}/{m['scored']} ({pct(m['primary'])}) " |
| f"SECONDARY={m['secondaryNum']}/{m['scored']} ({pct(m['secondary'])}) bounds {pct(m['lower'])}-{pct(m['upper'])} " |
| f"mixed={m['mixed']} notScored={m['notScored']} alias={m['alias']} rerouted={m['rerouted']}") |
|
|
|
|
| def _ci(byrow, idx): |
| """Row-cluster bootstrap (resample calendar rows, 2000 draws, seed 23196) of the mean of component idx. |
| Both indicators use the same resamples, so PRIMARY and SECONDARY CIs are comparable.""" |
| rng = random.Random(23196) |
| rowsl = list(byrow) |
| ests = [[], []] |
| for _ in range(2000): |
| tot = [0, 0] |
| cnt = 0 |
| for _ in rowsl: |
| v = byrow[rng.choice(rowsl)] |
| tot[0] += sum(x[0] for x in v) |
| tot[1] += sum(x[1] for x in v) |
| cnt += len(v) |
| ests[0].append(tot[0] / cnt) |
| ests[1].append(tot[1] / cnt) |
| for e in ests: |
| e.sort() |
| return [[e[49], e[1949]] for e in ests] |
|
|
|
|
| def _excl0(ci): |
| return 1 if ci[0] > 0 else (-1 if ci[1] < 0 else 0) |
|
|
|
|
| def paired(rows, model, a, b, boot=True): |
| """Arm comparison (reading rule fixed before any scored run). Indicators: |
| PRIMARY = outcome in BAD (FAIL, BROKEN_ALREADY_ROW) |
| SECONDARY = PRIMARY or outcome in SECOND_EXTRA (BROKEN_ALREADY_OTHER, OTHER_SCHEDULED) |
| Reading rule (frozen): the arm-effect headline is the PRIMARY paired diff shown beside the SECONDARY diff. |
| noCalendarEffectClaimed = True when (i) the two CIs exclude 0 in opposite directions, or (ii) more than half of |
| the net PRIMARY change comes from pairs whose non-PRIMARY side is BROKEN_ALREADY_OTHER / OTHER_SCHEDULED. |
| Then the write-up claims no calendar effect in either direction and shows the transition table.""" |
| ra = {(r["item"], r["sample"]): r for r in rows if r["model"] == model and r["arm"] == a and r["breakClass"] == PRIMARY_CLASS} |
| rb = {(r["item"], r["sample"]): r for r in rows if r["model"] == model and r["arm"] == b and r["breakClass"] == PRIMARY_CLASS} |
| keys = [k for k in ra if k in rb and ra[k]["outcome"] not in NOT_SCORED and rb[k]["outcome"] not in NOT_SCORED] |
| dropped = {"onlyA": len([k for k in ra if k not in rb]), "onlyB": len([k for k in rb if k not in ra]), |
| "unscoredEitherArm": len([k for k in ra if k in rb]) - len(keys)} |
| if not keys: |
| return {"pairs": 0, "dropped": dropped} |
| prim = lambda r: 1 if r["outcome"] in BAD else 0 |
| sec = lambda r: 1 if (r["outcome"] in BAD or r["outcome"] in SECOND_EXTRA) else 0 |
| byrow = defaultdict(list) |
| trans = Counter() |
| for k in keys: |
| byrow[ra[k]["row"]].append((prim(ra[k]) - prim(rb[k]), sec(ra[k]) - sec(rb[k]))) |
| trans[f"{ra[k]['outcome']}|{rb[k]['outcome']}"] += 1 |
| diffs = [d for v in byrow.values() for d in v] |
| n = len(keys) |
| out = {"pairs": n, "dropped": dropped, |
| "rateA": sum(prim(ra[k]) for k in keys) / n, "rateB": sum(prim(rb[k]) for k in keys) / n, |
| "diffAminusB": sum(d[0] for d in diffs) / n, |
| "secondaryRateA": sum(sec(ra[k]) for k in keys) / n, "secondaryRateB": sum(sec(rb[k]) for k in keys) / n, |
| "secondaryDiffAminusB": sum(d[1] for d in diffs) / n, |
| "transitions": {"armA": a, "armB": b, "pairCounts": dict(sorted(trans.items()))}} |
| other = sum(prim(ra[k]) - prim(rb[k]) for k in keys |
| if (ra[k]["outcome"] in SECOND_EXTRA) != (rb[k]["outcome"] in SECOND_EXTRA) |
| and prim(ra[k]) != prim(rb[k])) |
| net = sum(d[0] for d in diffs) |
| out["primaryChangeFromOtherCells"] = {"net": net, "fromOther": other, |
| "share": (other / net) if net else None} |
| reasons = [] |
| if boot and len(byrow) > 1: |
| cp, cs = _ci(byrow, 0) |
| out["ci95"], out["secondaryCi95"] = cp, cs |
| if _excl0(cp) * _excl0(cs) == -1: |
| reasons.append("PRIMARY and SECONDARY CIs exclude 0 in opposite directions") |
| if net and other / net > 0.5: |
| reasons.append("more than half of the net PRIMARY change comes from BROKEN_ALREADY_OTHER/OTHER_SCHEDULED cells") |
| out["noCalendarEffectClaimed"] = bool(reasons) |
| out["noCalendarEffectReasons"] = reasons |
| return out |
|
|
|
|
| def main(): |
| a = sys.argv[1:] |
| paths = a[0].split(",") |
| out = a[1] |
| flag = lambda f: json.load(open(a[a.index(f) + 1])) if f in a else {} |
| duck, rust = flag("--duckdb"), flag("--rust") |
| adj_p = HERE / "adjudications.json" |
| ctx = {"adjudications": json.load(open(adj_p)) if adj_p.exists() else {}} |
| sys.path.insert(0, str(HERE)) |
| from run_items import calendar_context |
| rows = load_rows(paths, duck, rust, ctx, calendar_context()) |
| cells = defaultdict(list) |
| for r in rows: |
| cells[(r["model"], r["arm"])].append(r) |
| report = {"cells": {}, "armCsplit": {}, "paired": {}} |
| for (m, arm), rs in sorted(cells.items()): |
| print(f"\n== {m} arm {arm}") |
| for cls in sorted({r["breakClass"] for r in rs}, key=lambda c: (c != PRIMARY_CLASS, c)): |
| mm = metrics([r for r in rs if r["breakClass"] == cls]) |
| report["cells"][f"{m}|{arm}|{cls}"] = mm |
| print(f" [{cls}] {line(mm)}") |
| if arm == "C": |
| for flagv in (True, False): |
| sub = [r for r in rs if r["breakClass"] == PRIMARY_CLASS and bool(r["echo"]) == flagv] |
| mm = metrics(sub) |
| report["armCsplit"][f"{m}|echo={flagv}"] = mm |
| print(f" [stops-working, calendarEchoAny={flagv}] {line(mm)}") |
| models = sorted({r["model"] for r in rows}) |
| if "--pilot" not in a: |
| for m in models: |
| for x, y in (("A", "B"), ("A", "C"), ("B", "C")): |
| p = paired(rows, m, x, y) |
| report["paired"][f"{m}|{x}-{y}"] = p |
| print(f"\npaired {m} {x} vs {y}: {json.dumps(p)}") |
| json.dump({"rows": rows, "report": report}, open(out, "w"), indent=1) |
| print("\nUNSCORED / UNKNOWN_ID / INVALID_ID / UNSCORED_IMPORT cases (the instrument-readability read):") |
| for r in rows: |
| if r["outcome"] in ("UNSCORED", "UNKNOWN_ID", "INVALID_ID", "UNSCORED_IMPORT"): |
| print(f" {r['item']} {r['arm']} {r['outcome']} finish={r['finish']} {json.dumps(r['detail'])[:160]}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
