Download spark/model.py from SparkCodeAI/Spark-2.0-code-base: direct link, hf CLI and curl.
- Browser
- Download file 18 kB
-
https://huggingface.co/SparkCodeAI/Spark-2.0-code-base/resolve/main/spark/model.py
- Command line
-
hf download hf://SparkCodeAI/Spark-2.0-code-base/spark/model.py
-
curl -L -o model.py https://huggingface.co/SparkCodeAI/Spark-2.0-code-base/resolve/main/spark/model.py
18 kB
| """ | |
| Гибридная языковая модель в стиле 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 | |
| # --------------------------------------------------------------------------- # | |
| # Конфигурация | |
| # --------------------------------------------------------------------------- # | |
| 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}, | |
| ] | |