Spark-2.0-code / spark /model.py
SparkCodeAI's picture
Add Spark 2.0-code model
5f847d0 verified
Raw History Blame Contribute Delete
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
# --------------------------------------------------------------------------- #
# Конфигурация
# --------------------------------------------------------------------------- #
@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},
]