tools/mega_factory/specs/megakernel_spec_decode_verify.py

"""megakernel-spec-decode-verify — whole-model verification of a speculative DRAFT TREE, fused."""
import pathlib, sys
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent))
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1] / "models"))
from spec import MegaSpec
from _common import CORRECTNESS_MD, PRECISION_MD, perf_md
import spec_verify

# MEASURED over 8 steps and 2 seeds: E = 0.033 (worst of an all-fp32 twin and a
# bf16-GEMM/fp32-residual twin), cheapest feature-drop D = 0.27 (a causal triangle instead
# of the tree mask). 6.5e-2 is 2.0x E and 4.1x below D. The old 5e-2 was only 1.5x E.
TOL = 6.5e-2
CFG = dict(layers=16, d=2048, ffn=8192, n_q=32, n_kv=8, hd=64, vocab=128256,
           eps=1e-5, theta=500000.0, wdtype="bf16", tree=8, tokens_per_step=8)

SPEC = MegaSpec(
    name="megakernel-spec-decode-verify",
    unfused_kernels=660,
    title="Write a whole-model speculative-verification megakernel (8-node draft tree)",
    blurb=("Verify a speculative draft TREE in one fused forward pass: 8 candidate nodes, each "
           "attending to the full committed KV cache plus exactly its own ancestors, each carrying the "
           "RoPE position of its depth so siblings share a position. The tree mask is 8x8 of data "
           "handed to you per call -- not a causal triangle, not decomposable, and sitting next to a "
           "2.5 GB weight stream."),
    keywords=["mle", "kernel-generation", "megakernel", "persistent-kernel", "speculative-decoding",
              "tree-attention", "eagle", "medusa", "low-latency"],
    cfg=CFG, model_src=spec_verify.MODEL_SRC,
    batch=1, prefill_len=2048, max_seq=2560, decode_steps=32,
    tol=TOL,
    bytes_per_step=2_546_600_000,
    reward_metric="verified-positions/s", reward_work=8,
    entry_step="verify_step",
    step_sig="handle, tokens, tree_mask, depth, pos",
    step_doc=("Verify a whole draft tree in one pass; append all `tree` nodes at pos .. pos+tree-1."
              "\n\n    tokens    : (B, tree) int64      node tokens, node 0 is the root"
              "\n    tree_mask : (tree, tree) bool     tree_mask[i, j] -> node i attends to node j"
              "\n    depth     : (tree,) int64         RoPE offset of each node relative to pos"
              "\n    pos       : int                   absolute position of node 0"
              "\n    returns   : (B, tree, vocab) logits, one row per node\n    "),
    step_ret="logits",
    spec_md="""## The computation

A speculative decoder proposes a **tree** of candidate continuations, not a chain. Node 0 is the last
accepted token; every other node has a parent among the earlier nodes, so the 8 nodes cover several
branching futures at once. Verifying them is one forward pass of the full model:

```
x = embed[tokens]                                  # (B, 8, d)
for each layer:
    h     = rmsnorm(x, in_norm)
    q,k,v = h @ Wq.T, h @ Wk.T, h @ Wv.T           # q: 32 heads, k/v: 8 heads (GQA, rep = 4)
    q,k   = rope(q, pos + depth), rope(k, pos + depth)     # per-NODE position, not per-slot
    kv_cache[layer].k[:, :, pos:pos+8] = k         # all 8 nodes appended
    kv_cache[layer].v[:, :, pos:pos+8] = v
    mask  = [ ones(8, pos) | tree_mask ]           # full history, then the tree among the new nodes
    a     = softmax(masked(q @ K[:pos+8].T / sqrt(hd))) @ V[:pos+8]
    x     = x + a_flat @ Wo.T
    h     = rmsnorm(x, post_norm)
    x     = x + (silu(h @ Wgate.T) * (h @ Wup.T)) @ Wdown.T
logits = rmsnorm(x, final_norm) @ embed.T          # (B, 8, vocab), tied lm_head
```

`/app/reference.py` implements exactly this, unfused, in eager torch.

Three things follow from the tree that do not follow from a chunk:

* **`tree_mask` is arbitrary data.** `tree_mask[i, j]` is true iff `j` is an ancestor of `i` or `j == i`.
  It is not a triangle, it is not banded, and it changes every call. You cannot bake it into a loop
  bound; you have to consult it.
* **Siblings share a RoPE position.** `depth[i]` is the node's depth in the tree, so two children of
  the same parent both get position `pos + depth`. RoPE is a per-node gather, not an affine function of
  the slot index.
* **All 8 nodes go into the cache** at slots `pos .. pos+7`, including nodes that will be rejected. A
  real scheduler compacts the accepted path afterwards; that compaction is not part of this task.

### What is deliberately NOT graded

Acceptance -- deciding which drafted tokens survive -- is an argmax over near-tied logits. Two correct
implementations of this model disagree about it routinely (this family measured top-1 agreement between
correct implementations at 0.79-0.92). The kernel problem is the masked forward pass, and that is what
is graded: all `8 x vocab` logits, by relative error.""",
    contract_md="""```python
def build_model(weights, kv_cache, cfg, max_seq_len) -> handle              # UNTIMED
def verify_step(handle, tokens, tree_mask, depth, pos) -> logits            # TIMED
def teardown(handle)                                                        # OPTIONAL
```

`build_model` is handed all four arguments below. `verify_step` is handed the handle you returned, plus
`tokens`, `tree_mask`, `depth` and `pos`.

| arg | shape | dtype | meaning |
|-----|-------|-------|---------|
| `weights` | `dict` | `bfloat16` throughout | keys: `embed`, `final_norm`, `layers` (a `list` of 16 dicts) |
| `weights["embed"]` | `(vocab, d)` = `(128256, 2048)` | `bfloat16` | token embedding table; also the **tied** LM head, used as `embed.T` |
| `weights["final_norm"]` | `(d,)` | `bfloat16` | RMSNorm gain before the LM head |
| `weights["layers"][i]` | 9 tensors | `bfloat16` | `in_norm (d,)`, `post_norm (d,)`, `q (n_q*hd, d)`, `k (n_kv*hd, d)`, `v (n_kv*hd, d)`, `o (d, n_q*hd)`, `gate (ffn, d)`, `up (ffn, d)`, `down (d, ffn)` -- row-major, applied as `h @ W.T` |
| `kv_cache` | `list` of 16 `(k, v)` pairs | `bfloat16` | each tensor `(B, n_kv, max_seq_len, hd)`; slots `[0, 2048)` hold the committed prefix, the rest are zero |
| `cfg` | `dict` | python `int` / `float` / `str` | `layers, d, ffn, n_q, n_kv, hd, vocab, eps, theta, wdtype, tree` (`tree` = 8) |
| `max_seq_len` | scalar | python `int` | `2560` -- the allocated time capacity of every cache, exactly `kv_cache[i][0].shape[2]`. `pos + tree <= max_seq_len` always holds, so a RoPE table of this length covers the whole run |
| `tokens` | `(B, tree)` = `(1, 8)` | `int64`, on the GPU | the 8 node tokens; node 0 is the root |
| `tree_mask` | `(tree, tree)` = `(8, 8)` | `bool`, on the GPU | `tree_mask[i, j]` is True iff node `i` attends to node `j`. Lower-triangular in *index* order but not otherwise structured |
| `depth` | `(tree,)` = `(8,)` | `int64`, on the GPU | `depth[i]` is node `i`'s depth in the tree; its RoPE position is `pos + depth[i]`, so siblings share a position |
| `pos` | scalar | python `int` | absolute position of node 0; the tree occupies cache slots `pos .. pos+7`, and `pos` advances by 8 per call |

**Return** -- `verify_step` returns a **single tensor** `logits` of shape `(B, tree, vocab)` =
`(1, 8, 128256)`, one row per node **in node-index order**, **bf16 or fp32, both accepted** (the grader
compares in fp32). `build_model` returns an opaque handle of any type; the grader never inspects it and
only passes it back to `verify_step`.

`weights`, `cfg`, `tokens`, `tree_mask` and `depth` are **read-only**. `kv_cache` is the one thing you
must update **in place**: all 8 nodes' K and V go into slots `pos .. pos+7`, because the next call
attends over them.

`tree_mask` and `depth` are **regenerated every call** from a seed you do not control, so nothing about
the tree shape can be precomputed in `build_model`. Successive calls advance `pos` by 8.

Every node attends to the **entire** committed prefix `[0, pos)` unconditionally; the mask only governs
the 8 new columns.

`build_model` is untimed: repack weights, pre-transpose, allocate scratch, launch a persistent kernel,
build an instruction schedule -- whatever you need.""",
    correctness_md=CORRECTNESS_MD.format(tol=TOL).replace("(B, vocab)", "(B, 8, vocab)") + """

All 8 rows are compared in one Frobenius norm, so a kernel that handles the root correctly and gets the
mask wrong for the deeper nodes fails immediately. Measured: dropping the tree mask entirely -- letting
every node see every other node -- gives **0.46**; substituting a causal triangle for the DAG gives
**0.27**; giving the nodes chain positions instead of `pos + depth` gives **0.57**. The gate is at
6.5e-2 and a correct kernel measures 0.033 -- see the Precision section.""",
    precision_md=PRECISION_MD + """

Masked positions must be `-inf` **before** the softmax max is taken, not zeroed afterwards. With only 8
new columns against thousands of unmasked ones the difference is small in magnitude and completely
wrong in the rows where it matters.

**Where the tolerance comes from (measured, not guessed).** `tol` is `6.5e-2`. Measured on the graded
fixtures (batch 1, committed cache 2048+, 8 consecutive trees, 2 weight/tree seeds):

| implementation | worst relative error |
|---|---|
| all-fp32 twin: residual, GEMMs and the masked softmax in fp32 | 2.9e-2 |
| **bf16 GEMMs + fp32 residual, hand-rolled masked softmax** | **3.3e-2** |
| *(the gate)* | *6.5e-2* |
| **a causal triangle over the 8 nodes instead of the ancestor DAG** | **1.8e-1 - 2.7e-1** |
| no mask over the 8 nodes at all | 4.6e-1 |
| chain RoPE positions (`pos + i`) instead of `pos + depth(i)` | 5.7e-1 |
| the tree is never appended to the cache | 2.9e-1 - 1.07 |

So **E = 3.3e-2**, **tol = 6.5e-2 = 2.0x E**, and the closest wrong implementation -- a causal
triangle, which is what you get if you reach for an off-the-shelf causal kernel -- is **4.1x** the
tolerance. That is below this benchmark's 10x target and it cannot be widened by moving the gate: at
8 tree nodes against a 2048-token committed cache, the new columns are 0.4% of the attention, so even
a completely wrong mask over them only moves the logits so far. Note it is still caught at every one
of the 8 compared steps. This is an arithmetic gate; bf16 and fp32 residual streams both pass.""",
    perf_md=perf_md(
        floor_us=531, eager_us=9250, graph_us=3200, toks=8, unit="positions/s",
        lead="""This is still the **bandwidth** regime, and that is exactly why speculative decoding
works. Verifying 8 positions costs the same 2.47 GB of weight traffic as verifying 1 -- the arithmetic
goes up 8x (to a still-trivial 12 GFLOP) while the bytes barely move. Per call: 2.47 GB of weights,
76 MB of KV, and an 8x8 mask.""",
        extra="""
* **The 8 nodes are free; do not serialise them.** The whole point is that one weight stream serves all
  8 rows. A kernel that loops over nodes, or that is really 8 GEMVs sharing a launch, reads `Wgate`
  eight times and performs exactly like a batch-1 decode.
* **The mask costs nothing if you keep it in registers.** It is 64 bits. Load it once per call, not
  once per layer and certainly not once per head.
* **Two attention regimes in one kernel.** Columns `[0, pos)` are unmasked and enormous; columns
  `[pos, pos+8)` are masked and tiny. Stream the bulk with a flash-style online softmax and handle the
  8-column tail as a separate, register-resident epilogue.
* **Never expand GQA.** 32 query heads over 8 KV heads: four query heads share one KV load.
* **The LM head runs 8 times over one 525 MB matrix.** Read it once, compute 8 dot products per tile."""),
    regime_md=("**Regime**: batch 1, **8 draft-tree nodes per call**, 16 layers, `d`=2048, ffn=8192, 32 "
               "query / 8 KV heads, head_dim 64, vocab 128256, tied LM head. The cache arrives holding "
               "2048 tokens and grows by 8 per call. ~2.55 GB per call puts the floor near 531 us -- "
               "for **eight** positions, which is the whole economic argument for speculative decoding. "
               "Reward is verified positions per second."),
).validate()