#!/usr/bin/env python3 """Plots for the wall-clock controlled experiment. python3 plot_wallclock.py --rows ../data/gke_runs/wcN1.jsonl \ ../data/gke_runs/wcS2.jsonl --out reports/plots Four figures, in the order the argument has to be made: 1. TURNS PER ARM -- the mechanism. Equalising wall clock instead of turns is the whole design, so the first thing to show is that it actually bought the execution-free arms more iterations. 2. WHERE THE BUDGET WENT -- why. An arm that spends most of its 1800s waiting on the interpreter is the finding, not a footnote. 3. OUTCOMES -- scored / improved / broke, stacked. `broke` is a real loss and is never dropped: an arm that revises a program into one that no longer runs has hurt it, and hiding that would score each arm only on the subset it happened not to destroy. 4. ADVANTAGE vs EXECUTION COST -- the actual hypothesis. The claim is that an execution-free channel wins where execution is expensive, so the headline is the RELATIONSHIP, not a pooled mean that mixes regimes. Medians, not means, wherever an outlier could dominate: relative improvement is unbounded when a competition's metric sits near zero (measured live, dogs-vs-cats log-loss 0.0444 -> 8.0075 is a real degradation but reads as -17955%, and one such row moves a 20-program mean by ~900 points). """ from __future__ import annotations import argparse import json import statistics import sys from collections import defaultdict from pathlib import Path sys.path.insert(0, str(Path(__file__).resolve().parent)) from common import read_jsonl # The repo's validated reference palette (codeworld-gym/scripts/make_report_plots.py). INK = "#0b0b0b" MUTED = "#898781" GRID = "#e1e0d9" ARM_COLOUR = { "wc_interp": "#2a78d6", # the baseline that has ground truth "wc_cwm": "#1baf7a", # the execution-free world model "wc_patchrev": "#008300", # world model + surgical diffs "wc_race": "#eda100", # world model raced against the interpreter "wc_revise": "#898781", # unguided control: deliberately grey, it is a floor } ARM_LABEL = { "wc_interp": "interpreter", "wc_cwm": "world model", "wc_patchrev": "WM + patch", "wc_race": "WM ⚡ race", "wc_revise": "unguided (floor)", } OUTLIER_ABS = 10.0 def _style(ax): ax.spines[["top", "right"]].set_visible(False) ax.spines[["left", "bottom"]].set_color(GRID) ax.tick_params(colors=MUTED, labelsize=9) ax.yaxis.grid(True, color=GRID, lw=0.8) ax.set_axisbelow(True) def load(paths: list[str]) -> list[dict]: rows, seen = [], set() for p in paths: for r in read_jsonl(p): k = (r.get("state_id"), r.get("arm")) if not r.get("arm") or k in seen: continue seen.add(k) rows.append(r) return rows def fig_turns(rows, ax): arms = [a for a in ARM_COLOUR if any(r["arm"] == a for r in rows)] data = [[r["iterations"] for r in rows if r["arm"] == a and r.get("iterations") is not None] for a in arms] ax.bar([ARM_LABEL[a] for a in arms], [statistics.median(d) if d else 0 for d in data], color=[ARM_COLOUR[a] for a in arms], width=0.62) for i, d in enumerate(data): if d: ax.text(i, statistics.median(d), f" {statistics.median(d):.0f}", ha="center", va="bottom", fontsize=9, color=INK) ax.set_title("Turns taken inside the same 30-minute budget", fontsize=11, color=INK, loc="left") ax.set_ylabel("median turns", fontsize=9, color=MUTED) _style(ax) def fig_budget(rows, ax): arms = [a for a in ARM_COLOUR if any(r["arm"] == a for r in rows)] cats = ["execution", "race_interp", "wm_judge", "wm_judge_final", "retrieval", "patch_edit", "coder"] shades = {"execution": "#e34948", "race_interp": "#e87ba4", "wm_judge": "#1baf7a", "wm_judge_final": "#7ee08a", "retrieval": "#2a78d6", "patch_edit": "#008300", "coder": "#c3c2b7"} bottom = [0.0] * len(arms) for c in cats: vals = [] for a in arms: xs = [(r.get("budget") or {}).get("spent_by_category", {}).get(c, 0.0) for r in rows if r["arm"] == a] vals.append(statistics.fmean(xs) if xs else 0.0) if not any(vals): continue ax.bar([ARM_LABEL[a] for a in arms], vals, bottom=bottom, color=shades[c], label=c, width=0.62) bottom = [b + v for b, v in zip(bottom, vals)] ax.set_title("Where each arm's budget went (mean seconds)", fontsize=11, color=INK, loc="left") ax.legend(fontsize=7, frameon=False, ncol=2) _style(ax) def fig_outcomes(rows, ax): arms = [a for a in ARM_COLOUR if any(r["arm"] == a for r in rows)] imp, flat, broke = [], [], [] for a in arms: sub = [r for r in rows if r["arm"] == a] sc = [r for r in sub if r.get("outcome") == "scored"] imp.append(sum(1 for r in sc if r.get("improvement", 0) > 0)) flat.append(len(sc) - imp[-1]) broke.append(sum(1 for r in sub if r.get("outcome") == "broke")) lbl = [ARM_LABEL[a] for a in arms] ax.bar(lbl, imp, color="#1baf7a", label="improved", width=0.62) ax.bar(lbl, flat, bottom=imp, color="#c3c2b7", label="scored, no gain", width=0.62) ax.bar(lbl, broke, bottom=[i + f for i, f in zip(imp, flat)], color="#e34948", label="broke the program", width=0.62) ax.set_title("Outcomes per arm (broke is a real loss, never dropped)", fontsize=11, color=INK, loc="left") ax.set_ylabel("programs", fontsize=9, color=MUTED) ax.legend(fontsize=8, frameon=False) _style(ax) def fig_advantage(rows, ax, control="wc_interp"): """Paired advantage over the interpreter, against execution cost.""" cost = defaultdict(list) for r in rows: if r["arm"] not in ("wc_interp", "wc_race"): continue cat = (r.get("budget") or {}).get("spent_by_category") or {} secs = cat.get("execution", 0.0) or cat.get("race_interp", 0.0) n = r.get("iterations") or 0 if secs and n: cost[r["competition"]].append(secs / n) cost = {k: statistics.fmean(v) for k, v in cost.items()} by_state = defaultdict(dict) comp_of = {} for r in rows: if r.get("outcome") == "scored": by_state[r["state_id"]][r["arm"]] = r["relative_improvement"] comp_of[r["state_id"]] = r["competition"] plotted = False for a in ("wc_cwm", "wc_patchrev", "wc_race"): xs, ys = [], [] for sid, v in by_state.items(): if a in v and control in v and comp_of[sid] in cost: d = v[a] - v[control] if abs(d) > OUTLIER_ABS: continue # metric artifact, see module docstring xs.append(cost[comp_of[sid]]) ys.append(100 * d) if xs: ax.scatter(xs, ys, s=42, color=ARM_COLOUR[a], label=ARM_LABEL[a], alpha=0.85, edgecolor="white", linewidth=0.6) plotted = True ax.axhline(0, color=INK, lw=1) ax.set_xscale("log") ax.set_xlabel("seconds per real execution (log)", fontsize=9, color=MUTED) ax.set_ylabel("advantage over interpreter (pp)", fontsize=9, color=MUTED) ax.set_title("The hypothesis: does the execution-free channel win where\n" "execution is expensive?", fontsize=11, color=INK, loc="left") if plotted: ax.legend(fontsize=8, frameon=False) else: ax.text(0.5, 0.5, "no paired states yet", ha="center", va="center", transform=ax.transAxes, color=MUTED, fontsize=10) _style(ax) def fig_library(un, ga, ax_out, ax_use, arm="wc_cwm"): """Gated vs ungated library, on the programs run under BOTH. Restricting to the common set is not cosmetic. The two libraries scored different subsets (9 vs 12 of 19), so a pooled median silently compares different programs -- and the gated library's extra scored programs are exactly the hard ones the ungated library destroyed, which biases the comparison AGAINST gating on any metric conditioned on scoring. """ UN = {r["state_id"]: r for r in un if r["arm"] == arm} GA = {r["state_id"]: r for r in ga if r["arm"] == arm} common = sorted(set(UN) & set(GA)) # Left: outcome shift. `broke` is the cost of a wrong fire, so it is the # quantity precision gating is supposed to move. labels = ["ungated\n430 rubrics", "gated\n22 rubrics"] scored = [sum(1 for s in common if UN[s].get("outcome") == "scored"), sum(1 for s in common if GA[s].get("outcome") == "scored")] broke = [len(common) - scored[0], len(common) - scored[1]] x = range(2) ax_out.bar(x, scored, 0.55, color="#1baf7a", label="scored") ax_out.bar(x, broke, 0.55, bottom=scored, color="#c2452d", label="broke") # Segments are labelled in place rather than via a legend: a legend box in # this panel lands on top of a full-height bar and its swatch disappears # against the fill. for i, (s, b) in enumerate(zip(scored, broke)): ax_out.text(i, s / 2, f"{s} scored" if i == 0 else str(s), ha="center", va="center", color="white", fontsize=11, fontweight="bold") ax_out.text(i, s + b / 2, f"{b} broke" if i == 0 else str(b), ha="center", va="center", color="white", fontsize=11, fontweight="bold") ax_out.set_xticks(list(x)) ax_out.set_xticklabels(labels, fontsize=9) ax_out.set_ylabel(f"programs (n={len(common)} run under both)") ax_out.set_title("Precision gating breaks fewer programs", fontsize=11, color=INK, loc="left") _style(ax_out) # Right: the cost of gating. Fires collapse -- which is the point -- but so # does budget utilisation, and that is the constraint gating cannot fix. def fires(rows): a = [r for r in rows if r["arm"] == arm] f = sum(len(s.get("flagged") or []) for r in a for s in (r.get("iteration_log") or [])) t = sum(len(r.get("iteration_log") or []) for r in a) used = statistics.fmean([(r.get("budget") or {}).get("elapsed_seconds", 0) for r in a] or [0]) return 100 * f / max(t, 1), 100 * used / 1800 (fu, bu), (fg, bg) = fires(un), fires(ga) xs = [0, 1] ax_use.bar([i - 0.19 for i in xs], [fu, fg], 0.36, color="#2a78d6", label="fire rate (% of turns)") ax_use.bar([i + 0.19 for i in xs], [bu, bg], 0.36, color="#eda100", label="budget used (% of 1800s)") for i, v in zip([-0.19, 0.81], [fu, fg]): ax_use.text(i, v + 1.5, f"{v:.1f}%", ha="center", fontsize=8, color=INK) for i, v in zip([0.19, 1.19], [bu, bg]): ax_use.text(i, v + 1.5, f"{v:.0f}%", ha="center", fontsize=8, color=INK) ax_use.set_xticks(xs) ax_use.set_xticklabels(labels, fontsize=9) ax_use.set_ylabel("percent") ax_use.set_title("...but runs out of things to say (17% of budget)", fontsize=11, color=INK, loc="left") ax_use.legend(frameon=False, fontsize=8) _style(ax_use) def main() -> int: ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) ap.add_argument("--rows", required=True, nargs="+") ap.add_argument("--gated-rows", nargs="*", default=[], help="Rows from the causally-gated library run; adds the " "library-comparison figure.") ap.add_argument("--out", default="reports/plots") ap.add_argument("--tag", default="wallclock") args = ap.parse_args() import matplotlib matplotlib.use("Agg") import matplotlib.pyplot as plt rows = load(args.rows) if not rows: raise SystemExit("no rows") out = Path(args.out) out.mkdir(parents=True, exist_ok=True) fig, axes = plt.subplots(2, 2, figsize=(13, 9)) fig.patch.set_facecolor("white") fig_turns(rows, axes[0][0]) fig_budget(rows, axes[0][1]) fig_outcomes(rows, axes[1][0]) fig_advantage(rows, axes[1][1]) progs = len({r["state_id"] for r in rows}) fig.suptitle(f"Wall-clock controlled experiment — {len(rows)} arm-runs, " f"{progs} held-out programs, 1800s per arm", fontsize=13, color=INK, x=0.02, ha="left") fig.tight_layout(rect=(0, 0, 1, 0.96)) p = out / f"{args.tag}.png" fig.savefig(p, dpi=160) print(f"-> {p}") if args.gated_rows: ga = load(args.gated_rows) f2, ax2 = plt.subplots(1, 2, figsize=(11, 4.4)) f2.patch.set_facecolor("white") fig_library(rows, ga, ax2[0], ax2[1]) f2.suptitle("Causally gated vs ungated rubric library — the two levers " "are multiplicative", fontsize=12, color=INK, x=0.02, ha="left") f2.tight_layout(rect=(0, 0, 1, 0.93)) p2 = out / f"{args.tag}_library.png" f2.savefig(p2, dpi=160) print(f"-> {p2}") return 0 if __name__ == "__main__": raise SystemExit(main())