"""The operator practitioners actually use: SLERP. Every rung in the main SET 1 table is a lab operator. A census of community merges on the Hub finds SLERP on ~25% of them -- more than TIES, DARE-TIES and task arithmetic combined -- and it needs no shared base, which is exactly why it gets reached for when merging two models with no common ancestor. That is the PolyPythia seed case. This adds it, on the same pairs, before and after unit alignment, with both metrics. Rungs: M0 naive average - M1 permutation-aligned average - M6 SLERP - M7 permutation-aligned SLERP. """ import os, sys, json, time, glob, itertools, argparse, gc, csv sys.path.insert(0, "/root/compose-audit") from common import * from transformers import AutoModelForCausalLM, AutoTokenizer import pyarrow.parquet as pq ap = argparse.ArgumentParser() ap.add_argument("--size", default="14m") ap.add_argument("--seeds", default="1,2,3,4,5,6,7,8,9") ap.add_argument("--blocks", type=int, default=48) ap.add_argument("--bs", type=int, default=16) ap.add_argument("--n_per_paradigm", type=int, default=200) ap.add_argument("--acts_rows", type=int, default=2048) A = ap.parse_args() SEEDS = [int(s) for s in A.seeds.split(",")] OUT = f"/root/compose-audit/results/slerp_{A.size}.jsonl" DEV = "cuda" BLIMP = glob.glob("/root/hf_cache_brainalign/hub/datasets--nyu-mll--blimp/snapshots/*/")[0] def log(*a): print(f"[{time.strftime('%H:%M:%S')}]", *a, flush=True) def neox_head_match(sd_a, sd_b, d, nh, nl): hd, perms = d // nh, {} for L in range(nl): qk = f"gpt_neox.layers.{L}.attention.query_key_value.weight" de = f"gpt_neox.layers.{L}.attention.dense.weight" if qk not in sd_a: continue Aq = np.asarray(sd_a[qk], float).reshape(nh, 3 * hd, d) Bq = np.asarray(sd_b[qk], float).reshape(nh, 3 * hd, d) g = np.einsum("ixy,jxy->ij", Aq, Bq) Ad = np.asarray(sd_a[de], float).reshape(d, nh, hd) Bd = np.asarray(sd_b[de], float).reshape(d, nh, hd) perms[L] = AL._assignment(g + np.einsum("xiy,xjy->ij", Ad, Bd)) return perms def neox_apply_head(sd, perms, d, nh): hd, out = d // nh, dict(sd) for L, h in perms.items(): qk = f"gpt_neox.layers.{L}.attention.query_key_value.weight" qb = f"gpt_neox.layers.{L}.attention.query_key_value.bias" de = f"gpt_neox.layers.{L}.attention.dense.weight" out[qk] = np.asarray(sd[qk], float).reshape(nh, 3 * hd, d)[h].reshape(3 * d, d) if qb in sd: out[qb] = np.asarray(sd[qb], float).reshape(nh, 3 * hd)[h].reshape(3 * d) out[de] = np.asarray(sd[de], float).reshape(d, nh, hd)[:, h].reshape(d, d) return out def align_perm(sd_a, sd_b, d, aa, ab, nh, nl): sd, _ = AL.align_weights_full(sd_a, sd_b, d, acts_a=aa, acts_b=ab, n_heads=None, method="permutation", strict=True, accept_each=True) hp = neox_head_match(sd_a, sd, d, nh, nl) if hp: cand = neox_apply_head(sd, hp, d, nh) if AL.block_normalised_distance(sd_a, cand) <= AL.block_normalised_distance(sd_a, sd): sd = cand return sd # ------------------------------------------------------------------ REPAIR TARGETS = ("mlp.dense_h_to_4h", "attention.query_key_value") @torch.no_grad() def preact_stats(model, blocks, dev, bs, nl): """{(layer, target): (mean, std)} of each Linear's OUTPUT (= pre-activation), per unit.""" acc = {} hs = [] def mk(key): def hook(mod, inp, out): o = out.detach().float().reshape(-1, out.shape[-1]) s = acc.setdefault(key, [0.0, None, None]) s[0] += o.shape[0] s[1] = o.sum(0) if s[1] is None else s[1] + o.sum(0) s[2] = (o * o).sum(0) if s[2] is None else s[2] + (o * o).sum(0) return hook for L in range(nl): blk = model.gpt_neox.layers[L] hs.append(blk.mlp.dense_h_to_4h.register_forward_hook(mk((L, "mlp.dense_h_to_4h")))) hs.append(blk.attention.query_key_value.register_forward_hook(mk((L, "attention.query_key_value")))) for i in range(0, blocks.shape[0], bs): model(blocks[i:i + bs].to(dev)) for h in hs: h.remove() out = {} for k, (n, s1, s2) in acc.items(): m = s1 / n v = (s2 / n - m * m).clamp_min(1e-12) out[k] = (m.cpu().numpy().astype(np.float64), v.sqrt().cpu().numpy().astype(np.float64)) return out def repair(sd_merged, stats_a, stats_b, shell, blocks, dev, bs, nl): """Walk layers in order; after fixing layers < L the inputs to layer L are already corrected, so layer L's own statistics are re-measured before it is corrected. Affine correction on the Linear's weight/bias, so the model stays exactly a model of the same architecture.""" sd = {k: np.array(v, dtype=np.float64, copy=True) for k, v in sd_merged.items()} for L in range(nl): sd_load(shell, sd, dev) cur = preact_stats(shell, blocks, dev, bs, nl) for t in TARGETS: mu_t = 0.5 * (stats_a[(L, t)][0] + stats_b[(L, t)][0]) sd_t = 0.5 * (stats_a[(L, t)][1] + stats_b[(L, t)][1]) mu_m, sd_m = cur[(L, t)] g = sd_t / np.maximum(sd_m, 1e-8) wk, bk = f"gpt_neox.layers.{L}.{t}.weight", f"gpt_neox.layers.{L}.{t}.bias" sd[wk] = sd[wk] * g[:, None] sd[bk] = (sd[bk] - mu_m) * g + mu_t return sd # ------------------------------------------------------------------ BLiMP def load_blimp(n_per): out = [] for d in sorted(glob.glob(BLIMP + "*/")): f = glob.glob(d + "*.parquet") if not f: continue t = pq.read_table(f[0]).to_pydict() out.append((os.path.basename(d.rstrip("/")), t["sentence_good"][:n_per], t["sentence_bad"][:n_per])) return out tok = AutoTokenizer.from_pretrained(f"EleutherAI/pythia-{A.size}") if tok.pad_token is None: tok.pad_token = tok.eos_token def enc(sents, maxlen=48): e = tok(sents, return_tensors="pt", padding=True, truncation=True, max_length=maxlen) return e["input_ids"], e["attention_mask"] ENC = [(n, enc(g), enc(b)) for n, g, b in load_blimp(A.n_per_paradigm)] lines = flores_lines("eng_Latn") blocks = make_blocks(tok, lines, block=512, max_blocks=A.blocks) shell = AutoModelForCausalLM.from_pretrained(f"EleutherAI/pythia-{A.size}-seed{SEEDS[0]}", dtype=torch.float32).to(DEV).eval() cfg = shell.config D, NH, NL = cfg.hidden_size, cfg.num_attention_heads, cfg.num_hidden_layers log(f"size={A.size} d={D} heads={NH} layers={NL} blimp_paradigms={len(ENC)}") @torch.no_grad() def bscore(ids, am): o = [] for i in range(0, ids.shape[0], 128): x, m = ids[i:i + 128].to(DEV), am[i:i + 128].to(DEV) lp = torch.log_softmax(shell(x, attention_mask=m).logits.float()[:, :-1], -1) o.append((lp.gather(-1, x[:, 1:].unsqueeze(-1)).squeeze(-1) * m[:, 1:].float()).sum(1).cpu()) return torch.cat(o).numpy() def evaluate(sd): sd_load(shell, sd, DEV) nll = nll_nats(shell, blocks, DEV, bs=A.bs) cor = tot = 0 for name, (gi, gm), (bi, bm) in ENC: sg, sb = bscore(gi, gm), bscore(bi, bm) cor += int((sg > sb).sum()); tot += len(sg) return nll, cor / tot SDS, ACTS, PAR, STATS = {}, {}, {}, {} for s in SEEDS: m = AutoModelForCausalLM.from_pretrained(f"EleutherAI/pythia-{A.size}-seed{s}", dtype=torch.float32).to(DEV).eval() SDS[s] = sd_np(m); ACTS[s] = capture_acts(m, blocks, DEV, n_rows=A.acts_rows, bs=A.bs) del m; torch.cuda.empty_cache() PAR[s] = evaluate(SDS[s]) log(f" seed{s} nll={PAR[s][0]:.4f} blimp={PAR[s][1]:.4f}") done = set() if os.path.exists(OUT): for l in open(OUT): try: done.add(tuple(json.loads(l)["pair"])) except Exception: pass fh = open(OUT, "a") for a, b in itertools.combinations(SEEDS, 2): if (a, b) in done: continue t0 = time.time() sa, sb = SDS[a], SDS[b] sbp = align_perm(sa, sb, D, ACTS[a], ACTS[b], NH, NL) rungs = {"M0_naive_avg": MG.average([sa, sb]), "M1_perm_avg": MG.average([sa, sbp]), "M6_slerp": MG.slerp(sa, sb, t=0.5), "M7_perm_slerp": MG.slerp(sa, sbp, t=0.5)} floor = min(PAR[a][0], PAR[b][0]); ceil = max(PAR[a][1], PAR[b][1]) res = {} for k, sd in rungs.items(): nll, acc = evaluate(sd) res[k] = {"nll": nll, "delta_floor": nll - floor, "blimp_acc": acc, "blimp_delta_vs_ceiling": acc - ceil} r = {"set": "set1_slerp", "size": A.size, "pair": [a, b], "floor": floor, "blimp_ceiling": ceil, "parent_nll": {"a": PAR[a][0], "b": PAR[b][0]}, "parent_blimp": {"a": PAR[a][1], "b": PAR[b][1]}, "rungs": res, "secs": time.time() - t0} fh.write(json.dumps(r) + "\n"); fh.flush() log(f"pair {a},{b} floor={floor:.2f}/ceil={ceil:.3f} | " + " | ".join(f"{k}: {v['delta_floor']:+.2f}n {v['blimp_acc']:.3f}" for k, v in res.items()) + f" ({r['secs']:.0f}s)") del rungs, sbp; gc.collect() fh.close() log("DONE slerp", A.size)