推理
这一课在哪
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 个词,就重复算了 次位置。
哪些能存下来
解码器一层里有三种计算,看看哪些是「历史不变」的:
量 | 对已生成的位置 | 能存吗 |
|---|---|---|
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 个(这部分省不掉) |
省的是哪一项
记序列长度为 、维度 、层数 :
部分 | 不缓存 | 缓存 |
|---|---|---|
投影 + FFN | ||
注意力打分 |
两项都少了一个 倍。
投影和 FFN 那项尤其重要——在实际模型里,它们才是计算量大头 (37.3 课算过,FFN 占一层参数的 67%)。
实测
RTX 5060,6 层,,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 各一份 |
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 / 评估 | 可选,不影响分数 |
线上生成 | 必须 |
超长上下文 | 必须,但要想办法压显存 |
这一课留下的三个数
数 | 值 | 含义 |
|---|---|---|
重复计算 | 不缓存时白算的位置数 | |
复杂度改善 | 少一个 倍 | 投影和 FFN 从 降到 |
缓存显存 | 48 MB @ 64,192 MB @ 256 | 长度翻倍就翻倍 |
下一课
整章讲完了。最后一课是习题—— 算参数、手推掩码、判断实现错在哪、辨真假。