code/analyze.py

"""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")