File size: 14,945 Bytes
8620460
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
"""
Пошаговое декодирование с кэшем состояний + 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