File size: 24,054 Bytes
862587b
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
#!/usr/bin/env python3
"""Prior-shift diagnostic: how much of a model's loss increase on old-distribution text is
recovered by a context-free correction of its logits?

For a base model and one or more derived models sharing its tokenizer:
  1. Read web documents (one DCLM shard of the OLMo-2 pretraining mix) in file order and
     split them by document into FIT (F) and EVAL (E) by a fixed token budget.
  2. For each model, cache the final hidden states h (bf16) on F and E, and the
     unembedding W. Logits are z = h @ W^T with fp32 accumulation (TF32 loses nothing on
     the bf16-valued inputs).
  3. Fit per model, on F only:
       cf         b = log q_s - log pbar (closed form, q_s Dirichlet-smoothed toward pbar)
       bias       b by iterative proportional fitting toward a smoothed target,
                  early-stopped on the last 10% of F documents
       aff        temperature T by golden-section search on log T over T in [0.25, 4], with the
                  IPF bias refitted at each T
       bias_top4k, aff_top4k   as bias and aff, but only the 4,096 most frequent F tokens
                  may move
  4. Score E for both models under each correction and report
       Delta  = CE_new - CE_old
       S_card = (CE_new - CE_new^x) / Delta              (share recovered on the new model)
       S_sym  = 1 - (CE_new^x - CE_old^x) / Delta       (base given its own fit of the same kind of correction)
     with document-bootstrap 95% intervals, and the in-sample Jensen bound
     R_cf(E) >= KL(q_E || pbar_E) on E as a correctness check.

Logits are restricted to the "regular" vocabulary: ids below len(tokenizer) that are not
special or added tokens in any of the group's tokenizers. Targets outside it are dropped.

The statistics (`stats_*`, `fit_*`, `analyse`) are pure torch and are exercised on synthetic
known-answer cases by test_prior_shift.py.

usage: python prior_shift.py --base BASE [--base_rev SHA] --new NEW [NEW ...]
                             [--new_rev SHA [SHA ...]] --out DIR
"""
from __future__ import annotations

import argparse
import hashlib
import io
import json
import math
import os
import platform
import sys
import time

import numpy as np
import torch

DCLM_SHARD = ("data/dclm/raw/hero-run-fasttext_for_HF/filtered/OH_eli5_vs_rw_v2_bigram_200k_train/"
              "fasttext_openhermes_reddit_eli5_vs_rw_v2_bigram_200k_train/processed_data/"
              "global-shard_01_of_10/local-shard_0_of_10/shard_00000000_processed.jsonl.zstd")
DCLM_REPO = "allenai/olmo-mix-1124"
T0 = time.time()


def log(msg):
    print(f"[{time.time() - T0:8.1f}s] {msg}", file=sys.stderr, flush=True)
POS_BUCKETS = [(1, 1), (2, 8), (9, 64), (65, 512), (513, 10**9)]


# ----------------------------------------------------------------------------- data

def iter_dclm_docs(path_or_url: str):
    """Yield (index, text) from a .jsonl.zstd file, streaming."""
    import zstandard
    if path_or_url.startswith("http"):
        import requests
        raw = requests.get(path_or_url, stream=True, timeout=120).raw
    else:
        raw = open(path_or_url, "rb")
    reader = zstandard.ZstdDecompressor().stream_reader(raw)
    for i, line in enumerate(io.TextIOWrapper(reader, encoding="utf-8")):
        rec = json.loads(line)
        yield i, rec["text"]


