File size: 8,503 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 144 145 146 147 148 149 150 151 152 153 | """Spec for `comba-forward` — Comba (2025), a delta-rule variant with a decoupled read key."""
import pathlib
import sys
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
from spec import TaskSpec
SPEC = TaskSpec(
name="comba-forward",
title="Write a fast Comba forward kernel",
blurb=("Comba is a 2025 linear-attention layer: the gated delta rule with a DECOUPLED read key — the "
"state correction is read with a separate vector p while the write still uses k, so the "
"within-chunk transform is no longer the symmetric one DeltaNet's WY trick relies on."),
keywords=["mle", "kernel-generation", "comba", "linear-attention", "delta-rule", "gpu"],
module="comba.py",
func="comba_forward",
signature="comba_forward(q, k, v, p, beta, g, scale=None)",
returns_doc="""Comba forward.
Args:
q, k, p: (B, T, H, K) bfloat16 — queries, write-keys, read-keys.
v: (B, T, H, V) bfloat16 — values.
beta: (B, T, H) bfloat16 — delta-rule step size in (0, 1).
g: (B, T, H) float32 — per-step log-decay (<= 0); exp(g) is the gate.
scale: float or None — query scale; None means K ** -0.5.
Returns:
o: (B, T, H, V), bfloat16 or float32 — must match /app/reference.py numerically.""",
reference_imports="import torch",
reference_src='''
def comba_forward(q, k, v, p, beta, g, scale=None):
"""Comba forward, written as the plain step-by-step recurrence in fp32.
Correct and simple — it is the numerical SPECIFICATION, not a performance target.
"""
q, k, v, p, beta, g = [x.transpose(1, 2).contiguous().to(torch.float32) for x in (q, k, v, p, beta, g)]
B, H, T, K = k.shape
V = v.shape[-1]
if scale is None:
scale = K ** -0.5
q = q * scale
o = torch.zeros(B, H, T, V, device=q.device, dtype=torch.float32)
h = torch.zeros(B, H, K, V, device=q.device, dtype=torch.float32)
for i in range(T):
h = h * g[:, :, i].exp()[..., None, None] # scalar forget gate
v_i = v[:, :, i] - (h * p[:, :, i][..., None]).sum(-2) # read the state with p
v_i = v_i * beta[:, :, i][..., None] # delta-rule step size
h = h + k[:, :, i].unsqueeze(-1) * v_i.unsqueeze(-2) # write the state with k
o[:, :, i] = torch.einsum('bhd,bhdm->bhm', q[:, :, i], h) # readout
return o.transpose(1, 2).contiguous()
''',
make_inputs_src='''
def _mk(B, T, H, K, V, seed):
import torch.nn.functional as F
gen = torch.Generator(device="cuda").manual_seed(seed)
q = torch.randn(B, T, H, K, device="cuda", dtype=torch.bfloat16, generator=gen)
k = F.normalize(torch.randn(B, T, H, K, device="cuda", generator=gen), dim=-1).to(torch.bfloat16)
v = torch.randn(B, T, H, V, device="cuda", dtype=torch.bfloat16, generator=gen)
p = F.normalize(torch.randn(B, T, H, K, device="cuda", generator=gen), dim=-1).to(torch.bfloat16)
beta = torch.rand(B, T, H, device="cuda", generator=gen).sigmoid().to(torch.bfloat16)
g = (F.logsigmoid(torch.randn(B, T, H, device="cuda", generator=gen)) / 4.0).to(torch.float32)
return q, k, v, p, beta, g
''',
flops_src='''
def canonical_work(B, T, H, K, V, C=64):
"""FLOPs attributed to one Comba forward, from the SHAPE ALONE (chunked form, chunk length C)."""
return B * H * T * (2 * C * (2 * K + V) + 6 * K * V)
''',
metric="TFLOP/s",
compare="tensor",
tol=2e-2,
shape_names=("B", "T", "H", "K", "V"),
grader_shapes=[(2, 8192, 32, 128, 128), (4, 4096, 32, 128, 128), (2, 16384, 32, 128, 128),
(4, 8192, 16, 128, 128), (2, 8192, 32, 64, 128)],
measure_shapes=[(3, 6144, 32, 128, 128), (2, 12288, 24, 128, 128), (4, 8192, 32, 128, 128),
(2, 8192, 16, 128, 128), (4, 4096, 16, 64, 128)],
measure_quick_shapes=[(1, 2048, 16, 128, 128), (2, 2048, 8, 128, 128), (1, 4096, 16, 64, 128)],
correct_shapes=[(1, 256, 4, 128, 128), (2, 512, 8, 64, 128), (1, 512, 6, 128, 128),
(2, 128, 4, 64, 64)],
spec_md="""Per batch `b` and head `h`, with a recurrent state `S` of shape `(K, V)` initialised to zero,
for `t = 0 … T-1`:
```
S = exp(g_t) * S # scalar forget gate on the whole state
u_t = beta_t * ( v_t - S^T p_t ) # correction, read with p (NOT with k)
S = S + k_t u_t^T # rank-1 write, using k
o_t = S^T (scale * q_t) # readout
```
`scale` defaults to `K ** -0.5`.
The single thing that distinguishes Comba from a gated delta rule is that the state is **read with `p` and
written with `k`**. In DeltaNet those are the same vector, which is what makes its within-chunk transform
`(I - tril(beta k kᵀ))⁻¹` symmetric-ish and lets the WY/UT trick apply directly. Here the corresponding
chunk matrix is built from `p` against `k` and is **not** symmetric, so the standard transform has to be
re-derived rather than reused.
`/app/reference.py` writes the recurrence out step by step in fp32. That is the exact specification; it is
deliberately simple rather than fast, and its runtime has no bearing on your score.""",
contract_md="""| arg | shape | dtype | meaning |
|-----|-------|-------|---------|
| `q` | `(B, T, H, K)` | `bfloat16` | queries |
| `k` | `(B, T, H, K)` | `bfloat16` | **write** keys (L2-normalised along `K`) |
| `v` | `(B, T, H, V)` | `bfloat16` | values |
| `p` | `(B, T, H, K)` | `bfloat16` | **read** keys (L2-normalised along `K`) |
| `beta` | `(B, T, H)` | `bfloat16` | delta-rule step size, in `(0, 1)` |
| `g` | `(B, T, H)` | `float32` | per-step log-decay, `<= 0` (`exp(g)` is the gate) |
| `scale` | scalar | `float` or `None` | query scale; `None` means `K ** -0.5` |
**Return** `o` of shape `(B, T, H, V)`, dtype `bfloat16` or `float32`.
Note the argument order is `(q, k, v, p, beta, g)` — `p` comes after `v`, and `g` is last.
All tensors are CUDA and contiguous. `T` is a multiple of 64. No initial/final state, no variable-length
packing, no GQA. Treat all inputs as read-only.""",
regime_md="""**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): `B` in 2–4,
`T` in 4096–16384, `H` in 16–32, `K` in {64, 128}, `V` = 128. These are large enough that kernel time, not
launch overhead, dominates. Write a **general** kernel — one tuned to a single shape will not score well.""",
correctness_md="""Your output must match the reference (evaluated in fp32 as a stable ground truth)
within **relative Frobenius error `2e-2`** at every graded shape, including the timed ones.""",
perf_md="""The reference walks the sequence one position at a time, so essentially all of its time is
launch overhead on tiny operations — but note that beating it is trivial and **not** the point: your score is
absolute throughput, so the question is how close to the machine's roofline you get.
The real work is the chunked reformulation. Within a chunk of length `C`, the `C` rank-1 writes can be
linearised into a single transform so the chunk becomes dense matmuls, and only a small state has to be
carried sequentially between chunks. Because the read key `p` differs from the write key `k`, the chunk
matrix here is `tril(beta ⊙ (p kᵀ))` rather than the symmetric DeltaNet form — derive the inverse (a
forward substitution) and fuse it into the same kernel rather than materialising it. Keep the `(K, V)` state
in registers/shared memory across chunks, use bf16 tensor cores for the chunk matmuls with fp32
accumulation, and fold the scalar decay into the matmul operands instead of materialising `exp(g)` tensors.""",
precision_md="""All inputs and outputs are **bfloat16** — this is an LLM kernel and that is the precision
it runs at in production. Your kernel is expected to do its matmuls on **bf16 tensor cores with fp32
accumulation**. **fp8** is acceptable anywhere you can still hold the tolerance.
For calibration, a correct bf16 fused delta-rule-family kernel lands around **4e-3** relative error against
the fp32 recurrence — roughly 5x inside the `2e-2` gate — while a wrong algorithm misses by 0.2 or more. The
state carry is the sensitive part: accumulate it in fp32, since errors there compound along the sequence and
will grow with `T`.
Do **not** infer from the reference that fp32 compute is wanted. It runs in fp32 purely to be a stable
numerical *specification*.""",
).validate()
|