Skip to content

MQA、GQA 与 MLA:注意力 KV 压缩演进

剖析 KV 带宽瓶颈,推导 MQA、GQA 与 DeepSeek MLA 低秩压缩、矩阵吸收及解耦 RoPE。

当前:讲解模式 — 侧重直觉建立、生活类比与分步拆解快捷键 M 切换
概念定义 · 什么是 MQA、GQA 与 DeepSeek MLA?

大模型生成回复时,必须把前面所有词算过的键(K)和值(V)缓存在显存里(即 KV Cache),否则每吐一个新字都要把整篇上下文重算一遍。随着上下文拉长到几十万字,KV Cache 迅速吃光显存并卡死显存带宽。

MQA、GQA 和 DeepSeek MLA 是压缩 KV Cache 的三代注意力架构演进:核心思路都是让多个查询头 Q 共享或联合压缩同一份更精简的 KV 信息,在几乎不损失模型智力的前提下,把推理显存和带宽消耗削减数倍乃至 90% 以上。

01 问题从何而来:为什么大模型推理会被“记忆包袱”压垮? ​

在标准 多头注意力(MHA) 里,假设模型有 64 个注意力头,每个头都各自存一套独立的 Key 和 Value。训练时所有词并行算完,看着非常舒服;可一旦上线进入逐字吐词的解码(Decode)阶段,噩梦来了。

为了不重复计算前面几万个字,推理引擎必须把历史所有词的 K 和 V 存进显存——这就是 KV Cache。每生成一个新词,GPU 算术单元明明只干了一丁点活,却要从显存里把几十 GB 甚至几百 GB 的历史 KV 缓存全搬出来读一遍!算以 70B 模型处理 128K 上下文为例,光单条请求的 MHA KV Cache 就能吃掉 335 GB 显存,一张 80 GB 的 H100 直接爆显存,GPU 算力利用率常年不到 5%——彻底卡死在“显存带宽墙”上。

类比 · 图书馆的复印包袱:从 MHA 到 MQA、GQA 再到 MLA

把每个注意力头想象成去图书馆查资料的读者,历史 KV Cache 就是整座图书馆的藏书:

  • MHA(每人全套复印):64 位读者每人把整馆藏书完整复印一份塞进自己书包。查起来最爽,但书包重得根本背不动。
  • MQA(全员合看一套书):Shazeer(2019)↗ 提出 64 位读者只共用图书馆里唯一一套藏书(nkv=1)。书包瞬间轻了 64 倍,可大家被迫用同一套索引视角看书,容易“抢书”,模型理解力明显下滑。
  • GQA(按学习小组分书):Ainslie 等人(2023)↗ 折中把 64 位读者分成 8 个小组,每 8 人共用一套书。既把缓存砍掉 8 倍,又几乎不掉点,迅速成为 LLaMA-3、Qwen2.5 的工业标配。
  • MLA(浓缩密码摘要本 + 专属解码镜片):DeepSeek-V2(2024)↗ 换了个完全不同的思路——不删读者视角,而是把整套书压缩成一本极薄的低秩密码摘要本(潜向量 ctKV),只存这本薄册子;等每位读者来查时,再透过自己专属的“解码镜片”(上投影矩阵)把同一本摘要本看成各自不同的完整藏书!
核心设问

压缩 KV Cache 似乎总在“省显存”和“保精度”之间二选一:能不能像 MQA 一样把缓存压到极致,同时在计算时还保留像 MHA 一样每个头独一无二的丰富表达?

02 核心直觉:MLA 的两大魔法——矩阵吸收与解耦 RoPE ​

听到“先压缩成薄册子,查的时候再还原成大书”,敏锐的你肯定会立刻质疑:那解码时每步还要把几万本薄册子重新解压回高维 K,V,算力和显存不又涨回去了吗?

DeepSeek 团队用初中就学过的矩阵乘法结合律变出了一招神技——矩阵吸收(Matrix Absorption)。

类比 · 别去翻译整座图书馆,把你的检索条翻译成密码!

原本的做法是:手里拿着明文检索条 q,对着书架上 10 万本“密码摘要本” cjKV,先把 10 万本摘要本逐一乘以解压矩阵 WUK 翻译成明文,再去和 q 匹配——累个半死。

