| """SET 1: PolyPythia seed-merge. EleutherAI/pythia-{size}-seed{1..9}, C(9,2)=36 pairs. |
| Same data, same arch, same tokenizer; only the init/data-order seed varies -> the merge |
| obstruction is PURELY COORDINATE. Rungs M0 naive / M1 unit-aligned / task-arith / TIES. |
| Metric: Delta-floor in nats/token on a held-out corpus (FLORES-200 eng_Latn devtest).""" |
| import os, sys, json, time, itertools, argparse, gc |
| sys.path.insert(0, "/root/compose-audit") |
| from common import * |
| from transformers import AutoModelForCausalLM, AutoTokenizer |
|
|
| ap = argparse.ArgumentParser() |
| ap.add_argument("--size", default="14m") |
| ap.add_argument("--base", default=None, help="repo stem for tokenizer/pseudo-base; defaults to pythia-<size>") |
| 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("--barrier_n", type=int, default=7) |
| ap.add_argument("--acts_rows", type=int, default=2048) |
| ap.add_argument("--tag", default="set1") |
| A = ap.parse_args() |
| BASE_STEM = A.base or f"pythia-{A.size}" |
| SEEDS = [int(s) for s in A.seeds.split(",")] |
| OUT = f"/root/compose-audit/results/{A.tag}_{A.size}.jsonl" |
| DEV = "cuda" |
|
|
|
|
| def log(*a): |
| print(f"[{time.strftime('%H:%M:%S')}]", *a, flush=True) |
|
|
|
|
| |
| def neox_head_match(sd_a, sd_b, d, n_heads, nlayer): |
| hd = d // n_heads |
| perms = {} |
| for L in range(nlayer): |
| 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 or qk not in sd_b: |
| continue |
| A_ = np.asarray(sd_a[qk], float).reshape(n_heads, 3 * hd, d) |
| B_ = np.asarray(sd_b[qk], float).reshape(n_heads, 3 * hd, d) |
| gain = np.einsum("ixy,jxy->ij", A_, B_) |
| Ad = np.asarray(sd_a[de], float).reshape(d, n_heads, hd) |
| Bd = np.asarray(sd_b[de], float).reshape(d, n_heads, hd) |
| gain = gain + np.einsum("xiy,xjy->ij", Ad, Bd) |
| perms[L] = AL._assignment(gain) |
| return perms |
|
|
|
|
| def neox_apply_head(sd, perms, d, n_heads): |
| hd = d // n_heads |
| out = 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(n_heads, 3 * hd, d)[h].reshape(3 * d, d) |
| if qb in sd: |
| out[qb] = np.asarray(sd[qb], float).reshape(n_heads, 3 * hd)[h].reshape(3 * d) |
| out[de] = np.asarray(sd[de], float).reshape(d, n_heads, hd)[:, h].reshape(d, d) |
| return out |
|
|
|
|
| def align_full(sd_a, sd_b, d, acts_a, acts_b, n_heads, nlayer, method): |
| """AL.align_weights_full (residual basis + free MLP axis) + a GPTNeoX fused-QKV head factor, |
| each accepted only if it does not increase the scale-free block-normalised distance.""" |
| sd, info = AL.align_weights_full(sd_a, sd_b, d, acts_a=acts_a, acts_b=acts_b, |
| n_heads=None, method=method, strict=True, accept_each=True) |
| hp = neox_head_match(sd_a, sd, d, n_heads, nlayer) |
| if hp: |
| cand = neox_apply_head(sd, hp, d, n_heads) |
| if AL.block_normalised_distance(sd_a, cand) <= AL.block_normalised_distance(sd_a, sd): |
| sd, info["heads"] = cand, len(hp) |
| else: |
| info["rejected"].append("heads") |
| return sd, info |
|
|
|
|
| |
| tok = AutoTokenizer.from_pretrained(f"EleutherAI/{BASE_STEM}") |
| lines = flores_lines("eng_Latn") |
| blocks = make_blocks(tok, lines, block=512, max_blocks=A.blocks) |
| log(f"size={A.size} blocks={tuple(blocks.shape)} tokens={blocks.numel()}") |
|
|
| 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"d={D} heads={NH} layers={NL} params={sum(p.numel() for p in shell.parameters())/1e6:.1f}M") |
|
|
|
|
| def ev(sd): |
| sd_load(shell, sd, DEV) |
| return nll_nats(shell, blocks, DEV, bs=A.bs) |
|
|
|
|
| SDS, NLL, ACTS = {}, {}, {} |
| 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) |
| NLL[s] = nll_nats(m, blocks, DEV, bs=A.bs) |
| ACTS[s] = capture_acts(m, blocks, DEV, n_rows=A.acts_rows, bs=A.bs) |
| del m; torch.cuda.empty_cache() |
| log(f" seed{s} nll={NLL[s]:.4f}") |
|
|
| BASE = None |
| try: |
| mb = AutoModelForCausalLM.from_pretrained(f"EleutherAI/{BASE_STEM}", dtype=torch.float32).to(DEV).eval() |
| BASE = sd_np(mb); BASE_NLL = nll_nats(mb, blocks, DEV, bs=A.bs) |
| del mb; torch.cuda.empty_cache() |
| log(f" base({BASE_STEM}, NOT a shared ancestor of the seeds) nll={BASE_NLL:.4f}") |
| except Exception as e: |
| log("base load failed:", e) |
|
|
| KEYS = shared_keys(SDS[SEEDS[0]], SDS[SEEDS[1]]) |
| done = set() |
| if os.path.exists(OUT): |
| for line in open(OUT): |
| try: done.add(tuple(json.loads(line)["pair"])) |
| except Exception: pass |
| log(f"resuming: {len(done)} pairs already done") |
|
|
| 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] |
| r = {"set": "set1_polypythia", "size": A.size, "pair": [a, b], |
| "parent_nll": {"a": NLL[a], "b": NLL[b]}, "floor": min(NLL[a], NLL[b]), |
| "corpus": "flores200_devtest_eng_Latn", "metric": "nats_per_token"} |
|
|
| |
| sb_perm, info_p = align_full(sa, sb, D, ACTS[a], ACTS[b], NH, NL, "permutation") |
| sb_orth, info_o = align_full(sa, sb, D, ACTS[a], ACTS[b], NH, NL, "orthogonal") |
| r["align_info"] = {"perm": info_p, "orth": info_o} |
|
|
| |
| fa, fb = flat(sa, KEYS), flat(sb, KEYS) |
| p = {"weight_cosine": float(fa @ fb / (np.linalg.norm(fa) * np.linalg.norm(fb)))} |
| p["weight_cosine_bn"] = float(np.mean([ |
| float(np.asarray(sa[k], float).ravel() @ np.asarray(sb[k], float).ravel() / |
| (np.linalg.norm(sa[k]) * np.linalg.norm(sb[k]) + 1e-12)) for k in KEYS])) |
| qwd_p = MT.quotient_weight_distance(sa, sb, sb_perm, KEYS) |
| qwd_o = MT.quotient_weight_distance(sa, sb, sb_orth, KEYS) |
| p.update({"d_raw": qwd_p["d_raw"], "qmd_perm": qwd_p["qmd"], |
| "coord_share_perm": qwd_p["coord_fraction"], "norm_ratio_perm": qwd_p["norm_ratio"], |
| "qmd_orth": qwd_o["qmd"], "coord_share_orth": qwd_o["coord_fraction"]}) |
| for tag, extra in (("perm", qwd_p), ("orth", qwd_o)): |
| for k in ("d_raw_bn", "qmd_bn", "coordinate_gap_bn", "coord_fraction_bn"): |
| if k in extra: |
| p[f"{k}_{tag}"] = extra[k] |
| bnd_raw = AL.block_normalised_distance(sa, sb, KEYS) |
| bnd_p = AL.block_normalised_distance(sa, sb_perm, KEYS) |
| bnd_o = AL.block_normalised_distance(sa, sb_orth, KEYS) |
| p.update({"bnd_raw": bnd_raw, "bnd_perm": bnd_p, "bnd_orth": bnd_o, |
| "coord_share_bnd_perm": float((bnd_raw - bnd_p) / bnd_raw), |
| "coord_share_bnd_orth": float((bnd_raw - bnd_o) / bnd_raw)}) |
| ck, ck_by = mean_cka(ACTS[a], ACTS[b]) |
| p["cka_mean"] = ck; p["cka_last"] = ck_by[max(ck_by)] |
| mid = NL // 2 |
| for g in ("perm", "procrustes", "ot"): |
| try: |
| qr = MT.quotient_residual(ACTS[a][mid], ACTS[b][mid], group=g) |
| p[f"qmd_act_{g}"] = qr["distance"]; p[f"aligned_cka_{g}"] = qr["aligned_cka"] |
| except Exception as e: |
| p[f"qmd_act_{g}"] = float("nan") |
| if BASE is not None: |
| ta = flat({k: sa[k] - BASE[k] for k in KEYS}, KEYS) |
| tb = flat({k: sb[k] - BASE[k] for k in KEYS}, KEYS) |
| p["task_vector_cosine"] = float(ta @ tb / (np.linalg.norm(ta) * np.linalg.norm(tb))) |
| r["predictors"] = p |
|
|
| |
| rungs = {} |
| rungs["M0_naive_avg"] = MG.average([sa, sb]) |
| rungs["M1_perm_avg"] = MG.average([sa, sb_perm]) |
| rungs["M1_orth_avg"] = MG.average([sa, sb_orth]) |
| if BASE is not None: |
| rungs["M2_task_arith"] = MG.task_arithmetic(BASE, [sa, sb]) |
| try: |
| rungs["M3_ties"] = MG.ties(BASE, [sa, sb], density=0.2) |
| except Exception as e: |
| log("ties failed", e) |
| res = {} |
| for name, sd in rungs.items(): |
| n = ev(sd) |
| res[name] = {"nll": n, "delta_floor": n - r["floor"], |
| "delta_vs_naive": None} |
| for name in res: |
| res[name]["delta_vs_naive"] = res[name]["nll"] - res["M0_naive_avg"]["nll"] |
| r["rungs"] = res |
|
|
| |
| try: |
| bn = EV.merge_barrier(sa, sb, ev, n=A.barrier_n) |
| r["barrier_naive"] = {"barrier": bn["barrier"], "losses": list(map(float, bn["losses"]))} |
| bp = EV.merge_barrier(sa, sb_perm, ev, n=A.barrier_n) |
| r["barrier_perm"] = {"barrier": bp["barrier"], "losses": list(map(float, bp["losses"]))} |
| except Exception as e: |
| log("barrier failed", e) |
|
|
| r["secs"] = time.time() - t0 |
| fh.write(json.dumps(r) + "\n"); fh.flush() |
| log(f"pair {a},{b} floor={r['floor']:.3f} M0={res['M0_naive_avg']['delta_floor']:+.3f} " |
| f"M1perm={res['M1_perm_avg']['delta_floor']:+.3f} M1orth={res['M1_orth_avg']['delta_floor']:+.3f} " |
| f"({r['secs']:.0f}s)") |
| del rungs, sb_perm, sb_orth; gc.collect() |
| fh.close() |
| log("DONE", A.size) |
|
|
