| """POSITIVE CONTROL with GROUND TRUTH. |
| |
| Take a real fork and act on it by a RANDOM element of the model's own symmetry group (per-layer |
| free-hidden-axis permutation + attention-head permutation). The permuted fork is *functionally |
| identical* -- same accuracy on every benchmark, exactly -- but it now lives in a different |
| parameterisation. The base model's chat vector is therefore being added in the wrong frame. |
| |
| Ground truth: naive must collapse, and alignment must recover EXACTLY the unpermuted naive result. |
| This is the only cell in the study where we know the right answer in advance, so it tells us |
| whether the diagnostic's decision rule fires when it should, and calibrates the threshold. |
| |
| usage: cv_control.py <forks.json> <gpu> <lambda> <fractions e.g. 0.125,0.25,0.5,1.0> |
| """ |
| import os, sys, json, time, gc, traceback |
| os.environ["CUDA_VISIBLE_DEVICES"] = sys.argv[2] |
| import numpy as np, torch |
| import ma_common as C, tasks as TK, gmap |
| from mergeschool.core import alignment as AL, metrics as MT |
|
|
| FORKS = json.load(open(sys.argv[1])) |
| LAM = float(sys.argv[3]) |
| FRACS = [float(x) for x in (sys.argv[4] if len(sys.argv) > 4 else "1.0").split(",")] |
| LEDGER = os.environ.get("MA_LEDGER", "/root/merge-accuracy/results/chatvec.jsonl") |
| NBEL = int(os.environ.get("MA_NBEL", "300")); NENG = int(os.environ.get("MA_NENG", "500")) |
| BS = int(os.environ.get("MA_BS", "16")) |
| NIF = int(os.environ.get("MA_NIF", "200")) |
| BASE = "meta-llama/Llama-3.1-8B"; INST = "meta-llama/Llama-3.1-8B-Instruct" |
| DEV, DT = "cuda", torch.bfloat16 |
| done = C.jload(LEDGER) |
|
|
| def put(k, rec): |
| rec["key"] = k; rec["t"] = time.time(); C.jappend(LEDGER, rec); done[k] = rec |
| print(f"[{time.strftime('%H:%M:%S')}] {k} " + |
| " ".join(f"{t}={v:.4f}" for t, v in rec.get("acc", {}).items()), flush=True) |
|
|
| def evaluate(model, tok, langs): |
| """Three axes: target-language capability, instruction following, English retention.""" |
| out = {} |
| if isinstance(langs, str): langs = [langs] |
| for lg in langs: |
| out[f"belebele_{lg}"] = C.eval_task(model, tok, TK.belebele(lg, NBEL), DEV, bs=BS)["acc"] |
| out["belebele_eng_Latn"] = C.eval_task(model, tok, TK.belebele("eng_Latn", NBEL), DEV, bs=BS)["acc"] |
| out["arc_easy"] = C.eval_task(model, tok, TK.arc_easy(NENG), DEV, bs=BS)["acc"] |
| ife, _ = C.eval_ifeval(model, tok, DEV, n=NIF, bs=max(BS // 2, 4)) |
| out["ifeval_prompt"] = ife["ifeval_prompt"]; out["ifeval_inst"] = ife["ifeval_inst"] |
| return out |
|
|
| mb = C.load_model(BASE, dev="cpu", dtype=torch.float32) |
| sd_base = C.sd_np(mb); cfg = mb.config; HID, NH = cfg.hidden_size, cfg.num_attention_heads |
| NKV = getattr(cfg, "num_key_value_heads", NH) |
| del mb; gc.collect() |
| mi = C.load_model(INST, dev="cpu", dtype=torch.float32); sd_inst = C.sd_np(mi); del mi; gc.collect() |
| KEYS = C.shared_keys(sd_base, sd_inst) |
| tau = {k: sd_inst[k] - sd_base[k] for k in KEYS}; del sd_inst; gc.collect() |
| tok_base = C.load_tok(BASE); sents = C.flores_lines("eng_Latn", 256) |
| m = C.load_model(BASE, dev=DEV, dtype=DT); acts_base = C.capture_acts_sent(m, tok_base, sents, DEV) |
| del m; gc.collect(); torch.cuda.empty_cache() |
| print("base+tau ready", flush=True) |
|
|
| F = FORKS[0] |
| mf = C.load_model(F["repo"], dev="cpu", dtype=torch.float32) |
| sd_fork0 = C.sd_np(mf); del mf; gc.collect() |
| tok_f = C.load_tok(F["repo"]); lang = F["lang"] |
| mm = C.load_model(F["repo"], dev=DEV, dtype=DT) |
| LAYER_PRES = sorted({p for p in (AL._layer_prefix(n) for n in sd_fork0) if p}) |
| AXES = AL.free_hidden_axes(sd_fork0, HID) |
|
|
| for frac in FRACS: |
| name = f'{F["name"]}_PERM{frac}' |
| try: |
| rng = np.random.default_rng(int(frac * 1000)) |
| npick = max(1, int(round(frac * len(LAYER_PRES)))) |
| picked = set(rng.choice(LAYER_PRES, size=npick, replace=False).tolist()) |
| hperm = {pre: rng.permutation(ax["f"]) for pre, ax in AXES.items() if pre in picked} |
| sd_fork = AL.apply_hidden_perms(sd_fork0, hperm, HID) |
| aperm = gmap.random_gqa_head_perms(sd_fork0, HID, NH, NKV, rng, only=picked) |
| sd_fork = gmap.apply_gqa_head_perms(sd_fork, aperm, HID, NH, NKV) |
| print(f"### {name}: permuted {npick}/{len(LAYER_PRES)} layers", flush=True) |
|
|
| k = f"{name}|fork_alone" |
| if k not in done: |
| C.sd_load(mm, sd_fork, dtype=DT) |
| put(k, {"kind": "control", "fork": name, "arm": "fork_alone", "lam": None, "lang": lang, |
| "frac_layers_permuted": frac, "model": F["repo"], |
| "acc": evaluate(mm, tok_f, [lang]), |
| "note": "random symmetry-group action: must match the unpermuted fork exactly"}) |
|
|
| C.sd_load(mm, sd_fork, dtype=DT) |
| acts_f = C.capture_acts_sent(mm, tok_f, sents, DEV) |
|
|
| kd = f"{name}|diag" |
| if kd not in done: |
| t0 = time.time() |
| g, info = gmap.fit_g(sd_fork, sd_base, HID, NH, acts_f, acts_base, "permutation", verbose=False, n_kv_heads=NKV) |
| a = np.concatenate([sd_base[x].ravel() for x in KEYS]); b = np.concatenate([sd_fork[x].ravel() for x in KEYS]) |
| info["weight_cosine_vs_base"] = float(a @ b / (np.linalg.norm(a) * np.linalg.norm(b))) |
| info["rel_drift"] = float(np.linalg.norm(a - b) / np.linalg.norm(a)); del a, b; gc.collect() |
| L = sorted(set(acts_f) & set(acts_base)) |
| info["cka_mean"] = float(np.mean([MT.cka(acts_base[l], acts_f[l]) for l in L])) |
| info["cka_last"] = float(MT.cka(acts_base[L[-1]], acts_f[L[-1]])) |
| info["coord_share"] = info["coord_share_bn"] |
| info["PREDICTION_align_helps"] = bool(info["coord_share"] >= 0.01) |
| info["fit_seconds"] = time.time() - t0 |
| info["frac_layers_permuted"] = frac |
| info = {kk: (v.tolist() if isinstance(v, np.ndarray) else v) for kk, v in info.items()} |
| np.save(f"/root/merge-accuracy/results/g_{name}.npy", np.array([g], dtype=object), allow_pickle=True) |
| put(kd, {"kind": "diag", "fork": name, "arm": "diag", "lang": lang, "diag": info}) |
| print(f" DIAG {name}: coord_share={info['coord_share']:.4f} identity={info['is_identity']} " |
| f"hidden={info['hidden']} heads={info['heads']} {info['fit_seconds']:.0f}s", flush=True) |
| else: |
| g = np.load(f"/root/merge-accuracy/results/g_{name}.npy", allow_pickle=True)[0] |
| diag = done[kd]["diag"] |
| del acts_f; gc.collect() |
|
|
| tau_al = gmap.apply_g(tau, g, HID, NH) |
| for arm, tv in (("naive", tau), ("aligned", tau_al)): |
| k = f"{name}|{arm}|lam{LAM}" |
| if k in done: continue |
| sd_m = {kk: sd_fork[kk] + LAM * tv[kk] for kk in KEYS} |
| C.sd_load(mm, sd_m, dtype=DT) |
| put(k, {"kind": "control", "fork": name, "arm": arm, "lam": LAM, "lang": lang, |
| "frac_layers_permuted": frac, "coord_share": diag["coord_share"], |
| "acc": evaluate(mm, tok_f, [lang])}) |
| del sd_m; gc.collect() |
| del tau_al, sd_fork; gc.collect() |
| except Exception: |
| print(f"!! CONTROL FAIL {name}\n" + traceback.format_exc()[-2000:], flush=True) |
| gc.collect(); torch.cuda.empty_cache() |
| print("CONTROL_DONE", flush=True) |
|
|