矩阵吸收反其道而行之:既然 (q⊤)(WUKcjKV)=(q⊤WUK)cjKV,那为什么不直接把解压矩阵 WUK 提前乘到我手里这 1 张检索条 q 上,把我的检索条变成“密码格式”,然后直接拿它去和密码摘要本做点积?

同理,从密码本里按权重捞出一份混合摘要后,也不用先解压 10 万次再相加,直接先把混合摘要算出来,最后一步再把解压矩阵 WUV 和输出矩阵 WO 合并起来统一翻译回明文!整趟解码过程全程在极低维的潜空间完成,一次高维 K,V 都不用还原。

可刚高兴没两秒,一个致命的拦路虎出现了:RoPE 旋转位置编码 挡在了中间! 如果给还原后的 q 和 k 施加旋转矩阵,旋转矩阵 RΘ,t−j 会死死卡在 q⊤ 和 WUK 之间,因为矩阵乘法不满足交换律,WUK 根本越不过旋转矩阵被吸收走。

类比 · 解耦 RoPE:给内容和位置分两张独立的纸条

DeepSeek 的破局办法极其干脆:既然内容压缩和位置旋转放一起会打架,那就把它俩彻底拆家!

给每个注意力头切出两段通道:主体大段通道(NoPE)完全不做 RoPE 旋转,安心走低秩压缩和矩阵吸收;旁边再额外附带一小段专门负责位置的通道(64 维),所有头共享同一份旋转后的位置键 ktR。算点积时,内容分加位置分,井水不犯河水——既完美保住了矩阵吸收,又拿回了 RoPE 的相对位置能力。

03 把关键公式读成人话 ​

先看 MLA 把内容投影“吸收”进 Query 的核心代数魔法:

(qt,iC)⊤kj,iC=(qt,iC)⊤(WiUKcjKV)=((WiUK)⊤qt,iC)⊤cjKV

**把公式读成直觉:**等号左边是传统思路:把缓存里的薄摘要 cjKV 乘上 WiUK 还原成胖键向量 kj,iC,再和当前查询 qt,iC 做内积;等号右边只是换了个括号的位置:先把 WiUK 折叠进当前这唯一一个词元的查询里,算出“潜空间查询向量”,就能直接跟缓存里超薄的 cjKV 做点积!对 V 的上投影 WiUV 也是如法炮制,直接吸收进输出矩阵 WiO。

再看加上解耦 RoPE 之后的完整注意力打分:

qt,i⊤kj,i=(qt,iC)⊤kj,iC⏟内容打分:矩阵吸收,只读 cjKV+(qt,iR)⊤kjR⏟位置打分:共享 kjR 独立旋转

**为什么缓存一下缩小了 93% 以上?:**以 DeepSeek-V2/V3(128 个头、每头 128 维)为例:传统 MHA 每层每词元要存 2×128×128=32768 个数;MLA 只需要把压缩潜向量 ctKV(512 维)和共享位置键 ktR(64 维)拼在一起存下,总共才 576 个数——缓存体积暴跌到原来的 不到 2%(压缩率超过 93.3%,甚至比 2.25 个 KV 头的 GQA 还省),而且实测效果反而强于原生 MHA!

04 它在模型里怎么工作 & 与上下游的关系 ​

KV 压缩架构处在 自注意力 与推理系统的交汇点上,直接决定长文本服务的商业成本:

  • 与位置编码的深度耦合:MLA 为了保住矩阵吸收被迫发明了解耦 RoPE,而在超长上下文外推时依然可以无缝叠加 RoPE 的 YaRN 外推 策略。
  • 与推理系统正交叠加:GQA / MLA 是算法结构级的 KV 瘦身,它可以和系统级的 PagedAttention 分页缓存 以及数值级的 KV Cache FP8/INT4 量化 叠加使用,把 长上下文推理 的并发吞吐推升一个数量级。
  • 与 MoE 组成旗舰搭档:在 DeepSeek-V3(2024)↗ 中,MLA 负责打穿解码期的显存带宽墙,而 细粒度 MoE 负责打穿计算量墙,二者共同把 671B 模型的推理成本压到了不可思议的水平;同时也有如 TransMLA(2025)↗ 的研究探索把现有 GQA 权重直接迁移转换为 MLA。

05 演化对比:四代注意力怎么选? ​

