SparkCodeAI's picture
Add Spark 2.0-code model
7b4e7cd verified
Raw History Blame Contribute Delete
14.9 kB
"""
Пошаговое декодирование с кэшем состояний + CUDA-граф.
Зачем это нужно. Замер (scripts/13_bench_gen.py) показал странное: один
forward стоит 29 мс и при контексте в 1 токен, и при 1024. Профайлер
объяснил почему -- за forward запускается 1466 отдельных CUDA-ядер, а
считает GPU всего 2.47 мс. То есть 92% времени карта простаивает, ожидая,
пока CPU поставит ей очередную мелкую задачу.
Лечится это CUDA-графом: вся последовательность запусков записывается один
раз и потом воспроизводится одной командой. Но граф требует, чтобы формы
тензоров и адреса памяти не менялись от шага к шагу -- а при генерации без
кэша контекст растёт на каждом токене. Поэтому сначала кэш (он делает вход
всегда равным одному токену), и только потом граф.
Кэш держит:
* для слоёв внимания -- K и V в буфере фиксированного размера MAX_LEN,
заполняемом по индексу; маска отсекает ещё не записанные позиции;
* для слоёв DeltaNet -- состояние дельта-правила [B, H, D, D] и хвост
входа для причинной свёртки (conv_size-1 токенов).
model.py не тронут: здесь только чтение его весов.
"""
import torch
import torch.nn.functional as F
from fla.ops.gated_delta_rule import (chunk_gated_delta_rule,
fused_recurrent_gated_delta_rule)
from .model import apply_rope, build_rope_cache
class Cache:
"""Все состояния модели для одной генерации. Формы фиксированы навсегда."""
def __init__(self, model, batch=1, max_len=1024, device="cuda"):
cfg = model.cfg
self.cfg, self.max_len, self.B = cfg, max_len, batch
dt = next(model.parameters()).dtype
self.attn, self.dn = {}, {}
for i, blk in enumerate(model.blocks):
if blk.is_attn:
self.attn[i] = {
"k": torch.zeros(batch, cfg.n_kv_heads, max_len, cfg.head_dim,
device=device, dtype=dt),
"v": torch.zeros(batch, cfg.n_kv_heads, max_len, cfg.head_dim,
device=device, dtype=dt),
}
else:
m = blk.mixer
self.dn[i] = {
"state": torch.zeros(batch, m.hv, m.hd, m.hd,
device=device, dtype=torch.float32),
"conv": torch.zeros(batch, m.conv_dim, cfg.dn_conv_size - 1,
device=device, dtype=dt),
}
# позиция живёт в видеопамяти: граф читает её как данные, а не как
# число, вшитое в момент записи
self.pos = torch.zeros((), device=device, dtype=torch.long)
self.ar = torch.arange(max_len, device=device)
self.cos, self.sin = build_rope_cache(max_len, cfg.head_dim,
cfg.rope_theta, device, torch.float32)
def reset(self):
for c in self.attn.values():
c["k"].zero_(); c["v"].zero_()
for c in self.dn.values():
c["state"].zero_(); c["conv"].zero_()
self.pos.zero_()
# --------------------------------------------------------------------------- #
# Один шаг: T = 1
# --------------------------------------------------------------------------- #
def _attn_step(mix, h, cache, i):
B = h.shape[0]
c = cache.attn[i]
q = mix.q_norm(mix.q_proj(h).view(B, 1, mix.nh, mix.hd))
k = mix.k_norm(mix.k_proj(h).view(B, 1, mix.nkv, mix.hd))
v = mix.v_proj(h).view(B, 1, mix.nkv, mix.hd)
cos = cache.cos.index_select(0, cache.pos.view(1))
sin = cache.sin.index_select(0, cache.pos.view(1))
q, k = apply_rope(q, cos, sin), apply_rope(k, cos, sin)
# index_copy_ по тензору-индексу: адрес буфера постоянен, меняется
# только содержимое -- ровно то, что нужно графу
c["k"].index_copy_(2, cache.pos.view(1), k.transpose(1, 2))
c["v"].index_copy_(2, cache.pos.view(1), v.transpose(1, 2))
# смотрим на весь буфер, маской отсекая ещё не заполненный хвост
mask = (cache.ar <= cache.pos).view(1, 1, 1, -1)
o = F.scaled_dot_product_attention(q.transpose(1, 2), c["k"], c["v"],
attn_mask=mask, enable_gqa=True)
o = o.transpose(1, 2).reshape(B, 1, mix.nh * mix.hd)
return mix.o_proj(o * torch.sigmoid(mix.g_proj(h)))
def _dn_step(mix, h, cache, i):
B = h.shape[0]
c = cache.dn[i]
qkv = torch.cat([mix.q_proj(h), mix.k_proj(h), mix.v_proj(h)], dim=-1)
# причинная свёртка вручную: хвост прошлых входов + текущий вход
win = torch.cat([c["conv"], qkv.transpose(1, 2)], dim=-1)
conv = F.conv1d(win, mix.conv.weight, groups=mix.conv_dim)
c["conv"].copy_(win[..., 1:])
qkv = F.silu(conv).transpose(1, 2)
q, k, v = qkv.split([mix.k_dim, mix.k_dim, mix.v_dim], dim=-1)
q = q.view(B, 1, mix.hk, mix.hd).repeat_interleave(mix.rep, dim=2)
k = k.view(B, 1, mix.hk, mix.hd).repeat_interleave(mix.rep, dim=2)
v = v.view(B, 1, mix.hv, mix.hd)
beta = torch.sigmoid(mix.b_proj(h).float())
g = -mix.A_log.float().exp() * F.softplus(mix.a_proj(h).float()
+ mix.dt_bias.float())
o, new_state = fused_recurrent_gated_delta_rule(
q=q, k=k, v=v, g=g, beta=beta.to(v.dtype),
initial_state=c["state"], output_final_state=True,
use_qk_l2norm_in_kernel=True)
c["state"].copy_(new_state)
o = mix.o_norm(o).reshape(B, 1, mix.v_dim)
return mix.o_proj(o * torch.sigmoid(mix.g_proj(h)))
def step(model, cache, tok):
"""tok: [B, 1] -> логиты [B, vocab]. Позицию двигает вызывающий."""
x = model.embed(tok)
for i, blk in enumerate(model.blocks):
h = blk.norm1(x)
mix = _attn_step(blk.mixer, h, cache, i) if blk.is_attn \
else _dn_step(blk.mixer, h, cache, i)
x = x + mix
x = x + blk.ffn(blk.norm2(x))
return model.lm_head(model.norm_f(x))[:, -1]
# --------------------------------------------------------------------------- #
# Префилл: весь промпт разом, чтобы не гнать его по одному токену
# --------------------------------------------------------------------------- #
def _attn_prefill(mix, h, cache, i, start):
B, T, _ = h.shape
c = cache.attn[i]
q = mix.q_norm(mix.q_proj(h).view(B, T, mix.nh, mix.hd))
k = mix.k_norm(mix.k_proj(h).view(B, T, mix.nkv, mix.hd))
v = mix.v_proj(h).view(B, T, mix.nkv, mix.hd)
cos, sin = cache.cos[start:start + T], cache.sin[start:start + T]
q, k = apply_rope(q, cos, sin), apply_rope(k, cos, sin)
c["k"][:, :, start:start + T] = k.transpose(1, 2)
c["v"][:, :, start:start + T] = v.transpose(1, 2)
o = F.scaled_dot_product_attention(q.transpose(1, 2),
c["k"][:, :, :start + T],
c["v"][:, :, :start + T],
is_causal=True, enable_gqa=True)
o = o.transpose(1, 2).reshape(B, T, mix.nh * mix.hd)
return mix.o_proj(o * torch.sigmoid(mix.g_proj(h)))
def _dn_prefill(mix, h, cache, i):
B, T, _ = h.shape
c = cache.dn[i]
qkv = torch.cat([mix.q_proj(h), mix.k_proj(h), mix.v_proj(h)], dim=-1)
xt = qkv.transpose(1, 2)
conv = mix.conv(xt)[..., :T]
# хвост входа переносим в кэш: следующему шагу нужен именно он
tail = xt[..., -(mix.cfg.dn_conv_size - 1):]
c["conv"][..., -tail.shape[-1]:].copy_(tail)
qkv = F.silu(conv).transpose(1, 2)
q, k, v = qkv.split([mix.k_dim, mix.k_dim, mix.v_dim], dim=-1)
q = q.view(B, T, mix.hk, mix.hd).repeat_interleave(mix.rep, dim=2)
k = k.view(B, T, mix.hk, mix.hd).repeat_interleave(mix.rep, dim=2)
v = v.view(B, T, mix.hv, mix.hd)
beta = torch.sigmoid(mix.b_proj(h).float())
g = -mix.A_log.float().exp() * F.softplus(mix.a_proj(h).float()
+ mix.dt_bias.float())
o, new_state = chunk_gated_delta_rule(
q=q, k=k, v=v, g=g, beta=beta.to(v.dtype),
initial_state=c["state"], output_final_state=True,
use_qk_l2norm_in_kernel=True)
c["state"].copy_(new_state)
o = mix.o_norm(o).reshape(B, T, mix.v_dim)
return mix.o_proj(o * torch.sigmoid(mix.g_proj(h)))
@torch.no_grad()
def prefill(model, cache, ids):
"""ids: [B, T] -> логиты последней позиции [B, vocab]."""
start = int(cache.pos)
x = model.embed(ids)
for i, blk in enumerate(model.blocks):
h = blk.norm1(x)
mix = _attn_prefill(blk.mixer, h, cache, i, start) if blk.is_attn \
else _dn_prefill(blk.mixer, h, cache, i)
x = x + mix
x = x + blk.ffn(blk.norm2(x))
cache.pos.fill_(start + ids.shape[1] - 1) # позиция ПОСЛЕДНЕГО токена
return model.lm_head(model.norm_f(x))[:, -1]
# --------------------------------------------------------------------------- #
# CUDA-граф вокруг шага
# --------------------------------------------------------------------------- #
class GraphedStep:
"""
Записывает один шаг декодирования в CUDA-граф и потом воспроизводит его.
Граф работает только с теми буферами, что были при записи, поэтому вход
и выход -- постоянные тензоры: пишем в них, запускаем, читаем из них.
"""
def __init__(self, model, cache, warmup=3):
self.model, self.cache = model, cache
self.tok = torch.zeros(cache.B, 1, device="cuda", dtype=torch.long)
# прогрев на отдельном потоке: без него в граф попадут ленивые
# инициализации Triton-ядер, и запись сломается
s = torch.cuda.Stream()
s.wait_stream(torch.cuda.current_stream())
with torch.cuda.stream(s), torch.no_grad():
for _ in range(warmup):
step(model, cache, self.tok)
torch.cuda.current_stream().wait_stream(s)
self.graph = torch.cuda.CUDAGraph()
with torch.no_grad(), torch.cuda.graph(self.graph):
self.logits = step(model, cache, self.tok)
def __call__(self, tok):
self.tok.copy_(tok)
self.graph.replay()
return self.logits
# --------------------------------------------------------------------------- #
# Потоковая генерация поверх графа
# --------------------------------------------------------------------------- #
@torch.no_grad()
def generate(model, cache, graphed, prompt_ids, max_new, temp=0.4, top_p=0.95,
eos_id=0, rep_penalty=1.0, rep_window=256, structural=None,
on_token=None):
"""
Генерирует токены, вызывая on_token(id) по мере готовности.
Семплирование и штраф за повтор считаются ВНЕ графа: внутрь их не
затащить -- там нельзя ветвиться по значению и менять формы. Поэтому
они написаны так, чтобы стоить доли миллисекунды: при 4 мс на шаг
даже одна лишняя аллокация на токен заметна.
Штраф за повтор держит счётчики в векторе на [vocab] и правит их
инкрементально. Наивный вариант (собрать историю в тензор и позвать
torch.unique на каждом шаге) стоил около трети времени шага.
Возвращает (список токенов, причина остановки).
"""
cache.reset()
ids = prompt_ids[:, -(cache.max_len - max_new - 1):] # запас под ответ
logits = prefill(model, cache, ids)
dev = ids.device
hist = ids[0].tolist()
counts = torch.zeros(model.cfg.vocab_size, device=dev)
if rep_penalty > 1.0:
for t in hist[-rep_window:]:
counts[t] += 1
if structural is not None:
counts[structural] = 0 # отступы и переносы не штрафуем
out, why = [], "упёрся в лимит"
for _ in range(max_new):
lg = logits[0].float()
if rep_penalty > 1.0:
factor = rep_penalty ** counts # для counts=0 это ровно 1
lg = torch.where(lg > 0, lg / factor, lg * factor)
if temp <= 0:
nxt = int(lg.argmax())
else:
p = F.softmax(lg / temp, dim=-1)
if top_p < 1.0:
sp, si = torch.sort(p, descending=True)
sp[sp.cumsum(0) - sp > top_p] = 0
sp /= sp.sum()
nxt = int(si[torch.multinomial(sp, 1)])
else:
nxt = int(torch.multinomial(p, 1))
if nxt == eos_id:
why = "закончил сам (EOS)"
break
out.append(nxt); hist.append(nxt)
if rep_penalty > 1.0:
if structural is None or not bool(structural[nxt]):
counts[nxt] += 1
if len(hist) > rep_window: # токен вышел из окна
old = hist[-rep_window - 1]
if structural is None or not bool(structural[old]):
counts[old] -= 1
if on_token is not None:
on_token(nxt)
if int(cache.pos) + 1 >= cache.max_len - 1:
why = "кончился буфер контекста"
break
cache.pos += 1
logits = graphed(torch.tensor([[nxt]], device=dev))
return out, why