compose-audit refresh 2026-08-26 21:04 UTC

README.md

@@ -1,11 +1,17 @@
 ---
 license: apache-2.0
-tags: [model-merging, alignment, polypythia, goldfish, multilingual]
+tags:
+- model-merging
+- alignment
+- polypythia
+- goldfish
+- multilingual
+- blimp
 ---
 
 # Compose-audit: putting the alignment map and the merging payoff on the SAME real models
 
-_Generated 2026-08-26 20:59 UTC · training-free · code: `/root/compose-audit` · operators/aligners/metrics imported unmodified from `mergeschool.core` (`/root/mergeability`, treated as read-only)._
+_Generated 2026-08-26 21:04 UTC · training-free · code: `/root/compose-audit` · operators/aligners/metrics imported unmodified from `mergeschool.core` (`/root/mergeability`, treated as read-only)._
 
 ## Read this first: what substrate, and what metric
 
@@ -28,9 +34,9 @@ _Generated 2026-08-26 20:59 UTC · training-free · code: `/root/compose-audit`
 
 ## Headline findings
 
-1. **Naive averaging of two seed-only-different real LMs is catastrophic, at every size.** Δfloor 14m: +32.4 · 31m: +20.4 · 70m: +20.2 · 160m: +8.8 · 410m: +6.5 nats/token against parent floors of 3–4.4 nats/token, i.e. above the uniform-over-vocabulary reference of 10.8 for all but the largest. n = 36 / 36 / 36 / 28 / 3 pairs.
-2. **Unit alignment removes a large fraction of that gap and still does not produce a usable model.** Best of permutation / Procrustes removes 14m: 72% · 31m: 57% · 70m: 55% · 160m: 32% · 410m: 11% — leaving 9.0 · 8.1 · 8.7 · 6.0 · 5.7 nats/token above the better parent.
-3. **The rescue shrinks monotonically with scale** (14m: 72% → 410m: 11%) while the naive gap shrinks too — so the coordinate-removable share of the obstruction is falling in exactly the direction the field is scaling. (Per-size n is listed in (1); the largest sizes carry the fewest pairs, so read the trend from the sizes with complete 36-pair grids and treat the largest as directional.)
+1. **Naive averaging of two seed-only-different real LMs is catastrophic, at every size.** Δfloor 14m: +32.4 · 31m: +20.4 · 70m: +20.2 · 160m: +8.8 · 410m: +6.5 nats/token against parent floors of 3–4.4 nats/token, i.e. above the uniform-over-vocabulary reference of 10.8 for all but the largest. n = 36 / 36 / 36 / 30 / 3 pairs.
+2. **Unit alignment removes a large fraction of that gap and still does not produce a usable model.** The exactly function-preserving permutation rung removes 14m: 70% · 31m: 48% · 70m: 44% · 160m: 23% · 410m: 11% — leaving 9.6 · 9.6 · 11.0 · 6.7 · 5.7 nats/token above the better parent, i.e. an absolute 14.0 · 13.5 · 14.6 · 10.0 · 8.7 nats/token against parent floors of 3.0–4.4 and a uniform-over-vocabulary reference of 10.8. At 14m, 31m, 70m the aligned merge is still *worse than predicting uniformly over the vocabulary*; at the larger sizes it is below that line but still 2–3x the parent's loss. (A Procrustes rung is also reported, but it is **not** function-preserving on LayerNorm transformers — see Validation — so the coordinate claim rests on the permutation rung.)
+3. **The rescue shrinks monotonically with scale** (14m: 70% → 410m: 11% on the exact rung) while the naive gap shrinks too — so the coordinate-removable share of the obstruction is falling in exactly the direction the field is scaling. (Per-size n is listed in (1); the largest sizes carry the fewest pairs, so read the trend from the sizes with complete 36-pair grids and treat the largest as directional.)
 4. **The likelihood rescue does not transfer to accuracy.** On pythia-14m (n=36), parents average 0.652 on BLiMP; the naive merge 0.518 and the aligned merge 0.544, against chance 0.500. A ~70% Δfloor rescue buys ~0.026 accuracy. Pairwise, the two rescues are uncorrelated.
 5. **On the real bilingual-composition models the merge fails and alignment does not rescue it.** Goldfish eng×{nld,spa,ell,pol}: naive Δfloor on English text +0.91 nats/byte against a 0.81 floor; the best M1 rung +0.90. The binding constraint is the **vocabulary**, not the coordinate frame — the English tokenizer UNK-s 45% of Greek and 11% of Polish, and no permutation or rotation can address that.
 6. **…and the accuracy dissociation runs the other way there.** The same likelihood-destroyed Goldfish merges retain 0.68 on MultiBLiMP-English (parent 0.96, chance 0.50). Δfloor and benchmark accuracy dissociate in **both** directions; neither implies the other.
@@ -82,17 +88,17 @@ Linear-mode-connectivity barrier (`eval.merge_barrier`): naive **20.30**, permut
 Linear-mode-connectivity barrier (`eval.merge_barrier`): naive **20.17**, permutation-aligned **10.98** nats/token.
 
 
-### pythia-160m — 28 seed pairs · mean parent floor **3.254** nats/token · uniform-over-vocabulary reference **10.826** nats/token
+### pythia-160m — 30 seed pairs · mean parent floor **3.254** nats/token · uniform-over-vocabulary reference **10.826** nats/token
 
 | rung | n | mean nats/tok | mean Δfloor | median Δfloor | best Δfloor | beats naive | % of naive Δfloor removed |
 |---|---|---|---|---|---|---|---|
-| M0_naive_avg | 28 | 12.10 | 8.84 | 8.38 | 6.88 | 0/28 | 0.0% |
-| M1_perm_avg | 28 | 9.97 | 6.72 | 6.38 | 5.50 | 25/28 | 22.6% |
-| M1_orth_avg | 28 | 9.38 | 6.12 | 6.04 | 5.13 | 28/28 | 29.8% |
-| M2_task_arith | 28 | 30.32 | 27.07 | 26.97 | 17.88 | 0/28 | -205.4% |
-| M3_ties | 28 | 60.19 | 56.93 | 57.41 | 49.30 | 0/28 | -554.6% |
+| M0_naive_avg | 30 | 12.10 | 8.84 | 8.38 | 6.88 | 0/30 | 0.0% |
+| M1_perm_avg | 30 | 9.96 | 6.70 | 6.38 | 5.50 | 27/30 | 22.8% |
+| M1_orth_avg | 30 | 9.42 | 6.16 | 6.14 | 5.13 | 30/30 | 29.4% |
+| M2_task_arith | 30 | 30.31 | 27.05 | 26.97 | 17.88 | 0/30 | -205.1% |
+| M3_ties | 30 | 60.28 | 57.03 | 57.47 | 49.30 | 0/30 | -555.5% |
 
-Linear-mode-connectivity barrier (`eval.merge_barrier`): naive **8.84**, permutation-aligned **6.71** nats/token.
+Linear-mode-connectivity barrier (`eval.merge_barrier`): naive **8.83**, permutation-aligned **6.70** nats/token.
 
 
 ### pythia-410m — 3 seed pairs · mean parent floor **2.971** nats/token · uniform-over-vocabulary reference **10.826** nats/token
@@ -116,10 +122,11 @@ Linear-mode-connectivity barrier (`eval.merge_barrier`): naive **6.38**, permuta
    destroyed one. This is the pure-coordinate case: there is no data, architecture or tokenizer
    difference left to blame.
 2. **Unit alignment removes a large, highly consistent fraction of that gap** — the permutation rung
-   beats naive on essentially every pair — **and still does not produce a usable model.** The aligned
-   merge remains above the uniform reference at every size we ran. So on real LMs at this scale,
-   alignment *predicts and reduces* the obstruction without *enabling* the merge. Reporting the
-   reduction as "merging works once you align" would be wrong.
+   beats naive on essentially every pair — **and still does not produce a usable model.** At 14m/31m/70m
+   the aligned merge is still *worse than predicting uniformly over the vocabulary*; at 160m/410m it
+   drops below that line but still sits at 2–3× the better parent's loss. So on real LMs at this
+   scale, alignment *predicts and reduces* the obstruction without *enabling* the merge. Reporting
+   the reduction as "merging works once you align" would be wrong.
 3. **Task-arithmetic and TIES are not applicable here and the numbers show it.** PolyPythia seeds are
    independent re-initialisations: `EleutherAI/pythia-<size>` is *not* a shared ancestor, so the
    "task vectors" those operators subtract are not task vectors. Their rows are reported only to
@@ -128,6 +135,42 @@ Linear-mode-connectivity barrier (`eval.merge_barrier`): naive **6.38**, permuta
    interior t that beats the better parent, aligned or not.
 
 
+### Validation: is the alignment actually function-preserving? (One rung is not.)
+
+Every M1 rung is only an *alignment* if `g.θ_B` computes exactly what `θ_B` computes. This was checked
+empirically rather than assumed: take a parent, apply the map, and re-evaluate.
+
+
+| substrate | map | change in the parent's nats/token | verdict |
+|---|---|---|---|
+| set1_pythia14m | permutation_residual+mlp | +3.026e-06 | EXACT |
+| set1_pythia14m | permutation_full(+heads) | +5.893e-06 | EXACT |
+| set1_pythia14m | orthogonal_residual+mlp | +27.262 | **NOT function-preserving** |
+| set4_goldfish_nld | perm_residual_only | +0.000e+00 | EXACT |
+| set4_goldfish_nld | mlp_only | +0.000e+00 | EXACT |
+| set4_goldfish_nld | heads_only | +0.000e+00 | EXACT |
+| set4_goldfish_nld | perm_full | +0.000e+00 | EXACT |
+| set4_goldfish_nld | orth_full | +0.069 | negligible |
+
+**The permutation family is exact** — residual basis, free MLP hidden axis and attention heads, on
+both architectures, to float32 noise. Those rungs are genuine alignments.
+
+**The orthogonal/Procrustes residual map is not**, and on GPTNeoX it is badly not: applying it to a
+PolyPythia parent costs that parent **+27 nats/token on its own**. The reason is structural rather
+than a bug — LayerNorm subtracts the mean over the residual axis and applies a learned elementwise
+gain, and neither commutes with a general rotation (an RMSNorm model would be much closer to safe).
+On the GPT-2 Goldfish models the same map costs only +0.07 nats/token, so the defect is
+architecture-specific in magnitude.
+
+**Consequence for the tables.** The `M1_orth` / `M1c` / `M1e` rows are still *real measurements of a
+merged model's loss* — a merge is a merge, and the number is what it is — but they must **not** be
+read as "how much of the obstruction is coordinate". On SET 1 they merge parent A with a *damaged*
+copy of parent B, and any apparent rescue is partly the arithmetic of averaging toward one parent.
+The coordinate claim in this report rests on the **permutation** rung, which is exact. Where the two
+disagree, believe the permutation rung. This is flagged again at every table that contains an
+orthogonal row.
+
+
 ### The scale trend — alignment's coordinate rescue WEAKENS with model size
 
 | substrate | n pairs | parent floor | naive Δfloor | rescue, permutation | rescue, Procrustes | rescue, best of the two | unaligned CKA | aligned CKA | weight coordinate share |
@@ -135,11 +178,15 @@ Linear-mode-connectivity barrier (`eval.merge_barrier`): naive **6.38**, permuta
 | pythia-14m | 36 | 4.38 | 32.43 | 69.9% | 50.5% | 72.0% | 0.588 | 0.374 | 0.0652 |
 | pythia-31m | 36 | 3.94 | 20.35 | 47.7% | 46.4% | 57.4% | 0.632 | 0.380 | 0.0645 |
 | pythia-70m | 36 | 3.63 | 20.16 | 43.9% | 50.4% | 55.1% | 0.671 | 0.428 | 0.0793 |
-| pythia-160m | 28 | 3.25 | 8.84 | 22.6% | 29.8% | 31.5% | 0.751 | 0.765 | 0.0874 |
+| pythia-160m | 30 | 3.25 | 8.84 | 22.8% | 29.4% | 31.2% | 0.739 | 0.746 | 0.0871 |
 | pythia-410m | 3 | 2.97 | 6.49 | 11.2% | 9.2% | 11.2% | 0.410 | 0.372 | 0.0333 |
 
-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
+Read the **permutation** column: it is the one that is exactly function-preserving (see Validation
+above). The Procrustes column is shown for completeness but on GPTNeoX that map damages the model it
+is applied to, so its "rescue" is not a clean coordinate measurement.
+
+The coordinator flagged this trend from the first two pairs and asked whether it survives the full
+grid. **It does, monotonically, across every size we ran, on the exact rung alone.** 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
@@ -253,8 +300,9 @@ PolyPythia parents are English LMs, so BLiMP applies directly to SET 1's merges.
 | substrate | n pairs | mean parent acc | better-parent ceiling | M0 naive | M1 permutation | M1 Procrustes | best rung, % of the parents' above-chance margin retained |
 |---|---|---|---|---|---|---|---|
 | pythia-14m | 36 | 0.652 | 0.664 | 0.518 | 0.533 | 0.530 | 28.5% |
-| pythia-31m | 11 | 0.688 | 0.695 | 0.514 | 0.530 | 0.535 | 22.8% |
-| pythia-70m | 35 | 0.717 | 0.722 | 0.515 | 0.540 | 0.542 | 24.4% |
+| pythia-31m | 30 | 0.690 | 0.697 | 0.523 | 0.532 | 0.534 | 24.3% |
+| pythia-70m | 36 | 0.717 | 0.722 | 0.516 | 0.541 | 0.542 | 24.4% |
+| pythia-160m | 1 | 0.774 | 0.780 | 0.562 | 0.545 | 0.556 | 22.1% |
 
 **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
@@ -268,8 +316,8 @@ Pair by pair, does the size of the likelihood rescue predict the size of the acc
 | substrate | n | Spearman(Δfloor rescue, BLiMP rescue) | mean Δfloor rescue (nats/tok) | mean BLiMP rescue (acc) |
 |---|---|---|---|---|
 | pythia-14m | 36 | 0.139 | 23.44 | 0.0257 |
-| pythia-31m | 11 | -0.327 | 14.16 | 0.0303 |
-| pythia-70m | 35 | 0.239 | 11.31 | 0.0370 |
+| pythia-31m | 30 | -0.141 | 12.58 | 0.0213 |
+| pythia-70m | 36 | 0.169 | 11.43 | 0.0361 |
 
 ## Did we try hard enough? · REPAIR on top of the alignment
 
@@ -282,11 +330,11 @@ The obvious objection to a negative merging result is that averaging is a weak m
 | pythia-14m | 36 | M4_perm_repair | 7.88 | 7.41 | 0.527 | 16.7% |
 | pythia-14m | 36 | M5_naive_repair | 32.50 | 31.10 | 0.512 | 7.2% |
 | pythia-14m | 36 | **parents** | 0.00 | 0.00 | 0.664 | 100.0% |
-| pythia-70m | 4 | M0_naive_avg | 20.95 | 19.69 | 0.544 | 19.0% |
-| pythia-70m | 4 | M1_perm_avg | 21.63 | 20.06 | 0.541 | 17.6% |
-| pythia-70m | 4 | M4_perm_repair | 21.67 | 20.37 | 0.532 | 13.7% |
-| pythia-70m | 4 | M5_naive_repair | 20.02 | 20.22 | 0.518 | 8.0% |
-| pythia-70m | 4 | **parents** | 0.00 | 0.00 | 0.731 | 100.0% |
+| pythia-70m | 10 | M0_naive_avg | 18.33 | 17.75 | 0.523 | 10.3% |
+| pythia-70m | 10 | M1_perm_avg | 16.91 | 16.26 | 0.541 | 17.9% |
+| pythia-70m | 10 | M4_perm_repair | 16.88 | 17.01 | 0.535 | 15.6% |
+| pythia-70m | 10 | M5_naive_repair | 18.29 | 18.49 | 0.516 | 7.1% |
+| pythia-70m | 10 | **parents** | 0.00 | 0.00 | 0.727 | 100.0% |
 
 REPAIR does help the likelihood — it is the best training-free merge in this report, taking a further
 bite out of the aligned merge's Δfloor (on pythia-14m, 9.61 → 7.88 nats/token, a further 18%). **And
