File size: 10,658 Bytes
e0588e3 | 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 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 | #!/usr/bin/env python3
"""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 # noqa: E402
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()
|