注意力机制的进化：MHA → GQA → MLA → CSA → HCA

本文梳理大语言模型（LLM）核心组件"注意力机制"的演进主线：

复制代码

MHA  (Multi-Head Attention)           多头注意力
 └─ GQA (Grouped-Query Attention)     分组查询注意力
     └─ MLA (Multi-head Latent Attention)  多头潜在注意力
         ├─ CSA (Compressed Sparse Attention)   压缩稀疏注意力
         └─ HCA (Heavily Compressed Attention)  重度压缩注意力

前三个阶段（MHA → GQA → MLA）的核心问题是：如何让每个 token 的 KV 表示更窄、更省缓存------即沿着"宽度/特征维度"压缩。

后两个阶段（CSA / HCA）的思路发生了跃迁：如何让上下文在"长度/时间维度"上更短------把连续多个 token 的 KV 合并为一条，从而支撑百万级上下文。

理解这条路线，本质上是理解大模型在"表达能力"与"推理成本（显存 + 带宽 + 计算）"之间的持续博弈。

1. 背景：注意力与 KV Cache 问题

1.1 缩放点积注意力

Transformer 的核心是缩放点积注意力（Scaled Dot-Product Attention）：

Attention ( Q , K , V ) = s o f t m a x ⁣ ( Q K T d k ) V \text{Attention}(Q, K, V) = \mathrm{softmax}\!\left(\frac{Q K^{T}}{\sqrt{d_k}}\right) V Attention(Q,K,V)=softmax(dk QKT)V

其中 Q , K , V Q, K, V Q,K,V 分别是查询（Query）、键（Key）、值（Value）矩阵， d k d_k dk 是每个头的维度。softmax 对每一行的所有位置进行归一化，使每个查询 token 能够"按照相关性"聚合所有位置的 value。

多头注意力（MHA）将其重复 h h h 次并拼接：

MultiHead ( Q , K , V ) = C o n c a t ( head 1 , ... , head h ) W O \text{MultiHead}(Q, K, V) = \mathrm{Concat}(\text{head}_1, \dots, \text{head}_h)\, W^{O} MultiHead(Q,K,V)=Concat(head1,...,headh)WO

head i = Attention ( Q W i Q , K W i K , V W i V ) \text{head}_i = \text{Attention}(Q W_i^{Q},\; K W_i^{K},\; V W_i^{V}) headi=Attention(QWiQ,KWiK,VWiV)

设模型隐层维度为 d model d_{\text{model}} dmodel、注意力头数为 h h h、每个头维度 d h = d model / h d_h = d_{\text{model}} / h dh=dmodel/h。

1.2 推理中的 KV Cache

自回归解码时，模型逐 token 生成。为了避免每个新 token 都重新计算历史位置的 K、V，推理框架会把每层、每个历史 token 的 K、V 缓存起来，即 KV Cache。

对标准 MHA，每个 token、每一层 需要缓存 2 ⋅ h ⋅ d h = 2 ⋅ d model 2 \cdot h \cdot d_h = 2 \cdot d_{\text{model}} 2⋅h⋅dh=2⋅dmodel 个元素（K、V 各一半）。
对 L L L 层、上下文长度 N N N，单 batch 的 KV Cache 为 2 L N d model 2 L N d_{\text{model}} 2LNdmodel 个元素（以 bf16 计，每个元素 2 字节，再乘 2）。

推理分两个阶段：

Prefill（预填充）：一次性输入全部 prompt，计算规模大，处于算力（compute）瓶颈。
Decode（逐 token 解码） ：每生成一个 token，都要读取整份 KV Cache 并做一次注意力，处于显存带宽（memory bandwidth）瓶颈 。每 token 的计算量约为 O ( N ) O(N) O(N)。

因此在长上下文场景下，KV Cache 的显存占用和每次解码的内存搬运，成为首要瓶颈。围绕它的优化由此形成两条主线。

1.3 两条优化主线

主线	思路	代表
宽度压缩：让每个 token 的 KV 更小	共享头（MQA/GQA）、低秩压缩（MLA）	MQA → GQA → MLA
长度压缩：让上下文的 token 数更少	滑动窗口、稀疏、按块压缩	CSA → HCA