def build_splits(docs, tok, fit_tokens: int, eval_tokens: int, max_len: int, min_tokens: int = 16):
    """Assign whole documents in file order: first to F until fit_tokens targets, then E.

    Each document becomes [prefix] + text_ids[: max_len - 1]. Returns lists of
    dicts with doc index, sha256 of the text and the token ids."""
    prefix = tok.bos_token_id if tok.bos_token_id is not None else tok.eos_token_id
    F, E, nf, ne = [], [], 0, 0
    for idx, text in docs:
        ids = tok(text, add_special_tokens=False)["input_ids"][: max_len - 1]
        if len(ids) < min_tokens:
            continue
        rec = {"doc": idx, "sha256": hashlib.sha256(text.encode()).hexdigest(), "ids": [prefix] + ids}
        if nf < fit_tokens:
            F.append(rec); nf += len(ids)
        elif ne < eval_tokens:
            E.append(rec); ne += len(ids)
        else:
            break
    return F, E


def regular_vocab_mask(toks, vocab_rows: int) -> torch.Tensor:
    """True for ids that are ordinary text tokens of every tokenizer in toks."""
    allowed = torch.zeros(vocab_rows, dtype=torch.bool)
    n = min(min(len(t) for t in toks), vocab_rows)
    allowed[:n] = True
    special = set()
    for tok in toks:
        special |= set(tok.all_special_ids)
        special |= set(getattr(tok, "added_tokens_decoder", {}).keys())
    for i in special:
        if 0 <= i < vocab_rows:
            allowed[i] = False
    return allowed


# ----------------------------------------------------------------------------- caching

@torch.no_grad()
def cache_hidden(model, docs, device, batch_tokens: int = 16384):
    """Run docs through the model; return (H [N,d] bf16, targets [N], pos [N], doc_of [N]) on CPU.

    Row n holds the final normed hidden state at position t, whose target is ids[t+1].
    Position index p = t+1 is the target's position in the document (1 = first text token)."""
    Hs, Ys, Ps, Ds = [], [], [], []
    order = sorted(range(len(docs)), key=lambda i: len(docs[i]["ids"]))
    i = 0
    while i < len(order):
        # order is ascending in length, so the last doc in a group is its longest: grow the
        # group while (size x longest) stays within batch_tokens of padded positions
        group = [order[i]]
        while i + len(group) < len(order) and \
                (len(group) + 1) * len(docs[order[i + len(group)]]["ids"]) <= batch_tokens:
            group.append(order[i + len(group)])
        i += len(group)
        Lmax = len(docs[group[-1]]["ids"])
        x = torch.zeros(len(group), Lmax, dtype=torch.long)
        att = torch.zeros(len(group), Lmax, dtype=torch.long)
        for r, j in enumerate(group):
            ids = docs[j]["ids"]
            x[r, : len(ids)] = torch.tensor(ids)
            att[r, : len(ids)] = 1
        out = model.model(input_ids=x.to(device), attention_mask=att.to(device), use_cache=False)
        h = out.last_hidden_state  # already passed through the final norm
        for r, j in enumerate(group):
            n = len(docs[j]["ids"])
            Hs.append(h[r, : n - 1].to(torch.bfloat16).cpu())
            Ys.append(torch.tensor(docs[j]["ids"][1:n]))
            Ps.append(torch.arange(1, n))
            Ds.append(torch.full((n - 1,), j))
    # kept on CPU while the model is resident; moved to the device after it is freed
    return torch.cat(Hs), torch.cat(Ys), torch.cat(Ps), torch.cat(Ds)


# ----------------------------------------------------------------------------- core math

class Logits:
    """z = h @ W^T restricted to an allowed vocabulary, evaluated in chunks."""

    def __init__(self, H, W, allowed, chunk: int = 4096):
        self.H, self.W, self.chunk = H, W, chunk
        self.neg = torch.zeros(W.shape[0], device=W.device)
        self.neg[~allowed.to(W.device)] = float("-inf")

    def __len__(self):
        return self.H.shape[0]

    def chunks(self, idx=None):
        n = len(self) if idx is None else idx.numel()
        for s in range(0, n, self.chunk):
            sl = slice(s, min(s + self.chunk, n))
            rows = self.H[sl] if idx is None else self.H[idx[sl]]
            yield sl, rows.float() @ self.W.T

    def ce(self, z, y, b=None, logT=None):
        return ce_terms(z, y, b, logT, self.neg)

    def softmax(self, z):
        return torch.softmax(z + self.neg, dim=-1)


def ce_terms(z, y, b=None, logT=None, neg=None):
    """Per-token cross-entropy of softmax(z / T + b + neg) at targets y.

    neg is 0 on allowed ids and -inf elsewhere; it is added after the temperature so
    that d/dlogT never meets -inf * 0."""
    if logT is not None:
        z = z * torch.exp(-logT)
    if b is not None:
        z = z + b
    if neg is not None:
        z = z + neg
    return torch.logsumexp(z, dim=-1) - z.gather(1, y[:, None]).squeeze(1)


@torch.no_grad()
def mean_softmax(L: Logits, idx=None, b=None, logT=None):
    """Mean predictive distribution of softmax(z / T + b) over the rows idx (all rows if None)."""
    acc, n = torch.zeros(L.W.shape[0], device=L.W.device, dtype=torch.float64), 0
    for _, z in L.chunks(idx):
        if logT is not None:
            z = z * torch.exp(-logT)
        if b is not None:
            z = z + b
        acc += L.softmax(z).sum(0).double(); n += z.shape[0]
    return acc / n


@torch.no_grad()
def mean_ce(L: Logits, y, idx, b=None, logT=None):
    return sum(L.ce(z, y[idx[sl]], b, logT).double().sum().item()
               for sl, z in L.chunks(idx)) / idx.numel()


def counts(y, V, idx=None):
    yy = y if idx is None else y[idx]
    return torch.bincount(yy, minlength=V).double()


def closed_form_bias(c, pbar, beta: float):
    """b = log q_s - log pbar with q_s = (c + beta * pbar) / (N + beta)."""
    N = c.sum()
    qs = (c + beta * pbar) / (N + beta)
    b = torch.log(qs) - torch.log(pbar)
    b[~torch.isfinite(b)] = 0.0  # disallowed ids have pbar = 0; their logits are -inf anyway
    return b.float()


def smoothed_target(L: Logits, y, train_idx, beta_frac: float):
    """q_s = (c + beta * pbar0) / (N + beta) on the train rows, beta = beta_frac * N."""
    V = L.W.shape[0]
    c = counts(y, V, train_idx)
    beta = beta_frac * c.sum()
    return (c + beta * mean_softmax(L, train_idx)) / (c.sum() + beta)


@torch.no_grad()
def fit_bias_ipf(L: Logits, y, train_idx, val_idx, target, logT=None, max_iter: int = 20,
                 patience: int = 3, tag: str = "bias", active=None):
    """Iterative proportional fitting of a context-free bias: b <- b + log target - log pbar_b.

    Each token activates exactly one bias coordinate, so this is generalised iterative
    scaling with C = 1: it increases the target-weighted likelihood monotonically, and its
    fixed point is the bias whose train-mean predictive distribution equals the target
    (MDI / dynamic marginals). The first step from b = 0 is the closed-form bias. The
    iterate with the lowest val CE is kept. Deterministic; no line search."""
    allowed = L.neg == 0
    if active is not None:  # only these coordinates may move; the rest stay at 0
        allowed = allowed & active
    logt = torch.where(allowed, target.clamp_min(1e-300).log(), torch.zeros_like(target))
    b = torch.zeros(L.W.shape[0], device=L.W.device)
    best = (mean_ce(L, y, val_idx, b, logT), b.clone(), 0)
    trace = [{"it": 0, "val": best[0]}]
    for it in range(1, max_iter + 1):
        pb = mean_softmax(L, train_idx, b, logT)
        step = logt - pb.log()
        step[~allowed | ~torch.isfinite(step)] = 0.0
        b = b + step.float()
        v = mean_ce(L, y, val_idx, b, logT)
        trace.append({"it": it, "val": v, "max_abs_step": float(step.abs().max())})
        log(f"  fit {tag} it={it} val={v:.6f} max|step|={float(step.abs().max()):.3g}")
        if v < best[0] - 1e-7:
            best = (v, b.clone(), it)
        elif it - best[2] >= patience:
            break
    return best[1], best[0], trace


@torch.no_grad()
def fit_affine(L: Logits, y, train_idx, val_idx, target, max_iter: int = 20,
               lo: float = 0.25, hi: float = 4.0, evals: int = 14, active=None, tag: str = "aff"):
    """Temperature by golden-section search on log T over [lo, hi], scored by the val CE of the
    IPF-fitted bias at that temperature. Returns (b, logT, trace)."""
    g = (math.sqrt(5) - 1) / 2
    a, d = math.log(lo), math.log(hi)
    cache = {}

    def f(x):
        if x not in cache:
            lt = torch.tensor(x, device=L.W.device)
            b, v, _ = fit_bias_ipf(L, y, train_idx, val_idx, target, lt, max_iter,
                                   tag=f"{tag} T={math.exp(x):.3f}", active=active)
            cache[x] = (v, b)
        return cache[x][0]

    x1, x2 = d - g * (d - a), a + g * (d - a)
    f1, f2 = f(x1), f(x2)
    for _ in range(evals - 2):
        if f1 <= f2:
            d, x2, f2 = x2, x1, f1
            x1 = d - g * (d - a); f1 = f(x1)
        else:
            a, x1, f1 = x1, x2, f2
            x2 = a + g * (d - a); f2 = f(x2)
    xb = min(cache, key=lambda k: cache[k][0])
    trace = [{"T": math.exp(k), "val": v[0]} for k, v in sorted(cache.items())]
    at_edge = min(abs(xb - math.log(lo)), abs(xb - math.log(hi))) < 0.05
    return cache[xb][1], torch.tensor(xb, device=L.W.device), {"grid": trace, "T_at_bracket_edge": at_edge}


@torch.no_grad()
def score(L: Logits, y, pos, doc, n_docs, corrections: dict):
    """Per-document CE sums under each correction, plus per-position-bucket sums."""
    out = {k: torch.zeros(n_docs, dtype=torch.float64, device=y.device) for k in corrections}
    buck = {k: torch.zeros(len(POS_BUCKETS), dtype=torch.float64, device=y.device) for k in corrections}
    ntok = torch.zeros(n_docs, dtype=torch.float64, device=y.device)
    nbuck = torch.zeros(len(POS_BUCKETS), dtype=torch.float64, device=y.device)
    for sl, z in L.chunks():
        yy, pp, dd = y[sl], pos[sl], doc[sl]
        ntok.index_add_(0, dd, torch.ones_like(dd, dtype=torch.float64))
        for bi, (lo, hi) in enumerate(POS_BUCKETS):
            nbuck[bi] += ((pp >= lo) & (pp <= hi)).sum()
        for k, (b, s) in corrections.items():
            ce = L.ce(z, yy, b, s).double()
            out[k].index_add_(0, dd, ce)
            for bi, (lo, hi) in enumerate(POS_BUCKETS):
                m = (pp >= lo) & (pp <= hi)
                buck[k][bi] += ce[m].sum()
    return out, ntok, buck, nbuck


def stats_from_docsums(old: dict, new: dict, ntok, B: int = 2000, seed: int = 0):
    """Point estimates and document-bootstrap 95% CIs of Delta, R's, S_card and S_sym."""
    keys = list(old)
    o = {k: old[k].cpu().numpy() for k in keys}
    n = {k: new[k].cpu().numpy() for k in keys}
    t = ntok.cpu().numpy()

    def point(ix):
        T = t[ix].sum()
        ce_o = {k: o[k][ix].sum() / T for k in keys}
        ce_n = {k: n[k][ix].sum() / T for k in keys}
        d = ce_n["id"] - ce_o["id"]
        r = {"Delta": d}
        for k in keys:
            if k == "id":
                continue
            r[f"R_{k}_new"] = ce_n["id"] - ce_n[k]
            r[f"R_{k}_old"] = ce_o["id"] - ce_o[k]
            r[f"S_card_{k}"] = (ce_n["id"] - ce_n[k]) / d if d != 0 else float("nan")
            r[f"S_sym_{k}"] = 1 - (ce_n[k] - ce_o[k]) / d if d != 0 else float("nan")
        r.update({f"CE_old_{k}": ce_o[k] for k in keys})
        r.update({f"CE_new_{k}": ce_n[k] for k in keys})
        return r

    allix = np.arange(len(t))
    est = point(allix)
    rng = np.random.default_rng(seed)
    boots = [point(rng.integers(0, len(t), len(t))) for _ in range(B)]
    ci = {k: [float(np.nanpercentile([bb[k] for bb in boots], 2.5)),
              float(np.nanpercentile([bb[k] for bb in boots], 97.5))] for k in est}
    return {k: float(v) for k, v in est.items()}, ci


# ----------------------------------------------------------------------------- per model

def run_model(name, rev, F, E, tok, args, device, unrestricted: bool):
    """tok: list of the pair's tokenizers (the vocabulary mask is their intersection)."""
    from transformers import AutoModelForCausalLM
    t0 = time.time()
    model = AutoModelForCausalLM.from_pretrained(name, revision=rev, dtype=torch.bfloat16).to(device).eval()
    W = model.get_output_embeddings().weight.detach().to(torch.bfloat16).float()
    if getattr(model.get_output_embeddings(), "bias", None) is not None:
        raise SystemExit(f"{name} has an output bias; harness assumes none")
    log(f"{name}: loaded; caching FIT")
    HF, yF, pF, dF = cache_hidden(model, F, device, args.batch_tokens)
    log(f"{name}: caching EVAL")
    HE, yE, pE, dE = cache_hidden(model, E, device, args.batch_tokens)
    log(f"{name}: cached {HF.shape[0]} + {HE.shape[0]} positions")
    del model
    torch.cuda.empty_cache() if device.startswith("cuda") else None
    W = W.to(device)
    V = W.shape[0]
    allowed = regular_vocab_mask(tok, V) if not unrestricted else torch.ones(V, dtype=torch.bool)
    # caches are still on the CPU; analyse masks them there and moves only the kept rows
    sums, ntok, buck, nbuck, meta = analyse(HF, yF, pF, dF, HE, yE, pE, dE, W, allowed,
                                            len(F), len(E), args)
    meta.update({"model": name, "revision": rev, "seconds": time.time() - t0})
    return sums, ntok, buck, nbuck, meta


