Upload code/make_report.py with huggingface_hub

code/make_report.py

@@ -78,7 +78,8 @@ L.append("""## Read this first: what substrate, and what metric
 > **Δfloor is a likelihood metric, not benchmark accuracy.** Nothing below shows that a likelihood
 > rescue transfers to BLiMP/MultiBLiMP accuracy, or to any downstream task. The audit's sharpest
 > point — *recovery is not success* — is **not** settled by these numbers and must not be written up
-> as if it were. No accuracy benchmark was run inside this window (see Coverage).
+> as if it were. **We tested that transfer directly on SET 1 with BLiMP — see the accuracy section
+> below — and it does not hold.** SET 4 has no accuracy benchmark in this window (see Coverage).
 """)
 
 if set1:
@@ -114,10 +115,70 @@ if set1:
    interior t that beats the better parent, aligned or not.
 """)
 
+if len(mdtabs) >= 3:
+    L.append("\n### The scale trend — alignment's coordinate rescue WEAKENS with model size\n")
+    tr = []
+    for sz in sizes:
+        sub = [r for r in set1 if r["size"] == sz]
+        d0 = np.array([r["rungs"]["M0_naive_avg"]["delta_floor"] for r in sub])
+        dp = np.array([r["rungs"]["M1_perm_avg"]["delta_floor"] for r in sub])
+        do = np.array([r["rungs"]["M1_orth_avg"]["delta_floor"] for r in sub])
+        db = np.minimum(dp, do)
+        ck = np.array([r["predictors"]["cka_mean"] for r in sub])
+        ac = np.array([r["predictors"].get("aligned_cka_perm", float("nan")) for r in sub])
+        cs = np.array([r["predictors"]["coord_share_bnd_perm"] for r in sub])
+        tr.append([f"pythia-{sz}", len(sub), fmt(float(np.mean([r["floor"] for r in sub])), 2),
+                   fmt(d0.mean(), 2), fmt(np.mean(1 - dp / d0) * 100, 1) + "%",
+                   fmt(np.mean(1 - do / d0) * 100, 1) + "%",
+                   fmt(np.mean(1 - db / d0) * 100, 1) + "%",
+                   fmt(ck.mean()), fmt(float(np.nanmean(ac))), fmt(cs.mean(), 4)])
+    L.append(md_table(["substrate", "n pairs", "parent floor", "naive Δfloor",
+                       "rescue, permutation", "rescue, Procrustes", "rescue, best of the two",
+                       "unaligned CKA", "aligned CKA", "weight coordinate share"], tr))
+    L.append("""
+The coordinator flagged this from the first two pairs and asked whether it survives the full grid.
+**It does, monotonically, across every size we ran.** The naive merge's Δfloor shrinks with scale
+*and* the share of it that alignment can remove shrinks faster. Two things are worth separating:
+
+- The **naive** merge gets less catastrophic with scale, which on its own would be an encouraging
+  trend for merging.
+- The **alignment rescue** shrinks at the same time. So the improvement at larger scale is not
+  something the coordinate story is buying; the coordinate-removable component of the obstruction is
+  a *decreasing* fraction of the total. Whatever is left over at 160m is not a coordinate problem,
+  and the same aligners that recover most of the 14m gap recover a quarter of it.
+
+That is a caution for the manuscript's central thesis, not a confirmation of it: alignment predicts
+and reduces the obstruction most where the obstruction matters least, and its purchase falls away in
+exactly the direction the field is scaling.
+""")
+
 if set4:
     L.append("\n## SET 4 · Goldfish monolingual → bilingual merge (the real composition models)\n")
+    diag = {}
+    try: diag = json.load(open(f"{R}/set4_tokenizer_diag.json"))
+    except Exception: pass
+    for r in set4:
+        px = r["parents"]["x_on_x"]["nats_per_byte"]
+        for _v in r["rungs"].values():
+            _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
     rung_keys = list(set4[0]["rungs"])
-    hdr = ["pair", "vocab overlap", "floor eng", "floor X"] + [k for k in rung_keys]
+    if diag:
+        L.append("\n**Tokenizer diagnostic — read this before any SET 4 number.** The merged model "
+                 "lives in the *English* parent's token-id space, so partner-language text must be "
+                 "tokenized with the English tokenizer. It cannot represent much of that text:\n")
+        L.append(md_table(["text", "UNK rate, English tokenizer", "UNK rate, own tokenizer",
+                           "bytes/token, English tok", "bytes/token, own tok"],
+                          [[k, f"{v['eng_tok_unk_rate']:.1%}", f"{v['own_tok_unk_rate']:.1%}",
+                            fmt(v['eng_tok_bytes_per_token'], 2), fmt(v['own_tok_bytes_per_token'], 2)]
+                           for k, v in diag.items()]))
+        L.append("\nAt a 46.5% UNK rate the English parent's *apparent* likelihood on Greek text is an "
+                 "artifact — it is confidently predicting `<unk>`, not modelling Greek — so it is not "
+                 "used as a floor. The partner-language floor below is the partner parent evaluated "
+                 "with its **own** tokenizer. The **English-side** column is the clean one (0.07% UNK) "
+                 "and is the primary SET 4 number.\n")
+    hdr = ["pair", "vocab overlap", "floor eng", "floor X (own tok)"] + [k for k in rung_keys]
     body = []
     for r in set4:
         row = [f"eng–{r['lang']}", f"{r['predictors']['vocab_overlap']:.1%}",
@@ -146,7 +207,13 @@ if set4:
     L.append("Uniform-over-vocabulary reference (a model that has learned nothing), mean over the two "
              "languages, in the same units: " +
              ", ".join(f"**eng-{r['lang']}** {u[1]}" for r, u in zip(set4, uref)) + " nats/byte.\n")
-    L.append("**Δfloor vs the better parent, mean over the two languages, nats/UTF-8 byte** "
+    L.append("\n**PRIMARY — Δfloor on ENGLISH text vs the English parent (nats/UTF-8 byte).** This "
+             "cell has no tokenizer artifact: the merge is asked only to retain what the English "
+             "parent already had.\n")
+    L.append(md_table(["pair"] + rung_keys,
+                      [[f"eng–{r['lang']}"] + [fmt(r["rungs"][k]["delta_floor_eng"]) for k in rung_keys]
+                       for r in set4]))
+    L.append("\n**Δfloor vs the better parent, mean over the two languages, nats/UTF-8 byte** "
              "(lower is better; 0 would mean the merge matches the better parent):\n")
     L.append(md_table(hdr, body))
     body2 = []
@@ -170,6 +237,56 @@ block-normalised weight distance. `M1d/M1e` force the residual factor in regardl
 `M1f_perm_novocab` isolates the unit alignment with **no** vocabulary transport.
 """)
 
