Upload code/set1_polypythia.py with huggingface_hub

code/set1_polypythia.py

@@ -0,0 +1,206 @@
+"""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("--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)
+A = ap.parse_args()
+SEEDS = [int(s) for s in A.seeds.split(",")]
+OUT = f"/root/compose-audit/results/set1_{A.size}.jsonl"
+DEV = "cuda"
+
+
+def log(*a):
+    print(f"[{time.strftime('%H:%M:%S')}]", *a, flush=True)
+
+
+# ------------------------------------------------------------------ local: GPTNeoX fused-QKV head perm
+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
+
+
+# ------------------------------------------------------------------ setup
+tok = AutoTokenizer.from_pretrained(f"EleutherAI/pythia-{A.size}")
+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/pythia-{A.size}", 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(pythia-{A.size}, 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"}
+
+    # ---------------- alignments (fitted BEFORE any merge) ----------------
+    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}
+
+    # ---------------- predictors (pre-merge) ----------------
+    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
+
+    # ---------------- merge rungs ----------------
+    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
+
+    # ---------------- barriers ----------------
+    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)