| """Sanity: is the alignment actually FUNCTION-PRESERVING? |
| |
| Every M1 rung is only meaningful if g.th_B computes exactly what th_B computes. A permutation of the |
| residual basis, of the free MLP hidden axis and of the attention heads is exact in theory; a bug in |
| applying it produces a plausible-looking state dict whose merges are quietly garbage. This checks it |
| empirically on both substrates: evaluate the parent, then evaluate the aligned parent, and compare. |
| An orthogonal map is NOT expected to be exact (it does not commute with the elementwise LayerNorm |
| gain), so its drift is reported as a magnitude, not as a pass/fail.""" |
| import sys, json, glob |
| sys.path.insert(0, "/root/compose-audit") |
| from common import * |
| import gpt2_align as G2 |
| from transformers import AutoModelForCausalLM, AutoTokenizer |
| from mergeschool.core.models import load_hf |
| from set4_goldfish_lib import sent_acts |
|
|
| DEV = "cuda" |
| out = {} |
|
|
|
|
| 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) |
| 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(np.einsum("ixy,jxy->ij", Aq, Bq) + np.einsum("xiy,xjy->ij", Ad, Bd)) |
| return perms |
|
|
|
|
| def neox_apply_head(sd, perms, d, nh): |
| hd, o = 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" |
| o[qk] = np.asarray(sd[qk], float).reshape(nh, 3 * hd, d)[h].reshape(3 * d, d) |
| if qb in sd: o[qb] = np.asarray(sd[qb], float).reshape(nh, 3 * hd)[h].reshape(3 * d) |
| o[de] = np.asarray(sd[de], float).reshape(d, nh, hd)[:, h].reshape(d, d) |
| return o |
|
|
|
|
| |
| tok = AutoTokenizer.from_pretrained("EleutherAI/pythia-14m") |
| blocks = make_blocks(tok, flores_lines("eng_Latn"), block=512, max_blocks=24) |
| ma = AutoModelForCausalLM.from_pretrained("EleutherAI/pythia-14m-seed1", dtype=torch.float32).to(DEV).eval() |
| mb = AutoModelForCausalLM.from_pretrained("EleutherAI/pythia-14m-seed2", dtype=torch.float32).to(DEV).eval() |
| D, NH, NL = ma.config.hidden_size, ma.config.num_attention_heads, ma.config.num_hidden_layers |
| sa, sb = sd_np(ma), sd_np(mb) |
| aa, ab = capture_acts(ma, blocks, DEV), capture_acts(mb, blocks, DEV) |
| base = nll_nats(mb, blocks, DEV, bs=16) |
| res = {} |
| for method in ("permutation", "orthogonal"): |
| sd, info = AL.align_weights_full(sa, sb, D, acts_a=aa, acts_b=ab, n_heads=None, |
| method=method, strict=True, accept_each=False) |
| sd_load(mb, sd, DEV); res[f"{method}_residual+mlp"] = nll_nats(mb, blocks, DEV, bs=16) - base |
| if method == "permutation": |
| hp = neox_head_match(sa, sd, D, NH, NL) |
| sd2 = neox_apply_head(sd, hp, D, NH) |
| sd_load(mb, sd2, DEV); res["permutation_full(+heads)"] = nll_nats(mb, blocks, DEV, bs=16) - base |
| sd_load(mb, sb, DEV) |
| out["set1_pythia14m"] = {"parent_nll": base, "nll_change_after_alignment": res} |
| print("SET1", json.dumps(out["set1_pythia14m"], indent=1)) |
| del ma, mb; torch.cuda.empty_cache() |
|
|
| |
| m_e, tok_e = load_hf("goldfish-models/eng_latn_1000mb", dtype=torch.float32, device=DEV); m_e.eval() |
| m_x, tok_x = load_hf("goldfish-models/nld_latn_1000mb", dtype=torch.float32, device=DEV); m_x.eval() |
| D2, NH2 = m_e.config.n_embd, m_e.config.n_head |
| lines_e = flores_lines("eng_Latn")[:300]; lines_x = flores_lines("nld_Latn")[:300] |
| ae = sent_acts(m_e, tok_e, lines_e, DEV); ax = sent_acts(m_x, tok_x, lines_x, DEV) |
| sde, sdx = sd_np(m_e), sd_np(m_x) |
| bl = make_blocks(tok_x, lines_x, block=512, max_blocks=16) |
| b0 = nll_nats(m_x, bl, DEV, bs=8) |
| res2 = {} |
| for tag, sd in (("perm_residual_only", G2.apply_resid(sdx, D2, perm=AL.residual_basis_map(ae, ax, "permutation")[1])), |
| ("mlp_only", G2.apply_mlp(sdx, G2.mlp_match(sde, sdx))), |
| ("heads_only", G2.apply_head(sdx, G2.head_match(sde, sdx, D2, NH2), D2, NH2)), |
| ("perm_full", G2.align_full(sde, sdx, D2, NH2, ae, ax, "permutation", accept_each=False)[0]), |
| ("orth_full", G2.align_full(sde, sdx, D2, NH2, ae, ax, "orthogonal", accept_each=False)[0])): |
| sd_load(m_x, sd, DEV); res2[tag] = nll_nats(m_x, bl, DEV, bs=8) - b0 |
| out["set4_goldfish_nld"] = {"parent_nll": b0, "nll_change_after_alignment": res2} |
| print("SET4", json.dumps(out["set4_goldfish_nld"], indent=1)) |
| json.dump(out, open("/root/compose-audit/results/alignment_health.json", "w"), indent=1) |
|
|