@@ -640,7 +688,7 @@ SET 1's main grid uses `pythia-<size>-seed{n}`, which reseeds **both** the initi
 |---|---|---|---|---|---|---|---|
 | 160m-data | 3 | 3.27 | 3.13 | 3.00 | 3.00 | 3.9% | 0.0139 |
 | 160m-weight | 3 | 3.25 | 3.10 | 2.79 | 2.79 | 10.0% | 0.0123 |
-| 160m (init+data, main grid) | 28 | 3.25 | 8.84 | 6.72 | 6.12 | 31.5% | 0.0874 |
+| 160m (init+data, main grid) | 30 | 3.25 | 8.84 | 6.70 | 6.16 | 31.2% | 0.0871 |
 
 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,
@@ -658,12 +706,12 @@ init-plus-data-order number, not an init-only one.
 | SET 1 Δfloor · pythia-14m | 36/36 seed pairs | complete | M0 naive · M1 permutation · M1 Procrustes · M2 task-arithmetic · M3 TIES; LMC barrier for M0 and M1-perm |
 | SET 1 Δfloor · pythia-31m | 36/36 seed pairs | complete | M0 naive · M1 permutation · M1 Procrustes · M2 task-arithmetic · M3 TIES; LMC barrier for M0 and M1-perm |
 | SET 1 Δfloor · pythia-70m | 36/36 seed pairs | complete | M0 naive · M1 permutation · M1 Procrustes · M2 task-arithmetic · M3 TIES; LMC barrier for M0 and M1-perm |
-| SET 1 Δfloor · pythia-160m | 28/36 seed pairs | partial | M0 naive · M1 permutation · M1 Procrustes · M2 task-arithmetic · M3 TIES; LMC barrier for M0 and M1-perm |
+| SET 1 Δfloor · pythia-160m | 30/36 seed pairs | partial | M0 naive · M1 permutation · M1 Procrustes · M2 task-arithmetic · M3 TIES; LMC barrier for M0 and M1-perm |
 | SET 1 Δfloor · pythia-410m | 3/15 seed pairs | partial | M0 naive · M1 permutation · M1 Procrustes · M2 task-arithmetic · M3 TIES; LMC barrier for M0 and M1-perm |
 | SET 1 control · pythia-160m-data | 3/3 pairs | complete | init-seed-only vs data-order-only, same rungs |
 | SET 1 control · pythia-160m-weight | 3/3 pairs | complete | init-seed-only vs data-order-only, same rungs |
-| SET 1 accuracy · BLiMP | pythia-14m: 36/36, pythia-31m: 11/36, pythia-70m: 35/36 | RAN | 67 paradigms from `nyu-mll/blimp`, minimal-pair sentence-logprob scoring, on the SAME merges |
-| SET 1 · REPAIR rung | pythia-14m: 36/36, pythia-70m: 4/36 | RAN | M4 = permutation-aligned average + pre-activation statistics repair; M5 = naive + repair; Δfloor and BLiMP on the same merges |
+| SET 1 accuracy · BLiMP | pythia-14m: 36/36, pythia-31m: 30/36, pythia-70m: 36/36, pythia-160m: 1/36 | RAN | 67 paradigms from `nyu-mll/blimp`, minimal-pair sentence-logprob scoring, on the SAME merges |
+| SET 1 · REPAIR rung | pythia-14m: 36/36, pythia-70m: 10/36 | RAN | M4 = permutation-aligned average + pre-activation statistics repair; M5 = naive + repair; Δfloor and BLiMP on the same merges |
 | SET 4 Δfloor · English-anchored | 4/4 language pairs (nld_Latn, spa_Latn, ell_Grek, pol_Latn) | complete | M0 naive · M1a vocab-transport · M1b/c vocab+unit-aligned · M1d/e forced-residual · M1f units-only · M1g/h embedding-row Procrustes |
 | SET 4 Δfloor · partner-anchored (reverse) | 4/4 language pairs | complete | same rungs, roles swapped |
 | SET 4 accuracy · MultiBLiMP 1.0 | 4/4 language pairs | RAN | `jumelet/multiblimp`, English + partner, on the SAME merges; UNK rate reported per cell |

code/bgpt_ceiling.py

@@ -0,0 +1,139 @@
+"""What would SUCCESS look like? The jointly-trained bilingual ceiling.
+
+SET 4 shows that merging two monolingual Goldfish models produces a model that is destroyed by
+likelihood and badly degraded by accuracy. That is only interpretable against what a bilingual model
+of the same budget actually achieves. B-GPT (Arnett et al.) trains English+X jointly with a single
+shared tokenizer — the target the composition literature is trying to reach without joint training.
+
+Reports the same two metrics on the same two corpora: nats per UTF-8 byte on FLORES-200 devtest, and
+MultiBLiMP 1.0 accuracy."""
+import os, sys, json, time, csv, argparse
+sys.path.insert(0, "/root/compose-audit")
+from common import *
+from mergeschool.core.models import load_hf
+from huggingface_hub import hf_hub_download
+
+ap = argparse.ArgumentParser()
+ap.add_argument("--pairs", default="nld_Latn:nl:nld,spa_Latn:es:spa,ell_Grek:el:ell,pol_Latn:pl:pol")
+ap.add_argument("--variant", default="simultaneous")
+ap.add_argument("--n_sent", type=int, default=500)
+ap.add_argument("--max_items", type=int, default=1200)
+ap.add_argument("--bs", type=int, default=8)
+A = ap.parse_args()
+OUT = "/root/compose-audit/results/bgpt_ceiling.jsonl"
+DEV = "cuda"
+
+
+def log(*a): print(f"[{time.strftime('%H:%M:%S')}]", *a, flush=True)
+
+
+def build_blocks(tok, text, block=128, max_blocks=200):
+    ids = tok(text)["input_ids"]
+    n = max(1, min(max_blocks, len(ids) // block))
+    arr = torch.from_numpy(np.asarray(ids[: n * block], dtype=np.int64).reshape(n, block))
+    nb = sum(len(tok.decode(list(arr[i, 1:].numpy())).encode("utf-8")) for i in range(n))
+    return arr, nb
+
+
+@torch.no_grad()
+def nll_total(model, blocks, dev, bs=8):
+    tot, ntok = 0.0, 0
+    for i in range(0, blocks.shape[0], bs):
+        x = blocks[i:i + bs].to(dev)
+        lp = torch.log_softmax(model(x).logits.float()[:, :-1], -1)
+        tgt = x[:, 1:]
+        tot += (-lp.gather(-1, tgt.unsqueeze(-1)).squeeze(-1)).sum().item(); ntok += tgt.numel()
+    return tot, ntok
+
+
+def mb_pairs(lang, n):
+    p = hf_hub_download("jumelet/multiblimp", f"{lang}/data.tsv", repo_type="dataset")
+    rows = list(csv.DictReader(open(p, encoding="utf-8"), delimiter="\t"))[:n]
+    return [(r["sen"], r["wrong_sen"]) for r in rows if r.get("sen") and r.get("wrong_sen")]
+
+
+@torch.no_grad()
+def mb_acc(model, tok, pairs, dev, bs=48, maxlen=64):
+    def sc(sents):
+        e = tok(sents, return_tensors="pt", padding=True, truncation=True, max_length=maxlen)
+        ids, am = e["input_ids"], e["attention_mask"]
+        o = []
+        for i in range(0, ids.shape[0], bs):
+            x, m = ids[i:i + bs].to(dev), am[i:i + bs].to(dev)
+            lp = torch.log_softmax(model(x, attention_mask=m).logits.float()[:, :-1], -1)
+            o.append((lp.gather(-1, x[:, 1:].unsqueeze(-1)).squeeze(-1) * m[:, 1:].float()).sum(1).cpu())
+        return torch.cat(o).numpy()
+    sg, sb = sc([g for g, _ in pairs]), sc([b for _, b in pairs])
+    unk = 0.0
+    if tok.unk_token_id is not None:
+        e = tok([g for g, _ in pairs], return_tensors="pt", padding=True, truncation=True, max_length=maxlen)
+        unk = float(((e["input_ids"] == tok.unk_token_id) & e["attention_mask"].bool()).sum().item()
+                    / max(1, e["attention_mask"].sum().item()))
+    return float((sg > sb).mean()), unk
+
+
+eng_text = "\n".join(flores_lines("eng_Latn")[: A.n_sent])
+MB_ENG = mb_pairs("eng", A.max_items)
+BLOCK = 128            # B-GPT's n_positions. Every model in this table is scored at the SAME
+                       # context length so the nats/byte numbers are comparable.
+
+
+def eval_model(m, tok, x_text, mbx):
+    be, nbe = build_blocks(tok, eng_text, BLOCK); bx, nbx = build_blocks(tok, x_text, BLOCK)
+    te, _ = nll_total(m, be, DEV, bs=A.bs); tx, _ = nll_total(m, bx, DEV, bs=A.bs)
+    ae, ue = mb_acc(m, tok, MB_ENG, DEV)
+    ax, ux = mb_acc(m, tok, mbx, DEV)
+    return {"nats_per_byte_eng": te / nbe, "nats_per_byte_x": tx / nbx,
+            "multiblimp_eng": ae, "multiblimp_x": ax, "unk_rate_eng": ue, "unk_rate_x": ux}
+
+done = set()
+if os.path.exists(OUT):
+    for l in open(OUT):
+        try: done.add(json.loads(l)["lang"]) 
+        except Exception: pass
+fh = open(OUT, "a")
+
+for spec in A.pairs.split(","):
+    fcode, x2, mb = spec.split(":")
+    if fcode in done: continue
+    repo = f"catherinearnett/B-GPT_en_{x2}_{A.variant}"
+    try:
+        m, tok = load_hf(repo, dtype=torch.float32, device=DEV); m.eval()
+    except Exception as e:
+        log("FAILED to load", repo, type(e).__name__, str(e)[:200]); continue
+    x_text = "\n".join(flores_lines(fcode)[: A.n_sent])
+    MBX = mb_pairs(mb, A.max_items)
+    arms = {"bgpt_joint_bilingual": eval_model(m, tok, x_text, MBX)}
+    log(f"  B-GPT joint: {arms['bgpt_joint_bilingual']}")
+    del m; torch.cuda.empty_cache()
+
+    # --- the same table for the Goldfish parents and their merges, at the SAME 128-token context
+    gcode = {"nld_Latn": "nld_latn", "spa_Latn": "spa_latn", "ell_Grek": "ell_grek", "pol_Latn": "pol_latn"}[fcode]
+    m_e, tok_e = load_hf("goldfish-models/eng_latn_1000mb", dtype=torch.float32, device=DEV); m_e.eval()
+    SD_E = sd_np(m_e)
+    arms["goldfish_eng_parent"] = eval_model(m_e, tok_e, x_text, MBX)
+    m_x, tok_x = load_hf(f"goldfish-models/{gcode}_1000mb", dtype=torch.float32, device=DEV); m_x.eval()
+    SD_X = sd_np(m_x)
+    arms["goldfish_partner_parent"] = eval_model(m_x, tok_x, x_text, MBX)
+    del m_x; torch.cuda.empty_cache()
+    V = int(m_e.config.vocab_size)
+    vkeys = [k for k in SD_X if k.endswith("wte.weight") or k.endswith("lm_head.weight")]
+    SD_X_V, _cov = AL.remap_vocab_rows(SD_X, tok_e, tok_x, V, keys=vkeys)
+    for k in vkeys:
+        W = np.asarray(SD_X_V[k], float)
+        if W.shape[0] == V:
+            bad = ~np.isfinite(W).all(axis=1); W[bad] = np.asarray(SD_E[k], float)[bad]
+        SD_X_V[k] = W
+    for nm, sd in (("merge_M0_naive", MG.average([SD_E, SD_X])),
+                   ("merge_M1a_vocab", MG.average([SD_E, SD_X_V]))):
+        sd_load(m_e, sd, DEV)
+        arms[nm] = eval_model(m_e, tok_e, x_text, MBX)
+        log(f"  {nm}: {arms[nm]}")
+    del m_e; torch.cuda.empty_cache()
+
+    r = {"set": "bgpt_ceiling", "lang": fcode, "repo": repo, "variant": A.variant,
+         "context_tokens": BLOCK, "n_items_eng": len(MB_ENG), "n_items_x": len(MBX),
+         "arms": arms}
+    fh.write(json.dumps(r) + "\n"); fh.flush()
+fh.close()
+log("DONE bgpt")

code/check_alignment_health.py

@@ -0,0 +1,88 @@
+"""Sanity: is the alignment actually FUNCTION-PRESERVING?
+
+Every M1 rung is only meaningful if g.th_B computes exactly what th_B computes. A permutation of the
+residual basis, of the free MLP hidden axis and of the attention heads is exact in theory; a bug in
+applying it produces a plausible-looking state dict whose merges are quietly garbage. This checks it
+empirically on both substrates: evaluate the parent, then evaluate the aligned parent, and compare.
+An orthogonal map is NOT expected to be exact (it does not commute with the elementwise LayerNorm
+gain), so its drift is reported as a magnitude, not as a pass/fail."""
+import sys, json, glob
+sys.path.insert(0, "/root/compose-audit")
+from common import *
+import gpt2_align as G2
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from mergeschool.core.models import load_hf
+from set4_goldfish_lib import sent_acts
+
+DEV = "cuda"
+out = {}
+
+
+def neox_head_match(sd_a, sd_b, d, nh, nl):
+    hd, perms = d // nh, {}
+    for L in range(nl):
+        qk = f"gpt_neox.layers.{L}.attention.query_key_value.weight"
+        de = f"gpt_neox.layers.{L}.attention.dense.weight"
+        if qk not in sd_a: continue
+        Aq = np.asarray(sd_a[qk], float).reshape(nh, 3 * hd, d)
+        Bq = np.asarray(sd_b[qk], float).reshape(nh, 3 * hd, d)
+        Ad = np.asarray(sd_a[de], float).reshape(d, nh, hd)
+        Bd = np.asarray(sd_b[de], float).reshape(d, nh, hd)
+        perms[L] = AL._assignment(np.einsum("ixy,jxy->ij", Aq, Bq) + np.einsum("xiy,xjy->ij", Ad, Bd))
+    return perms
+
+
+def neox_apply_head(sd, perms, d, nh):
+    hd, o = d // nh, dict(sd)
+    for L, h in perms.items():
+        qk = f"gpt_neox.layers.{L}.attention.query_key_value.weight"
+        qb = f"gpt_neox.layers.{L}.attention.query_key_value.bias"
+        de = f"gpt_neox.layers.{L}.attention.dense.weight"
+        o[qk] = np.asarray(sd[qk], float).reshape(nh, 3 * hd, d)[h].reshape(3 * d, d)
+        if qb in sd: o[qb] = np.asarray(sd[qb], float).reshape(nh, 3 * hd)[h].reshape(3 * d)
+        o[de] = np.asarray(sd[de], float).reshape(d, nh, hd)[:, h].reshape(d, d)
+    return o
+
+
+# ---------------- SET 1 / GPTNeoX
+tok = AutoTokenizer.from_pretrained("EleutherAI/pythia-14m")
+blocks = make_blocks(tok, flores_lines("eng_Latn"), block=512, max_blocks=24)
+ma = AutoModelForCausalLM.from_pretrained("EleutherAI/pythia-14m-seed1", dtype=torch.float32).to(DEV).eval()
+mb = AutoModelForCausalLM.from_pretrained("EleutherAI/pythia-14m-seed2", dtype=torch.float32).to(DEV).eval()
+D, NH, NL = ma.config.hidden_size, ma.config.num_attention_heads, ma.config.num_hidden_layers
+sa, sb = sd_np(ma), sd_np(mb)
+aa, ab = capture_acts(ma, blocks, DEV), capture_acts(mb, blocks, DEV)
+base = nll_nats(mb, blocks, DEV, bs=16)
+res = {}
+for method in ("permutation", "orthogonal"):
+    sd, info = AL.align_weights_full(sa, sb, D, acts_a=aa, acts_b=ab, n_heads=None,
+                                     method=method, strict=True, accept_each=False)
+    sd_load(mb, sd, DEV); res[f"{method}_residual+mlp"] = nll_nats(mb, blocks, DEV, bs=16) - base
+    if method == "permutation":
+        hp = neox_head_match(sa, sd, D, NH, NL)
+        sd2 = neox_apply_head(sd, hp, D, NH)
+        sd_load(mb, sd2, DEV); res["permutation_full(+heads)"] = nll_nats(mb, blocks, DEV, bs=16) - base
+sd_load(mb, sb, DEV)
+out["set1_pythia14m"] = {"parent_nll": base, "nll_change_after_alignment": res}
+print("SET1", json.dumps(out["set1_pythia14m"], indent=1))
+del ma, mb; torch.cuda.empty_cache()
+
+# ---------------- SET 4 / GPT-2 (Conv1D)
+m_e, tok_e = load_hf("goldfish-models/eng_latn_1000mb", dtype=torch.float32, device=DEV); m_e.eval()
+m_x, tok_x = load_hf("goldfish-models/nld_latn_1000mb", dtype=torch.float32, device=DEV); m_x.eval()
+D2, NH2 = m_e.config.n_embd, m_e.config.n_head
+lines_e = flores_lines("eng_Latn")[:300]; lines_x = flores_lines("nld_Latn")[:300]
+ae = sent_acts(m_e, tok_e, lines_e, DEV); ax = sent_acts(m_x, tok_x, lines_x, DEV)
+sde, sdx = sd_np(m_e), sd_np(m_x)
+bl = make_blocks(tok_x, lines_x, block=512, max_blocks=16)
+b0 = nll_nats(m_x, bl, DEV, bs=8)
+res2 = {}
+for tag, sd in (("perm_residual_only", G2.apply_resid(sdx, D2, perm=AL.residual_basis_map(ae, ax, "permutation")[1])),
+                ("mlp_only", G2.apply_mlp(sdx, G2.mlp_match(sde, sdx))),
+                ("heads_only", G2.apply_head(sdx, G2.head_match(sde, sdx, D2, NH2), D2, NH2)),
+                ("perm_full", G2.align_full(sde, sdx, D2, NH2, ae, ax, "permutation", accept_each=False)[0]),
+                ("orth_full", G2.align_full(sde, sdx, D2, NH2, ae, ax, "orthogonal", accept_each=False)[0])):
+    sd_load(m_x, sd, DEV); res2[tag] = nll_nats(m_x, bl, DEV, bs=8) - b0
+out["set4_goldfish_nld"] = {"parent_nll": b0, "nll_change_after_alignment": res2}
+print("SET4", json.dumps(out["set4_goldfish_nld"], indent=1))
+json.dump(out, open("/root/compose-audit/results/alignment_health.json", "w"), indent=1)

code/make_report.py

@@ -93,20 +93,32 @@ if set1:
     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])
         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())
