推理

这一课在哪

37.8 课说过:训练时整句一起算,推理时只能一个一个来。

这一课讲那个「一个一个来」到底有多贵,以及KV 缓存怎么把它救回来。

先看看不优化会怎样

最直白的写法:每生成一个词,就把「已经生成的整句」重新喂进解码器。

ys = torch.tensor([[BOS]]) for _ in range(max_len): # 每步都拿整条序列跑一遍解码器 out = model.decode(ys, enc_out, src) # 但只取最后一个位置的分数——前面那些早就算过了 nxt = model.fc(out[:, -1]).argmax(-1, keepdim=True) ys = torch.cat([ys, nxt], dim=1)

这里在重复做无用功

生成第 5 个词时,解码器把前 4 个位置又算了一遍。

而那 4 个位置的结果,上一步已经算出来了, 而且永远不会变——因为它们是已经确定的历史。

生成 n 个词,就重复算了 1+2+⋯+n=n(n+1)/21+2+\dots+n = n(n+1)/2 次位置。

哪些能存下来

解码器一层里有三种计算,看看哪些是「历史不变」的:

量

对已生成的位置

能存吗

K 键

只由那个位置的输入决定

能

V 值

同上

能

Q 查询

每步都要用新的那个

不用存

关键就一句话

K 和 V 只跟位置本身有关,不会因为后来生成了什么而变化。

所以算过一次就该留着。这就是「KV 缓存」这个名字的来历。

Q 不一样——每一步是一个新的查询,没法复用。

带缓存怎么写

在注意力里加一个 cache 参数:

class MultiHeadAttention(nn.Module): def forward(self, q, k, v, mask=None, cache=None): B, T, _ = q.shape # 无论有没有缓存,新的 Q K V 都要投影出来 Q = self.w_q(q).view(B, T, self.n_heads, self.d_k).transpose(1, 2) K = self.w_k(k).view(B, T, self.n_heads, self.d_k).transpose(1, 2) V = self.w_v(v).view(B, T, self.n_heads, self.d_k).transpose(1, 2) if cache is not None: # 把历史上算过的 K、V 接在前面 if cache["k"] is not None: K = torch.cat([cache["k"], K], dim=2) V = torch.cat([cache["v"], V], dim=2) # 存起来给下一步用 cache["k"], cache["v"] = K, V # 后面照常算 scores = Q @ K.transpose(-2, -1) / math.sqrt(self.d_k) ... return self.w_o(out)

解码循环变成这样:

ys = torch.tensor([[BOS]]) # 每一层一对空缓存 caches = [{"k": None, "v": None} for _ in range(n_layers)] for _ in range(max_len): # 只把新生成的那个词喂进去 x = model.tgt_embed(ys[:, -1:]) * math.sqrt(model.d_model) for i, layer in enumerate(model.decoder): x = layer(x, enc_out, src, cache=caches[i]) nxt = model.fc_out(x[:, -1]).argmax(-1, keepdim=True) ys = torch.cat([ys, nxt], dim=1)

对比

不缓存

缓存

每步喂进去的

整条已生成序列

只有新词

FFN 跑几次

t 个位置

1 个位置

K/V 投影算几次

t 个位置

1 个位置

注意力还是要看几个 K

t 个

t 个(这部分省不掉)

省的是哪一项

记序列长度为 nn、维度 dd、层数 LL:

部分

不缓存

缓存

投影 + FFN

O(n2d2)O(n^2 d^2)

O(nd2)O(n d^2)

注意力打分

O(n3d)O(n^3 d)

O(n2d)O(n^2 d)

两项都少了一个 nn 倍。

投影和 FFN 那项尤其重要——在实际模型里,它们才是计算量大头 (37.3 课算过,FFN 占一层参数的 67%)。

实测

RTX 5060,6 层,d=512d = 512,batch 32:

生成长度

不缓存

缓存

快

16 词

873.4 ms

276.2 ms

3.2×

32 词

596.3 ms

475.9 ms

1.3×

第二行噪声很大,别当结论

GPU 上小规模测时,每次 kernel 启动的固定开销会盖过计算量差异。

所以短序列上有时看不出差距,甚至缓存更慢(多了拼接操作)。

真正该信的是上面那个复杂度分析—— 序列越长、batch 越大、模型越深,差距越明显。

缓存的代价:吃显存

没有免费的午餐。存下来的 K、V 要占显存:

生成长度

KV 缓存占用

64

48.0 MB

256

192.0 MB

(batch 32、8 头、d 512、6 层、fp32)

公式是:

项

说明

2

K 和 V 各一份

B×L×h×n×dkB \times L \times h \times n \times d_k

batch × 层数 × 头数 × 长度 × 每头维度

4 字节

fp32

长度翻倍,显存就翻倍。

这就是长上下文贵的原因

生成 8K 个 token 时,这份缓存能到几个 GB。

推理服务里「同时能服务多少个用户」, 往往不是被模型权重卡住,是被 KV 缓存卡住。

今天很多工程优化(PagedAttention、连续批处理、量化缓存)都是为了压这一块。

框架里怎么用

HuggingFace 的 generate 默认就开着缓存:

from transformers import AutoModelForCausalLM, AutoTokenizer out = model.generate( input_ids, max_new_tokens=100, use_cache=True, # 默认就是 True,一般不用写 )

use_cache=True 就是开 KV 缓存。 关掉它(False)只在少数调试场景有用。

用缓存会改变输出的一个小细节

开启缓存后,模型返回的序列里通常只有新生成的部分, 输入那段要自己 cat 回去。

很多人第一次用 generate 时发现「输出少了开头」, 就是这个原因。

回到我们自己的模型

37.10 课那个实验里,推理是没有用缓存的—— 每步都把整条序列重跑一遍。

因为 BLEU 只关心结果对不对,不关心快不快。 但真上线就必须要缓存。

场景

要不要缓存

训练

不要(本来就是整句并行算)

算 BLEU / 评估

可选,不影响分数

线上生成

必须

超长上下文

必须,但要想办法压显存

这一课留下的三个数

数

值

含义

重复计算

n(n+1)/2n(n+1)/2

不缓存时白算的位置数

复杂度改善

少一个 nn 倍

投影和 FFN 从 O(n2d2)O(n^2d^2) 降到 O(nd2)O(nd^2)

缓存显存

48 MB @ 64,192 MB @ 256

长度翻倍就翻倍

下一课

整章讲完了。最后一课是习题—— 算参数、手推掩码、判断实现错在哪、辨真假。