Upload code/analyze.py with huggingface_hub

code/analyze.py

@@ -98,10 +98,18 @@ set4 = load("set4_goldfish.jsonl")
 rows4 = []
 for r in set4:
     rg = r["rungs"]
+    # Re-reference the X-language floor to the X parent's OWN tokenizer. The English parent's
+    # nats/byte on X text is degenerate wherever the English tokenizer UNK-s the script (46% of
+    # Greek tokens), so min(parents) was picking up an artifact rather than a floor.
+    px = r["parents"]["x_on_x"]["nats_per_byte"]
+    for _k, _v in rg.items():
+        _v["delta_floor_x"] = _v["x"]["nats_per_byte"] - px
+        _v["delta_floor_mean"] = 0.5 * (_v["delta_floor_eng"] + _v["delta_floor_x"])
+    r["floor_x"] = px
     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")
+    best = min(m1, key=lambda k: m1[k]["delta_floor_eng"]) if m1 else None
+    d0 = rg["M0_naive_avg"]["delta_floor_eng"]
+    d1 = m1[best]["delta_floor_eng"] 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,
@@ -139,74 +147,142 @@ PRED_KEYS = ["p_weight_cosine", "p_weight_cosine_bn", "p_d_raw", "p_qmd_perm", "
              "p_qmd_act_perm", "p_qmd_act_procrustes", "p_qmd_act_ot", "p_task_vector_cosine"]
 
 pred_rows, roc_store = [], {}
+OUTCOMES = [("rescue_frac", "fraction of the naive Δfloor that the best M1 rung removes", +1),
+            ("dfloor_M1best", "Δfloor of the best M1 rung (how good the ALIGNED merge actually is)", -1)]
 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 = []
+    pair_ix = {(r["a"], r["b"]): i for i, r in enumerate(sub)}
+    complete = len(sub) == len(seeds) * (len(seeds) - 1) // 2
+    for oname, odesc, osign in OUTCOMES:
+        y_cont = osign * np.array([r[oname] for r in sub], float)
+        med = np.nanmedian(y_cont)
+        y = (y_cont > med).astype(int)
+        rng = np.random.default_rng(0)
+        # pre-draw the seed-cluster permutations ONCE per outcome so every predictor sees the same null
+        perms = []
         for _ in range(2000):
             pi = rng.permutation(seeds)
-            m = {s: pi[i] for i, s in enumerate(seeds)}
-            idx = []
+            m = {sd: pi[i] for i, sd in enumerate(seeds)}
+            idx, ok = [], True
             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,
+                if (u, v) not in pair_ix:
+                    ok = False; break
+                idx.append(pair_ix[(u, v)])
+            if ok:
+                perms.append(np.asarray(idx))
+        for pk in PRED_KEYS:
+            x = np.array([r.get(pk, np.nan) for r in sub], float)
+            if np.isfinite(x).sum() < 8 or np.nanstd(x) == 0:
+                continue
+            # HELD OUT BY SEED: fold k = every pair touching seed k, fitted on pairs touching neither,
+            # so the predictor's SIGN never sees the held-out pairs.
+            oof = np.full(len(sub), np.nan)
+            for sd_ in seeds:
+                te = np.array([(r["a"] == sd_ or r["b"] == sd_) 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)
+            null = np.array([auroc(oof, y[ix]) for ix in perms]) if len(perms) >= 200 else np.array([])
+            null = null[np.isfinite(null)]
+            pval = 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}", "outcome": oname,
+                              "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"),
+                              "n_null_draws": int(len(null)), "pairs_complete": int(complete),
+                              "perm_null_p": pval})
+            if oname == "rescue_frac":
+                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]
+        Xg = (Xg - Xg.mean(0)) / (Xg.std(0) + 1e-12)
+        oof = np.full(len(sub), np.nan)
+        for sd_ in seeds:
+            te = np.array([(r["a"] == sd_ or r["b"] == sd_) 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
+        a_oof = auroc(oof, y)
+        null = np.array([auroc(oof, y[ix]) for ix in perms]) if len(perms) >= 200 else np.array([])
+        null = null[np.isfinite(null)]
+        pred_rows.append({"set": "SET1", "substrate": f"pythia-{size}", "outcome": oname,
+                          "n_pairs": len(sub), "predictor": "MULTIVARIATE_ridge_all",
+                          "spearman_rescue": spearman(oof, y_cont), "auroc_in_sample": float("nan"),
+                          "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")})
+                          "n_null_draws": int(len(null)), "pairs_complete": int(complete),
+                          "perm_null_p": float((np.sum(null >= a_oof) + 1) / (len(null) + 1)) if len(null) else float("nan")})
 
 if pred_rows:
