Upload code/ma_common.py with huggingface_hub

code/ma_common.py

@@ -0,0 +1,295 @@
+"""merge-accuracy: downstream-ACCURACY benchmark of merge-before/after-alignment.
+
+Imports mergeschool.core (/root/mergeability) READ-ONLY for the merge operators, aligners and
+quotient-distance diagnostics; adds the accuracy axis (this file) that the NLL work lacks.
+"""
+from __future__ import annotations
+import os, sys, json, math, gc, time, hashlib
+for v in ("OMP_NUM_THREADS","MKL_NUM_THREADS","OPENBLAS_NUM_THREADS","NUMEXPR_NUM_THREADS"):
+    os.environ.setdefault(v, "8")
+os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+os.environ.setdefault("HF_HOME", "/root/hf_cache_mergeacc")
+sys.path.insert(0, "/root/mergeability/src")
+sys.path.insert(0, "/root/merge-accuracy")
+import numpy as np
+import torch
+torch.set_num_threads(8)
+from transformers import AutoModelForCausalLM, AutoTokenizer, AutoConfig
+
+from mergeschool.core import merge as MG
+from mergeschool.core import alignment as AL
+from mergeschool.core import metrics as MT
+
+CACHE = "/root/hf_cache_mergeacc"
+RES = "/root/merge-accuracy/results"
+
+
+# ------------------------------------------------------------------ models
+def load_model(repo, revision=None, dev="cuda", dtype=torch.float32):
+    m = AutoModelForCausalLM.from_pretrained(repo, revision=revision, cache_dir=CACHE,
+                                             dtype=dtype, low_cpu_mem_usage=True)
+    return m.to(dev).eval()
+
+
+def load_tok(repo, revision=None):
+    t = AutoTokenizer.from_pretrained(repo, revision=revision, cache_dir=CACHE)
+    if t.pad_token is None:
+        t.pad_token = t.eos_token
+    return t
+
+
+def sd_np(model):
+    return {k: v.detach().float().cpu().numpy() for k, v in model.state_dict().items()}
+
+
+def sd_load(model, sd, dtype=torch.float32):
+    with torch.no_grad():
+        msd = model.state_dict()
+        for k, v in sd.items():
+            if k in msd and tuple(msd[k].shape) == tuple(np.shape(v)):
+                msd[k].copy_(torch.as_tensor(np.asarray(v), dtype=dtype))
+    return model
+
+
+def shared_keys(a, b):
+    return [k for k, v in a.items() if k in b and np.shape(b[k]) == np.shape(v)]
+
+
+# ------------------------------------------------------------------ accuracy scoring
+@torch.no_grad()
+def _score_batch(model, tok, ctxs, conts, dev, max_len=1024):
+    """sum logprob, per-token mean logprob, and greedy-match flag for each (ctx, cont)."""
+    enc_c = [tok(c, add_special_tokens=False)["input_ids"] for c in ctxs]
+    enc_t = [tok(t, add_special_tokens=False)["input_ids"] for t in conts]
+    seqs, nconts = [], []
+    for c, t in zip(enc_c, enc_t):
+        if len(t) == 0:
+            t = [tok.eos_token_id]
+        s = (c + t)[-max_len:]
+        seqs.append(s); nconts.append(min(len(t), len(s) - 1))
+    L = max(len(s) for s in seqs)
+    pad = tok.pad_token_id or 0
+    x = torch.full((len(seqs), L), pad, dtype=torch.long)
+    for i, s in enumerate(seqs):
+        x[i, L - len(s):] = torch.tensor(s)          # left-pad
+    x = x.to(dev)
+    logits = model(x).logits.float()
+    lp = torch.log_softmax(logits[:, :-1], -1)
+    tgt = x[:, 1:]
+    tok_lp = lp.gather(-1, tgt.unsqueeze(-1)).squeeze(-1)      # (B, L-1)
+    greedy_ok = (lp.argmax(-1) == tgt)
+    out = []
+    for i, n in enumerate(nconts):
+        sl = slice(L - 1 - n, L - 1)
+        s = tok_lp[i, sl].sum().item()
+        out.append((s, s / max(n, 1), bool(greedy_ok[i, sl].all().item()), n,
+                    len(conts[i])))
+    return out
+
+
+@torch.no_grad()
+def eval_task(model, tok, docs, dev, bs=16, max_len=1024):
+    """Returns dict with acc, acc_norm, n. `acc` uses summed logprob (harness default);
+    `acc_norm` normalises by continuation character length. Generative tasks (doc['greedy'])
+    score exact greedy match of the continuation."""
+    reqs = []
+    for di, d in enumerate(docs):
+        for ci, (c, t) in enumerate(zip(d["ctxs"], d["conts"])):
+            reqs.append((di, ci, c, t))
+    # sort by length for efficient batching
+    order = sorted(range(len(reqs)), key=lambda i: -(len(reqs[i][2]) + len(reqs[i][3])))
+    res = [None] * len(reqs)
+    for b in range(0, len(order), bs):
+        idx = order[b:b + bs]
+        sc = _score_batch(model, tok, [reqs[i][2] for i in idx], [reqs[i][3] for i in idx],
+                          dev, max_len)
+        for i, s in zip(idx, sc):
+            res[i] = s
+    per_doc = {}
+    for (di, ci, _, _), s in zip(reqs, res):
+        per_doc.setdefault(di, {})[ci] = s
+    correct, correct_norm, hits = [], [], []
+    for di, d in enumerate(docs):
+        sc = per_doc[di]
+        if d.get("greedy"):
+            hits.append(int(sc[0][2]))
+            correct.append(int(sc[0][2])); correct_norm.append(int(sc[0][2]))
+        else:
+            n = len(d["ctxs"])
+            tot = [sc[c][0] for c in range(n)]
+            nrm = [sc[c][0] / max(sc[c][4], 1) for c in range(n)]
+            correct.append(int(int(np.argmax(tot)) == d["gold"]))
+            correct_norm.append(int(int(np.argmax(nrm)) == d["gold"]))
+    a = float(np.mean(correct))
+    return {"acc": a, "acc_norm": float(np.mean(correct_norm)), "n": len(docs),
+            "stderr": float(np.sqrt(a * (1 - a) / max(len(docs), 1))),
+            "items": correct}
+
+
+# ------------------------------------------------------------------ activations / alignment
+def make_blocks(tok, lines, block=512, max_blocks=32, sep="\n\n"):
+    ids = tok(sep.join(lines), add_special_tokens=False)["input_ids"]
+    n = min(max_blocks, len(ids) // block)
+    if n == 0:
+        n, block = 1, min(block, len(ids))
+    return torch.from_numpy(np.asarray(ids[:n * block], dtype=np.int64).reshape(n, block))
+
+
+@torch.no_grad()
+def capture_acts(model, blocks, dev, n_rows=2048, bs=4, seed=0):
+    outs = None
+    for i in range(0, blocks.shape[0], bs):
+        x = blocks[i:i + bs].to(dev)
+        hs = model(x, output_hidden_states=True).hidden_states
+        if outs is None:
+            outs = [[] for _ in hs]
+        for j, h in enumerate(hs):
+            outs[j].append(h.float().reshape(-1, h.shape[-1]).cpu())
+    rng = np.random.default_rng(seed)
+    N = torch.cat(outs[0]).shape[0]
+    idx = np.sort(rng.choice(N, size=min(n_rows, N), replace=False))
+    return {j: torch.cat(outs[j])[idx].numpy().astype(np.float64) for j in range(len(outs))}
+
+
+def flores_lines(code="eng_Latn", n=200):
+    p = f"/root/goldfish-alignment/data/{code}.jsonl"
+    out = []
+    with open(p, encoding="utf-8") as f:
+        for line in f:
+            r = json.loads(line)
+            if r.get("text"):
+                out.append(r["text"])
+    return out[:n]
+
+
+def align_pair(sd_a, sd_b, hidden_dim, n_heads, acts_a=None, acts_b=None, method="permutation"):
+    """Carry B into A's frame. Returns (sd_b_aligned, info)."""
+    return AL.align_weights_full(sd_a, sd_b, hidden_dim, acts_a=acts_a, acts_b=acts_b,
+                                 n_heads=n_heads, method=method, strict=False, accept_each=True)
+
+
+def diagnostics(sd_a, sd_b, sd_b_perm, sd_b_orth, acts_a=None, acts_b=None):
+    """Pre-merge diagnostic block: quotient distance / coordinate share / CKA."""
+    keys = shared_keys(sd_a, sd_b)
+    d = {}
+    for tag, sdb in (("perm", sd_b_perm), ("orth", sd_b_orth)):
+        q = MT.quotient_weight_distance(sd_a, sd_b, sdb, keys)
+        for k, v in q.items():
+            if k != "n_params":
+                d[f"{k}_{tag}"] = v
+    a = np.concatenate([np.asarray(sd_a[k], float).ravel() for k in keys])
+    b = np.concatenate([np.asarray(sd_b[k], float).ravel() for k in keys])
+    d["weight_cosine"] = float(a @ b / (np.linalg.norm(a) * np.linalg.norm(b)))
+    if acts_a is not None and acts_b is not None:
+        L = sorted(set(acts_a) & set(acts_b))
+        ck = [MT.cka(acts_a[l], acts_b[l]) for l in L]
+        d["cka_mean"] = float(np.mean(ck)); d["cka_last"] = float(ck[-1])
+        try:
+            qr = MT.quotient_residual(acts_a[L[-1]], acts_b[L[-1]], group="perm")
+            d["qmd_act_perm"] = float(qr["distance"])          # 1 - post-alignment CKA
+            d["aligned_cka_perm"] = float(qr["aligned_cka"])
+        except Exception:
+            d["qmd_act_perm"] = d["aligned_cka_perm"] = float("nan")
+    # THE diagnostic the selection experiment uses: block-normalised coordinate share, the
+    # fraction of the scale-free parameter distance that the alignment map removes.
+    d["coord_share"] = max(d.get("coord_fraction_bn_perm", 0.0) or 0.0,
+                           d.get("coord_fraction_bn_orth", 0.0) or 0.0)
+    return d
+
+
+# ------------------------------------------------------------------ merge
+def interp(a, b, t, keys=None):
+    keys = keys or list(a)
+    return {k: (1 - t) * np.asarray(a[k], float) + t * np.asarray(b[k], float) for k in keys}
+
+
+def ties_merge(base, exp_a, exp_b, density=0.2):
+    return MG.ties(base, [exp_a, exp_b], density=density)
+
+
+def jload(p):
+    if not os.path.exists(p): return {}
+    out = {}
+    with open(p) as f:
+        for line in f:
+            try:
+                r = json.loads(line); out[r["key"]] = r
+            except Exception: pass
+    return out
+
+
+def jappend(p, rec):
+    os.makedirs(os.path.dirname(p), exist_ok=True)
+    with open(p, "a") as f:
+        f.write(json.dumps(rec) + "\n"); f.flush(); os.fsync(f.fileno())
+
+
+# ------------------------------------------------------------------ tokenizer-agnostic acts
+@torch.no_grad()
+def capture_acts_sent(model, tok, sents, dev, bs=8, max_len=256):
+    """{layer: (n_sent, d)} mean-pooled residual states, ONE ROW PER SENTENCE. Row-aligned across
+    models even when the two tokenizers differ (rung 4), which token-level capture is not."""
+    outs = None
+    for i in range(0, len(sents), bs):
+        batch = sents[i:i + bs]
+        enc = tok(batch, return_tensors="pt", padding=True, truncation=True, max_length=max_len)
+        enc = {k: v.to(dev) for k, v in enc.items()}
+        hs = model(**enc, output_hidden_states=True).hidden_states
+        m = enc["attention_mask"].unsqueeze(-1).float()
+        if outs is None:
+            outs = [[] for _ in hs]
+        for j, h in enumerate(hs):
+            outs[j].append(((h.float() * m).sum(1) / m.sum(1).clamp(min=1)).cpu())
+    return {j: torch.cat(outs[j]).numpy().astype(np.float64) for j in range(len(outs))}
+
+
+def body_keys(sd_a, sd_b):
+    """Shared keys with equal shapes, EXCLUDING the token embedding / unembedding. For a
+    cross-tokenizer pair these are exactly the mergeable parameters; for a same-tokenizer pair
+    they are the whole transformer body and we merge the embeddings too (see merge_keys)."""
+    sk = shared_keys(sd_a, sd_b)
+    return [k for k in sk if not any(s in k for s in ("embed_in", "embed_out", "embed_tokens", "lm_head"))]
+
+
+def merge_keys(sd_a, sd_b):
+    sk = shared_keys(sd_a, sd_b)
+    bk = body_keys(sd_a, sd_b)
+    return (sk, "full") if len(sk) == len(bk) + 0 and len(sk) > len(bk) else (
+        (sk, "full") if len(sk) > len(bk) and _emb_match(sd_a, sd_b) else (bk, "body_only"))
+
+
+def _emb_match(sd_a, sd_b):
+    for k in sd_a:
+        if "embed_in" in k or "embed_tokens" in k:
+            return k in sd_b and np.shape(sd_a[k]) == np.shape(sd_b[k])
+    return False
+
+
+# ------------------------------------------------------------------ generation (IFEval)
+LLAMA31_CHAT = ("<|begin_of_text|><|start_header_id|>user<|end_header_id|>\n\n"
+                "{content}<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\n")
+
+@torch.no_grad()
+def generate_batch(model, tok, prompts, dev, bs=16, max_new=256, max_len=1024):
+    """Greedy decoding, left-padded. Used for IFEval, where the constraint is on the TEXT."""
+    outs = []
+    order = sorted(range(len(prompts)), key=lambda i: -len(prompts[i]))
+    res = [None] * len(prompts)
+    tok.padding_side = "left"
+    for b in range(0, len(order), bs):
+        idx = order[b:b + bs]
+        enc = tok([prompts[i] for i in idx], return_tensors="pt", padding=True,
+                  truncation=True, max_length=max_len, add_special_tokens=False).to(dev)
+        gen = model.generate(**enc, max_new_tokens=max_new, do_sample=False,
+                             pad_token_id=tok.pad_token_id)
+        for j, i in enumerate(idx):
+            res[i] = tok.decode(gen[j][enc["input_ids"].shape[1]:], skip_special_tokens=True)
+    return res
+
+
+def eval_ifeval(model, tok, dev, n=200, bs=16, max_new=256):
+    import ifeval
+    rows = ifeval.docs(n)
+    prompts = [LLAMA31_CHAT.format(content=r["prompt"]) for r in rows]
+    resp = generate_batch(model, tok, prompts, dev, bs=bs, max_new=max_new)
+    return ifeval.score(rows, resp), resp