File size: 7,495 Bytes
0f775e2 | 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 | """Final RMSNorm -> tied LM head -> temperature -> min-p filter -> inverse-CDF sample, in one kernel.
A serving stack samples for every running sequence at every step. Done as separate ops that is a
128k-wide logit matrix written to HBM, read back for a max, read back for a sum, read back for a
filter, read back for a prefix sum, and read back once more to pick a token: 1024 x 128256 fp32 is
525 MB per pass, several times over, next to a 525 MB weight read. Fused, the logits never exist.
Sampling is stochastic, so this task does NOT grade token equality. `compare` scores two things:
* a deterministic per-row summary (max logit, full log-sum-exp, log of the kept mass), by relative
error -- this pins the norm, the projection, the temperature and the filter threshold exactly; and
* the sampled tokens *statistically*, against the reference's own distribution: every token must lie
in the kept support, and the mean surprisal of the drawn tokens must match the entropy of the
filtered distribution. Correct samplers pass at any seed; argmax, unfiltered sampling and
uniform-over-support all miss by a wide margin.
The surprisal term is scored under `e / kept_sum` rather than under `q`, which matters only for a
token sitting in the support check's slack band -- see the long comment in `compare`. Scoring it under
`q` charged such a token 69 nats and failed CORRECT implementations at z = 15-30.
The reference stashes its filtered distribution in a module global so `compare` can score the
submission's tokens under the *reference's* probabilities -- a submission cannot fabricate them.
"""
from model import HELPERS_CORE
BODY = r'''
_REF = {}
_TOL = 1e-2 # the task's tolerance; compare() scales every check into these units
_ZCRIT = 8.0 # the statistical check spends the whole tolerance at 8 sigma
def make_weights(cfg, seed=0, device="cuda"):
"""Tied LM head: the embedding matrix, plus the final RMSNorm gain."""
g = torch.Generator(device=device).manual_seed(seed)
d = cfg["d"]
e = (torch.randn(cfg["vocab"], d, device=device, dtype=torch.float32, generator=g)
/ (d ** 0.5)).to(torch.bfloat16)
return {"embed": e, "final_norm": torch.ones(d, device=device, dtype=torch.bfloat16)}
def make_kv(cfg, batch, prefill_len, max_seq, seed=0, device="cuda"):
"""No KV cache in this task."""
return []
def make_step_args(cfg, batch, base_pos, seed, n):
"""(x, u) per call -- B hidden states and B uniform variates in [0, 1)."""
g = torch.Generator(device="cuda").manual_seed(seed)
out = []
for _ in range(n):
x = torch.randn(batch, cfg["d"], device="cuda", dtype=torch.float32,
generator=g).to(torch.bfloat16)
u = torch.rand(batch, device="cuda", dtype=torch.float32, generator=g)
out.append((x, u))
return out
def build_head(weights, kv_cache, cfg, max_seq_len):
"""UNTIMED setup. Re-tile the embedding, allocate scratch, launch a persistent kernel, ..."""
return {"W": weights, "cfg": cfg}
@torch.no_grad()
def sample_step(handle, x, u):
"""Norm, project to the vocabulary, min-p filter, and draw one token per row.
x : (B, d) bf16 the final hidden state of each running sequence
u : (B,) fp32 one uniform variate per row, in [0, 1)
returns : (tokens, aux) -- tokens (B,) int64; aux (B, 3) fp32 = [max_logit, lse, log_kept_mass]
"""
W, cfg = handle["W"], handle["cfg"]
minp = cfg["min_p"]
h = _rms_norm(x, W["final_norm"], cfg["eps"])
z = torch.matmul(h, W["embed"].T).float() * (1.0 / cfg["temperature"]) # (B, vocab)
m = z.amax(-1, keepdim=True)
e = torch.exp(z - m) # e_max == 1, so p_i >= min_p * p_max <=> e_i >= min_p
se = e.sum(-1, keepdim=True)
kept = e * (e >= minp)
ks = kept.sum(-1, keepdim=True)
q = kept / ks # renormalised filtered distribution
cdf = q.cumsum(-1)
tok = torch.searchsorted(cdf.contiguous(), u.unsqueeze(1).contiguous())
tok = tok.clamp_(max=cfg["vocab"] - 1).squeeze(1)
_REF.update(e=e, q=q, ks=ks, minp=minp) # ground truth for the statistical check
return tok, torch.cat([m, m + se.log(), (ks / se).log()], dim=1)
def compare(got, exp):
"""Deterministic summary by relative error; sampled tokens by a statistical test.
Returns one scalar in tolerance units -- the max of
* relative error of `aux` (already in those units),
* 10x the fraction of drawn tokens outside the reference's kept support, with a 2x slack band
on the threshold so a boundary token is never punished, and
* the surprisal z-score, scaled so that |z| = 8 exactly spends the tolerance.
The z-score is the honest way to do this. For a correct draw from `q`, the surprisal
`-log q(token)` has mean `H(q)` and variance `V(q)` (the varentropy) for each row, so the mean
over B independent rows is `mean(H)` with standard error `sqrt(sum(V))/B` -- a quantity computed
from the reference's own distribution, with nothing to tune. A correct sampler gives |z| ~ N(0,1)
at any seed; at B = 1024 an argmax gives z = 33.8, uniform-over-support 33.6 and unfiltered
sampling 3064 (measured). The limit is eight sigma; the worst |z| over 24 correct draws was 3.19.
The probabilities used are the REFERENCE's, recorded by the reference call that ran immediately
before this comparison, so a submission cannot influence its own statistical score.
"""
gt, ga = got
et, ea = exp
a = ((ga.float() - ea.float()).norm() / ea.float().norm().clamp(min=1e-9)).item()
e, q, ks, minp = _REF["e"], _REF["q"], _REF["ks"], _REF["minp"]
t = gt.reshape(-1).to(torch.int64)
B = q.shape[0]
if t.numel() != B or int(t.min()) < 0 or int(t.max()) >= q.shape[1]:
return 1.0
r = torch.arange(B, device=q.device)
out_of_support = (e[r, t] < 0.5 * minp).float().mean().item()
lq = q.clamp(min=1e-30).log()
Hrow = -(q * lq).sum(-1) # entropy per row
Vrow = ((q * lq * lq).sum(-1) - Hrow * Hrow).clamp(min=0) # varentropy per row
stderr = (Vrow.sum().sqrt() / B).clamp(min=1e-9)
# Surprisal is scored under e/ks, NOT under q. On every token the reference kept, the two are the
# same number, so the statistic is unchanged for a correct sampler. They differ only for a token
# in the 2x slack band -- one the support check above deliberately forgives -- where q is exactly
# 0 and -log q is 69 nats. Scoring those under q was a real defect: an independent but CORRECT
# implementation lands a handful of the 1024 rows in that band (its logits differ from the
# reference's by ~1.7e-3, so a token whose e sits within a per cent of the threshold falls the
# other way), and 7 rows x 69 nats moved the mean surprisal by 0.44 against a standard error of
# 0.029 -- z = 15 to 30 on a limit of 8. Measured: the same correct implementation scores 0.005
# under this line and 0.11 under the old one, against a tolerance of 0.03. A boundary token now
# scores just above the least likely KEPT token, and a token from far outside the support still
# scores enormously (and is caught by out_of_support besides).
ps = (e / ks).clamp(min=1e-30)
z = ((-ps[r, t].log()).mean() - Hrow.mean()).abs() / stderr
return max(a, 10.0 * out_of_support, _TOL * z.item() / _ZCRIT)
'''
MODEL_SRC = HELPERS_CORE + BODY
|