| """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" |
|
|
|
|
| |
| 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) |
|
|
|
|
| |
| 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 |
|
|
|
|
| |
| @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 |
|
|
|
|
| |
| 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} |
|
|
