5.2 注意力的省显存之路:MHA、MQA 与 GQA

本页范围:第 5 章第 2 节 | 整理时间:2026-09-29

快速浏览

核心问题逐 token 生成时,注意力的 KV 缓存随层数、头数、序列长线性膨胀,成为显存占用与显存带宽的双重瓶颈。能否不改注意力的数学形式,只把「存几份 K/V」减下来?
本节主张MHA、MQA、GQA 是同一种注意力的三种存储档位:MQA 让所有查询头共享 1 组 K/V,缓存砍到 1/h 但质量有损;GQA 分组共享,用很小的质量代价换数倍的缓存与速度收益。
一句话结论GQA 把「省不省缓存」变成「省多少」的连续旋钮(GQA-1=MQA,GQA-h=MHA),实测 GQA-8 质量接近 MHA、速度接近 MQA,成为现代开源大模型的主流配置。
关键词
KV CacheMHAMQAGQArepeat_kv显存带宽

  上一节改造的是归一化与前馈,本节轮到注意力本身。不过要动的不是注意力的算法,而是它的存储方式:推理时模型逐 token 生成,每蹦一个 token 都要回头翻全部历史的 K、V,这份 KV 缓存(KV Cache)随层数、头数、序列长线性膨胀,既是显存大户,也是解码速度的瓶颈。本节沿「存几份 K、V」这条主线,把多头注意力(MHA,Multi-Head Attention)的三种存储档位从极端到折中逐一摆开:

  1. 显存瓶颈从哪来:KV 缓存账本(5.2.1):先算清每生成一个 token 要往显存写多少字节,找到最顺手的下刀处;
  2. MQA(Multi-Query Attention,多查询注意力):一刀砍到 1 组(5.2.2):全体查询头合雇一名秘书,缓存缩到 1/h,速度快了,质量却有可测损失;
  3. GQA(Grouped-Query Attention,分组查询注意力):折中的分组艺术(5.2.3):「几个头合看一份」变成连续可调的旋钮,GQA-8 实测质量接近 MHA、速度接近 MQA;
  4. 三者对照:一张表看清(5.2.4):同一套配置下三档缓存、质量与代表模型的全景对照,附接线方式示意图(图 2)。

  读完本节,你应该能独立算出一个模型的 KV 缓存账,并说清为什么 Llama 2/3 和 minimind 都把旋钮停在 GQA 这一档。还想继续往下压,就得改变注意力的结构本身了,那是 5.3 节多头潜在注意力(MLA,Multi-head Latent Attention)的故事。

  第 4 章搭好了 Transformer 块的骨架,本节改造的是块内注意力子层里 K、V 的存储份数,不动注意力算法本身。把注意力子层放大来看,三种方案的差别落在哪?每个 token 到底要往缓存里写多少个数?把 MHA、GQA、MQA 摆到同一把尺上量:

原创示意图 · 非论文原图 局部放大:同一层里,三种方案每个 token 要存进 KV 缓存多少个数(头维度 96,与正文公式同口径) MHA:8 组 K/V 8 个查询头,各自独占一组 8 个查询头(算完不存) 要存的 K/V:8 组 ×(K 96 + V 96) KV1KV2KV3KV4KV5KV6KV7KV8 每层每 token 存 2×768 = 1536 个数 GQA-4:4 组 K/V minimind 默认:每 2 个查询头共享 Q1Q2 一组、Q3Q4 一组……共 4 组 要存的 K/V:4 组 ×(K 96 + V 96) KV1(供 Q1、Q2)KV2(供 Q3、Q4)KV3(供 Q5、Q6)KV4(供 Q7、Q8) 每层每 token 存 2×384 = 768 个数 MQA:1 组 K/V 8 个查询头全体共享 全部头合看同一份 要存的 K/V:1 组 ×(K 96 + V 96) KV(全体共享) 每层每 token 存 2×96 = 192 个数 口径:K、V 各存一份,每份 = K/V 组数 × 头维度 96(minimind 与正文示例同);层数与序列长度对三者是相同倍数,此处只比单层单 token。 缓存越小,每步解码从显存搬运的数据越少:MHA → GQA-4 → MQA 依次减半再除以 4。
图 1:同一层内三种注意力方案每个 token 要存进 KV 缓存的数据量。MHA 存 8 组 K/V,K、V 各 8×96=768 个数,合计 2×768;GQA-4 是 minimind 的默认配置,8 个查询头分 4 组,合计 2×384=768 个数,比 MHA 省一半;MQA 全体共享 1 组,合计 2×96=192 个数。组数就是正文公式 (1) 里的 h_kv,注意力算法本身三者完全一样,差别只在存几份。

5.2.1 显存瓶颈从哪来:KV 缓存账本

  第 4 章讲过,多头注意力(MHA)给每个头配一套独立的 Q、K、V 投影:8 个头就有 8 组 K、V。训练时整段序列一次性算完,K、V 只在单次前向、反向计算里临时存在,不需要长期驻留显存供后续 token 反复查阅,所以没有这份缓存账。但推理阶段模型是一个 token 一个 token 往外蹦的:生成第 100 个 token 时,它要「回头看」前面 99 个 token 的 K、V;生成第 101 个时,又要看前 100 个。若每生成一个 token 都把历史 K、V 重算一遍,计算量将随序列长度平方级浪费。

  工程上的做法很直接:把算过的 K、V 存起来,后续位置直接复用。这份存下来的数据就是 KV 缓存(KV Cache),它是推理提速的关键,也是本节所有优化的靶子。

KV 缓存(KV Cache) Key-Value Cache = 把历史 token 的 K、V 向量存起来反复查阅

自回归生成时,每个历史 token 在每一层都算出过一组 K、V。把它们全部缓存,新 token 只需算自己的 Q(顺带把新的一份 K、V 追加进缓存),就能对全部历史做注意力,不必让历史 token 重跑一遍网络。缓存随四个量线性增长:层数、K/V 头数、头维度、已生成的 token 数。

  缓存到底有多大?以「每生成一个 token 要往缓存追加多少字节」为单位,算一笔细账:

\[ B = 2 \times L \times h_{kv} \times d_{\text{head}} \times s \tag{1} \]
公式 (1):每 token 的 KV 缓存增量。符号说明:\(B\) 是每生成一个 token 要向缓存追加的字节数;2 表示 K、V 各存一份;\(L\) 是层数;\(h_{kv}\) 是 K/V 头数(MHA 中等于查询头数);\(d_{\text{head}}\) 是每个头的维度;\(s\) 是每个数值的字节数(bf16/fp16 为 2 字节)。

  代入一个具体配置:8 个头、头维度 96、16 层、bf16 精度(每个数占 2 字节)的 MHA 模型:

\[ B_{\text{MHA}} = 2 \times 16 \times 8 \times 96 \times 2 = 49{,}152\ \text{B} = 48\ \text{KB} \tag{2} \]
公式 (2):每多生成一个 token,就要多写 48 KB 进显存。一段 4096 token 的对话,仅 KV 缓存就占 48 KB × 4096 ≈ 192 MiB,而这只是个中小尺寸的模型。

  注意公式 (1) 中 \(B\) 与 \(h_{kv}\) 成正比:层数、头维度、精度一时半会动不了,想省缓存,最顺手的下刀处就是 K/V 头数。后面两节正是在这个因子上做文章。

  为什么省缓存等于提速?逐 token 解码时,每生成一个 token 都要把整个 KV 缓存从显存通读一遍,而矩阵计算本身相对快:解码阶段的瓶颈在显存带宽(数据搬运速度)而非算力。缓存越小,每步搬运的数据越少,出字越快。所以 MQA/GQA 的收益是双份的:显存占用下降,解码速度上升。KV Cache 与带宽的系统级展开见第 13 章。

  所以这步在干嘛:推理时模型靠「翻旧账」(读缓存的历史 K、V)避免重复计算,而缓存大小与 K/V 头数成正比。想省显存、提速度,就得在头数上动刀。

5.2.2 MQA:一刀砍到 1 组

  既然账单与 K/V 头数成正比,最狠的省法是让所有查询头共用 1 组 K、V。这就是 Shazeer 2019 年提出的多查询注意力(Multi-Query Attention,MQA):查询侧保持多头不变,每个头有自己的 Q 投影,照样各问各的问题;但 K、V 只剩一份,全体共享。同一配置代入公式 (1):