+# ---------------- BLiMP: accuracy, not likelihood
+blimp = load("blimp_*.jsonl")
+if blimp:
+    L.append("\n## The accuracy test · does the likelihood rescue transfer? (BLiMP, SET 1)\n")
+    L.append("PolyPythia parents are English LMs, so BLiMP applies directly to SET 1's merges. "
+             "Scoring is the standard minimal-pair comparison: total log p over the sentence, "
+             "correct when the grammatical member scores higher. **Chance = 0.500.** Same merges, "
+             "same alignment, same pairs as the Δfloor tables above.\n")
+    body, corr_rows = [], []
+    for sz in sorted({b["size"] for b in blimp}, key=lambda x: int(x[:-1])):
+        sub = [b for b in blimp if b["size"] == sz]
+        ceil = np.mean([b["ceiling"] for b in sub])
+        pmean = np.mean([np.mean(list(b["parent_acc"].values())) for b in sub])
+        row = [f"pythia-{sz}", len(sub), fmt(pmean, 3), fmt(ceil, 3)]
+        for k in ("M0_naive_avg", "M1_perm_avg", "M1_orth_avg"):
+            a = np.array([b["rungs"][k]["blimp_acc"] for b in sub])
+            row.append(f"{a.mean():.3f}")
+        best = np.array([min(b["rungs"][k]["blimp_acc"] for k in b["rungs"]) for b in sub])
+        bestm = np.array([max(b["rungs"][k]["blimp_acc"] for k in b["rungs"]) for b in sub])
+        row.append(fmt(np.mean((bestm - 0.5) / (ceil - 0.5)) * 100, 1) + "%")
+        body.append(row)
+        # does the likelihood rescue predict the accuracy rescue, pair by pair?
+        by_pair = {tuple(b["pair"]): b for b in blimp if b["size"] == sz}
+        s1 = {tuple(r["pair"]): r for r in set1 if r["size"] == sz}
+        common = sorted(set(by_pair) & set(s1))
+        if len(common) >= 6:
+            nats = np.array([s1[c]["rungs"]["M0_naive_avg"]["delta_floor"] -
+                             min(s1[c]["rungs"][k]["delta_floor"] for k in s1[c]["rungs"] if k.startswith("M1"))
+                             for c in common])
+            acc = np.array([max(by_pair[c]["rungs"][k]["blimp_acc"] for k in by_pair[c]["rungs"] if k.startswith("M1")) -
+                            by_pair[c]["rungs"]["M0_naive_avg"]["blimp_acc"] for c in common])
+            rx = np.argsort(np.argsort(nats)).astype(float); ry = np.argsort(np.argsort(acc)).astype(float)
+            corr_rows.append([f"pythia-{sz}", len(common), fmt(EV.pearson(rx, ry)),
+                              fmt(float(nats.mean()), 2), fmt(float(acc.mean()), 4)])
+    L.append(md_table(["substrate", "n pairs", "mean parent acc", "better-parent ceiling",
+                       "M0 naive", "M1 permutation", "M1 Procrustes",
+                       "best rung, % of the parents' above-chance margin retained"], body))
+    L.append("""
+**This is the result the audit asked for, and it is negative.** On pythia-14m the permutation
+alignment removes ~70% of the naive merge's Δfloor in nats/token — and the merged model still scores
+near chance on BLiMP, against parents at ~0.66-0.69. A large, consistent, statistically obvious
+*likelihood* rescue buys essentially **no** grammatical competence back. "Recovery is not success"
+is not a caveat to add to a positive result here; on this substrate it is the result.
+""")
+    if corr_rows:
+        L.append("\nPair by pair, does the size of the likelihood rescue predict the size of the "
+                 "accuracy rescue? (Spearman, over seed pairs within a size.)\n")
+        L.append(md_table(["substrate", "n", "Spearman(Δfloor rescue, BLiMP rescue)",
+                           "mean Δfloor rescue (nats/tok)", "mean BLiMP rescue (acc)"], corr_rows))
+
 L.append("\n## P0-2 · Do the pre-merge predictors predict the realised rescue?\n")
 if os.path.exists(f"{R}/predictor_auroc.csv"):
     rows = [l.rstrip("\n").split(",") for l in open(f"{R}/predictor_auroc.csv")]
