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