code/chatvec_run.py

"""CHAT-VECTOR EXPERIMENT.

    theta_new = theta_fork + lambda * (theta_instruct - theta_base)          [naive]
    theta_new = theta_fork + lambda * g(theta_instruct - theta_base)         [aligned]

g is fitted from (fork, base) -- i.e. it is the map that carries the BASE model's parameterisation
into the FORK's frame. The falsifiable prediction, recorded before any merged model is scored:
a fork whose frame has drifted (high coordinate share) is one where the naive chat vector is being
added in the wrong basis, and alignment should rescue it; a fork that never left base's frame
(coordinate share ~ 0) should show no benefit at all.

usage: chatvec_run.py <forks.json> <gpu> <lambdas> [shard nshards]
"""
from __future__ import annotations
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
import tasks as TK
import gmap

FORKS = json.load(open(sys.argv[1]))
LAMS = [float(x) for x in sys.argv[3].split(",")]
SHARD, NSH = (int(sys.argv[4]), int(sys.argv[5])) if len(sys.argv) > 5 else (0, 1)
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 = "cuda"
DT = torch.bfloat16

done = C.jload(LEDGER)
def put(k, rec):
    rec["key"] = k; rec["t"] = time.time()
    C.jappend(LEDGER, rec); done[k] = rec
    a = rec.get("acc", {})
    print(f"[{time.strftime('%H:%M:%S')}] {k}  " + " ".join(f"{t}={v:.4f}" for t, v in a.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


print("loading base + instruct ...", flush=True)
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()
print(f"base+tau ready, {len(KEYS)} keys", flush=True)

tok_base = C.load_tok(BASE); tok_inst = C.load_tok(INST)
sents = C.flores_lines("eng_Latn", 256)

# ---- references (evaluated once, shared by every fork) -------------------------------------
for tag, repo, tk in (("REF_base", BASE, tok_base), ("REF_instruct", INST, tok_inst)):
    k = f"{tag}"
    if k in done: continue
    m = C.load_model(repo, dev=DEV, dtype=DT)
    langs = sorted({f["lang"] for f in FORKS})
    acc = evaluate(m, tk, langs)
    put(k, {"kind": "reference", "fork": None, "arm": tag, "lam": None, "model": repo, "acc": acc})
    del m; gc.collect(); torch.cuda.empty_cache()

# base activations for the residual-basis factor of g
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()

for fi, F in enumerate(FORKS):
    if fi % NSH != SHARD: continue
    name, repo, lang = F["name"], F["repo"], F["lang"]
    try:
        print(f"### fork {name} ({repo}) lang={lang}", flush=True)
        tok_f = C.load_tok(repo)
        mf = C.load_model(repo, dev=DEV, dtype=DT)
        acts_f = C.capture_acts_sent(mf, tok_f, sents, DEV)
        kf = f"{name}|fork_alone"
        if kf not in done:
            put(kf, {"kind": "fork", "fork": name, "arm": "fork_alone", "lam": None,
                     "model": repo, "lang": lang, "acc": evaluate(mf, tok_f, [lang])})
        del mf; gc.collect(); torch.cuda.empty_cache()

        mf_cpu = C.load_model(repo, dev="cpu", dtype=torch.float32)
        sd_fork = C.sd_np(mf_cpu); del mf_cpu; gc.collect()

        # ---------------- PRE-MERGE DIAGNOSTIC + RECORDED PREDICTION ----------------
        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", n_kv_heads=NKV)
            info["fit_seconds"] = time.time() - t0
            # provenance check by weight geometry, not by the model card
            a = np.concatenate([sd_base[k].ravel() for k in KEYS[:40]])
            b = np.concatenate([sd_fork[k].ravel() for k in KEYS[:40]])
            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))
            L = sorted(set(acts_f) & set(acts_base))
            from mergeschool.core import metrics as MT
            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 = {k: (v if not isinstance(v, np.ndarray) else v.tolist()) for k, v in info.items()}
            put(kd, {"kind": "diag", "fork": name, "arm": "diag", "lang": lang, "diag": info})
            np.save(f"/root/merge-accuracy/results/g_{name}.npy", np.array([g], dtype=object),
                    allow_pickle=True)
        else:
            g = np.load(f"/root/merge-accuracy/results/g_{name}.npy", allow_pickle=True)[0]
        diag = done[kd]["diag"]
        print(f"  DIAG {name}: coord_share={diag['coord_share']:.4f} identity={diag['is_identity']} "
              f"PREDICT_align_helps={diag['PREDICTION_align_helps']} cka={diag['cka_mean']:.3f}", flush=True)

        tau_al = gmap.apply_g(tau, g, HID, NH) if not diag["is_identity"] else None

        # reload a bf16 shell we can overwrite repeatedly
        mm = C.load_model(repo, dev=DEV, dtype=DT)
        for lam in LAMS:
            for arm, tv in (("naive", tau), ("aligned", tau_al)):
                k = f"{name}|{arm}|lam{lam}"
                if k in done: continue
                if tv is None:
                    put(k, {"kind": "merge", "fork": name, "arm": arm, "lam": lam, "lang": lang,
                            "acc": dict(done[f"{name}|naive|lam{lam}"]["acc"]) if f"{name}|naive|lam{lam}" in done else None,
                            "note": "g is the identity -> aligned chat vector is bitwise the naive one"})
                    continue
                sd_m = {kk: sd_fork[kk] + lam * tv[kk] for kk in KEYS}
                C.sd_load(mm, sd_m, dtype=DT)
                acc = evaluate(mm, tok_f, [lang])
                put(k, {"kind": "merge", "fork": name, "arm": arm, "lam": lam, "lang": lang,
                        "coord_share": diag["coord_share"], "acc": acc})
                del sd_m; gc.collect()
        del mm, sd_fork, tau_al, acts_f; gc.collect(); torch.cuda.empty_cache()
    except Exception:
        print(f"!! FORK FAIL {name}\n{traceback.format_exc()[-2000:]}", flush=True)
        gc.collect(); torch.cuda.empty_cache()
print("CHATVEC_DONE", flush=True)