不同压缩方案在显存体积、表达力与工程复杂度上各有侧重:

架构每层每词元缓存元素相对 MHA 压缩比模型表达力工业代表
MHA2nhdh1×强(基准)GPT-3, LLaMA-1
GQA2Gdh4×∼8×几乎无损LLaMA-3, Qwen2.5, Mistral
MQA2dhnh×有明显损失PaLM, Falcon
MLAdc+dhR15×∼56×优于 MHADeepSeek-V2 / V3

如何快速选型?如果你追求生态最成熟、零定制算子直接跑 FlashAttention,选 GQA(如 8 个 KV 头)依然是最稳妥的工程方案;如果你正在攻坚百 K 超长上下文和高并发低成本推理,且具备编写或接入 FlashMLA 算子的能力,MLA 带来的 93% 缓存瘦身会直接改写单位 Token 的成本曲线。

06 三个最容易踩的工程坑 ​

  1. Prefill 和 Decode 要走两条不同的路:在预填充(Prefill)阶段一次算几万个词,走矩阵吸收反而会重复投影降低算力效率;生产引擎(vLLM / SGLang)通常在 Prefill 走展开路径吃满 FlashAttention,在 Decode 切换成矩阵吸收路径(配合 FlashMLA) 省爆显存带宽。
  2. 缓存前必须先过 kv_norm:DeepSeek 在潜向量 ctKV 后加了一层 RMSNorm 稳住低秩梯度。注意一定要把归一化之后的 ctKV 存进缓存,千万不能存归一化前的原始向量,否则非线性的 Norm 会卡死矩阵吸收。
  3. 缩放分母别漏算位置维度,且核对 GQA 分组顺序:MLA 拼接内容与解耦 RoPE 后,单头真实长度变成 dh+dhR(如 128+64=192),缩放因子必须用 1/dh+dhR;而在 GQA 跨框架导权重时,务必核对 KV 头是连续复制还是交错映射,避免头索引错位。

想查看矩阵吸收的完整矩阵分块推导、MLA 双分支数据流图,以及同时验证“展开路径 vs 吸收路径”零误差的 PyTorch 实现?按快捷键 M 或点击顶部 技术 Wiki 随时切换。

在标准 多头注意力(MHA) 中,每个注意力头都维护独立的 Key 与 Value 投影。这一设计在训练和预填充(Prefill)阶段并行度极高,却在自回归解码(Decode)阶段暴露出致命缺陷——庞大的 KV Cache 显存占用与显存带宽瓶颈。从 MQA(Multi-Query Attention)、GQA(Grouped-Query Attention) 到 DeepSeek 提出的 MLA(Multi-Head Latent Attention),注意力架构沿着“用极少缓存保留高表达力”的脉络完成了代际跃迁,并与 解耦 RoPE、细粒度 MoE 及 长上下文推理 深度协同。

直观理解

如果把 MHA 比作每位读者(Query 头)都必须把整座图书馆的书(KV Cache)各复印一份放进自己书包,那么 MQA 就是所有人只共用图书馆里唯一的一套藏书(极省空间,但容易“抢书”导致理解单一);GQA 折中为按小组分书;而 MLA 则是把整套书高度浓缩成一本极薄的“密码摘要本”(低秩潜向量 cKV),每位读者拿取摘要本后,用自己专属的“解码镜片”(上投影矩阵,且可提前合并进 Q 与 O 矩阵)还原出各不相同的视角。

问题动机与演进背景 ​

在自回归解码阶段,模型每生成一个新词元仅计算 1 个 Query 向量,却必须从 GPU 高带宽显存(HBM)中完整读取前面 N 个历史词元对应的全部 KV Cache。对于一个层数为 L、头数为 nh、头维度为 dh、精度为 BF16(2 字节)的 MHA 模型,单个请求长度为 N 的 KV Cache 显存占用为:

MemoryKVMHA=2⋅L⋅nh⋅dh⋅N⋅2 Bytes

以 70B 级模型(L=80,nh=64,dh=128)为例,在 N=128K 上下文下,单条请求的 MHA KV Cache 高达 335 GB,直接超过单张 H100(80 GB)显存容量!同时,解码步的算术强度(Arithmetic Intensity,FLOPs/Byte)极低,计算核心长期处于显存带宽受限(Memory-Bound) 状态,GPU 利用率不足 5%。

