| """Llama-style dense decoder: RMSNorm(pre) + RoPE + GQA + SwiGLU. Plain PyTorch.""" |
| import math |
| from dataclasses import dataclass |
| import torch, torch.nn as nn, torch.nn.functional as F |
|
|
|
|
| @dataclass |
| class ModelConfig: |
| vocab_size: int = 65536 |
| n_layers: int = 28 |
| dim: int = 3072 |
| n_heads: int = 24 |
| n_kv_heads: int = 8 |
| ffn_dim: int = 8192 |
| max_seq_len: int = 4096 |
| rope_theta: float = 500000.0 |
| norm_eps: float = 1e-5 |
| tie_embeddings: bool = False |
|
|
|
|
| PRESETS = { |
| "micro": dict(n_layers=2, dim=64, n_heads=4, n_kv_heads=2, ffn_dim=128), |
| "tiny": dict(n_layers=6, dim=512, n_heads=8, n_kv_heads=4, ffn_dim=1408), |
| "100m": dict(n_layers=12, dim=768, n_heads=12, n_kv_heads=4, ffn_dim=2048), |
| "1b": dict(n_layers=18, dim=2048, n_heads=16, n_kv_heads=8, ffn_dim=5632, tie_embeddings=True), |
| "3b": dict(n_layers=28, dim=3072, n_heads=24, n_kv_heads=8, ffn_dim=8192), |
| } |
|
|
|
|
| def get_config(name, **kw): |
| return ModelConfig(**{**PRESETS[name], **kw}) |
|
|
|
|
| class RMSNorm(nn.Module): |
| def __init__(self, dim, eps): |
| super().__init__(); self.eps = eps; self.weight = nn.Parameter(torch.ones(dim)) |
|
|
| def forward(self, x): |
| xf = x.float() |
| return (xf * torch.rsqrt(xf.pow(2).mean(-1, keepdim=True) + self.eps)).type_as(x) * self.weight |
|
|
|
|
| def precompute_rope(head_dim, seq_len, theta, device=None): |
| inv = 1.0 / (theta ** (torch.arange(0, head_dim, 2, device=device).float() / head_dim)) |
| ang = torch.outer(torch.arange(seq_len, device=device).float(), inv) |
| return torch.cos(ang), torch.sin(ang) |
|
|
|
|
| def apply_rope(x, cos, sin): |
| T = x.shape[1] |
| cos, sin = cos[:T, None, :], sin[:T, None, :] |
| x1, x2 = x.float().chunk(2, dim=-1) |
| return torch.cat([x1 * cos - x2 * sin, x2 * cos + x1 * sin], dim=-1).type_as(x) |
|
|
|
|
| class Attention(nn.Module): |
| def __init__(self, c): |
| super().__init__() |
| self.nh, self.nkv, self.hd = c.n_heads, c.n_kv_heads, c.dim // c.n_heads |
| self.wq = nn.Linear(c.dim, self.nh * self.hd, bias=False) |
| self.wk = nn.Linear(c.dim, self.nkv * self.hd, bias=False) |
| self.wv = nn.Linear(c.dim, self.nkv * self.hd, bias=False) |
| self.wo = nn.Linear(self.nh * self.hd, c.dim, bias=False) |
|
|
| def forward(self, x, cos, sin): |
| B, T, _ = x.shape |
| q = self.wq(x).view(B, T, self.nh, self.hd) |
| k = self.wk(x).view(B, T, self.nkv, self.hd) |
| v = self.wv(x).view(B, T, self.nkv, self.hd) |
| q, k = apply_rope(q, cos, sin), apply_rope(k, cos, sin) |
| q, k, v = (t.transpose(1, 2) for t in (q, k, v)) |
| o = F.scaled_dot_product_attention(q, k, v, is_causal=True, enable_gqa=True) |
| return self.wo(o.transpose(1, 2).reshape(B, T, -1)) |
|
|
|
|
| class FeedForward(nn.Module): |
| def __init__(self, c): |
| super().__init__() |
| self.w1 = nn.Linear(c.dim, c.ffn_dim, bias=False) |
| self.w3 = nn.Linear(c.dim, c.ffn_dim, bias=False) |
| self.w2 = nn.Linear(c.ffn_dim, c.dim, bias=False) |
|
|
| def forward(self, x): |
| return self.w2(F.silu(self.w1(x)) * self.w3(x)) |
|
|
|
|
| class Block(nn.Module): |
| def __init__(self, c): |
| super().__init__() |
| self.attn_norm, self.ffn_norm = RMSNorm(c.dim, c.norm_eps), RMSNorm(c.dim, c.norm_eps) |
| self.attn, self.ffn = Attention(c), FeedForward(c) |
|
|
| def forward(self, x, cos, sin): |
| x = x + self.attn(self.attn_norm(x), cos, sin) |
| return x + self.ffn(self.ffn_norm(x)) |
|
|
|
|
| class Transformer(nn.Module): |
| def __init__(self, c: ModelConfig): |
| super().__init__() |
| self.c = c |
| self.tok = nn.Embedding(c.vocab_size, c.dim) |
| self.blocks = nn.ModuleList(Block(c) for _ in range(c.n_layers)) |
| self.norm = RMSNorm(c.dim, c.norm_eps) |
| self.out = nn.Linear(c.dim, c.vocab_size, bias=False) |
| if c.tie_embeddings: self.out.weight = self.tok.weight |
| self.register_buffer("cos", torch.empty(0), persistent=False) |
| self.register_buffer("sin", torch.empty(0), persistent=False) |
| self.init_weights() |
|
|
| def init_weights(self): |
| c = self.c |
| for m in self.modules(): |
| if isinstance(m, RMSNorm): nn.init.ones_(m.weight) |
| elif isinstance(m, nn.Linear): nn.init.normal_(m.weight, std=0.02) |
| elif isinstance(m, nn.Embedding): nn.init.normal_(m.weight, std=0.02) |
| |
| for b in self.blocks: |
| nn.init.normal_(b.attn.wo.weight, std=0.02 / math.sqrt(2 * c.n_layers)) |
| nn.init.normal_(b.ffn.w2.weight, std=0.02 / math.sqrt(2 * c.n_layers)) |
| self.cos, self.sin = precompute_rope(c.dim // c.n_heads, c.max_seq_len, c.rope_theta) |
|
|
| def forward(self, idx, targets=None): |
| x = self.tok(idx) |
| cos, sin = self.cos.to(x.device), self.sin.to(x.device) |
| for b in self.blocks: x = b(x, cos, sin) |
| logits = self.out(self.norm(x)) |
| if targets is None: return logits |
| return F.cross_entropy(logits.float().view(-1, logits.size(-1)), targets.view(-1)) |
|
|
| def num_params(self): |
| n = sum(p.numel() for p in self.parameters()) |
| return n |
|
|
| def flops_per_token(self, seq_len): |
| c = self.c |
| n_nonemb = self.num_params() - self.tok.weight.numel() * (1 if c.tie_embeddings else 2) + self.out.weight.numel() |
| return 6 * n_nonemb + 12 * c.n_layers * c.dim * seq_len |
|
|
