返回专栏
· 17 分钟阅读

KV Cache 的工作原理:大语言模型如何缓存历史计算结果?


一、为什么大模型需要 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=XW_Q
K=XW_K
V=XW_V

其中:

  • Q:Query,表示当前 Token 要查询什么信息。
  • K:Key,表示每个 Token 提供什么匹配信息。
  • V:Value,表示每个 Token 实际提供的内容表示。
  • W_Q,W_K,W_V:可学习的线性投影矩阵。

标准 Scaled Dot-Product Attention:

Attention(Q,K,V) = Softmax\left(\frac{QK^T}{\sqrt{d_k}}\right)V

其中:

  • 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 都会随着生成过程不断增长。

逻辑上可以表示为:

KVCache= \left\{ (K_1,V_1), (K_2,V_2), \ldots, (K_L,V_L) \right\}

其中:

  • 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: ?

模型会对整个输入序列进行前向计算。

在每一层中:

  1. 计算所有输入 Token 的 Q、K、V。
  2. 执行带有因果掩码的 Self-Attention。
  3. 完成该层的后续计算。
  4. 将本层所有输入位置的 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 阶段的执行过程:

  1. 输入当前新 Token。
  2. 计算当前 Token 的 Q、K、V。
  3. 读取各层历史 KV Cache。
  4. 使用当前 Q 与历史 K 计算注意力分数。
  5. 使用注意力权重对历史 V 进行加权聚合。
  6. 将当前 Token 的 K、V 追加到对应层的缓存。
  7. 继续经过后续层,得到当前隐藏状态。
  8. 通过 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 各需要一份缓存,因此:

M_{KV}=2LBT H_{kv}DP

其中系数 2 表示 K 和 V 两部分。

如果使用 FP16 或 BF16:

P=2\ Bytes

如果使用 FP32:

P=4\ Bytes

如果使用 8-bit 缓存格式:

P\approx1\ Byte

实际量化缓存还可能包含缩放因子、零点和对齐开销,因此不能只按数据元素大小估算最终显存。

2. 具体计算示例

假设某个模型具有以下配置:

参数 数值
Transformer 层数 32
Batch Size 1
上下文长度 8192
KV Head 数量 32
Head Dimension 128
数据类型 FP16
单元素大小 2 Bytes

代入公式:

M_{KV} = 2\times32\times1\times8192\times32\times128\times2
M_{KV}=4,294,967,296\ Bytes

换算:

M_{KV}=4\ GiB

也就是说,仅一个上下文长度为 8192 Token 的请求,就需要约 4 GiB 的 KV Cache 显存。

如果 Batch Size 增加到 8:

M_{KV}=4\times8=32\ GiB

这还没有计算模型权重、激活、临时工作区和其他运行时开销。

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

因此:

H_{kv}=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

因此:

H_{kv}=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。

因此:

H_{kv}=8

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 位置数量近似为:

S+(S+1)+\cdots+(S+N-1)

展开:

NS+\frac{N(N-1)}{2}

随着生成长度增加,重复计算开销会越来越大。

2. 使用 KV Cache 的情况

启用 KV Cache 后:

  • Prefill 一次性计算 Prompt 的 K、V。
  • Decode 每次只计算新增 Token 的 K、V。
  • 历史 K、V 直接从缓存读取。

因此,K、V 投影只需要处理:

S+N

个 Token 位置,而不是反复处理增长中的整个上下文。

这并不代表 Attention 的全部计算量也变成线性常数。

每个新 Token 仍然需要与历史 Key 计算注意力,并读取历史 Value。

对于从长度 S 开始生成 N 个 Token,标准全注意力的增量注意力计算量仍与下式同阶:

O\left(Ld\left(NS+\frac{N(N+1)}{2}\right)\right)

KV Cache 的核心收益是避免重复计算历史 K、V,而不是消除新 Token 对历史上下文的注意力计算。

3. 两种模式的对比

对比维度 不使用 KV Cache 使用 KV Cache
历史 K、V 每轮重新计算 直接读取
当前 Token 的 Q、K、V 需要计算 需要计算
历史 Attention 重新处理整个上下文 当前 Query 读取历史 K、V
显存占用 缓存需求较低 需要额外缓存显存
计算重复 较多 显著减少
长文本生成 计算开销较高 通常更高效

KV Cache 用额外显存换取重复计算的减少。

这是一种典型的空间换时间优化。

七、KV Cache 的工程实现与管理