本文属于《AI 深度培训》系列 · 难度:专家 · 篇幅:约 7000 字
大模型推理与训练瓶颈迥异:训练重算力,推理重延迟。本文聚焦解码阶段的访存密集特性,深入解析 KV Cache 显存占用公式,探讨 MQA/GQA 如何通过共享 KV 头降低带宽压力,并介绍 PagedAttention 解决显存碎片问题。旨在建立“突破显存带宽瓶颈”的核心认知,为掌握高效推理优化奠定基础。
1. 导读:推理与训练的不同瓶颈
大模型推理与训练在系统瓶颈上存在本质差异。训练阶段通常追求高吞吐,通过大规模数据并行和梯度累积来最大化 GPU 利用率,其核心约束往往是计算能力(FLOPs)。然而,推理阶段,尤其是面向用户的在线服务,对延迟(Latency)极为敏感。我们需要区分两个关键指标:首 token 时间(Time to First Token, TTFT)和每 token 生成时间(Time per Output Token, TPOT)。 TTFT 主要取决于提示词(Prompt)的处理速度。由于提示词长度固定且通常较长,这一阶段涉及大量的矩阵乘法运算,属于计算密集型任务。此时,GPU 的算力上限决定了响应速度。相比之下,TPOT 决定了用户感知到的流式输出流畅度。在解码(Decode)阶段,每生成一个新 token,都需要读取之前所有历史 token 的 Key 和 Value 向量。由于每步仅处理一个 token,计算量极小,但需要频繁访问显存中的 KV Cache。这使得解码阶段转变为访存密集型任务,瓶颈从计算单元转移到了显存带宽(Memory Bandwidth)。 这种转变解释了为什么单纯增加 GPU 算力对提升解码速度帮助有限,而优化显存访问模式至关重要。例如,MQA 和 GQA 技术通过共享 KV 头,显著减少了需要读取的显存数据量,从而直接降低带宽压力(Shazeer, 2019; Ainslie et al., 2023)。此外,PagedAttention 等技术通过管理显存碎片,进一步提升了带宽的有效利用率(Kwon et al., 2023)。 理解这一“计算-访存”瓶颈的转移,是掌握推理优化的基础。它解释了为何 FlashAttention 等算法强调 IO 感知(Dao et al., 2022),以及为何 Orca 等系统采用迭代级调度以平衡不同请求的延迟需求(Yu et al., 2022)。 本文后续内容将深入探讨:
- Prefill 与 Decode 的算术强度分析:量化两个阶段的资源需求差异。
- KV Cache 原理:推导显存占用公式,揭示容量限制。
- MQA 与 GQA:分析共享 KV 头对带宽和质量的影响。
- PagedAttention:解决显存碎片问题,实现高效调度。
通过本节导读,读者应建立“推理优化核心在于突破显存带宽瓶颈”的认知框架,为后续深入算法细节做好准备。
2. Prefill 与 Decode
Prefill 与 Decode:计算密集与访存密集的不对称性
在大模型推理中,自回归生成过程在硬件资源消耗上呈现出极端的不对称性。这种不对称性源于两个阶段截然不同的算术强度(Arithmetic Intensity),即每字节访存所执行的浮点运算数量。理解这一差异是设计高效推理系统的前提。 Prefill 阶段:计算密集 当用户输入一段提示词(Prompt)时,模型需要一次性处理整个序列以生成首个 Token。这一过程称为 Prefill。由于序列长度 L 通常远大于 1,注意力机制中的 Query、Key、Value 矩阵乘法涉及大量的矩阵-矩阵运算(GEMM)。 在 Transformer 的自注意力层中,计算量主要取决于 O(L^2 · d),其中 d 为隐藏层维度。此时,GPU 的 Tensor Core 能够被充分饱和,算术强度极高。例如,对于 L=2048 的序列,计算量远超访存量。因此,Prefill 阶段的瓶颈在于计算能力(FLOPS)。这也是为什么在长文本推理中,首 Token 延迟(Time to First Token, TTFT)往往较高,因为它受限于模型的计算吞吐量。 Decode 阶段:访存密集 一旦首个 Token 生成,后续每个 Token 的生成都依赖于前序所有 Token 的上下文。这一过程称为 Decode。在每一步 Decode 中,虽然序列长度仍在增加,但当前步仅计算一个新 Token 的 Query 向量,并与缓存中所有的 Key 和 Value 向量进行点积。 此时,注意力计算退化为向量-矩阵乘法(GEMV)。假设隐藏层维度 d=4096,序列长度 L=2048,每步计算量约为 O(L · d),而需要读取的 KV Cache 数据量同样约为 O(L · d)。由于每步仅产生 1 个输出 Token,算术强度极低(接近 1 FLOP/Byte)。 如下图所示,Prefill 阶段像是一个宽而深的矩阵乘法,而 Decode 阶段则像是一系列细长的向量检索。
Prefill: Q [1, L, d] @ K [1, d, L] -> O [1, L, L] (GEMM, High AI)
Decode: q [1, 1, d] @ K [1, d, L] -> o [1, 1, L] (GEMV, Low AI)
带宽瓶颈的本质 在 Decode 阶段,GPU 的计算单元大部分时间处于空闲状态,等待数据从 HBM(高带宽内存)传输到片上缓存。此时,推理速度直接受限于显存带宽(Memory Bandwidth)。 以典型的 A100 GPU 为例,其 HBM 带宽约为 2 TB/s,而 FP16 算力约为 312 TFLOPS。若算术强度低于 312 / 2 ≈ 156 FLOP/Byte,GPU 将处于带宽受限状态。Decode 阶段的算术强度通常远低于此阈值,因此即使使用更强大的计算芯片,如果带宽未同步提升,Decode 速度也不会显著增加。 工程含义
- 批处理(Batching)的价值:通过增加批大小
B,可以将多个请求的 Decode 步骤合并,将 GEMV 转化为 GEMM,从而提升算术强度,掩盖访存延迟。这是提高推理吞吐量的核心手段。 - KV Cache 的优化:由于 Decode 阶段需要反复读取 KV Cache,减少 KV Cache 的体积(如使用 MQA/GQA)或优化其存储布局(如 PagedAttention)能直接降低访存压力,从而提升 Decode 速度。
- 硬件选型:对于以 Decode 为主的在线推理服务,显存带宽比峰值算力更为关键。
常见误区:许多工程师误以为提升 GPU 算力(如使用更高 FLOPS 的芯片)能线性提升生成速度。事实上,在 Decode 阶段,算力往往过剩,带宽才是瓶颈。只有当批大小足够大,使得算术强度超过硬件的带宽/算力比值时,算力提升才会转化为速度收益。