def analyse(HF, yF, pF, dF, HE, yE, pE, dE, W, allowed, nF_docs, nE_docs, args):
    """Everything after caching: fit corrections on F, score E. Model-free, so testable."""
    device = W.device
    V = W.shape[0]
    keepF, keepE = allowed[yF.cpu()], allowed[yE.cpu()]
    HF, yF, pF, dF = (t.cpu()[keepF].to(device) for t in (HF, yF, pF, dF))
    HE, yE, pE, dE = (t.cpu()[keepE].to(device) for t in (HE, yE, pE, dE))
    LF, LE = Logits(HF, W, allowed, args.chunk), Logits(HE, W, allowed, args.chunk)

    # F split for early stopping: last 10% of F documents
    cut = int(0.9 * nF_docs)
    tr_idx = torch.nonzero(dF < cut).squeeze(1)
    va_idx = torch.nonzero(dF >= cut).squeeze(1)

    pbar = mean_softmax(LF)
    c = counts(yF, V)
    corr = {"id": (None, None)}
    for beta in args.betas:
        corr[f"cf_beta{beta:g}"] = (closed_form_bias(c, pbar, beta), None)
    target = smoothed_target(LF, yF, tr_idx, args.beta_frac)
    b_bias, _, tr_b = fit_bias_ipf(LF, yF, tr_idx, va_idx, target, None, args.max_iter)
    b_aff, s_aff, tr_a = fit_affine(LF, yF, tr_idx, va_idx, target, args.max_iter)
    corr["bias"] = (b_bias, None)
    corr["aff"] = (b_aff, s_aff)
    # secondary: bias restricted to the top-K FIT tokens (regularised by support, not by shrinkage)
    ctr = counts(yF, V, tr_idx)
    active = torch.zeros(V, dtype=torch.bool, device=device)
    active[torch.topk(ctr, min(args.topk, V)).indices] = True
    k = f"top{args.topk // 1024}k" if args.topk % 1024 == 0 else f"top{args.topk}"
    b_bk, _, tr_bk = fit_bias_ipf(LF, yF, tr_idx, va_idx, target, None, args.max_iter, tag=f"bias_{k}", active=active)
    b_ak, s_ak, tr_ak = fit_affine(LF, yF, tr_idx, va_idx, target, args.max_iter, active=active, tag=f"aff_{k}")
    corr[f"bias_{k}"] = (b_bk, None)
    corr[f"aff_{k}"] = (b_ak, s_ak)

    log("scoring EVAL")
    sums, ntok, buck, nbuck = score(LE, yE, pE, dE, nE_docs, corr)

    # in-sample Jensen check on E: R_cf(E) >= KL(q_E || pbar_E)
    pbarE = mean_softmax(LE)
    qE = counts(yE, V) / yE.numel()
    m = qE > 0
    kl = float((qE[m] * (qE[m].log() - pbarE[m].log())).sum())
    bE = torch.where(m, qE.clamp_min(1e-300).log() - pbarE.log(), torch.full_like(qE, float("-inf"))).float()
    bE[~allowed.to(device)] = 0.0
    ce_id = ce_ins = 0.0
    for sl, z in LE.chunks():
        ce_id += LE.ce(z, yE[sl]).double().sum().item()
        ce_ins += LE.ce(z, yE[sl], bE).double().sum().item()
    R_in = (ce_id - ce_ins) / yE.numel()

    n_pbar0 = int(((qE > 0) & (pbarE <= 0)).sum())  # fp32 underflow would make the check non-finite
    meta = {"vocab_rows": V, "allowed": int(allowed.sum()), "eval_targets_with_pbar0": n_pbar0,
            "fit_targets": int(yF.numel()), "eval_targets": int(yE.numel()),
            "T_aff": float(torch.exp(s_aff)), "bias_trace": tr_b, "aff_trace": tr_a,
            "T_aff_topk": float(torch.exp(s_ak)), "bias_topk_trace": tr_bk, "aff_topk_trace": tr_ak,
            "jensen_in_sample_E": {"R_cf": R_in, "KL_q_pbar": kl, "holds": R_in >= kl - 1e-9}}
    return sums, ntok, buck, nbuck, meta


