"""P0-2: do the PRE-MERGE predictors predict the REALISED rescue? Held out by seed pair (SET 1) and by language pair (SET 4). Held-out AUROC + permutation null (seed-cluster permutation, which respects the pair dependence structure) + BH correction.""" import os, sys, json, glob, itertools sys.path.insert(0, "/root/compose-audit") from common import * import matplotlib matplotlib.use("Agg") import matplotlib.pyplot as plt R = "/root/compose-audit/results" F = "/root/compose-audit/figs" os.makedirs(F, exist_ok=True) def load(pat): rows = [] for fp in sorted(glob.glob(f"{R}/{pat}")): for line in open(fp): try: rows.append(json.loads(line)) except Exception: pass return rows # ------------------------------------------------------------------ stats helpers def auroc(score, label): s, y = np.asarray(score, float), np.asarray(label, int) ok = np.isfinite(s) s, y = s[ok], y[ok] if y.sum() == 0 or y.sum() == len(y): return float("nan") order = np.argsort(s) ranks = np.empty(len(s), float); ranks[order] = np.arange(1, len(s) + 1) # average ranks for ties for v in np.unique(s): m = s == v if m.sum() > 1: ranks[m] = ranks[m].mean() n1, n0 = y.sum(), len(y) - y.sum() return float((ranks[y == 1].sum() - n1 * (n1 + 1) / 2) / (n1 * n0)) def spearman(x, y): x, y = np.asarray(x, float), np.asarray(y, float) ok = np.isfinite(x) & np.isfinite(y) if ok.sum() < 3: return float("nan") rx = np.argsort(np.argsort(x[ok])).astype(float) ry = np.argsort(np.argsort(y[ok])).astype(float) return EV.pearson(rx, ry) def bh(pvals): p = np.asarray(pvals, float) ok = np.isfinite(p) out = np.full(len(p), np.nan) idx = np.where(ok)[0] o = idx[np.argsort(p[idx])] m = len(o) prev = 1.0 for rank in range(m - 1, -1, -1): v = min(prev, p[o[rank]] * m / (rank + 1)) out[o[rank]] = v; prev = v return out def ridge(X, y, lam=1.0): Xb = np.hstack([X, np.ones((len(X), 1))]) A = Xb.T @ Xb + lam * np.eye(Xb.shape[1]) w = np.linalg.solve(A, Xb.T @ y) return w[:-1], w[-1] # ------------------------------------------------------------------ SET 1 assembly set1 = load("set1_*.jsonl") rows1 = [] for r in set1: rg = r["rungs"] m1 = {k: v for k, v in rg.items() if k.startswith("M1")} best = min(m1, key=lambda k: m1[k]["delta_floor"]) if m1 else None d0 = rg["M0_naive_avg"]["delta_floor"] d1 = m1[best]["delta_floor"] if best else float("nan") row = {"set": "SET1_polypythia", "substrate": f"pythia-{r['size']}", "size": r["size"], "pair": f"{r['pair'][0]}-{r['pair'][1]}", "a": r["pair"][0], "b": r["pair"][1], "floor": r["floor"], "dfloor_M0": d0, "dfloor_M1best": d1, "M1best": best, "rescue_nats": d0 - d1, "rescue_frac": (d0 - d1) / d0 if d0 > 0 else float("nan")} for k, v in rg.items(): row[f"nll_{k}"] = v["nll"]; row[f"dfloor_{k}"] = v["delta_floor"] for k in ("barrier_naive", "barrier_perm"): if k in r: row[k] = r[k]["barrier"] row.update({f"p_{k}": v for k, v in r["predictors"].items()}) row["align_perm_hidden"] = r["align_info"]["perm"].get("hidden", 0) row["align_perm_heads"] = r["align_info"]["perm"].get("heads", 0) row["align_perm_residual"] = int(bool(r["align_info"]["perm"].get("residual"))) rows1.append(row) # ------------------------------------------------------------------ SET 4 assembly set4 = load("set4_goldfish.jsonl") rows4 = [] for r in set4: rg = r["rungs"] m1 = {k: v for k, v in rg.items() if k.startswith("M1")} best = min(m1, key=lambda k: m1[k]["delta_floor_mean"]) if m1 else None d0 = rg["M0_naive_avg"]["delta_floor_mean"] d1 = m1[best]["delta_floor_mean"] if best else float("nan") row = {"set": "SET4_goldfish", "substrate": "goldfish-125M", "pair": f"eng-{r['lang']}", "lang": r["lang"], "floor_eng": r["floor_eng"], "floor_x": r["floor_x"], "dfloor_M0": d0, "dfloor_M1best": d1, "M1best": best, "rescue_nats": d0 - d1, "rescue_frac": (d0 - d1) / d0 if d0 > 0 else float("nan")} for k, v in rg.items(): for f_ in ("delta_floor_eng", "delta_floor_x", "delta_floor_mean"): row[f"{f_}_{k}"] = v[f_] row[f"npb_eng_{k}"] = v["eng"]["nats_per_byte"]; row[f"npb_x_{k}"] = v["x"]["nats_per_byte"] for k in ("barrier_naive", "barrier_perm"): if k in r: row[k] = r[k]["barrier"] row.update({f"p_{k}": v for k, v in r["predictors"].items()}) rows4.append(row) def to_csv(rows, path): if not rows: return keys = [] for r in rows: for k in r: if k not in keys: keys.append(k) with open(path, "w") as f: f.write(",".join(keys) + "\n") for r in rows: f.write(",".join("" if r.get(k) is None else str(r.get(k, "")) for k in keys) + "\n") to_csv(rows1, f"{R}/set1_pairs.csv") to_csv(rows4, f"{R}/set4_pairs.csv") print(f"SET1 rows={len(rows1)} SET4 rows={len(rows4)}") # ------------------------------------------------------------------ P0-2: held-out prediction, SET 1 PRED_KEYS = ["p_weight_cosine", "p_weight_cosine_bn", "p_d_raw", "p_qmd_perm", "p_coord_share_perm", "p_qmd_orth", "p_coord_share_orth", "p_bnd_raw", "p_bnd_perm", "p_bnd_orth", "p_coord_share_bnd_perm", "p_coord_share_bnd_orth", "p_cka_mean", "p_cka_last", "p_qmd_act_perm", "p_qmd_act_procrustes", "p_qmd_act_ot", "p_task_vector_cosine"] pred_rows, roc_store = [], {} for size in sorted({r["size"] for r in rows1}): sub = [r for r in rows1 if r["size"] == size] if len(sub) < 8: continue y_cont = np.array([r["rescue_frac"] for r in sub], float) med = np.nanmedian(y_cont) y = (y_cont > med).astype(int) seeds = sorted({r["a"] for r in sub} | {r["b"] for r in sub}) rng = np.random.default_rng(0) for pk in PRED_KEYS: x = np.array([r.get(pk, np.nan) for r in sub], float) if not np.isfinite(x).sum() >= 8 or np.nanstd(x) == 0: continue # HELD OUT BY SEED PAIR: fold k = every pair touching seed k; the sign of the predictor is # fitted on the training folds only, so nothing about the held-out pairs leaks in. oof = np.full(len(sub), np.nan) for s in seeds: te = np.array([(r["a"] == s or r["b"] == s) for r in sub]) tr = ~te if tr.sum() < 4 or te.sum() < 1: continue sgn = np.sign(spearman(x[tr], y_cont[tr])) or 1.0 oof[te] = sgn * x[te] a_oof = auroc(oof, y) a_in = auroc(np.sign(spearman(x, y_cont) or 1.0) * x, y) # SEED-CLUSTER PERMUTATION NULL: permute the seed identities and re-map each pair's outcome # to the outcome of the permuted pair; the predictor vector is untouched. pair_ix = {(r["a"], r["b"]): i for i, r in enumerate(sub)} null = [] for _ in range(2000): pi = rng.permutation(seeds) m = {s: pi[i] for i, s in enumerate(seeds)} idx = [] for r in sub: u, v = sorted((m[r["a"]], m[r["b"]])) idx.append(pair_ix.get((u, v), pair_ix[(r["a"], r["b"])])) null.append(auroc(oof, y[idx])) null = np.array([v for v in null if np.isfinite(v)]) p = float((np.sum(null >= a_oof) + 1) / (len(null) + 1)) if len(null) else float("nan") pred_rows.append({"set": "SET1", "substrate": f"pythia-{size}", "n_pairs": len(sub), "predictor": pk[2:], "spearman_rescue": spearman(x, y_cont), "auroc_in_sample": a_in, "auroc_heldout_by_seed": a_oof, "perm_null_mean": float(null.mean()) if len(null) else float("nan"), "perm_null_p": p}) roc_store[(size, pk)] = (oof, y) # multivariate, held out by seed X = np.array([[r.get(k, np.nan) for k in PRED_KEYS] for r in sub], float) good = np.isfinite(X).all(0) & (np.nanstd(X, 0) > 0) Xg = X[:, good] mu, sd = Xg.mean(0), Xg.std(0) + 1e-12 Xg = (Xg - mu) / sd oof = np.full(len(sub), np.nan) for s in seeds: te = np.array([(r["a"] == s or r["b"] == s) for r in sub]); tr = ~te if tr.sum() < 4: continue w, b = ridge(Xg[tr], y_cont[tr], lam=2.0) oof[te] = Xg[te] @ w + b pred_rows.append({"set": "SET1", "substrate": f"pythia-{size}", "n_pairs": len(sub), "predictor": "MULTIVARIATE_ridge_all", "spearman_rescue": spearman(oof, y_cont), "auroc_in_sample": float("nan"), "auroc_heldout_by_seed": auroc(oof, y), "perm_null_mean": float("nan"), "perm_null_p": float("nan")}) if pred_rows: ps = [r["perm_null_p"] for r in pred_rows] q = bh(ps) for r, qq in zip(pred_rows, q): r["bh_q"] = float(qq) if np.isfinite(qq) else "" to_csv(pred_rows, f"{R}/predictor_auroc.csv") # SET 4: leave-one-language-out, n=4 -> report Spearman only, flagged as underpowered pred4 = [] if len(rows4) >= 3: y4 = np.array([r["rescue_frac"] for r in rows4], float) for pk in PRED_KEYS + ["p_vocab_overlap", "p_weight_cosine_body"]: x = np.array([r.get(pk, np.nan) for r in rows4], float) if np.isfinite(x).sum() < 3 or np.nanstd(x) == 0: continue pred4.append({"set": "SET4", "substrate": "goldfish-125M", "n_pairs": len(rows4), "predictor": pk[2:], "spearman_rescue": spearman(x, y4), "note": "n=4 language pairs -- UNDERPOWERED, no AUROC/null reported"}) to_csv(pred4, f"{R}/set4_predictors.csv") # ------------------------------------------------------------------ figures plt.rcParams.update({"figure.dpi": 130, "font.size": 9, "axes.grid": True, "grid.alpha": .25, "axes.spines.top": False, "axes.spines.right": False}) # 1. Delta-floor by rung if rows1: sizes = sorted({r["size"] for r in rows1}, key=lambda s: int(s[:-1])) rungs = [k[7:] for k in rows1[0] if k.startswith("dfloor_M")] fig, axes = plt.subplots(1, len(sizes), figsize=(3.6 * len(sizes), 3.4), squeeze=False) for ax, sz in zip(axes[0], sizes): sub = [r for r in rows1 if r["size"] == sz] data = [[r[f"dfloor_{k}"] for r in sub if np.isfinite(r.get(f"dfloor_{k}", np.nan))] for k in rungs] keep = [(k, d) for k, d in zip(rungs, data) if d] ax.boxplot([d for _, d in keep], tick_labels=[k.replace("_", "\n", 1) for k, _ in keep], showfliers=False) ax.set_yscale("symlog"); ax.set_title(f"pythia-{sz} (n={len(sub)} seed pairs)") ax.set_ylabel("Δfloor (nats/token, log)") ax.tick_params(axis="x", labelsize=6) fig.suptitle("SET 1 · PolyPythia seed merge · Δfloor vs the better parent, by merge rung", fontsize=10) fig.tight_layout(); fig.savefig(f"{F}/set1_dfloor_by_rung.png", bbox_inches="tight"); plt.close(fig) # 2. rescue vs coordinate share if rows1: fig, axes = plt.subplots(1, 2, figsize=(8.4, 3.6)) for ax, pk, lab in ((axes[0], "p_coord_share_bnd_perm", "coordinate share (block-normalised, permutation)"), (axes[1], "p_cka_mean", "unaligned CKA (mean over layers)")): for sz in sorted({r["size"] for r in rows1}, key=lambda s: int(s[:-1])): sub = [r for r in rows1 if r["size"] == sz] ax.scatter([r.get(pk, np.nan) for r in sub], [r["rescue_frac"] for r in sub], s=18, alpha=.75, label=f"pythia-{sz}") ax.set_xlabel(lab); ax.set_ylabel("realised rescue (frac of naive Δfloor removed)") ax.legend(fontsize=7, frameon=False) fig.suptitle("SET 1 · does a PRE-MERGE predictor track the REALISED rescue?", fontsize=10) fig.tight_layout(); fig.savefig(f"{F}/set1_rescue_vs_predictor.png", bbox_inches="tight"); plt.close(fig) # 3. ROC of the best held-out predictor per size if roc_store and pred_rows: fig, ax = plt.subplots(figsize=(4.2, 4)) best = {} for r in pred_rows: if r["predictor"].startswith("MULTIVAR"): continue sz = r["substrate"].split("-")[1] a = r["auroc_heldout_by_seed"] if np.isfinite(a) and (sz not in best or abs(a - .5) > abs(best[sz][1] - .5)): best[sz] = (r["predictor"], a) for sz, (pk, a) in best.items(): oof, y = roc_store[(sz, "p_" + pk)] o = np.argsort(-oof); yy = y[o] tpr = np.cumsum(yy) / max(1, yy.sum()); fpr = np.cumsum(1 - yy) / max(1, (1 - yy).sum()) ax.plot(np.r_[0, fpr], np.r_[0, tpr], label=f"pythia-{sz}: {pk} (AUROC={a:.2f})") ax.plot([0, 1], [0, 1], "k--", lw=.8) ax.set_xlabel("false positive rate"); ax.set_ylabel("true positive rate") ax.set_title("SET 1 · held-out-by-seed ROC\n(best predictor per size)", fontsize=9) ax.legend(fontsize=7, frameon=False) fig.tight_layout(); fig.savefig(f"{F}/set1_roc.png", bbox_inches="tight"); plt.close(fig) # 4. SET 4 bars if rows4: rungs = sorted({k[len("delta_floor_mean_"):] for r in rows4 for k in r if k.startswith("delta_floor_mean_M")}) fig, ax = plt.subplots(figsize=(7.6, 3.6)) w = 0.8 / len(rungs) for i, k in enumerate(rungs): ax.bar(np.arange(len(rows4)) + i * w, [r.get(f"delta_floor_mean_{k}", np.nan) for r in rows4], width=w, label=k) ax.set_xticks(np.arange(len(rows4)) + 0.4 - w / 2) ax.set_xticklabels([r["pair"] for r in rows4]) ax.set_ylabel("Δfloor (nats/UTF-8 byte)"); ax.legend(fontsize=7, frameon=False, ncol=2) ax.set_title("SET 4 · Goldfish eng×X merge · Δfloor vs the better parent (LIKELIHOOD, not accuracy)", fontsize=9) fig.tight_layout(); fig.savefig(f"{F}/set4_dfloor.png", bbox_inches="tight"); plt.close(fig) print("figures + csvs written")