Prefill 以矩阵乘为主、偏计算密集;Decode 每步要读完整权重与 KV Cache,小批量时偏内存带宽密集(参见 Pope et al., 2022)。
3. KV Cache:原理与容量公式
在 Transformer 的解码(Decode)阶段,自回归生成的核心痛点在于重复计算。若每生成一个新 token 都重新计算整个历史序列的 Key 和 Value,计算复杂度将随序列长度线性增长,导致推理延迟不可接受。KV Cache 机制通过缓存已处理 token 的 K、V 向量,将每步新增的计算量降至常数级,是降低解码延迟的关键工程手段。
1. 原理:避免重复计算
在标准多头注意力机制中,Query (Q)、Key (K)、Value (V) 均由输入隐藏状态通过线性投影得到。在 Prefill 阶段,模型并行处理整个提示词(Prompt),生成所有位置的 K、V 并计算首个输出 token。进入 Decode 阶段后,每步仅输入一个新 token 的 Q,但需要与所有历史 token 的 K、V 进行注意力计算。 若不使用缓存,第 t 步需重新计算前 t-1 个 token 的 K、V。KV Cache 则将这些 K、V 存储在显存中。第 t 步仅需:
- 计算当前 token 的
Q_t, K_t, V_t; - 将
K_t, V_t追加到缓存末尾; - 使用
Q_t与缓存中完整的K_1..t, V_1..t计算注意力。
这使得每步解码的注意力计算复杂度从 O(t^2) 降至 O(t)(仅涉及当前 Q 与历史 KV 的点积),且避免了大量冗余的矩阵乘法。
2. 容量公式推导
KV Cache 的显存占用是推理系统的主要瓶颈之一,尤其在大批量(Batch Size)或长序列场景下。其总容量 C_KV 由以下因素决定:
- 2:表示同时缓存 Key 和 Value 两个张量;
- L:Transformer 层数;
- H_kv:每层的 KV 头数(Multi-Query Attention 中为 1,Grouped-Query Attention 中为组数);
- d_head:每个头的维度;
- S:当前序列长度(含提示词与已生成 token);
- B:批大小(Batch Size);
- b:数据类型的字节数(如 FP16 为 2 字节,FP8 为 1 字节)。
总容量公式为:
C_KV = 2 × L × H_kv × d_head × S × B × b
示例:假设一个 32 层模型,H_kv=8(GQA),d_head=128,S=4096,B=32,使用 FP16(b=2)。
C_KV = 2 × 32 × 8 × 128 × 4096 × 32 × 2 bytes ≈ 10.7 GB。 此数值仅为演示,实际需结合硬件显存上限进行规划。
3. 伪代码实现
以下伪代码展示了 KV Cache 在解码步骤中的核心操作逻辑(简化版,忽略多头并行细节):
# 假设 kv_cache 是一个列表,每个元素为 (K_cache, V_cache)
# K_cache, V_cache 形状: [B, H_kv, S_current, d_head]
def decode_step(x_t, kv_cache, layer_idx):
# x_t: 当前 token 的隐藏状态, 形状 [B, d_model]
# 1. 计算当前 token 的 Q, K, V
Q_t = linear_proj_Q(x_t) # [B, H_q, d_head]
K_t = linear_proj_K(x_t) # [B, H_kv, d_head]
V_t = linear_proj_V(x_t) # [B, H_kv, d_head]
# 2. 追加到缓存(沿序列维度拼接)
K_cache, V_cache = kv_cache[layer_idx]
K_new = concat([K_cache, K_t], dim=-2) # [B, H_kv, S_current+1, d_head]
V_new = concat([V_cache, V_t], dim=-2)
kv_cache[layer_idx] = (K_new, V_new)
# 3. 计算注意力(Q_t 与完整 K_new, V_new 交互)
# 注意:实际中需处理 H_q 与 H_kv 的映射(如 GQA 中多个 Q 头共享一组 KV)
scores = matmul(Q_t, transpose(K_new, dim=[0,1,3,2])) / sqrt(d_head)
attn_weights = softmax(scores, dim=-1)
output = matmul(attn_weights, V_new)
return output
4. 工程含义与常见误区
- 显存带宽瓶颈:Decode 阶段算术强度低,主要受限于显存带宽。KV Cache 的读取量随序列长度线性增长,成为主要开销。
- 误区 1:认为 KV Cache 仅影响显存容量。实际上,其读取频率直接影响推理延迟,尤其在长序列场景下。
- 误区 2:忽视数据类型选择。使用 FP8 或 INT8 量化 KV Cache 可显著降低显存占用和带宽压力,但需评估精度损失。
- 优化方向:结合 MQA/GQA 减少
H_kv,或使用 PagedAttention 管理显存碎片,是后续章节的重点。
4. MQA 与 GQA:共享 KV 头
在标准多头注意力(MHA)机制中,每个查询头(Query Head)都拥有独立的键(Key)和值(Value)投影矩阵。这意味着对于 H 个注意力头,我们需要存储 H 组 K 和 H 组 V。在解码阶段,随着序列长度增加,KV Cache 的显存占用成为主要瓶颈。为了降低这一开销,研究者们提出了通过减少 KV 头数量来压缩缓存容量的策略,即多查询注意力(MQA)和分组查询注意力(GQA)。 多查询注意力(MQA) 的核心思想是极致的共享。如 Shazeer et al. (2019) 所提出的,MQA 让所有查询头共享同一组 K 和 V。形式化地,如果 MHA 有 H 个查询头、H 个键头和 H 个值头,MQA 则保持 H 个查询头,但将键头和值头数量均减少为 1。
# MHA: Q (B, H, L, D), K (B, H, L, D), V (B, H, L, D) # MQA: Q (B, H, L, D), K (B, 1, L, D), V (B, 1, L, D) # 注意:K 和 V 在广播到所有 H 个查询头之前只计算一次
这种设计直接将 KV Cache 的容量降低了 H 倍。如下图所示,以 32 层、head_dim 128、FP16、序列 4096、批大小 1 为例,MHA 的 KV Cache 占用约为 128 MB,而 MQA 仅需约 4 MB(假设 32 个头)。然而,极端的共享往往导致模型表达能力下降,因为不同的语义视角(由不同查询头捕捉)被迫使用相同的上下文表示(K/V)。 分组查询注意力(GQA) 则是在 MHA 和 MQA 之间寻找平衡点。Ainslie et al. (2023) 指出,GQA 将 H 个查询头分为 G 组,每组共享一组 K 和 V。当 G=1 时退化为 MQA,当 G=H 时退化为 MHA。通常 G 取 8 或 16,既显著减少了 KV Cache 占用,又保留了足够的语义区分度。 GQA 的一个重要工程优势在于其可训练性。Ainslie et al. (2023) 证明,可以从现有的 MHA 检查点出发,通过“Uptraining”(继续预训练)的方式将其转换为 GQA 模型,而无需从头训练。具体做法是将 MHA 的多个 K/V 头平均或投影合并为每组一个 K/V 头,然后进行少量步数的继续预训练以恢复精度。这种方法极大地降低了部署 GQA 模型的成本。
# 伪代码:从 MHA 检查点初始化 GQA 权重
# 假设 MHA 有 32 个头,GQA 分组数 G=8
# W_k_mha: shape (H, D_k, D_model)
# W_k_gqa: shape (G, D_k, D_model)
def uptrain_mha_to_gqa(w_k_mha, G):
H = w_k_mha.shape[0]
# 将 H 个头平均分为 G 组,每组 H/G 个头
# 简单策略:取每组内权重的平均值作为新的共享权重
w_k_gqa = w_k_mha.reshape(G, H//G, D_k, D_model).mean(dim=1)
return w_k_gqa
在性能权衡方面,GQA 在保持与 MHA 相近的困惑度(Perplexity)的同时,显著提升了解码吞吐量。由于 KV Cache 读写量减少,访存带宽压力降低,使得解码阶段更接近计算密集型,从而更好地利用 GPU 算力。Pope et al. (2022) 的研究也表明,在大规模推理场景中,减少 KV 头数是提升能效比的关键手段之一。 常见误区是认为 GQA 必然导致精度大幅下降。实际上,只要分组数 G 设置合理(如 8 或 16),并通过 Uptraining 微调,GQA 模型在主流基准测试上的表现与 MHA 几乎无差,而显存节省可达 4 倍以上。因此,GQA 已成为现代大模型(如 LLaMA 2 70B)的标准配置。

容量 = 2(K 和 V)× 层数 × KV 头数 × head_dim × 序列长度 × 2 字节。示例配置为假设值,用于演示公式;批大小为 B 时再乘以 B。
5. PagedAttention 与连续批处理
在大规模 LLM 推理服务中,KV Cache 的显存管理是核心痛点。传统实现通常要求为每个序列预分配连续显存块,以容纳最大可能长度。这种做法导致严重的内部碎片:若序列实际长度远小于预分配上限,大量显存被浪费;同时,不同序列的预分配大小不一,使得显存池难以复用,造成外部碎片。随着批处理规模扩大,这种碎片化会迅速耗尽 GPU 显存,限制并发请求数。 PagedAttention 借鉴操作系统的虚拟内存分页机制,将 KV Cache 划分为固定大小的物理块(block),例如每块存储 16 或 32 个 token 的键值对。每个序列维护一张块表(block table),记录其逻辑块到物理块的映射关系。如下图所示,逻辑上连续的 KV 序列在物理显存中可分散存储于任意空闲块中,只要块表正确指向即可。这种设计消除了预分配需求,显存按需分配,内部碎片率降至块大小以内,外部碎片通过块级复用几乎消除。
class PagedKVCache:
def __init__(self, num_blocks, block_size, kv_heads, head_dim, dtype):
# 预分配物理块池,形状: [num_blocks, block_size, kv_heads, head_dim]
self.blocks = torch.empty(num_blocks, block_size, kv_heads, head_dim, dtype=dtype)
self.free_blocks = list(range(num_blocks))
def allocate(self, num_logical_blocks):
# 从空闲池分配物理块 ID
if len(self.free_blocks) < num_logical_blocks:
raise MemoryError("No free blocks")
allocated = self.free_blocks[:num_logical_blocks]
self.free_blocks = self.free_blocks[num_logical_blocks:]
return allocated
def free(self, block_ids):
# 释放物理块回空闲池
self.free_blocks.extend(block_ids)
块表是序列状态的核心数据结构。每个序列维护一个列表,其中第 i 个元素指向存储第 i 个逻辑块(含 block_size 个 token)的物理块 ID。在注意力计算时,内核根据块表动态定位物理地址,无需连续内存假设。这种间接寻址使 KV Cache 管理接近零开销,且支持高效的序列前缀共享(如多轮对话中复用系统提示的 KV 块)。 连续批处理(continuous batching)进一步利用 PagedAttention 的灵活性。传统静态批处理要求所有序列同步完成,短序列需等待长序列,导致 GPU 空闲。连续批处理在迭代级(iteration-level)调度:每个解码步结束后,立即将已完成的序列移出批次,同时插入新到达的序列。由于 KV Cache 按块动态分配/释放,新序列可即时获得所需显存,无需等待批次边界。这种调度显著提升吞吐,尤其适用于请求长度分布不均的场景。
# 迭代级调度伪代码
for each iteration:
# 1. 执行当前批次所有序列的一步解码
outputs = decode_step(batch)
# 2. 移除已完成序列,释放其 KV 块
for seq in batch:
if seq.is_finished():
paged_cache.free(seq.block_table)
batch.remove(seq)
# 3. 插入等待队列中的新序列
while waiting_queue and len(batch) < max_batch_size:
new_seq = waiting_queue.pop()
num_blocks = ceil(new_seq.len / block_size)
new_seq.block_table = paged_cache.allocate(num_blocks)
batch.add(new_seq)
这种机制使系统能动态适应负载变化,最大化 GPU 利用率。PagedAttention 与连续批处理的结合,已成为现代 LLM 推理引擎(如 vLLM)的标准架构,显著提升了服务效率与可扩展性。
常见误区:认为分页机制会引入额外内存访问开销。实际上,块大小通常与 GPU 缓存行对齐,且注意力内核已优化为按块读取,额外开销可忽略。碎片消除带来的显存节省远超此成本。

示意:每块 16 个 token(块大小可配置)。物理块不必连续,只在最后一块有少量浪费;共享前缀的序列可以共享物理块(Kwon et al., 2023)。
6. 小结与思考题
回顾本文核心,推理优化的本质是在计算密集(Prefill)与访存密集(Decode)两种截然不同的工作负载间寻求平衡。 关键结论回顾:
- 瓶颈转移:Prefill 阶段并行度高,受限于 FLOPs;Decode 阶段每步仅生成一个 token,受限于显存带宽(Memory Bandwidth)。
- KV Cache 是核心约束:其容量公式为
2 × L × H_kv × d_head × S × B × bytes。其中L为层数,H_kv为 KV 头数,d_head为头维度,S为序列长度,B为批大小。 - MQA/GQA 的价值:通过减少
H_kv(MQA 设为 1,GQA 设为组数),直接线性降低 KV Cache 显存占用,从而提升 Decode 阶段的算术强度(Arithmetic Intensity),缓解带宽瓶颈(Shazeer, 2019; Ainslie et al., 2023)。 - PagedAttention 的作用:解决显存碎片化问题,通过块表(Block Table)映射逻辑块到物理块,实现非连续内存的高效利用,支撑连续批处理(Continuous Batching)以最大化吞吐(Kwon et al., 2023)。
思考题:
- 容量估算:假设一个 7B 参数模型,层数
L=32,KV 头数H_kv=32(MHA),d_head=128,序列长度S=2048,批大小B=8,使用 FP16(2 字节)。请计算该配置下 KV Cache 的总显存占用(GB),并估算若改为 MQA(H_kv=1)后,显存占用减少为原来的多少比例? - 提示:先计算单 token、单层、单头的字节数,再乘以总维度。
- 带宽 vs 算力:在 Decode 阶段,若显存带宽为 800 GB/s,模型权重为 14 GB(FP16)。假设每生成一个 token 需读取全部权重,且忽略 KV Cache 读取开销,理论最大吞吐量(tokens/s)是多少?若此时引入 GQA 使 KV Cache 读取量减半,对吞吐量的提升是否显著?为什么?
- 提示:吞吐量 ≈ 带宽 / 每 token 读取的总字节数。分析权重读取与 KV 读取在总字节数中的占比。
- PagedAttention 的代价:PagedAttention 将 KV Cache 分块存储,虽然解决了碎片化,但引入了块表查找和可能的非连续内存访问。在什么场景下,这种间接寻址的开销会抵消其带来的内存利用率提升?
- 提示:考虑序列长度极短、批大小极大,或硬件对连续内存访问优化极强的场景。
参考文献
- Pope et al., 2022. Efficiently Scaling Transformer Inference. arXiv:2211.05102 arxiv.org/abs/2211.05102
- Shazeer, 2019. Fast Transformer Decoding: One Write-Head is All You Need. arXiv:1911.02150 arxiv.org/abs/1911.02150
- Ainslie et al., 2023. GQA: Training Generalized Multi-Query Transformer Models from Multi-Head Checkpoints. arXiv:2305.13245 arxiv.org/abs/2305.13245
- Kwon et al., 2023. Efficient Memory Management for Large Language Model Serving with PagedAttention. arXiv:2309.06180 arxiv.org/abs/2309.06180
- Yu et al., 2022. Orca: A Distributed Serving System for Transformer-Based Generative Models. OSDI 2022
- Dao et al., 2022. FlashAttention: Fast and Memory-Efficient Exact Attention with IO-Awareness. arXiv:2205.14135 arxiv.org/abs/2205.14135
Paragoger衍生者AI训练营。发布者:稻草人,转载请注明出处:https://www.shxcj.com/archives/10379