为打破这一瓶颈,架构经历了三个演进阶段:

  1. MQA(Shazeer, 2019):所有 nh 个 Query 头共享同一组 Key 和 Value 头(nkv=1),KV Cache 直接缩小 nh 倍。但过度共享导致训练不稳定且模型质量显著下降(早期 PaLM、Falcon、StarCoder 采用)。
  2. GQA(Ainslie et al., 2023):将 nh 个 Query 头划分为 G 个小组(1<G<nh),每组 nh/G 个 Query 头共享一组 KV。GQA 在几乎不损失模型精度的前提下将 KV Cache 压缩 nh/G 倍(通常 4×∼8×),成为 LLaMA-2/3、Qwen2.5、Mistral 等开源模型的标配。
  3. MLA(DeepSeek-V2/V3, 2024):跳出“直接减少头数”的思路,引入低秩联合键值压缩(Low-Rank Key-Value Joint Compression) 与矩阵吸收(Matrix Absorption),在缓存体积小于甚至媲美 MQA 的同时,在推理计算中仍保持完整多头的独立表达力,实测效果反而超越标准 MHA。

核心原理与数学推导 ​

GQA 的数学表述 ​

设 Query 头数为 nh,KV 头数为 nkv=G,分组倍率 g=nh/G。对第 i 个 Query 头(i∈{1,…,nh}),其索引所属的 KV 组号为 k(i)=⌈i/g⌉:

Q(i)=XWQ(i),K(k(i))=XWK(k(i)),V(k(i))=XWV(k(i))

当 G=nh 时退化为 MHA;当 G=1 时退化为 MQA。训练时可通过对原 MHA 预训练权重的 KV 头按组求均值(Mean-Pooling)快速“Uptraining”转换为 GQA。

MLA 核心原理一:低秩联合压缩与矩阵吸收 ​

给定第 t 步输入隐状态 ht∈Rd,MLA 不再直接缓存高维的 kt,vt∈Rnhdh,而是先将其联合下投影至一个极低维的共享潜向量(Latent Vector) ctKV∈Rdc(其中 dc≪nhdh,例如 DeepSeek-V2 中 nhdh=16384 而 dc=512):

ctKV=WDKVht∈Rdc

随后通过各自的上投影矩阵还原所有头所需的 Key 与 Value(下标 C 表示 Content 内容部分):

ktC=WUKctKV∈Rnhdh,vtC=WUVctKV∈Rnhdh

(为降低训练激活显存,MLA 同样对 Query 执行低秩压缩:ctQ=WDQht∈Rdc′,qtC=WUQctQ。)

关键推导:推理时的矩阵吸收(Matrix Absorption)

推理阶段,KV Cache 仅需缓存低维向量 ctKV。若在解码时显式将 ctKV 乘以 WUK,WUV 还原出 ktC,vtC,计算量依然很大。MLA 巧妙利用矩阵乘法结合律,将上投影矩阵直接“吸收”进 Query 和输出权重中。

对第 i 个注意力头,其与历史第 j 步的注意力打分点积为:

(qt,iC)⊤kj,iC=(WiUQctQ)⊤(WiUKcjKV)=(ctQ)⊤((WiUQ)⊤WiUK)⏟可离线合并的等效矩阵cjKV=((WiUK)⊤qt,iC)⊤cjKV

同理,对于加权求和后的输出投影(记 WiO 为 WO 对应第 i 头的列分块):

∑j=1tαt,j(i)WiOvj,iC=∑j=1tαt,j(i)WiOWiUVcjKV=(WiOWiUV)⏟吸收进输出权重(∑j=1tαt,j(i)cjKV)

通过这一变换,解码阶段完全无需物化高维的 kjC 与 vjC,注意力得分与加权聚合直接在潜空间 cjKV 上完成!

MLA 核心原理二:解耦旋转位置编码(Decoupled RoPE) ​

上述矩阵吸收有一个致命障碍:RoPE 位置编码与矩阵吸收不兼容。因为若对 qtC,kjC 施加旋转矩阵 RΘ,t,RΘ,j,则点积变为:

(qt,iC)⊤RΘ,t−jWiUKcjKV

由于 RΘ,t−j 随相对位置 t−j 变化,且矩阵乘法不满足交换律,WiUK 被夹在中间,无法越过 RΘ,t−j 被左侧吸收!