-    ps = [r["perm_null_p"] for r in pred_rows]
-    q = bh(ps)
+    q = bh([r["perm_null_p"] for r in pred_rows])
     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")
 
+# ---------------- P0-2b: does the predictor transfer ACROSS substrates (leave-one-size-out)?
+xfer = []
+szs_all = sorted({r["size"] for r in rows1 if len([q for q in rows1 if q["size"] == r["size"]]) >= 8})
+if len(szs_all) >= 3:
+    pool = [r for r in rows1 if r["size"] in szs_all]
+    for oname, osign in (("rescue_frac", +1), ("dfloor_M1best", -1)):
+        Y = osign * np.array([r[oname] for r in pool], float)
+        SZ = np.array([r["size"] for r in pool])
+        X = np.array([[r.get(k, np.nan) for k in PRED_KEYS] for r in pool], float)
+        good = np.isfinite(X).all(0) & (np.nanstd(X, 0) > 0)
+        Xg = X[:, good].copy()
+        # standardise WITHIN size: the raw scales differ across substrates, and a predictor that only
+        # works because it encodes "which size is this" is not a transferring predictor.
+        for sz in szs_all:
+            m = SZ == sz
+            Xg[m] = (Xg[m] - Xg[m].mean(0)) / (Xg[m].std(0) + 1e-12)
+        oof = np.full(len(pool), np.nan)
+        for sz in szs_all:
+            te = SZ == sz; tr = ~te
+            w, b = ridge(Xg[tr], Y[tr], lam=2.0)
+            oof[te] = Xg[te] @ w + b
+        rng = np.random.default_rng(1)
+        for sz in szs_all:
+            te = SZ == sz
+            y = (Y[te] > np.median(Y[te])).astype(int)
+            a = auroc(oof[te], y)
+            null = np.array([auroc(oof[te], y[rng.permutation(len(y))]) for _ in range(2000)])
+            null = null[np.isfinite(null)]
+            xfer.append({"outcome": oname, "held_out_substrate": f"pythia-{sz}", "n": int(te.sum()),
+                         "auroc_transfer": a, "null_mean": float(null.mean()),
+                         "perm_p": float((np.sum(null >= a) + 1) / (len(null) + 1))})
+        # univariate transfer of the single most-cited predictor family
+        for pk in ("p_coord_share_bnd_perm", "p_qmd_act_perm", "p_cka_mean", "p_weight_cosine"):
+            if pk not in PRED_KEYS: continue
+            j = PRED_KEYS.index(pk)
+            if not good[j]: continue
+            col = np.where(good)[0].tolist().index(j)
+            for sz in szs_all:
+                te = SZ == sz; tr = ~te
+                sgn = np.sign(spearman(Xg[tr, col], Y[tr])) or 1.0
+                y = (Y[te] > np.median(Y[te])).astype(int)
+                a = auroc(sgn * Xg[te, col], y)
+                null = np.array([auroc(sgn * Xg[te, col], y[rng.permutation(len(y))]) for _ in range(1000)])
+                null = null[np.isfinite(null)]
+                xfer.append({"outcome": oname, "held_out_substrate": f"pythia-{sz}", "n": int(te.sum()),
+                             "predictor": pk[2:], "auroc_transfer": a,
+                             "null_mean": float(null.mean()),
+                             "perm_p": float((np.sum(null >= a) + 1) / (len(null) + 1))})
+    for r in xfer:
+        r.setdefault("predictor", "MULTIVARIATE_ridge_all")
+    qq = bh([r["perm_p"] for r in xfer])
+    for r, q in zip(xfer, qq):
+        r["bh_q"] = float(q)
+    to_csv(xfer, f"{R}/predictor_transfer_across_size.csv")
+
 # SET 4: leave-one-language-out, n=4 -> report Spearman only, flagged as underpowered
 pred4 = []
 if len(rows4) >= 3:
@@ -290,3 +366,69 @@ if rows4:
     fig.tight_layout(); fig.savefig(f"{F}/set4_dfloor.png", bbox_inches="tight"); plt.close(fig)
 
 print("figures + csvs written")