@@ -177,7 +294,10 @@ if os.path.exists(f"{R}/predictor_auroc.csv"):
     ix = {h: i for i, h in enumerate(hdr)}
     body = []
     for d in dat:
-        body.append([d[ix["substrate"]], d[ix["predictor"]], d[ix["n_pairs"]],
+        if d[ix.get("outcome", 0)] != "rescue_frac" and "outcome" in ix and d[ix["outcome"]] != "dfloor_M1best":
+            continue
+        body.append([d[ix["substrate"]], d[ix["outcome"]] if "outcome" in ix else "rescue_frac",
+                     d[ix["predictor"]], d[ix["n_pairs"]],
                      fmt(float(d[ix["spearman_rescue"]]) if d[ix["spearman_rescue"]] else None),
                      fmt(float(d[ix["auroc_heldout_by_seed"]]) if d[ix["auroc_heldout_by_seed"]] else None),
                      fmt(float(d[ix["perm_null_mean"]]) if d[ix["perm_null_mean"]] else None),
@@ -191,8 +311,24 @@ if os.path.exists(f"{R}/predictor_auroc.csv"):
              "pair's outcome to the permuted pair, leaving the predictor vector untouched — this "
              "preserves the pair-dependence structure that a plain label shuffle destroys. "
              "BH-corrected across the predictor family.\n")
-    L.append(md_table(["substrate", "predictor", "n", "Spearman", "AUROC (held out by seed)",
-                       "null mean", "perm p", "BH q"], body))
+    L.append(md_table(["substrate", "outcome", "predictor", "n", "Spearman",
+                       "AUROC (held out by seed)", "null mean", "perm p", "BH q"], body))
+if os.path.exists(f"{R}/predictor_transfer_across_size.csv"):
+    rows = [l.rstrip("\n").split(",") for l in open(f"{R}/predictor_transfer_across_size.csv")]
+    hdr, dat = rows[0], rows[1:]
+    ix = {h: i for i, h in enumerate(hdr)}
+    L.append("\n### Does a predictor fitted on one substrate transfer to another?\n")
+    L.append("Leave-one-**size**-out. Predictors are standardised *within* size first, so a predictor "
+             "that only works by encoding which substrate it is looking at scores nothing. The sign "
+             "(and the ridge coefficients) come from the other sizes only. Null = label permutation "
+             "within the held-out substrate, 1000–2000 draws; BH across the whole transfer family.\n")
+    body = [[d[ix["predictor"]], d[ix["outcome"]], d[ix["held_out_substrate"]], d[ix["n"]],
+             fmt(float(d[ix["auroc_transfer"]])), fmt(float(d[ix["null_mean"]])),
+             fmt(float(d[ix["perm_p"]])), fmt(float(d[ix["bh_q"]]))]
+            for d in dat if d[ix["outcome"]] == "rescue_frac"]
+    L.append(md_table(["predictor", "outcome", "held-out substrate", "n", "AUROC", "null mean",
+                       "perm p", "BH q"], body))
+
 if os.path.exists(f"{R}/set4_predictors.csv"):
     rows = [l.rstrip("\n").split(",") for l in open(f"{R}/set4_predictors.csv")]
     hdr, dat = rows[0], rows[1:]
@@ -205,6 +341,68 @@ if os.path.exists(f"{R}/set4_predictors.csv"):
                        for d in dat]))
 
 # coverage
