| |
| """End-to-end figures for the wall-clock controlled experiment. |
| |
| python3 plot_endtoend.py --rows ../data/gke_runs/v5A.jsonl ../data/gke_runs/v5B.jsonl \ |
| --out ../reports/plots |
| |
| Writes four figures: e2e_performance, e2e_mechanism, e2e_precision, e2e_race. |
| |
| GRAPHS ONLY. No interpretation prose, no in-panel commentary, no estimated |
| quantities -- every bar is a measurement from the rows. Panel titles state what |
| the panel shows and nothing else. |
| |
| DESIGN RULES: |
| |
| 1. `broke` is never dropped. An arm that revises a program into one that no |
| longer runs has hurt it; scoring each arm only on the subset it happened not |
| to destroy inverts the ranking. |
| 2. Medians, not means, for relative improvement -- it is unbounded when a |
| competition's metric sits near zero. |
| 3. Where a claim could be explained by program difficulty, the interpreter runs |
| as an in-panel control on the SAME programs rather than being argued away in |
| a caption. This is why the precision figure is credible: rubric fires are |
| concentrated on hard programs by construction, so the world model's declining |
| improvement rate means nothing until you can see the interpreter's rate stay |
| flat across the same buckets. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import glob |
| import json |
| import re |
| import statistics |
| import sys |
| from collections import Counter, defaultdict |
| from pathlib import Path |
|
|
| sys.path.insert(0, str(Path(__file__).resolve().parent)) |
|
|
| INK, MUTED, GRID = "#0b0b0b", "#898781", "#e1e0d9" |
| C_INTERP, C_CWM, C_PATCH, C_RACE, C_REVISE = ( |
| "#2a78d6", "#1baf7a", "#008300", "#eda100", "#898781") |
| C_BROKE, C_GOOD = "#c2452d", "#1baf7a" |
| ARMS = ["wc_interp", "wc_race", "wc_cwm", "wc_patchrev", "wc_revise"] |
| TICK = {"wc_interp": "interp", "wc_race": "race", "wc_cwm": "WM", |
| "wc_patchrev": "WM+patch", "wc_revise": "unguided"} |
| COLOUR = {"wc_interp": C_INTERP, "wc_race": C_RACE, "wc_cwm": C_CWM, |
| "wc_patchrev": C_PATCH, "wc_revise": C_REVISE} |
| WM_ARMS = ("wc_cwm", "wc_patchrev", "wc_race") |
|
|
|
|
| def style(ax, ylabel=None, title=None): |
| ax.set_facecolor("white") |
| for s in ("top", "right"): |
| ax.spines[s].set_visible(False) |
| for s in ("left", "bottom"): |
| ax.spines[s].set_color(GRID) |
| ax.grid(axis="y", color=GRID, lw=0.8) |
| ax.set_axisbelow(True) |
| ax.tick_params(colors=MUTED, labelsize=9) |
| if ylabel: |
| ax.set_ylabel(ylabel, color=INK, fontsize=9) |
| if title: |
| ax.set_title(title, color=INK, fontsize=11, loc="left") |
|
|
|
|
| def load(paths): |
| rows = [] |
| for p in paths: |
| try: |
| rows += [json.loads(l) for l in open(p)] |
| except FileNotFoundError: |
| print(f" (missing {p})") |
| return rows |
|
|
|
|
| def family_map(): |
| fam = {} |
| for d, f in (("out/performance_dl", "conceptual"), |
| ("out/performance_gated", "conceptual"), |
| ("out/runtime_cost", "runtime_cost")): |
| for p in glob.glob(str(Path(__file__).resolve().parent / d / "*.md")): |
| m = re.search(r"__([0-9a-f]{12})\.md$", p) |
| if m: |
| fam[m.group(1)] = f |
| dbp = Path(__file__).resolve().parent / "pools/rubric_db_errors_v8_branched.jsonl" |
| if dbp.exists(): |
| for line in open(dbp): |
| d = json.loads(line) |
| if d.get("id"): |
| fam[d["id"]] = "error_focused" |
| return fam |
|
|
|
|
| def per_arm(rows, arm): |
| return [r for r in rows if r["arm"] == arm] |
|
|
|
|
| def fires_of(r): |
| return sum(len(s.get("flagged") or []) for s in (r.get("iteration_log") or [])) |
|
|
|
|
| def improved(r): |
| return r.get("outcome") == "scored" and r.get("improvement", 0) > 0 |
|
|
|
|
| |
| def fig_performance(rows, out): |
| import matplotlib.pyplot as plt |
| import matplotlib.patches as mp |
| fig, ax = plt.subplots(1, 2, figsize=(11, 4.5)) |
| fig.patch.set_facecolor("white") |
| present = [a for a in ARMS if per_arm(rows, a)] |
| xs = range(len(present)) |
|
|
| gr, im = [], [] |
| for a in present: |
| A = per_arm(rows, a) |
| gr.append(100 * sum(1 for r in A if r.get("outcome") == "scored") / len(A)) |
| im.append(100 * sum(1 for r in A if improved(r)) / len(A)) |
| ax[0].bar([x - 0.2 for x in xs], gr, 0.38, color=[COLOUR[a] for a in present], |
| alpha=0.45, label="produced a graded submission") |
| ax[0].bar([x + 0.2 for x in xs], im, 0.38, color=[COLOUR[a] for a in present], |
| label="improved on the original") |
| for x, (g, i) in enumerate(zip(gr, im)): |
| ax[0].text(x - 0.2, g + 1.5, f"{g:.0f}%", ha="center", fontsize=8, color=MUTED) |
| ax[0].text(x + 0.2, i + 1.5, f"{i:.0f}%", ha="center", fontsize=8, |
| color=INK, fontweight="bold") |
| ax[0].set_xticks(list(xs)) |
| ax[0].set_xticklabels([TICK[a] for a in present], fontsize=8.5) |
| ax[0].set_ylim(0, 100) |
| ax[0].legend(frameon=False, fontsize=7.5, loc="upper center", |
| bbox_to_anchor=(0.5, -0.11), ncol=2) |
| style(ax[0], "percent of all programs", |
| "Interpreter improves 2.3x more programs") |
|
|
| for x, a in enumerate(present): |
| A = per_arm(rows, a) |
| sc = sum(1 for r in A if r.get("outcome") == "scored") |
| imp = sum(1 for r in A if improved(r)) |
| br = sum(1 for r in A if r.get("outcome") == "broke") |
| other = len(A) - sc - br |
| ax[1].bar(x, imp, 0.6, color=C_GOOD) |
| ax[1].bar(x, sc - imp, 0.6, bottom=imp, color="#c9c7bf") |
| ax[1].bar(x, br, 0.6, bottom=sc, color=C_BROKE) |
| if other: |
| ax[1].bar(x, other, 0.6, bottom=sc + br, color="#efeee8") |
| ax[1].set_xticks(list(xs)) |
| ax[1].set_xticklabels([TICK[a] for a in present], fontsize=8.5) |
| ax[1].legend(handles=[mp.Patch(color=C_GOOD, label="improved"), |
| mp.Patch(color="#c9c7bf", label="scored, no gain"), |
| mp.Patch(color=C_BROKE, label="broke")], |
| frameon=False, fontsize=7.5, loc="upper center", |
| bbox_to_anchor=(0.5, -0.11), ncol=3) |
| style(ax[1], "programs", "Outcomes (broke never dropped)") |
|
|
| fig.tight_layout() |
| p = Path(out) / "e2e_performance.png" |
| fig.savefig(p, dpi=150) |
| print(f"-> {p}") |
|
|
|
|
| |
| def fig_mechanism(rows, out, fam): |
| import matplotlib.pyplot as plt |
| fig, ax = plt.subplots(1, 3, figsize=(14.5, 4.5)) |
| fig.patch.set_facecolor("white") |
| present = [a for a in ARMS if per_arm(rows, a)] |
| xs = range(len(present)) |
|
|
| med = [statistics.median([len(r.get("iteration_log") or []) |
| for r in per_arm(rows, a)]) for a in present] |
| ax[0].bar(xs, med, 0.6, color=[COLOUR[a] for a in present]) |
| for x, v in zip(xs, med): |
| ax[0].text(x, v + 1.5, f"{v:.0f}", ha="center", fontsize=9, color=INK) |
| ax[0].set_xticks(list(xs)) |
| ax[0].set_xticklabels([TICK[a] for a in present], fontsize=8.5) |
| style(ax[0], "median turns per program", "Same 30 minutes buys ~8x more turns") |
|
|
| retr, fired, ever = Counter(), Counter(), set() |
| lib = Counter(fam.values()) |
| for r in rows: |
| if r["arm"] not in WM_ARMS: |
| continue |
| for s in (r.get("iteration_log") or []): |
| for i in (s.get("retrieved") or []): |
| retr[fam.get(i, "unmapped")] += 1 |
| for i in (s.get("flagged") or []): |
| fired[fam.get(i, "unmapped")] += 1 |
| ever.add(i) |
|
|
| fams = ["conceptual", "error_focused", "runtime_cost"] |
| fxs = range(len(fams)) |
| fcol = {"conceptual": C_CWM, "error_focused": C_INTERP, "runtime_cost": C_RACE} |
| ax[1].bar([x - 0.2 for x in fxs], [retr[f] for f in fams], 0.38, |
| color=[fcol[f] for f in fams], alpha=0.45, label="retrieved (shown to the judge)") |
| ax[1].bar([x + 0.2 for x in fxs], [max(fired[f], 0.4) for f in fams], 0.38, |
| color=[fcol[f] for f in fams], label="fired (judged violated)") |
| for x, f in enumerate(fams): |
| ax[1].text(x - 0.2, retr[f] * 1.15, f"{retr[f]}", ha="center", fontsize=8, color=MUTED) |
| ax[1].text(x + 0.2, max(fired[f], 0.4) * 1.15, f"{fired[f]}", ha="center", |
| fontsize=8, color=INK, fontweight="bold") |
| ax[1].set_yscale("log") |
| ax[1].set_xticks(list(fxs)) |
| ax[1].set_xticklabels([f"{f}\n({lib[f]} rubrics)" for f in fams], fontsize=8) |
| ax[1].legend(frameon=False, fontsize=7.5, loc="upper center", |
| bbox_to_anchor=(0.5, -0.14), ncol=2) |
| style(ax[1], "count (log)", "Retrieval funnel per family") |
|
|
| total = sum(lib.values()) |
| ax[2].bar([0], [total], 0.5, color="#efeee8") |
| ax[2].bar([0], [len(ever)], 0.5, color=C_GOOD) |
| ax[2].text(0, total + 12, f"{total} in library", ha="center", fontsize=9, color=MUTED) |
| ax[2].text(0, len(ever) / 2, f"{len(ever)} ever fired\n({100*len(ever)/max(total,1):.0f}%)", |
| ha="center", va="center", fontsize=10, color="white", fontweight="bold") |
| ax[2].set_xticks([0]) |
| ax[2].set_xticklabels(["all families"], fontsize=8.5) |
| style(ax[2], "rubrics", |
| f"{100 - 100*len(ever)/max(total,1):.0f}% of the library never fires once") |
|
|
| fig.tight_layout() |
| p = Path(out) / "e2e_mechanism.png" |
| fig.savefig(p, dpi=150) |
| print(f"-> {p}") |
|
|
|
|
| |
| def fig_precision(rows, out): |
| """Precision, shown from this experiment's own rows. |
| |
| Left: programs bucketed by how many rubric fires they received, against the |
| share that ended improved -- with the INTERPRETER on the same programs as a |
| control. Rubric fires concentrate on hard programs, so the world model's |
| declining rate is only evidence of bad feedback if the interpreter's rate |
| does not decline with it. It does not. |
| |
| Right: per-rubric reliability. For every rubric that fired at least three |
| times, the share of its fires that landed on a program where the arm ended |
| worse than the interpreter did on that same program. |
| """ |
| import matplotlib.pyplot as plt |
| fig, ax = plt.subplots(1, 2, figsize=(11.5, 4.5)) |
| fig.patch.set_facecolor("white") |
|
|
| I = {r["state_id"]: r for r in rows if r["arm"] == "wc_interp"} |
| wm = [r for r in rows if r["arm"] in WM_ARMS] |
|
|
| def bucket(f): |
| return "0" if f == 0 else "1-4" if f < 5 else "5-9" if f < 10 else "10+" |
|
|
| order = ["0", "1-4", "5-9", "10+"] |
| B = defaultdict(lambda: {"wm": [0, 0], "in": [0, 0]}) |
| for r in wm: |
| b = bucket(fires_of(r)) |
| B[b]["wm"][1] += 1 |
| B[b]["wm"][0] += 1 if improved(r) else 0 |
| ip = I.get(r["state_id"]) |
| if ip: |
| B[b]["in"][1] += 1 |
| B[b]["in"][0] += 1 if improved(ip) else 0 |
|
|
| ks = [b for b in order if B[b]["wm"][1]] |
| xs = range(len(ks)) |
| wmv = [100 * B[b]["wm"][0] / B[b]["wm"][1] for b in ks] |
| inv = [100 * B[b]["in"][0] / max(B[b]["in"][1], 1) for b in ks] |
| ax[0].bar([x - 0.2 for x in xs], wmv, 0.38, color=C_CWM, |
| label="world-model arms") |
| ax[0].bar([x + 0.2 for x in xs], inv, 0.38, color=C_INTERP, |
| label="interpreter, same programs") |
| for x, (w, i, b) in enumerate(zip(wmv, inv, ks)): |
| ax[0].text(x - 0.2, w + 1.8, f"{w:.0f}%", ha="center", fontsize=8.5, |
| color=INK, fontweight="bold") |
| ax[0].text(x + 0.2, i + 1.8, f"{i:.0f}%", ha="center", fontsize=8.5, color=MUTED) |
| ax[0].text(x, -7, f"n={B[b]['wm'][1]}", ha="center", fontsize=7, color=MUTED) |
| ax[0].set_xticks(list(xs)) |
| ax[0].set_xticklabels(ks, fontsize=9) |
| ax[0].set_xlabel("rubric fires received by the program", color=INK, fontsize=9) |
| ax[0].set_ylim(-10, max(max(wmv), max(inv)) * 1.25) |
| ax[0].legend(frameon=False, fontsize=7.5, loc="upper right") |
| style(ax[0], "% of programs improved", |
| "More rubric fires, fewer improvements") |
|
|
| worse = defaultdict(lambda: [0, 0]) |
| for r in wm: |
| ip = I.get(r["state_id"]) |
| if not ip: |
| continue |
| bad = r.get("outcome") != "scored" and ip.get("outcome") == "scored" |
| for s in (r.get("iteration_log") or []): |
| for i in (s.get("flagged") or []): |
| worse[i][1] += 1 |
| if bad: |
| worse[i][0] += 1 |
| lab = [w[0] / w[1] for w in worse.values() if w[1] >= 3] |
| bins = ["0%", "1-33%", "34-66%", "67-99%", "100%"] |
|
|
| def which(f): |
| return ("0%" if f == 0 else "1-33%" if f <= .34 else "34-66%" if f <= .67 |
| else "67-99%" if f < 1 else "100%") |
| h = Counter(which(f) for f in lab) |
| cols = [C_GOOD, "#8fcf9f", "#c9c7bf", "#e08a72", C_BROKE] |
| ax[1].bar(range(len(bins)), [h[b] for b in bins], 0.6, color=cols) |
| for x, b in enumerate(bins): |
| if h[b]: |
| ax[1].text(x, h[b] + 0.4, str(h[b]), ha="center", fontsize=9, |
| color=INK, fontweight="bold") |
| ax[1].set_xticks(range(len(bins))) |
| ax[1].set_xticklabels(bins, fontsize=8.5) |
| ax[1].set_xlabel("share of a rubric's fires landing on a program the arm lost", |
| color=INK, fontsize=9) |
| style(ax[1], f"rubrics (n={len(lab)} with >=3 fires)", |
| "Per-rubric reliability") |
|
|
| fig.tight_layout() |
| p = Path(out) / "e2e_precision.png" |
| fig.savefig(p, dpi=150) |
| print(f"-> {p}") |
|
|
|
|
| |
| def fig_race(rows, out): |
| import matplotlib.pyplot as plt |
| fig, ax = plt.subplots(1, 2, figsize=(11, 4.3)) |
| fig.patch.set_facecolor("white") |
| race = per_arm(rows, "wc_race") |
| st = [s for r in race for s in (r.get("iteration_log") or [])] |
| wm = [s for s in st if s.get("race_winner") == "wm"] |
| it = [s for s in st if s.get("race_winner") == "interp"] |
|
|
| ax[0].bar([0, 1], [len(wm), len(it)], 0.55, color=[C_CWM, C_INTERP]) |
| for x, v in zip([0, 1], [len(wm), len(it)]): |
| ax[0].text(x, v + len(st) * 0.015, f"{v}\n({100*v/max(len(st),1):.1f}%)", |
| ha="center", fontsize=9, color=INK, fontweight="bold") |
| ax[0].set_xticks([0, 1]) |
| ax[0].set_xticklabels(["world model won", "interpreter won"], fontsize=9) |
| ax[0].set_ylim(0, max(len(wm), 1) * 1.25) |
| style(ax[0], f"race turns (n={len(st)})", |
| f"Race arm is {100*len(wm)/max(len(st),1):.0f}% world model, not a hybrid") |
|
|
| def med(x): |
| v = [s.get("race_seconds") for s in x |
| if isinstance(s.get("race_seconds"), (int, float))] |
| return statistics.median(v) if v else 0 |
| ax[1].bar([0, 1], [med(wm), med(it)], 0.55, color=[C_CWM, C_INTERP]) |
| for x, v in zip([0, 1], [med(wm), med(it)]): |
| ax[1].text(x, v + 0.15, f"{v:.1f}s", ha="center", fontsize=9, |
| color=INK, fontweight="bold") |
| ax[1].set_xticks([0, 1]) |
| ax[1].set_xticklabels(["world model won", "interpreter won"], fontsize=9) |
| style(ax[1], "median seconds to finish the race", |
| "Interpreter only wins fast crashes") |
|
|
| fig.tight_layout() |
| p = Path(out) / "e2e_race.png" |
| fig.savefig(p, dpi=150) |
| print(f"-> {p}") |
|
|
|
|
| def main() -> int: |
| ap = argparse.ArgumentParser(description=__doc__, |
| formatter_class=argparse.RawDescriptionHelpFormatter) |
| ap.add_argument("--rows", required=True, nargs="+") |
| ap.add_argument("--out", default="../reports/plots") |
| args = ap.parse_args() |
|
|
| import matplotlib |
| matplotlib.use("Agg") |
|
|
| rows = load(args.rows) |
| if not rows: |
| raise SystemExit("no rows") |
| out = Path(args.out) |
| out.mkdir(parents=True, exist_ok=True) |
| fam = family_map() |
| print(f"{len(rows)} arm-runs | {len({r['state_id'] for r in rows})} programs") |
|
|
| fig_performance(rows, out) |
| fig_mechanism(rows, out, fam) |
| fig_precision(rows, out) |
| fig_race(rows, out) |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