下文的演进正是沿着这两条主线展开。

2. MHA：多头注意力（基线）

出处：Vaswani et al., Attention Is All You Need（2017）。

结构

把 d model d_{\text{model}} dmodel 维的 Q、K、V 投影成 h h h 组，每组维度 d h d_h dh，各自独立计算注意力，再拼接、投影回 d model d_{\text{model}} dmodel。
每个头学习不同的内容子空间（例如有的头关注语法、有的关注位置、有的关注实体），提高表达能力。

KV Cache 与复杂度

每 token 每层缓存： 2 h d h = 2 d model 2 h d_h = 2 d_{\text{model}} 2hdh=2dmodel。
单 token 注意力计算： O ( h ⋅ d h ⋅ N ) = O ( d model N ) O(h \cdot d_h \cdot N) = O(d_{\text{model}} N) O(h⋅dh⋅N)=O(dmodelN)。

优点

表达力最强，多个子空间并行捕获不同关系。
是后续一切变体的"对照基线"。

问题

KV Cache 与头数成正比，长上下文时显存线性爆炸。
Decode 阶段内存带宽受限，头数越多、读写越多，速度越慢。

MHA 本身没有做任何压缩，是最"贵"但也最"准"的上限参考。

3. GQA：分组查询注意力

出处：Ainslie et al., GQA: Training Generalized Multi-Query Transformer Models from Multi-Head Checkpoints （2023）；其前身是 MQA（Multi-Query Attention）（Shazeer, 2019）。

3.1 铺垫：MQA

MQA 的思路非常直接------所有查询头共享同一份 K 和 V：

每 token 每层只需缓存 2 d h 2 d_h 2dh（只有 1 个 KV 头）。
解码时读取的 KV 数据量大幅下降，速度更快、显存更省。
代价是注意力多样性受损，训练可能不稳定，质量相对 MHA 略有下降。

3.2 GQA：在 MHA 与 MQA 之间取折中

GQA 把 h h h 个查询头分成 G G G 组，每组共享一个 K、V 头 ，得到 n k v = G n_{kv} = G nkv=G 个 KV 头：

Query 头个数： h h h（保持不变，表达力依旧丰富）。
KV 头个数： G G G，满足 1 ≤ G ≤ h 1 \le G \le h 1≤G≤h。
当 G = 1 G = 1 G=1 时退化为 MQA；当 G = h G = h G=h 时退化为 MHA。

head i = Attention ⁣ ( Q W i Q , K W ⌊ i ⋅ G / h ⌋ K , V W ⌊ i ⋅ G / h ⌋ V ) \text{head}i = \text{Attention}\!\left(Q W_i^{Q},\; K W{\lfloor i \cdot G / h \rfloor}^{K},\; V W_{\lfloor i \cdot G / h \rfloor}^{V}\right) headi=Attention(QWiQ,KW⌊i⋅G/h⌋K,VW⌊i⋅G/h⌋V)

即第 i i i 个查询头复用其所属分组的共享 K、V。

3.3 缓存与复杂度

每 token 每层缓存： 2 G d h = 2 n k v d h 2 G d_h = 2 n_{kv} d_h 2Gdh=2nkvdh。
相比 MHA 缩小到 G / h = n k v / h G / h = n_{kv} / h G/h=nkv/h 倍。
注意力计算量渐进相同（ O ( d model N ) O(d_{\text{model}} N) O(dmodelN)），但内存读写量下降，解码吞吐显著提升。

3.4 从 MHA 检查点快速迁移

GQA 论文给出了实用的 uptraining 方案：从已训好的 MHA 检查点出发，对同组的多个 K、V 头做均值池化作为共享头的初始化，再用原始预训练量的很小比例继续训练，即可接近全量训练质量，显著降低迁移成本。

3.5 典型配置与权衡

Llama-3/3.1 8B： G = 4 G=4 G=4；Llama-2/3 70B： G = 8 G=8 G=8（ n k v = 8 n_{kv}=8 nkv=8）。
Qwen、Mistral 等大量开源模型也采用 GQA。
结论： G G G 越小越省缓存、越快，但质量下降越明显；实践中 n k v ∈ $1 , 8$ n_{kv} \in $1,8$ nkv∈ $1,8$ 时通常质量损失很小。