def main(argv=None):
    ap = argparse.ArgumentParser()
    ap.add_argument("--base", required=True); ap.add_argument("--base_rev", default=None)
    ap.add_argument("--new", required=True, nargs="+")
    ap.add_argument("--new_rev", nargs="+", default=None, help="one per --new; '-' for the default branch")
    ap.add_argument("--data", default=f"https://huggingface.co/datasets/{DCLM_REPO}/resolve/main/{DCLM_SHARD}")
    ap.add_argument("--fit_tokens", type=int, default=1_000_000)
    ap.add_argument("--eval_tokens", type=int, default=1_000_000)
    ap.add_argument("--max_len", type=int, default=2048)
    ap.add_argument("--betas", type=float, nargs="+", default=[1e5, 1e4, 1e6])
    ap.add_argument("--max_iter", type=int, default=20, help="IPF iterations per bias fit")
    ap.add_argument("--beta_frac", type=float, default=0.1)
    ap.add_argument("--topk", type=int, default=4096, help="support of the secondary top-K bias")
    ap.add_argument("--batch_tokens", type=int, default=16384)
    ap.add_argument("--chunk", type=int, default=2048)
    ap.add_argument("--unrestricted", action="store_true")
    ap.add_argument("--device", default="cuda" if torch.cuda.is_available() else "cpu")
    ap.add_argument("--out", required=True)
    a = ap.parse_args(argv)
    revs = a.new_rev or ["-"] * len(a.new)
    if len(revs) != len(a.new):
        raise SystemExit("--new_rev must have one entry per --new")
    revs = [None if r == "-" else r for r in revs]
    torch.backends.cuda.matmul.allow_tf32 = True  # exact for bf16-valued operands
    os.makedirs(a.out, exist_ok=True)
    from transformers import AutoTokenizer
    tok = AutoTokenizer.from_pretrained(a.base, revision=a.base_rev)
    toks_new = [AutoTokenizer.from_pretrained(n, revision=r) for n, r in zip(a.new, revs)]
    probe = "The quick brown fox, 1234 jumps; über naïve café."
    for n, t in zip(a.new, toks_new):
        if tok(probe, add_special_tokens=False)["input_ids"] != t(probe, add_special_tokens=False)["input_ids"]:
            raise SystemExit(f"base and {n} tokenizers disagree on plain text")
    F, E = build_splits(iter_dclm_docs(a.data), tok, a.fit_tokens, a.eval_tokens, a.max_len)
    log(f"splits: {len(F)} FIT docs, {len(E)} EVAL docs")
    with open(os.path.join(a.out, "inputs.json"), "w") as fh:
        json.dump({"data": a.data, "fit_docs": [(d["doc"], d["sha256"], len(d["ids"])) for d in F],
                   "eval_docs": [(d["doc"], d["sha256"], len(d["ids"])) for d in E], "args": vars(a)}, fh)
    # one vocabulary mask for the whole group, so the base is fitted once
    all_toks = [tok] + toks_new
    so, nt, bo, nb, mo = run_model(a.base, a.base_rev, F, E, all_toks, a, a.device, a.unrestricted)
    env = {"torch": torch.__version__, "python": sys.version, "platform": platform.platform(),
           "gpu": torch.cuda.get_device_name(0) if torch.cuda.is_available() else None}
    outs = []
    for name, rev in zip(a.new, revs):
        sn, _, bn, _, mn = run_model(name, rev, F, E, all_toks, a, a.device, a.unrestricted)
        est, ci = stats_from_docsums(so, sn, nt)
        by_pos = {f"{lo}-{hi}": {"n": float(nb[i]),
                                 "Delta": float((bn["id"][i] - bo["id"][i]) / nb[i]),
                                 "Delta_after_aff": float((bn["aff"][i] - bo["aff"][i]) / nb[i])}
                  for i, (lo, hi) in enumerate(POS_BUCKETS) if nb[i] > 0}
        out = {"pair": [a.base, name], "revisions": [a.base_rev, rev], "estimates": est, "ci95": ci,
               "by_position": by_pos, "old_meta": mo, "new_meta": mn,
               "n_eval_docs": len(E), "n_fit_docs": len(F), "env": env}
        slug = (name.split("/")[-1] + ("@" + rev[:12] if rev else "")).replace("/", "_")
        d = os.path.join(a.out, slug); os.makedirs(d, exist_ok=True)
        np.savez_compressed(os.path.join(d, "docsums.npz"), ntok=nt.cpu().numpy(),
                            **{f"old_{k}": v.cpu().numpy() for k, v in so.items()},
                            **{f"new_{k}": v.cpu().numpy() for k, v in sn.items()})
        with open(os.path.join(d, "result.json"), "w") as fh:
            json.dump(out, fh, indent=1)
        keys = [k for k in est if k.startswith(("Delta", "S_sym_aff", "S_sym_bias", "S_sym_cf_beta100000"))]
        print(slug, json.dumps({k: round(est[k], 4) for k in keys}), flush=True)
        outs.append(out)
    return outs


if __name__ == "__main__":
    main()