File size: 3,681 Bytes
524f4d4 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 | """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}
|