Download spark/decode.py from SparkCodeAI/Spark-2.0-code: direct link, hf CLI and curl.
- Browser
- Download file 14.9 kB
-
https://huggingface.co/SparkCodeAI/Spark-2.0-code/resolve/6f9d714aeaea4579edacc10086dce0136773ce1f/spark/decode.py
- Command line
-
hf download hf://SparkCodeAI/Spark-2.0-code@6f9d714aeaea4579edacc10086dce0136773ce1f/spark/decode.py
-
curl -L -o decode.py https://huggingface.co/SparkCodeAI/Spark-2.0-code/resolve/6f9d714aeaea4579edacc10086dce0136773ce1f/spark/decode.py
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))) | |
| 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 | |
| # --------------------------------------------------------------------------- # | |
| # Потоковая генерация поверх графа | |
| # --------------------------------------------------------------------------- # | |
| 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 | |