局限：GQA 的本质只是"少存几个 KV 头"，上下文长度没有变，KV Cache 依旧随 N N N 线性增长。

4. MLA：多头潜在注意力

出处：DeepSeek-V2（2024），论文 DeepSeek-V2: A Strong, Economical, and Efficient Mixture-of-Experts Language Model。后被 DeepSeek-V3 / R1 沿用。

4.1 动机

MQA / GQA 通过"共享 KV 头"减少缓存，但会损失多头之间的多样性，且压缩程度受头数限制。MLA 换了一个更根本的思路：

与其共享头，不如把"所有头的 K、V 联合起来"做低秩压缩，只缓存一个很小的潜在向量（latent），需要时再即时还原。

由于 K、V 都来自同一输入 token 的线性投影，它们之间高度冗余，完全可以被一个远小于 2 h d h 2 h d_h 2hdh 的潜在向量近似表示。MLA 正是利用这一点，把 KV Cache 的体积压缩到原来的百分之几。

4.2 低秩联合压缩

对第 t t t 个 token 的隐状态 h t h_t ht，先下投影到一个 d c d_c dc 维的潜在向量：

c t K V = W D K V h t ∈ R d c , d c ≪ h ⋅ d h c_t^{KV} = W^{DKV} h_t \in \mathbb{R}^{d_c}, \qquad d_c \ll h \cdot d_h ctKV=WDKVht∈Rdc,dc≪h⋅dh

对每个头 i i i，再通过上投影矩阵即时还原 K、V：

k t , i C = W i U K c t K V , v t , i C = W i U V c t K V k_{t,i}^{C} = W_i^{UK} c_t^{KV}, \qquad v_{t,i}^{C} = W_i^{UV} c_t^{KV} kt,iC=WiUKctKV,vt,iC=WiUVctKV

关键点 ：推理时只需要缓存 c t K V c_t^{KV} ctKV，各头的 k t , i C k_{t,i}^{C} kt,iC、 v t , i C v_{t,i}^{C} vt,iC 在计算注意力时临时解压，用完即弃。

4.3 解耦 RoPE（Decoupled RoPE）

RoPE（旋转位置编码）不满足"先投影再施加位置编码"的交换律：

W i U K R o P E ( c t K V ) ≠ R o P E ⁣ ( W i U K c t K V ) W_i^{UK}\,\mathrm{RoPE}(c_t^{KV}) \neq \mathrm{RoPE}\!\left(W_i^{UK} c_t^{KV}\right) WiUKRoPE(ctKV)=RoPE(WiUKctKV)

因此不能直接把位置编码叠加在低秩 latent 上。MLA 的解法是把位置信息解耦：额外维护一条独立的、低维的 RoPE key：

k t R = R o P E ⁣ ( W K R h t ) ∈ R d h R k_t^{R} = \mathrm{RoPE}\!\left(W^{KR} h_t\right) \in \mathbb{R}^{d_h^R} ktR=RoPE(WKRht)∈RdhR

查询也相应拆分，构成共享的 RoPE 部分：

q t , i C = W i U Q q t , i q t , i R = R o P E ⁣ ( W i Q R q t , i ) q_{t,i}^{C} = W_i^{UQ} q_{t,i} \qquad q_{t,i}^{R} = \mathrm{RoPE}\!\left(W_i^{QR} q_{t,i}\right) qt,iC=WiUQqt,iqt,iR=RoPE(WiQRqt,i)

最终拼接：

k t , i = $k t , i C k t R$ q t , i = $q t , i C q t , i R$ k_{t,i} = \begin{bmatrix} k_{t,i}^{C} \\ k_t^{R} \end{bmatrix} \qquad q_{t,i} = \begin{bmatrix} q_{t,i}^{C} \\ q_{t,i}^{R} \end{bmatrix} kt,i= $kt,iCktR$ qt,i= $qt,iCqt,iR$

注意力输出：

