""" Пошаговое декодирование с кэшем состояний + 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