Datasets:
Publish cross-hardware reproducibility dataset with preprint PDF and source (CC-BY-4.0)
4e189ca verified | #!/usr/bin/env python3 | |
| """Regenerate every number, table and figure in paper.tex from the item-level evidence. | |
| python3 figures/make_figures.py --decl <batch1 decl dir> --decl <batch2 decl dir> \ | |
| --items <dir holding every run's items.jsonl> [--p100-decl <dir>] | |
| Writes figures/*.pdf + *.png, tables/*.tex and build/numbers.json (plus tables/numbers.tex, | |
| a file of \\newcommand macros that paper.tex \\input's, so no number in the text is typed by hand). | |
| Everything is rebuilt from the per-item runs and cross-checked against the signed-capsule | |
| declarations by xhw.load(); a mismatch aborts. | |
| """ | |
| from __future__ import annotations | |
| import argparse | |
| import collections | |
| import json | |
| import math | |
| import os | |
| import sys | |
| HERE = os.path.dirname(os.path.abspath(__file__)) | |
| ROOT = os.path.dirname(HERE) | |
| sys.path.insert(0, HERE) | |
| import xhw # noqa: E402 | |
| import matplotlib # noqa: E402 | |
| matplotlib.use("Agg") | |
| import matplotlib.pyplot as plt # noqa: E402 | |
| # palette: validated with the dataviz validator (light surface, adjacent pairs, all hard gates pass) | |
| C_IDENT, C_RAWONLY, C_SWAP, C_FLIP = "#2a78d6", "#1baf7a", "#4a3aa7", "#eb6834" | |
| INK, INK2, MUTED, GRID = "#0b0b0b", "#52514e", "#898781", "#e1e0d9" | |
| SEQ = ["#fcfcfb", "#cde2fb", "#9ec5f4", "#6da7ec", "#3987e5", "#256abf", "#184f95", "#0d366b"] | |
| plt.rcParams.update({ | |
| "font.family": "DejaVu Sans", "font.size": 8, "axes.edgecolor": "#c3c2b7", "axes.labelcolor": INK2, | |
| "xtick.color": INK2, "ytick.color": INK2, "axes.spines.top": False, "axes.spines.right": False, | |
| "axes.grid": False, "pdf.fonttype": 42, "savefig.dpi": 200, | |
| }) | |
| # Read from the T4 ollama serve logs (print_info: file type; load_tensors: CUDA0/CUDA1 model buffer). | |
| # The same GGUF blobs (same manifest digest) ran on the 3090; the 3090-side layout is UNRECORDED. | |
| QUANT = {"mistral-nemo:12b": "Q4_0", "gemma3:12b": "Q4_K_M", "gemma3:4b": "Q4_K_M", "llama3.1:8b": "Q4_K_M", | |
| "llama3.2:3b": "Q4_K_M", "mistral:7b": "Q4_K_M", "phi3.5:3.8b": "Q4_0", "qwen2.5:0.5b-instruct": "Q4_K_M", | |
| "qwen2.5:1.5b": "Q4_K_M", "qwen2.5:7b": "Q4_K_M", "qwen3:8b": "Q4_K_M"} | |
| T4_SPLIT = {"mistral-nemo:12b": True, "gemma3:12b": True, "phi3.5:3.8b": True} | |
| PARAMS_B = {"mistral-nemo:12b": 12.2, "gemma3:12b": 12.2, "gemma3:4b": 4.3, "llama3.1:8b": 8.0, "llama3.2:3b": 3.2, | |
| "mistral:7b": 7.2, "phi3.5:3.8b": 3.8, "qwen2.5:0.5b-instruct": 0.5, "qwen2.5:1.5b": 1.5, | |
| "qwen2.5:7b": 7.6, "qwen3:8b": 8.2} | |
| def wilson(k: int, n: int, z: float = 1.96) -> tuple[float, float]: | |
| if n == 0: | |
| return (float("nan"), float("nan")) | |
| p = k / n | |
| d = 1 + z * z / n | |
| c = (p + z * z / (2 * n)) / d | |
| h = z * math.sqrt(p * (1 - p) / n + z * z / (4 * n * n)) / d | |
| return (c - h, c + h) | |
| def binom_two_sided(k: int, n: int) -> float: | |
| """Exact two-sided sign test p-value, H0 p = 1/2.""" | |
| tail = sum(math.comb(n, i) for i in range(0, min(k, n - k) + 1)) / 2 ** n | |
| return min(1.0, 2 * tail) | |
| def pct(a: int, b: int, d: int = 1) -> str: | |
| return f"{100 * a / b:.{d}f}" if b else "--" | |
| def common_prefix(a: str, b: str) -> int: | |
| n = min(len(a), len(b)) | |
| i = 0 | |
| while i < n and a[i] == b[i]: | |
| i += 1 | |
| return i | |
| def tex_escape(s: str) -> str: | |
| return s.replace("_", r"\_").replace("%", r"\%").replace("&", r"\&") | |
| def model_order(cards): | |
| return sorted({c.model for c in cards}, key=lambda m: (PARAMS_B.get(m, 0), m)) | |
| def main() -> None: | |
| ap = argparse.ArgumentParser() | |
| ap.add_argument("--decl", action="append", required=True) | |
| ap.add_argument("--items", action="append", required=True) | |
| ap.add_argument("--p100-decl", default=None, help="third-runtime declarations, when the P100 run completes") | |
| a = ap.parse_args() | |
| cards = xhw.load(a.decl, a.items) | |
| os.makedirs(os.path.join(ROOT, "build"), exist_ok=True) | |
| os.makedirs(os.path.join(ROOT, "tables"), exist_ok=True) | |
| N = {} | |
| # ------------------------------------------------------------------ totals | |
| def tally(cs): | |
| t = collections.Counter() | |
| for c in cs: | |
| p = c.pair() | |
| for k in ("n", "raw_eq", "label_eq", "grade_eq", "status_eq", "flips", "flips_up", "flips_down", "swaps"): | |
| t[k] += p[k] | |
| t["cards"] += 1 | |
| t["itemwise"] += p["itemwise_grade_equal"] | |
| t["admit_item"] += p["admitted_item_rule"] | |
| t["admit_count"] += p["admitted_count_rule"] | |
| t["agg_only"] += p["aggregate_equal"] and not p["itemwise_grade_equal"] | |
| t["itemwise_not_agg"] += p["itemwise_grade_equal"] and not p["aggregate_equal"] | |
| t["raw_identical_cards"] += p["raw_eq"] == p["n"] | |
| t["n30"] += c.decl["n"] >= 30 | |
| t["admit_item_n30"] += p["admitted_item_rule"] and c.decl["n"] >= 30 | |
| return t | |
| for label, cs in (("all", cards), ("b1", [c for c in cards if c.batch == "batch1"]), | |
| ("b2", [c for c in cards if c.batch == "batch2"])): | |
| t = tally(cs) | |
| for k, v in t.items(): | |
| N[f"{label}_{k}"] = v | |
| N[f"{label}_raw_eq_pct"] = pct(t["raw_eq"], t["n"]) | |
| N[f"{label}_grade_eq_pct"] = pct(t["grade_eq"], t["n"]) | |
| N[f"{label}_label_eq_pct"] = pct(t["label_eq"], t["n"]) | |
| N[f"{label}_status_eq_pct"] = pct(t["status_eq"], t["n"]) | |
| lo, hi = wilson(t["n"] - t["grade_eq"], t["n"]) | |
| N[f"{label}_flip_rate_pct"] = pct(t["n"] - t["grade_eq"], t["n"], 2) | |
| N[f"{label}_flip_rate_ci"] = f"{100*lo:.2f}--{100*hi:.2f}" | |
| N[f"{label}_models"] = len({c.model for c in cs}) | |
| N[f"{label}_axes"] = len({c.axis for c in cs}) | |
| N["sign_test_p"] = f"{binom_two_sided(N['all_flips_up'], N['all_flips']):.2f}" | |
| # raw differs -> how often does the grade move? | |
| raw_diff = N["all_n"] - N["all_raw_eq"] | |
| N["all_raw_diff"] = raw_diff | |
| N["raw_diff_grade_moves_pct"] = pct(N["all_n"] - N["all_grade_eq"], raw_diff) | |
| # ------------------------------------------------------------------ repeat | |
| rep = collections.defaultdict(collections.Counter) | |
| rep_flip_overlap = 0 | |
| for c in cards: | |
| if not c.has_repeat(): | |
| continue | |
| q = c.pair("t4", "t4_repeat") | |
| r = rep[c.model] | |
| r["cards"] += 1 | |
| r["items"] += q["n"] | |
| r["nonident_cards"] += q["raw_eq"] < q["n"] | |
| r["raw_diff"] += q["n"] - q["raw_eq"] | |
| r["grade_diff"] += q["n"] - q["grade_eq"] | |
| r["status_diff"] += q["n"] - q["status_eq"] | |
| r["count_diff_cards"] += not q["aggregate_equal"] | |
| r["itemwise_fail_cards"] += q["grade_eq"] < q["n"] | |
| unstable = {i for i in c.order() if c.items[i]["t4"]["raw_output_sha256"] != c.items[i]["t4_repeat"]["raw_output_sha256"]} | |
| rep_flip_overlap += len(unstable & set(c.pair()["flip_ids"])) | |
| R = collections.Counter() | |
| for m in rep.values(): | |
| R.update(m) | |
| for k, v in R.items(): | |
| N[f"rep_{k}"] = v | |
| N["rep_missing_cards"] = sum(1 for c in cards if not c.has_repeat()) | |
| N["rep_flip_overlap"] = rep_flip_overlap | |
| N["rep_b1_nonident"] = sum(1 for c in cards if c.batch == "batch1" and c.has_repeat() | |
| and c.pair("t4", "t4_repeat")["raw_eq"] < len(c.items)) | |
| N["rep_models_nonident"] = sum(1 for m in rep.values() if m["nonident_cards"]) | |
| # ------------------------------------------------------------------ swaps and first divergence | |
| swap_rows, prefixes, prefix_len_stop = [], [], collections.Counter() | |
| length_items = length_raw_diff = stop_items = stop_raw_diff = 0 | |
| for c in cards: | |
| p = c.pair() | |
| for i in p["swap_ids"]: | |
| x, y = c.items[i]["rtx3090"], c.items[i]["t4"] | |
| swap_rows.append((c, i, xhw.item_status(x), xhw.item_status(y))) | |
| for i in c.order(): | |
| x, y = c.items[i]["rtx3090"], c.items[i]["t4"] | |
| is_len = "length" in (x["done_reason"], y["done_reason"]) | |
| if is_len: | |
| length_items += 1 | |
| length_raw_diff += x["raw_output_sha256"] != y["raw_output_sha256"] | |
| else: | |
| stop_items += 1 | |
| stop_raw_diff += x["raw_output_sha256"] != y["raw_output_sha256"] | |
| if x["raw_output_sha256"] != y["raw_output_sha256"]: | |
| k = common_prefix(x["raw_output"], y["raw_output"]) | |
| prefixes.append((k, x["grade"] != y["grade"])) | |
| N["swaps_total"] = len(swap_rows) | |
| N["swaps_pe_on_3090"] = sum(1 for r in swap_rows if r[2] == "excluded") | |
| N["swaps_pe_on_t4"] = sum(1 for r in swap_rows if r[3] == "excluded") | |
| N["swap_cards"] = len({r[0].card_id for r in swap_rows}) | |
| N["len_items"], N["len_raw_diff_pct"] = length_items, pct(length_raw_diff, length_items) | |
| N["stop_items"], N["stop_raw_diff_pct"] = stop_items, pct(stop_raw_diff, stop_items) | |
| ks = sorted(k for k, _ in prefixes) | |
| N["prefix_median"] = ks[len(ks) // 2] | |
| N["prefix_zero"] = sum(1 for k in ks if k == 0) | |
| N["prefix_zero_pct"] = pct(N["prefix_zero"], len(ks)) | |
| # cards whose item-level disagreement is hidden by the total, and the size of the total's error | |
| hidden = [c for c in cards if c.pair()["aggregate_equal"] and not c.pair()["itemwise_grade_equal"]] | |
| N["hidden_cards"] = len(hidden) | |
| N["hidden_flips"] = sum(c.pair()["flips"] for c in hidden) | |
| N["hidden_b1_list"] = ", ".join(f"\\texttt{{{c.axis}}}" for c in hidden if c.batch == "batch1") | |
| within = beyond = 0 | |
| dacc = [] | |
| for c in cards: | |
| p = c.pair() | |
| if p["itemwise_grade_equal"] and p["aggregate_equal"]: | |
| continue | |
| a3, a4 = c.accuracy("rtx3090"), c.accuracy("t4") | |
| n3 = c.counts("rtx3090")["graded_n"] | |
| se = math.sqrt(max(a3 * (1 - a3), 1e-9) / n3) if n3 else float("inf") | |
| d = abs(a4 - a3) | |
| dacc.append(d) | |
| within += d <= 1.96 * se | |
| beyond += d > 1.96 * se | |
| N["dacc_cards"], N["dacc_within_ci"], N["dacc_beyond_ci"] = len(dacc), within, beyond | |
| N["dacc_max_pp"] = f"{100 * max(dacc):.1f}" | |
| N["dacc_median_pp"] = f"{100 * sorted(dacc)[len(dacc) // 2]:.1f}" | |
| # ------------------------------------------------------------------ tables | |
| models = model_order(cards) | |
| rows = [] | |
| for m in models: | |
| cs = [c for c in cards if c.model == m] | |
| t = tally(cs) | |
| r = rep.get(m, collections.Counter()) | |
| rows.append((m, cs[0].digest[:12], QUANT[m], "2" if T4_SPLIT.get(m) else "1", t, r)) | |
| with open(os.path.join(ROOT, "tables", "models.tex"), "w") as fh: | |
| fh.write("\\begin{tabular}{lllrrr}\n\\toprule\n") | |
| fh.write("Model (Ollama tag) & Manifest digest & Quant. & T4s & Cards & Items \\\\\n\\midrule\n") | |
| for m, dg, q, sp, t, _ in rows: | |
| fh.write(f"\\texttt{{{tex_escape(m)}}} & \\texttt{{{dg}}}\\ldots & {tex_escape(q)} & {sp} & {t['cards']} & {t['n']:,} \\\\\n".replace(",", "{,}")) | |
| fh.write(f"\\midrule\nTotal & & & & {N['all_cards']} & {N['all_n']:,} \\\\\n".replace(",", "{,}")) | |
| fh.write("\\bottomrule\n\\end{tabular}\n") | |
| with open(os.path.join(ROOT, "tables", "per_model.tex"), "w") as fh: | |
| fh.write("\\begin{tabular}{lrrrrrrrr}\n\\toprule\n") | |
| fh.write(" & & \\multicolumn{3}{c}{Items equal (\\%)} & \\multicolumn{2}{c}{Flips} & \\multicolumn{2}{c}{Cards (of 14)} \\\\\n") | |
| fh.write("\\cmidrule(lr){3-5}\\cmidrule(lr){6-7}\\cmidrule(lr){8-9}\n") | |
| fh.write("Model & Items & Raw & Label & Grade & $\\uparrow$ & $\\downarrow$ & Item-eq. & Hidden \\\\\n\\midrule\n") | |
| for m, _, _, _, t, _ in rows: | |
| fh.write(f"\\texttt{{{tex_escape(m)}}} & {t['n']:,} & {pct(t['raw_eq'], t['n'])} & {pct(t['label_eq'], t['n'])} & " | |
| f"{pct(t['grade_eq'], t['n'])} & {t['flips_up']} & {t['flips_down']} & {t['itemwise']} & {t['agg_only']} \\\\\n".replace(",", "{,}")) | |
| T = tally(cards) | |
| fh.write(f"\\midrule\nAll & {T['n']:,} & {pct(T['raw_eq'], T['n'])} & {pct(T['label_eq'], T['n'])} & {pct(T['grade_eq'], T['n'])} & " | |
| f"{T['flips_up']} & {T['flips_down']} & {T['itemwise']} & {T['agg_only']} \\\\\n".replace(",", "{,}")) | |
| fh.write("\\bottomrule\n\\end{tabular}\n") | |
| axes = sorted({c.axis for c in cards}) | |
| with open(os.path.join(ROOT, "tables", "per_axis.tex"), "w") as fh: | |
| fh.write("\\begin{tabular}{lrrrrrrr}\n\\toprule\n") | |
| fh.write("Axis & Items/card & Raw\\,\\% & Grade\\,\\% & Flips & Swaps & Item-eq. & Hidden \\\\\n\\midrule\n") | |
| for ax in axes: | |
| cs = [c for c in cards if c.axis == ax] | |
| t = tally(cs) | |
| ipc = sorted({len(c.items) for c in cs}) | |
| ipc_s = str(ipc[0]) if len(ipc) == 1 else f"{ipc[0]}--{ipc[-1]}" | |
| fh.write(f"\\texttt{{{ax}}} & {ipc_s} & {pct(t['raw_eq'], t['n'])} & {pct(t['grade_eq'], t['n'])} & {t['flips']} & " | |
| f"{t['swaps']} & {t['itemwise']}/{t['cards']} & {t['agg_only']} \\\\\n") | |
| fh.write("\\bottomrule\n\\end{tabular}\n") | |
| with open(os.path.join(ROOT, "tables", "repeat.tex"), "w") as fh: | |
| fh.write("\\begin{tabular}{lrrrrrr}\n\\toprule\n") | |
| fh.write("Model & Cards & Items & Cards not & Items raw & Items grade & Cards count \\\\\n") | |
| fh.write(" & repeated & & byte-identical & differs & differs & differs \\\\\n\\midrule\n") | |
| for m in models: | |
| r = rep[m] | |
| fh.write(f"\\texttt{{{tex_escape(m)}}} & {r['cards']} & {r['items']:,} & {r['nonident_cards']} & {r['raw_diff']} & {r['grade_diff']} & {r['count_diff_cards']} \\\\\n".replace(",", "{,}")) | |
| fh.write(f"\\midrule\nAll & {R['cards']} & {R['items']:,} & {R['nonident_cards']} & {R['raw_diff']} & {R['grade_diff']} & {R['count_diff_cards']} \\\\\n".replace(",", "{,}")) | |
| fh.write("\\bottomrule\n\\end{tabular}\n") | |
| # admission: counts-only rule vs item-level rule, per batch | |
| with open(os.path.join(ROOT, "tables", "admission.tex"), "w") as fh: | |
| fh.write("\\begin{tabular}{lrrr}\n\\toprule\n") | |
| fh.write("Outcome & Batch 1 & Batch 2 & All \\\\\n\\midrule\n") | |
| def row(name, key): | |
| fh.write(f"{name} & {N['b1_' + key]} & {N['b2_' + key]} & {N['all_' + key]} \\\\\n") | |
| row("Cards compared", "cards") | |
| row("Raw output byte-identical on every item", "raw_identical_cards") | |
| row("Grade equal on every item", "itemwise") | |
| row("Totals equal (counts-only rule admits)", "admit_count") | |
| row("\\quad of which an item's grade differs (hidden flips)", "agg_only") | |
| row("Grade equal on every item but totals differ (swaps)", "itemwise_not_agg") | |
| row("Admitted under the item-level rule", "admit_item") | |
| row("\\quad of which $n \\ge 30$", "admit_item_n30") | |
| fh.write("\\bottomrule\n\\end{tabular}\n") | |
| # the swaps, one row each (small) | |
| with open(os.path.join(ROOT, "tables", "swaps_by_model.tex"), "w") as fh: | |
| by = collections.Counter((r[0].model, r[2], r[3]) for r in swap_rows) | |
| fh.write("\\begin{tabular}{lrr}\n\\toprule\n") | |
| fh.write("Model & PE on 3090, wrong on T4 & wrong on 3090, PE on T4 \\\\\n\\midrule\n") | |
| for m in models: | |
| a1 = by[(m, "excluded", "wrong")] | |
| a2 = by[(m, "wrong", "excluded")] | |
| if a1 or a2: | |
| fh.write(f"\\texttt{{{tex_escape(m)}}} & {a1} & {a2} \\\\\n") | |
| fh.write(f"\\midrule\nAll & {N['swaps_pe_on_3090']} & {N['swaps_pe_on_t4']} \\\\\n\\bottomrule\n\\end{{tabular}}\n") | |
| # ------------------------------------------------------------------ figures | |
| fig, ax = plt.subplots(figsize=(6.3, 3.3)) | |
| ys = list(range(len(models)))[::-1] | |
| for y, (m, _, _, _, t, _) in zip(ys, rows): | |
| n = t["n"] | |
| seg = [(t["raw_eq"], C_IDENT), (t["grade_eq"] - t["raw_eq"] - 0, C_RAWONLY), (0, C_SWAP), (t["flips"], C_FLIP)] | |
| # grade-equal but raw-differs splits into status-equal and status-swapped | |
| seg = [(t["raw_eq"], C_IDENT), (t["grade_eq"] - t["raw_eq"] - t["swaps"], C_RAWONLY), (t["swaps"], C_SWAP), (t["flips"], C_FLIP)] | |
| left = 0.0 | |
| for v, col in seg: | |
| w = 100 * v / n | |
| if w > 0: | |
| ax.barh(y, w, left=left, height=0.62, color=col, edgecolor="#fcfcfb", linewidth=1.0) | |
| left += w | |
| ax.text(101, y, f"{100 * (n - t['grade_eq']) / n:.1f}% flip", va="center", fontsize=7, color=INK2) | |
| ax.set_yticks(ys) | |
| ax.set_yticklabels(models, fontsize=7.5) | |
| ax.set_xlim(0, 112) | |
| ax.set_xticks([0, 20, 40, 60, 80, 100]) | |
| ax.set_xlabel("share of items (%) - RTX 3090 vs. Tesla T4, same digest, prompts, decode settings") | |
| from matplotlib.patches import Patch | |
| ax.legend(handles=[Patch(color=C_IDENT, label="raw output byte-identical"), | |
| Patch(color=C_RAWONLY, label="raw differs, same grade and status"), | |
| Patch(color=C_SWAP, label="same grade, parse-error <-> wrong swap"), | |
| Patch(color=C_FLIP, label="grade flips")], | |
| loc="upper center", bbox_to_anchor=(0.45, 1.2), ncol=2, frameon=False, fontsize=7) | |
| fig.tight_layout() | |
| for ext in ("pdf", "png"): | |
| fig.savefig(os.path.join(HERE, f"fig_per_model.{ext}")) | |
| plt.close(fig) | |
| # fig 2: flips vs net change, one point per card | |
| fig, ax = plt.subplots(figsize=(3.3, 2.8)) | |
| pts = collections.Counter() | |
| for c in cards: | |
| p = c.pair() | |
| net = abs(c.counts("t4")["correct"] - c.counts("rtx3090")["correct"]) | |
| pts[(p["flips"], net, p["aggregate_equal"])] += 1 | |
| def _kind(f, agg): | |
| return "hidden" if (agg and f > 0) else ("equal" if (f == 0 and agg) else "other") | |
| for want in ("other", "equal", "hidden"): | |
| for (f, net, agg), k in sorted(pts.items()): | |
| if _kind(f, agg) != want: | |
| continue | |
| col = {"hidden": C_FLIP, "equal": C_IDENT, "other": MUTED}[want] | |
| ax.scatter(f, net, s=12 + 40 * math.sqrt(k), color=col, edgecolor="#fcfcfb", linewidth=0.8, zorder=3) | |
| mx = max(f for f, _, _ in pts) | |
| ax.plot([0, mx], [0, mx], color=GRID, lw=1, zorder=1) | |
| ax.set_xlabel("items whose grade flipped") | |
| ax.set_ylabel("|change in correct count|") | |
| ax.text(mx * 0.98, mx * 0.9, "flips all in\none direction", ha="right", va="top", fontsize=6.5, color=MUTED) | |
| ax.annotate(f"orange: {N['hidden_cards']} cards whose totals\nare equal but items are not", xy=(4.3, 0.3), xytext=(6.5, 6.5), | |
| fontsize=6.5, color=INK2, arrowprops=dict(arrowstyle="-", color=MUTED, lw=0.6)) | |
| fig.tight_layout() | |
| for ext in ("pdf", "png"): | |
| fig.savefig(os.path.join(HERE, f"fig_flips_vs_net.{ext}")) | |
| plt.close(fig) | |
| # fig 3: model x axis heatmap of grade-flip rate | |
| fig, ax = plt.subplots(figsize=(6.3, 3.1)) | |
| from matplotlib.colors import ListedColormap, BoundaryNorm | |
| grid = [] | |
| for m in models: | |
| row_ = [] | |
| for axn in axes: | |
| cs = [c for c in cards if c.model == m and c.axis == axn] | |
| if not cs: | |
| row_.append(float("nan")) | |
| continue | |
| p = cs[0].pair() | |
| row_.append(100 * (p["n"] - p["grade_eq"] + p["swaps"]) / p["n"]) | |
| grid.append(row_) | |
| bounds = [0, 0.001, 2, 4, 6, 8, 12, 20, 100] | |
| cmap = ListedColormap(SEQ) | |
| im = ax.imshow(grid, cmap=cmap, norm=BoundaryNorm(bounds, cmap.N), aspect="auto") | |
| for yi, m in enumerate(models): | |
| for xi, axn in enumerate(axes): | |
| cs = [c for c in cards if c.model == m and c.axis == axn] | |
| if not cs: | |
| continue | |
| p = cs[0].pair() | |
| k = p["n"] - p["grade_eq"] | |
| s = p["swaps"] | |
| lab = f"{k}" + (f"+{s}" if s else "") | |
| ax.text(xi, yi, lab if (k or s) else "", ha="center", va="center", fontsize=5.5, | |
| color="#ffffff" if grid[yi][xi] >= 6 else INK) | |
| ax.set_xticks(range(len(axes))) | |
| ax.set_xticklabels(axes, rotation=40, ha="right", fontsize=6.5) | |
| ax.set_yticks(range(len(models))) | |
| ax.set_yticklabels(models, fontsize=6.5) | |
| ax.tick_params(length=0) | |
| for s in ax.spines.values(): | |
| s.set_visible(False) | |
| cb = fig.colorbar(im, ax=ax, fraction=0.03, pad=0.02, ticks=bounds[1:-1]) | |
| cb.ax.set_yticklabels([">0", "2", "4", "6", "8", "12", "20"]) | |
| cb.ax.tick_params(labelsize=6) | |
| cb.set_label("% of items with a grade flip or a status swap", fontsize=6.5) | |
| fig.tight_layout() | |
| for ext in ("pdf", "png"): | |
| fig.savefig(os.path.join(HERE, f"fig_heatmap.{ext}")) | |
| plt.close(fig) | |
| # fig 4: where raw outputs first diverge (characters of common prefix), ECDF | |
| fig, ax = plt.subplots(figsize=(3.3, 2.5)) | |
| for flag, col, lab in ((False, C_RAWONLY, "grade unchanged"), (True, C_FLIP, "grade flipped")): | |
| v = sorted(k for k, f in prefixes if f == flag) | |
| if not v: | |
| continue | |
| ax.step(v, [(i + 1) / len(v) for i in range(len(v))], where="post", color=col, lw=1.6, | |
| label=f"{lab} (n={len(v):,})") | |
| ax.set_xscale("symlog", linthresh=1) | |
| ax.set_xlim(0, 3000) | |
| ax.set_xticks([0, 1, 10, 100, 1000]) | |
| ax.set_xticklabels(["0", "1", "10", "100", "1000"]) | |
| ax.set_xlabel("characters before the two raw outputs diverge") | |
| ax.set_ylabel("cumulative share of items") | |
| ax.legend(frameon=False, fontsize=6.5, loc="lower right") | |
| fig.tight_layout() | |
| for ext in ("pdf", "png"): | |
| fig.savefig(os.path.join(HERE, f"fig_divergence.{ext}")) | |
| plt.close(fig) | |
| N["prefix_flip_median"] = sorted(k for k, f in prefixes if f)[len([1 for _, f in prefixes if f]) // 2] | |
| N["prefix_n"] = len(prefixes) | |
| # ------------------------------------------------------------------ P100 (third runtime), if present | |
| N["p100_status"] = "PENDING" | |
| if a.p100_decl and os.path.isdir(a.p100_decl): | |
| N["p100_status"] = "PRESENT" # the three-way analysis is filled in when the run lands | |
| with open(os.path.join(ROOT, "build", "numbers.json"), "w") as fh: | |
| json.dump(N, fh, indent=1, sort_keys=True, default=str) | |
| # LaTeX macros: \N<key> with non-letters removed and digits spelled out | |
| def macro(k: str) -> str: | |
| spell = {"0": "Zero", "1": "One", "2": "Two", "3": "Three", "4": "Four", "5": "Five", "6": "Six", | |
| "7": "Seven", "8": "Eight", "9": "Nine"} | |
| return "\\N" + "".join(spell.get(ch, ch.upper() if i == 0 or k[i - 1] == "_" else ch) | |
| for i, ch in enumerate(k) if ch.isalnum()) | |
| with open(os.path.join(ROOT, "tables", "numbers.tex"), "w") as fh: | |
| fh.write("% generated by figures/make_figures.py -- do not edit\n") | |
| for k, v in sorted(N.items()): | |
| if isinstance(v, int): | |
| v = f"{v:,}".replace(",", "{,}") | |
| fh.write(f"\\newcommand{{{macro(k)}}}{{{v}}}\n") | |
| print(json.dumps(N, indent=1, sort_keys=True, default=str)) | |
| if __name__ == "__main__": | |
| main() | |