DeepSeek 提出解耦 RoPE(Decoupled RoPE) 巧妙化解此矛盾:为每个头额外分配少量专门携带位置信息的维度 dhR(如 dhR=64),而键的位置部分由所有头共享(即 MQA 风格缓存单头 ktR∈RdhR):

qt,iR=RoPE(WiQRctQ)∈RdhR,ktR=RoPE(WKRht)∈RdhR

最终每个头的 Query 与 Key 通过拼接内容部分与位置部分构成:

qt,i=[qt,iC;qt,iR]∈Rdh+dhR,kj,i=[kj,iC;kjR]∈Rdh+dhR

展开点积后,内容项与位置项完全解耦相加:

qt,i⊤kj,i=(qt,iC)⊤kj,iC⏟应用矩阵吸收,仅需 cjKV+(qt,iR)⊤kjR⏟独立 RoPE 位置打分,仅需共享 kjR

因此,每层每词元的完整 KV Cache 仅需存储两个极小向量:[ctKV;ktR]∈Rdc+dhR(在 DeepSeek-V2/V3 中仅为 512+64=576 维,等效于仅有 2.25 个 GQA KV 头的体量,压缩率高达 93.3% 以上)。

算法架构与数据流图 ​

下图展示了 MLA 的双分支(低秩内容压缩分支 + 解耦 RoPE 位置分支)与推理缓存路径:

图表加载中...

复杂度与横向对比表 ​

以单层单词元、隐维度 d、头数 nh、头维度 dh 为基准,比较四大注意力变体:

注意力机制每层每词元 KV Cache 元素数代表模型及压缩比(相对 MHA)表达能力推理计算特点
MHA2nhdhGPT-3, LLaMA-1 (1×)强(基准)HBM 带宽严重受限,长上下文极易 OOM
GQA2GdhLLaMA-3 (4×∼8×), Qwen2.5接近 MHA实现极简,完美兼容现有 FlashAttention 核
MQA2dhPaLM, Falcon (nh×)明显弱于 MHA极低显存,但微调与长推理精度有损
MLAdc+dhRDeepSeek-V2/V3 (≈15×∼28×)优于 MHA需结合矩阵吸收与定制 MLA 算子(如 FlashMLA)

DeepSeek-V2 实测数据参考:nh=128,dh=128 时,MHA 每层每词元需缓存 32768 个标量;MLA 取 dc=512,dhR=64,仅需缓存 576 个标量,压缩率达 56.9 倍(若与同等头数 dh=128 的 GQA 对比,仅相当于 2.25 个 KV 头的显存开销)。

核心 PyTorch 参考实现 ​

下面给出完整可运行的 MLA 核心模块实现,涵盖训练/Prefill 标准路径以及显式展示矩阵吸收思想的推理路径校验:

python
import math
import torch
import torch.nn as nn
import torch.nn.functional as F


def apply_rope(x: torch.Tensor, cos: torch.Tensor, sin: torch.Tensor) -> torch.Tensor:
    # x: [B, H, N, d_r], cos/sin: [1, 1, N, d_r // 2]
    x1, x2 = x[..., ::2], x[..., 1::2]
    rotated = torch.stack([x1 * cos - x2 * sin, x1 * sin + x2 * cos], dim=-1)
    return rotated.flatten(-2)


