Upload code/make_report.py with huggingface_hub

code/make_report.py

@@ -69,17 +69,19 @@ L.append("""## Read this first: what substrate, and what metric
 
 | | SET 1 | SET 4 |
 |---|---|---|
-| **Substrate** | `EleutherAI/pythia-{14m,70m,160m}-seed{1..9}` (PolyPythia) — real reseeded LMs | `goldfish-models/eng_latn_1000mb` × `{nld,spa,ell,pol}_*_1000mb` — the real bilingual-composition models, GPT-2 arch, 125M |
+| **Substrate** | `EleutherAI/pythia-{14m,31m,70m,160m,410m}-seed{1..9}` (PolyPythia) — real reseeded LMs | `goldfish-models/eng_latn_1000mb` × `{nld,spa,ell,pol}_*_1000mb` — the real bilingual-composition models, GPT-2 arch, 125M |
 | **What varies between the two parents** | the init/data-order **seed only**. Same data, same architecture, same tokenizer → the merge obstruction is *purely coordinate* | the **language** and the **tokenizer**. Independently initialised, independently trained |
 | **Held-out corpus** | FLORES-200 devtest `eng_Latn` | FLORES-200 devtest, `eng_Latn` + the partner language |
-| **Metric** | Δfloor in **nats/token** vs the better parent | Δfloor in **nats per UTF-8 byte** vs the better parent (bytes, because the two parents use different tokenizers and nats/token is not comparable across them) |
-| **What the metric is** | a **likelihood** metric | a **likelihood** 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. **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).
+| **Metric** | Δfloor in **nats/token** vs the better parent; **BLiMP accuracy** on the same merges | Δfloor in **nats per UTF-8 byte** vs the better parent (bytes, because the two parents use different tokenizers and nats/token is not comparable across them); **MultiBLiMP 1.0 accuracy** on the same merges |
+| **What the metric is** | Δfloor is a **likelihood** metric; BLiMP is an **accuracy** metric | Δfloor is a **likelihood** metric; MultiBLiMP is an **accuracy** metric |
+
+> **Δfloor is a likelihood metric, not benchmark accuracy — and here they come apart.** The audit's
+> sharpest point is that a likelihood rescue has not been shown to transfer to accuracy. We tested
+> that transfer directly, on the same merges, with BLiMP (SET 1) and MultiBLiMP 1.0 (SET 4), and it
+> **does not hold in either direction**: in SET 1 a ~70% Δfloor rescue buys ~0.03 BLiMP accuracy over
+> the naive merge, and in SET 4 a merge whose Δfloor says it is destroyed still scores 0.68 on
+> MultiBLiMP-English. Neither metric may be reported as a proxy for the other. Every table below
+> states which one it is.
 """)
 
 # ---------------- headline summary (computed, so it cannot drift from the tables)
@@ -270,9 +272,17 @@ if set4:
     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]))
+    _b = [[f"eng–{r['lang']}"] + [fmt(r["rungs"][k]["delta_floor_eng"]) for k in rung_keys] for r in set4]
+    _b.append(["**mean of the 4**"] + ["**" + fmt(float(np.mean([r["rungs"][k]["delta_floor_eng"] for r in set4]))) + "**"
+                                       for k in rung_keys])
+    L.append(md_table(["pair"] + rung_keys, _b))
+    L.append("\nAveraged over the four pairs the best M1 rung removes **"
+             + fmt(100 * (1 - min(np.mean([r["rungs"][k]["delta_floor_mean"] for r in set4]) for k in rung_keys if k.startswith("M1"))
+                          / np.mean([r["rungs"]["M0_naive_avg"]["delta_floor_mean"] for r in set4])), 1)
+             + "%** of the naive merge's Δfloor. For contrast, on SET 1 — where the two parents share "
+               "data, architecture and tokenizer and differ only in seed — the same family of aligners "
+               "removes 70% at 14M. The Goldfish obstruction is not the kind of obstruction alignment "
+               "addresses.\n")
     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))