\[ B_{\text{MQA}} = 2 \times 16 \times 1 \times 96 \times 2 = 6{,}144\ \text{B} = 6\ \text{KB} \tag{3} \]
公式 (3):缓存缩到 MHA 的 1/8(一般地为 1/h)。同样 4096 token 的对话,缓存从 192 MiB 降到 24 MiB。

  代价在哪?多头设计的初衷是让不同的头学会关注不同表示子空间的信息(第 4 章):有的头盯语法搭配,有的头盯指代关系。MHA 里每个头有独立的 K、V,「用什么标签索引信息、读出什么内容」可以各不相同;MQA 里大家挤在同一份 K、V 上各取所需,头的表达多样性打了折扣。沿用会议纪要的比方:MHA 是每人各带一名秘书记笔记,MQA 是 8 个人合雇一名秘书,工资省了 8 倍,但这份笔记不再为任何人量身定做。Shazeer 的实验与后来的工程实践都表明:MQA 的速度收益巨大,质量却会出现可测的下降。

  注意:MQA 的收益与代价都很直白:缓存与带宽省到 1/h,解码显著加快;但所有查询头共享一份 K/V,模型质量有可测损失。头数越多,共享带来的挤压感越强。

  MQA 最著名的应用是 Google 的 PaLM(2022,540B),它证明了 MQA 在超大模型上的工程价值。但对质量更敏感的开源社区没有全盘接受这一刀,而是走向了下一节的折中方案。

  所以这步在干嘛:让 8 个查询头合看同一份笔记。笔记瞬间薄了 8 倍,翻笔记快得多,但每个头读到的内容不再是为它单独准备的。

5.2.3 GQA:折中的分组艺术

  一刀砍到底(MQA)和完全不动(MHA)之间其实是一整个连续谱。Ainslie 等人 2023 年提出的分组查询注意力(Grouped-Query Attention,GQA)把这个谱做成了旋钮:把 \(h\) 个查询头分成 \(g\) 组,组内共享一组 K、V,组数 \(g\) 就是 K/V 头数。

GQA-1(g=1)

全部查询头共享 1 组 K/V,就是 MQA:缓存最省,质量损失最大。

GQA-g(中间档位)

查询头分成 g 组,组内共享一组 K/V:g 越大越接近 MHA,越小越接近 MQA。

GQA-h(g=h)

每个头独占一组 K/V,就是 MHA:质量上限,缓存最贵。

  同一套配置(8 个查询头、头维度 96、16 层、bf16)拧到 g=2 这一档,即 GQA-2(每 4 个查询头合看一组 K/V):

\[ B_{\text{GQA-2}} = 2 \times 16 \times 2 \times 96 \times 2 = 12{,}288\ \text{B} = 12\ \text{KB} \tag{4} \]
公式 (4):缓存是 MHA 的 1/4、MQA 的 4 倍。旋钮拧到哪,账就算到哪,这就是「分组」的全部含义。

  GQA 论文的关键实验结论是:GQA-8 这一档的质量非常接近 MHA,推理速度接近 MQA,两头的好处几乎全拿到。论文还顺手解决了一个工程问题:已训好的 MHA 检查点可以通过少量继续训练转换成 GQA,不必从头预训练(论文标题里 from Multi-Head Checkpoints 说的就是这件事)。落地方面,Llama 2 最大的 70B 模型采用 GQA-8(64 个查询头分 8 组),Llama 3 全系沿用 8 组 K/V;教学工程 minimind 同样使用 GQA(8 个查询头分 4 组,即 GQA-4),其代码实现见 minimind 工程。

  易错点:「GQA-8」里的数字是 K/V 组数,不是每组的头数:Llama 2 70B 的 GQA-8 是 64 个查询头分 8 组,每组 8 个头共享一组 K/V。实现上还要求查询头数能被组数整除,h/g 就是每组 K/V 要服务的查询头数。

  实现上有个直观细节:计算注意力前,会把每组 K、V 复制 h/g 份,「拼」回与查询头相同的数量再照常计算(minimind 里的 repeat_kv 函数干的就是这件事)。所以 MQA/GQA 不改变注意力公式本身,省的是存储与带宽,注意力分数的计算量并没有减少。

  所以这步在干嘛:不再问「要不要共享」,而是问「几个头合看一份」,省显存从一道是非题变成了可微调的挡位题。秘书的比方说到这,折中方案自然是每 4 人合雇一名:笔记薄了 4 倍,读起来却和一人一秘差别不大。

5.2.4 三者对照:一张表看清

  把三种机制放在同一套配置(8 个查询头、头维度 96、16 层、bf16)下对照:

方案K/V 组数每 token 缓存相对 MHA质量代表模型
MHA848 KB1×(基准)基准上限原始 Transformer、GPT-2
GQA-4424 KB1/2接近 MHAminimind(8 查询头分 4 组)
GQA-2212 KB1/4接近 MHA演示档位
MQA16 KB1/8有可测损失PaLM

  Llama 2 70B 的 GQA-8 是同一旋钮上的另一档:64 个查询头分 8 组,缓存同样降到 1/8,而实测质量与 MHA 基本持平。组数越少缓存越小、质量损失越大,这就是三者关系的全部。三者的接线方式看图 2 更直观:

原创示意图 · 非论文原图 MHA(多头注意力) 8 组 K/V,缓存基准 1× Q1 Q2 Q3 Q4 Q5 Q6 Q7 Q8 KV1 KV2 KV3 KV4 KV5 KV6 KV7 KV8 每 token 存 8 组 K/V MQA(多查询注意力) 1 组 K/V,缓存 ÷8 Q1 Q2 Q3 Q4 Q5 Q6 Q7 Q8 KV 存 1 组:最省,质量有损 GQA-4(分组查询注意力) 4 组 K/V,缓存 ÷2 Q1 Q2 Q3 Q4 Q5 Q6 Q7 Q8 KV1 KV2 KV3 KV4 存 4 组:质量接近 MHA 查询头(8 个,算完不存) K/V 组(每个 token 都要存)
图 2:三种注意力中查询头与 K/V 组的连接关系(以 8 个查询头为例)。K/V 组数就是每个 token 要存进 KV 缓存的份数:MHA 存 8 份,GQA-4 存 4 份,MQA 只存 1 份。右图的 GQA-4 正是 minimind 的实际配置。

  MHA、MQA、GQA 是同一种注意力的三种存储档位:KV 缓存与 K/V 组数成正比,质量与组数同向变化。GQA 用约 1/8 的缓存换到接近 MHA 的质量,2023 年以来被 Llama 2/3、minimind 等模型采用,成为主流配置。想继续往下压缓存,就得改变注意力的结构本身:下一节 5.3 的 MLA 走的正是这条路。

🧭本节要点回顾
推理阶段的显存瓶颈具体卡在哪?
每生成一个 token,每层都要把它的 K、V 追加进 KV 缓存,缓存随层数、K/V 组数、头维度、序列长线性增长。解码每步都要通读整个缓存,瓶颈在显存带宽:缓存越小,出字越快。
MQA 把缓存砍到 1/h,为什么没成为最终答案?
它让全体查询头共享同一份 K、V,多头「各看一类信息」的表达多样性被压缩,质量有可测损失。PaLM 证明了它的工程价值,但对质量敏感的场景需要更稳的折中。
GQA 凭什么成为主流?
它把「是否共享 K/V」变成「分几组」的旋钮:GQA-1=MQA、GQA-h=MHA,中间档位连续可调。实测 GQA-8 质量接近 MHA、速度接近 MQA,Llama 2 70B、Llama 3 与 minimind 都采用。

参考来源

  • Vaswani et al., 2017. Attention Is All You Need(MHA 出处,arXiv:1706.03762;§3.2.2 给出 h=8 与多头的子空间动机)。
  • Shazeer, 2019. Fast Transformer Decoding: One Write-Head is All You Need(MQA 原始论文,arXiv:1911.02150)。
  • Ainslie et al., 2023. GQA: Training Generalized Multi-Query Transformer Models from Multi-Head Checkpoints(GQA 原始论文,arXiv:2305.13245;GQA-8 质量接近 MHA、速度接近 MQA 的结论与 MHA 检查点转换方法出自该文)。
  • Touvron et al., 2023. Llama 2: Open Foundation and Fine-Tuned Chat Models(arXiv:2307.09288;70B 采用 GQA-8,即 64 查询头 / 8 组 K/V)。
  • Grattafiori et al., 2024. The Llama 3 Herd of Models(arXiv:2407.21783;全系使用 8 组 K/V 的 GQA)。
  • Chowdhery et al., 2022. PaLM: Scaling Language Modeling with Pathways(arXiv:2204.02311;采用 MQA 的代表模型)。
  • minimind 工程源码 model/model_minimind.py(Apache 2.0):GQA 配置(num_attention_heads / num_key_value_heads)与 repeat_kv 实现。