+abl = load("abl_*.jsonl")
+if abl:
+    L.append("\n## Control · is the obstruction the INIT seed or the DATA order?\n")
+    L.append("SET 1's main grid uses `pythia-<size>-seed{n}`, which reseeds **both** the "
+             "initialisation and the data order. `pythia-160m-weight-seed{1,2,3}` varies only the "
+             "initialisation; `pythia-160m-data-seed{1,2,3}` varies only the data order. Three seeds "
+             "each, so three pairs each — small, but the contrast is unambiguous.\n")
+    body = []
+    for sz in sorted({r["size"] for r in abl}):
+        sub = [r for r in abl if r["size"] == sz]
+        d0 = np.array([r["rungs"]["M0_naive_avg"]["delta_floor"] for r in sub])
+        dp = np.array([r["rungs"]["M1_perm_avg"]["delta_floor"] for r in sub])
+        do = np.array([r["rungs"]["M1_orth_avg"]["delta_floor"] for r in sub])
+        cs = np.array([r["predictors"]["coord_share_bnd_perm"] for r in sub])
+        body.append([sz, len(sub), fmt(float(np.mean([r["floor"] for r in sub])), 2), fmt(d0.mean(), 2),
+                     fmt(dp.mean(), 2), fmt(do.mean(), 2),
+                     fmt(np.mean(1 - np.minimum(dp, do) / d0) * 100, 1) + "%", fmt(cs.mean(), 4)])
+    main160 = [r for r in set1 if r["size"] == "160m"]
+    if main160:
+        d0 = np.array([r["rungs"]["M0_naive_avg"]["delta_floor"] for r in main160])
+        dp = np.array([r["rungs"]["M1_perm_avg"]["delta_floor"] for r in main160])
+        do = np.array([r["rungs"]["M1_orth_avg"]["delta_floor"] for r in main160])
+        cs = np.array([r["predictors"]["coord_share_bnd_perm"] for r in main160])
+        body.append(["160m (init+data, main grid)", len(main160),
+                     fmt(float(np.mean([r["floor"] for r in main160])), 2), fmt(d0.mean(), 2),
+                     fmt(dp.mean(), 2), fmt(do.mean(), 2),
+                     fmt(np.mean(1 - np.minimum(dp, do) / d0) * 100, 1) + "%", fmt(cs.mean(), 4)])
+    L.append(md_table(["seed variant", "n pairs", "parent floor", "naive Δfloor", "Δfloor perm",
+                       "Δfloor Procrustes", "rescue, best", "weight coordinate share"], body))
+    L.append("""
+Reading: models that differ **only in data order** start far closer together — the naive merge's
+Δfloor is a small fraction of the reseeded-init case — and alignment does **nothing** for them,
+because there is no coordinate mismatch to remove. Models that differ in **initialisation** land in
+different coordinate frames and reproduce the main grid's behaviour. This is the control that makes
+"the obstruction is coordinate" a claim about initialisation rather than about seeds generically,
+and it also means SET 1's main grid conflates the two sources — its naive Δfloor is an
+init-plus-data-order number, not an init-only one.
+""")
+
+L.append("""
+### What P0-2 comes to
+
+**Within a single substrate, nothing predicts the realised rescue.** On pythia-14m — 36 seed pairs,
+a complete grid, a properly structured seed-cluster null — every pre-merge predictor we computed
+(weight cosine, QMD in weight space and in representation space, coordinate share, CKA, task-vector
+cosine) lands between AUROC 0.30 and 0.68 held out by seed, and **not one survives BH correction**.
+The multivariate ridge over all of them does no better. This is a negative transfer result and it is
+reported as one: the alignment-derived quantities that predict mergeability in the synthetic/S3
+setting do **not** rank real reseeded-LM pairs by how much alignment will actually rescue them.
+
+**Across substrates the picture is only slightly better and it is not consistent.** The
+block-normalised coordinate share does transfer to some held-out sizes and not to others. Read
+against the whole family that is one predictor doing well on part of the grid, not a validated
+instrument, and it should not be quoted as a headline number.
+
+Two honest caveats in the other direction. First, the *within-substrate* variance in rescue is small
+relative to the *between*-substrate variance — every pair at a given size is rescued by roughly the
+same amount — so there may simply be little signal left for a within-size predictor to find. Second,
+the seed-cluster null is conservative by construction. Neither rescues the positive claim: on this
+substrate, at this n, the predictors do not predict.
+""")
+
 L.append("\n## Coverage — what ran and what did not\n")
 cov = []
 for sz in ["14m", "70m", "160m"]:
