File size: 4,530 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 | """One (or a few) complete transformer decoder layers, taking a hidden state in and out.
This is the megakernel problem with the whole-model scaffolding removed: no embedding, no LM head,
no 16-layer schedule to amortise anything over. Just RMSNorm -> QKV -> RoPE -> KV append -> GQA
attention -> output projection -> residual -> RMSNorm -> SwiGLU MLP -> residual, which is about 40
fusable operations, and it must come out of one launch.
`src(build_name, step_name)` renders the reference with task-specific entry-point names.
"""
from model import HELPERS_CORE
TEMPLATE = r'''
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"]
def rnd(*shape, fan_in):
return (torch.randn(*shape, device=device, dtype=torch.float32, generator=g)
/ (fan_in ** 0.5)).to(torch.bfloat16)
ones = lambda: torch.ones(d, device=device, dtype=torch.bfloat16)
layers = []
for _ in range(cfg["layers"]):
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 {"layers": layers}
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):
"""(x, pos) per call -- a fresh (B, d) bf16 hidden state and the position being appended."""
g = torch.Generator(device="cuda").manual_seed(seed)
return [(torch.randn(batch, cfg["d"], device="cuda", dtype=torch.float32,
generator=g).to(torch.bfloat16), base_pos + i) for i in range(n)]
def {BUILD}(weights, kv_cache, cfg, max_seq_len):
"""UNTIMED setup. Repack weights, build RoPE tables, allocate scratch, launch a daemon, ..."""
dev = weights["layers"][0]["q"].device
cos, sin = _rope_cache(cfg, max_seq_len, dev)
return {"W": weights["layers"], "kv": kv_cache, "cfg": cfg, "cos": cos, "sin": sin}
@torch.no_grad()
def {STEP}(handle, x, pos):
"""Run the layer(s) on one hidden state; append this position's K/V into the cache.
x : (B, d) bf16 the incoming residual stream
pos : int the absolute position being written
returns : (B, d) fp32 the residual stream after the layer(s)
"""
W, kv, cfg = handle["W"], handle["kv"], handle["cfg"]
cos, sin = handle["cos"], handle["sin"]
B = x.shape[0]
n_q, n_kv, hd = cfg["n_q"], cfg["n_kv"], cfg["hd"]
rep = n_q // n_kv
for li, L in enumerate(W):
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)
h = _rms_norm(x, L["post_norm"], cfg["eps"])
x = x + ((F.silu(h @ L["gate"].T) * (h @ L["up"].T)) @ L["down"].T)
return x.float()
'''
def src(build_name, step_name):
return HELPERS_CORE + TEMPLATE.replace("{BUILD}", build_name).replace("{STEP}", step_name)
|