o t , i = ∑ j s o f t m a x j ⁣ ( q t , i ⊤ k j , i d h + d h R ) v j , i C o_{t,i} = \sum_j \mathrm{softmax}j\!\left(\frac{q{t,i}^{\top} k_{j,i}}{\sqrt{d_h + d_h^R}}\right) v_{j,i}^{C} ot,i=j∑softmaxj dh+dhR qt,i⊤kj,i vj,iC

4.4 KV Cache 变化

MLA 每 token、每层只需缓存：

c t K V ⏟ d c 维 + k t R ⏟ d h R 维 \underbrace{c_t^{KV}}{d_c \text{ 维}} + \underbrace{k_t^{R}}{d_h^R \text{ 维}} dc 维 ctKV+dhR 维 ktR

对比 MHA 的 2 h d h 2 h d_h 2hdh：

DeepSeek-V2 中， h = 128 h=128 h=128、 d h = 128 d_h=128 dh=128，完整 K、V 为 2 × 128 × 128 = 32768 2 \times 128 \times 128 = 32768 2×128×128=32768 维；
MLA 的 d c = 512 d_c = 512 dc=512，RoPE key d h R = 64 d_h^R = 64 dhR=64，缓存仅约 576 576 576 维；
官方报告给出的口径是 KV Cache 减少约 93.3%（相对常用 MHA 配置），这也是"DeepSeek 把 KV Cache 干掉 93%"说法的来源。

4.5 工程优化

MLA 在部署侧还有两个关键技巧：

吸收上投影矩阵 ： W U K W^{UK} WUK 可吸收进 W U Q W^{UQ} WUQ， W U V W^{UV} WUV 可吸收进 W O W^{O} WO，推理时无需真正还原高维 K、V，进一步节省激活值显存与带宽。
算子级联合优化：由于 MLA 的"缓存压缩态 + 即时解压"，催生了专门的融合内核（如 FlashMLA），把解压、注意力、softmax、写回合并为一条流水线，大幅提升 decode 吞吐。

4.6 优点与局限

优点

缓存大幅下降且几乎不损失质量（优于同缓存量级的 GQA）。
保持了所有查询头的多样性。
与 MoE、FP8、长上下文结合良好，支撑了 DeepSeek-V3 / R1 的高效推理。

局限

实现复杂：低秩投影 + 解耦 RoPE + 吸收投影，工程难度高于 GQA。
RoPE 部分仍需单独缓存，压缩并非"零剩余"。
最关键的一点：MLA 仍为每个历史 token 各存一份表示，token 数量并不减少。当上下文进一步膨胀到百万级时，即便单个缓存很小，token 数量本身仍会构成瓶颈。

这直接引出了下一阶段的思路跃迁。

5. CSA：压缩稀疏注意力

出处：DeepSeek-V4（2026-04）。全称 Compressed Sparse Attention（压缩稀疏注意力）。

5.1 从"宽度压缩"到"长度压缩"

MHA → GQA → MLA 都在回答"每个 token 的 KV 能有多小"。但 DeepSeek-V4 要支撑 1M（百万）token 上下文，此时瓶颈已经不只是"单个 token 的宽度"，而是"token 数量本身"。

CSA 因此第一次把压缩施加在序列长度维度：

把连续多个 token 的 K、V 合并成一条 KV entry，使上下文的"有效条目数"变少。

5.2 总体结构

CSA 由三大组件构成：

Sliding Window（滑动窗口）
- 对最近的若干 token 保持未压缩的原始 KV，做精确的局部注意力。
- 负责捕获近程依赖与语法/局部细节，保证"近距离"分辨率不损失。
Compressor（压缩器）
- 对更早的历史 token，以固定步长 m m m 分块（CSA 取 m = 4 m = 4 m=4，即 4:1 压缩）。
- 用可学习的权重 把块内 m m m 条 KV 聚合为 1 条压缩 KV：

K ~ b = ∑ t ∈ block b α b , t K t , V ~ b = ∑ t ∈ block b α b , t V t \widetilde{K}b = \sum{t \in \text{block}b} \alpha{b,t}\, K_t, \qquad \widetilde{V}b = \sum{t \in \text{block}b} \alpha{b,t}\, V_t K b=t∈blockb∑αb,tKt,V b=t∈blockb∑αb,tVt

