Upload code/common.py with huggingface_hub

code/common.py

@@ -0,0 +1,105 @@
+"""Shared machinery for the compose-audit. Imports mergeschool.core READ-ONLY."""
+from __future__ import annotations
+import os, sys, json, time, math, gc
+for v in ("OMP_NUM_THREADS","MKL_NUM_THREADS","OPENBLAS_NUM_THREADS","NUMEXPR_NUM_THREADS"):
+    os.environ.setdefault(v, "8")
+sys.path.insert(0, "/root/mergeability/src")
+import numpy as np
+import torch
+torch.set_num_threads(8)
+
+from mergeschool.core import merge as MG
+from mergeschool.core import alignment as AL
+from mergeschool.core import metrics as MT
+from mergeschool.core import eval as EV
+
+DATA = "/root/goldfish-alignment/data"
+
+
+# ------------------------------------------------------------------ corpora
+def flores_lines(code):
+    out = []
+    with open(f"{DATA}/{code}.jsonl", encoding="utf-8") as f:
+        for line in f:
+            r = json.loads(line)
+            if r.get("text"):
+                out.append(r["text"])
+    return out
+
+
+def make_blocks(tok, lines, block=512, max_blocks=64, sep="\n\n"):
+    ids = tok(sep.join(lines), return_tensors=None)["input_ids"]
+    n = min(max_blocks, len(ids) // block)
+    if n == 0:
+        n, block = 1, min(block, len(ids))
+    arr = np.asarray(ids[: n * block], dtype=np.int64).reshape(n, block)
+    return torch.from_numpy(arr)
+
+
+# ------------------------------------------------------------------ state dicts
+def sd_np(model):
+    return {k: v.detach().float().cpu().numpy() for k, v in model.state_dict().items()}
+
+
+def sd_load(model, sd, dev, dtype=torch.float32):
+    with torch.no_grad():
+        msd = model.state_dict()
+        for k, v in sd.items():
+            if k in msd:
+                msd[k].copy_(torch.as_tensor(np.asarray(v), dtype=dtype))
+    return model
+
+
+# ------------------------------------------------------------------ eval
+@torch.no_grad()
+def nll_nats(model, blocks, dev, bs=8):
+    """Mean nats/token on the held-out blocks (next-token CE)."""
+    tot, ntok = 0.0, 0
+    for i in range(0, blocks.shape[0], bs):
+        x = blocks[i:i + bs].to(dev)
+        logits = model(x).logits.float()
+        lp = torch.log_softmax(logits[:, :-1], -1)
+        tgt = x[:, 1:]
+        nll = -lp.gather(-1, tgt.unsqueeze(-1)).squeeze(-1)
+        tot += nll.sum().item(); ntok += tgt.numel()
+    return tot / ntok
+
+
+@torch.no_grad()
+def capture_acts(model, blocks, dev, n_rows=2048, bs=8, seed=0):
+    """{layer_idx: (n_rows, d)} residual-stream activations on the shared corpus."""
+    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())
+    acts = {}
+    rng = np.random.default_rng(seed)
+    N = torch.cat(outs[0]).shape[0]
+    idx = rng.choice(N, size=min(n_rows, N), replace=False)
+    idx = np.sort(idx)
+    for j in range(len(outs)):
+        acts[j] = torch.cat(outs[j])[idx].numpy().astype(np.float64)
+    return acts
+
+
+# ------------------------------------------------------------------ predictors
+def flat(sd, keys):
+    return np.concatenate([np.asarray(sd[k], float).ravel() for k in keys])
+
+
+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)]
+
+
+def mean_cka(acts_a, acts_b, layers=None):
+    L = sorted(set(acts_a) & set(acts_b)) if layers is None else layers
+    vals = [MT.cka(acts_a[l], acts_b[l]) for l in L]
+    return float(np.mean(vals)), {int(l): float(v) for l, v in zip(L, vals)}
+
+
+def interp_sd(a, b, t):
+    return {k: (1 - t) * np.asarray(a[k], float) + t * np.asarray(b[k], float) for k in a}