@@ -443,6 +453,31 @@ if mb:
   accuracy standing. Whichever of the two you report, the other does not follow from it.
 """)
 
+bgc = load("bgpt_ceiling.jsonl")
+if bgc:
+    L.append("\n## SET 4 · what would SUCCESS look like? The jointly-trained bilingual ceiling\n")
+    L.append("A merge that fails is only interpretable against what a bilingual model of the same "
+             "budget actually achieves. B-GPT (Arnett et al.) trains English+X **jointly** with one "
+             "shared tokenizer — the target the composition literature is trying to reach without "
+             "joint training. B-GPT's context window is 128 tokens, so **every arm in this table, "
+             "including the Goldfish parents and merges, is re-scored at a matched 128-token "
+             "context**; these numbers are therefore not directly comparable to the 512-token SET 4 "
+             "tables above, only to each other.\n")
+    arms = list(bgc[0]["arms"])
+    for metric, lbl in (("nats_per_byte_eng", "nats/byte, English"), ("nats_per_byte_x", "nats/byte, partner"),
+                        ("multiblimp_eng", "MultiBLiMP-English"), ("multiblimp_x", "MultiBLiMP-partner")):
+        L.append(f"\n**{lbl}**" + ("  (lower is better)" if "nats" in metric else "  (higher is better, chance 0.500)") + "\n")
+        L.append(md_table(["pair"] + arms,
+                          [[f"eng–{r['lang']}"] + [fmt(r["arms"][a][metric]) for a in arms] for r in bgc]))
+    L.append("""
+This is the cleanest single statement the audit can make about SET 4. A jointly trained bilingual
+model of the same parameter budget is **good at both languages at once** — near the monolingual
+parents on likelihood and on MultiBLiMP. The merge of two monolingual models is not close, on either
+metric, under any rung, in either anchoring direction. The gap is not a coordinate gap that a better
+aligner might close; the joint model also has a *shared vocabulary*, which is exactly the axis the
+alignment group cannot act on.
+""")
+
 rev = load("set4_reverse.jsonl")
 if rev:
     L.append("\n## SET 4 · reverse direction (the partner language is the anchor)\n")
@@ -575,23 +610,43 @@ init-plus-data-order number, not an init-only one.
 
 L.append("\n## Coverage — what ran and what did not\n")
 cov = []
-for sz in ["14m", "70m", "160m"]:
+for sz in ["14m", "31m", "70m", "160m", "410m"]:
     n = len([r for r in set1 if r["size"] == sz])
-    cov.append([f"SET 1 · pythia-{sz}", f"{n}/36 seed pairs", "complete" if n == 36 else ("partial" if n else "NOT RUN"),
-                "M0 naive · M1 permutation · M1 Procrustes · M2 task-arithmetic · M3 TIES; barrier for M0 and M1-perm"])
-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"])
-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",
+    tot = 36 if sz != "410m" else 15
+    cov.append([f"SET 1 Δfloor · pythia-{sz}", f"{n}/{tot} seed pairs",
+                "complete" if n >= tot else ("partial" if n else "NOT RUN"),
+                "M0 naive · M1 permutation · M1 Procrustes · M2 task-arithmetic · M3 TIES; LMC barrier for M0 and M1-perm"])
+if abl:
+    for sz in sorted({r["size"] for r in abl}):
+        cov.append([f"SET 1 control · pythia-{sz}", f"{len([r for r in abl if r['size'] == sz])}/3 pairs",
+                    "complete", "init-seed-only vs data-order-only, same rungs"])
+nb = {}
+for b in blimp: nb[b["size"]] = nb.get(b["size"], 0) + 1
+cov.append(["SET 1 accuracy · BLiMP", ", ".join(f"pythia-{k}: {v}/36" for k, v in sorted(nb.items(), key=lambda kv: int(kv[0][:-1]))) 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."])
+            "67 paradigms from `nyu-mll/blimp`, minimal-pair sentence-logprob scoring, on the SAME merges"])
+nr = {}
+for r_ in rep: nr[r_["size"]] = nr.get(r_["size"], 0) + 1
+cov.append(["SET 1 · REPAIR rung", ", ".join(f"pythia-{k}: {v}/36" for k, v in sorted(nr.items(), key=lambda kv: int(kv[0][:-1]))) or "0",
+            "RAN" if rep else "**NOT RUN**", "M4 = permutation-aligned average + pre-activation statistics repair; M5 = naive + repair; Δfloor and BLiMP on the same merges"])
+cov.append(["SET 4 Δfloor · English-anchored", f"{len(set4)}/4 language pairs ({', '.join(r['lang'] for r in set4) or '—'})",
+            "complete" if len(set4) == 4 else ("partial" if set4 else "NOT RUN"),
+            "M0 naive · M1a vocab-transport · M1b/c vocab+unit-aligned · M1d/e forced-residual · M1f units-only · M1g/h embedding-row Procrustes"])
+cov.append(["SET 4 Δfloor · partner-anchored (reverse)", f"{len(rev)}/4 language pairs",
+            "complete" if len(rev) == 4 else ("partial" if rev else "NOT RUN"), "same rungs, roles swapped"])
+cov.append(["SET 4 accuracy · MultiBLiMP 1.0", f"{len(mb)}/4 language pairs",
+            "RAN" if mb else "**NOT RUN**", "`jumelet/multiblimp`, English + partner, on the SAME merges; UNK rate reported per cell"])
+bg = load("bgpt_ceiling.jsonl")
+cov.append(["SET 4 · jointly-trained bilingual ceiling", f"{len(bg)}/4 language pairs",
+            "RAN" if bg else "**NOT RUN**",
+            "`catherinearnett/B-GPT_en_X_simultaneous` vs the Goldfish parents and merges, all scored at a matched 128-token context"])
+cov.append(["SET 4 · task-arithmetic / TIES", "0", "**NOT APPLICABLE**",
+            "Both operators need a shared ancestor. Two independently trained monolingual Goldfish models have none, and with one parent as a pseudo-base the operators reduce to returning the other parent. Excluded on definition, not on time."])
+cov.append(["SET 1 · pythia-410m full grid", f"{len([r for r in set1 if r['size'] == '410m'])}/36 possible pairs", "partial",
+            "6 seeds only (15 possible pairs) and a reduced eval budget; the per-pair alignment cost is ~9 min at this width. Treat 410m as directional."])
+cov.append(["Goldfish other tiers / other languages", "0", "NOT RUN", "Only the 1000mb tier and the four audit languages."])
+cov.append(["Any downstream task beyond BLiMP/MultiBLiMP", "0", "NOT RUN",
+            "Both benchmarks are minimal-pair grammaticality tests. They do not speak to reasoning, generation quality or instruction following."])
 L.append(md_table(["cell", "n", "status", "what was measured"], cov))
 
 L.append("""