+        dd[sz] = (len(sub), d0.mean(), float(np.mean(1 - dp / d0) * 100), dp.mean(),
+                  float(np.mean(1 - db / d0) * 100))
     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.")
+    _abs = {sz: dd[sz][3] + float(np.mean([r["floor"] for r in set1 if r["size"] == sz])) for sz in sizes}
+    _unif = math.log(50304)
+    _above = [sz for sz in sizes if _abs[sz] > _unif]
     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"usable model.** The exactly function-preserving permutation rung 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.")
+              f"{' · '.join(f'{dd[sz][3]:.1f}' for sz in sizes)} nats/token above the better parent, "
+              f"i.e. an absolute {' · '.join(f'{_abs[sz]:.1f}' for sz in sizes)} nats/token against "
+              f"parent floors of 3.0–4.4 and a uniform-over-vocabulary reference of {_unif:.1f}. "
+              f"At {', '.join(_above)} the aligned merge is still *worse than predicting uniformly "
+              f"over the vocabulary*; at the larger sizes it is below that line but still 2–3x the "
+              f"parent's loss. (A Procrustes rung is also reported, but it is **not** "
+              f"function-preserving on LayerNorm transformers — see Validation — so the coordinate "
+              f"claim rests on the permutation rung.)")
     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"→ {sizes[-1]}: {dd[sizes[-1]][2]:.0f}% on the exact rung) 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 "
@@ -181,10 +193,11 @@ if set1:
    destroyed one. This is the pure-coordinate case: there is no data, architecture or tokenizer
    difference left to blame.
 2. **Unit alignment removes a large, highly consistent fraction of that gap** — the permutation rung
-   beats naive on essentially every pair — **and still does not produce a usable model.** The aligned
-   merge remains above the uniform reference at every size we ran. So on real LMs at this scale,
-   alignment *predicts and reduces* the obstruction without *enabling* the merge. Reporting the
-   reduction as "merging works once you align" would be wrong.
+   beats naive on essentially every pair — **and still does not produce a usable model.** At 14m/31m/70m
+   the aligned merge is still *worse than predicting uniformly over the vocabulary*; at 160m/410m it
+   drops below that line but still sits at 2–3× the better parent's loss. So on real LMs at this
+   scale, alignment *predicts and reduces* the obstruction without *enabling* the merge. Reporting
+   the reduction as "merging works once you align" would be wrong.
 3. **Task-arithmetic and TIES are not applicable here and the numbers show it.** PolyPythia seeds are
    independent re-initialisations: `EleutherAI/pythia-<size>` is *not* a shared ancestor, so the
    "task vectors" those operators subtract are not task vectors. Their rows are reported only to
@@ -193,6 +206,45 @@ if set1:
    interior t that beats the better parent, aligned or not.
 """)
 
+# ---------------- alignment health
+try:
+    _ah = json.load(open(f"{R}/alignment_health.json"))
+except Exception:
+    _ah = None
+if _ah:
+    L.append("""
+### Validation: is the alignment actually function-preserving? (One rung is not.)
+
+Every M1 rung is only an *alignment* if `g.θ_B` computes exactly what `θ_B` computes. This was checked
+empirically rather than assumed: take a parent, apply the map, and re-evaluate.
+
+""")
+    body = []
+    for sub_, rec in _ah.items():
+        for k, v in rec["nll_change_after_alignment"].items():
+            body.append([sub_, k, f"{v:+.3e}" if abs(v) < 1e-2 else f"{v:+.3f}",
+                         "EXACT" if abs(v) < 1e-3 else ("negligible" if abs(v) < 0.1 else "**NOT function-preserving**")])
+    L.append(md_table(["substrate", "map", "change in the parent's nats/token", "verdict"], body))
+    L.append("""
+**The permutation family is exact** — residual basis, free MLP hidden axis and attention heads, on
+both architectures, to float32 noise. Those rungs are genuine alignments.
+
+**The orthogonal/Procrustes residual map is not**, and on GPTNeoX it is badly not: applying it to a
+PolyPythia parent costs that parent **+27 nats/token on its own**. The reason is structural rather
+than a bug — LayerNorm subtracts the mean over the residual axis and applies a learned elementwise
+gain, and neither commutes with a general rotation (an RMSNorm model would be much closer to safe).
+On the GPT-2 Goldfish models the same map costs only +0.07 nats/token, so the defect is
+architecture-specific in magnitude.
+
+**Consequence for the tables.** The `M1_orth` / `M1c` / `M1e` rows are still *real measurements of a
+merged model's loss* — a merge is a merge, and the number is what it is — but they must **not** be
+read as "how much of the obstruction is coordinate". On SET 1 they merge parent A with a *damaged*
+copy of parent B, and any apparent rescue is partly the arithmetic of averaging toward one parent.
+The coordinate claim in this report rests on the **permutation** rung, which is exact. Where the two
+disagree, believe the permutation rung. This is flagged again at every table that contains an
+orthogonal row.
+""")
+
 if len(mdtabs) >= 3:
     L.append("\n### The scale trend — alignment's coordinate rescue WEAKENS with model size\n")
     tr = []
@@ -214,8 +266,12 @@ if len(mdtabs) >= 3:
                        "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
+Read the **permutation** column: it is the one that is exactly function-preserving (see Validation
+above). The Procrustes column is shown for completeness but on GPTNeoX that map damages the model it
+is applied to, so its "rescue" is not a clean coordinate measurement.
+
+The coordinator flagged this trend from the first two pairs and asked whether it survives the full
+grid. **It does, monotonically, across every size we ran, on the exact rung alone.** 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

code/publish.py

@@ -0,0 +1,35 @@
+"""Publish the audit as a single commit (upload_folder), so repeated republishes do not
+burn the Hub's per-hour commit budget the way a file-at-a-time loop does."""
+import os, sys, shutil, glob, time
+sys.path.insert(0, "/root/mergeability/src")
+from huggingface_hub import HfApi, create_repo
+REPO = "Mergeability-2/compose-audit"
+ROOT = "/root/compose-audit"
+STAGE = "/root/compose-audit/.stage"
+
+api = HfApi()
+create_repo(REPO, repo_type="dataset", exist_ok=True)
+if os.path.isdir(STAGE):
+    shutil.rmtree(STAGE)
+os.makedirs(f"{STAGE}/results", exist_ok=True)
+os.makedirs(f"{STAGE}/figs", exist_ok=True)
+os.makedirs(f"{STAGE}/code", exist_ok=True)
+for fp in glob.glob(f"{ROOT}/results/*"):
+    if os.path.isfile(fp):
+        shutil.copy(fp, f"{STAGE}/results/{os.path.basename(fp)}")
+for fp in glob.glob(f"{ROOT}/figs/*.png"):
+    shutil.copy(fp, f"{STAGE}/figs/{os.path.basename(fp)}")
+for fp in glob.glob(f"{ROOT}/*.py") + glob.glob(f"{ROOT}/*.sh"):
+    shutil.copy(fp, f"{STAGE}/code/{os.path.basename(fp)}")
+shutil.copy(f"{ROOT}/RESULTS_COMPOSE_AUDIT.md", f"{STAGE}/RESULTS_COMPOSE_AUDIT.md")
+hdr = ("---\nlicense: apache-2.0\ntags:\n- model-merging\n- alignment\n- polypythia\n- goldfish\n"
+       "- multilingual\n- blimp\n---\n\n")
+with open(f"{ROOT}/RESULTS_COMPOSE_AUDIT.md", encoding="utf-8") as f:
+    body = f.read()
+with open(f"{STAGE}/README.md", "w", encoding="utf-8") as f:
+    f.write(hdr + body)
+
+api.upload_folder(folder_path=STAGE, repo_id=REPO, repo_type="dataset",
+                  commit_message=f"compose-audit refresh {time.strftime('%Y-%m-%d %H:%M UTC')}")
+shutil.rmtree(STAGE, ignore_errors=True)
+print("URL: https://huggingface.co/datasets/" + REPO)

code/run_abl.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+source /root/.ms_hf_env
+export HF_HOME=/root/hf_cache_brainalign
+export OMP_NUM_THREADS=8 MKL_NUM_THREADS=8 OPENBLAS_NUM_THREADS=8 NUMEXPR_NUM_THREADS=8
+P=/root/venvs/mergeability/bin/python
+CUDA_VISIBLE_DEVICES=0 $P /root/compose-audit/set1_polypythia.py --size 160m-weight --base pythia-160m \
+   --seeds 1,2,3 --blocks 32 --barrier_n 5 --tag abl >> /root/compose-audit/logs/abl.log 2>&1
+CUDA_VISIBLE_DEVICES=0 $P /root/compose-audit/set1_polypythia.py --size 160m-data --base pythia-160m \
+   --seeds 1,2,3 --blocks 32 --barrier_n 5 --tag abl >> /root/compose-audit/logs/abl.log 2>&1
+echo ABL_DONE >> /root/compose-audit/logs/abl.log

code/run_blimp.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+source /root/.ms_hf_env
+export HF_HOME=/root/hf_cache_brainalign
+export OMP_NUM_THREADS=8 MKL_NUM_THREADS=8 OPENBLAS_NUM_THREADS=8 NUMEXPR_NUM_THREADS=8
+P=/root/venvs/mergeability/bin/python
+G=${GPU:-1}
+CUDA_VISIBLE_DEVICES=$G $P /root/compose-audit/set1_blimp.py --size 14m --n_per_paradigm 200 \
+  >> /root/compose-audit/logs/blimp_14m.log 2>&1
+CUDA_VISIBLE_DEVICES=$G $P /root/compose-audit/set1_blimp.py --size 70m --n_per_paradigm 200 --bs 96 \
+  >> /root/compose-audit/logs/blimp_70m.log 2>&1
+CUDA_VISIBLE_DEVICES=$G $P /root/compose-audit/set1_blimp.py --size 160m --n_per_paradigm 150 --bs 64 --blocks 32 \
+  >> /root/compose-audit/logs/blimp_160m.log 2>&1
+echo BLIMP_ALL_DONE >> /root/compose-audit/logs/blimp_14m.log

code/run_repair.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+source /root/.ms_hf_env
+export HF_HOME=/root/hf_cache_brainalign
+export OMP_NUM_THREADS=8 MKL_NUM_THREADS=8 OPENBLAS_NUM_THREADS=8 NUMEXPR_NUM_THREADS=8
+P=/root/venvs/mergeability/bin/python
+CUDA_VISIBLE_DEVICES=1 $P /root/compose-audit/set1_repair.py --size 14m --n_per_paradigm 200 >> /root/compose-audit/logs/repair_14m.log 2>&1
+CUDA_VISIBLE_DEVICES=1 $P /root/compose-audit/set1_repair.py --size 70m --n_per_paradigm 200 --bs 12 >> /root/compose-audit/logs/repair_70m.log 2>&1
+CUDA_VISIBLE_DEVICES=1 $P /root/compose-audit/set1_repair.py --size 160m --n_per_paradigm 150 --bs 8 --blocks 32 >> /root/compose-audit/logs/repair_160m.log 2>&1
+echo REPAIR_ALL_DONE >> /root/compose-audit/logs/repair_14m.log

code/run_rev_after.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+source /root/.ms_hf_env
+export HF_HOME=/root/goldfish-alignment/cache/hf
+export OMP_NUM_THREADS=8 MKL_NUM_THREADS=8 OPENBLAS_NUM_THREADS=8
+until grep -q SET4B_DONE /root/compose-audit/logs/set4b.log 2>/dev/null; do sleep 20; done
+CUDA_VISIBLE_DEVICES=0 /root/venvs/mergeability/bin/python /root/compose-audit/set4_reverse.py --n_sent 500 \
+  >> /root/compose-audit/logs/set4_rev.log 2>&1
+echo SET4_REV_DONE >> /root/compose-audit/logs/set4_rev.log

code/run_set1.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+source /root/.ms_hf_env
+export HF_HOME=/root/hf_cache_brainalign
+export OMP_NUM_THREADS=8 MKL_NUM_THREADS=8 OPENBLAS_NUM_THREADS=8 NUMEXPR_NUM_THREADS=8
+size=$1; gpu=$2; shift 2
+CUDA_VISIBLE_DEVICES=$gpu /root/venvs/mergeability/bin/python /root/compose-audit/set1_polypythia.py --size $size "$@" \
+  >> /root/compose-audit/logs/set1_$size.log 2>&1

code/run_set4.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+source /root/.ms_hf_env
+export HF_HOME=/root/goldfish-alignment/cache/hf
+export OMP_NUM_THREADS=8 MKL_NUM_THREADS=8 OPENBLAS_NUM_THREADS=8 NUMEXPR_NUM_THREADS=8
+CUDA_VISIBLE_DEVICES=3 /root/venvs/mergeability/bin/python /root/compose-audit/set4_goldfish.py "$@" \
+  >> /root/compose-audit/logs/set4.log 2>&1

code/run_set4b.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+source /root/.ms_hf_env
+export HF_HOME=/root/goldfish-alignment/cache/hf
+export OMP_NUM_THREADS=8 MKL_NUM_THREADS=8 OPENBLAS_NUM_THREADS=8 NUMEXPR_NUM_THREADS=8
+P=/root/venvs/mergeability/bin/python
+CUDA_VISIBLE_DEVICES=0 $P /root/compose-audit/set4_multiblimp.py --max_items 1200 >> /root/compose-audit/logs/set4_mb.log 2>&1
+rm -f /root/compose-audit/results/set4_goldfish.jsonl
+CUDA_VISIBLE_DEVICES=0 $P /root/compose-audit/set4_goldfish.py --n_sent 500 >> /root/compose-audit/logs/set4b.log 2>&1
+echo SET4B_DONE >> /root/compose-audit/logs/set4b.log
+# (reverse direction is launched by run_rev_after.sh)
+#                                                                        

code/set1_blimp.py

