File size: 7,374 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 | """Qwen3-MoE-shaped decoder: GQA attention + a top-k routed sparse MLP.
Every layer stores `n_experts` expert MLPs but reads only `top_k` of them per token, so the model holds
~5.4 B parameters while touching ~1.2 B per decode step. That gap is the point: the megakernel has to
discover its weight addresses at run time instead of streaming a static sequence of matrices.
WHY THE DISPATCH PLAN IS AN INPUT
---------------------------------
The *set* of experts is given to `decode_step` as a plan tensor; the *gating weights* are still computed
by a real router GEMV over the layer's hidden state. That split is deliberate and it is a measured
decision, not a simplification for convenience.
`argmax`-based expert selection cannot be graded. Two correct implementations of this model differ in
the hidden state by ~1e-2 (bf16 vs fp32 residual), the router logits inherit that difference, and the
top-k membership then flips discretely. Measured end-to-end relative error between the shipped bf16
reference and an equally-correct fp32 implementation, purely from routing flips:
flat random router (sigma 1) relerr 1.27
peaked router (sigma 3) relerr 0.19
peaked router (sigma 5) relerr 0.31
against ~0.03 for the same model with a dense MLP. There is no tolerance that both accepts an honest
fp32 kernel and rejects "only use half the experts". Selection is therefore exact integer data --
which is also what an expert-parallel serving stack actually hands its expert kernels, since dispatch
is planned before the expert GEMMs are launched.
"""
from model import HELPERS
BODY = r'''
def make_weights(cfg, seed=0, device="cuda"):
"""Deterministic 1/sqrt(fan_in)-scaled weights. Experts are STACKED: one (E, ...) tensor per
projection per layer, which is how a serving stack lays them out for a grouped GEMM."""
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"]
E, dt = cfg["n_experts"], cfg["wdtype"]
def rnd(*shape, fan_in, dtype=None):
w = torch.randn(*shape, device=device, dtype=torch.float32, generator=g) / (fan_in ** 0.5)
return _quantise(w, dtype or 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),
# the router stays bf16: it is (E, d), it is read in full every step, and it is tiny.
router=rnd(E, d, fan_in=d, dtype="bf16"),
gate=rnd(E, ffn, d, fan_in=d), up=rnd(E, ffn, d, fan_in=d),
down=rnd(E, 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` tokens. Decode starts at pos = prefill_len."""
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):
"""(token_ids, plan, pos) per step.
`plan` is (B, layers, top_k) int32: for every sequence and every layer, the DISTINCT expert ids
this token is dispatched to. It is the routing decision, delivered as data."""
g = torch.Generator(device="cuda").manual_seed(seed)
E, L, K = cfg["n_experts"], cfg["layers"], cfg["top_k"]
out = []
for i in range(n):
tok = torch.randint(0, cfg["vocab"], (batch,), device="cuda", generator=g)
# distinct experts per (sequence, layer): argsort of a random key, take the first K
key = torch.rand(batch, L, E, device="cuda", generator=g)
plan = key.argsort(dim=-1)[:, :, :K].to(torch.int32).contiguous()
out.append((tok, plan, base_pos + i))
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 decode_step."""
cos, sin = _rope_cache(cfg, max_seq_len, weights["final_norm"].device)
keep = ("in_norm", "post_norm", "router")
W = {"embed": _deq(weights["embed"]), "final_norm": weights["final_norm"],
"layers": [{k: (v if k in keep 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 decode_step(handle, token_ids, plan, pos):
"""One decode step for every sequence in the batch. Appends this position's K/V into the cache.
token_ids: (B,) int64 pos: int, the absolute position being written
plan: (B, layers, top_k) int32, the experts this token is dispatched to
returns: (B, vocab) logits
"""
W, kv, cfg = handle["W"], handle["kv"], handle["cfg"]
cos, sin = handle["cos"], handle["sin"]
B = token_ids.shape[0]
n_q, n_kv, hd, top_k = cfg["n_q"], cfg["n_kv"], cfg["hd"], cfg["top_k"]
rep = n_q // n_kv
x = W["embed"][token_ids]
for li, L in enumerate(W["layers"]):
h = _rms_norm(x, L["in_norm"], cfg["eps"])
q = (h @ L["q"].T).view(B, n_q, 1, hd)
k = (h @ L["k"].T).view(B, n_kv, 1, hd)
v = (h @ L["v"].T).view(B, n_kv, 1, hd)
q = _apply_rope(q, cos, sin, pos)
k = _apply_rope(k, cos, sin, pos)
kc, vc = kv[li]
kc[:, :, pos:pos + 1] = k
vc[:, :, pos:pos + 1] = v
kk = kc[:, :, :pos + 1].repeat_interleave(rep, dim=1)
vv = vc[:, :, :pos + 1].repeat_interleave(rep, dim=1)
att = F.scaled_dot_product_attention(q, kk, vv)
x = x + (att.reshape(B, n_q * hd) @ L["o"].T)
# ---- routed sparse MLP -------------------------------------------------------------------
h = _rms_norm(x, L["post_norm"], cfg["eps"])
idx = plan[:, li].long() # (B, top_k) expert ids
rl = (h.float() @ L["router"].T.float()) # (B, E) router logits, fp32
gw = torch.softmax(torch.gather(rl, 1, idx), dim=-1) # softmax over the DISPATCHED experts
y = torch.zeros_like(x, dtype=torch.float32)
for b in range(B):
for j in range(top_k):
e = int(idx[b, j])
hb = h[b:b + 1]
g_e = F.silu(hb @ L["gate"][e].T) * (hb @ L["up"][e].T)
y[b:b + 1] += gw[b, j] * (g_e @ L["down"][e].T).float()
x = x + y.to(x.dtype)
x = _rms_norm(x, W["final_norm"], cfg["eps"])
return x @ W["embed"].T # tied lm_head
'''
MODEL_SRC = HELPERS + BODY
|