+
+# ------------------------------------------------------------------ 5. BLiMP dissociation
+blimp = load("blimp_*.jsonl")
+if blimp:
+    brows = []
+    for b in blimp:
+        m1 = {k: v for k, v in b["rungs"].items() if k.startswith("M1")}
+        brows.append({"size": b["size"], "pair": tuple(b["pair"]),
+                      "ceiling": b["ceiling"], "parent_mean": float(np.mean(list(b["parent_acc"].values()))),
+                      "M0": b["rungs"]["M0_naive_avg"]["blimp_acc"],
+                      "M1best": max(v["blimp_acc"] for v in m1.values()),
+                      **{f"acc_{k}": v["blimp_acc"] for k, v in b["rungs"].items()}})
+    to_csv(brows, f"{R}/blimp_pairs.csv")
+    s1 = {(r["size"], (r["a"], r["b"])): r for r in rows1}
+    sizes_b = sorted({b["size"] for b in brows}, key=lambda x: int(x[:-1]))
+    fig, axes = plt.subplots(1, 2, figsize=(9, 3.8))
+    for sz in sizes_b:
+        sub = [b for b in brows if b["size"] == sz]
+        xs, ys = [], []
+        for b in sub:
+            k = (sz, b["pair"])
+            if k in s1 and np.isfinite(s1[k]["rescue_nats"]):
+                xs.append(s1[k]["rescue_nats"]); ys.append(b["M1best"] - b["M0"])
+        if xs:
+            axes[0].scatter(xs, ys, s=20, alpha=.75, label=f"pythia-{sz} (n={len(xs)})")
+    axes[0].axhline(0, color="k", lw=.7)
+    axes[0].set_xlabel("likelihood rescue from alignment  (nats/token removed)")
+    axes[0].set_ylabel("accuracy rescue  (BLiMP, M1best − M0)")
+    axes[0].set_title("Rescue in nats does NOT buy rescue in accuracy", fontsize=9)
+    axes[0].legend(fontsize=7, frameon=False)
+    lab, vals = [], []
+    for sz in sizes_b:
+        sub = [b for b in brows if b["size"] == sz]
+        lab.append(f"pythia-{sz}\n(n={len(sub)})")
+        vals.append([np.mean([b["parent_mean"] for b in sub]), np.mean([b["M0"] for b in sub]),
+                     np.mean([b["acc_M1_perm_avg"] for b in sub]), np.mean([b["acc_M1_orth_avg"] for b in sub])])
+    vals = np.array(vals)
+    w = 0.2
+    for i, nm in enumerate(["parents", "M0 naive", "M1 permutation", "M1 Procrustes"]):
+        axes[1].bar(np.arange(len(lab)) + i * w, vals[:, i], width=w, label=nm)
+    axes[1].axhline(0.5, color="k", ls="--", lw=.8)
+    axes[1].text(0.02, 0.505, "chance", fontsize=7, transform=axes[1].get_yaxis_transform())
+    axes[1].set_xticks(np.arange(len(lab)) + 1.5 * w); axes[1].set_xticklabels(lab, fontsize=7)
+    axes[1].set_ylim(0.45, None); axes[1].set_ylabel("BLiMP accuracy")
+    axes[1].legend(fontsize=7, frameon=False)
+    axes[1].set_title("Parents vs merges", fontsize=9)
+    fig.suptitle("SET 1 · likelihood recovery vs grammatical competence", fontsize=10)
+    fig.tight_layout(); fig.savefig(f"{F}/set1_blimp_dissociation.png", bbox_inches="tight"); plt.close(fig)
+
+# ------------------------------------------------------------------ 6. scale trend
+if rows1:
+    szs = sorted({r["size"] for r in rows1}, key=lambda s: int(s[:-1]))
+    P = {"14m": 14, "31m": 31, "70m": 70, "160m": 160, "410m": 410}
+    x = [P[s] for s in szs]
+    naive = [np.mean([r["dfloor_M0_naive_avg"] for r in rows1 if r["size"] == s]) for s in szs]
+    resc = [np.mean([1 - min(r["dfloor_M1_perm_avg"], r["dfloor_M1_orth_avg"]) / r["dfloor_M0_naive_avg"]
+                     for r in rows1 if r["size"] == s]) * 100 for s in szs]
+    fig, ax = plt.subplots(figsize=(4.6, 3.6))
+    ax.plot(x, naive, "o-", color="#c0392b", label="naive merge Δfloor (nats/token)")
+    ax.set_xscale("log"); ax.set_xticks(x); ax.set_xticklabels(szs)
+    ax.set_xlabel("PolyPythia size"); ax.set_ylabel("naive Δfloor (nats/token)", color="#c0392b")
+    ax2 = ax.twinx(); ax2.plot(x, resc, "s--", color="#2471a3", label="rescue by alignment (%)")
+    ax2.set_ylabel("% of naive Δfloor removed by alignment", color="#2471a3"); ax2.grid(False)
+    ax.set_title("Both the obstruction AND alignment's purchase\nshrink with scale", fontsize=9)
+    fig.tight_layout(); fig.savefig(f"{F}/set1_scale_trend.png", bbox_inches="tight"); plt.close(fig)
+print("extra figures written")