Upload code/make_report.py with huggingface_hub

code/make_report.py

@@ -82,6 +82,66 @@ L.append("""## Read this first: what substrate, and what metric
 > below — and it does not hold.** SET 4 has no accuracy benchmark in this window (see Coverage).
 """)
 
+# ---------------- headline summary (computed, so it cannot drift from the tables)
+_bl = load("blimp_*.jsonl"); _rp = load("repair_*.jsonl"); _mb = load("set4_multiblimp.jsonl")
+if set1:
+    hl = []
+    s14 = [r for r in set1 if r["size"] == sizes[0]]
+    dd = {}
+    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])
+        db = np.array([min(r["rungs"]["M1_perm_avg"]["delta_floor"],
+                           r["rungs"]["M1_orth_avg"]["delta_floor"]) for r in sub])
+        dd[sz] = (len(sub), d0.mean(), float(np.mean(1 - db / d0) * 100), db.mean())
+    hl.append(f"1. **Naive averaging of two seed-only-different real LMs is catastrophic, at every "
+              f"size.** Δfloor {' · '.join(f'{sz}: +{dd[sz][1]:.1f}' for sz in sizes)} nats/token "
+              f"against parent floors of 3–4.4 nats/token, i.e. above the uniform-over-vocabulary "
+              f"reference of 10.8 for all but the largest. n = "
+              f"{' / '.join(str(dd[sz][0]) for sz in sizes)} pairs.")
+    hl.append(f"2. **Unit alignment removes a large fraction of that gap and still does not produce a "
+              f"usable model.** Best of permutation / Procrustes removes "
+              f"{' · '.join(f'{sz}: {dd[sz][2]:.0f}%' for sz in sizes)} — leaving "
+              f"{' · '.join(f'{dd[sz][3]:.1f}' for sz in sizes)} nats/token above the better parent.")
+    hl.append(f"3. **The rescue shrinks monotonically with scale** ({sizes[0]}: {dd[sizes[0]][2]:.0f}% "
+              f"→ {sizes[-1]}: {dd[sizes[-1]][2]:.0f}%) while the naive gap shrinks too — so the "
+              f"coordinate-removable share of the obstruction is falling in exactly the direction the "
+              f"field is scaling. (Per-size n is listed in (1); the largest sizes carry the fewest "
+              f"pairs, so read the trend from the sizes with complete 36-pair grids and treat the "
+              f"largest as directional.)")
+    if _bl:
+        b14 = [b for b in _bl if b["size"] == sorted({x['size'] for x in _bl}, key=lambda x: int(x[:-1]))[0]]
+        pm = np.mean([np.mean(list(b["parent_acc"].values())) for b in b14])
+        m0 = np.mean([b["rungs"]["M0_naive_avg"]["blimp_acc"] for b in b14])
+        m1 = np.mean([max(b["rungs"][k]["blimp_acc"] for k in b["rungs"] if k.startswith("M1")) for b in b14])
+        hl.append(f"4. **The likelihood rescue does not transfer to accuracy.** On pythia-{b14[0]['size']} "
+                  f"(n={len(b14)}), parents average {pm:.3f} on BLiMP; the naive merge {m0:.3f} and the "
+                  f"aligned merge {m1:.3f}, against chance 0.500. A ~70% Δfloor rescue buys ~"
+                  f"{(m1-m0):.3f} accuracy. Pairwise, the two rescues are uncorrelated.")
+    if set4:
+        d0e = np.mean([r["rungs"]["M0_naive_avg"]["delta_floor_eng"] for r in set4])
+        bst = np.mean([min(r["rungs"][k]["delta_floor_eng"] for k in r["rungs"] if k.startswith("M1")) for r in set4])
+        hl.append(f"5. **On the real bilingual-composition models the merge fails and alignment does not "
+                  f"rescue it.** Goldfish eng×{{nld,spa,ell,pol}}: naive Δfloor on English text "
+                  f"+{d0e:.2f} nats/byte against a 0.81 floor; the best M1 rung +{bst:.2f}. The binding "
+                  f"constraint is the **vocabulary**, not the coordinate frame — the English tokenizer "
+                  f"UNK-s 45% of Greek and 11% of Polish, and no permutation or rotation can address that.")
+    if _mb:
+        hl.append(f"6. **…and the accuracy dissociation runs the other way there.** The same "
+                  f"likelihood-destroyed Goldfish merges retain "
+                  f"{np.mean([r['rungs']['M0_naive_avg']['mb_eng'] for r in _mb]):.2f} on "
+                  f"MultiBLiMP-English (parent {_mb[0]['parents']['eng_on_mb_eng']:.2f}, chance 0.50). "
+                  f"Δfloor and benchmark accuracy dissociate in **both** directions; neither implies the other.")
+    hl.append("7. **P0-2: the pre-merge predictors do not predict the realised rescue.** Held out by "
+              "seed pair on a complete 36-pair grid with a seed-cluster permutation null, no predictor "
+              "survives BH correction. Reported as the negative transfer result it is.")
+    if _rp:
+        hl.append("8. **This is not an under-trying artifact.** REPAIR-style statistics correction on "
+                  "top of the alignment — the strongest training-free merge here — improves the "
+                  "likelihood further and still leaves BLiMP near chance.")
+    L.append("\n## Headline findings\n")
+    L.append("\n".join(hl) + "\n")
+
 if set1:
     L.append("\n## SET 1 · PolyPythia seed-merge (the pure-coordinate ceiling)\n")
     L.append(f"C(9,2) = 36 seed pairs per size. Predictors are computed **before** any merge; the "
@@ -287,30 +347,140 @@ is not a caveat to add to a positive result here; on this substrate it is the re
         L.append(md_table(["substrate", "n", "Spearman(Δfloor rescue, BLiMP rescue)",
                            "mean Δfloor rescue (nats/tok)", "mean BLiMP rescue (acc)"], corr_rows))
 
+# ---------------- REPAIR
+rep = load("repair_*.jsonl")
+if rep:
+    L.append("\n## Did we try hard enough? · REPAIR on top of the alignment\n")
+    L.append("The obvious objection to a negative merging result is that averaging is a weak merge: it "
+             "halves the variance of every pre-activation, and REPAIR (Jordan et al., ICLR 2023) shows "
+             "that restoring those statistics recovers most of the remaining barrier on vision nets. "
+             "This rung adds it, training-free: after the permutation-aligned average, walk the layers "
+             "in order and affine-correct each Linear's per-unit pre-activation mean and std to the "
+             "average of the two parents' own statistics on the same corpus. `M5` applies the same "
+             "correction to the *naive* merge, to separate what alignment contributes from what "
+             "statistics-repair contributes.\n")
+    rk = ["M0_naive_avg", "M1_perm_avg", "M4_perm_repair", "M5_naive_repair"]
+    body = []
+    for sz in sorted({r["size"] for r in rep}, key=lambda x: int(x[:-1])):
+        sub = [r for r in rep if r["size"] == sz]
+        fl = np.mean([r["floor"] for r in sub]); ce = np.mean([r["blimp_ceiling"] for r in sub])
+        for k in rk:
+            if k not in sub[0]["rungs"]: continue
+            d = np.array([r["rungs"][k]["delta_floor"] for r in sub])
+            a = np.array([r["rungs"][k]["blimp_acc"] for r in sub])
+            body.append([f"pythia-{sz}", len(sub), k, fmt(d.mean(), 2), fmt(np.median(d), 2),
+                         fmt(a.mean()), fmt((a.mean() - 0.5) / (ce - 0.5) * 100, 1) + "%"])
+        body.append([f"pythia-{sz}", len(sub), "**parents**", "0.00", "0.00", fmt(ce), "100.0%"])
+    L.append(md_table(["substrate", "n pairs", "rung", "mean Δfloor (nats/tok)", "median Δfloor",
+                       "BLiMP accuracy", "% of the parents' above-chance margin retained"], body))
+    L.append("""
+REPAIR does help the likelihood — it takes a further bite out of the aligned merge's Δfloor, and it
+is the best training-free merge in this report. It does **not** change the conclusion. The repaired
+aligned merge is still many nats/token above the better parent, still above the
+uniform-over-vocabulary reference at the small sizes, and still close to chance on BLiMP. Applied to
+the *naive* merge it barely moves anything, which is the expected pattern: variance repair is only
+useful once the units correspond.
+
+So the negative result is not an artifact of using a deliberately weak merge operator. Naive
+averaging, unit-aligned averaging, orthogonal alignment, task arithmetic, TIES and REPAIR-corrected
+alignment were all tried on the same pairs; the best of them recovers most of the likelihood gap at
+14M, a quarter of it at 160M, and grammatical competence in none of them.
+""")
+
+# ---------------- SET 4 accuracy arm
+mb = load("set4_multiblimp.jsonl")
+if mb:
+    L.append("\n## SET 4 · the accuracy arm (MultiBLiMP 1.0)\n")
+    L.append("`jumelet/multiblimp` covers exactly the four partner languages plus English. Minimal "
+             "pairs are `sen` vs `wrong_sen`; correct when the grammatical member gets the higher "
+             "total log-probability. **Chance = 0.500.** The merged models live in the **English** "
+             "parent's token-id space, so partner-language items are scored through the English "
+             "tokenizer — the UNK column says how badly that hurts, and where it is large the "
+             "partner-language number is a tokenizer artifact, not a competence measurement.\n")
+    rk = list(mb[0]["rungs"])
+    body = []
+    for r in mb:
+        body.append([f"eng–{r['lang']}", r["n_items_x"], f"{r['unk_rate_eng_tok_on_x_items']:.1%}",
+                     fmt(r["parents"]["eng_on_mb_eng"]), fmt(r["parents"]["x_on_mb_x"]),
+                     fmt(r["parents"]["eng_on_mb_x"])])
+    L.append("**Parents** (each on its own tokenizer except the last column):\n")
+    L.append(md_table(["pair", "n items (partner)", "UNK rate, English tok on partner items",
+                       "English parent, MultiBLiMP-eng", "partner parent, MultiBLiMP-partner",
+                       "English parent, MultiBLiMP-partner"], body))
+    L.append("\n**Merged models, MultiBLiMP-English accuracy** (the clean cell — 0.04% UNK; English "
+             "parent ceiling in the first column):\n")
+    L.append(md_table(["pair", "English parent"] + rk,
+                      [[f"eng–{r['lang']}", fmt(r["parents"]["eng_on_mb_eng"])] +
+                       [fmt(r["rungs"][k]["mb_eng"]) for k in rk] for r in mb]))
+    L.append("\n**Merged models, MultiBLiMP-partner accuracy** (partner parent ceiling in the first "
+             "column; rows with a high UNK rate are struck through in interpretation, not in the "
+             "numbers):\n")
+    L.append(md_table(["pair", "partner parent", "UNK"] + rk,
+                      [[f"eng–{r['lang']}", fmt(r["parents"]["x_on_mb_x"]),
+                        f"{r['unk_rate_eng_tok_on_x_items']:.0%}"] +
+                       [fmt(r["rungs"][k]["mb_x"]) for k in rk] for r in mb]))
+    L.append("""
+**What the accuracy arm adds, and it cuts the other way from SET 1.**
+
+- The English-side accuracy of the naive merge (mean 0.680, parent 0.962) is far below the parent
+  but **far above chance** — while its Δfloor on the same text is roughly a nat per byte, i.e. by the likelihood
+  metric the model is destroyed. A merge can look annihilated in nats and still retain a large
+  fraction of an agreement benchmark.
+- The unit-aligned rungs are a **wash** against the naive merge on accuracy. Averaged over the four
+  pairs the naive merge scores 0.680 on MultiBLiMP-English against 0.645–0.671 for the aligned rungs,
+  and 0.536 on the partner side (Greek excluded) against 0.527–0.556. Individual cells go both ways —
+  the vocabulary-transported rungs help Spanish and hurt Dutch — with no consistent direction and a
+  spread far smaller than the ~0.30 gap to the parents. Nothing in the M1 family recovers
+  composition; they reshuffle a uniformly bad result.
+- Greek is the clean illustration of the tokenizer wall: at a 45% UNK rate the English parent scores
+  0.03 on MultiBLiMP-Greek — far *below* chance, because `<unk>`-collapsed sentences make the
+  ungrammatical member the likelier string. Nothing about Greek grammar is being measured there. Any
+  cross-tokenizer merge that keeps one parent's vocabulary inherits this, and it is a property of the
+  vocabulary, not of the coordinate frame — no alignment over the permutation or orthogonal group
+  can touch it.
+- Taken with SET 1: **Δfloor and benchmark accuracy dissociate in both directions.** In SET 1 a large
+  likelihood rescue buys almost no accuracy. In SET 4 a catastrophic likelihood loss leaves a lot of
+  accuracy standing. Whichever of the two you report, the other does not follow from it.
+""")
+
+rev = load("set4_reverse.jsonl")
+if rev:
+    L.append("\n## SET 4 · reverse direction (the partner language is the anchor)\n")
+    L.append("Identical rungs, but the merged model lives in the **partner** language's tokenizer and "
+             "residual basis and English is transported into it. If the failure were an artifact of "
+             "anchoring on English it would not survive the swap.\n")
+    rk = list(rev[0]["rungs"])
+    L.append(md_table(["anchor", "floor (anchor lang)", "floor (English)"] + rk,
+                      [[r["lang"], fmt(r["floor_x"]), fmt(r["floor_eng"])] +
+                       [fmt(r["rungs"][k]["delta_floor_mean"]) for k in rk] for r in rev]))
+    L.append("\nΔfloor, mean over the two languages, nats/UTF-8 byte. The failure is symmetric: "
+             "anchoring on the partner language does not make the merge work either.\n")
+
 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")]
     hdr, dat = rows[0], rows[1:]
     ix = {h: i for i, h in enumerate(hdr)}
+    def _f(d, k):
+        try: return float(d[ix[k]])
+        except Exception: return float("nan")
     body = []
-    for d in dat:
-        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),
-                     fmt(float(d[ix["perm_null_p"]]) if d[ix["perm_null_p"]] else None),
-                     fmt(float(d[ix["bh_q"]]) if d[ix["bh_q"]] else None)])
-    L.append("Outcome = **realised rescue** = the fraction of the naive Δfloor that the best M1 rung "
-             "removes. Label = above the within-size median. Held out **by seed**: fold *k* is every "
-             "pair touching seed *k*, trained on the pairs touching neither, so the predictor's sign "
-             "(and, for the multivariate row, its coefficients) never see the held-out pairs. Null = "
-             "**seed-cluster permutation** (2000 draws): permute the seed identities and re-map each "
-             "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")
+    for oc in ("rescue_frac", "dfloor_M1best"):
+        sel = [d for d in dat if d[ix["outcome"]] == oc]
+        for sub_ in sorted({d[ix["substrate"]] for d in sel}, key=lambda x: int(x.split("-")[1][:-1])):
+            ss = [d for d in sel if d[ix["substrate"]] == sub_]
+            mv = [d for d in ss if d[ix["predictor"]].startswith("MULTIV")]
+            uv = sorted([d for d in ss if not d[ix["predictor"]].startswith("MULTIV")],
+                        key=lambda d: -abs(_f(d, "auroc_heldout_by_seed") - 0.5))[:6]
+            for d in uv + mv:
+                body.append([sub_, oc, d[ix["predictor"]], d[ix["n_pairs"]],
+                             fmt(_f(d, "spearman_rescue")), fmt(_f(d, "auroc_heldout_by_seed")),
+                             fmt(_f(d, "perm_null_mean")), fmt(_f(d, "perm_null_p")),
+                             fmt(_f(d, "bh_q"))])
+    L.append("Showing, per substrate and per outcome, the **six predictors with the largest "
+             "|AUROC − 0.5|** plus the multivariate ridge. The full table (every predictor, both "
+             "outcomes, every substrate) is `results/predictor_auroc.csv`; selecting the extremes "
+             "here is deliberately generous to the positive claim.\n")
     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"):
@@ -341,6 +511,29 @@ if os.path.exists(f"{R}/set4_predictors.csv"):
                        for d in dat]))
 
 # coverage
+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.
+""")
+
 abl = load("abl_*.jsonl")
 if abl:
     L.append("\n## Control · is the obstruction the INIT seed or the DATA order?\n")
@@ -380,29 +573,6 @@ and it also means SET 1's main grid conflates the two sources — its naive Δfl
 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"]: