Upload code/analyze.py with huggingface_hub

code/analyze.py

@@ -209,67 +209,112 @@ if rows:
     fig.tight_layout(rect=[0, 0, 1, 0.93])
     fig.savefig(f"{FIG}/scatter_naive_vs_aligned.png", bbox_inches="tight"); plt.close(fig)
 
-    # ---- dose-response: does the diagnostic track the true amount of frame drift? ------------
-    ctl = sorted([r for r in rows if r["is_control"]], key=lambda r: r["frac_layers_permuted"])
+    # ---- dose-response: the diagnostic vs the true amount of frame drift, and the payoff --------
+    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=(9.2, 3.6))
+        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)
-        ax[0].axhline(THRESH, color="#f59e0b", ls=":", lw=1.1)
+                   "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 (diagnostic)")
-        ax[0].set_title("The diagnostic tracks real frame drift", fontsize=9, loc="left")
-        for m, c, nm in (("ifeval_prompt", CC, "IFEval prompt"), ("tgt", CG, "Belebele target")):
-            if all(r.get(f"{m}__naive") is not None for r in ctl):
-                ax[1].plot([r["frac_layers_permuted"] for r in ctl],
-                           [r[f"{m}__naive"] for r in ctl], "o--", color=c, alpha=0.55,
-                           label=f"{nm}: naive")
-                ax[1].plot([r["frac_layers_permuted"] for r in ctl],
-                           [r[f"{m}__aligned"] for r in ctl], "o-", color=c, label=f"{nm}: aligned")
+        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")
+        # blue/green pair: CVD dE 24.9 deutan; line style + direct labels are the secondary encoding
+        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, loc="left")
-        ax[1].legend(fontsize=7, frameon=False)
-        fig.tight_layout(); fig.savefig(f"{FIG}/dose_response.png", bbox_inches="tight"); plt.close(fig)
+        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)
 
-# ---- selection experiment -------------------------------------------------------------------
+
+# ---- SELECTION EXPERIMENT ---------------------------------------------------------------------
+# Honest accounting. The `coord_share` used everywhere else is obtained BY fitting g, so
+# "diagnose, then align" cannot claim to save the fit -- they are the same computation, and a
+# selection experiment built on it would be vacuous. What decides the question is whether the
+# frame can be checked WITHOUT the fit. It can: evaluating the weight-matching gain on a few
+# hundred sampled columns of every layer already pins each row to itself when nothing was
+# permuted. That screen is `cheap_screen.py`; the numbers below are measured, not assumed.
+SCREEN = {}
+try:
+    SCREEN = json.load(open(f"{RES}/cheap_screen.json"))
+except Exception:
+    pass
+
+APPLY_AND_EVAL_S = 300.0    # apply g to the 8B chat vector + build and score the second model
 sel = []
-if rows:
+if rows and SCREEN:
     best = {}
-    for r in rows: best.setdefault(r["fork"], r)
-    P = list(best.values())
-    metric = "ifeval_prompt"
-    def acc(r, arm): return r.get(f"{metric}__{arm}")
-    P = [r for r in P if acc(r, "naive") is not None]
-    if P:
-        cost = lambda r: (r["align_fit_seconds"] or 0.0)
-        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(cost(r) for r in P))
-        picked = [r for r in P if r["coord_share"] >= THRESH]
-        sel_a = float(np.mean([acc(r, "aligned") if r["coord_share"] >= THRESH else acc(r, "naive") for r in P]))
-        sel_c = float(sum(cost(r) for r in picked))
-        sel = [("merge naive (never align)", 0.0, naive_a, 0),
-               ("align everything", all_c, all_a, len(P)),
-               (f"diagnose -> align if coord_share >= {THRESH}", sel_c, sel_a, len(picked))]
-        with open(f"{RES}/selection_experiment.csv", "w") as f:
-            f.write("strategy,alignment_seconds,mean_ifeval_prompt_acc,n_aligned,n_pairs,compute_saved_pct\n")
-            for nm, c, a, n in sel:
-                sv = 100 * (1 - c / all_c) if all_c else 0.0
-                f.write(f'"{nm}",{c:.1f},{a:.4f},{n},{len(P)},{sv:.1f}\n')
-        fig, ax = plt.subplots(figsize=(7.2, 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.004, i, f"acc {s[2]:.3f}   align cost {s[1]:.0f}s  ({sv:.0f}% saved)",
-                    va="center", fontsize=7.5)
-        ax.set_xlim(0, max(s[2] for s in sel) * 1.7); ax.invert_yaxis()
-        ax.set_xlabel("mean IFEval strict prompt accuracy")
-        ax.set_title("Selection experiment: which pairs are worth aligning?", fontsize=9.5, loc="left")
-        fig.tight_layout(); fig.savefig(f"{FIG}/selection_experiment.png", bbox_inches="tight"); plt.close(fig)
-print("figs:", sorted(os.listdir(FIG)))
+    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)
+
 
 # ---- rung-4 supporting rows
 r4rows_md = []
@@ -443,16 +488,108 @@ for r in sorted(rows, key=lambda z: (z["is_control"], z["coord_share"], z["fork"
     A("")
 
 if sel:
-    A("## 3. Selection experiment")
+    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("| strategy | alignment compute | mean IFEval prompt acc | pairs aligned | compute saved |")
+    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:.0f}s | **{a:.4f}** | {n}/{len(P)} | {100*(1-c/allc) if allc else 0:.0f}% |")
+        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("")
 
 # ---- coverage --------------------------------------------------------------------------------
+# ---- lambda sweep ----------------------------------------------------------------------------
+_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("")
+
+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 |")