深入剖析 LLM 推理中的 KV Cache 机制

举报
yd_292659020 发表于 2026/11/13 00:30:51 2026/11/13
【摘要】 # 深入剖析 LLM 推理中的 KV Cache 机制> 本文聚焦大语言模型推理阶段的核心优化技术——KV Cache,从原理推导到工程实现细节,逐层拆解其工作机制、内存占用模型、以及为什么它是自回归生成得以高效运行的基础设施。## 1. 问题起点:为什么朴素自回归推理慢得不可接受大语言模型生成文本的过程是**自回归的**(autoregressive):每生成一个 token,就把它拼回输...

# 深入剖析 LLM 推理中的 KV Cache 机制

> 本文聚焦大语言模型推理阶段的核心优化技术——KV Cache,从原理推导到工程实现细节,逐层拆解其工作机制、内存占用模型、以及为什么它是自回归生成得以高效运行的基础设施。

## 1. 问题起点:为什么朴素自回归推理慢得不可接受

大语言模型生成文本的过程是**自回归的**(autoregressive):每生成一个 token,就把它拼回输入序列,再送入模型预测下一个。假设要生成 $N$ 个 token,输入序列长度为 $S$,那么朴素做法需要跑 $N$ 次前向传播,第 $i$ 次处理的序列长度是 $S + i$。

关键问题出在 Self-Attention 层。对于序列中的每一个位置 $q$,Attention 的计算是:

$$
\text{Attention}(q, K, V) = \text{softmax}\left(\frac{q K^T}{\sqrt{d_k}}\right) V
$$

其中 $K$ 和 $V$ 是**整个序列**经过线性投影后的矩阵。也就是说,第 $i$ 步生成时,计算第 $q$ 个位置的 attention,需要拿 $q$ 去和**所有 $S + i$ 个位置的 $K$ 向量**做点积,再对 $S + i$ 个 $V$ 向量加权求和。

朴素实现的致命浪费在于:第 $i$ 步和第 $i+1$ 步之间,前 $S + i$ 个位置的 $K$ 和 $V$ 向量**完全没变**——它们只取决于输入 token 和模型权重,与后面的生成无关。但朴素做法每一步都从头重新计算所有位置的 $K$ 和 $V$,这是 $O(N \cdot (S+N)^2)$ 级别的重复计算。

## 2. KV Cache 的核心思想:缓存历史投影,只算新增的一列

KV Cache 的思路很直接:**把已经算过的 $K$ 和 $V$ 存下来,下一步只计算新 token 对应的那一列 $K$ 和 $V$,拼到缓存末尾即可。**

具体来说,在第 $i$ 步生成时:

1. **Query**:只需要计算**最新 token** 的 $q$ 向量(因为历史位置的输出我们已经不需要了,我们只关心下一个 token 是什么)。
2. **Key / Value**:计算最新 token 的 $k$ 和 $v$,然后**拼接到缓存**:
   - $K_{\text{cached}} = [k_1, k_2, \ldots, k_{S+i-1}, k_{\text{new}}]$
   - $V_{\text{cached}} = [v_1, v_2, \ldots, v_{S+i-1}, v_{\text{new}}]$
3. **Attention 计算**:用单个 $q_{\text{new}}$ 去和整个 $K_{\text{cached}}$ 做点积(一个向量乘矩阵),softmax 后再对 $V_{\text{cached}}$ 加权求和。

这样一来,每一步的计算量从 $O((S+i)^2 \cdot d)$ 降到了 $O((S+i) \cdot d)$——从二次降为线性。总推理复杂度从 $O(N \cdot (S+N)^2)$ 降为 $O(N \cdot (S+N))$,这是一个**数量级**的提升。

### 2.1 Prefill 与 Decode 两阶段的本质区别

引入 KV Cache 后,推理自然分裂为两个阶段,它们的计算特征截然不同,这也是推理引擎做调优的分界线:

| 特征 | Prefill 阶段 | Decode 阶段 |
|------|-------------|-------------|
| 输入 | 整个 prompt($S$ 个 token) | 单个新 token |
| 计算内容 | 计算所有 $S$ 个位置的 $Q, K, V$,做完整的 $S \times S$ attention | 只算 1 个位置的 $q, k, v$,做 $1 \times (S+i)$ attention |
| 计算密度 | **高**,矩阵乘矩阵,GPU 算力充分利用 | **低**,向量乘矩阵,GPU 大量算力闲置 |
| 瓶颈 | Compute-bound(算力瓶颈) | Memory-bound(显存带宽瓶颈) |
| KV Cache | 从空开始填充,写入 $S$ 对向量 | 每步追加 1 对向量,读取全部缓存 |

Prefill 是"一次性算完 prompt 的所有 KV",Decode 是"每步只算一个新 token 的 KV,但要把历史缓存全读一遍"。这个差异直接影响后面的 batching 策略和显存管理。

## 3. 内存占用模型:KV Cache 到底吃多少显存

这是工程中最常被低估的部分。我们来精确推导。

### 3.1 单层单头单 token 的 KV Cache 大小

对于一个 Attention Head,维度为 $d_k$,每个 token 产生一个 $k$ 向量和一个 $v$ 向量,各 $d_k$ 个元素。如果用 FP16(每个元素 2 字节),那么:

$$
\text{单 token 单头单层} = 2 \times d_k \times 2 \text{ bytes}
$$

### 3.2 全模型全序列的 KV Cache 总大小

扩展到所有层、所有头、所有 token:

$$
\text{KV Cache 总大小} = 2 \times L \times H \times d_k \times \text{seq\_len} \times \text{bytes\_per\_element}
$$

其中:
- $L$ = Transformer 层数
- $H$ = Attention 头数
- $d_k$ = 每个头的维度
- $\text{seq\_len}$ = 当前序列总长度(prompt + 已生成 token)
- $\text{bytes\_per\_element}$ = 精度字节数(FP16 = 2, FP32 = 4, INT8 = 1)

注意 $H \times d_k = d_{\text{model}}$(模型隐藏维度),所以可以简化为:

$$
\text{KV Cache} = 2 \times L \times d_{\text{model}} \times \text{seq\_len} \times \text{bytes\_per\_element}
$$

### 3.3 代入实际数字感受一下

以 LLaMA-2-70B 为例:
- $L = 80$ 层
- $d_{\text{model}} = 8192$
- 用 FP16,bytes = 2
- 假设 seq_len = 4096

$$
\text{KV Cache} = 2 \times 80 \times 8192 \times 4096 \times 2 = 10{,}737{,}418{,}240 \text{ bytes} \approx 10 \text{ GB}
$$

**单条请求、4096 长度的 KV Cache 就要 10GB 显存。** 而模型权重本身在 FP16 下约 140GB。这意味着在多并发场景下,KV Cache 的显存占用会迅速超过模型权重,成为限制并发数的首要瓶颈。

如果把序列长度拉到 16K,KV Cache 单条就要约 40GB——这就是为什么长上下文推理的显存压力远超直觉。

## 4. PagedAttention:把 KV Cache 当虚拟内存管理

KV Cache 的一个工程难题是**显存碎片化**。传统做法为每个请求预分配一块连续的 `max_seq_len` 大小的显存,但实际生成长度是动态的——大部分请求生成到一半就停了,预分配的空间大量浪费,且不同请求之间的空闲块无法复用。

vLLM 引入的 **PagedAttention** 借鉴了操作系统的**虚拟内存分页机制**:

### 4.1 核心设计

1. **物理块(Block)**:将 KV Cache 的物理显存划分为固定大小的块,每个块存储固定数量 token 的 KV 数据(通常 block_size = 16)。
2. **逻辑块到物理块的映射表(Block Table)**:每个请求维护一张映射表,记录它的逻辑块号 → 物理块号。逻辑上连续的 KV Cache,物理上可以分散在不同块中。
3. **按需分配**:请求每生成一个新 token,如果当前块没满就写入当前块;满了就从全局空闲块池分配一个新块,更新映射表。
4. **块级回收**:请求结束后,它占用的所有物理块归还到空闲池,立即可被其他请求复用。