其中 α b , t \alpha_{b,t} αb,t 由压缩器学习（可理解为块内的加权池化 / 轻量块内注意力）。压缩 KV 会被写入独立的缓存。

Lightning Indexer（闪电索引器，稀疏选择）
- 压缩后条目仍然很多（1M token → 250k 个压缩块），全看仍然昂贵。
- 索引器对每个 query 与各压缩块计算打分，只挑选 top-k 个最相关的压缩块参与真正的注意力（类似"检索增强的注意力"，把选择做成可训练模块）。

5.3 注意力计算

查询 q q q 的注意力范围是"窗口内未压缩 KV ∪ 被选中的 top-k 压缩块"：

S ( q ) = Window ( q ) ∪ T o p K b ⁣ ( score ( q , K ~ b ) ) \mathcal{S}(q) = \text{Window}(q)\ \cup\ \mathrm{TopK}_b\!\left(\text{score}(q, \widetilde{K}_b)\right) S(q)=Window(q) ∪ TopKb(score(q,K b))

o = ∑ j ∈ S ( q ) s o f t m a x j ⁣ ( q ⊤ k j d ) v j o = \sum_{j \in \mathcal{S}(q)} \mathrm{softmax}_j\!\left(\frac{q^{\top} k_j}{\sqrt{d}}\right) v_j o=j∈S(q)∑softmaxj(d q⊤kj)vj

每个压缩块只作为一个 KV entry 参与点乘，因此：

单 token 注意力计算量 ≈ O ( W + k ) O(W + k) O(W+k)，其中 W W W 为窗口长度， k k k 为 top-k 块数。
相比全量注意力的 O ( N ) O(N) O(N)，在长上下文下有数量级下降。

5.4 复杂度与收益

以 1M 上下文为例（示意）：

全量 MHA/GQA/MLA：每生成一个 token 都要看 ~100 万条 KV。
CSA：仅看窗口（未压缩近端） + 从 25 万压缩块中索引器选出的 top-k 块。
显存上，历史 KV 被压缩到约 1 / 4 1/4 1/4，再加索引器的小型辅助状态，整体 KV Cache 与单 token 解码 FLOPs 都大幅下降。

5.5 与 NSA 的关系

CSA 的"窗口 + 选择 + 压缩"结构，延续了 DeepSeek 2025 年 NSA（Native Sparse Attention，原生稀疏注意力） 的设计脉络。NSA 使用"压缩 token、选择 token、滑动窗口"三路并行的稀疏模式；CSA 则更强调结构化压缩块 + 索引器 top-k 选择，把稀疏检索做得更工程化、更适合超长上下文。

5.6 在 DeepSeek-V4 中的用法

CSA 与下文 HCA 交替堆叠，形成混合注意力（Hybrid Attention）。
V4-Flash：前 2 层使用纯滑动窗口注意力（不压缩），其后交替 CSA / HCA；V4-Pro：前 2 层使用 HCA，第 2--60 层交替 CSA / HCA。
具体窗口大小、top-k 数值、辅助状态布局以官方技术报告与推理内核实现（vLLM、TensorRT-LLM）为准。

6. HCA：重度压缩注意力

出处：DeepSeek-V4（2026-04）。全称 Heavily Compressed Attention（重度压缩注意力） 。注意：部分资料误写为 "Hierarchical Compressed Attention"，官方名称以 Heavily（重度）为准。

6.1 动机

CSA 用 4:1 压缩 + 索引器 top-k 选择，既降低了长度，又保留了中粒度。但它有两个代价：

索引器本身需要额外的参数、打分与状态缓存。
top-k 选择丢弃了未选中的长尾信息，可能丢失分散在远处的重要线索。

HCA 反其道而行之：

压缩得足够狠，让"全部历史"都能被放进注意力，这样就不需要索引器，也不丢弃任何 token。

6.2 结构

HCA 同样有两部分：

Sliding Window：最近的 token 保持未压缩，提供局部高分辨率。
Compressor（重度压缩） ：以 m ′ = 128 m' = 128 m′=128（128:1） 的激进比例压缩历史 KV，一条压缩 entry 是 128 个连续 token 的加权聚合。

