| """Llama-shaped decoder verifying a speculative-decoding DRAFT TREE in one forward pass. |
| |
| A speculative decoder proposes a *tree* of candidate continuations, not a chain: node 0 is the last |
| accepted token, and every other node has a parent, so the 8 nodes cover several branching futures at |
| once. Verifying them means one forward pass in which |
| |
| * every node attends to the whole committed KV cache, and |
| * among the 8 new nodes, node `i` attends to node `j` only if `j` is an ancestor of `i` (or `i` |
| itself) -- an arbitrary DAG mask, **not** a causal triangle; |
| * node `i` gets RoPE position `pos + depth(i)`, so two siblings share a position; |
| * all 8 nodes are appended to the cache at slots `pos .. pos+7`, because the accepted prefix will be |
| compacted out of them afterwards. |
| |
| The mask and the position ids arrive as inputs, freshly generated per step. This is the EAGLE / Medusa |
| tree-attention kernel, and it is a genuinely different shape from a causal chunk: the mask is data, it |
| is not decomposable into a triangle, and it is tiny (8x8) while the KV it sits next to is enormous. |
| |
| Acceptance is deliberately NOT part of the graded contract. Deciding which drafts are accepted is an |
| argmax over near-tied logits, which two correct implementations disagree about; the kernel problem is |
| the masked forward pass, and that is what is graded. |
| """ |
| from model import HELPERS_CORE, QUANT_FP8 |
|
|
| BODY = r''' |
| def _rope_at(x, cos, sin, pos_ids): |
| """x: (B, H, T, hd), pos_ids: (T,) int64 -- one RoPE position per node. fp32, then cast back.""" |
| c = cos[pos_ids].unsqueeze(0).unsqueeze(0) # (1, 1, T, hd/2) |
| s = sin[pos_ids].unsqueeze(0).unsqueeze(0) |
| xf = x.float() |
| x1, x2 = xf[..., ::2], xf[..., 1::2] |
| return torch.stack([x1 * c - x2 * s, x1 * s + x2 * c], dim=-1).flatten(-2).to(x.dtype) |
| |
| |
| def make_weights(cfg, seed=0, device="cuda"): |
| """Deterministic 1/sqrt(fan_in)-scaled weights. No checkpoint is shipped or downloaded.""" |
| g = torch.Generator(device=device).manual_seed(seed) |
| d, ffn, n_q, n_kv, hd = cfg["d"], cfg["ffn"], cfg["n_q"], cfg["n_kv"], cfg["hd"] |
| dt = cfg["wdtype"] |
| |
| def rnd(*shape, fan_in): |
| w = torch.randn(*shape, device=device, dtype=torch.float32, generator=g) / (fan_in ** 0.5) |
| return _quantise(w, dt) |
| |
| ones = lambda: torch.ones(d, device=device, dtype=torch.bfloat16) |
| W = {"embed": rnd(cfg["vocab"], d, fan_in=d), "final_norm": ones(), "layers": []} |
| for _ in range(cfg["layers"]): |
| W["layers"].append(dict( |
| in_norm=ones(), post_norm=ones(), |
| q=rnd(n_q * hd, d, fan_in=d), k=rnd(n_kv * hd, d, fan_in=d), |
| v=rnd(n_kv * hd, d, fan_in=d), o=rnd(d, n_q * hd, fan_in=n_q * hd), |
| gate=rnd(ffn, d, fan_in=d), up=rnd(ffn, d, fan_in=d), down=rnd(d, ffn, fan_in=ffn))) |
| return W |
| |
| |
| def make_kv(cfg, batch, prefill_len, max_seq, seed=0, device="cuda"): |
| """KV cache already holding `prefill_len` committed tokens.""" |
| g = torch.Generator(device=device).manual_seed(seed + 777) |
| kv = [] |
| for _ in range(cfg["layers"]): |
| k = torch.zeros(batch, cfg["n_kv"], max_seq, cfg["hd"], device=device, dtype=torch.bfloat16) |
| v = torch.zeros_like(k) |
| k[:, :, :prefill_len] = torch.randn(batch, cfg["n_kv"], prefill_len, cfg["hd"], device=device, |
| dtype=torch.float32, generator=g).to(torch.bfloat16) * 0.5 |
| v[:, :, :prefill_len] = torch.randn(batch, cfg["n_kv"], prefill_len, cfg["hd"], device=device, |
| dtype=torch.float32, generator=g).to(torch.bfloat16) * 0.5 |
| kv.append((k, v)) |
| return kv |
| |
| |
| def make_step_args(cfg, batch, base_pos, seed, n): |
| """(tokens, tree_mask, pos_ids, pos) per step. |
| |
| A random tree over `tree` nodes: node 0 is the root (the last accepted token), node i > 0 picks a |
| uniformly random parent among 0..i-1. `tree_mask[i, j]` is True iff j is an ancestor of i or j == i; |
| `pos_ids[i]` is `depth(i)`, the RoPE offset relative to `pos`.""" |
| g = torch.Generator(device="cuda").manual_seed(seed) |
| T = cfg["tree"] |
| out = [] |
| for i in range(n): |
| tok = torch.randint(0, cfg["vocab"], (batch, T), device="cuda", generator=g) |
| r = torch.rand(T, device="cuda", generator=g) |
| mask = torch.zeros(T, T, dtype=torch.bool, device="cuda") |
| depth = torch.zeros(T, dtype=torch.int64, device="cuda") |
| parent = [0] * T |
| for j in range(1, T): |
| parent[j] = int(r[j] * j) # uniform over 0..j-1 |
| for j in range(T): |
| mask[j, j] = True |
| p, dep = parent[j], 0 |
| u = j |
| while u != 0: |
| u = parent[u] |
| mask[j, u] = True |
| dep += 1 |
| depth[j] = dep |
| out.append((tok, mask, depth, base_pos + i * T)) |
| return out |
| |
| |
| def build_model(weights, kv_cache, cfg, max_seq_len): |
| """UNTIMED setup. Returns whatever handle you like; the grader only passes it back to verify_step.""" |
| cos, sin = _rope_cache(cfg, max_seq_len, weights["final_norm"].device) |
| W = {"embed": _deq(weights["embed"]), "final_norm": weights["final_norm"], |
| "layers": [{k: (v if k.endswith("norm") else _deq(v)) for k, v in L.items()} |
| for L in weights["layers"]]} |
| return {"W": W, "kv": kv_cache, "cfg": cfg, "cos": cos, "sin": sin} |
| |
| |
| @torch.no_grad() |
| def verify_step(handle, tokens, tree_mask, depth, pos): |
| """Verify a whole draft tree in one forward pass. Appends all `tree` nodes at pos .. pos+tree-1. |
| |
| tokens: (B, tree) int64 node tokens, node 0 is the root |
| tree_mask: (tree, tree) bool tree_mask[i, j] -> node i attends to node j |
| depth: (tree,) int64 RoPE offset of each node relative to `pos` |
| pos: int absolute position of node 0 |
| returns: (B, tree, vocab) logits, one row per node |
| """ |
| W, kv, cfg = handle["W"], handle["kv"], handle["cfg"] |
| cos, sin = handle["cos"], handle["sin"] |
| B, T = tokens.shape |
| n_q, n_kv, hd = cfg["n_q"], cfg["n_kv"], cfg["hd"] |
| rep = n_q // n_kv |
| |
| # every node sees the whole committed cache [0, pos), plus the tree mask over the new nodes |
| full = torch.ones(T, pos, dtype=torch.bool, device=tokens.device) |
| mask = torch.cat([full, tree_mask], dim=1) # (T, pos + T) |
| |
| x = W["embed"][tokens] # (B, T, d) |
| for li, L in enumerate(W["layers"]): |
| h = _rms_norm(x, L["in_norm"], cfg["eps"]) |
| q = (h @ L["q"].T).view(B, T, n_q, hd).transpose(1, 2) |
| k = (h @ L["k"].T).view(B, T, n_kv, hd).transpose(1, 2) |
| v = (h @ L["v"].T).view(B, T, n_kv, hd).transpose(1, 2) |
| q = _rope_at(q, cos, sin, pos + depth) |
| k = _rope_at(k, cos, sin, pos + depth) |
| kc, vc = kv[li] |
| kc[:, :, pos:pos + T] = k |
| vc[:, :, pos:pos + T] = v |
| kk = kc[:, :, :pos + T].repeat_interleave(rep, dim=1) |
| vv = vc[:, :, :pos + T].repeat_interleave(rep, dim=1) |
| att = F.scaled_dot_product_attention(q, kk, vv, attn_mask=mask) |
| x = x + (att.transpose(1, 2).reshape(B, T, n_q * hd) @ L["o"].T) |
| h = _rms_norm(x, L["post_norm"], cfg["eps"]) |
| x = x + ((F.silu(h @ L["gate"].T) * (h @ L["up"].T)) @ L["down"].T) |
| x = _rms_norm(x, W["final_norm"], cfg["eps"]) |
| return x @ W["embed"].T # (B, T, vocab), tied lm_head |
| ''' |
|
|
| MODEL_SRC = HELPERS_CORE + QUANT_FP8 + BODY |
|
|