### 4.2 为什么这能大幅提升并发

- **消除内部碎片**:不再预分配 max_seq_len,只按实际生成长度分配,碎片从 ~60-80% 降到 <4%。
- **支持灵活的内存共享**:在并行采样(Parallel Sampling)和 beam search 中,多个序列共享同一个 prompt 的 KV Cache——只需在 Block Table 中指向相同的物理块即可,写时复制(Copy-on-Write)处理分歧部分。
- **全局调度**:因为所有块在同一个池中,调度器可以精确知道剩余可用块数,做精确的准入控制,而不是靠预估。

## 4.3 Copy-on-Write 在 beam search 中的细节

当 beam search 中两个候选序列在某个 token 处分叉时,它们共享分叉点之前的所有 KV Cache 块。分叉后各自写入新 token 时:

1. 检测到当前块被多个序列引用(引用计数 > 1)。
2. 从空闲池分配一个新物理块,把原块内容复制过去。
3. 当前序列的 Block Table 更新指向新块。
4. 原块的引用计数减 1。
5. 新 token 的 KV 写入新块。

这个机制使得 beam search 的 KV Cache 显存占用从 $O(\text{beam\_width} \times \text{seq\_len})$ 降到接近 $O(\text{seq\_len} + \text{beam\_width} \times \text{divergence\_len})$,在分叉点靠前时节省巨大。

## 5. Continuous Batching:与 KV Cache 配合的动态调度

传统 batching 是**静态**的:凑齐一个 batch 后一起跑,等最长的那个生成完才释放整个 batch。问题在于同一 batch 内各请求生成长度不同,短请求生成完后空等,GPU 利用率低下。

**Continuous Batching**(也叫 iteration-level batching)改为**每一步(每个 token 生成)都可以动态调整 batch**:

1. 当前 iteration 结束后,检查哪些请求已生成完毕(遇到 EOS 或达到 max_tokens)。
2. 完成的请求立即移出 batch,其 KV Cache 块归还空闲池。
3. 如果有空闲块且等待队列中有新请求,立即将新请求加入 batch,开始 prefill。
4. 未完成的请求继续 decode。

这意味着 batch 的组成在**每个 token 生成步**都在变化。配合 PagedAttention,新请求不需要等待连续显存空间——只要有足够的空闲块就能加入。这把 GPU 利用率从静态 batching 的 ~20-40% 拉到了 80%+。

### 5.1 Prefill 和 Decode 混合调度的挑战

Continuous Batching 的一个微妙问题是:prefill 是 compute-bound(大量矩阵乘法),decode 是 memory-bound(读 KV Cache 做少量计算)。如果把一个 prefill 请求和一堆 decode 请求放在同一个 batch 的同一步执行,会出现两种情况:

- **Prefill 打满算力,Decode 被拖慢**:prefill 的大量计算占据了 SM(Streaming Multiprocessor),decode 请求的 memory-bound 操作被延迟。
- **Decode 占满显存带宽,Prefill 计算变慢**:decode 读取大量 KV Cache 消耗 HBM 带宽,prefill 的矩阵乘法数据加载变慢。

实践中常见的解决策略是 **Prefill 和 Decode 分离调度**:
- 将 prefill 和 decode 分到不同的 iteration 执行,避免资源争抢。
- 或者做 chunked prefill——把长 prompt 的 prefill 拆成多个小块,与 decode 请求混合执行,每块的计算量与 decode 相当,减少争抢。

## 6. Multi-Query Attention 与 Grouped-Query Attention:从结构上压缩 KV Cache

KV Cache 大小正比于 Attention 头数 $H$。如果减少头数,KV Cache 就线性缩小——但直接减少头数会损害模型质量。

**Multi-Query Attention (MQA)** 的做法是:所有 Query 头**共享同一组** Key 和 Value 头(即 $H_K = H_V = 1$)。这样 KV Cache 从 $O(H \times d_k)$ 降到 $O(d_k)$,缩小 $H$ 倍。但 MQA 对质量有可感知的损害。