由于压缩比极高，压缩后的条目数很少（1M token → 约 7813 条），全部压缩块 都可以参与注意力，因此无需索引器：

S ( q ) = Window ( q ) ∪ { K ~ b ∣ ∀ b } \mathcal{S}(q) = \text{Window}(q)\ \cup\ \{\widetilde{K}_b \mid \forall b\} S(q)=Window(q) ∪ {K b∣∀b}

单 token 注意力计算量 ≈ O ( W + N / 128 ) O(W + N/128) O(W+N/128)。

6.3 与 CSA 的对比

	CSA	HCA
压缩比	m = 4 m = 4 m=4（4:1，温和）	m ′ = 128 m' = 128 m′=128（128:1，激进）
是否索引选择	是（Lightning Indexer，top-k）	否（全量浏览压缩块）
历史覆盖	部分（只保留 top-k）	全部（不漏信息）
分辨率	中粒度（4 token/块）	粗粒度（128 token/块）
额外开销	索引器打分/状态	几乎无（压缩器本身）
定位能力强项	中程检索式聚焦	全局完整覆盖

一句话：

CSA = 温和压缩 + 稀疏检索，用"选择"换取更细粒度与更短注意力。
HCA = 激进压缩 + 全量浏览，用"高压缩比"换取简单实现与全局不漏信息。

6.4 为什么两者要"混用"

在 DeepSeek-V4 中，CSA 与 HCA 交织出现在不同层：

HCA 层提供"全局背景"：每个 token 都能看到整个历史的粗粒度概貌，保证上下文不丢、主题一致。
CSA 层负责"精确检索"：在中等粒度上通过索引器聚焦到相关区域，捕捉关键证据与长程依赖。
**滑动窗口（部分作为前两层或窗口分支）**提供"局部细节"：近距离句法、语义细节不因压缩而模糊。

三者构成"全局粗粒度 ⟵ 中程检索 ⟵ 局部高精度"的分层信息流，是 DeepSeek-V4 支撑百万上下文、同时控制单 token 推理 FLOPs 的核心。

7. 综合对比

维度	MHA	GQA	MLA	CSA	HCA
全称	Multi-Head Attention	Grouped-Query Attention	Multi-head Latent Attention	Compressed Sparse Attention	Heavily Compressed Attention
出处/时间	2017	2023（MQA 2019）	2024	2026	2026
优化维度	基线	宽度（共享头）	宽度（低秩压缩）	长度（块压缩 + 稀疏）	长度（激进块压缩）
每 token 每层 KV	2 h d h 2 h d_h 2hdh	2 G d h 2 G d_h 2Gdh	d c + d h R d_c + d_h^R dc+dhR	窗口 + N / 4 N/4 N/4 压缩块 + 索引状态	窗口 + N / 128 N/128 N/128 压缩块
单 token 注意力	O ( N ) O(N) O(N)	O ( N ) O(N) O(N)	O ( N ) O(N) O(N)	O ( W + k ) O(W + k) O(W+k)	O ( W + N / 128 ) O(W + N/128) O(W+N/128)
稀疏/选择	无	无	无	top-k（索引器）	无（全量压缩块）
代表模型	原始 Transformer、早期 GPT	Llama-2/3 70B、Qwen、Mistral	DeepSeek-V2/V3/R1、Kimi、GLM	DeepSeek-V4	DeepSeek-V4

几点解读

MHA → GQA → MLA 的"缓存数字"是在每个 token 内做文章，token 总数不变。
CSA / HCA 的"缓存数字"是在序列长度上做文章，token 的表示粒度变粗。
两条路并不互斥：实践中完全可以"MLA 式宽度压缩 + CSA/HCA 式长度压缩"叠加使用。

8. 演进逻辑总结

整条主线可以浓缩为四句话：

MHA：表达能力优先，缓存最贵。
GQA：用"共享 KV 头"换内存带宽，几乎不掉点。
MLA：用"低秩潜在向量"换缓存，宽度压缩的集大成者。
CSA / HCA：用"块压缩 + （可选的）稀疏检索"换上下文长度，开启百万上下文。

演进的两个阶段：