| """Generate every markdown table and assemble RESULTS_CROSSARCH.md from the CSVs on disk.""" |
| import glob, json, os, sys |
| import numpy as np, pandas as pd |
|
|
| ROOT = "/root/crossarch-diagnostics" |
| R, F = f"{ROOT}/results", f"{ROOT}/figures" |
| ORDER = ["EN_pythia", "ZH_pythia", "PT_tucano", "PL_bielik", "IT_minerva"] |
| SHORT = {"EN_pythia": "Pythia-EN", "ZH_pythia": "ZhPythia-ZH", "PT_tucano": "Tucano-PT", |
| "PL_bielik": "Bielik-PL", "IT_minerva": "Minerva-IT"} |
|
|
|
|
| def md(df, floatfmt="%.3f"): |
| d = df.copy() |
| for c in d.columns: |
| if pd.api.types.is_float_dtype(d[c]): |
| d[c] = d[c].map(lambda v: "" if pd.isna(v) else floatfmt % v) |
| return d.to_markdown(index=False) |
|
|
|
|
| def t_roster(): |
| rows = [ |
| ("Pythia-1.4B", "EleutherAI/pythia-1.4b", "EN", "GPT-NeoX", 2048, 24, 16, 50304, "as specified"), |
| ("Zh-Pythia-1.4B", "SJTU-CL/Zh-Pythia-1.4B", "ZH", "GPT-NeoX", 2048, 24, 16, 49953, |
| "as specified; **vocab 49 953 != 50 304**"), |
| ("Tucano-1b1", "TucanoBR/Tucano-1b1", "PT", "LLaMA", 2048, 22, 32, 32000, "as specified"), |
| ("Bielik-1.5B-v3", "speakleash/Bielik-1.5B-v3", "PL", "LLaMA (Qwen2.5-derived)", 1536, 32, 12, |
| 32000, "**MISMATCH: 32 layers, not 28; `model_type: llama`, not qwen2**"), |
| ("Minerva-1B", "sapienzanlp/Minerva-1B-base-v1.0", "IT", "Mistral", 2048, 16, 16, 32768, |
| "as specified"), |
| ] |
| return pd.DataFrame(rows, columns=["model", "HF repo id", "lang", "arch (config `model_type`)", |
| "hidden", "layers", "heads", "vocab", "vs. brief"]) |
|
|
|
|
| def t_cka_triangle(): |
| df = pd.read_csv(f"{R}/crossmodel_pairs.csv") |
| n = len(ORDER) |
| M = pd.DataFrame("--", index=[SHORT[m] for m in ORDER], columns=[SHORT[m] for m in ORDER]) |
| for _, r in df.iterrows(): |
| i, j = ORDER.index(r.model_a), ORDER.index(r.model_b) |
| lo, hi = max(i, j), min(i, j) |
| M.iloc[lo, hi] = f"{r.cka:.3f}" |
| M.iloc[hi, lo] = f"_{r.cka_shuf:.3f}_" |
| for i in range(n): |
| M.iloc[i, i] = "1.000" |
| M.insert(0, "", M.index) |
| return M |
|
|
|
|
| def t_coverage(): |
| df = pd.read_csv(f"{R}/crossmodel_pairs.csv") |
| tp = {} |
| p = f"{R}/transport_merge.csv" |
| if os.path.exists(p): |
| for _, r in pd.read_csv(p).iterrows(): |
| tp.setdefault(f"{r.target}|{r.donor}", []).append(r) |
| rows = [] |
| for _, r in df.iterrows(): |
| key1, key2 = f"{r.model_a}|{r.model_b}", f"{r.model_b}|{r.model_a}" |
| blockers = [] |
| if r.hid_a != r.hid_b: blockers.append(f"hidden {r.hid_a} vs {r.hid_b}") |
| if r.L_a != r.L_b: blockers.append(f"depth {r.L_a} vs {r.L_b}") |
| if r.heads_a != r.heads_b: blockers.append(f"heads {r.heads_a} vs {r.heads_b}") |
| if r.arch_a != r.arch_b: blockers.append(f"arch {r.arch_a} vs {r.arch_b}") |
| if r.vocab_a != r.vocab_b: blockers.append(f"vocab {r.vocab_a} vs {r.vocab_b}") |
| if r.same_param_space: |
| native = "blocks only (vocab differs, so embed/LM head excluded)" \ |
| if r.vocab_a != r.vocab_b else "full" |
| else: |
| native = "NO" |
| transported = "yes" if (key1 in tp or key2 in tp) else "not run (see Cuts)" |
| rows.append(dict(pair=f"{SHORT[r.model_a]} x {SHORT[r.model_b]}", |
| native_weight_merge=native, |
| transport_merge=transported, |
| representation_diagnostics="yes", |
| blocking_differences="; ".join(blockers) or "none")) |
| return pd.DataFrame(rows) |
|
|
|
|
| def t_xmodel(): |
| df = pd.read_csv(f"{R}/crossmodel_pairs.csv") |
| d = df[["model_a", "model_b", "cka", "cka_shuf", "cka_delta", "cka_ci_low", "cka_ci_high", |
| "procrustes", "procrustes_shuf", "svcca", "svcca_shuf", "p_at_1", "p_at_1_shuf", |
| "uriel_syntactic", "uriel_genetic", "uriel_featural", "mean_tok_nll"]].copy() |
| d["pair"] = [f"{SHORT[a]} x {SHORT[b]}" for a, b in zip(d.model_a, d.model_b)] |
| return d.drop(columns=["model_a", "model_b"])[ |
| ["pair", "cka", "cka_shuf", "cka_delta", "cka_ci_low", "cka_ci_high", "procrustes", |
| "procrustes_shuf", "svcca", "svcca_shuf", "p_at_1", "p_at_1_shuf", |
| "uriel_syntactic", "uriel_genetic", "uriel_featural", "mean_tok_nll"]] |
|
|
|
|
| def t_ckpt_summary(): |
| p = f"{R}/checkpoint_pairs.csv" |
| if not os.path.exists(p): return None, None |
| ck = pd.read_csv(p) |
| g = ck.groupby("family").agg( |
| n_pairs=("pair", "count"), |
| median_barrier=("barrier", "median"), max_barrier=("barrier", "max"), |
| median_w_cos=("w_cos", "median"), |
| median_gain_best=("gain_best", "median"), |
| frac_merge_beats_best_endpoint=("gain_best", lambda s: float((s > 0).mean())), |
| median_cka=("cka", "median")).reset_index() |
| return ck, g |
|
|
|
|
| def t_corr(path, top=25): |
| if not os.path.exists(path): return None |
| ct = pd.read_csv(path) |
| if not len(ct): return None |
| d = ct.head(top)[["diag_a", "diag_b", "spearman_rho", "p_asymptotic", "p_permutation", |
| "q_bh", "n_pairs"]] |
| return d |
|
|
|
|
| def main(): |
| os.makedirs(R, exist_ok=True) |
| t_roster().to_csv(f"{R}/table_model_roster.csv", index=False) |
| t_cka_triangle().to_csv(f"{R}/table_cka_triangle.csv", index=False) |
| t_coverage().to_csv(f"{R}/table_coverage.csv", index=False) |
| t_xmodel().to_csv(f"{R}/table_crossmodel_diagnostics.csv", index=False) |
| ck, gsum = t_ckpt_summary() |
| if gsum is not None: |
| gsum.to_csv(f"{R}/table_checkpoint_summary.csv", index=False) |
| qual = json.load(open(f"{R}/model_quality.json")) |
| uriel = json.load(open(f"{R}/provenance_uriel.json"))["uriel_source"] |
| prov = json.load(open(f"{R}/corr_provenance.json")) if os.path.exists(f"{R}/corr_provenance.json") else {} |
|
|
| L = [] |
| A = L.append |
| A(open(f"{ROOT}/scripts/report_head.md").read()) |
| |
| H = ["\n---\n\n## 0. Headline findings\n"] |
| xm0 = pd.read_csv(f"{R}/crossmodel_pairs.csv") |
| H.append(f"1. **Representational alignment is far above the shuffled control for all " |
| f"{len(xm0)} cross-model pairs.** Matched last-layer CKA spans " |
| f"{xm0.cka.min():.3f}-{xm0.cka.max():.3f} (median {xm0.cka.median():.3f}) against a " |
| f"shuffled control of {xm0.cka_shuf.min():.3f}-{xm0.cka_shuf.max():.3f}. Retrieval " |
| f"P@1 after a fitted linear map reaches {xm0.p_at_1.max():.3f} against a chance rate " |
| f"of {xm0.p_at_1_chance.iloc[0]:.4f}. Five different architectures in five different " |
| "languages encode FLORES sentences in near-affinely-related spaces.\n") |
| if os.path.exists(f"{R}/crossmodel_native_geometry.json"): |
| g0 = json.load(open(f"{R}/crossmodel_native_geometry.json")) |
| nm = pd.read_csv(f"{R}/crossmodel_native_merge_summary.csv") |
| en = nm[(nm.host == "EN") & (nm.operator == "lerp")].iloc[0] |
| H.append(f"2. **That alignment does not make the models weight-mergeable.** The one pair " |
| f"with a genuinely shared parameter space (Pythia-EN x Zh-Pythia) has a weight " |
| f"cosine of **{g0['w_cos']:.4f}** over its shared blocks -- they are effectively " |
| f"orthogonal, having been trained from scratch with no common ancestor. Linear " |
| f"interpolation of their blocks raises EN NLL from {en.nll_host_only:.2f} to " |
| f"{en.nll_half:.2f} nats/token at the midpoint, a barrier of " |
| f"{en.barrier:.2f}. High CKA and zero weight-space compatibility coexist.\n") |
| if ck is not None: |
| pyt = ck[ck.family == "pythia"]; zh = ck[ck.family == "zhpythia"] |
| cc = pd.read_csv(f"{R}/corr_checkpoint_ALL.csv") |
| def rho(a, b): |
| m = cc[((cc.diag_a == a) & (cc.diag_b == b)) | ((cc.diag_a == b) & (cc.diag_b == a))] |
| return m.spearman_rho.iloc[0] if len(m) else float("nan") |
| H.append(f"3. **In the native arm, trajectory distance dominates every diagnostic.** Over " |
| f"{len(ck)} within-run checkpoint pairs ({len(pyt)} Pythia + {len(zh)} " |
| f"Zh-Pythia), log10(step_b/step_a) correlates with the task-vector cosine at " |
| f"rho={rho('log10_step_ratio','tau_cos'):.2f}, with TIES sign agreement at " |
| f"{rho('log10_step_ratio','sign_agree'):.2f}, with CKA at " |
| f"{rho('log10_step_ratio','cka'):.2f} and with the best merge gain at " |
| f"{rho('log10_step_ratio','gain_best'):.2f}. The pattern replicates " |
| "independently in both families.\n") |
| near = ck[ck.log10_step_ratio <= 0.5]; far = ck[ck.log10_step_ratio > 1.5] |
| H.append(f"4. **Nearby checkpoints are linearly mode-connected; distant ones are not.** " |
| f"For pairs within half a decade of each other (n={len(near)}) the median LMC " |
| f"barrier is {near.barrier.median():+.3f} nats/token -- at or below zero, i.e. " |
| f"the straight path between them is no worse than its endpoints. Beyond 1.5 " |
| f"decades (n={len(far)}) the median barrier is {far.barrier.median():+.3f}. " |
| f"Merging nonetheless almost never *beats* the better endpoint " |
| f"({100*(ck.gain_best>0).mean():.0f}% of all {len(ck)} pairs), which is expected: " |
| "within one run the later checkpoint is simply the better model, so there is no " |
| "complementary knowledge to combine. Checkpoint merging is the right instrument " |
| "for measuring the geometry, not for producing a better model.\n") |
| H.append(f"5. **The diagnostics are highly redundant.** Weight cosine and relative L2 " |
| f"correlate at rho={rho('w_cos','w_l2_rel'):.2f}; task-vector cosine and sign " |
| f"agreement at {rho('tau_cos','sign_agree'):.2f}. A mergeability panel of a " |
| "dozen columns is measuring far fewer than a dozen things.\n") |
| if os.path.exists(f"{R}/table_transport_summary.csv"): |
| ts = pd.read_csv(f"{R}/table_transport_summary.csv") |
| beat = (ts.ot_minus_rand_target < 0).sum() |
| best = ts.sort_values("delta_target_lang").iloc[0] |
| helped = (ts.delta_target_lang < 0).sum() |
| H.append(f"6. **Transport-based cross-architecture fusion is measurable but, without " |
| f"adaptation, not useful.** All {len(ts)} directed pairs fused successfully, " |
| f"including every rectangular case (1536 <-> 2048 hidden, 16 <-> 32 layers) -- " |
| f"the OT plans are rectangular by construction, so nothing was padded. The " |
| f"learned neuron correspondence is doing real work: the OT plan beats its own " |
| f"shuffled-plan control on the target's language in " |
| f"{(ts.ot_minus_rand_target < 0).sum()}/{len(ts)} directions. But fusion alone " |
| f"improves the target in only {helped}/{len(ts)} directions; the median effect " |
| f"is {ts.delta_target_lang.median():+.4f} nats/token. The exception is " |
| f"instructive: the best result is **{best.target} <- {best.donor}** at " |
| f"{best.delta_target_lang:+.4f}, and the two directions that help at all both " |
| f"have Bielik-PL as the target -- the weakest model in the set " |
| f"(NLL {best.nll_target_lang_a0:.2f}). That is exactly the paper's setting: " |
| "transfer INTO a low-resource target. Cui et al. recover their headline gains " |
| "in the post-fusion adaptation step, which we did not run.\n") |
| A("\n".join(H)) |
| A("\n## 1. The five models, as actually configured\n") |
| A(md(t_roster())) |
| A("\n**Config check.** Four of the five match the brief. **Bielik-1.5B-v3 does not**: its config " |
| "reports `model_type: llama` with **32 layers**, not a 28-layer Qwen2.5. Its geometry " |
| "(hidden 1536, 12 heads, 2 KV heads, FFN 8960) is Qwen2.5-1.5B's, so it is a Qwen2.5-derived " |
| "model re-exported under the Llama class with a 32k Polish-adapted vocabulary. Everything " |
| "below uses the true config, not the brief's.\n") |
| A("\n**Access note.** `speakleash/Bielik-1.5B-v3` and `sapienzanlp/Minerva-1B-base-v1.0` are " |
| "auto-gated on the Hub. The gates were accepted programmatically with the project token to " |
| "obtain the weights; the Bielik gate is a checkbox agreeing to be contacted for feedback. " |
| "Flagging it because it was accepted on the account owner's behalf.\n") |
|
|
| A("\n## 2. Coverage: which pairs were merged, by which route, and why\n") |
| A(md(t_coverage())) |
| A("") |
|
|
| A("\n## 3. Table 3 equivalent -- last-layer matched vs shuffled CKA\n") |
| A("Lower triangle = matched. _Upper triangle, italic_ = shuffled control.\n") |
| A(t_cka_triangle().to_markdown(index=False)) |
| A("") |
|
|
| A("\n## 4. The 10-pair cross-model diagnostic matrix\n") |
| A(md(t_xmodel())) |
| A("") |
| A("\nPer-model quality (mean per-token NLL on that model's own FLORES-200 devtest side):\n") |
| q = pd.DataFrame([dict(model=SHORT[k], tok_nll=v["tok_nll"], sent_nll=v["sent_nll"]) |
| for k, v in qual.items()]) |
| A(md(q)) |
| A(f"\nURIEL source: `{uriel}`.\n") |
|
|
| if ck is not None: |
| A("\n## 5. Checkpoint merging -- the native weight-space arm\n") |
| A(md(gsum)) |
| A("") |
| A("\nAll of these are **native** merges: same run, same architecture, same vocabulary, " |
| "same parameter space. No alignment, no transport, no padding.\n") |
| piv = ck.groupby(pd.cut(ck.log10_step_ratio, [0, .5, 1, 1.5, 2, 3, 6])).agg( |
| n=("pair", "count"), barrier=("barrier", "median"), w_cos=("w_cos", "median"), |
| gain_best=("gain_best", "median"), cka=("cka", "median")).reset_index() |
| piv.columns = ["log10(step_b/step_a) bin", "n", "median barrier", "median w_cos", |
| "median gain_best", "median CKA"] |
| piv["log10(step_b/step_a) bin"] = piv["log10(step_b/step_a) bin"].astype(str) |
| A("\nBy trajectory distance:\n") |
| A(md(piv)) |
| A("") |
|
|
| p = f"{R}/table_family_comparison.csv" |
| if os.path.exists(p): |
| A("\n### 4b. This family beside the project's other two\n") |
| A("The one number that is comparable across the three studies is last-layer, SGPT-pooled, " |
| "FLORES matched CKA. Read the `note` column before comparing rows -- the Goldfish " |
| "values were transcribed upstream and were not recomputed under this protocol.\n") |
| A(md(pd.read_csv(p))) |
| A("") |
|
|
| p = f"{R}/crossmodel_native_merge_summary.csv" |
| if os.path.exists(p): |
| A("\n## 6. The one natively weight-mergeable cross-model pair: Pythia-EN x Zh-Pythia\n") |
| g = json.load(open(f"{R}/crossmodel_native_geometry.json")) |
| A(f"Shared parameter space covers **{g['n_shared_tensors']} tensors / " |
| f"{g['n_shared_params']:,} parameters** (every transformer block). Excluded because the " |
| f"shapes differ: `{'`, `'.join(g['excluded_tensors'])}` -- Zh-Pythia's 49 953-entry " |
| "vocabulary against Pythia's 50 304.\n") |
| A(f"\nWeight cosine over the shared blocks: **{g['w_cos']:.4f}**; relative L2 " |
| f"**{g['w_l2_rel']:.3f}**; norm ratio {g['norm_ratio']:.3f}.\n") |
| A("\nOnly base-free operators are defined here (the two models have no shared " |
| "pre-trained ancestor, so task vectors `theta - theta_base` are meaningless across " |
| "them). `t=0` is the host alone; `t=1` replaces every block with the donor's.\n") |
| A(md(pd.read_csv(p), "%.4f")) |
| A("") |
|
|
| p = f"{R}/table_transport_summary.csv" |
| if os.path.exists(p): |
| A("\n## 7. Transport-based cross-architecture merging\n") |
| A("Directional: the target keeps its architecture, tokenizer, embeddings and LM head. " |
| "Donor weights are carried into the target's coordinate system by entropic-OT neuron " |
| "plans plus a layer-level OT, then fused on a top-128 neuron mask. Fusion only -- " |
| "**no post-fusion adaptation**, which is where Cui et al. get most of their gain. " |
| "Deviations from the released code are listed in the header of " |
| "`scripts/transport_merge.py`; the load-bearing one is that we rescale each plan to be " |
| "row-stochastic, without which the transported term is numerically ~0.\n") |
| A(md(pd.read_csv(p), "%.4f")) |
| A("\n**Deviations from the paper / the released code**, all deliberate and all " |
| "reproducible from `scripts/transport_merge.py`:\n\n" |
| "- *Plan normalisation.* Neither the paper nor the released code rescales the OT plan " |
| "`Q`, whose rows sum to `1/n`. The transported term is then smaller than the donor " |
| "weight by ~`1/(n_out n_in)`, so the fusion degenerates into a `(1-alpha)` shrinkage of " |
| "the masked entries rather than a change of basis. We use the standard OT-fusion " |
| "convention `Phi = n * Q` so each plan is row-stochastic.\n" |
| "- *Epsilon 0.1 -> 0.01.* Our neuron costs `1-rho` have mean 1.00 and sd 0.07-0.10; at " |
| "the paper's `eps=0.1` the plan sits close to the uniform coupling (row max 0.006 " |
| "against a uniform 0.0005) and fusion through it is indistinguishable from fusion " |
| "through a shuffled plan -- which is exactly what the random-plan control showed. At " |
| "`eps=0.01` the plan is a soft near-assignment whose transport cost is within 1% of the " |
| "unregularised optimum. Evidence: `results/ot_epsilon_calibration.txt`.\n" |
| "- *Sublayer coverage.* The released code transports attention q/k/v/o. Across these " |
| "five models the attention sublayer is not commensurable (GPT-NeoX fuses QKV; head " |
| "counts 12/16/32; GQA with 2 or 4 KV heads), so we transport the interfaces every one " |
| "of them shares: the MLP (`d_model -> d_ffn -> d_model`) and the attention output " |
| "projection. q/k/v keep the target's own values.\n" |
| "- *Layer-pair pruning and layer-cost subsampling.* The outer OT needs only the scalar " |
| "`<C,Q>` per layer pair, so that pass runs on a fixed random subsample of at most 2048 " |
| "neurons per side; fusion uses full dimensions, on the top-3 donor layers per target " |
| "layer, with `P_eff` renormalised over the kept entries.\n" |
| "- *No post-fusion adaptation.*\n\n" |
| "Negative `delta_*` means fusion reduced NLL (helped); positive means it hurt. " |
| "`nll_donor_lang` is the target model evaluated on the donor's language with the " |
| "target's own tokenizer -- the setting where transferred donor knowledge would show up. " |
| "`ot_minus_rand_*` is the control: negative means the OT plan beat a shuffled plan.\n") |
| A("\nThe control splits the pairs cleanly, and the split is interpretable. Every " |
| "direction with **Bielik-PL as target** has the OT plan beating its shuffled control on " |
| "both languages -- transporting into the weakest model in the set is where the learned " |
| "correspondence pays. Every direction with **Zh-Pythia as donor** has the OT plan doing " |
| "markedly *worse* than random. That is not the plan being uninformative -- an " |
| "uninformative plan scores zero on this axis, as the middle of the ranking does -- it is " |
| "the plan being confidently wrong. The probe sides there are Chinese against a " |
| "Latin-script language, and a neuron correspondence fitted on 512 mean-pooled samples " |
| "across that gap appears to concentrate transported mass on the wrong neurons. More " |
| "probe data (the paper uses 2000) is the obvious first thing to try.\n") |
|
|
| for tag, path, note in [ |
| ("checkpoint arm (native weight merging)", f"{R}/corr_checkpoint_ALL.csv", |
| "n is adequate here."), |
| ("cross-model arm", f"{R}/corr_crossmodel.csv", |
| "**n=10. This is badly underpowered.** Spearman rho on 10 points has a 95% CI roughly " |
| "+/-0.6 wide; nothing short of |rho|>0.65 clears an uncorrected permutation test, and " |
| "nothing at all survives BH correction across 55 comparisons. Read the signs, not the " |
| "significance.")]: |
| d = t_corr(path) |
| if d is None: continue |
| A(f"\n## 8. Diagnostic x diagnostic Spearman correlations -- {tag}\n") |
| A(f"{note} Permutation null: {prov.get('n_perm', 20000)} label shuffles per cell; " |
| "`q_bh` is Benjamini-Hochberg across the whole table.\n") |
| A(md(d, "%.4f")) |
| A("") |
|
|
| A("\n## 9. Figures\n") |
| for f, cap in [("fig1_cka_matched_shuffled.png", "matched vs shuffled last-layer CKA, 5 models"), |
| ("fig2a_corr_checkpoint.png", "diagnostic correlation heatmap, checkpoint arm"), |
| ("fig2b_corr_crossmodel.png", "diagnostic correlation heatmap, cross-model arm (n=10)"), |
| ("fig3_checkpoint_merge.png", "checkpoint merge results vs trajectory distance"), |
| ("fig4_transport_merge.png", "transport-based cross-architecture merge")]: |
| if os.path.exists(f"{F}/{f}"): |
| A(f"\n\n*{cap}*\n") |
| A(open(f"{ROOT}/scripts/report_tail.md").read()) |
| out = "\n".join(L) |
| open(f"{ROOT}/RESULTS_CROSSARCH.md", "w").write(out) |
| print("wrote RESULTS_CROSSARCH.md", len(out), "chars") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