@@ -0,0 +1,166 @@
+"""ACCURACY, not likelihood: does the Δfloor rescue transfer to BLiMP?
+
+The audit's sharpest point is that "recovery is not success" -- a likelihood rescue has not been
+shown to transfer to benchmark accuracy. PolyPythia parents are English LMs, so BLiMP is directly
+applicable to SET 1's merges. Scoring: sum log p over the sentence (all tokens after the first);
+a paradigm item is correct when the grammatical sentence scores higher. Chance = 50%."""
+import os, sys, json, time, glob, itertools, argparse, gc
+sys.path.insert(0, "/root/compose-audit")
+from common import *
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import pyarrow.parquet as pq
+
+ap = argparse.ArgumentParser()
+ap.add_argument("--size", default="14m")
+ap.add_argument("--seeds", default="1,2,3,4,5,6,7,8,9")
+ap.add_argument("--n_per_paradigm", type=int, default=200)
+ap.add_argument("--bs", type=int, default=128)
+ap.add_argument("--acts_rows", type=int, default=2048)
+ap.add_argument("--blocks", type=int, default=48)
+A = ap.parse_args()
+SEEDS = [int(s) for s in A.seeds.split(",")]
+OUT = f"/root/compose-audit/results/blimp_{A.size}.jsonl"
+DEV = "cuda"
+BLIMP = glob.glob("/root/hf_cache_brainalign/hub/datasets--nyu-mll--blimp/snapshots/*/")[0]
+
+
+def log(*a):
+    print(f"[{time.strftime('%H:%M:%S')}]", *a, flush=True)
+
+
+# reuse SET 1's aligners
+import importlib.util
+spec = importlib.util.spec_from_file_location("s1", "/root/compose-audit/set1_polypythia.py")
+
+def neox_head_match(sd_a, sd_b, d, nh, nl):
+    hd, perms = d // nh, {}
+    for L in range(nl):
+        qk = f"gpt_neox.layers.{L}.attention.query_key_value.weight"
+        de = f"gpt_neox.layers.{L}.attention.dense.weight"
+        if qk not in sd_a: continue
+        Aq = np.asarray(sd_a[qk], float).reshape(nh, 3 * hd, d)
+        Bq = np.asarray(sd_b[qk], float).reshape(nh, 3 * hd, d)
+        g = np.einsum("ixy,jxy->ij", Aq, Bq)
+        Ad = np.asarray(sd_a[de], float).reshape(d, nh, hd)
+        Bd = np.asarray(sd_b[de], float).reshape(d, nh, hd)
+        perms[L] = AL._assignment(g + np.einsum("xiy,xjy->ij", Ad, Bd))
+    return perms
+
+
+def neox_apply_head(sd, perms, d, nh):
+    hd, out = d // nh, dict(sd)
+    for L, h in perms.items():
+        qk = f"gpt_neox.layers.{L}.attention.query_key_value.weight"
+        qb = f"gpt_neox.layers.{L}.attention.query_key_value.bias"
+        de = f"gpt_neox.layers.{L}.attention.dense.weight"
+        out[qk] = np.asarray(sd[qk], float).reshape(nh, 3 * hd, d)[h].reshape(3 * d, d)
+        if qb in sd: out[qb] = np.asarray(sd[qb], float).reshape(nh, 3 * hd)[h].reshape(3 * d)
+        out[de] = np.asarray(sd[de], float).reshape(d, nh, hd)[:, h].reshape(d, d)
+    return out
+
+
+def align_full(sd_a, sd_b, d, aa, ab, nh, nl, method):
+    sd, info = AL.align_weights_full(sd_a, sd_b, d, acts_a=aa, acts_b=ab, n_heads=None,
+                                     method=method, strict=True, accept_each=True)
+    hp = neox_head_match(sd_a, sd, d, nh, nl)
+    if hp:
+        cand = neox_apply_head(sd, hp, d, nh)
+        if AL.block_normalised_distance(sd_a, cand) <= AL.block_normalised_distance(sd_a, sd):
+            sd = cand
+    return sd
+
+
+# ------------------------------------------------------------------ BLiMP
+def load_blimp(tok, n_per):
+    items = []
+    for d in sorted(glob.glob(BLIMP + "*/")):
+        name = os.path.basename(d.rstrip("/"))
+        f = glob.glob(d + "*.parquet")
+        if not f: continue
+        t = pq.read_table(f[0]).to_pydict()
+        good, bad = t["sentence_good"][:n_per], t["sentence_bad"][:n_per]
+        items.append((name, good, bad))
+    return items
+
+
+def encode(tok, sents, maxlen=48):
+    enc = tok(sents, return_tensors="pt", padding=True, truncation=True, max_length=maxlen)
+    return enc["input_ids"], enc["attention_mask"]
+
+
+@torch.no_grad()
+def score(model, ids, am, dev, bs=128):
+    out = []
+    for i in range(0, ids.shape[0], bs):
+        x, m = ids[i:i + bs].to(dev), am[i:i + bs].to(dev)
+        lp = torch.log_softmax(model(x, attention_mask=m).logits.float()[:, :-1], -1)
+        tgt = x[:, 1:]
+        tokl = lp.gather(-1, tgt.unsqueeze(-1)).squeeze(-1) * m[:, 1:].float()
+        out.append(tokl.sum(1).cpu())
+    return torch.cat(out).numpy()
+
+
+tok = AutoTokenizer.from_pretrained(f"EleutherAI/pythia-{A.size}")
+if tok.pad_token is None: tok.pad_token = tok.eos_token
+PARA = load_blimp(tok, A.n_per_paradigm)
+log(f"BLiMP paradigms={len(PARA)} items/paradigm={len(PARA[0][1])}")
+ENC = [(n, encode(tok, g), encode(tok, b)) for n, g, b in PARA]
+
+lines = flores_lines("eng_Latn")
+blocks = make_blocks(tok, lines, block=512, max_blocks=A.blocks)
+shell = AutoModelForCausalLM.from_pretrained(f"EleutherAI/pythia-{A.size}-seed{SEEDS[0]}",
+                                             dtype=torch.float32).to(DEV).eval()
+cfg = shell.config
+D, NH, NL = cfg.hidden_size, cfg.num_attention_heads, cfg.num_hidden_layers
+
+
+def blimp_acc(sd):
+    sd_load(shell, sd, DEV)
+    per, tot, cor = {}, 0, 0
+    for name, (gi, gm), (bi, bm) in ENC:
+        sg = score(shell, gi, gm, DEV, bs=A.bs)
+        sb = score(shell, bi, bm, DEV, bs=A.bs)
+        c = int((sg > sb).sum()); per[name] = c / len(sg); cor += c; tot += len(sg)
+    return cor / tot, per
+
+
+SDS, ACTS, PACC = {}, {}, {}
+for s in SEEDS:
+    m = AutoModelForCausalLM.from_pretrained(f"EleutherAI/pythia-{A.size}-seed{s}", dtype=torch.float32).to(DEV).eval()
+    SDS[s] = sd_np(m); ACTS[s] = capture_acts(m, blocks, DEV, n_rows=A.acts_rows, bs=16)
+    del m; torch.cuda.empty_cache()
+    a, _ = blimp_acc(SDS[s]); PACC[s] = a
+    log(f"  seed{s} BLiMP={a:.4f}")
+
+done = set()
+if os.path.exists(OUT):
+    for l in open(OUT):
+        try: done.add(tuple(json.loads(l)["pair"]))
+        except Exception: pass
+fh = open(OUT, "a")
+for a, b in itertools.combinations(SEEDS, 2):
+    if (a, b) in done: continue
+    t0 = time.time()
+    sa, sb = SDS[a], SDS[b]
+    sbp = align_full(sa, sb, D, ACTS[a], ACTS[b], NH, NL, "permutation")
+    sbo = align_full(sa, sb, D, ACTS[a], ACTS[b], NH, NL, "orthogonal")
+    rungs = {"M0_naive_avg": MG.average([sa, sb]), "M1_perm_avg": MG.average([sa, sbp]),
+             "M1_orth_avg": MG.average([sa, sbo])}
+    res = {}
+    for k, sd in rungs.items():
+        acc, per = blimp_acc(sd)
+        res[k] = {"blimp_acc": acc, "per_paradigm": per}
+    r = {"set": "set1_blimp", "size": A.size, "pair": [a, b],
+         "metric": "BLiMP accuracy (chance=0.5) -- ACCURACY, not likelihood",
+         "n_per_paradigm": A.n_per_paradigm, "n_paradigms": len(ENC),
+         "parent_acc": {"a": PACC[a], "b": PACC[b]}, "ceiling": max(PACC[a], PACC[b]),
+         "rungs": {k: {"blimp_acc": v["blimp_acc"],
+                       "delta_vs_best_parent": v["blimp_acc"] - max(PACC[a], PACC[b])} for k, v in res.items()},
+         "per_paradigm": {k: v["per_paradigm"] for k, v in res.items()},
+         "secs": time.time() - t0}
+    fh.write(json.dumps(r) + "\n"); fh.flush()
+    log(f"pair {a},{b} ceil={r['ceiling']:.4f} M0={res['M0_naive_avg']['blimp_acc']:.4f} "
+        f"M1p={res['M1_perm_avg']['blimp_acc']:.4f} M1o={res['M1_orth_avg']['blimp_acc']:.4f} ({r['secs']:.0f}s)")
+    del rungs, sbp, sbo; gc.collect()
+fh.close()
+log("DONE blimp", A.size)

code/set1_repair.py

@@ -0,0 +1,217 @@
+"""Did we try hard enough to make merging work?
+
+The obvious objection to SET 1's negative result is that a plain average of aligned weights is a weak
+merge: averaging two networks halves the variance of every pre-activation, and REPAIR (Jordan et al.,
+ICLR 2023) shows that restoring those first- and second-order statistics recovers most of the
+remaining barrier on vision nets. This adds that rung, training-free: after the permutation-aligned
+average, walk the layers in order and affine-correct each Linear's pre-activations so their per-unit
+mean and std match the average of the two parents' own statistics on the same corpus.
+
+Rungs: M0 naive · M1 permutation-aligned average · M4 = M1 + REPAIR · M5 = M0 + REPAIR.
+Metrics: Δfloor in nats/token (FLORES-200 eng devtest) AND BLiMP accuracy, on the same merges."""
+import os, sys, json, time, glob, itertools, argparse, gc, csv
+sys.path.insert(0, "/root/compose-audit")
+from common import *
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import pyarrow.parquet as pq
+
+ap = argparse.ArgumentParser()
+ap.add_argument("--size", default="14m")
+ap.add_argument("--seeds", default="1,2,3,4,5,6,7,8,9")
+ap.add_argument("--blocks", type=int, default=48)
+ap.add_argument("--bs", type=int, default=16)
+ap.add_argument("--n_per_paradigm", type=int, default=200)
+ap.add_argument("--acts_rows", type=int, default=2048)
+A = ap.parse_args()
+SEEDS = [int(s) for s in A.seeds.split(",")]
+OUT = f"/root/compose-audit/results/repair_{A.size}.jsonl"
+DEV = "cuda"
+BLIMP = glob.glob("/root/hf_cache_brainalign/hub/datasets--nyu-mll--blimp/snapshots/*/")[0]
+
+
+def log(*a):
+    print(f"[{time.strftime('%H:%M:%S')}]", *a, flush=True)
+
+
+def neox_head_match(sd_a, sd_b, d, nh, nl):
+    hd, perms = d // nh, {}
+    for L in range(nl):
+        qk = f"gpt_neox.layers.{L}.attention.query_key_value.weight"
+        de = f"gpt_neox.layers.{L}.attention.dense.weight"
+        if qk not in sd_a: continue
+        Aq = np.asarray(sd_a[qk], float).reshape(nh, 3 * hd, d)
+        Bq = np.asarray(sd_b[qk], float).reshape(nh, 3 * hd, d)
+        g = np.einsum("ixy,jxy->ij", Aq, Bq)
+        Ad = np.asarray(sd_a[de], float).reshape(d, nh, hd)
+        Bd = np.asarray(sd_b[de], float).reshape(d, nh, hd)
+        perms[L] = AL._assignment(g + np.einsum("xiy,xjy->ij", Ad, Bd))
+    return perms
+
+
+def neox_apply_head(sd, perms, d, nh):
+    hd, out = d // nh, dict(sd)
+    for L, h in perms.items():
+        qk = f"gpt_neox.layers.{L}.attention.query_key_value.weight"
+        qb = f"gpt_neox.layers.{L}.attention.query_key_value.bias"
+        de = f"gpt_neox.layers.{L}.attention.dense.weight"
+        out[qk] = np.asarray(sd[qk], float).reshape(nh, 3 * hd, d)[h].reshape(3 * d, d)
+        if qb in sd: out[qb] = np.asarray(sd[qb], float).reshape(nh, 3 * hd)[h].reshape(3 * d)
+        out[de] = np.asarray(sd[de], float).reshape(d, nh, hd)[:, h].reshape(d, d)
+    return out
+
+
+def align_perm(sd_a, sd_b, d, aa, ab, nh, nl):
+    sd, _ = AL.align_weights_full(sd_a, sd_b, d, acts_a=aa, acts_b=ab, n_heads=None,
+                                  method="permutation", strict=True, accept_each=True)
+    hp = neox_head_match(sd_a, sd, d, nh, nl)
+    if hp:
+        cand = neox_apply_head(sd, hp, d, nh)
+        if AL.block_normalised_distance(sd_a, cand) <= AL.block_normalised_distance(sd_a, sd):
+            sd = cand
+    return sd
+
+
+# ------------------------------------------------------------------ REPAIR
+TARGETS = ("mlp.dense_h_to_4h", "attention.query_key_value")
+
+
+@torch.no_grad()
+def preact_stats(model, blocks, dev, bs, nl):
+    """{(layer, target): (mean, std)} of each Linear's OUTPUT (= pre-activation), per unit."""
+    acc = {}
+    hs = []
+
+    def mk(key):
+        def hook(mod, inp, out):
+            o = out.detach().float().reshape(-1, out.shape[-1])
+            s = acc.setdefault(key, [0.0, None, None])
+            s[0] += o.shape[0]
+            s[1] = o.sum(0) if s[1] is None else s[1] + o.sum(0)
+            s[2] = (o * o).sum(0) if s[2] is None else s[2] + (o * o).sum(0)
+        return hook
+
+    for L in range(nl):
+        blk = model.gpt_neox.layers[L]
+        hs.append(blk.mlp.dense_h_to_4h.register_forward_hook(mk((L, "mlp.dense_h_to_4h"))))
+        hs.append(blk.attention.query_key_value.register_forward_hook(mk((L, "attention.query_key_value"))))
+    for i in range(0, blocks.shape[0], bs):
+        model(blocks[i:i + bs].to(dev))
+    for h in hs: h.remove()
+    out = {}
+    for k, (n, s1, s2) in acc.items():
+        m = s1 / n
+        v = (s2 / n - m * m).clamp_min(1e-12)
+        out[k] = (m.cpu().numpy().astype(np.float64), v.sqrt().cpu().numpy().astype(np.float64))
+    return out
+
+
+def repair(sd_merged, stats_a, stats_b, shell, blocks, dev, bs, nl):
+    """Walk layers in order; after fixing layers < L the inputs to layer L are already corrected, so
+    layer L's own statistics are re-measured before it is corrected. Affine correction on the
+    Linear's weight/bias, so the model stays exactly a model of the same architecture."""
+    sd = {k: np.array(v, dtype=np.float64, copy=True) for k, v in sd_merged.items()}
+    for L in range(nl):
+        sd_load(shell, sd, dev)
+        cur = preact_stats(shell, blocks, dev, bs, nl)
+        for t in TARGETS:
+            mu_t = 0.5 * (stats_a[(L, t)][0] + stats_b[(L, t)][0])
+            sd_t = 0.5 * (stats_a[(L, t)][1] + stats_b[(L, t)][1])
+            mu_m, sd_m = cur[(L, t)]
+            g = sd_t / np.maximum(sd_m, 1e-8)
+            wk, bk = f"gpt_neox.layers.{L}.{t}.weight", f"gpt_neox.layers.{L}.{t}.bias"
+            sd[wk] = sd[wk] * g[:, None]
+            sd[bk] = (sd[bk] - mu_m) * g + mu_t
+    return sd
+
+
+# ------------------------------------------------------------------ BLiMP
+def load_blimp(n_per):
+    out = []
+    for d in sorted(glob.glob(BLIMP + "*/")):
+        f = glob.glob(d + "*.parquet")
+        if not f: continue
+        t = pq.read_table(f[0]).to_pydict()
+        out.append((os.path.basename(d.rstrip("/")), t["sentence_good"][:n_per], t["sentence_bad"][:n_per]))
+    return out
+
+
+tok = AutoTokenizer.from_pretrained(f"EleutherAI/pythia-{A.size}")
+if tok.pad_token is None: tok.pad_token = tok.eos_token
+
+
+def enc(sents, maxlen=48):
+    e = tok(sents, return_tensors="pt", padding=True, truncation=True, max_length=maxlen)
+    return e["input_ids"], e["attention_mask"]
+
+
+ENC = [(n, enc(g), enc(b)) for n, g, b in load_blimp(A.n_per_paradigm)]
+lines = flores_lines("eng_Latn")
+blocks = make_blocks(tok, lines, block=512, max_blocks=A.blocks)
+shell = AutoModelForCausalLM.from_pretrained(f"EleutherAI/pythia-{A.size}-seed{SEEDS[0]}",
+                                             dtype=torch.float32).to(DEV).eval()
+cfg = shell.config
+D, NH, NL = cfg.hidden_size, cfg.num_attention_heads, cfg.num_hidden_layers
+log(f"size={A.size} d={D} heads={NH} layers={NL} blimp_paradigms={len(ENC)}")
+
+
+@torch.no_grad()
+def bscore(ids, am):
+    o = []
+    for i in range(0, ids.shape[0], 128):
+        x, m = ids[i:i + 128].to(DEV), am[i:i + 128].to(DEV)
+        lp = torch.log_softmax(shell(x, attention_mask=m).logits.float()[:, :-1], -1)
+        o.append((lp.gather(-1, x[:, 1:].unsqueeze(-1)).squeeze(-1) * m[:, 1:].float()).sum(1).cpu())
+    return torch.cat(o).numpy()
+
+
+def evaluate(sd):
+    sd_load(shell, sd, DEV)
+    nll = nll_nats(shell, blocks, DEV, bs=A.bs)
+    cor = tot = 0
+    for name, (gi, gm), (bi, bm) in ENC:
+        sg, sb = bscore(gi, gm), bscore(bi, bm)
+        cor += int((sg > sb).sum()); tot += len(sg)
+    return nll, cor / tot
+
+
+SDS, ACTS, PAR, STATS = {}, {}, {}, {}
+for s in SEEDS:
+    m = AutoModelForCausalLM.from_pretrained(f"EleutherAI/pythia-{A.size}-seed{s}", dtype=torch.float32).to(DEV).eval()
+    SDS[s] = sd_np(m); ACTS[s] = capture_acts(m, blocks, DEV, n_rows=A.acts_rows, bs=A.bs)
+    del m; torch.cuda.empty_cache()
+    PAR[s] = evaluate(SDS[s])
+    log(f"  seed{s} nll={PAR[s][0]:.4f} blimp={PAR[s][1]:.4f}")
+
+done = set()
+if os.path.exists(OUT):
+    for l in open(OUT):
+        try: done.add(tuple(json.loads(l)["pair"]))
+        except Exception: pass
+fh = open(OUT, "a")
+for a, b in itertools.combinations(SEEDS, 2):
+    if (a, b) in done: continue
+    t0 = time.time()
+    sa, sb = SDS[a], SDS[b]
+    sbp = align_perm(sa, sb, D, ACTS[a], ACTS[b], NH, NL)
+    sd_load(shell, sa, DEV); st_a = preact_stats(shell, blocks, DEV, A.bs, NL)
+    sd_load(shell, sbp, DEV); st_b = preact_stats(shell, blocks, DEV, A.bs, NL)
+    sd_load(shell, sb, DEV); st_braw = preact_stats(shell, blocks, DEV, A.bs, NL)
+    rungs = {"M0_naive_avg": MG.average([sa, sb]), "M1_perm_avg": MG.average([sa, sbp])}
+    rungs["M4_perm_repair"] = repair(rungs["M1_perm_avg"], st_a, st_b, shell, blocks, DEV, A.bs, NL)
+    rungs["M5_naive_repair"] = repair(rungs["M0_naive_avg"], st_a, st_braw, shell, blocks, DEV, A.bs, NL)
+    floor = min(PAR[a][0], PAR[b][0]); ceil = max(PAR[a][1], PAR[b][1])
+    res = {}
+    for k, sd in rungs.items():
+        nll, acc = evaluate(sd)
+        res[k] = {"nll": nll, "delta_floor": nll - floor, "blimp_acc": acc,
+                  "blimp_delta_vs_ceiling": acc - ceil}
+    r = {"set": "set1_repair", "size": A.size, "pair": [a, b], "floor": floor, "blimp_ceiling": ceil,
+         "parent_nll": {"a": PAR[a][0], "b": PAR[b][0]},
+         "parent_blimp": {"a": PAR[a][1], "b": PAR[b][1]}, "rungs": res, "secs": time.time() - t0}
+    fh.write(json.dumps(r) + "\n"); fh.flush()
+    log(f"pair {a},{b} floor={floor:.2f}/ceil={ceil:.3f} | " +
+        " | ".join(f"{k}: {v['delta_floor']:+.2f}n {v['blimp_acc']:.3f}" for k, v in res.items()) +
+        f" ({r['secs']:.0f}s)")
+    del rungs, sbp; gc.collect()
+fh.close()
+log("DONE repair", A.size)

code/set4_goldfish_lib.py

@@ -0,0 +1,22 @@
+"""Shared with set4_goldfish.py: cross-lingual sentence-level activations."""
+import sys
+sys.path.insert(0,"/root/compose-audit")
+from common import *
+
+@torch.no_grad()
+def sent_acts(model, tok, lines, dev, bs=16, maxlen=128):
+    """Mean-pooled per-sentence residual activations, {layer: (n_sent, d)} -- rows are matched
+    ACROSS LANGUAGES by FLORES sentence id, which is what makes a cross-lingual basis map fittable."""
+    outs = None
+    for i in range(0, len(lines), bs):
+        enc = tok(lines[i:i + bs], return_tensors="pt", padding=True, truncation=True, max_length=maxlen)
+        ids = enc["input_ids"].to(dev); am = enc["attention_mask"].to(dev).float()
+        hs = model(ids, attention_mask=enc["attention_mask"].to(dev), output_hidden_states=True).hidden_states
+        if outs is None:
+            outs = [[] for _ in hs]
+        w = am / am.sum(1, keepdim=True).clamp(min=1)
+        for j, h in enumerate(hs):
+            outs[j].append((h.float() * w.unsqueeze(-1)).sum(1).cpu())
+    return {j: torch.cat(o).numpy().astype(np.float64) for j, o in enumerate(outs)}
+
+

code/set4_multiblimp.py

@@ -0,0 +1,154 @@
+"""SET 4, ACCURACY arm: MultiBLiMP 1.0 (jumelet/multiblimp) on the Goldfish merges.
+
+The Δfloor tables for SET 4 are likelihood only. This asks the accuracy question directly, on the
+same merges: does anything survive as *grammatical competence*? Minimal pairs are `sen` (grammatical)
+vs `wrong_sen`; a model is correct when it assigns the higher total log-probability to `sen`.
+Chance = 0.500.
+
+CAVEAT built into the design: the merged models live in the ENGLISH parent's token-id space, so
+partner-language items must be tokenized with the English tokenizer. The per-cell UNK rate is
+reported alongside every number; where it is high (Greek) the partner-language accuracy is not
+interpretable as grammatical competence and is marked as such."""
+import os, sys, json, time, csv, argparse, gc
+sys.path.insert(0, "/root/compose-audit")
+from common import *
+import gpt2_align as G2
+from mergeschool.core.models import load_hf
+from huggingface_hub import hf_hub_download
+
+ap = argparse.ArgumentParser()
+ap.add_argument("--pairs", default="nld_Latn:nld_latn:nld,spa_Latn:spa_latn:spa,ell_Grek:ell_grek:ell,pol_Latn:pol_latn:pol")
+ap.add_argument("--n_sent", type=int, default=500)
+ap.add_argument("--max_items", type=int, default=1200)
+ap.add_argument("--bs", type=int, default=48)
+A = ap.parse_args()
+OUT = "/root/compose-audit/results/set4_multiblimp.jsonl"
+DEV = "cuda"
+ENG_REPO = "goldfish-models/eng_latn_1000mb"
+
+
+def log(*a):
+    print(f"[{time.strftime('%H:%M:%S')}]", *a, flush=True)
+
+
+def mb_pairs(lang, n):
+    p = hf_hub_download("jumelet/multiblimp", f"{lang}/data.tsv", repo_type="dataset")
+    rows = list(csv.DictReader(open(p, encoding="utf-8"), delimiter="\t"))[:n]
+    return [(r["sen"], r["wrong_sen"], r.get("phenomenon", "?")) for r in rows
+            if r.get("sen") and r.get("wrong_sen")]
+
+
+def encode(tok, sents, maxlen=64):
+    e = tok(sents, return_tensors="pt", padding=True, truncation=True, max_length=maxlen)
+    return e["input_ids"], e["attention_mask"]
+
+
+@torch.no_grad()
+def score(model, ids, am, dev, bs):
+    out = []
+    for i in range(0, ids.shape[0], bs):
+        x, m = ids[i:i + bs].to(dev), am[i:i + bs].to(dev)
+        lp = torch.log_softmax(model(x, attention_mask=m).logits.float()[:, :-1], -1)
+        out.append((lp.gather(-1, x[:, 1:].unsqueeze(-1)).squeeze(-1) * m[:, 1:].float()).sum(1).cpu())
+    return torch.cat(out).numpy()
+
+
+def unk_rate(tok, ids, am):
+    u = tok.unk_token_id
+    if u is None: return 0.0
+    return float(((ids == u) & (am.bool())).sum().item() / max(1, am.sum().item()))
+
+
+log("loading eng parent")
+m_e, tok_e = load_hf(ENG_REPO, dtype=torch.float32, device=DEV); m_e.eval()
+cfg = m_e.config
+D, NH, NL, V = cfg.n_embd, cfg.n_head, cfg.n_layer, cfg.vocab_size
+SD_E = sd_np(m_e)
+shell = m_e
+
+sys.path.insert(0, "/root/compose-audit")
+from set4_goldfish_lib import sent_acts   # noqa
+
+eng_lines = flores_lines("eng_Latn")[: A.n_sent]
+acts_e = sent_acts(m_e, tok_e, eng_lines, DEV)
+MB_ENG = mb_pairs("eng", A.max_items)
+ENC_ENG_E = (encode(tok_e, [g for g, b, p in MB_ENG]), encode(tok_e, [b for g, b, p in MB_ENG]))
+log(f"MultiBLiMP eng items={len(MB_ENG)}  UNK(eng tok)={unk_rate(tok_e, *ENC_ENG_E[0]):.2%}")
+
+
+def acc(sd, enc_g, enc_b):
+    sd_load(shell, sd, DEV)
+    sg = score(shell, *enc_g, DEV, A.bs); sb = score(shell, *enc_b, DEV, A.bs)
+    return float((sg > sb).mean())
+
+
+ACC_E_ENG = acc(SD_E, *ENC_ENG_E)
+log(f"eng parent, MultiBLiMP-eng = {ACC_E_ENG:.4f}")
+
+done = set()
+if os.path.exists(OUT):
+    for l in open(OUT):
+        try: done.add(json.loads(l)["lang"])
+        except Exception: pass
+fh = open(OUT, "a")
+
+for spec in A.pairs.split(","):
+    fcode, gcode, mb = spec.split(":")
+    if fcode in done: continue
+    t0 = time.time()
+    repo = f"goldfish-models/{gcode}_1000mb"
+    log(f"=== {fcode} <- {repo}")
+    m_x, tok_x = load_hf(repo, dtype=torch.float32, device=DEV); m_x.eval()
+    SD_X = sd_np(m_x)
+    x_lines = flores_lines(fcode)[: A.n_sent]
+    acts_x = sent_acts(m_x, tok_x, x_lines, DEV)
+    MB_X = mb_pairs(mb, A.max_items)
+    ENC_X_X = (encode(tok_x, [g for g, b, p in MB_X]), encode(tok_x, [b for g, b, p in MB_X]))
+    ENC_X_E = (encode(tok_e, [g for g, b, p in MB_X]), encode(tok_e, [b for g, b, p in MB_X]))
+    unk_x_e = unk_rate(tok_e, *ENC_X_E[0]); unk_x_x = unk_rate(tok_x, *ENC_X_X[0])
+    sg = score(m_x, *ENC_X_X[0], DEV, A.bs); sb = score(m_x, *ENC_X_X[1], DEV, A.bs)
+    ACC_X_X = float((sg > sb).mean())
+    del m_x; torch.cuda.empty_cache()
+    ACC_E_X = acc(SD_E, *ENC_X_E)                     # English parent on partner-language items
+    log(f"  items={len(MB_X)} UNK(eng tok on {mb})={unk_x_e:.2%}  X parent MB-{mb}={ACC_X_X:.4f}  "
+        f"eng parent MB-{mb}={ACC_E_X:.4f}  (chance 0.5)")
+
+    vkeys = [k for k in SD_X if k.endswith("wte.weight") or k.endswith("lm_head.weight")]
+    SD_X_V, cov = AL.remap_vocab_rows(SD_X, tok_e, tok_x, V, keys=vkeys)
+    for k in vkeys:
+        W = np.asarray(SD_X_V[k], float)
+        if W.shape[0] == V:
+            bad = ~np.isfinite(W).all(axis=1); W[bad] = np.asarray(SD_E[k], float)[bad]
+        SD_X_V[k] = W
+    BODY = [k for k in SD_E if not (k.endswith("wte.weight") or k.endswith("lm_head.weight"))]
+    R_emb, n_anch = G2.emb_procrustes(SD_E, SD_X, tok_e, tok_x)
+    sd_emb = G2.apply_resid(SD_X_V, D, R=R_emb)
+    sd_emb2, _ = G2.align_full(SD_E, sd_emb, D, NH, None, None, "permutation", body_keys=BODY)
+    sdp, ip = G2.align_full(SD_E, SD_X_V, D, NH, acts_e, acts_x, "permutation", body_keys=BODY)
+    sdo, io = G2.align_full(SD_E, SD_X_V, D, NH, acts_e, acts_x, "orthogonal", body_keys=BODY)
+    sdof, _ = G2.align_full(SD_E, SD_X_V, D, NH, acts_e, acts_x, "orthogonal", body_keys=BODY, accept_each=False)
+
+    rungs = {"M0_naive_avg": MG.average([SD_E, SD_X]),
+             "M1a_vocab_avg": MG.average([SD_E, SD_X_V]),
+             "M1b_vocab_perm_avg": MG.average([SD_E, sdp]),
+             "M1c_vocab_orth_avg": MG.average([SD_E, sdo]),
+             "M1e_vocab_orth_forced": MG.average([SD_E, sdof]),
+             "M1g_emb_procrustes": MG.average([SD_E, sd_emb]),
+             "M1h_emb_proc_units": MG.average([SD_E, sd_emb2])}
+    res = {}
+    for k, sd in rungs.items():
+        res[k] = {"mb_eng": acc(sd, *ENC_ENG_E), "mb_x": acc(sd, *ENC_X_E)}
+        res[k]["delta_eng_vs_eng_parent"] = res[k]["mb_eng"] - ACC_E_ENG
+        res[k]["delta_x_vs_x_parent"] = res[k]["mb_x"] - ACC_X_X
+
+    r = {"set": "set4_multiblimp", "lang": fcode, "mb_lang": mb, "repo_b": repo,
+         "metric": "MultiBLiMP 1.0 accuracy (chance=0.5) -- ACCURACY, not likelihood",
+         "n_items_eng": len(MB_ENG), "n_items_x": len(MB_X),
+         "unk_rate_eng_tok_on_x_items": unk_x_e, "unk_rate_own_tok_on_x_items": unk_x_x,
+         "parents": {"eng_on_mb_eng": ACC_E_ENG, "x_on_mb_x": ACC_X_X, "eng_on_mb_x": ACC_E_X},
+         "rungs": res, "align_info": {"perm": ip, "orth": io}, "secs": time.time() - t0}
+    fh.write(json.dumps(r) + "\n"); fh.flush()
+    log("  " + "  ".join(f"{k}: eng={v['mb_eng']:.3f} x={v['mb_x']:.3f}" for k, v in res.items()))
+    del rungs, sdp, sdo, sdof, sd_emb, sd_emb2, SD_X, SD_X_V; gc.collect()
+fh.close()
+log("DONE set4_multiblimp")