class MultiHeadLatentAttention(nn.Module):
    def __init__(
        self,
        d_model: int = 512,
        n_heads: int = 8,
        d_c_q: int = 192,
        d_c_kv: int = 128,
        d_h_nope: int = 64,
        d_h_rope: int = 32,
    ):
        super().__init__()
        self.n_heads = n_heads
        self.d_c_kv = d_c_kv
        self.d_h_nope = d_h_nope  # 内容头维度 d_h
        self.d_h_rope = d_h_rope  # 解耦 RoPE 位置维度 d_h^R
        self.scale = 1.0 / math.sqrt(d_h_nope + d_h_rope)

        # Query 低秩压缩与上投影
        self.w_dq = nn.Linear(d_model, d_c_q, bias=False)
        self.q_norm = nn.RMSNorm(d_c_q)
        self.w_uq = nn.Linear(d_c_q, n_heads * d_h_nope, bias=False)
        self.w_qr = nn.Linear(d_c_q, n_heads * d_h_rope, bias=False)

        # KV 联合低秩压缩与上投影 + 共享位置键
        self.w_dkv = nn.Linear(d_model, d_c_kv, bias=False)
        self.kv_norm = nn.RMSNorm(d_c_kv)
        self.w_uk = nn.Linear(d_c_kv, n_heads * d_h_nope, bias=False)
        self.w_uv = nn.Linear(d_c_kv, n_heads * d_h_nope, bias=False)
        self.w_kr = nn.Linear(d_model, d_h_rope, bias=False)

        self.w_o = nn.Linear(n_heads * d_h_nope, d_model, bias=False)

    def forward_standard(self, x: torch.Tensor, cos: torch.Tensor, sin: torch.Tensor):
        """训练与 Prefill 标准路径:展开 K, V 利用 FlashAttention 高吞吐计算"""
        B, N, _ = x.shape
        c_q = self.q_norm(self.w_dq(x))  # [B, N, d_c_q]
        q_c = self.w_uq(c_q).view(B, N, self.n_heads, self.d_h_nope).transpose(1, 2)
        q_r = self.w_qr(c_q).view(B, N, self.n_heads, self.d_h_rope).transpose(1, 2)
        q_r = apply_rope(q_r, cos, sin)

        c_kv = self.kv_norm(self.w_dkv(x))  # [B, N, d_c_kv] -> 需缓存
        k_c = self.w_uk(c_kv).view(B, N, self.n_heads, self.d_h_nope).transpose(1, 2)
        v_c = self.w_uv(c_kv).view(B, N, self.n_heads, self.d_h_nope).transpose(1, 2)

        # 共享 RoPE Key: [B, 1, N, d_h_rope] -> 需缓存,广播至所有头
        k_r = apply_rope(self.w_kr(x).unsqueeze(1), cos, sin)
        k_r_exp = k_r.expand(-1, self.n_heads, -1, -1)

        q = torch.cat([q_c, q_r], dim=-1)       # [B, H, N, d_h + d_r]
        k = torch.cat([k_c, k_r_exp], dim=-1)   # [B, H, N, d_h + d_r]

        scores = torch.matmul(q, k.transpose(-2, -1)) * self.scale
        mask = torch.triu(torch.ones(N, N, device=x.device, dtype=torch.bool), diagonal=1)
        scores = scores.masked_fill(mask, float("-inf"))
        attn = F.softmax(scores, dim=-1, dtype=torch.float32).to(x.dtype)

        out = torch.matmul(attn, v_c).transpose(1, 2).contiguous().view(B, N, -1)
        return self.w_o(out), (c_kv, k_r)

    def forward_absorbed_decode(
        self,
        x_last: torch.Tensor,
        cache: tuple[torch.Tensor, torch.Tensor],
        cos_last: torch.Tensor,
        sin_last: torch.Tensor,
    ) -> torch.Tensor:
        """解码期矩阵吸收路径:直接对缓存的 c_kv 与 k_r 计算,零 K/V 显存还原"""
        B, _, _ = x_last.shape
        c_kv_cache, k_r_cache = cache  # [B, N, d_c_kv], [B, 1, N, d_h_rope]

        c_q = self.q_norm(self.w_dq(x_last))
        q_c = self.w_uq(c_q).view(B, 1, self.n_heads, self.d_h_nope).transpose(1, 2)
        q_r = apply_rope(
            self.w_qr(c_q).view(B, 1, self.n_heads, self.d_h_rope).transpose(1, 2),
            cos_last,
            sin_last,
        )

        # 吸收 W_UK 至 Query: q_absorbed = q_c @ W_UK (按头投影到潜空间 d_c_kv)
        w_uk = self.w_uk.weight.view(self.n_heads, self.d_h_nope, self.d_c_kv)
        q_absorbed = torch.einsum("bhnd,hdc->bhnc", q_c, w_uk)  # [B, H, 1, d_c_kv]

        # 内容打分 + 位置打分(直接在低维潜空间完成)
        score_c = torch.einsum("bhnc,bmc->bhnm", q_absorbed, c_kv_cache)
        score_r = torch.matmul(q_r, k_r_cache.transpose(-2, -1))
        attn = F.softmax((score_c + score_r) * self.scale, dim=-1)  # [B, H, 1, N]

        # 在潜空间直接聚合 c_kv,再吸收 W_UV 投影回每个头
        latent_out = torch.einsum("bhnm,bmc->bhnc", attn, c_kv_cache)  # [B, H, 1, d_c_kv]
        w_uv = self.w_uv.weight.view(self.n_heads, self.d_h_nope, self.d_c_kv)
        out = torch.einsum("bhnc,hdc->bhnd", latent_out, w_uv)  # [B, H, 1, d_h_nope]
        return self.w_o(out.transpose(1, 2).contiguous().view(B, 1, -1))