@@ -614,23 +669,42 @@ L.append("""
 
 L.append("\n## Files\n")
 L.append("""```
-results/set1_{14m,70m,160m}.jsonl   per-pair raw records (predictors, rungs, barriers, align info)
-results/set1_pairs.csv              per-pair flat table, SET 1
-results/set4_goldfish.jsonl         per-language-pair raw records, SET 4
-results/set4_pairs.csv              per-language-pair flat table, SET 4
-results/rung_summary.csv            rung x substrate x metric summary
-results/predictor_auroc.csv         SET 1 predictor table: held-out AUROC, permutation null, BH q
-results/set4_predictors.csv         SET 4 predictor rank correlations (n=4, descriptive)
-figs/set1_dfloor_by_rung.png        Δfloor by rung, per size
-figs/set1_rescue_vs_predictor.png   realised rescue vs coordinate share / CKA
-figs/set1_roc.png                   held-out-by-seed ROC
-figs/set4_dfloor.png                Δfloor by rung, Goldfish
-```""")
+results/set1_{14m,31m,70m,160m,410m}.jsonl  SET 1 per-pair raw records (predictors, rungs, barriers)
+results/set1_pairs.csv                      SET 1 per-pair flat table
+results/abl_160m-{weight,data}.jsonl        init-seed-only vs data-order-only control
+results/blimp_{size}.jsonl, blimp_pairs.csv SET 1 BLiMP accuracy, per pair and per rung
+results/repair_{size}.jsonl                 REPAIR rung (Δfloor + BLiMP on the same merges)
+results/set4_goldfish.jsonl, set4_pairs.csv SET 4 Δfloor, English-anchored
+results/set4_reverse.jsonl                  SET 4 Δfloor, partner-language-anchored
+results/set4_multiblimp.jsonl               SET 4 MultiBLiMP accuracy
+results/set4_tokenizer_diag.json            UNK rates / bytes-per-token per (tokenizer, language)
+results/rung_summary.csv                    rung x substrate x metric summary
+results/predictor_auroc.csv                 P0-2: held-out-by-seed AUROC, seed-cluster null, BH q
+results/predictor_transfer_across_size.csv  P0-2: leave-one-substrate-out transfer
+results/set4_predictors.csv                 P0-2 on SET 4 (n=4, descriptive only)
+figs/set1_dfloor_by_rung.png                Δfloor by rung, per size
+figs/set1_scale_trend.png                   obstruction and rescue vs model size
+figs/set1_rescue_vs_predictor.png           realised rescue vs coordinate share / CKA
+figs/set1_roc.png                           held-out-by-seed ROC
+figs/set1_blimp_dissociation.png            likelihood rescue vs accuracy rescue
+figs/set4_dfloor.png                        Δfloor by rung, Goldfish
+code/*.py                                   every script that produced the above
+```
+
+**Reproducing.** `common.py` holds the corpora and evaluation; `gpt2_align.py` holds the GPT-2
+(Conv1D) symmetry factors that `mergeschool.core.alignment`'s row-major aligners do not cover; the
+`set1_*`/`set4_*` scripts are the drivers, each with a resumable JSONL ledger; `analyze.py` builds
+the tables and figures and `make_report.py` writes this document. Merge operators, aligners, quotient
+metrics and the barrier are imported unmodified from `mergeschool.core`.
+""")
 
 open("/root/compose-audit/RESULTS_COMPOSE_AUDIT.md", "w").write("\n".join(L) + "\n")
 
 if rung_rows:
-    keys = list(rung_rows[0])
+    keys = []
+    for r in rung_rows:
+        for k in r:
+            if k not in keys: keys.append(k)
     with open(f"{R}/rung_summary.csv", "w") as f:
         f.write(",".join(keys) + "\n")
         for r in rung_rows: