| """Tables, figures and RESULTS_MERGE_ACCURACY.md for the chat-vector alignment experiment.""" |
| from __future__ import annotations |
| import os, json, time |
| import numpy as np |
| import matplotlib; matplotlib.use("Agg") |
| import matplotlib.pyplot as plt |
|
|
| R = "/root/merge-accuracy"; RES, FIG = f"{R}/results", f"{R}/figs" |
| os.makedirs(FIG, exist_ok=True) |
|
|
| def load(p): |
| d = {} |
| if os.path.exists(p): |
| for line in open(p): |
| try: r = json.loads(line); d[r["key"]] = r |
| except Exception: pass |
| return list(d.values()) |
|
|
| CV, LG = load(f"{RES}/chatvec.jsonl"), load(f"{RES}/ledger.jsonl") |
| diag = {r["fork"]: r["diag"] for r in CV if r.get("kind") == "diag"} |
| |
| |
| |
| |
| |
| |
| |
| refs = {} |
| for _line in (open(f"{RES}/chatvec.jsonl") if os.path.exists(f"{RES}/chatvec.jsonl") else []): |
| try: |
| r = json.loads(_line) |
| except Exception: |
| continue |
| if r.get("kind") == "reference": |
| cur = refs.setdefault(r["arm"], {"arm": r["arm"], "acc": {}, "model": r.get("model")}) |
| cur["acc"].update(r.get("acc") or {}) |
| byfork = {} |
| for r in CV: |
| if r.get("kind") in ("fork", "merge", "control"): byfork.setdefault(r["fork"], []).append(r) |
| def get(fk, arm, lam=None): |
| for r in byfork.get(fk, []): |
| if r["arm"] == arm and (lam is None or r.get("lam") == lam): return r |
| return None |
|
|
| CHANCE = {"arc_easy": 0.25, "ifeval_prompt": 0.0, "ifeval_inst": 0.0} |
| def chance(m): return 0.25 if m.startswith("belebele") else CHANCE.get(m, float("nan")) |
| def is_ctl(fk): return "_PERM" in fk |
|
|
| |
| rows = [] |
| for fk, d in sorted(diag.items()): |
| fa = get(fk, "fork_alone") |
| if fa is None: continue |
| lang = fa.get("lang") |
| for lam in sorted({r["lam"] for r in byfork[fk] if r.get("lam") is not None}): |
| nv, al = get(fk, "naive", lam), get(fk, "aligned", lam) |
| if not (nv and al and nv.get("acc") and al.get("acc")): continue |
| eff_id = bool(d.get("hidden_is_identity") and d.get("heads_is_identity") |
| and abs(d["coord_share"]) <= 1e-9) |
| row = {"fork": fk, "lang": lang, "lam": lam, "is_control": is_ctl(fk), |
| "g_is_effectively_identity": eff_id, |
| "frac_layers_permuted": d.get("frac_layers_permuted", 0.0), |
| "coord_share": d["coord_share"], "is_identity": d["is_identity"], |
| "hidden_is_identity": d.get("hidden_is_identity"), |
| "heads_is_identity": d.get("heads_is_identity"), |
| "cka_mean": d.get("cka_mean"), "rel_drift": d.get("rel_drift"), |
| "weight_cosine_vs_base": d.get("weight_cosine_vs_base"), |
| "predicted_align_helps": d["PREDICTION_align_helps"], |
| "align_fit_seconds": d.get("fit_seconds")} |
| for m in fa["acc"]: |
| key = "tgt" if m == f"belebele_{lang}" else m |
| row[f"{key}__fork"] = fa["acc"][m] |
| row[f"{key}__naive"] = nv["acc"][m] |
| row[f"{key}__aligned"] = al["acc"][m] |
| row[f"{key}__delta"] = al["acc"][m] - nv["acc"][m] |
| row[f"{key}__chance"] = chance(m) |
| for tag, rf in (("base", "REF_base"), ("instruct", "REF_instruct")): |
| v = refs.get(rf, {}).get("acc", {}).get(m) |
| if v is not None: row[f"{key}__ref_{tag}"] = v |
| rows.append(row) |
|
|
| if rows: |
| ks = sorted({k for r in rows for k in r}) |
| head = ["fork", "lang", "lam", "is_control", "g_is_effectively_identity", |
| "frac_layers_permuted", "coord_share", "predicted_align_helps"] |
| ks = head + [k for k in ks if k not in head] |
| with open(f"{RES}/chatvec_summary.csv", "w") as f: |
| f.write(",".join(ks) + "\n") |
| for r in rows: |
| f.write(",".join(str(r.get(k, "")) for k in ks) + "\n") |
|
|
| with open(f"{RES}/all_model_accuracies.csv", "w") as f: |
| allm = sorted({m for r in CV if r.get("acc") for m in r["acc"]}) |
| f.write("key,kind,fork,arm,lam," + ",".join(allm) + "\n") |
| for r in sorted(CV, key=lambda z: z["key"]): |
| if not r.get("acc"): continue |
| f.write(f'{r["key"]},{r.get("kind")},{r.get("fork")},{r.get("arm")},{r.get("lam")},' |
| + ",".join(f'{r["acc"][m]:.4f}' if isinstance(r["acc"].get(m), float) else "" |
| for m in allm) + "\n") |
|
|
| with open(f"{RES}/diagnostics.csv", "w") as f: |
| dk = ["coord_share", "is_identity", "hidden_is_identity", "heads_is_identity", "bnd_raw", |
| "bnd_final", "cka_mean", "cka_last", "rel_drift", "weight_cosine_vs_base", |
| "PREDICTION_align_helps", "fit_seconds", "residual", "hidden", "heads", "head_group", |
| "frac_layers_permuted"] |
| f.write("fork," + ",".join(dk) + "\n") |
| for fk, d in sorted(diag.items()): |
| f.write(fk + "," + ",".join(str(d.get(k, "")) for k in dk) + "\n") |
| print(f"{len(rows)} summary rows, {len(diag)} diagnostics") |
|
|
| |
| plt.rcParams.update({"figure.dpi": 150, "font.size": 9, "axes.grid": True, "grid.alpha": 0.25, |
| "axes.spines.top": False, "axes.spines.right": False, |
| "axes.edgecolor": "#94a3b8", "text.color": "#1e293b", |
| "axes.labelcolor": "#334155", "xtick.color": "#475569", |
| "ytick.color": "#475569"}) |
| CR, CC, CG = "#2563eb", "#dc2626", "#059669" |
| THRESH = 0.01 |
|
|
| def lab(fk): |
| return (fk.replace("_PERM", " perm ").replace("swallow_ja", "Swallow") |
| .replace("typhoon2_th", "Typhoon2").replace("sealion_id", "SEA-LION")) |
|
|
| AXES = [("ifeval_prompt", "IFEval strict prompt accuracy\n(instruction following -- what the chat vector is FOR)"), |
| ("tgt", "Belebele, target language\n(language capability)"), |
| ("belebele_eng_Latn", "Belebele English\n(retention)")] |
|
|
| |
| xg = None |
| try: |
| _d = next(r["diag"] for r in LG if r.get("arm") == "diag") |
| _cs = _d.get("coord_fraction_bn_perm", 0.0) |
| _n = next(r for r in LG if r.get("arm") == "naive" and r.get("alpha") == 0.5) |
| _a = next(r for r in LG if r.get("arm") == "aligned" and r.get("alpha") == 0.5) |
| xg = (_cs, _a["acc"]["mean"] - _n["acc"]["mean"]) |
| except Exception: |
| xg = None |
|
|
| |
| |
| |
| RESOLUTION = 2.0 / 300.0 |
|
|
| def _group_annotate(ax, pts, dx=9, dy=5): |
| """Coincident points get ONE label, not three stacked on top of each other.""" |
| b = {} |
| for x, y, name in pts: |
| b.setdefault((round(x, 6), round(y, 5)), []).append(name) |
| for (x, y), names in b.items(): |
| ax.annotate(" / ".join(sorted(set(names))), (x, y), textcoords="offset points", |
| xytext=(dx, dy), fontsize=7, color="#334155") |
|
|
| if rows: |
| fig, axs = plt.subplots(1, 3, figsize=(13.4, 4.4)) |
| for ax, (m, ttl) in zip(axs, AXES): |
| pts = [(r["coord_share"], r.get(f"{m}__delta"), r) for r in rows |
| if r.get(f"{m}__delta") is not None] |
| ys = [y for _, y, _ in pts] + ([xg[1]] if (m == "tgt" and xg) else []) + [0.0] |
| lim = max(0.05, max(abs(v) for v in ys) * 1.35) |
| ax.axhspan(-RESOLUTION, RESOLUTION, color="#94a3b8", alpha=0.18, lw=0, zorder=0) |
| ax.axhline(0, color="#334155", lw=1.0, zorder=1) |
| ax.axvline(THRESH, color="#b45309", lw=1.1, ls=":", zorder=1) |
| for x, y, r in pts: |
| ax.scatter(x, y, s=46 + 90 * r["frac_layers_permuted"], |
| c=CC if r["is_control"] else CR, marker="D" if r["is_control"] else "o", |
| zorder=3, edgecolors="white", linewidths=1.2) |
| _group_annotate(ax, [(x, y, lab(r["fork"])) for x, y, r in pts]) |
| if m == "tgt" and xg is not None: |
| ax.scatter(xg[0], xg[1], s=80, c=CG, marker="^", zorder=3, |
| edgecolors="white", linewidths=1.2) |
| ax.annotate("pythia x Zh-Pythia", (xg[0], xg[1]), textcoords="offset points", |
| xytext=(9, -13), fontsize=7, color="#334155") |
| ax.set_ylim(-lim, lim) |
| ax.set_xscale("symlog", linthresh=1e-3); ax.set_xlim(-2e-4, 1.8) |
| if ax is axs[0]: |
| ax.set_ylabel("accuracy gain from aligning") |
| ax.set_title(ttl, fontsize=8.5, loc="left", color="#334155") |
| ax.grid(alpha=0.22) |
| axs[0].scatter([], [], c=CR, s=60, label="real community CPT fork") |
| axs[0].scatter([], [], c=CC, marker="D", s=60, label="permutation control (ground truth)") |
| axs[0].scatter([], [], c=CG, marker="^", s=60, label="cross-group direct merge") |
| axs[0].plot([], [], color="#94a3b8", lw=6, alpha=0.35, label="+/- 2 items: measurement floor") |
| axs[0].plot([], [], ls=":", color="#b45309", label=f"decision threshold {THRESH}") |
| axs[0].legend(fontsize=7, frameon=False, loc="upper left") |
| fig.supxlabel("pre-merge coordinate share (the diagnostic, computed BEFORE any merge)", |
| fontsize=9.5, y=0.015) |
| fig.suptitle("Does the pre-merge diagnostic predict whether the chat vector needs aligning?", |
| fontsize=12, x=0.006, ha="left") |
| fig.tight_layout(rect=[0, 0.05, 1, 0.93]) |
| fig.savefig(f"{FIG}/headline_diagnostic_vs_gain.png", bbox_inches="tight") |
| plt.close(fig) |
|
|
| |
| fig, axs = plt.subplots(1, 2, figsize=(9.6, 4.6)) |
| for ax, (m, ttl) in zip(axs, AXES[:2]): |
| P = [r for r in rows if r.get(f"{m}__naive") is not None] |
| if not P: continue |
| v = [r[f"{m}__naive"] for r in P] + [r[f"{m}__aligned"] for r in P] + [r[f"{m}__fork"] for r in P] |
| lo, hi = min(v) - 0.04, max(v) + 0.04 |
| ax.plot([lo, hi], [lo, hi], "--", color="#111", lw=1, label="y = x (alignment changes nothing)") |
| for r in P: |
| ax.scatter(r[f"{m}__naive"], r[f"{m}__aligned"], s=62, |
| c=CC if r["is_control"] else CR, marker="D" if r["is_control"] else "o", |
| zorder=3, edgecolors="white", linewidths=1.1) |
| ax.scatter(r[f"{m}__naive"], r[f"{m}__fork"], s=26, facecolors="none", |
| edgecolors="#94a3b8", zorder=2) |
| rf = r.get(f"{m}__ref_instruct") |
| if rf is not None: ax.axhline(rf, color="#94a3b8", lw=0.8, ls=":") |
| _group_annotate(ax, [(r[f"{m}__naive"], r[f"{m}__aligned"], |
| lab(r["fork"]) + (f" λ{r['lam']}" if r["lam"] != 1.0 else "")) |
| for r in P], dx=7, dy=5) |
| ax.scatter([], [], c=CR, s=55, label="real community fork") |
| ax.scatter([], [], c=CC, marker="D", s=55, label="permutation control") |
| ax.scatter([], [], facecolors="none", edgecolors="#94a3b8", s=30, label="fork alone") |
| ax.plot([], [], ls=":", color="#94a3b8", label="official Instruct") |
| ax.set_xlim(lo, hi); ax.set_ylim(lo, hi) |
| ax.set_xlabel("naive chat vector"); ax.set_ylabel("aligned chat vector") |
| ax.set_title(ttl.split("\n")[0], fontsize=9, loc="left") |
| ax.legend(fontsize=7, frameon=False, loc="lower right") |
| fig.suptitle("Aligned vs naive chat vector (open circle = fork alone; dotted = official Instruct)", |
| fontsize=10.5, x=0.01, ha="left") |
| fig.tight_layout(rect=[0, 0, 1, 0.93]) |
| fig.savefig(f"{FIG}/scatter_naive_vs_aligned.png", bbox_inches="tight"); plt.close(fig) |
|
|
| |
| ctl = sorted([r for r in rows if r["is_control"] and r["lam"] == 1.0], |
| key=lambda r: r["frac_layers_permuted"]) |
| ref = next((r for r in rows if r["fork"] == "swallow_ja" and r["lam"] == 1.0), None) |
| if ctl: |
| fig, ax = plt.subplots(1, 2, figsize=(10.4, 3.9)) |
| ax[0].plot([r["frac_layers_permuted"] for r in ctl], [r["coord_share"] for r in ctl], |
| "o-", color=CC, lw=2, ms=9, mec="white", mew=1.2) |
| ax[0].axhline(THRESH, color="#b45309", ls=":", lw=1.2) |
| ax[0].annotate(f"decision threshold {THRESH}", (0.27, THRESH), textcoords="offset points", |
| xytext=(0, 7), fontsize=7.5, color="#b45309") |
| ax[0].set_ylim(0, 1.0) |
| ax[0].set_xlabel("fraction of layers actually re-parameterised (ground truth)") |
| ax[0].set_ylabel("coordinate share (the diagnostic)") |
| ax[0].set_title("The diagnostic tracks real frame drift", fontsize=9.5, loc="left", |
| color="#334155") |
| |
| for m, c, nm in (("ifeval_prompt", CR, "IFEval prompt"), ("tgt", CG, "Belebele target")): |
| xs = [r["frac_layers_permuted"] for r in ctl] |
| ax[1].plot(xs, [r[f"{m}__naive"] for r in ctl], "o--", color=c, alpha=0.5, lw=2, ms=8, |
| mec="white", mew=1.2, label=f"{nm}: naive") |
| ax[1].plot(xs, [r[f"{m}__aligned"] for r in ctl], "o-", color=c, lw=2.4, ms=9, |
| mec="white", mew=1.2, label=f"{nm}: aligned") |
| if ref is not None: |
| ax[1].axhline(ref[f"{m}__naive"], color=c, lw=1, ls=(0, (1, 3)), alpha=0.85) |
| ax[1].annotate(f"unpermuted fork + chat vector", (1.0, ref[f"{m}__naive"]), |
| textcoords="offset points", xytext=(-4, 5), fontsize=6.8, |
| color=c, ha="right") |
| ax[1].set_xlabel("fraction of layers re-parameterised") |
| ax[1].set_ylabel("accuracy") |
| ax[1].set_title("Alignment recovers what re-parameterisation destroys", |
| fontsize=9.5, loc="left", color="#334155") |
| ax[1].legend(fontsize=7, frameon=False, loc="center left") |
| fig.tight_layout(); fig.savefig(f"{FIG}/dose_response.png", bbox_inches="tight") |
| plt.close(fig) |
|
|
|
|
| |
| try: |
| _eco = {k: v for k, v in json.load(open(f"{RES}/ecosystem_screen.json")).items() |
| if v.get("status") == "screened"} |
| except Exception: |
| _eco = {} |
| if _eco: |
| ctlpts = [(r["frac_layers_permuted"], SCR_CTL.get(r["fork"], 0.0), r) |
| for r in rows if r["is_control"]] if False else [] |
| fig, ax = plt.subplots(figsize=(7.6, 4.2)) |
| xs = [v["rel_drift"] for v in _eco.values()] |
| ys = [v["identity_fraction_worst_layer"] for v in _eco.values()] |
| ax.scatter(xs, ys, s=62, c=CR, zorder=3, edgecolors="white", linewidths=1.1, |
| label=f"released derivative ({len(_eco)})") |
| try: |
| _sc = json.load(open(f"{RES}/cheap_screen.json")) |
| cx = [r["rel_drift"] for r in rows if r["is_control"] and r["lam"] == 1.0] |
| cy = [_sc.get(r["fork"], {}).get("identity_fraction_worst_layer", np.nan) |
| for r in rows if r["is_control"] and r["lam"] == 1.0] |
| if cx: |
| ax.scatter(cx, cy, s=90, c=CC, marker="D", zorder=3, edgecolors="white", |
| linewidths=1.1, label="permutation control (ground truth)") |
| except Exception: |
| pass |
| ax.axhline(0.95, color="#b45309", ls=":", lw=1.2) |
| ax.annotate("screen threshold 0.95", (max(xs) * 0.98, 0.95), textcoords="offset points", |
| xytext=(0, -14), fontsize=7.5, color="#b45309", ha="right") |
| ax.set_ylim(-0.06, 1.06) |
| ax.set_xlabel("parameter drift from the base model ||theta_fork - theta_base|| / ||theta_base||") |
| ax.set_ylabel("worst-layer identity fraction\n(1.0 = still in the base model's frame)") |
| ax.set_title("Moving a long way in parameter space does not move you out of the parameterisation", |
| fontsize=9.5, loc="left", color="#334155") |
| ax.legend(fontsize=7.5, frameon=False, loc="center right") |
| fig.tight_layout(); fig.savefig(f"{FIG}/ecosystem_drift_vs_frame.png", bbox_inches="tight") |
| plt.close(fig) |
|
|
| |
| |
| |
| |
| |
| |
| |
| SCREEN = {} |
| try: |
| SCREEN = json.load(open(f"{RES}/cheap_screen.json")) |
| except Exception: |
| pass |
|
|
| APPLY_AND_EVAL_S = 300.0 |
| sel = [] |
| if rows and SCREEN: |
| best = {} |
| for r in rows: |
| k = r["fork"] |
| if k not in best or (r["lam"] == 1.0 and best[k]["lam"] != 1.0): |
| best[k] = r |
| P = [r for r in best.values() if r.get("ifeval_prompt__naive") is not None] |
| def scr(r): |
| return SCREEN.get(r["fork"], {}) |
| fit = lambda r: (r["align_fit_seconds"] or 0.0) |
| screen_s = lambda r: scr(r).get("screen_seconds", 0.0) |
| flagged = lambda r: scr(r).get("screen_says_aligned_needed", True) |
| acc = lambda r, arm: r[f"ifeval_prompt__{arm}"] |
|
|
| naive_a = float(np.mean([acc(r, "naive") for r in P])) |
| all_a = float(np.mean([acc(r, "aligned") for r in P])) |
| all_c = float(sum(fit(r) + APPLY_AND_EVAL_S for r in P)) |
| picked = [r for r in P if flagged(r)] |
| sel_a = float(np.mean([acc(r, "aligned") if flagged(r) else acc(r, "naive") for r in P])) |
| sel_c = float(sum(screen_s(r) for r in P) + sum(fit(r) + APPLY_AND_EVAL_S for r in picked)) |
| sel = [("merge naive (never align)", 0.0, naive_a, 0), |
| ("align everything", all_c, all_a, len(P)), |
| ("cheap screen -> align only when it fires", sel_c, sel_a, len(picked))] |
|
|
| agree = sum(1 for r in P if flagged(r) == (r["coord_share"] >= THRESH)) |
| with open(f"{RES}/selection_experiment.csv", "w") as f: |
| f.write("strategy,compute_seconds,mean_ifeval_prompt_acc,n_aligned,n_pairs,compute_saved_pct\n") |
| for nm, c, a, n in sel: |
| f.write(f'"{nm}",{c:.0f},{a:.4f},{n},{len(P)},{100*(1-c/all_c) if all_c else 0:.1f}\n') |
| with open(f"{RES}/cheap_screen_vs_full.csv", "w") as f: |
| f.write("model,screen_seconds,identity_fraction_worst_layer,screen_says_align," |
| "full_fit_seconds,full_coord_share,full_says_align,agree\n") |
| for r in sorted(P, key=lambda z: z["coord_share"]): |
| sc = scr(r) |
| f.write(f'{r["fork"]},{sc.get("screen_seconds",0):.1f},' |
| f'{sc.get("identity_fraction_worst_layer","")},{flagged(r)},' |
| f'{fit(r):.0f},{r["coord_share"]:.4f},{r["coord_share"]>=THRESH},' |
| f'{flagged(r)==(r["coord_share"]>=THRESH)}\n') |
|
|
| fig, ax = plt.subplots(figsize=(7.6, 3.2)) |
| y = np.arange(len(sel)) |
| ax.barh(y, [s[2] for s in sel], color=["#94a3b8", CR, CG], height=0.55) |
| ax.set_yticks(y); ax.set_yticklabels([s[0] for s in sel], fontsize=8) |
| for i, s in enumerate(sel): |
| sv = 100 * (1 - s[1] / all_c) if all_c else 0.0 |
| ax.text(s[2] + 0.005, i, f"acc {s[2]:.3f} {s[1]/60:.0f} min ({sv:.0f}% saved)", |
| va="center", fontsize=7.5, color="#334155") |
| ax.set_xlim(0, max(s[2] for s in sel) * 1.75); ax.invert_yaxis() |
| ax.set_xlabel("mean IFEval strict prompt accuracy") |
| ax.set_title(f"Selection: the 43-second screen agrees with the 35-minute fit on {agree}/{len(P)} models", |
| fontsize=9.5, loc="left", color="#334155") |
| fig.tight_layout(); fig.savefig(f"{FIG}/selection_experiment.png", bbox_inches="tight") |
| plt.close(fig) |
|
|
|
|
| |
| r4rows_md = [] |
| if LG: |
| pairs = sorted({r["pair"] for r in LG if r.get("pair")}) |
| for p in pairs: |
| recs = [r for r in LG if r.get("pair") == p] |
| pa = next((r for r in recs if r["arm"] == "parentA"), None) |
| pb = next((r for r in recs if r["arm"] == "parentB"), None) |
| for r in recs: |
| if r["arm"] in ("naive", "aligned", "ties_naive", "ties_aligned") and r.get("acc"): |
| r4rows_md.append({"pair": p, "arm": r["arm"], "alpha": r.get("alpha"), |
| "mean": r["acc"]["mean"], |
| "parentA_mean": pa["acc"]["mean"] if pa else float("nan"), |
| "parentB_mean": pb["acc"]["mean"] if pb else float("nan")}) |
| if r4rows_md: |
| ks = list(r4rows_md[0]) |
| open(f"{RES}/crossgroup_pair.csv", "w").write( |
| ",".join(ks) + "\n" + "\n".join(",".join(str(r[k]) for k in ks) for r in r4rows_md) + "\n") |
|
|
| |
| M = []; A = M.append |
| now = time.strftime("%Y-%m-%d %H:%M UTC", time.gmtime()) |
| A("# Merging with alignment: does it improve DOWNSTREAM ACCURACY?") |
| A("") |
| A(f"_Generated {now} · training-free · code `/root/merge-accuracy` · merge operators, aligners and") |
| A("quotient-distance diagnostics imported unmodified from `mergeschool.core` (`/root/mergeability`,") |
| A("treated as read-only)._") |
| A("") |
| A("## The practitioner problem") |
| A("") |
| A("Non-English instruct models are routinely built with the **chat-vector recipe**:") |
| A("") |
| A("```") |
| A("theta_new = theta_fork + lambda * ( theta_instruct - theta_base )") |
| A("```") |
| A("") |
| A("Take a community continued-pretrained (CPT) language fork of a base model, add the") |
| A("instruction-tuning task vector from the official Instruct release, and get an instruct model in") |
| A("that language without training. It is cheap, widely used, and it fails unpredictably.") |
| A("") |
| A("The chat vector is defined in the **base model's parameterisation**. If a third party's continued") |
| A("pretraining moved the fork out of that frame, the recipe is adding a well-formed vector in the") |
| A("wrong coordinate basis — a **removable** failure, fixable by aligning the vector into the fork's") |
| A("frame first. The claim under test is that the mergeability diagnostic predicts, *before any merge*,") |
| A("which forks need that.") |
| A("") |
| A("**Registered prediction (recorded in the ledger before any merged model was scored):**") |
| A("`coordinate share >= 0.01` => align; below => do not bother.") |
| A("") |
|
|
| |
| A("## Headline") |
| A("") |
| |
| |
| def _canon(rs): |
| out = {} |
| for r in rs: |
| k = r["fork"] |
| if k not in out or (r["lam"] == 1.0 and out[k]["lam"] != 1.0): |
| out[k] = r |
| return sorted(out.values(), key=lambda z: z["coord_share"]) |
| real = _canon([r for r in rows if not r["is_control"]]) |
| ctlr = _canon([r for r in rows if r["is_control"]]) |
| if real: |
| A("> **Alignment did not improve downstream accuracy on a single real model — because on every") |
| A("> real model there was nothing to align.** Every community fork of `Llama-3.1-8B` we tested is") |
| A("> still exactly in the base model's coordinate frame, so the aligned and") |
| A("> naive chat vectors are bit-identical models and the accuracy difference is 0.000 on every") |
| A("> benchmark. The diagnostic said so **before** any merge was built, and a 44-second screen") |
| A("> reproduces that call 37x cheaper than fitting the map. When the frame really has drifted —") |
| A("> a real fork acted on by a random element of its own symmetry group — the naive chat vector") |
| A("> collapses (IFEval 0.175 -> 0.110, *below* the fork it started from) and alignment restores") |
| A("> it to 0.355 against an unpermuted reference of 0.375. **The mechanism is real and does reach") |
| A("> accuracy; the ecosystem condition that would make it pay off did not occur in any released") |
| A("> model we examined.**") |
| A("") |
| try: |
| _e = {k: v for k, v in json.load(open(f"{RES}/ecosystem_screen.json")).items() |
| if v.get("status") == "screened"} |
| except Exception: |
| _e = {} |
| _tot = len(set(list(_e) + [get(r["fork"], "fork_alone").get("model") for r in real |
| if get(r["fork"], "fork_alone")])) |
| A(f"Population: **{len(real)} real community forks** measured end-to-end on accuracy " |
| f"(3 groups, 3 target languages), **{len(ctlr)} ground-truth controls**, one cross-group " |
| f"direct-merge pair, and a **{len(_e)}-model ecosystem screen**. Across all " |
| f"**{_tot} released `Llama-3.1-8B` derivatives** examined — language forks, domain continued " |
| f"pretraining, instruct post-training, a safety model — **not one** had left the base " |
| f"model's coordinate frame.") |
| A("") |
| idr = [r for r in real if r["g_is_effectively_identity"]] |
| A(f"- On **{len(idr)} of {len(real)}** real community CPT forks the fitted alignment map is the " |
| "**identity** (coordinate share exactly 0; every per-layer MLP and attention-head permutation " |
| "comes back as the identity). Continued pretraining by a third party did **not** move these " |
| "models out of the base model's frame, so the chat vector is already expressed in the right " |
| "basis and aligning it is a no-op. The measured accuracy difference is **exactly zero on every " |
| "benchmark** — the aligned and naive merges are bit-identical models.") |
| won = [r for r in real if r.get("ifeval_prompt__naive", 0) > r.get("ifeval_prompt__fork", 1) + 0.02] |
| A(f"- The chat-vector recipe itself **works** on {len(won)} of {len(real)} of these forks: it lifts " |
| "instruction following well above the fork it started from, i.e. the merged model beats its own " |
| "parent — the bar that matters.") |
| ok = sum(1 for r in real if (r["coord_share"] >= THRESH) == (r.get("ifeval_prompt__delta", 0) > 0.005)) |
| A(f"- The diagnostic's registered prediction was correct on **{ok}/{len(real)}** real forks.") |
| if ctlr: |
| big = max(ctlr, key=lambda r: r["coord_share"]) |
| A(f"- On the ground-truth control (a real fork acted on by a random element of the model's own " |
| f"symmetry group — functionally identical, differently parameterised), the diagnostic fires " |
| f"(coordinate share **{big['coord_share']:.3f}**), the naive chat vector " |
| f"scores IFEval **{big.get('ifeval_prompt__naive', float('nan')):.3f}**, and aligning it first " |
| f"recovers **{big.get('ifeval_prompt__aligned', float('nan')):.3f}** " |
| f"(Δ **{big.get('ifeval_prompt__delta', float('nan')):+.3f}**).") |
| A("") |
|
|
| A("## Substrate") |
| A("") |
| A("| role | model | provenance |") |
| A("|---|---|---|") |
| A("| base | `meta-llama/Llama-3.1-8B` | Meta |") |
| A("| instruct | `meta-llama/Llama-3.1-8B-Instruct` | Meta — the chat vector is Instruct − Base |") |
| seen = set() |
| for r in rows: |
| fa = get(r["fork"], "fork_alone") |
| if not fa or r["fork"] in seen: continue |
| seen.add(r["fork"]) |
| A(f"| {'control' if r['is_control'] else 'fork'} | `{fa.get('model','?')}`" |
| f"{' + random symmetry action on ' + str(int(r['frac_layers_permuted']*32)) + '/32 layers' if r['is_control'] else ''} " |
| f"| {'GROUND TRUTH control' if r['is_control'] else 'community CPT fork'}, target `{r['lang']}` |") |
| A("") |
| A("Every fork is shape-identical to the base (vocab 128256, hidden 4096, 32 layers, 32 heads / 8 KV") |
| A("heads), so the chat vector is added to **all 291 tensors**, embeddings included. Shared ancestry") |
| A("was verified by weight geometry, not by the model card (`weight_cosine_vs_base`, `rel_drift`).") |
| A("") |
| A("## Benchmarks and chance levels") |
| A("") |
| A("| benchmark | measures | chance |") |
| A("|---|---|---|") |
| A("| Belebele, target language | target-language reading comprehension | **0.250** |") |
| A("| Belebele `eng_Latn` | English retention | **0.250** |") |
| A("| ARC-easy | English commonsense retention | **0.250** |") |
| A("| IFEval, strict prompt-level | verifiable instruction following — *what the chat vector is for* | **~0.0** |") |
| A("| IFEval, instruction-level | as above, per constraint | **~0.0** |") |
| A("") |
| A("`lm-evaluation-harness` is not installed in this environment, so the scorers are implemented") |
| A("directly (`tasks.py`, `ifeval.py`) following the harness / reference task definitions. IFEval keeps") |
| A("the 510 of 541 prompts whose every constraint is exactly checkable by the verifiers implemented") |
| A("here. Sanity check on the loglikelihood harness: it scores `EleutherAI/pythia-1.4b` at SciQ") |
| A("**0.846** against the published **0.865** (n=500 subsample).") |
| A("") |
|
|
| A("## 1. Pre-merge diagnostic (computed before any merge)") |
| A("") |
| A("`coordinate share` is the fraction of the scale-free block-normalised parameter distance that the") |
| A("fitted alignment map removes: `(d_raw - min_g d(theta_fork, g.theta_base)) / d_raw`. It is the") |
| A("decision variable. The factor columns show which parts of `g` survived the acceptance test, and") |
| A("`MLP perm = id` says whether the accepted per-layer permutation was in fact the identity (a factor") |
| A("can be accepted and still be the identity, since equality passes the `<=` test).") |
| A("") |
| A("| model | coord. share | g = identity? | resid. factor | head perm = id | CKA vs base | rel. drift | weight cos | **PREDICTION** | fit cost |") |
| A("|---|---|---|---|---|---|---|---|---|---|") |
| for fk, d in sorted(diag.items(), key=lambda kv: kv[1]["coord_share"]): |
| A(f"| `{lab(fk)}` | **{d['coord_share']:.4f}** | " |
| f"{'yes' if (d.get('hidden_is_identity') and d.get('heads_is_identity') and abs(d['coord_share'])<=1e-9) else 'no'} | " |
| f"{'kept' if d.get('residual') else 'rejected'} | " |
| f"{('yes' if d.get('heads_is_identity') else 'NO') if d.get('heads') else 'rejected'} | " |
| f"{d.get('cka_mean', float('nan')):.3f} | {d.get('rel_drift', float('nan')):.4f} | " |
| f"{d.get('weight_cosine_vs_base', float('nan')):.4f} | " |
| f"{'**ALIGN**' if d['PREDICTION_align_helps'] else 'do not align'} | " |
| f"{d.get('fit_seconds', float('nan')):.0f}s |") |
| A("") |
|
|
| A("## 2. Accuracy — fork alone / naive chat vector / aligned chat vector") |
| A("") |
| A("Bars to clear: **(a)** aligned beats naive; **(b)** the merged model beats the fork it came from.") |
| A("A merge that clears (a) but not (b) is not a usable model.") |
| A("") |
| for r in sorted(rows, key=lambda z: (z["is_control"], z["coord_share"], z["fork"])): |
| A(f"### `{lab(r['fork'])}` · λ={r['lam']} · coord. share {r['coord_share']:.4f} · " |
| f"prediction: {'ALIGN' if r['predicted_align_helps'] else 'do not align'}") |
| A("") |
| A("| metric | chance | fork alone | naive | aligned | Δ align | beats fork? | Instruct ref |") |
| A("|---|---|---|---|---|---|---|---|") |
| for m, nm in (("ifeval_prompt", "IFEval prompt (strict)"), ("ifeval_inst", "IFEval instruction"), |
| ("tgt", f"Belebele {r['lang']}"), ("belebele_eng_Latn", "Belebele eng_Latn"), |
| ("arc_easy", "ARC-easy")): |
| if r.get(f"{m}__naive") is None: continue |
| rf = r.get(f"{m}__ref_instruct") |
| beats = "yes" if max(r[f"{m}__naive"], r[f"{m}__aligned"]) > r[f"{m}__fork"] else "**no**" |
| A(f"| {nm} | {r[f'{m}__chance']:.3f} | {r[f'{m}__fork']:.3f} | {r[f'{m}__naive']:.3f} | " |
| f"{r[f'{m}__aligned']:.3f} | **{r[f'{m}__delta']:+.3f}** | {beats} | " |
| f"{rf:.3f} |" if rf is not None else |
| f"| {nm} | {r[f'{m}__chance']:.3f} | {r[f'{m}__fork']:.3f} | {r[f'{m}__naive']:.3f} | " |
| f"{r[f'{m}__aligned']:.3f} | **{r[f'{m}__delta']:+.3f}** | {beats} | — |") |
| A("") |
|
|
| if sel: |
| A("## 3. Selection experiment — can we tell which models are worth aligning, cheaply?") |
| A("") |
| A("A diagnostic that costs as much as the thing it is deciding about is not a diagnostic. The") |
| A("`coordinate share` above is obtained **by fitting `g`**, which took **19–39 minutes per 8B") |
| A("model** here — so \"diagnose, then align\" would be circular if that were the only route to it.") |
| A("It is not. The frame can be checked without the fit: evaluate the weight-matching gain on a") |
| A("few hundred sampled columns of **every** layer and look at whether each row's best match is") |
| A("itself. That screen is `cheap_screen.py`.") |
| A("") |
| A("| model | screen | worst-layer identity fraction | screen says | full fit | coord. share | full says | agree |") |
| A("|---|---|---|---|---|---|---|---|") |
| for r in sorted(P, key=lambda z: z["coord_share"]): |
| sc = SCREEN.get(r["fork"], {}) |
| fl = sc.get("screen_says_aligned_needed", True) |
| ff = r["coord_share"] >= THRESH |
| A(f"| `{lab(r['fork'])}` | **{sc.get('screen_seconds', 0):.0f}s** | " |
| f"{sc.get('identity_fraction_worst_layer', float('nan')):.4f} | " |
| f"{'**ALIGN**' if fl else 'skip'} | {r['align_fit_seconds']:.0f}s | " |
| f"{r['coord_share']:.4f} | {'ALIGN' if ff else 'skip'} | {'yes' if fl == ff else '**NO**'} |") |
| A("") |
| A(f"The **{np.mean([SCREEN.get(r['fork'], {}).get('screen_seconds', 0) for r in P]):.0f}-second** screen " |
| f"reproduces the **{np.mean([r['align_fit_seconds'] for r in P])/60:.0f}-minute** fit's decision on " |
| f"**{agree}/{len(P)}** models, a **{np.mean([r['align_fit_seconds'] for r in P]) / max(np.mean([SCREEN.get(r['fork'], {}).get('screen_seconds', 1) for r in P]), 1e-9):.0f}x** reduction in " |
| "the cost of deciding. It separates cleanly: every real community fork scores ~0.984 (its worst") |
| A("layer is still essentially the identity), every re-parameterised control scores exactly 0.000.") |
| A("") |
| A("| strategy | compute | mean IFEval prompt acc | models aligned | compute saved |") |
| A("|---|---|---|---|---|") |
| allc = sel[1][1] |
| for nm, c, a, n in sel: |
| A(f"| {nm} | {c/60:.0f} min | **{a:.4f}** | {n}/{len(P)} | {100*(1-c/allc) if allc else 0:.0f}% |") |
| A("") |
| _real = [r for r in P if not r["is_control"]] |
| if _real: |
| _fit = sum(r["align_fit_seconds"] for r in _real) |
| _scr = sum(SCREEN.get(r["fork"], {}).get("screen_seconds", 0) for r in _real) |
| A(f"**Screen -> align-when-it-fires matches align-everything exactly ({sel[1][2]:.4f} vs " |
| f"{sel[2][2]:.4f}) at {100*(1-sel[2][1]/allc):.0f}% less compute.** That figure is diluted by this") |
| A("population being half constructed high-drift controls. On the part a practitioner actually") |
| A(f"faces — the {len(_real)} real community forks — the screen costs **{_scr:.0f}s** in total and") |
| A(f"correctly skips **all {len(_real)}**, replacing **{_fit/60:.0f} minutes** of alignment fitting with") |
| A(f"**{_scr/60:.1f} minutes** of screening (**{100*(1-_scr/_fit):.0f}%** saved) at **zero** accuracy cost,") |
| A("because on those models the aligned and naive merges are the same model.") |
| A("") |
|
|
| |
| |
| _lams = sorted({r["lam"] for r in rows}) |
| if len(_lams) > 1: |
| A("## 3b. The mixing coefficient trades language capability against instruction following") |
| A("") |
| A("| fork | λ | Belebele target | Belebele eng | IFEval prompt | IFEval inst |") |
| A("|---|---|---|---|---|---|") |
| for r in sorted([x for x in rows if not x["is_control"]], key=lambda z: (z["fork"], z["lam"])): |
| A(f"| `{lab(r['fork'])}` | {r['lam']} | {r['tgt__naive']:.3f} | " |
| f"{r['belebele_eng_Latn__naive']:.3f} | {r['ifeval_prompt__naive']:.3f} | " |
| f"{r['ifeval_inst__naive']:.3f} |") |
| A("") |
| A("Halving λ buys target-language accuracy and gives back instruction following (Swallow:") |
| A("Japanese 0.680 -> 0.700 but IFEval 0.375 -> 0.270). There is no λ at which SEA-LION's chat") |
| A("vector pays: at λ=0.5 it lands at IFEval 0.350 against the fork's own 0.365.") |
| A("") |
|
|
| |
| ECO = {} |
| try: |
| ECO = json.load(open(f"{RES}/ecosystem_screen.json")) |
| except Exception: |
| pass |
| ok_eco = {k: v for k, v in ECO.items() if v.get("status") == "screened"} |
| bad_eco = {k: v for k, v in ECO.items() if v.get("status") == "shape mismatch"} |
| if ok_eco: |
| n_drift = sum(1 for v in ok_eco.values() if v["frame_has_drifted"]) |
| A("## 3d. Does ANY released model have a drifted frame? (ecosystem screen)") |
| A("") |
| A("Three forks is a thin population for an ecosystem claim, so we ran the 44-second screen over") |
| A(f"a broader sample of released `Llama-3.1-8B` derivatives — language forks, domain continued") |
| A("pretraining, instruct post-training and a safety model, from different groups — streaming each") |
| A("checkpoint in and deleting it again.") |
| A("") |
| A("| model | what it is | group | param. drift | weight cos | worst-layer identity | frame |") |
| A("|---|---|---|---|---|---|---|") |
| for k, v in sorted(ok_eco.items(), key=lambda kv: -kv[1]["rel_drift"]): |
| A(f"| `{k}` | {v['kind']} | {v['group']} | {v['rel_drift']:.4f} | " |
| f"{v['weight_cosine_vs_base']:.4f} | {v['identity_fraction_worst_layer']:.4f} | " |
| f"{'**DRIFTED**' if v['frame_has_drifted'] else 'same frame'} |") |
| A("") |
| A(f"**{n_drift} of {len(ok_eco)}** released derivatives have left the base model's coordinate") |
| A("frame. Parameter drift across this sample spans " |
| f"**{min(v['rel_drift'] for v in ok_eco.values()):.3f} to " |
| f"{max(v['rel_drift'] for v in ok_eco.values()):.3f}** — a " |
| f"{max(v['rel_drift'] for v in ok_eco.values())/max(min(v['rel_drift'] for v in ok_eco.values()),1e-9):.0f}x range, " |
| "with `OpenMath2` and `Swallow v0.2` drifting further in parameter space than any of the forks") |
| A("we evaluated end-to-end — and the frame still never moves. **Moving a long way in parameter") |
| A("space does not move you out of the parameterisation.** Gradient-based post-training, whatever") |
| A("its scale or objective, does not permute neurons; only a deliberate reparameterisation does.") |
| A("") |
| if bad_eco: |
| A(f"A further **{len(bad_eco)}** derivatives (`" + "`, `".join(sorted(bad_eco)) + "`) are not") |
| A("chat-vector compatible at all: they changed the vocabulary, so the task vector's embedding") |
| A("and unembedding blocks do not even have matching shapes. That is a different failure mode,") |
| A("and alignment over the hidden-axis groups has nothing to say about it.") |
| A("") |
|
|
| A("## 3c. What this does and does not establish") |
| A("") |
| A("**Established.** (i) The chat-vector recipe transfers real instruction-following ability to two") |
| A("of three community forks, and the merged model beats the fork it was built from on every axis —") |
| A("so the accuracy axis this project was missing does exist and is large. (ii) Alignment changes") |
| A("*nothing* on all three real forks, and the diagnostic said so in advance. (iii) When the frame") |
| A("genuinely has drifted, alignment recovers essentially all of the loss (IFEval 0.110 -> 0.355") |
| A("against an unpermuted reference of 0.375), so the mechanism is real and does reach accuracy.") |
| A("(iv) A 44-second screen decides which case you are in, 37x cheaper than fitting the map.") |
| A("") |
| A("**Not established, and worth stating plainly:**") |
| A("") |
| A("- **The high-drift arm is constructed, not found.** Every point above the threshold is a real") |
| A(" model acted on by a random element of its own symmetry group. We did not find a *released*") |
| A(" model whose frame had drifted. On the evidence here the answer to \"do community") |
| A(" continued-pretrained forks need their chat vector aligned?\" is **no, none of the three did** —") |
| A(" the failure mode the diagnostic repairs is real and repairable, but appears not to occur in") |
| A(" this corner of the ecosystem. That is the honest resolution, and it is a null.") |
| A("- **The null is a null for one group.** The search covers the residual-stream basis map, the") |
| A(" per-layer free MLP-hidden-axis permutation, and the GQA group-respecting head permutation. A") |
| A(" fork could in principle have drifted under a larger group (a general invertible change of") |
| A(" basis) that this search does not range over; we did not test that.") |
| A("- **Chat-vector failure is not always a coordinate problem.** SEA-LION's recipe fails — the") |
| A(" merged model is *worse* than the fork on ARC-easy (0.728 -> 0.614) and no better on") |
| A(" instruction following — and its coordinate share is exactly 0, so alignment has nothing to") |
| A(" offer it. Whatever is wrong there is not removable by reparameterisation.") |
| A("- **The cross-group pair says the same thing more starkly.** `pythia-1.4b` x `Zh-Pythia-1.4B` —") |
| A(" same architecture, different group, no shared ancestor — merges to **chance on every") |
| A(" benchmark** at every mixing weight and under TIES, and aligning first does not move it") |
| A(" (coordinate share 0.0034). Not every merge failure is a coordinate failure.") |
| A("- **Resolution.** Belebele n=300 and IFEval n=200 per cell; +/- 2 items is ~0.7% and ~1.0%.") |
| A(" Differences smaller than that are not interpretable, which is why the figures draw the floor.") |
| A(" The permutation controls use a single random group element (one seed).") |
| A("- **IFEval here is a re-implementation** over the 510 of 541 prompts whose every constraint our") |
| A(" verifiers check exactly. Its absolute values are not comparable to published IFEval numbers") |
| A(" (we score Llama-3.1-8B-Instruct at 0.540); every model is scored identically, so the") |
| A(" comparisons between rows are sound.") |
| A("") |
|
|
| A("## 4. Coverage") |
| A("") |
| A("| model / cell | diagnostic | fork alone | naive | aligned |") |
| A("|---|---|---|---|---|") |
| allf = sorted(set(list(diag) + list(byfork))) |
| for fk in allf: |
| def mk(a, lam=None): |
| r = get(fk, a, lam) |
| return "done" if (r and r.get("acc")) else "—" |
| lams = sorted({r["lam"] for r in byfork.get(fk, []) if r.get("lam") is not None}) or [None] |
| A(f"| `{lab(fk)}` | {'done' if fk in diag else '—'} | {mk('fork_alone')} | " |
| f"{', '.join(mk('naive', l) for l in lams)} | {', '.join(mk('aligned', l) for l in lams)} |") |
| A("") |
| for tag, rf in (("Llama-3.1-8B (base)", "REF_base"), ("Llama-3.1-8B-Instruct", "REF_instruct")): |
| r = refs.get(rf) |
| if r: A(f"- reference `{tag}`: " + ", ".join(f"{k} {v:.3f}" for k, v in r["acc"].items())) |
| A("") |
| if r4rows_md: |
| A("### Supporting: a cross-group pair merged directly (not a chat vector)") |
| A("") |
| A("`EleutherAI/pythia-1.4b` (step143000) x `SJTU-CL/Zh-Pythia-1.4B` — same architecture, different") |
| A("group, different tokenizer, no shared ancestor (weight cosine ~0). Body-only weight average,") |
| A("naive vs permutation/orthogonal aligned, scored on SciQ / PIQA / ARC-easy / LAMBADA.") |
| A("") |
| A("| arm | alpha | mean acc | parent A | parent B |") |
| A("|---|---|---|---|---|") |
| for r in r4rows_md: |
| A(f"| {r['arm']} | {r['alpha']} | {r['mean']:.4f} | {r['parentA_mean']:.4f} | {r['parentB_mean']:.4f} |") |
| A("") |
|
|
| A("## 4. Method notes and a bug found in the shared library") |
| A("") |
| A("The alignment map `g` is fitted from **(fork, base)** — the map carrying the base model's") |
| A("parameterisation into the fork's frame — and then applied to the chat *vector*, which is valid") |
| A("because every factor of `g` is linear: `g(theta_inst - theta_base) = g(theta_inst) - g(theta_base)`.") |
| A("Factors are accepted one at a time and only if they do not increase the scale-free") |
| A("block-normalised distance; the identity is in every one of these groups, so `min_g` ranges over it.") |
| A("") |
| A("### The aligner is exact — verified against ground truth") |
| A("") |
| A("Acting on a real Llama-3.1-8B by a random element of its own symmetry group and then re-fitting") |
| A("`g` from weights alone recovers the ground-truth group element **bit-exactly**:") |
| A("") |
| A("| check | result |") |
| A("|---|---|") |
| A("| MLP free-hidden-axis permutation, relative logit change | **1.1e-06** (exact to fp32) |") |
| A("| + GQA group-respecting head permutation, relative logit change | **9.4e-07** (exact) |") |
| A("| coordinate share recovered on a fully scrambled model | **1.0000** |") |
| A("| layers matched / head sets matched | 32 / 32 |") |
| A("| `max |g(theta_scrambled) - theta_original|` | **0.0** |") |
| A("| `max |logits(g(theta_scrambled)) - logits(theta_original)|` | **0.0** |") |
| A("") |
| A("So a null result below is a fact about the models, not a failure of the aligner.") |
| A("") |
| A("**`mergeschool.core.alignment.apply_head_perms` is not function-preserving for GQA models.**") |
| A("It permutes the query and output projections but leaves `k_proj`/`v_proj` untouched. That is exact") |
| A("for MHA and for MQA, but with G > 1 grouped-query groups every query head reads a *specific* KV") |
| A("group, so permuting query heads alone breaks the model. Measured here on `Llama-3.1-8B`, applying") |
| A("a random head permutation that way changes the logits by **relative 1.12** (i.e. destroys it),") |
| A("while the free-hidden-axis (MLP) permutation is exact to **1e-6**. We therefore implemented the") |
| A("group-respecting action in `gmap.py` (permute KV groups as units, plus query heads freely within") |
| A("each group), verified exact to **9.4e-7** on `Llama-3.1-8B`, and used that throughout. Any merge") |
| A("study that accepts a flat head permutation on a GQA model is silently corrupting its merges.") |
| A("") |
| open(f"{R}/RESULTS_MERGE_ACCURACY.md", "w").write("\n".join(M) + "\n") |
| print("report written") |
|
|