if __name__ == "__main__":
    torch.manual_seed(0)
    mla = MultiHeadLatentAttention()
    x = torch.randn(2, 12, 512)
    pos = torch.arange(12).float().unsqueeze(-1)
    freqs = pos / (10000 ** (torch.arange(0, 32, 2).float() / 32))
    cos, sin = freqs.cos()[None, None], freqs.sin()[None, None]

    out_std, cache = mla.forward_standard(x, cos, sin)
    out_abs = mla.forward_absorbed_decode(x[:, -1:], cache, cos[:, :, -1:], sin[:, :, -1:])
    diff = (out_std[:, -1:] - out_abs).abs().max().item()
    print(f"标准路径与矩阵吸收路径最大数值误差: {diff:.2e}")

工程实践与常见陷阱 ​

工程实践

  1. Prefill 与 Decode 双路径切换:在 Prefill 阶段,矩阵吸收反而会增加 cjKV 的跨头重复计算并丧失常规 FlashAttention 支持;因此在生产推理引擎(如 vLLM、SGLang)中,通常在 Prefill 阶段走展开路径,而在 Decode 阶段走矩阵吸收路径(配合 FlashMLA Kernel),实现算力与带宽的双重最优。
  2. 潜向量归一化不可或缺:DeepSeek-V2/V3 在 ctQ 与 ctKV 之后均紧接了一层 RMSNorm(代码中 q_norm 与 kv_norm),用于稳定低秩瓶颈处的梯度尺度;注意归一化必须发生在缓存之前,否则会破坏吸收线性性。
  3. 张量并行(TP)下的缓存冗余权衡:在 GQA 中,当张量并行度大于 G 时需在多卡间复制 KV 头;而在 MLA 中,缓存的 ctKV 本身维度极低,即便在每张 TP 卡上完整复制一份 ctKV,其显存占用依然远小于 MHA。

常见陷阱

  1. 吸收路径忘记同步处理 kv_norm:若把未经过 kv_norm 的原始 w_dkv(x) 存入缓存,则解码时无法把非线性 RMSNorm 吸收进矩阵乘法,必须缓存归一化之后的 ctKV。
  2. Softmax 缩放系数维度算错:解耦 RoPE 拼接后,有效 Query/Key 向量长度为 dh+dhR,缩放因子必须是 1/dh+dhR 而非 1/dh;此外在长上下文 YaRN 外推时,还需对缩放因子乘以温度修正系数 mscale。
  3. 混淆 GQA 的分组索引顺序:部分框架(如 HuggingFace Transformers)使用 repeat_interleave(g, dim=1) 将第 k 组 KV 连续复制到相邻头,而部分内核使用步长交错排列,转换权重或对接推理引擎时务必校验头映射一致性。

延伸阅读与参考论文 ​

  • MQA 奠基:Shazeer, Fast Transformer Decoding: One Write-Head is All You Need, arXiv:1911.02150 ↗, 2019.
  • GQA 提出:Ainslie et al., GQA: Training Generalized Multi-Query Transformer Models from Multi-Head Checkpoints, EMNLP 2023 (arXiv:2305.13245 ↗).
  • MLA 首发:DeepSeek-AI, DeepSeek-V2: A Strong, Economical, and Efficient Mixture-of-Experts Language Model, 2024 (arXiv:2405.04434 ↗).
  • MLA 规模化工程实践:DeepSeek-AI, DeepSeek-V3 Technical Report, 2024 (arXiv:2412.19437 ↗).
  • 从 GQA 向 MLA 迁移转换:Ji et al., Towards Economical Inference: Enabling DeepSeek's Multi-Head Latent Attention in Any Transformer-based LLMs (TransMLA), 2025 (arXiv:2502.07864 ↗).