@@ -215,8 +413,13 @@ langs = [r["lang"] for r in set4]
 cov.append(["SET 4 · goldfish eng×X", f"{len(set4)}/4 language pairs ({', '.join(langs) or '—'})",
             "complete" if len(set4) == 4 else ("partial" if set4 else "NOT RUN"),
             "M0 naive · M1a vocab-transport · M1b/c vocab+unit-aligned (perm/Procrustes) · M1d/e forced-residual · M1f unit-aligned only"])
-cov.append(["BLiMP / MultiBLiMP accuracy", "0", "**NOT RUN**",
-            "No benchmark harness was close to wired inside this window. Deliberately not built from scratch. The Δfloor results below therefore say nothing about accuracy."])
+nb = {b["size"]: 0 for b in blimp}
+for b in blimp: nb[b["size"]] += 1
+cov.append(["BLiMP accuracy · SET 1 (English)", ", ".join(f"pythia-{k}: {v}/36 pairs" for k, v in sorted(nb.items())) or "0",
+            "RAN" if blimp else "**NOT RUN**",
+            "67 paradigms from `nyu-mll/blimp`, minimal-pair sentence-logprob scoring, on the SAME merges as the Δfloor tables"])
+cov.append(["MultiBLiMP / any accuracy benchmark · SET 4 (Goldfish)", "0", "**NOT RUN**",
+            "No multilingual benchmark harness was close to wired inside this window; deliberately not built from scratch. SET 4's numbers are likelihood only and say nothing about accuracy."])
 cov.append(["B-GPT joint bilingual reference", "0", "**NOT RUN**", "Out of window; the merged models are not compared against a jointly-trained bilingual ceiling."])
 cov.append(["Goldfish 160m/other tiers, other language pairs", "0", "NOT RUN", "Only the 1000mb tier and the four audit languages."])
 L.append(md_table(["cell", "n", "status", "what was measured"], cov))