""" Гибридная языковая модель в стиле Qwen3.5 / Qwen3-Next. Схема одного блока (как в обычном трансформере): x -> [норма] -> [смеситель токенов] -> +x -> [норма] -> [FFN] -> +x "Смеситель токенов" бывает двух видов, они чередуются 3:1 - Gated DeltaNet (линейное внимание, быстрое, 3 слоя из 4) - Gated Attention (полное внимание, медленное но точное, каждый 4-й слой) """ import math from dataclasses import dataclass, asdict import torch import torch.nn as nn import torch.nn.functional as F from fla.ops.gated_delta_rule import chunk_gated_delta_rule from fla.ops.attn.parallel import parallel_attn # --------------------------------------------------------------------------- # # Конфигурация # --------------------------------------------------------------------------- # @dataclass class ModelConfig: vocab_size: int = 16384 d_model: int = 640 n_layers: int = 20 max_seq_len: int = 4096 # --- слои полного внимания --- attn_every: int = 4 # каждый 4-й слой — полное внимание n_heads: int = 8 # голов запроса n_kv_heads: int = 2 # голов ключа/значения (GQA) head_dim: int = 128 # развязан с d_model, как у Qwen3 rope_theta: float = 50000.0 # НЕ 1e6: у нас контекст 4096, не 40k # --- слои Gated DeltaNet --- dn_k_heads: int = 4 dn_v_heads: int = 8 dn_head_dim: int = 128 dn_conv_size: int = 4 # --- FFN --- ffn_hidden: int = 1536 norm_eps: float = 1e-6 tie_embeddings: bool = True init_std: float = 0.02 # пересчитывать активации в backward вместо хранения (экономит память, # стоит ~30% лишних вычислений в прямом проходе) grad_checkpoint: bool = False def is_attn_layer(self, i: int) -> bool: """Каждый attn_every-й слой (последний в группе) — полное внимание.""" return (i + 1) % self.attn_every == 0 def to_dict(self): return asdict(self) # --------------------------------------------------------------------------- # # Базовые кирпичики # --------------------------------------------------------------------------- # class RMSNorm(nn.Module): """Нормализация. Дешевле LayerNorm, стандарт во всех современных моделях.""" def __init__(self, dim: int, eps: float = 1e-6): super().__init__() self.eps = eps self.weight = nn.Parameter(torch.ones(dim)) def forward(self, x): dtype = x.dtype x = x.float() x = x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps) return (x * self.weight.float()).to(dtype) class SwiGLU(nn.Module): """FFN. Три матрицы вместо двух: одна работает воротами для другой.""" def __init__(self, d_model: int, hidden: int): super().__init__() self.gate = nn.Linear(d_model, hidden, bias=False) self.up = nn.Linear(d_model, hidden, bias=False) self.down = nn.Linear(hidden, d_model, bias=False) def forward(self, x): return self.down(F.silu(self.gate(x)) * self.up(x)) def build_rope_cache(seq_len: int, head_dim: int, theta: float, device, dtype): """Предпосчитанные синусы/косинусы для RoPE.""" inv_freq = 1.0 / (theta ** (torch.arange(0, head_dim, 2, device=device).float() / head_dim)) pos = torch.arange(seq_len, device=device).float() freqs = torch.outer(pos, inv_freq) # [T, head_dim/2] return freqs.cos().to(dtype), freqs.sin().to(dtype) def apply_rope(x, cos, sin): """x: [B, T, H, D]. Поворачивает пары каналов на угол, зависящий от позиции.""" x1, x2 = x.float().chunk(2, dim=-1) cos = cos[None, :, None, :] sin = sin[None, :, None, :] out = torch.cat([x1 * cos - x2 * sin, x1 * sin + x2 * cos], dim=-1) return out.to(x.dtype) # --------------------------------------------------------------------------- # # Смеситель 1: полное внимание с воротами (каждый 4-й слой) # --------------------------------------------------------------------------- # class GatedAttention(nn.Module): """ Обычное причинное внимание + два отличия Qwen3: * QK-Norm — нормализация Q и K, страхует обучение от разъезжания * выходные ворота — сигмоида решает, сколько внимания пропустить дальше """ def __init__(self, cfg: ModelConfig): super().__init__() self.cfg = cfg self.nh, self.nkv, self.hd = cfg.n_heads, cfg.n_kv_heads, cfg.head_dim q_dim, kv_dim = self.nh * self.hd, self.nkv * self.hd self.q_proj = nn.Linear(cfg.d_model, q_dim, bias=False) self.k_proj = nn.Linear(cfg.d_model, kv_dim, bias=False) self.v_proj = nn.Linear(cfg.d_model, kv_dim, bias=False) self.o_proj = nn.Linear(q_dim, cfg.d_model, bias=False) self.g_proj = nn.Linear(cfg.d_model, q_dim, bias=False) # ворота self.q_norm = RMSNorm(self.hd, cfg.norm_eps) # QK-Norm self.k_norm = RMSNorm(self.hd, cfg.norm_eps) def forward(self, x, cos, sin, docs=None): B, T, _ = x.shape q = self.q_proj(x).view(B, T, self.nh, self.hd) k = self.k_proj(x).view(B, T, self.nkv, self.hd) v = self.v_proj(x).view(B, T, self.nkv, self.hd) q, k = self.q_norm(q), self.k_norm(k) q, k = apply_rope(q, cos, sin), apply_rope(k, cos, sin) if docs is not None: # маска документов: каждый токен видит только свой документ. # Кернел fla сам пропускает блоки чужих документов o = parallel_attn(q, k, v, cu_seqlens=docs[0]) o = o.reshape(B, T, self.nh * self.hd) o = o * torch.sigmoid(self.g_proj(x)) return self.o_proj(o) # SDPA ждёт [B, H, T, D] q, k, v = (t.transpose(1, 2) for t in (q, k, v)) # kv-головы размножаем явно, а не через enable_gqa=True: в сборке # PyTorch под Windows нет FlashAttention, и с enable_gqa SDPA падает # на математический путь с полной матрицей TxT. С явным повтором # включается memory-efficient кернел -- замерено 8.3 мс против 16.1 # на слой (fwd+bwd, T=4096), и сотни МБ памяти на слой не хранятся if self.nkv != self.nh: k = k.repeat_interleave(self.nh // self.nkv, dim=1) v = v.repeat_interleave(self.nh // self.nkv, dim=1) o = F.scaled_dot_product_attention(q, k, v, is_causal=True) o = o.transpose(1, 2).reshape(B, T, self.nh * self.hd) o = o * torch.sigmoid(self.g_proj(x)) # ворота return self.o_proj(o) # --------------------------------------------------------------------------- # # Смеситель 2: Gated DeltaNet (линейное внимание, 3 слоя из 4) # --------------------------------------------------------------------------- # class GatedDeltaNet(nn.Module): """ Линейное внимание из Qwen3-Next. Вместо матрицы TxT держит в голове компактное состояние фиксированного размера и обновляет его по дельта-правилу: на каждом токене чуть-чуть забывает старое (затухание g) и дописывает новое (сила записи beta). Отсюда O(T) вместо O(T^2). Короткая причинная свёртка перед этим даёт слою локальный контекст, который чистой рекуррентности даётся тяжело. """ def __init__(self, cfg: ModelConfig): super().__init__() self.cfg = cfg self.hk, self.hv, self.hd = cfg.dn_k_heads, cfg.dn_v_heads, cfg.dn_head_dim self.rep = self.hv // self.hk # во сколько раз v-голов больше k_dim, v_dim = self.hk * self.hd, self.hv * self.hd self.k_dim, self.v_dim = k_dim, v_dim self.q_proj = nn.Linear(cfg.d_model, k_dim, bias=False) self.k_proj = nn.Linear(cfg.d_model, k_dim, bias=False) self.v_proj = nn.Linear(cfg.d_model, v_dim, bias=False) self.b_proj = nn.Linear(cfg.d_model, self.hv, bias=False) # beta: сила записи self.a_proj = nn.Linear(cfg.d_model, self.hv, bias=False) # g: скорость забывания self.g_proj = nn.Linear(cfg.d_model, v_dim, bias=False) # выходные ворота self.o_proj = nn.Linear(v_dim, cfg.d_model, bias=False) # depthwise причинная свёртка по q|k|v conv_dim = k_dim * 2 + v_dim self.conv_dim = conv_dim self.conv = nn.Conv1d(conv_dim, conv_dim, kernel_size=cfg.dn_conv_size, groups=conv_dim, padding=cfg.dn_conv_size - 1, bias=False) # обучаемые параметры затухания (инициализация как в Mamba2/Qwen3-Next) self.A_log = nn.Parameter(torch.log(torch.empty(self.hv).uniform_(1, 16))) dt = torch.exp(torch.rand(self.hv) * (math.log(0.1) - math.log(0.001)) + math.log(0.001)) dt = dt.clamp(min=1e-4) self.dt_bias = nn.Parameter(dt + torch.log(-torch.expm1(-dt))) self.o_norm = RMSNorm(self.hd, cfg.norm_eps) def forward(self, x, cos=None, sin=None, docs=None): B, T, _ = x.shape qkv = torch.cat([self.q_proj(x), self.k_proj(x), self.v_proj(x)], dim=-1) if docs is None: qkv = self.conv(qkv.transpose(1, 2))[..., :T].transpose(1, 2) # причинная обрезка else: # та же свёртка, но сдвиги, залезающие в предыдущий документ, # обнуляются. Иначе первые 3 токена документа видят хвост чужого, # а внимание разносит эту утечку по всему документу w = self.conv.weight[:, 0, :].to(qkv.dtype) # [C, K] K = w.shape[1] pos = docs[2] # позиция внутри документа out = qkv * w[:, K - 1] for j in range(1, K): sh = F.pad(qkv, (0, 0, j, 0))[:, :T] out = out + sh * (pos >= j)[None, :, None].to(qkv.dtype) * w[:, K - 1 - j] qkv = out qkv = F.silu(qkv) q, k, v = qkv.split([self.k_dim, self.k_dim, self.v_dim], dim=-1) q = q.view(B, T, self.hk, self.hd).repeat_interleave(self.rep, dim=2) k = k.view(B, T, self.hk, self.hd).repeat_interleave(self.rep, dim=2) v = v.view(B, T, self.hv, self.hd) beta = torch.sigmoid(self.b_proj(x).float()) g = -self.A_log.float().exp() * F.softplus(self.a_proj(x).float() + self.dt_bias.float()) o, _ = chunk_gated_delta_rule( q=q, k=k, v=v, g=g, beta=beta.to(v.dtype), use_qk_l2norm_in_kernel=True, # L2-норма Q/K обязательна для устойчивости # с маской документов состояние обнуляется на границе документа cu_seqlens=None if docs is None else docs[0], cu_seqlens_cpu=None if docs is None else docs[1], ) o = self.o_norm(o).reshape(B, T, self.v_dim) o = o * torch.sigmoid(self.g_proj(x)) return self.o_proj(o) def make_doc_mask(x_cpu: torch.Tensor, eos_id: int = 0, device="cuda"): """ Границы документов для маски: x_cpu -- батч [B, T] на процессоре. Батч склеивается в одну строку [1, B*T]; документ начинается после каждого EOS и на стыке строк батча. Возвращает (cu_seqlens на карте, то же на процессоре, позиция каждого токена внутри своего документа). Копия на процессоре избавляет fla от синхронизации с картой. """ B, T = x_cpu.shape N = B * T flat = x_cpu.reshape(-1) starts = (flat == eos_id).nonzero().flatten() + 1 # после EOS starts = torch.cat([starts, torch.arange(0, N + 1, T)]) # стыки строк cu = torch.unique(starts.clamp(max=N)).to(torch.int32) lens = cu[1:] - cu[:-1] pos = torch.arange(N, dtype=torch.int32) - torch.repeat_interleave(cu[:-1], lens) return (cu.to(device, non_blocking=True), cu, pos.to(device, non_blocking=True)) # --------------------------------------------------------------------------- # # Блок и модель целиком # --------------------------------------------------------------------------- # class Block(nn.Module): def __init__(self, cfg: ModelConfig, layer_idx: int): super().__init__() self.is_attn = cfg.is_attn_layer(layer_idx) self.norm1 = RMSNorm(cfg.d_model, cfg.norm_eps) self.mixer = GatedAttention(cfg) if self.is_attn else GatedDeltaNet(cfg) self.norm2 = RMSNorm(cfg.d_model, cfg.norm_eps) self.ffn = SwiGLU(cfg.d_model, cfg.ffn_hidden) def forward(self, x, cos, sin, docs=None): x = x + self.mixer(self.norm1(x), cos, sin, docs) x = x + self.ffn(self.norm2(x)) return x class HybridLM(nn.Module): def __init__(self, cfg: ModelConfig): super().__init__() self.cfg = cfg self.embed = nn.Embedding(cfg.vocab_size, cfg.d_model) self.blocks = nn.ModuleList([Block(cfg, i) for i in range(cfg.n_layers)]) self.norm_f = RMSNorm(cfg.d_model, cfg.norm_eps) self.lm_head = nn.Linear(cfg.d_model, cfg.vocab_size, bias=False) if cfg.tie_embeddings: self.lm_head.weight = self.embed.weight self.apply(self._init) # затухающая инициализация выходных проекций: чем глубже, тем тише вклад for name, p in self.named_parameters(): if name.endswith("o_proj.weight") or name.endswith("down.weight"): nn.init.normal_(p, std=cfg.init_std / math.sqrt(2 * cfg.n_layers)) self._rope = {} def _init(self, m): if isinstance(m, nn.Linear): nn.init.normal_(m.weight, std=self.cfg.init_std) elif isinstance(m, nn.Embedding): nn.init.normal_(m.weight, std=self.cfg.init_std) elif isinstance(m, nn.Conv1d): nn.init.normal_(m.weight, std=self.cfg.init_std) def _rope_for(self, T, device, dtype): key = (T, device, dtype) if key not in self._rope: self._rope[key] = build_rope_cache( T, self.cfg.head_dim, self.cfg.rope_theta, device, dtype) return self._rope[key] def forward(self, idx, targets=None, docs=None): """ docs -- маска документов для обучения, из make_doc_mask(): тогда idx должен быть [1, N] (батч склеен в одну строку), а внимание и состояние DeltaNet не переходят через границы документов. """ B, T = idx.shape x = self.embed(idx) cos, sin = self._rope_for(T, idx.device, torch.float32) use_ckpt = self.cfg.grad_checkpoint and self.training for blk in self.blocks: if use_ckpt: x = torch.utils.checkpoint.checkpoint(blk, x, cos, sin, docs, use_reentrant=False) else: x = blk(x, cos, sin, docs) x = self.norm_f(x) logits = self.lm_head(x) loss = None if targets is not None: loss = F.cross_entropy( logits.view(-1, logits.size(-1)).float(), targets.reshape(-1), ignore_index=-100, ) return logits, loss # ------------------------------------------------------------------ # def param_counts(self): emb = self.embed.weight.numel() total = sum(p.numel() for p in self.parameters()) if self.cfg.tie_embeddings: non_emb = total - emb else: non_emb = total - emb - self.lm_head.weight.numel() return {"total": total, "embedding": emb, "non_embedding": non_emb} def optim_groups(self, weight_decay: float): """Матрицы штрафуем весовым распадом, векторы (нормы, смещения) — нет.""" decay, no_decay = [], [] for n, p in self.named_parameters(): if not p.requires_grad: continue (decay if p.dim() >= 2 else no_decay).append(p) return [ {"params": decay, "weight_decay": weight_decay}, {"params": no_decay, "weight_decay": 0.0}, ]