code/set4_reverse.py

@@ -0,0 +1,136 @@
+"""SET 4, REVERSE direction: the partner language is the anchor, English is transported into it.
+
+Same four Goldfish pairs, same rungs, same metric — but the merged model now lives in the PARTNER
+language's tokenizer and residual basis. If the composition failure were an artifact of anchoring on
+English (English rows filling every unshared id, English tokenizer scoring the partner text), it
+would not survive the swap."""
+import os, sys, json, time, argparse, gc
+sys.path.insert(0, "/root/compose-audit")
+from common import *
+import gpt2_align as G2
+from set4_goldfish_lib import sent_acts
+from mergeschool.core.models import load_hf
+
+ap = argparse.ArgumentParser()
+ap.add_argument("--pairs", default="nld_Latn:nld_latn,spa_Latn:spa_latn,ell_Grek:ell_grek,pol_Latn:pol_latn")
+ap.add_argument("--n_sent", type=int, default=500)
+ap.add_argument("--bs", type=int, default=8)
+ap.add_argument("--barrier_n", type=int, default=7)
+A = ap.parse_args()
+OUT = "/root/compose-audit/results/set4_reverse.jsonl"
+DEV = "cuda"
+ENG_REPO = "goldfish-models/eng_latn_1000mb"
+
+
+def log(*a):
+    print(f"[{time.strftime('%H:%M:%S')}]", *a, flush=True)
+
+
+def build_blocks(tok, text, block=512, max_blocks=64):
+    ids = tok(text)["input_ids"]
+    n = max(1, min(max_blocks, len(ids) // block))
+    arr = torch.from_numpy(np.asarray(ids[: n * block], dtype=np.int64).reshape(n, block))
+    nb = sum(len(tok.decode(list(arr[i, 1:].numpy())).encode("utf-8")) for i in range(n))
+    return arr, nb
+
+
+@torch.no_grad()
+def nll_total(model, blocks, dev, bs=8):
+    tot, ntok = 0.0, 0
+    for i in range(0, blocks.shape[0], bs):
+        x = blocks[i:i + bs].to(dev)
+        lp = torch.log_softmax(model(x).logits.float()[:, :-1], -1)
+        tgt = x[:, 1:]
+        tot += (-lp.gather(-1, tgt.unsqueeze(-1)).squeeze(-1)).sum().item(); ntok += tgt.numel()
+    return tot, ntok
+
+
+eng_lines = flores_lines("eng_Latn")[: A.n_sent]
+eng_text = "\n".join(eng_lines)
+m_e, tok_e = load_hf(ENG_REPO, dtype=torch.float32, device=DEV); m_e.eval()
+SD_E = sd_np(m_e)
+cfg = m_e.config
+D, NH, NL, V = cfg.n_embd, cfg.n_head, cfg.n_layer, cfg.vocab_size
+acts_e = sent_acts(m_e, tok_e, eng_lines, DEV)
+bl_e_e, by_e_e = build_blocks(tok_e, eng_text)
+te0, _ = nll_total(m_e, bl_e_e, DEV, bs=A.bs)
+ENG_ON_ENG = te0 / by_e_e
+del m_e; torch.cuda.empty_cache()
+log(f"eng parent on eng (own tok) = {ENG_ON_ENG:.4f} nats/byte")
+
+done = set()
+if os.path.exists(OUT):
+    for l in open(OUT):
+        try: done.add(json.loads(l)["lang"])
+        except Exception: pass
+fh = open(OUT, "a")
+
+for spec in A.pairs.split(","):
+    fcode, gcode = spec.split(":")
+    if fcode in done: continue
+    t0 = time.time()
+    repo = f"goldfish-models/{gcode}_1000mb"
+    log(f"=== ANCHOR={fcode}  transporting {ENG_REPO} into it")
+    m_x, tok_x = load_hf(repo, dtype=torch.float32, device=DEV); m_x.eval()
+    SD_X = sd_np(m_x)                       # ANCHOR  (role "A")
+    shell = m_x
+    x_lines = flores_lines(fcode)[: A.n_sent]
+    x_text = "\n".join(x_lines)
+    acts_x = sent_acts(m_x, tok_x, x_lines, DEV)
+    bl_x_x, by_x_x = build_blocks(tok_x, x_text)         # X text, X tok  (anchor space)
+    bl_e_x, by_e_x = build_blocks(tok_x, eng_text)       # eng text, X tok (anchor space)
+    tx, _ = nll_total(m_x, bl_x_x, DEV, bs=A.bs); X_ON_X = tx / by_x_x
+
+    def ev(sd, blocks):
+        sd_load(shell, sd, DEV)
+        t, n = nll_total(shell, blocks, DEV, bs=A.bs)
+        return t, n
+
+    tex, _ = ev(SD_X, bl_e_x); X_ON_ENG = tex / by_e_x
+    log(f"  parents: X/X={X_ON_X:.4f}  X-on-eng={X_ON_ENG:.4f}  eng/eng(own tok)={ENG_ON_ENG:.4f}")
+
+    # transport ENGLISH into the anchor's id space
+    vkeys = [k for k in SD_E if k.endswith("wte.weight") or k.endswith("lm_head.weight")]
+    SD_E_V, cov = AL.remap_vocab_rows(SD_E, tok_x, tok_e, V, keys=vkeys)
+    for k in vkeys:
+        W = np.asarray(SD_E_V[k], float)
+        if W.shape[0] == V:
+            bad = ~np.isfinite(W).all(axis=1); W[bad] = np.asarray(SD_X[k], float)[bad]
+        SD_E_V[k] = W
+    anchors = AL.vocab_anchors(tok_x, tok_e)
+    BODY = [k for k in SD_X if not (k.endswith("wte.weight") or k.endswith("lm_head.weight"))]
+    R_emb, n_anch = G2.emb_procrustes(SD_X, SD_E, tok_x, tok_e)
+    sd_emb = G2.apply_resid(SD_E_V, D, R=R_emb)
+    sdp, ip = G2.align_full(SD_X, SD_E_V, D, NH, acts_x, acts_e, "permutation", body_keys=BODY)
+    sdo, io = G2.align_full(SD_X, SD_E_V, D, NH, acts_x, acts_e, "orthogonal", body_keys=BODY)
+    sdof, _ = G2.align_full(SD_X, SD_E_V, D, NH, acts_x, acts_e, "orthogonal", body_keys=BODY, accept_each=False)
+
+    rungs = {"M0_naive_avg": MG.average([SD_X, SD_E]),
+             "M1a_vocab_avg": MG.average([SD_X, SD_E_V]),
+             "M1b_vocab_perm_avg": MG.average([SD_X, sdp]),
+             "M1c_vocab_orth_avg": MG.average([SD_X, sdo]),
+             "M1e_vocab_orth_forced": MG.average([SD_X, sdof]),
+             "M1g_emb_procrustes": MG.average([SD_X, sd_emb])}
+    res = {}
+    for k, sd in rungs.items():
+        t_x, n_x = ev(sd, bl_x_x); t_e, n_e = ev(sd, bl_e_x)
+        res[k] = {"x": {"nats_per_byte": t_x / by_x_x, "nats_per_token": t_x / n_x},
+                  "eng": {"nats_per_byte": t_e / by_e_x, "nats_per_token": t_e / n_e},
+                  "delta_floor_x": t_x / by_x_x - X_ON_X,
+                  "delta_floor_eng": t_e / by_e_x - min(X_ON_ENG, ENG_ON_ENG)}
+        res[k]["delta_floor_mean"] = 0.5 * (res[k]["delta_floor_x"] + res[k]["delta_floor_eng"])
+    for k in res:
+        res[k]["delta_vs_naive_mean"] = res[k]["delta_floor_mean"] - res["M0_naive_avg"]["delta_floor_mean"]
+
+    r = {"set": "set4_reverse", "lang": fcode, "anchor": fcode, "repo_a": repo, "repo_b": ENG_REPO,
+         "corpus": "flores200_devtest", "n_sent": A.n_sent,
+         "metric": "nats_per_utf8_byte (likelihood, NOT benchmark accuracy)",
+         "parents": {"x_on_x": X_ON_X, "x_on_eng": X_ON_ENG, "eng_on_eng_own_tok": ENG_ON_ENG},
+         "floor_x": X_ON_X, "floor_eng": min(X_ON_ENG, ENG_ON_ENG),
+         "vocab_anchors": len(anchors), "align_info": {"perm": ip, "orth": io},
+         "rungs": res, "secs": time.time() - t0}
+    fh.write(json.dumps(r) + "\n"); fh.flush()
+    log("  " + "  ".join(f"{k}: dfl_mean={v['delta_floor_mean']:+.4f}" for k, v in res.items()))
+    del rungs, sdp, sdo, sdof, sd_emb, SD_E_V, m_x; gc.collect(); torch.cuda.empty_cache()
+fh.close()
+log("DONE set4_reverse")

results/alignment_health.json

@@ -0,0 +1,20 @@
+{
+ "set1_pythia14m": {
+  "parent_nll": 4.414665286866031,
+  "nll_change_after_alignment": {
+   "permutation_residual+mlp": 3.025878587692432e-06,
+   "permutation_full(+heads)": 5.892500407611578e-06,
+   "orthogonal_residual+mlp": 27.2622880929448
+  }
+ },
+ "set4_goldfish_nld": {
+  "parent_nll": 4.093903364267368,
+  "nll_change_after_alignment": {
+   "perm_residual_only": 0.0,
+   "mlp_only": 0.0,
+   "heads_only": 0.0,
+   "perm_full": 0.0,
+   "orth_full": 0.06913312400623717
+  }
+ }
+}

results/blimp_160m.jsonl

@@ -0,0 +1 @@
+{"set": "set1_blimp", "size": "160m", "pair": [1, 2], "metric": "BLiMP accuracy (chance=0.5) -- ACCURACY, not likelihood", "n_per_paradigm": 150, "n_paradigms": 67, "parent_acc": {"a": 0.780497512437811, "b": 0.7677611940298508}, "ceiling": 0.780497512437811, "rungs": {"M0_naive_avg": {"blimp_acc": 0.5619900497512438, "delta_vs_best_parent": -0.21850746268656718}, "M1_perm_avg": {"blimp_acc": 0.5450746268656717, "delta_vs_best_parent": -0.2354228855721393}, "M1_orth_avg": {"blimp_acc": 0.5556218905472636, "delta_vs_best_parent": -0.22487562189054733}}, "per_paradigm": {"M0_naive_avg": {"adjunct_island": 0.4533333333333333, "anaphor_gender_agreement": 0.38, "anaphor_number_agreement": 0.6066666666666667, "animate_subject_passive": 0.6266666666666667, "animate_subject_trans": 0.52, "causative": 0.4666666666666667, "complex_NP_island": 0.49333333333333335, "coordinate_structure_constraint_complex_left_branch": 0.5933333333333334, "coordinate_structure_constraint_object_extraction": 0.38666666666666666, "determiner_noun_agreement_1": 0.56, "determiner_noun_agreement_2": 0.54, "determiner_noun_agreement_irregular_1": 0.4866666666666667, "determiner_noun_agreement_irregular_2": 0.5533333333333333, "determiner_noun_agreement_with_adj_2": 0.5133333333333333, "determiner_noun_agreement_with_adj_irregular_1": 0.54, "determiner_noun_agreement_with_adj_irregular_2": 0.58, "determiner_noun_agreement_with_adjective_1": 0.46, "distractor_agreement_relational_noun": 0.48, "distractor_agreement_relative_clause": 0.4666666666666667, "drop_argument": 0.74, "ellipsis_n_bar_1": 0.66, "ellipsis_n_bar_2": 0.26, "existential_there_object_raising": 0.7666666666666667, "existential_there_quantifiers_1": 0.72, "existential_there_quantifiers_2": 0.19333333333333333, "existential_there_subject_raising": 0.62, "expletive_it_object_raising": 0.6533333333333333, "inchoative": 0.4, "intransitive": 0.4533333333333333, "irregular_past_participle_adjectives": 1.0, "irregular_past_participle_verbs": 0.5866666666666667, "irregular_plural_subject_verb_agreement_1": 0.44666666666666666, "irregular_plural_subject_verb_agreement_2": 0.5266666666666666, "left_branch_island_echo_question": 0.28, "left_branch_island_simple_question": 0.6266666666666667, "matrix_question_npi_licensor_present": 0.22, "npi_present_1": 0.38666666666666666, "npi_present_2": 0.8066666666666666, "only_npi_licensor_present": 0.6, "only_npi_scope": 0.7666666666666667, "passive_1": 0.6666666666666666, "passive_2": 0.66, "principle_A_c_command": 0.6866666666666666, "principle_A_case_1": 0.96, "principle_A_case_2": 0.44, "principle_A_domain_1": 0.5266666666666666, "principle_A_domain_2": 0.5333333333333333, "principle_A_domain_3": 0.4533333333333333, "principle_A_reconstruction": 0.37333333333333335, "regular_plural_subject_verb_agreement_1": 0.56, "regular_plural_subject_verb_agreement_2": 0.5666666666666667, "sentential_negation_npi_licensor_present": 1.0, "sentential_negation_npi_scope": 0.52, "sentential_subject_island": 0.48, "superlative_quantifiers_1": 0.10666666666666667, "superlative_quantifiers_2": 0.34, "tough_vs_raising_1": 0.22, "tough_vs_raising_2": 0.8266666666666667, "transitive": 0.49333333333333335, "wh_island": 0.9333333333333333, "wh_questions_object_gap": 0.9333333333333333, "wh_questions_subject_gap": 0.9733333333333334, "wh_questions_subject_gap_long_distance": 0.9533333333333334, "wh_vs_that_no_gap": 0.9866666666666667, "wh_vs_that_no_gap_long_distance": 0.96, "wh_vs_that_with_gap": 0.04, "wh_vs_that_with_gap_long_distance": 0.04}, "M1_perm_avg": {"adjunct_island": 0.46, "anaphor_gender_agreement": 0.28, "anaphor_number_agreement": 0.47333333333333333, "animate_subject_passive": 0.64, "animate_subject_trans": 0.5, "causative": 0.26, "complex_NP_island": 0.6133333333333333, "coordinate_structure_constraint_complex_left_branch": 0.35333333333333333, "coordinate_structure_constraint_object_extraction": 0.5866666666666667, "determiner_noun_agreement_1": 0.56, "determiner_noun_agreement_2": 0.5, "determiner_noun_agreement_irregular_1": 0.4666666666666667, "determiner_noun_agreement_irregular_2": 0.5333333333333333, "determiner_noun_agreement_with_adj_2": 0.48, "determiner_noun_agreement_with_adj_irregular_1": 0.49333333333333335, "determiner_noun_agreement_with_adj_irregular_2": 0.5533333333333333, "determiner_noun_agreement_with_adjective_1": 0.5066666666666667, "distractor_agreement_relational_noun": 0.4666666666666667, "distractor_agreement_relative_clause": 0.5, "drop_argument": 0.6533333333333333, "ellipsis_n_bar_1": 0.4666666666666667, "ellipsis_n_bar_2": 0.16666666666666666, "existential_there_object_raising": 0.72, "existential_there_quantifiers_1": 0.6066666666666667, "existential_there_quantifiers_2": 0.37333333333333335, "existential_there_subject_raising": 0.6733333333333333, "expletive_it_object_raising": 0.66, "inchoative": 0.32666666666666666, "intransitive": 0.43333333333333335, "irregular_past_participle_adjectives": 0.04, "irregular_past_participle_verbs": 0.76, "irregular_plural_subject_verb_agreement_1": 0.5933333333333334, "irregular_plural_subject_verb_agreement_2": 0.4533333333333333, "left_branch_island_echo_question": 0.6466666666666666, "left_branch_island_simple_question": 0.36666666666666664, "matrix_question_npi_licensor_present": 0.16, "npi_present_1": 0.9666666666666667, "npi_present_2": 0.92, "only_npi_licensor_present": 0.9666666666666667, "only_npi_scope": 0.88, "passive_1": 0.56, "passive_2": 0.5733333333333334, "principle_A_c_command": 0.7866666666666666, "principle_A_case_1": 0.8666666666666667, "principle_A_case_2": 0.30666666666666664, "principle_A_domain_1": 0.6333333333333333, "principle_A_domain_2": 0.5066666666666667, "principle_A_domain_3": 0.46, "principle_A_reconstruction": 0.22666666666666666, "regular_plural_subject_verb_agreement_1": 0.38, "regular_plural_subject_verb_agreement_2": 0.52, "sentential_negation_npi_licensor_present": 0.92, "sentential_negation_npi_scope": 0.44, "sentential_subject_island": 0.5266666666666666, "superlative_quantifiers_1": 0.38, "superlative_quantifiers_2": 0.7466666666666667, "tough_vs_raising_1": 0.26666666666666666, "tough_vs_raising_2": 0.8, "transitive": 0.5, "wh_island": 0.06666666666666667, "wh_questions_object_gap": 1.0, "wh_questions_subject_gap": 1.0, "wh_questions_subject_gap_long_distance": 1.0, "wh_vs_that_no_gap": 1.0, "wh_vs_that_no_gap_long_distance": 0.9933333333333333, "wh_vs_that_with_gap": 0.0, "wh_vs_that_with_gap_long_distance": 0.0}, "M1_orth_avg": {"adjunct_island": 0.42, "anaphor_gender_agreement": 0.32666666666666666, "anaphor_number_agreement": 0.6, "animate_subject_passive": 0.54, "animate_subject_trans": 0.4266666666666667, "causative": 0.36666666666666664, "complex_NP_island": 0.58, "coordinate_structure_constraint_complex_left_branch": 0.18666666666666668, "coordinate_structure_constraint_object_extraction": 0.3933333333333333, "determiner_noun_agreement_1": 0.5533333333333333, "determiner_noun_agreement_2": 0.5333333333333333, "determiner_noun_agreement_irregular_1": 0.5266666666666666, "determiner_noun_agreement_irregular_2": 0.5866666666666667, "determiner_noun_agreement_with_adj_2": 0.48, "determiner_noun_agreement_with_adj_irregular_1": 0.54, "determiner_noun_agreement_with_adj_irregular_2": 0.5333333333333333, "determiner_noun_agreement_with_adjective_1": 0.52, "distractor_agreement_relational_noun": 0.46, "distractor_agreement_relative_clause": 0.41333333333333333, "drop_argument": 0.7466666666666667, "ellipsis_n_bar_1": 0.5, "ellipsis_n_bar_2": 0.35333333333333333, "existential_there_object_raising": 0.8266666666666667, "existential_there_quantifiers_1": 0.8666666666666667, "existential_there_quantifiers_2": 0.22, "existential_there_subject_raising": 0.6533333333333333, "expletive_it_object_raising": 0.6533333333333333, "inchoative": 0.41333333333333333, "intransitive": 0.58, "irregular_past_participle_adjectives": 0.6066666666666667, "irregular_past_participle_verbs": 0.54, "irregular_plural_subject_verb_agreement_1": 0.6266666666666667, "irregular_plural_subject_verb_agreement_2": 0.6533333333333333, "left_branch_island_echo_question": 0.6733333333333333, "left_branch_island_simple_question": 0.2866666666666667, "matrix_question_npi_licensor_present": 0.4666666666666667, "npi_present_1": 0.34, "npi_present_2": 0.47333333333333333, "only_npi_licensor_present": 0.9466666666666667, "only_npi_scope": 0.30666666666666664, "passive_1": 0.6133333333333333, "passive_2": 0.6533333333333333, "principle_A_c_command": 0.6933333333333334, "principle_A_case_1": 0.9866666666666667, "principle_A_case_2": 0.36, "principle_A_domain_1": 0.8466666666666667, "principle_A_domain_2": 0.5466666666666666, "principle_A_domain_3": 0.4066666666666667, "principle_A_reconstruction": 0.26, "regular_plural_subject_verb_agreement_1": 0.5666666666666667, "regular_plural_subject_verb_agreement_2": 0.5933333333333334, "sentential_negation_npi_licensor_present": 0.9933333333333333, "sentential_negation_npi_scope": 0.5133333333333333, "sentential_subject_island": 0.58, "superlative_quantifiers_1": 0.5533333333333333, "superlative_quantifiers_2": 0.9666666666666667, "tough_vs_raising_1": 0.32666666666666666, "tough_vs_raising_2": 0.68, "transitive": 0.4866666666666667, "wh_island": 0.26666666666666666, "wh_questions_object_gap": 0.74, "wh_questions_subject_gap": 0.9666666666666667, "wh_questions_subject_gap_long_distance": 0.9, "wh_vs_that_no_gap": 0.94, "wh_vs_that_no_gap_long_distance": 0.9666666666666667, "wh_vs_that_with_gap": 0.06, "wh_vs_that_with_gap_long_distance": 0.04}}, "secs": 136.26438093185425}

results/repair_70m.jsonl

@@ -3,3 +3,8 @@
 {"set": "set1_repair", "size": "70m", "pair": [1, 4], "floor": 3.5788330555895302, "blimp_ceiling": 0.7305223880597015, "parent_nll": {"a": 3.5788330555895302, "b": 3.6809065309289384}, "parent_blimp": {"a": 0.7305223880597015, "b": 0.7046268656716418}, "rungs": {"M0_naive_avg": {"nll": 31.469823390614806, "delta_floor": 27.890990335025275, "blimp_acc": 0.5120149253731343, "blimp_delta_vs_ceiling": -0.21850746268656718}, "M1_perm_avg": {"nll": 34.52885987442922, "delta_floor": 30.950026818839692, "blimp_acc": 0.5324626865671642, "blimp_delta_vs_ceiling": -0.19805970149253727}, "M4_perm_repair": {"nll": 33.901358906148076, "delta_floor": 30.322525850558545, "blimp_acc": 0.5334328358208955, "blimp_delta_vs_ceiling": -0.19708955223880598}, "M5_naive_repair": {"nll": 27.07668085962981, "delta_floor": 23.49784780404028, "blimp_acc": 0.49417910447761193, "blimp_delta_vs_ceiling": -0.23634328358208956}}, "secs": 46.491278886795044}
 {"set": "set1_repair", "size": "70m", "pair": [1, 5], "floor": 3.5788330555895302, "blimp_ceiling": 0.7305223880597015, "parent_nll": {"a": 3.5788330555895302, "b": 3.653146961508276}, "parent_blimp": {"a": 0.7305223880597015, "b": 0.712910447761194}, "rungs": {"M0_naive_avg": {"nll": 22.256370270711024, "delta_floor": 18.677537215121493, "blimp_acc": 0.5526865671641791, "blimp_delta_vs_ceiling": -0.1778358208955224}, "M1_perm_avg": {"nll": 19.006473469096544, "delta_floor": 15.427640413507014, "blimp_acc": 0.561865671641791, "blimp_delta_vs_ceiling": -0.16865671641791047}, "M4_perm_repair": {"nll": 19.184357226944716, "delta_floor": 15.605524171355185, "blimp_acc": 0.5460447761194029, "blimp_delta_vs_ceiling": -0.18447761194029855}, "M5_naive_repair": {"nll": 24.3843732163242, "delta_floor": 20.80554016073467, "blimp_acc": 0.539179104477612, "blimp_delta_vs_ceiling": -0.19134328358208952}}, "secs": 43.83965444564819}
 {"set": "set1_repair", "size": "70m", "pair": [1, 6], "floor": 3.5788330555895302, "blimp_ceiling": 0.7305223880597015, "parent_nll": {"a": 3.5788330555895302, "b": 3.652026510518591}, "parent_blimp": {"a": 0.7305223880597015, "b": 0.7257462686567164}, "rungs": {"M0_naive_avg": {"nll": 17.456871356205152, "delta_floor": 13.878038300615621, "blimp_acc": 0.48649253731343284, "blimp_delta_vs_ceiling": -0.24402985074626865}, "M1_perm_avg": {"nll": 12.588115814069635, "delta_floor": 9.009282758480104, "blimp_acc": 0.5443283582089552, "blimp_delta_vs_ceiling": -0.1861940298507463}, "M4_perm_repair": {"nll": 11.522275562622308, "delta_floor": 7.943442507032778, "blimp_acc": 0.5246268656716417, "blimp_delta_vs_ceiling": -0.20589552238805975}, "M5_naive_repair": {"nll": 16.34223865327381, "delta_floor": 12.76340559768428, "blimp_acc": 0.49977611940298505, "blimp_delta_vs_ceiling": -0.23074626865671644}}, "secs": 45.298933267593384}
+{"set": "set1_repair", "size": "70m", "pair": [1, 7], "floor": 3.5788330555895302, "blimp_ceiling": 0.7305223880597015, "parent_nll": {"a": 3.5788330555895302, "b": 3.6513079439823874}, "parent_blimp": {"a": 0.7305223880597015, "b": 0.7194776119402985}, "rungs": {"M0_naive_avg": {"nll": 20.72262344310584, "delta_floor": 17.143790387516308, "blimp_acc": 0.5322388059701493, "blimp_delta_vs_ceiling": -0.1982835820895522}, "M1_perm_avg": {"nll": 22.063156774910308, "delta_floor": 18.484323719320777, "blimp_acc": 0.5494776119402985, "blimp_delta_vs_ceiling": -0.18104477611940295}, "M4_perm_repair": {"nll": 22.484095982142858, "delta_floor": 18.905262926553327, "blimp_acc": 0.5373880597014925, "blimp_delta_vs_ceiling": -0.19313432835820898}, "M5_naive_repair": {"nll": 22.253626595115787, "delta_floor": 18.674793539526256, "blimp_acc": 0.5185820895522388, "blimp_delta_vs_ceiling": -0.21194029850746265}}, "secs": 51.879844665527344}
+{"set": "set1_repair", "size": "70m", "pair": [1, 8], "floor": 3.5788330555895302, "blimp_ceiling": 0.7305223880597015, "parent_nll": {"a": 3.5788330555895302, "b": 3.6366048814110403}, "parent_blimp": {"a": 0.7305223880597015, "b": 0.7105970149253731}, "rungs": {"M0_naive_avg": {"nll": 17.48817327391145, "delta_floor": 13.909340218321919, "blimp_acc": 0.5073880597014926, "blimp_delta_vs_ceiling": -0.2231343283582089}, "M1_perm_avg": {"nll": 20.054851852984346, "delta_floor": 16.476018797394815, "blimp_acc": 0.5556716417910448, "blimp_delta_vs_ceiling": -0.1748507462686567}, "M4_perm_repair": {"nll": 20.535853476129322, "delta_floor": 16.95702042053979, "blimp_acc": 0.5664179104477612, "blimp_delta_vs_ceiling": -0.16410447761194025}, "M5_naive_repair": {"nll": 18.670102790688194, "delta_floor": 15.091269735098663, "blimp_acc": 0.5109701492537313, "blimp_delta_vs_ceiling": -0.2195522388059702}}, "secs": 62.3910436630249}
+{"set": "set1_repair", "size": "70m", "pair": [1, 9], "floor": 3.5788330555895302, "blimp_ceiling": 0.7305223880597015, "parent_nll": {"a": 3.5788330555895302, "b": 3.631728518810135}, "parent_blimp": {"a": 0.7305223880597015, "b": 0.7205970149253731}, "rungs": {"M0_naive_avg": {"nll": 20.806881421232877, "delta_floor": 17.228048365643346, "blimp_acc": 0.5282089552238806, "blimp_delta_vs_ceiling": -0.20231343283582093}, "M1_perm_avg": {"nll": 23.1886485598092, "delta_floor": 19.609815504219668, "blimp_acc": 0.5526119402985075, "blimp_delta_vs_ceiling": -0.17791044776119402}, "M4_perm_repair": {"nll": 22.703683035714285, "delta_floor": 19.124849980124754, "blimp_acc": 0.556865671641791, "blimp_delta_vs_ceiling": -0.17365671641791047}, "M5_naive_repair": {"nll": 20.535575732326322, "delta_floor": 16.95674267673679, "blimp_acc": 0.5292537313432836, "blimp_delta_vs_ceiling": -0.20126865671641792}}, "secs": 55.22801184654236}
+{"set": "set1_repair", "size": "70m", "pair": [2, 3], "floor": 3.631012022611913, "blimp_ceiling": 0.7144029850746269, "parent_nll": {"a": 3.654927770685543, "b": 3.631012022611913}, "parent_blimp": {"a": 0.7114925373134329, "b": 0.7144029850746269}, "rungs": {"M0_naive_avg": {"nll": 21.89409233834801, "delta_floor": 18.263080315736097, "blimp_acc": 0.5023134328358209, "blimp_delta_vs_ceiling": -0.212089552238806}, "M1_perm_avg": {"nll": 12.230675465284573, "delta_floor": 8.59966344267266, "blimp_acc": 0.5131343283582089, "blimp_delta_vs_ceiling": -0.20126865671641792}, "M4_perm_repair": {"nll": 12.242747128281964, "delta_floor": 8.611735105670052, "blimp_acc": 0.5155223880597015, "blimp_delta_vs_ceiling": -0.19888059701492533}, "M5_naive_repair": {"nll": 21.926796671151337, "delta_floor": 18.295784648539424, "blimp_acc": 0.522686567164179, "blimp_delta_vs_ceiling": -0.1917164179104478}}, "secs": 38.11003923416138}
+{"set": "set1_repair", "size": "70m", "pair": [2, 4], "floor": 3.654927770685543, "blimp_ceiling": 0.7114925373134329, "parent_nll": {"a": 3.654927770685543, "b": 3.6809065309289384}, "parent_blimp": {"a": 0.7114925373134329, "b": 0.7046268656716418}, "rungs": {"M0_naive_avg": {"nll": 22.71234087063764, "delta_floor": 19.057413099952097, "blimp_acc": 0.5008955223880597, "blimp_delta_vs_ceiling": -0.2105970149253732}, "M1_perm_avg": {"nll": 14.072119108773647, "delta_floor": 10.417191338088104, "blimp_acc": 0.5295522388059701, "blimp_delta_vs_ceiling": -0.18194029850746274}, "M4_perm_repair": {"nll": 14.23412018917156, "delta_floor": 10.579192418486016, "blimp_acc": 0.5261940298507463, "blimp_delta_vs_ceiling": -0.1852985074626866}, "M5_naive_repair": {"nll": 24.689999057199934, "delta_floor": 21.03507128651439, "blimp_acc": 0.5065671641791045, "blimp_delta_vs_ceiling": -0.20492537313432835}}, "secs": 62.753533124923706}

results/set1_160m.jsonl

@@ -26,3 +26,5 @@
 {"set": "set1_polypythia", "size": "160m", "pair": [4, 9], "parent_nll": {"a": 3.2741363585111913, "b": 3.262358126108427}, "floor": 3.262358126108427, "corpus": "flores200_devtest_eng_Latn", "metric": "nats_per_token", "align_info": {"perm": {"residual": true, "hidden": 12, "heads": 12, "rejected": []}, "orth": {"residual": true, "hidden": 12, "heads": 12, "rejected": []}}, "predictors": {"weight_cosine": 0.03161099443751422, "weight_cosine_bn": 0.198844620318614, "d_raw": 1.3926834761794986, "qmd_perm": 1.3306865199238942, "coord_share_perm": 0.044516185706229935, "norm_ratio_perm": 1.0000000000000009, "qmd_orth": 1.2979315969696825, "coord_share_orth": 0.0680354731211041, "d_raw_bn_perm": 1.193857643425369, "qmd_bn_perm": 1.132963438133865, "coordinate_gap_bn_perm": 0.06089420529150402, "coord_fraction_bn_perm": 0.05100625323869334, "d_raw_bn_orth": 1.193857643425369, "qmd_bn_orth": 1.0599208049643605, "coordinate_gap_bn_orth": 0.13393683846100846, "coord_fraction_bn_orth": 0.11218828241256822, "bnd_raw": 1.193857643425369, "bnd_perm": 1.132963438133865, "bnd_orth": 1.0599208049643605, "coord_share_bnd_perm": 0.05100625323869334, "coord_share_bnd_orth": 0.11218828241256822, "cka_mean": 0.7211211159755844, "cka_last": 0.8792108760076334, "qmd_act_perm": 0.27289764096798597, "aligned_cka_perm": 0.727102359032014, "qmd_act_procrustes": 0.2728976409679881, "aligned_cka_procrustes": 0.7271023590320119, "qmd_act_ot": 0.27214817102079025, "aligned_cka_ot": 0.7278518289792097, "task_vector_cosine": 0.5774673146699185}, "rungs": {"M0_naive_avg": {"nll": 16.348348061399218, "delta_floor": 13.08598993529079, "delta_vs_naive": 0.0}, "M1_perm_avg": {"nll": 10.698082134448386, "delta_floor": 7.4357240083399585, "delta_vs_naive": -5.650265926950832}, "M1_orth_avg": {"nll": 9.423008748929794, "delta_floor": 6.160650622821366, "delta_vs_naive": -6.925339312469424}, "M2_task_arith": {"nll": 42.591483457681015, "delta_floor": 39.32912533157259, "delta_vs_naive": 26.243135396281797}, "M3_ties": {"nll": 62.245552914016635, "delta_floor": 58.98319478790821, "delta_vs_naive": 45.89720485261742}}, "barrier_naive": {"barrier": 13.08010081908941, "losses": [3.2741363585111913, 9.463472549229452, 16.348348061399218, 9.968132242997799, 3.262358126108427]}, "barrier_perm": {"barrier": 7.429834772696001, "losses": [3.2741363585111913, 7.971878678831335, 10.698082134448386, 7.5754769580938115, 3.262358364993579]}, "secs": 103.6531343460083}
 {"set": "set1_polypythia", "size": "160m", "pair": [5, 6], "parent_nll": {"a": 3.255690960968077, "b": 3.275654115322285}, "floor": 3.255690960968077, "corpus": "flores200_devtest_eng_Latn", "metric": "nats_per_token", "align_info": {"perm": {"residual": true, "hidden": 12, "heads": 12, "rejected": []}, "orth": {"residual": true, "hidden": 12, "heads": 12, "rejected": []}}, "predictors": {"weight_cosine": 0.029452020971517494, "weight_cosine_bn": 0.20353675966522838, "d_raw": 1.393565225037434, "qmd_perm": 1.3389471776539443, "coord_share_perm": 0.039193032663413715, "norm_ratio_perm": 0.9999999999999996, "qmd_orth": 1.3183360477744988, "coord_share_orth": 0.05398324808292658, "d_raw_bn_perm": 1.191233032171224, "qmd_bn_perm": 1.1051826225905557, "coordinate_gap_bn_perm": 0.08605040958066823, "coord_fraction_bn_perm": 0.07223641995876054, "d_raw_bn_orth": 1.191233032171224, "qmd_bn_orth": 1.0548282186261682, "coordinate_gap_bn_orth": 0.13640481354505574, "coord_fraction_bn_orth": 0.11450724573716267, "bnd_raw": 1.191233032171224, "bnd_perm": 1.1051826225905557, "bnd_orth": 1.0548282186261682, "coord_share_bnd_perm": 0.07223641995876054, "coord_share_bnd_orth": 0.11450724573716267, "cka_mean": 0.649440526694889, "cka_last": 0.8637804403134508, "qmd_act_perm": 0.33485238992431854, "aligned_cka_perm": 0.6651476100756815, "qmd_act_procrustes": 0.33485238992431976, "aligned_cka_procrustes": 0.6651476100756802, "qmd_act_ot": 0.33289167401260766, "aligned_cka_ot": 0.6671083259873923, "task_vector_cosine": 0.5972592227439053}, "rungs": {"M0_naive_avg": {"nll": 11.751382189487524, "delta_floor": 8.495691228519448, "delta_vs_naive": 0.0}, "M1_perm_avg": {"nll": 9.339639742080479, "delta_floor": 6.083948781112402, "delta_vs_naive": -2.411742447407045}, "M1_orth_avg": {"nll": 8.96071199241683, "delta_floor": 5.705021031448752, "delta_vs_naive": -2.7906701970706944}, "M2_task_arith": {"nll": 28.49879792991683, "delta_floor": 25.24310696894875, "delta_vs_naive": 16.747415740429304}, "M3_ties": {"nll": 57.710245688600786, "delta_floor": 54.45455472763271, "delta_vs_naive": 45.958863499113264}}, "barrier_naive": {"barrier": 8.485709651342344, "losses": [3.255690960968077, 8.387657568646038, 11.751382189487524, 8.489705483274218, 3.275654115322285]}, "barrier_perm": {"barrier": 6.0739676219843135, "losses": [3.255690960968077, 7.5054752476761255, 9.339639742080479, 7.668855969453278, 3.275653279224254]}, "secs": 157.79209566116333}
 {"set": "set1_polypythia", "size": "160m", "pair": [5, 7], "parent_nll": {"a": 3.255690960968077, "b": 3.2518446711411446}, "floor": 3.2518446711411446, "corpus": "flores200_devtest_eng_Latn", "metric": "nats_per_token", "align_info": {"perm": {"residual": true, "hidden": 12, "heads": 12, "rejected": []}, "orth": {"residual": true, "hidden": 12, "heads": 12, "rejected": []}}, "predictors": {"weight_cosine": 0.01915622824598225, "weight_cosine_bn": 0.2034414457667437, "d_raw": 1.4054618945489141, "qmd_perm": 1.3374365428824475, "coord_share_perm": 0.04840070864269109, "norm_ratio_perm": 1.0000000000000004, "qmd_orth": 1.3364405485695097, "coord_share_orth": 0.04910936841980835, "d_raw_bn_perm": 1.1878870672165711, "qmd_bn_perm": 1.0993100663726114, "coordinate_gap_bn_perm": 0.0885770008439597, "coord_fraction_bn_perm": 0.07456685343962136, "d_raw_bn_orth": 1.1878870672165711, "qmd_bn_orth": 1.057410730308829, "coordinate_gap_bn_orth": 0.13047633690774219, "coord_fraction_bn_orth": 0.10983900785574781, "bnd_raw": 1.1878870672165711, "bnd_perm": 1.0993100663726114, "bnd_orth": 1.057410730308829, "coord_share_bnd_perm": 0.07456685343962136, "coord_share_bnd_orth": 0.10983900785574781, "cka_mean": 0.42912236754975763, "cka_last": 0.8934120530157756, "qmd_act_perm": 0.7496748755874749, "aligned_cka_perm": 0.25032512441252514, "qmd_act_procrustes": 0.7496748755874751, "aligned_cka_procrustes": 0.2503251244125248, "qmd_act_ot": 0.668917372802649, "aligned_cka_ot": 0.33108262719735104, "task_vector_cosine": 0.6099042051034456}, "rungs": {"M0_naive_avg": {"nll": 10.320688982999021, "delta_floor": 7.068844311857877, "delta_vs_naive": 0.0}, "M1_perm_avg": {"nll": 9.72730638836228, "delta_floor": 6.475461717221135, "delta_vs_naive": -0.5933825946367417}, "M1_orth_avg": {"nll": 9.17136091915362, "delta_floor": 5.919516248012476, "delta_vs_naive": -1.1493280638454006}, "M2_task_arith": {"nll": 22.496724406800393, "delta_floor": 19.244879735659246, "delta_vs_naive": 12.176035423801371}, "M3_ties": {"nll": 61.21087825648239, "delta_floor": 57.959033585341245, "delta_vs_naive": 50.890189273483365}}, "barrier_naive": {"barrier": 7.066921166944411, "losses": [3.255690960968077, 8.213293863136007, 10.320688982999021, 8.742778979635519, 3.2518446711411446]}, "barrier_perm": {"barrier": 6.473538154258653, "losses": [3.255690960968077, 8.223385327482877, 9.72730638836228, 7.600769162411326, 3.2518455072391754]}, "secs": 112.05698370933533}
+{"set": "set1_polypythia", "size": "160m", "pair": [5, 8], "parent_nll": {"a": 3.255690960968077, "b": 3.2340771102158756}, "floor": 3.2340771102158756, "corpus": "flores200_devtest_eng_Latn", "metric": "nats_per_token", "align_info": {"perm": {"residual": true, "hidden": 12, "heads": 12, "rejected": []}, "orth": {"residual": true, "hidden": 12, "heads": 12, "rejected": []}}, "predictors": {"weight_cosine": 0.021209732059568748, "weight_cosine_bn": 0.20021527035166653, "d_raw": 1.399296639755202, "qmd_perm": 1.3204037532476478, "coord_share_perm": 0.0563803873075519, "norm_ratio_perm": 0.999999999999999, "qmd_orth": 1.3049933683615855, "coord_share_orth": 0.06739333799166004, "d_raw_bn_perm": 1.1854023591369292, "qmd_bn_perm": 1.086907705870477, "coordinate_gap_bn_perm": 0.09849465326645213, "coord_fraction_bn_perm": 0.08308963830489115, "d_raw_bn_orth": 1.1854023591369292, "qmd_bn_orth": 1.0524820315302943, "coordinate_gap_bn_orth": 0.13292032760663486, "coord_fraction_bn_orth": 0.11213097947891029, "bnd_raw": 1.1854023591369292, "bnd_perm": 1.086907705870477, "bnd_orth": 1.0524820315302943, "coord_share_bnd_perm": 0.08308963830489115, "coord_share_bnd_orth": 0.11213097947891029, "cka_mean": 0.6863836885751571, "cka_last": 0.8952499492708976, "qmd_act_perm": 0.32540832925888985, "aligned_cka_perm": 0.6745916707411101, "qmd_act_procrustes": 0.3254083292588872, "aligned_cka_procrustes": 0.6745916707411128, "qmd_act_ot": 0.32527434289189827, "aligned_cka_ot": 0.6747256571081017, "task_vector_cosine": 0.5870299075043434}, "rungs": {"M0_naive_avg": {"nll": 11.34057473856409, "delta_floor": 8.106497628348215, "delta_vs_naive": 0.0}, "M1_perm_avg": {"nll": 9.431755289872799, "delta_floor": 6.197678179656923, "delta_vs_naive": -1.9088194486912915}, "M1_orth_avg": {"nll": 9.744953790056263, "delta_floor": 6.510876679840387, "delta_vs_naive": -1.5956209485078272}, "M2_task_arith": {"nll": 24.767799810420744, "delta_floor": 21.53372270020487, "delta_vs_naive": 13.427225071856654}, "M3_ties": {"nll": 62.77044474681996, "delta_floor": 59.53636763660408, "delta_vs_naive": 51.429870008255875}}, "barrier_naive": {"barrier": 8.095690702972114, "losses": [3.255690960968077, 8.579819173495597, 11.34057473856409, 8.70538533130504, 3.2340771102158756]}, "barrier_perm": {"barrier": 6.186870537625367, "losses": [3.255690960968077, 7.922326970706947, 9.431755289872799, 7.9574896706060425, 3.2340785435267856]}, "secs": 119.55984807014465}
+{"set": "set1_polypythia", "size": "160m", "pair": [5, 9], "parent_nll": {"a": 3.255690960968077, "b": 3.262358126108427}, "floor": 3.255690960968077, "corpus": "flores200_devtest_eng_Latn", "metric": "nats_per_token", "align_info": {"perm": {"residual": true, "hidden": 12, "heads": 12, "rejected": []}, "orth": {"residual": true, "hidden": 12, "heads": 12, "rejected": []}}, "predictors": {"weight_cosine": 0.03175794804743437, "weight_cosine_bn": 0.20099153645269635, "d_raw": 1.391689139546756, "qmd_perm": 1.3257191886094788, "coord_share_perm": 0.04740279209102856, "norm_ratio_perm": 1.0000000000000007, "qmd_orth": 1.3119229902655778, "coord_share_orth": 0.05731606794542959, "d_raw_bn_perm": 1.2012469216172317, "qmd_bn_perm": 1.1051201293880468, "coordinate_gap_bn_perm": 0.09612679222918485, "coord_fraction_bn_perm": 0.08002250869435729, "d_raw_bn_orth": 1.2012469216172317, "qmd_bn_orth": 1.0719854456121225, "coordinate_gap_bn_orth": 0.12926147600510918, "coord_fraction_bn_orth": 0.10760608304501228, "bnd_raw": 1.2012469216172317, "bnd_perm": 1.1051201293880468, "bnd_orth": 1.0719854456121225, "coord_share_bnd_perm": 0.08002250869435729, "coord_share_bnd_orth": 0.10760608304501228, "cka_mean": 0.4491167062038712, "cka_last": 0.8540013414352915, "qmd_act_perm": 0.7117680963700491, "aligned_cka_perm": 0.2882319036299509, "qmd_act_procrustes": 0.7117680963700488, "aligned_cka_procrustes": 0.2882319036299512, "qmd_act_ot": 0.6231035100779849, "aligned_cka_ot": 0.3768964899220151, "task_vector_cosine": 0.5866746181886868}, "rungs": {"M0_naive_avg": {"nll": 12.76205318921233, "delta_floor": 9.506362228244253, "delta_vs_naive": 0.0}, "M1_perm_avg": {"nll": 10.125313895089286, "delta_floor": 6.869622934121209, "delta_vs_naive": -2.6367392941230428}, "M1_orth_avg": {"nll": 10.130426515105185, "delta_floor": 6.874735554137108, "delta_vs_naive": -2.631626674107144}, "M2_task_arith": {"nll": 35.43659796966732, "delta_floor": 32.18090700869924, "delta_vs_naive": 22.674544780454987}, "M3_ties": {"nll": 60.47141022504892, "delta_floor": 57.215719264080846, "delta_vs_naive": 47.70935703583659}}, "barrier_naive": {"barrier": 9.503028645674078, "losses": [3.255690960968077, 9.004827391144815, 12.76205318921233, 9.568154411539872, 3.262358126108427]}, "barrier_perm": {"barrier": 6.866289530714898, "losses": [3.255690960968077, 8.016000288573263, 10.125313895089286, 8.429588601547211, 3.2623577677806996]}, "secs": 119.26395511627197}

results/set4_tokenizer_diag.json

@@ -0,0 +1,46 @@
+{
+ "eng_Latn": {
+  "eng_tok_tokens": 13449,
+  "eng_tok_bytes_per_token": 4.917614692542196,
+  "eng_tok_unk_rate": 0.0006691947356680794,
+  "own_tok_tokens": 13449,
+  "own_tok_bytes_per_token": 4.917614692542196,
+  "own_tok_unk_rate": 0.0006691947356680794
+ },
+ "nld_Latn": {
+  "eng_tok_tokens": 27457,
+  "eng_tok_bytes_per_token": 2.7147903995338165,
+  "eng_tok_unk_rate": 0.0033142732272280293,
+  "own_tok_tokens": 14656,
+  "own_tok_bytes_per_token": 5.085971615720524,
+  "own_tok_unk_rate": 0.0008187772925764192,
+  "partner_tok_unk_rate_on_ENGLISH_text": 0.0009789273017672213
+ },
+ "spa_Latn": {
+  "eng_tok_tokens": 28343,
+  "eng_tok_bytes_per_token": 2.8297992449634832,
+  "eng_tok_unk_rate": 0.05271142786578697,
+  "own_tok_tokens": 16023,
+  "own_tok_bytes_per_token": 5.00561692566935,
+  "own_tok_unk_rate": 0.0006241028521500343,
+  "partner_tok_unk_rate_on_ENGLISH_text": 0.00037121247273908404
+ },
+ "ell_Grek": {
+  "eng_tok_tokens": 24991,
+  "eng_tok_bytes_per_token": 5.725861310071625,
+  "eng_tok_unk_rate": 0.4648873594494018,
+  "own_tok_tokens": 16049,
+  "own_tok_bytes_per_token": 8.916131846220948,
+  "own_tok_unk_rate": 0.0002492367125677612,
+  "partner_tok_unk_rate_on_ENGLISH_text": 0.0005506374687619128
+ },
+ "pol_Latn": {
+  "eng_tok_tokens": 33295,
+  "eng_tok_bytes_per_token": 2.235650998648446,
+  "eng_tok_unk_rate": 0.11371076738248986,
+  "own_tok_tokens": 14458,
+  "own_tok_bytes_per_token": 5.148429934984092,
+  "own_tok_unk_rate": 0.0003458292986581823,
+  "partner_tok_unk_rate_on_ENGLISH_text": 0.0005674378000872981
+ }
+}