**Grouped-Query Attention (GQA)** 是折中方案:将 $H$ 个 Query 头分成 $G$ 组,每组共享一对 K/V 头,即 $H_K = H_V = G$。当 $G = 1$ 时退化为 MQA,当 $G = H$ 时退化为标准 MHA。

以 LLaMA-2-70B 为例,使用 GQA,$G = 8$(8 组 K/V 头,64 个 Query 头),KV Cache 比标准 MHA 小 8 倍。前面算的 10GB 直接降到约 1.25GB。这是**模型结构层面**的优化,与推理引擎的 PagedAttention 是正交的,两者叠加效果显著。

## 7. 量化压缩:用更少的比特存 KV Cache

除了减少头数,还可以用低精度存储 KV Cache:

- **FP8 KV Cache**:将 FP16 的 K/V 向量量化到 FP8(E4M3 或 E5M2),显存减半。精度损失在大多数任务上可接受。
- **INT8 KV Cache**:对称或非对称量化到 INT8,配合逐通道(per-channel)缩放因子,精度损失更小。
- **INT4 KV Cache**:更激进的量化,显存压缩 4 倍,但在长序列上精度损失明显,需要配合 outlier 保护策略。

量化的一个技术细节是:K 和 V 的数值分布不同。K 向量的分布通常更集中,量化友好;V 向量可能有较大的 outlier,直接量化损失大。实践中常对 K 和 V 使用不同的量化粒度或策略。

## 8. 一个容易踩的坑:KV Cache 与滑动窗口注意力

有些模型使用 **Sliding Window Attention**(如 Mistral,窗口大小 $W$):每个 token 只 attend 前面 $W$ 个 token,而不是全部历史。直觉上这应该能大幅减少 KV Cache——只需要存最近 $W$ 个 token 的 KV。

但实现上有一个陷阱:**Sliding Window 并不意味着可以直接丢弃窗口外的 KV Cache**。原因是:

1. **不同层可以有不同的注意力范围**。某些模型在底层用 sliding window,顶层用 full attention(如 Gemma-2 的设计)。顶层需要完整的 KV Cache,如果底层丢弃了,就无法恢复。
2. **生成阶段的安全余量**。即使所有层都用 sliding window,实现中通常保留略多于 $W$ 的缓存,以避免在 block 边界频繁分配/释放。
3. **Prefill 阶段仍然需要完整序列**。Prefill 时 sliding window 只是限制 attention 的计算范围,但 KV Cache 仍然要为整个 prompt 分配空间(因为后续 decode 会逐步用到)。

正确的做法是:在 PagedAttention 的框架下,标记每个块是否在窗口内,decode 时只读取窗口内的块做 attention,但块的分配和回收仍然由全局调度器管理,而不是在 attention 层直接释放。

## 9. 总结:KV Cache 是推理系统设计的第一公民

回看全文,KV Cache 不是一个简单的"缓存"概念,而是一整套推理基础设施的核心:

- **计算层面**:将自回归推理从 $O(N^2)$ 降为 $O(N)$,是推理可行的前提。
- **显存层面**:是长上下文和多并发的首要瓶颈,催生了 PagedAttention 分页管理。
- **调度层面**:与 Continuous Batching 深度耦合,决定了请求的准入和驱逐策略。
- **模型结构层面**:GQA/MQA 从架构上压缩 KV Cache 大小,与推理引擎优化正交叠加。
- **精度层面**:FP8/INT8 量化进一步压缩存储,需注意 K/V 分布差异。

理解 KV Cache 的每一个环节,是从"会用推理框架"到"能调优推理系统"的关键一步。在 LLM 服务化的工程实践中,绝大多数性能问题——OOM、并发低、首 token 延迟高、吞吐不足——最终都能追溯到 KV Cache 的管理策略上。

【声明】本内容来自华为云开发者社区博主,不代表华为云及华为云开发者社区的观点和立场。转载时必须标注文章的来源(华为云社区)、文章链接、文章作者等基本信息,否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0)

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。