Upload code/analyze.py with huggingface_hub

code/analyze.py

@@ -0,0 +1,292 @@
+"""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")