"""Training-time re-implementation of the Qwen3.5/3.8 multi-token-prediction (MTP) head. The serving engine (vLLM v0.31.0, ``qwen3_5_mtp.py``) builds the head from the *target's* config, so a replacement head must keep the baseline tensor layout exactly: mtp.pre_fc_norm_embedding / mtp.pre_fc_norm_hidden RMSNorm (1 + w) mtp.fc Linear(2H -> H) mtp.layers.0 one gated full-attention block mtp.norm RMSNorm (1 + w) This module mirrors that computation in plain PyTorch (parameter names are identical to the checkpoint names without the ``mtp.`` prefix) and adds what training needs: * ``unroll`` - the K-step recursive drafting pass, vectorised over every position of a sequence with the same key/value visibility the engine's draft KV cache has; * ``e4m3_round`` - FP8 (E4M3) rounding with a straight-through estimator for QAT; * ``equalize_`` - an exact, function-preserving re-scaling that moves weights into the range where E4M3 has relative (not absolute) precision. """ from __future__ import annotations import json import math import struct from dataclasses import dataclass from pathlib import Path import torch import torch.nn as nn import torch.nn.functional as F # Tensors stored in FP8 in the compact variant (the big matrices); the rest stay bf16. FP8_TENSORS = ( "layers.0.mlp.gate_proj.weight", "layers.0.mlp.up_proj.weight", "layers.0.mlp.down_proj.weight", "layers.0.self_attn.o_proj.weight", "layers.0.self_attn.k_proj.weight", "layers.0.self_attn.v_proj.weight", ) @dataclass class HeadConfig: hidden: int = 5120 inter: int = 17408 heads: int = 24 kv_heads: int = 4 head_dim: int = 256 rot_dim: int = 64 theta: float = 1e7 eps: float = 1e-6 @classmethod def from_target(cls, cfg: dict) -> "HeadConfig": t = cfg.get("text_config", cfg) rp = t.get("rope_parameters") or {} prf = rp.get("partial_rotary_factor", t.get("partial_rotary_factor", 1.0)) hd = t.get("head_dim") or t["hidden_size"] // t["num_attention_heads"] return cls(hidden=t["hidden_size"], inter=t["intermediate_size"], heads=t["num_attention_heads"], kv_heads=t.get("num_key_value_heads", t["num_attention_heads"]), head_dim=hd, rot_dim=int(hd * prf), theta=float(rp.get("rope_theta", t.get("rope_theta", 10000.0))), eps=float(t.get("rms_norm_eps", 1e-6))) # --------------------------------------------------------------------------- FP8 (E4M3) def e4m3_round(w: torch.Tensor) -> torch.Tensor: """Round-to-nearest-even onto the finite FP8 E4M3 grid (saturating at 448).""" a = w.detach().abs().float().clamp(max=448.0) _, ex = torch.frexp(a) # a = m * 2**ex, m in [0.5, 1) e = (ex - 1).clamp(min=-6).float() # binade; subnormals share e = -6 step = torch.exp2(e - 3.0) # 3 mantissa bits q = (torch.round(a / step) * step).clamp(max=448.0) return (torch.sign(w.detach().float()) * q).to(w.dtype) def e4m3_encode(w: torch.Tensor, chunk: int = 1 << 24) -> torch.Tensor: """uint8 bit patterns (sign | 4-bit exponent, bias 7 | 3-bit mantissa) of on-grid values. Works in chunks so the int64 temporaries stay small (host memory is limited).""" flat = w.detach().reshape(-1) out = torch.empty(flat.numel(), dtype=torch.uint8, device=flat.device) for s in range(0, flat.numel(), chunk): out[s:s + chunk] = _e4m3_encode(flat[s:s + chunk]) return out.view(w.shape) def _e4m3_encode(w: torch.Tensor) -> torch.Tensor: q = e4m3_round(w.float()) a = q.abs() _, ex = torch.frexp(a) e = (ex - 1).clamp(min=-6) normal = a >= 2.0 ** -6 mant_n = torch.round((a / torch.exp2(e.float()) - 1.0) * 8.0).long() mant_s = torch.round(a * 2.0 ** 9).long() bits = torch.where(normal, ((e.long() + 7) << 3) | mant_n, mant_s) bits = bits | ((q < 0).long() << 7) return bits.to(torch.uint8) def e4m3_decode(b: torch.Tensor) -> torch.Tensor: b = b.long() sign = torch.where((b >> 7) > 0, -1.0, 1.0) ef, m = (b >> 3) & 0xF, (b & 0x7).float() val = torch.where(ef > 0, (1.0 + m / 8.0) * torch.exp2(ef.float() - 7.0), m * 2.0 ** -9) return sign * val class QLinear(nn.Linear): """Bias-free linear layer; ``fq=True`` fake-quantises the weight to E4M3 (STE). ``add_lora(r)`` freezes the weight and learns a rank-r update B @ A instead (LoRA, Hu et al. 2021); ``merge_lora()`` folds it back into the weight, so exported files keep the engine's dense layout.""" def __init__(self, i: int, o: int): super().__init__(i, o, bias=False) self.fq = False self.lora_a = self.lora_b = None def add_lora(self, r: int): o, i = self.weight.shape dev = self.weight.device self.weight.requires_grad_(False) self.lora_a = nn.Parameter(torch.randn(r, i, device=dev) / math.sqrt(i)) self.lora_b = nn.Parameter(torch.zeros(o, r, device=dev)) @torch.no_grad() def merge_lora(self): if self.lora_a is not None: self.weight.copy_(self.dense_weight()) self.lora_a = self.lora_b = None self.weight.requires_grad_(True) def dense_weight(self) -> torch.Tensor: w = self.weight return w if self.lora_a is None else w + (self.lora_b @ self.lora_a).to(w.dtype) def qweight(self) -> torch.Tensor: w = self.dense_weight() return w + (e4m3_round(w) - w).detach() if self.fq else w def forward(self, x: torch.Tensor) -> torch.Tensor: return F.linear(x, self.qweight().to(x.dtype)) class GRMSNorm(nn.Module): """RMSNorm with a (1 + w) gain, computed in fp32 (the engine's GemmaRMSNorm).""" def __init__(self, dim: int, eps: float): super().__init__() self.weight = nn.Parameter(torch.zeros(dim)) self.eps = eps def forward(self, x: torch.Tensor) -> torch.Tensor: xf = x.float() xf = xf * torch.rsqrt(xf.pow(2).mean(-1, keepdim=True) + self.eps) return (xf * (1.0 + self.weight.float())).to(x.dtype) def rope(x: torch.Tensor, pos: torch.Tensor, rot_dim: int, theta: float) -> torch.Tensor: """NeoX-style partial rotary embedding. x: [B, N, heads, head_dim], pos: [B, N].""" half = rot_dim // 2 inv = 1.0 / (theta ** (torch.arange(0, rot_dim, 2, device=x.device, dtype=torch.float32) / rot_dim)) ang = pos.float()[..., None] * inv cos, sin = ang.cos()[:, :, None, :], ang.sin()[:, :, None, :] xf = x.float() x1, x2 = xf[..., :half], xf[..., half:rot_dim] out = torch.cat([x1 * cos - x2 * sin, x2 * cos + x1 * sin, xf[..., rot_dim:]], -1) return out.to(x.dtype) class Attention(nn.Module): def __init__(self, c: HeadConfig): super().__init__() self.c = c self.q_proj = QLinear(c.hidden, c.heads * c.head_dim * 2) # per head: [query | gate] self.k_proj = QLinear(c.hidden, c.kv_heads * c.head_dim) self.v_proj = QLinear(c.hidden, c.kv_heads * c.head_dim) self.o_proj = QLinear(c.heads * c.head_dim, c.hidden) self.q_norm = GRMSNorm(c.head_dim, c.eps) self.k_norm = GRMSNorm(c.head_dim, c.eps) def forward(self, x, pos, mem, mask): c = self.c B, N, _ = x.shape qg = self.q_proj(x).view(B, N, c.heads, 2 * c.head_dim) q, gate = qg[..., :c.head_dim], qg[..., c.head_dim:] k = self.k_proj(x).view(B, N, c.kv_heads, c.head_dim) v = self.v_proj(x).view(B, N, c.kv_heads, c.head_dim) q = rope(self.q_norm(q), pos, c.rot_dim, c.theta).transpose(1, 2) k = rope(self.k_norm(k), pos, c.rot_dim, c.theta).transpose(1, 2) v = v.transpose(1, 2) keys = torch.cat([m[0] for m in mem] + [k], 2) vals = torch.cat([m[1] for m in mem] + [v], 2) rep = c.heads // c.kv_heads keys, vals = keys.repeat_interleave(rep, 1), vals.repeat_interleave(rep, 1) o = F.scaled_dot_product_attention(q, keys, vals, attn_mask=mask) o = o.transpose(1, 2) * torch.sigmoid(gate) return self.o_proj(o.reshape(B, N, c.heads * c.head_dim)), (k, v) class MLP(nn.Module): def __init__(self, c: HeadConfig): super().__init__() self.gate_proj = QLinear(c.hidden, c.inter) self.up_proj = QLinear(c.hidden, c.inter) self.down_proj = QLinear(c.inter, c.hidden) def forward(self, x): return self.down_proj(F.silu(self.gate_proj(x)) * self.up_proj(x)) class Layer(nn.Module): def __init__(self, c: HeadConfig): super().__init__() self.self_attn = Attention(c) self.mlp = MLP(c) self.input_layernorm = GRMSNorm(c.hidden, c.eps) self.post_attention_layernorm = GRMSNorm(c.hidden, c.eps) def forward(self, h, pos, mem=(), mask=None): a, kv = self.self_attn(self.input_layernorm(h), pos, list(mem), mask) h = h + a return h + self.mlp(self.post_attention_layernorm(h)), kv class MTPHead(nn.Module): def __init__(self, c: HeadConfig): super().__init__() self.c = c self.pre_fc_norm_embedding = GRMSNorm(c.hidden, c.eps) self.pre_fc_norm_hidden = GRMSNorm(c.hidden, c.eps) self.fc = QLinear(2 * c.hidden, c.hidden) self.layers = nn.ModuleList([Layer(c)]) self.norm = GRMSNorm(c.hidden, c.eps) def step(self, emb, hid, pos, mem=(), mask=None): """One drafting step. emb/hid: [B, N, H]; returns (post-norm hidden, (k, v)).""" x = torch.cat([self.pre_fc_norm_embedding(emb), self.pre_fc_norm_hidden(hid)], -1) h, kv = self.layers[0](self.fc(x), pos, mem, mask) return self.norm(h), kv def set_fake_quant(self, on: bool, names=FP8_TENSORS): mods = dict(self.named_modules()) for n in names: mods[n.rsplit(".", 1)[0]].fq = on def unroll(head: MTPHead, embed, tokens: torch.Tensor, hidden: torch.Tensor, K: int = 3): """Vectorised K-step drafting for every base position of a batch of sequences. tokens [B, T]; hidden [B, T-1, H] = target final hidden states h_0..h_{T-2}. Step k (1-based) at base index i consumes token x_{i+k} and predicts x_{i+1+k}; it sees the "verified" keys/values of positions <= i (step-1 pass, true hidden states), plus the keys/values written by the earlier steps of the same round and its own - exactly what the engine's draft KV cache holds at that moment. Returns a generator of step outputs so the caller can interleave losses (and use correctness of step k-1 to weight step k). """ B, T = tokens.shape N = T - 1 dev = tokens.device base = torch.arange(N, device=dev) pos = base[None].expand(B, N) tri = torch.ones(N, N, dtype=torch.bool, device=dev).tril() eye = torch.eye(N, dtype=torch.bool, device=dev) mem, hid = [], hidden for k in range(1, K + 1): tok_k = tokens[:, (base + k).clamp(max=T - 1)] mask = torch.cat([tri] + [eye] * (k - 1), 1)[None, None] out, kv = head.step(embed(tok_k), hid, pos + (k - 1), mem, mask) mem.append(kv) hid = out yield k, out def walk(correct, P: int, T: int, K: int = 3): """Greedy speculative decoding over per-position correctness flags. correct[k][i] says whether draft step k+1 at base index i matched the target's token. Returns (accepted draft tokens, drafting rounds) for one sequence of T tokens whose first P tokens are the prompt; acceptance length = 1 + accepted / rounds. """ acc = drafts = 0 cur = P while cur <= T - 2: i, n = cur - 1, 0 for k in range(K): if i + 2 + k > T - 1 or not correct[k][i]: break n += 1 drafts += 1 acc += n cur += n + 1 return acc, drafts # --------------------------------------------------------------------------- equalisation @torch.no_grad() def equalize_(head: MTPHead, r: float = 0.25) -> dict: """Exact re-scaling that brings every FP8 tensor to RMS ~= r (function unchanged). Uses the scale symmetries of the block: RMSNorm inputs are scale-free, so the residual stream can be scaled by s (fc, o_proj, down_proj); value/output and up/down projections trade scale; the norm gains absorb a common factor of everything that reads them. """ L = head.layers[0] A, M = L.self_attn, L.mlp rms = lambda w: w.float().pow(2).mean().sqrt().item() g = r / rms(M.gate_proj.weight) gam = rms(M.gate_proj.weight) / rms(M.up_proj.weight) s = r * gam / rms(M.down_proj.weight) beta = s * rms(A.o_proj.weight) / r cc = r / (rms(A.v_proj.weight) * beta) ak = r / rms(A.k_proj.weight) M.gate_proj.weight.mul_(g) M.up_proj.weight.mul_(g * gam) M.down_proj.weight.mul_(s / gam) L.post_attention_layernorm.weight.copy_((1 + L.post_attention_layernorm.weight) / g - 1) A.q_proj.weight.mul_(cc) A.v_proj.weight.mul_(cc * beta) A.o_proj.weight.mul_(s / beta) A.k_proj.weight.mul_(ak) L.input_layernorm.weight.copy_((1 + L.input_layernorm.weight) / cc - 1) head.fc.weight.mul_(s) return dict(g=g, gamma=gam, s=s, beta=beta, c=cc, a_k=ak) # --------------------------------------------------------------------------- checkpoint IO def read_safetensors(path, names=None, prefix=None) -> dict: from safetensors import safe_open out = {} with safe_open(str(path), framework="pt") as f: for n in f.keys(): if (names is None or n in names) and (prefix is None or n.startswith(prefix)): out[n] = f.get_tensor(n) return out def load_target_tensors(target_dir, names) -> dict: """Read named tensors straight from the target's shards (no model instantiation).""" target_dir = Path(target_dir) index = json.loads((target_dir / "model.safetensors.index.json").read_text())["weight_map"] out = {} for shard in sorted({index[n] for n in names}): out.update(read_safetensors(target_dir / shard, names=set(names))) return out def load_mtp_state(src) -> dict: """mtp.* tensors (prefix stripped) from a submission folder or the target folder.""" src = Path(src) if (src / "model.safetensors.index.json").exists(): index = json.loads((src / "model.safetensors.index.json").read_text())["weight_map"] raw = {} for shard in sorted({f for n, f in index.items() if n.startswith("mtp.")}): raw.update(read_safetensors(src / shard, prefix="mtp.")) else: raw = {} for p in sorted(src.glob("*.safetensors")): raw.update(read_safetensors(p, prefix="mtp.")) return {n[4:]: (e4m3_decode(t.view(torch.uint8)) if "float8" in str(t.dtype) else t.float()) for n, t in raw.items()} def build_head(state: dict, cfg: HeadConfig, device="cpu") -> MTPHead: head = MTPHead(cfg) head.load_state_dict(state, strict=True) return head.to(device) def save_safetensors_raw(path, tensors: dict): """Minimal safetensors writer (lets us emit F8_E4M3 without relying on torch float8).""" header, blobs, off = {}, [], 0 for name, (dtype, shape, data) in tensors.items(): header[name] = {"dtype": dtype, "shape": list(shape), "data_offsets": [off, off + len(data)]} blobs.append(data) off += len(data) hj = json.dumps(header, separators=(",", ":")).encode() hj += b" " * ((8 - len(hj) % 8) % 8) with open(path, "wb") as f: f.write(struct.pack(" dict: """Write a kit-format submission folder: config.json, model.safetensors, spec, metadata.""" out_dir = Path(out_dir) out_dir.mkdir(parents=True, exist_ok=True) tensors, nbytes = {}, 0 for name, p in head.state_dict().items(): w = p.detach().float().cpu() if fp8 and name in fp8_names: data = e4m3_encode(w).numpy().tobytes() tensors["mtp." + name] = ("F8_E4M3", w.shape, data) else: data = w.to(torch.bfloat16).view(torch.int16).numpy().tobytes() tensors["mtp." + name] = ("BF16", w.shape, data) nbytes += len(data) save_safetensors_raw(out_dir / "model.safetensors", tensors) (out_dir / "config.json").write_bytes(Path(target_config).read_bytes()) (out_dir / "spec.json").write_text(json.dumps({"method": "mtp"}) + "\n") (out_dir / "metadata.json").write_text(json.dumps(metadata, indent=2) + "\n") return {"weight_bytes": nbytes, "tensors": len(tensors)}