code/common.py

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