一、为什么大模型需要 KV Cache?
大语言模型通常采用自回归(Autoregressive)方式生成文本。
每次生成一个新 Token,都需要根据此前的上下文预测下一个 Token。
假设模型需要生成:
输入:Explain how Transformer works.
输出:Transformer is a neural network architecture...
模型的生成过程可以简化为:
flowchart TB
A["输入 Prompt"] --> B["模型处理上下文"]
B --> C["预测下一个 Token"]
C --> D["将 Token 加入上下文"]
D --> E{"是否达到停止条件"}
E -->|"否"| B
E -->|"是"| F["输出完整文本"]
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#EAF3EC,stroke:#83A995,color:#315D49
style C fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style D fill:#EAF3EC,stroke:#83A995,color:#315D49
style E fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style F fill:#E5F0E9,stroke:#83A995,color:#315D49
这里存在一个明显的问题:
每生成一个 Token,模型都需要利用此前的上下文进行计算。如果每次都从头计算所有历史 Token 的 Key 和 Value,就会产生大量重复计算。
例如:
| 生成步骤 | 当前上下文 | 新增 Token |
|---|---|---|
| 第 1 步 | A B C D | E |
| 第 2 步 | A B C D E | F |
| 第 3 步 | A B C D E F | G |
| 第 4 步 | A B C D E F G | H |
如果没有 KV Cache:
- 第 1 步计算 A、B、C、D 的 K、V。
- 第 2 步重新计算 A、B、C、D、E 的 K、V。
- 第 3 步重新计算 A、B、C、D、E、F 的 K、V。
- 第 4 步重新计算 A、B、C、D、E、F、G 的 K、V。
随着上下文变长,重复计算越来越多。
KV Cache 的核心思想:已经计算过的历史 K、V 不再重复计算,直接保存并复用。
二、KV Cache 缓存的是什么?
理解 KV Cache,需要先理解 Self-Attention 中的 Q、K、V。
1. Q、K、V 的计算
对于输入隐藏状态 X,Attention 层通过三个不同的线性投影矩阵计算:
其中:
- Q:Query,表示当前 Token 要查询什么信息。
- K:Key,表示每个 Token 提供什么匹配信息。
- V:Value,表示每个 Token 实际提供的内容表示。
- W_Q,W_K,W_V:可学习的线性投影矩阵。
标准 Scaled Dot-Product Attention:
其中:
- QK^T:计算 Query 与 Key 的匹配分数。
- \sqrt{d_k}:缩放因子。
- Softmax:将分数转换为注意力权重。
- V:根据注意力权重进行加权聚合。
2. 为什么只缓存 K 和 V,不缓存 Q?
这是 KV Cache 最关键的设计。
在自回归生成过程中:
- 历史 Token 的 K、V 已经计算完成。
- 新 Token 到来时,只需要计算新 Token 的 Q、K、V。
- 当前 Token 的 Query 需要与历史所有 Key 进行匹配。
- 历史 Value 可以直接参与加权聚合。
历史 Token 的 Query 不需要在后续生成中重新使用。
因此,推理阶段通常缓存 K 和 V,而不缓存 Q。
需要注意,缓存 K、V 并不意味着不再计算 Attention。每生成一个新 Token,仍然需要使用它的 Query 与历史 Key 计算注意力分数,并对历史 Value 进行加权聚合。
3. KV Cache 的存储结构
KV Cache 不只是保存一份全局 K、V。
在 Transformer 中,每一层都有自己的 Attention 模块,因此每一层都会产生独立的 K、V。
假设模型有 4 层 Transformer:
flowchart TB
A["输入 Token"] --> B["Transformer Layer 1"]
B --> C["Transformer Layer 2"]
C --> D["Transformer Layer 3"]
D --> E["Transformer Layer 4"]
B --> F["Layer 1 KV Cache"]
C --> G["Layer 2 KV Cache"]
D --> H["Layer 3 KV Cache"]
E --> I["Layer 4 KV Cache"]
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#EAF3EC,stroke:#83A995,color:#315D49
style C fill:#EAF3EC,stroke:#83A995,color:#315D49
style D fill:#EAF3EC,stroke:#83A995,color:#315D49
style E fill:#EAF3EC,stroke:#83A995,color:#315D49
style F fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style G fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style H fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F
每一层的 KV Cache 都会随着生成过程不断增长。
逻辑上可以表示为:
其中:
- L:Transformer 层数。
- K_l:第 l 层的 Key 缓存。
- V_l:第 l 层的 Value 缓存。
这意味着,KV Cache 的显存占用与模型层数、上下文长度、KV Head 数量、数据精度等因素密切相关。
三、KV Cache 的完整执行机制
KV Cache 的生命周期主要分为两个阶段:Prefill 和 Decode。
1. Prefill:建立 KV Cache
Prefill 阶段负责处理完整 Prompt。
假设输入包含 5 个 Token:
Token 1: What
Token 2: is
Token 3: KV
Token 4: Cache
Token 5: ?
模型会对整个输入序列进行前向计算。
在每一层中:
- 计算所有输入 Token 的 Q、K、V。
- 执行带有因果掩码的 Self-Attention。
- 完成该层的后续计算。
- 将本层所有输入位置的 K、V 保存到缓存。
Prefill 完成后,每一层都已经拥有这 5 个 Token 对应的 K、V。
flowchart TB
A["输入完整 Prompt"] --> B["Tokenizer"]
B --> C["Embedding"]
C --> D["进入 Transformer"]
D --> E["计算当前层所有 Token 的 Q、K、V"]
E --> F["执行 Causal Self-Attention"]
F --> G["保存当前层 K、V"]
G --> H["继续后续 Transformer 层"]
H --> I["所有层 KV Cache 建立完成"]
I --> J["LM Head 预测首个输出 Token"]
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style C fill:#EAF3EC,stroke:#83A995,color:#315D49
style D fill:#EAF3EC,stroke:#83A995,color:#315D49
style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style F fill:#EAF3EC,stroke:#83A995,color:#315D49
style G fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style H fill:#EAF3EC,stroke:#83A995,color:#315D49
style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style J fill:#E5F0E9,stroke:#83A995,color:#315D49
注意:Prefill 的因果注意力虽然限制每个位置只能访问自身及之前的位置,但所有输入位置仍然可以通过矩阵运算并行计算。
2. Decode:读取并追加 KV Cache
Prefill 完成后,模型开始生成输出。
假设 Prefill 已经处理 5 个 Token,并建立了对应缓存。
模型首先根据最后一个输入位置的隐藏状态预测第一个输出 Token,例如 works。
随后,模型将 works 对应的 Token ID 作为下一轮 Decode 的输入。
Decode 阶段的执行过程:
- 输入当前新 Token。
- 计算当前 Token 的 Q、K、V。
- 读取各层历史 KV Cache。
- 使用当前 Q 与历史 K 计算注意力分数。
- 使用注意力权重对历史 V 进行加权聚合。
- 将当前 Token 的 K、V 追加到对应层的缓存。
- 继续经过后续层,得到当前隐藏状态。
- 通过 LM Head 预测下一个 Token。
flowchart TB
A["已有历史 KV Cache"] --> B["输入当前 Token"]
B --> C["计算当前 Token 的 Q、K、V"]
C --> D["读取历史 K、V"]
D --> E["当前 Q 与历史 K 计算注意力"]
E --> F["Softmax 加权聚合历史 V"]
F --> G["当前 K、V 追加到缓存"]
G --> H["完成 Transformer 前向计算"]
H --> I["LM Head 预测下一个 Token"]
I --> J["进入下一轮 Decode"]
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style C fill:#EAF3EC,stroke:#83A995,color:#315D49
style D fill:#EAF3EC,stroke:#83A995,color:#315D49
style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style F fill:#EAF3EC,stroke:#83A995,color:#315D49
style G fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style H fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style I fill:#EAF3EC,stroke:#83A995,color:#315D49
style J fill:#E5F0E9,stroke:#83A995,color:#315D49
这里需要特别注意执行顺序:
当前 Token 的 K、V 必须参与当前 Token 的注意力计算,同时也需要被写入缓存,供后续 Token 使用。
实际实现中,缓存读取、当前 K/V 拼接或追加,以及注意力计算可以融合到高效 Kernel 中,不一定真的执行独立的内存拼接操作。
3. 一个完整的缓存增长示例
假设 Prompt 有 4 个 Token:
Prompt: A B C D
Prefill 完成后:
KV Cache: A B C D
第一次生成:
预测 Token: E
当 E 被选中并进入下一轮 Decode 后,缓存变为:
KV Cache: A B C D E
第二次生成:
预测 Token: F
当 F 进入下一轮 Decode 后,缓存变为:
KV Cache: A B C D E F
缓存增长过程:
flowchart TB
A["Prefill:A B C D"] --> B["KV Cache:A B C D"]
B --> C["生成 E"]
C --> D["KV Cache:A B C D E"]
D --> E["生成 F"]
E --> F["KV Cache:A B C D E F"]
F --> G["生成 G"]
G --> H["KV Cache:A B C D E F G"]
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#EAF3EC,stroke:#83A995,color:#315D49
style C fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style D fill:#EAF3EC,stroke:#83A995,color:#315D49
style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style F fill:#EAF3EC,stroke:#83A995,color:#315D49
style G fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style H fill:#E5F0E9,stroke:#83A995,color:#315D49
严格来说,生成 E 的那一轮 Decode 使用的是 Prefill 最后一个输入位置的隐藏状态。E 的 K、V 通常在 E 作为下一轮输入时才计算并写入缓存。
因此,生成 Token 和将该 Token 对应的 K、V 写入缓存之间存在一个执行时序关系,不能简单理解为 Token 一经采样就已经完成了 K、V 计算。
四、KV Cache 的显存占用如何计算?
KV Cache 是大模型推理中非常重要的显存开销来源。
尤其在长上下文和高并发场景下,KV Cache 可能占用大量 GPU 显存。
1. KV Cache 显存计算公式
定义以下参数:
- L:Transformer 层数。
- B:Batch Size。
- T:缓存 Token 数量。
- H_{kv}:KV Head 数量。
- D:每个 KV Head 的维度。
- P:每个元素占用的字节数。
Key 和 Value 各需要一份缓存,因此:
其中系数 2 表示 K 和 V 两部分。
如果使用 FP16 或 BF16:
如果使用 FP32:
如果使用 8-bit 缓存格式:
实际量化缓存还可能包含缩放因子、零点和对齐开销,因此不能只按数据元素大小估算最终显存。
2. 具体计算示例
假设某个模型具有以下配置:
| 参数 | 数值 |
|---|---|
| Transformer 层数 | 32 |
| Batch Size | 1 |
| 上下文长度 | 8192 |
| KV Head 数量 | 32 |
| Head Dimension | 128 |
| 数据类型 | FP16 |
| 单元素大小 | 2 Bytes |
代入公式:
换算:
也就是说,仅一个上下文长度为 8192 Token 的请求,就需要约 4 GiB 的 KV Cache 显存。
如果 Batch Size 增加到 8:
这还没有计算模型权重、激活、临时工作区和其他运行时开销。
3. 哪些因素影响 KV Cache 大小?
KV Cache 显存占用与以下因素近似呈线性关系:
| 因素 | 对显存占用的影响 |
|---|---|
| Transformer 层数 | 层数越多,缓存越大 |
| Batch Size | 请求越多,缓存越大 |
| 上下文长度 | Token 越多,缓存越大 |
| KV Head 数量 | KV Head 越多,缓存越大 |
| Head Dimension | 维度越大,缓存越大 |
| 数据精度 | 每个元素占用字节越多,缓存越大 |
因此,KV Cache 优化通常围绕三个方向展开:
- 减少需要缓存的元素数量。
- 降低每个元素的存储精度。
- 提高缓存空间的分配和复用效率。
五、MHA、GQA、MQA 对 KV Cache 的影响
不同 Attention 架构会直接影响 KV Cache 的大小。
1. MHA:Multi-Head Attention
标准多头注意力中,Query、Key、Value 通常拥有相同数量的 Head。
例如:
- Query Head:32
- Key Head:32
- Value Head:32
因此:
每一层需要保存 32 组 Key 和 32 组 Value。
2. MQA:Multi-Query Attention
MQA 的特点是:
- Query 拥有多个 Head。
- 所有 Query Head 共享一组 Key。
- 所有 Query Head 共享一组 Value。
例如:
- Query Head:32
- Key Head:1
- Value Head:1
因此:
相对于标准 MHA,KV Cache 的规模可以显著降低。
3. GQA:Grouped-Query Attention
GQA 介于 MHA 和 MQA 之间。
多个 Query Head 共享一组 KV Head。
例如:
- Query Head:32
- KV Head:8
- 每 4 个 Query Head 共享一组 KV Head。
因此:
4. 三种架构的缓存规模对比
假设其他参数完全相同:
| 架构 | Query Head | KV Head | KV Cache 相对大小 |
|---|---|---|---|
| MHA | 32 | 32 | 100% |
| GQA | 32 | 8 | 25% |
| MQA | 32 | 1 | 3.125% |
因为 KV Cache 的大小与 KV Head 数量成正比。
flowchart TB
A["Attention 架构"] --> B["MHA"]
A --> C["GQA"]
A --> D["MQA"]
B --> E["32 组 KV Head"]
C --> F["8 组 KV Head"]
D --> G["1 组 KV Head"]
E --> H["KV Cache 较大"]
F --> I["KV Cache 较小"]
G --> J["KV Cache 最小"]
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#EAF3EC,stroke:#83A995,color:#315D49
style C fill:#EAF3EC,stroke:#83A995,color:#315D49
style D fill:#EAF3EC,stroke:#83A995,color:#315D49
style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style F fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style G fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style H fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style J fill:#E5F0E9,stroke:#83A995,color:#315D49
需要注意,MHA、GQA 和 MQA 不只是缓存结构不同,它们也会改变模型的注意力投影结构和训练方式。不能在不改变模型结构的情况下,直接把一个已经训练好的标准 MHA 模型当作 GQA 或 MQA 模型使用。
六、KV Cache 为什么能够提升推理速度?
1. 不使用 KV Cache 的情况
假设当前上下文长度为 T。
生成下一个 Token 时,模型需要重新处理整个上下文,并计算所有历史位置的 K、V。
下一轮上下文长度变成 T+1,历史位置的 K、V 又被重新计算一次。
如果从长度为 S 的 Prompt 开始生成 N 个 Token,那么仅从 K、V 投影计算角度看,重复处理的 Token 位置数量近似为:
展开:
随着生成长度增加,重复计算开销会越来越大。
2. 使用 KV Cache 的情况
启用 KV Cache 后:
- Prefill 一次性计算 Prompt 的 K、V。
- Decode 每次只计算新增 Token 的 K、V。
- 历史 K、V 直接从缓存读取。
因此,K、V 投影只需要处理:
个 Token 位置,而不是反复处理增长中的整个上下文。
这并不代表 Attention 的全部计算量也变成线性常数。
每个新 Token 仍然需要与历史 Key 计算注意力,并读取历史 Value。
对于从长度 S 开始生成 N 个 Token,标准全注意力的增量注意力计算量仍与下式同阶:
KV Cache 的核心收益是避免重复计算历史 K、V,而不是消除新 Token 对历史上下文的注意力计算。
3. 两种模式的对比
| 对比维度 | 不使用 KV Cache | 使用 KV Cache |
|---|---|---|
| 历史 K、V | 每轮重新计算 | 直接读取 |
| 当前 Token 的 Q、K、V | 需要计算 | 需要计算 |
| 历史 Attention | 重新处理整个上下文 | 当前 Query 读取历史 K、V |
| 显存占用 | 缓存需求较低 | 需要额外缓存显存 |
| 计算重复 | 较多 | 显著减少 |
| 长文本生成 | 计算开销较高 | 通常更高效 |
KV Cache 用额外显存换取重复计算的减少。
这是一种典型的空间换时间优化。