**摘要:**自注意力机制是 Transformer 的核心组件,它让序列中的每个位置都能直接关注其他位置,从而捕捉全局依赖。本文将从直观理解出发,给出 Scaled Dot-Product Attention 的完整公式,用一个三词短句的数值示例逐步推演计算过程,并配以流程图和可运行 Python 代码,最后简要介绍多头注意力。
1. 从 RNN 到 Self-Attention:为什么需要 Transformer
在正式拆解自注意力之前,先回答一个更根本的问题:为什么一定要抛弃循环结构? 一个词又是如何决定该关注哪些词的?本节从序列建模的动机讲起,逐步过渡到 Q、K、V 的"谁该看谁"核心问题。
1.1 序列建模的核心任务
序列建模的目标可以概括为一句话:给定前文,预测或理解后文。无论是机器翻译、文本摘要、语音识别还是语言建模,模型都需要把一段有序的 token 序列映射为另一种表示或下一个 token 的概率分布。
难点在于:序列中的元素之间存在长短不一的依赖关系。有的依赖只隔一两个词,有的却跨越几十个词甚至整段文本。模型必须有能力把"远处"的信息带到"当前"位置。
1.2 RNN / LSTM 的工作方式
循环神经网络(RNN)采用逐步传递隐藏状态的方式处理序列。设第 t 步的输入为 x ₜ,隐藏状态为 hₜ,则基本形式为:
h ₜ = tanh( W ₓ x ₜ + W ₕ h ₜ₋₁ + b )
也就是说,第 t 步的输出依赖于第 t ₋₁ 步的隐藏状态,信息像接力棒一样一步步向后传递。LSTM 在此基础上引入输入门、遗忘门和输出门,用门控机制缓解长距离信息衰减,但逐步传递的串行本质并没有改变。
1.3 两大致命瓶颈
- 串行计算,无法并行 :第 t 步必须等第 t₋₁ 步算完,GPU 的大规模并行能力被严重浪费,训练长序列时速度成为瓶颈。
- 长距离依赖衰减:信息经过几十步传递后不断被压缩和覆盖,容易出现梯度消失,远处的关键信息难以保留。
1.4 Seq2Seq + Attention 的过渡
在 Transformer 之前,Seq2Seq 模型用一个 Encoder 把整句压缩成固定向量,再由 Decoder 逐步生成。固定向量成为信息瓶颈。注意力机制的出现改变了这一点:Decoder 在生成每个词时,可以直接"回头看" Encoder 的每一个位置,动态分配权重,而不必只依赖一个压缩向量。
这一步非常关键------注意力已经证明了自己能有效建模远距离依赖。于是自然引出下一个问题:
既然注意力这么好用,能不能彻底抛弃循环,只靠注意力来建模序列?
答案是肯定的,这正是 Transformer 的核心思想,也是自注意力机制登场的起点。
1.5 Self-Attention:一个词如何决定该关注哪些词
自注意力把"回头看"的对象从 Encoder 换成了序列自身:每个词都去和同一句话里的所有词计算相关性。可以用一个信息检索的比喻来理解 Q、K、V:
- Query(查询):我想找什么信息,相当于检索时输入的关键词。
- Key(键):每个位置对外提供的"标签",用来和 Query 匹配。
- Value(值):每个位置真正携带的内容,匹配度越高,被取用的比例越大。
三个投影矩阵 W _Q、W _K、W _V 把输入 X 映射为 Q 、K 、V:
Q = X × W _Q K = X × W _K V = X × W_V
随后依次进行:点积计算相关性 → 缩放(除以 √d _k,防止点积过大导致 softmax 饱和、梯度消失)→ Softmax 归一化 → 对 V 加权求和。完整公式为:
Attn(Q , K , V ) = softmax( Q K ᵀ / √d _k ) V
其中 Q K ᵀ 得到一个 n × n 的矩阵,第 i 行第 j 列表示第 i 个词对第 j 个词的关注程度,这就是"谁该看谁"的量化表达。
1.6 手算示例:3 个 token、d_k = 4
沿用后文的数值示例:输入为 3 个 token、维度为 4 的矩阵,假设投影矩阵为单位矩阵,则 Q = K = V = X ,d_k = 4,缩放因子 √4 = 2。
第一步,计算 Q Kᵀ 并缩放,得到分数矩阵:
text
S =
[[1.0, 0.0, 1.0],
[0.0, 4.0, 2.0],
[1.0, 2.0, 2.0]]
第二步,按行做 Softmax,得到注意力矩阵:
text
A ≈
[[0.4223, 0.1554, 0.4223],
[0.0159, 0.8668, 0.1173],
[0.1554, 0.4223, 0.4223]]
第三步,用 A 对 V 加权求和,得到输出:
text
O ≈
[[0.8446, 0.7331, 0.8446, 0.7331],
[0.1332, 1.8509, 0.1332, 1.8509],
[0.5777, 1.2669, 0.5777, 1.2669]]
可以看到,第二个 token 对自身的注意力权重约为 86.68%,同时仍参考了另外两个 token 的信息,体现了全局聚合能力。完整的逐步推演见后文"数值示例"一节。
1.7 复杂度与并行性
自注意力的计算复杂度为 O(n² d) :n 个位置两两计算相关性,得到 n × n 的注意力矩阵,每个元素涉及 d 维向量的点积。相比 RNN 的 O(n d²) 串行计算,自注意力在序列长度不大时计算量可控,而且天然并行------所有位置的 Q、K、V 可以一次性矩阵乘出,注意力矩阵也能整体计算。
更重要的是,自注意力中任意两个位置之间的距离恒为 1,无论它们在序列中相隔多远,都能通过一次注意力运算直接建立联系,从根本上缓解了长距离依赖衰减问题。
1.8 与 RNN 的对比总结
| 对比维度 | RNN / LSTM | Self-Attention |
|---|---|---|
| 计算方式 | 逐步串行,依赖上一步隐藏状态 | 矩阵运算,全序列并行 |
| 任意两位置距离 | O(n),需逐步传递 | O(1),一步直达 |
| 长距离依赖 | 易衰减,梯度消失 | 直接建模,衰减较弱 |
| 单层复杂度 | O(n d²) | O(n² d) |
| GPU 利用率 | 低,受串行限制 | 高,适合大规模并行 |
| 可解释性 | 隐藏状态难以直观解读 | 注意力权重可视化直观 |
正是这些优势,让自注意力成为 Transformer 的基石,并进一步支撑起 BERT、GPT 等现代大模型。下面从"什么是自注意力机制"开始,逐层展开公式、计算步骤与代码实现。
2. 自注意力机制详解
本节把自注意力机制拆成若干小节,从直观理解、动机、核心公式、计算步骤、数值示例、流程图、代码实现到多头注意力,逐层展开。
2.1 什么是自注意力机制
自注意力机制(Self-Attention)是一种用于序列建模的注意力计算方式。它的核心思想是:对于输入序列中的每一个元素,不再只依赖局部邻居或循环网络的逐步传递,而是直接计算它与序列中所有元素之间的相关性,并据此聚合全局信息。
可以用一个直观的比喻来理解:把一句话中的每个词都比作会议室里的一个与会者。每个与会者都想根据当前话题提出一个问题(Query),同时每个与会者身上都挂着一个标签(Key)说明自己掌握什么信息,并且带着一份发言内容(Value)。每个词在发言时,会根据自己提出的问题与在场所有人的标签进行匹配,决定应该重点听取谁的意见,最后把所有发言内容按匹配程度加权汇总,形成自己的新表达。
形式化地说,假设输入是一个由 n 个向量组成的序列 X = x₁, x₂, ..., xₙ,每个向量的维度为 d_model。自注意力会为每个位置生成三个向量:查询 Query、键 Key 和值 Value。第 i 个位置的输出,是对所有位置的 Value 做加权平均,权重由第 i 个位置的 Query 与所有位置的 Key 的相似度决定。可以用三个词概括这个过程:提出查询、匹配键、聚合值。
| 向量 | 全称 | 含义 | 类比 |
|---|---|---|---|
| Q | Query(查询) | "我想找什么?" | 你在搜索引擎输入的关键词 |
| K | Key(键) | "我能提供什么信息?" | 网页的标题/标签 |
| V | Value(值) | "我的实际内容是什么?" | 网页的实际正文内容 |
需要注意,自注意力与早期 Seq2Seq 中的注意力并不完全相同。Seq2Seq 中的注意力是 Decoder 对 Encoder 的跨序列注意力,也就是一种 Cross-Attention;而自注意力让序列中的每个元素都去关注同一个序列里的其他元素,因此整个关系矩阵是 n × n。这种机制最早在论文《Attention Is All You Need》中被系统提出,目前已经成为大语言模型、机器翻译、图像识别等任务中的基础模块。
2.2 为什么需要自注意力
自注意力的流行并不是因为它看起来更复杂,而是因为它解决了几类传统序列模型难以兼顾的问题。
- 捕捉全局依赖:任意两个位置都可以直接建立联系,无论它们相隔多远。一个词不需要等待信息逐步传递,就能直接参考句中任意位置的上下文。
- 支持并行计算:每个位置的输出可以同时计算,不像 RNN 需要按时间步逐步展开。所有 Query、Key、Value 都可以通过矩阵乘法一次得到,适合 GPU 大规模并行。
- 内容可解释性:注意力权重可以展示模型关注了哪些位置,便于分析模型为什么会做出某个判断,也方便做可视化热力图。
- 动态权重:不同输入会得到不同的注意力权重,模型能够根据当前内容动态决定"谁更重要",而不是使用固定窗口或固定连接。
- 处理变长序列:注意力矩阵的大小虽然与序列长度有关,但计算方式不依赖特定的顺序假设,因此可以灵活处理不同长度的输入。
2.3 核心公式
自注意力的标准形式是 Scaled Dot-Product Attention,即"缩放点积注意力"。它把"相似度计算、归一化、信息聚合"三步整合为一个可并行计算的公式:
Attention(Q , K , V ) = softmax( Q K ᵀ / √d _k ) V
其中:
- Q :查询矩阵,形状为 n × d_k,表示"我想查什么"。
- K :键矩阵,形状为 n × d_k,表示"我能匹配什么"。
- V :值矩阵,形状为 n × d_v,表示"我实际携带什么内容"。
- d_k:Key 向量的维度,用于缩放点积结果,防止数值过大导致 softmax 饱和、梯度消失。
- softmax:按行归一化,使每一行的注意力权重之和为 1。
Q、K、V 由输入 X 通过与学习参数相乘得到:
Q = X × W _Q K = X × W _K V = X × W_V
其中 W _Q、W _K 是 d _model × d _k 的权重矩阵,W _V 是 d _model × d_v 的权重矩阵。通过这三个可学习矩阵,模型可以自动学习到最适合当前任务的查询、键和值表示。
为什么公式中要除以 √d _k?当 d_k 较大时,点积 QKᵀ 的数值会普遍变大。Softmax 对较大输入非常敏感,容易让权重集中在少数几个位置上,从而出现梯度很小、学习困难的问题。缩放后,点积方差被控制在更稳定的范围,模型训练更平稳。
2.4 计算步骤详解
| 步骤 | 操作 | 形状变化 | 含义 |
|---|---|---|---|
| ① | 计算 Q Kᵀ | (n, d _k) × (d_k, n) → (n, n) | 计算每对词之间的相似度 |
| ② | 除以 √d_k | (n, n) → (n, n) | 缩放,防止点积过大导致 softmax 梯度消失 |
| ③ | 按行 softmax | (n, n) → (n, n) | 归一化为概率分布(每行和为 1) |
| ④ | 乘以 V | (n, n) × (n, d _v) → (n, d_v) | 加权求和,得到最终输出 |
自注意力的计算可以拆成五个连续步骤,每一步都有清晰的输入、输出和目的。
- 线性变换 :用三个不同的权重矩阵 W _Q、W _K、W_V 把输入 X 映射为 Q、K、V。这里的"线性变换"就是矩阵乘法,目的是把原始 token 向量投影到更利于查询、匹配和聚合的表示空间中。
- 计算注意力分数:对 Q 和 K 做点积,得到 n × n 的分数矩阵 S = QKᵀ。S 的第 i 行第 j 列表示第 i 个 Query 与第 j 个 Key 的相似度,分数越高,表示第 i 个位置越应该关注第 j 个位置。
- 缩放:将分数矩阵除以 √dk。这一步可以防止点积过大,保持 softmax 的梯度稳定。
- Softmax 归一化:对缩放后的矩阵按行做 softmax,得到注意力权重矩阵 A。每一行的权重都是正数,并且总和为 1,因此可以理解为一个概率分布。
- 加权求和:用权重矩阵 A 对 V 做加权平均,得到最终输出 O = A V。每个位置的输出,都是所有位置 Value 的加权组合,权重来自该位置与其他位置的相似度。
这五步看起来繁琐,但在实际工程中都可以表示为矩阵运算,因此一次前向传播就能同时得到所有位置的输出。
2.5 数值示例
下面用一个包含 3 个 token、向量维度为 4 的短句来演示。假设输入矩阵为:
| Token | 向量 |
|---|---|
| x₁ | 1, 0, 1, 0 |
| x₂ | 0, 2, 0, 2 |
| x₃ | 1, 1, 1, 1 |
为了简化,假设 WQ、WK、WV 都是单位矩阵,因此 Q = K = V = X,且 dk = 4,缩放因子 √4 = 2。这样我们就能把注意力完全聚焦在"点积、缩放、Softmax、加权求和"四步运算上。
2.5.1 计算分数矩阵
先计算 QKᵀ。以第 1 行第 1 列的分数为例,它是 x₁ 与自己的点积:1 × 1 + 0 × 0 + 1 × 1 + 0 × 0 = 2。完整结果为:
text
Q K^T =
[[2, 0, 2],
[0, 8, 4],
[2, 4, 4]]
除以 √dk = 2,得到缩放后的分数矩阵:
text
S =
[[1.0, 0.0, 1.0],
[0.0, 4.0, 2.0],
[1.0, 2.0, 2.0]]
可以看到,x₂ 与自身的相似度最高,达到 4.0;而 x₁ 与 x₂ 的相似度为 0,因为它们对应的向量维度完全不同。
2.5.2 对每一行做 Softmax
Softmax 公式为:
text
softmax(zᵢ) = exp(zᵢ) / ∑ⱼ exp(zⱼ)
按行计算得到注意力权重矩阵:
text
A ≈
[[0.4223, 0.1554, 0.4223],
[0.0159, 0.8668, 0.1173],
[0.1554, 0.4223, 0.4223]]
例如第一行的计算为:exp(1.0) ≈ 2.718,exp(0.0) = 1.0,exp(1.0) ≈ 2.718,三者和约为 6.436,因此 2.718 / 6.436 ≈ 0.4223,1.0 / 6.436 ≈ 0.1554。第一行两个 1.0 得到相同权重,中间的 0.0 得到较低权重。
2.5.3 加权求和得到输出
输出 O = A V,V = X。计算结果约为:
text
O ≈
[[0.8446, 0.7331, 0.8446, 0.7331],
[0.1332, 1.8509, 0.1332, 1.8509],
[0.5777, 1.2669, 0.5777, 1.2669]]
可以看到,第二个 token 的输出中,x₂ 自身占据了约 86.68% 的注意力权重,因为它与自己的相似度最高;而它同时也参考了 x₁ 和 x₃ 的信息,体现了全局聚合能力。第一个 token 的输出则主要表现为 x₁ 和 x₃ 的混合,因为二者与它的相似度相同。
2.6 图示:自注意力计算流程图
下图用流程图表示自注意力从输入到输出的完整计算过程:
如果从矩阵形状变化的角度理解,这个流程可以概括为:X 的形状是 n × d _model,经过投影后得到 n × d _k 的 Q 和 K,n × d _v 的 V;QKᵀ 得到 n × n 的分数矩阵;再经过缩放、Softmax,权重矩阵仍然是 n × n;最后与 V 相乘得到 n × d_v 的输出 O。整个过程的核心就是让每个位置都能根据自己的 Query,对所有位置的 Value 做一次全局加权汇总。
在实际实现中,B 到 F 的计算可以高度并行,是 Transformer 能高效训练大规模模型的重要原因之一。
2.7 代码实现
下面是使用 Python 和 NumPy 实现 Scaled Dot-Product Attention 的完整示例:
python
import numpy as np
def scaled_dot_product_attention(Q, K, V, mask=None):
d_k = Q.shape[-1]
scores = np.dot(Q, K.T) / np.sqrt(d_k)
if mask is not None:
scores = np.where(mask == 0, -1e9, scores)
# 数值稳定性处理:减去每行最大值,防止 exp 溢出
scores -= np.max(scores, axis=-1, keepdims=True)
exp_scores = np.exp(scores)
attention_weights = exp_scores / np.sum(exp_scores, axis=-1, keepdims=True)
output = np.dot(attention_weights, V)
return output, attention_weights
输入序列:3 个 token,每个 token 维度为 4
X = np.array([
[1, 0, 1, 0],
[0, 2, 0, 2],
[1, 1, 1, 1]
])
简化:假设 W_Q、W_K、W_V 均为单位矩阵
Q = X.copy()
K = X.copy()
V = X.copy()
output, attn = scaled_dot_product_attention(Q, K, V)
print("Attention Weights:")
print(attn)
print("Output:")
print(output)
如果用 PyTorch 实现,核心逻辑几乎一致,只是改用 torch 的张量运算:
python
import torch
import torch.nn.functional as F
def scaled_dot_product_attention_torch(Q, K, V, mask=None):
d_k = Q.size(-1)
scores = torch.matmul(Q, K.transpose(-2, -1)) / torch.sqrt(torch.tensor(d_k, dtype=torch.float32))
if mask is not None:
scores = scores.masked_fill(mask == 0, -1e9)
attention_weights = F.softmax(scores, dim=-1)
output = torch.matmul(attention_weights, V)
return output, attention_weights
运行后,注意力权重和输出矩阵会与前面数值示例中的结果一致。代码中的 mask 参数主要用于处理填充位置或因果遮挡:当某个 Key 不应被关注时,把对应分数设为一个极小的负数,经过 softmax 后其权重就会趋近于 0。实际使用中,Q、K、V 是通过可学习的线性层从 X 映射得到的,而不是直接复制输入。
3. 多头注意力(Multi-Head Attention)简介
单头自注意力只能从一种角度捕捉 token 之间的关系。为了让模型在不同表示子空间中同时关注不同位置和不同模式,Transformer 使用了多头注意力(Multi-Head Attention)。本节从动机、公式、维度变化、代码实现和常见问题几个角度,把多头注意力拆开讲清楚。
3.1 为什么需要多头:单头注意力的局限
回顾第 2 节的核心公式,单头自注意力只做了一件事:用一组投影矩阵 W _Q、W _K、W _V 把输入映射成一组 Q、K、V,然后计算一次注意力权重矩阵,最后对 V 加权求和。整个过程只产生一个 n × n 的注意力矩阵。
这带来两个问题:
- 视角单一:一个注意力矩阵只能表达一种"谁该看谁"的关系。如果某个头把权重集中到了语法相邻的词上,它就很难同时表达远距离的指代关系。
- 信息被平均:Softmax 之后每行权重之和为 1,多个不同性质的相关性会被强行压缩进同一组权重里,互相干扰。
一个直观的类比是:让一个人同时负责判断"语法是否通顺""代词指代谁""语义是否相近",他往往只能给出一个折中的答案。而如果安排多个专家各自负责一个维度,再把结论汇总,效果会明显更好。多头注意力就是让模型拥有多个"专家头"。
3.2 核心思想:把表示空间切成 h 份
多头注意力的做法并不复杂:不增加总计算量,而是把原来的高维表示拆成 h 份,每份独立做一次注意力。
具体来说,假设模型维度为 d_model,头数为 h,则每个头的维度为:
d _k = d _v = d_model / h
例如 d _model = 512、h = 8 时,每个头的维度就是 64。每个头都有自己的投影矩阵 W _i^Q、W _i^K、W _i^V,形状都是 d _model × d_k。于是 h 个头各自在 64 维的子空间里计算注意力,互不干扰。
关键点:多头不是把计算量放大 h 倍,而是把维度切分后并行计算。总参数量和单头全维度注意力基本相当,但表达能力更强。
3.3 完整公式与计算流程
多头注意力的计算可以形式化地写成两步。第一步,每个头独立执行缩放点积注意力:
head_i = Attention( Q × W _i^Q, K × W _i^K, V × W_i^V )
第二步,把所有头的输出在特征维度上拼接,再乘一个输出投影矩阵 W^O:
MultiHead( Q , K , V ) = Concat( head_1, ..., head_h ) × W^O
其中 W ^O 的形状是 (h × d _v) × d _model,作用是把拼接后的高维结果重新映射回 d_model 维,保证输出维度与输入一致,方便后续接残差连接和层归一化。
整个流程可以用下面的流程图表示:
3.4 参数量不增的证明
很多人第一次接触多头注意力时会担心:既然有 h 个头,每个头都有自己的投影矩阵,参数量岂不是变成 h 倍?答案是否定的。下面把单头和多头的参数量逐项算清楚。
先看单头全维度注意力 。它用一组投影矩阵把 d _model 维输入映射到 d_model 维的 Q、K、V,参数量为:
3 × d _model × d _model + d _model × d _model = 4 d_model²
其中前三项分别是 W _Q、W _K、W _V,最后一项是输出投影 W^O。
再看多头注意力 。每个头的投影矩阵形状是 d _model × d _k,其中 d _k = d_model / h。h 个头合起来,Q、K、V 的参数量为:
h × 3 × d _model × (d _model / h) = 3 d_model²
输出投影 W ^O 的形状是 (h × d _v) × d _model = d _model × d _model,参数量为 d_model²。两者相加:
3 d _model² + d _model² = 4 d_model²
可以看到,多头注意力的总参数量与单头全维度注意力完全相等 。多头并没有引入额外的参数,它只是把同一份参数预算重新组织成 h 个子空间,让模型在相同的成本下获得更丰富的表达方式。这也是多头注意力设计上最巧妙的地方:用切分换表达,而不是用堆参数换表达。
3.5 维度变化:一张表看清形状
多头注意力最容易出错的地方是维度。下表把每一步的形状列清楚,假设输入序列长度为 n、模型维度为 d _model、头数为 h、每头维度为 d _k = d_model / h:
| 步骤 | 操作 | 形状变化 |
|---|---|---|
| ① | 输入 X | (n, d_model) |
| ② | 每个头投影得到 Q_i、K_i、V_i | (n, d_k) |
| ③ | 每个头计算注意力 | head_i: (n, d_k) |
| ④ | 拼接所有头 | (n, h × d _k) = (n, d_model) |
| ⑤ | 乘以 W^O | (n, d_model) |
可以看到,输入和输出的形状完全一致,都是 (n, d_model)。这正是多头注意力能够无缝嵌入 Transformer 层的前提。
3.6 代码实现:NumPy 版多头注意力
下面用 NumPy 实现一个多头注意力,重点观察"拆分头 → 并行注意力 → 拼接 → 输出投影"这四步:
python
import numpy as np
def softmax(x, axis=-1):
x = x - np.max(x, axis=axis, keepdims=True)
e = np.exp(x)
return e / np.sum(e, axis=axis, keepdims=True)
def multi_head_attention(X, Wq, Wk, Wv, Wo, num_heads):
n, d_model = X.shape
d_k = d_model // num_heads
# 1. 线性投影,得到整体的 Q、K、V
Q = X @ Wq # (n, d_model)
K = X @ Wk
V = X @ Wv
2. 拆分成 h 个头: (n, h, d_k) -> (h, n, d_k)
Q = Q.reshape(n, num_heads, d_k).transpose(1, 0, 2)
K = K.reshape(n, num_heads, d_k).transpose(1, 0, 2)
V = V.reshape(n, num_heads, d_k).transpose(1, 0, 2)
3. 每个头独立计算缩放点积注意力
scores = Q @ K.transpose(0, 2, 1) / np.sqrt(d_k) # (h, n, n)
attn = softmax(scores, axis=-1)
heads = attn @ V # (h, n, d_k)
4. 拼接所有头并做输出投影
concat = heads.transpose(1, 0, 2).reshape(n, d_model)
output = concat @ Wo # (n, d_model)
return output, attn
示例:n=3, d_model=8, h=2
np.random.seed(0)
X = np.random.randn(3, 8)
Wq = np.random.randn(8, 8) * 0.1
Wk = np.random.randn(8, 8) * 0.1
Wv = np.random.randn(8, 8) * 0.1
Wo = np.random.randn(8, 8) * 0.1
out, attn = multi_head_attention(X, Wq, Wk, Wv, Wo, num_heads=2)
print("输出形状:", out.shape) # (3, 8)
print("注意力形状:", attn.shape) # (2, 3, 3)
代码中的 reshape + transpose 是理解多头的关键:它把 (n, d_model) 的矩阵重排成 (h, n, d_k),让每个头成为独立的一层,从而可以一次性完成所有头的注意力计算。
3.7 多头到底学到了什么
多头注意力的价值不仅在于公式,更在于它带来的可解释性。研究者通过可视化不同头的注意力权重,发现了一些典型模式:
- 局部头:注意力集中在相邻 token 上,类似 n-gram 或局部窗口,负责捕捉短语结构。
- 句法头:注意力倾向于连接动词与主语、形容词与名词,负责建模句法依赖。
- 指代头:注意力从代词指向它所指代的名词,负责消解指代关系。
- 全局头:注意力分散到整句,负责汇总全局语义,常见于 CLS 或句首位置。
这些头并不是人工设计的,而是在训练中自发形成的。不同头分工协作,最后通过 W^O 融合,使模型能够同时兼顾局部细节和全局语义。
3.8 常见问题与注意事项
- 头数越多越好吗? 不是。头数增加会让每个头的维度 d _k 变小,单头表达能力下降。实践中 h 通常取 8 或 16,d_k 保持在 64 左右比较常见。
- 为什么必须除以 √d_k? 与单头注意力相同,缩放是为了防止点积过大导致 softmax 饱和。注意这里除的是每个头的维度 ,而不是 d_model。
- 多头和单头的参数量差多少? 基本相当。因为每个头的投影矩阵是 d _model × d _k,h 个头加起来正好是 d _model × d_model,与单头全维度投影一致。
- 输出为什么要再乘 W^O? 拼接后的结果只是各头信息的简单堆叠,缺少头与头之间的交互。W^O 负责把不同头的信息混合,形成统一的表示。
3.9 与 Transformer 其他组件的配合
在实际 Transformer 中,多头注意力很少单独出现,而是与残差连接和层归一化组合成一个子层:
输出 = LayerNorm( X + MultiHead( X, X, X ) )
残差连接让梯度可以直接反传到浅层,缓解深层网络的梯度消失;层归一化则稳定每一层的输入分布,加快收敛。在解码器中,多头注意力还会加上因果掩码(causal mask),保证每个位置只能看到它之前的 token,从而支持自回归生成。
理解了单头自注意力之后,多头注意力本质上只是把同一套机制并行运行 h 次,再组合输出。它用很小的额外复杂度,换来了更丰富的表示能力和更好的可解释性,是 Transformer 能够支撑起 BERT、GPT 等大模型的重要设计之一。
4. MQA / GQA:共享 K/V 的谱系
在讨论 MQA 和 GQA 之前,有必要先把 MHA 的 KV Cache 显存问题彻底讲清楚。因为 MQA 和 GQA 的所有设计动机,本质上都是在回答同一个问题:标准多头注意力在推理时,KV Cache 到底占了多少显存,为什么它会成为大模型推理的头号瓶颈?
4.1 KV Cache 与显存瓶颈
4.1.1 为什么推理需要 KV Cache
先回顾自回归生成的过程。大模型生成文本时是逐 token 进行的:给定前文,预测下一个 token,把它拼到序列末尾,再预测下一个,如此循环。在标准 MHA 中,第 t 步计算注意力时,需要当前 token 的 Query 与所有历史位置的 Key 做点积,再对所有历史位置的 Value 加权求和。
如果每一步都重新计算全部历史 token 的 K、V,那么生成第 t 个 token 就要重算 t 次投影,总计算量会随序列长度呈平方级增长,完全不可接受。KV Cache 的思路很直接:把已经算过的 K、V 缓存下来,每步只计算新 token 的 K、V 并追加到缓存中。这样每步的投影计算量从 O(t) 降到 O(1),代价是显存里要常驻一份随序列增长而增长的缓存。
一句话总结:KV Cache 是用显存换计算时间的典型手段。它把推理从"每步重算全序列"变成"每步只算新 token",但也因此让显存占用随序列长度线性增长。
先回顾自回归生成的过程。大模型生成文本时是逐 token 进行的:给定前文,预测下一个 token,把它拼到序列末尾,再预测下一个,如此循环。在标准 MHA 中,第 t 步计算注意力时,需要当前 token 的 Query 与所有历史位置的 Key 做点积,再对所有历史位置的 Value 加权求和。
如果每一步都重新计算全部历史 token 的 K、V,那么生成第 t 个 token 就要重算 t 次投影,总计算量会随序列长度呈平方级增长,完全不可接受。KV Cache 的思路很直接:把已经算过的 K、V 缓存下来,每步只计算新 token 的 K、V 并追加到缓存中。这样每步的投影计算量从 O(t) 降到 O(1),代价是显存里要常驻一份随序列增长而增长的缓存。
一句话总结:KV Cache 是用显存换计算时间的典型手段。它把推理从"每步重算全序列"变成"每步只算新 token",但也因此让显存占用随序列长度线性增长。
4.1.2 KV Cache 显存占用的精确公式
把 KV Cache 的大小拆开算,可以写成下面这个公式:
KV Cache 显存 = 2 × L × h × d_head × s × b × p
其中每一项的含义如下:
| 符号 | 含义 | 说明 |
|---|---|---|
| 2 | K 和 V 两份 | Key 与 Value 各存一份 |
| L | Transformer 层数 | 每一层都有自己的 KV Cache |
| h | 注意力头数 | MHA 中每个头独立存一份 K/V |
| d_head | 每个头的维度 | 通常 d_head = d_model / h |
| s | 当前序列长度 | 随生成过程不断增长 |
| b | 批大小(batch size) | 并发请求越多,占用越大 |
| p | 每个数值的字节数 | FP16 为 2 字节,FP32 为 4 字节,INT8 为 1 字节 |
注意 h × d_head = d_model,所以公式也可以写成更简洁的形式:
KV Cache 显存 = 2 × L × d_model × s × b × p
这个简化形式揭示了一个关键事实:在 MHA 下,KV Cache 的大小与头数 h 无关,只与模型维度 d_model、层数 L、序列长度 s、批大小 b 和精度 p 有关。头数只是把 d_model 切成若干份,总量不变。真正能压缩 KV Cache 的,是减少"每个位置需要缓存的 K/V 份数",这正是 MQA 和 GQA 的切入点。
4.1.3 代入真实模型:数字有多夸张
光看公式不够直观,代入一个典型的大模型配置算一算。假设一个 7B 级别的模型:L = 32 层,d_model = 4096,使用 FP16(p = 2 字节),单条请求(b = 1)。
先算每个 token 的 KV Cache 大小:
2 × 32 × 4096 × 2 字节 = 524288 字节 ≈ 0.5 MB / token
也就是说,每多生成一个 token,就要多占约 0.5 MB 显存。再乘以序列长度:
| 序列长度 s | 单请求 KV Cache | 批大小 b = 16 时 |
|---|---|---|
| 1K | 约 0.5 GB | 约 8 GB |
| 4K | 约 2 GB | 约 32 GB |
| 32K | 约 16 GB | 约 256 GB |
| 128K | 约 64 GB | 约 1024 GB |
可以看到,当序列长度达到 32K 时,单条请求的 KV Cache 就已经和模型权重本身(7B 模型 FP16 约 14 GB)处于同一量级;如果同时服务 16 条请求,KV Cache 会直接超过单张 80 GB 显卡的容量。到了 128K 长上下文场景,KV Cache 甚至会成为比模型权重更大的显存消耗项。
4.1.4 为什么 MHA 的 KV Cache 特别大
把 MHA 的问题归纳成三点:
- 每个头都要独立缓存 K/V:h 个头就有 h 份 K 和 h 份 V。虽然总量等于 d_model,但这份缓存是"每个位置、每一层"都要存的,累积起来非常可观。
- 随序列长度线性增长:s 每增加一倍,KV Cache 就翻一倍。长上下文、长文档问答、多轮对话等场景下,s 很容易达到几万甚至几十万。
- 随批大小线性增长:推理服务要追求吞吐,就必须并发处理多条请求,b 增大直接让显存成倍上涨。
这三者相乘,使得 KV Cache 成为限制并发数、上下文长度和吞吐量的核心瓶颈。显存被 KV Cache 占满后,要么降低批大小(吞吐下降),要么截断上下文(能力下降),要么换更贵的卡(成本上升)。
4.1.5 与计算量的对比:为什么说它是"隐性成本"
训练阶段,主要开销是前向和反向的计算,KV Cache 并不存在(训练时整条序列一次性并行计算,不需要逐步缓存)。所以很多人在训练时感受不到这个问题。但到了推理阶段,尤其是自回归解码,情况完全反转:
- 计算是访存受限的:每生成一个 token,都要把整个 KV Cache 从显存读一遍参与注意力计算,计算量很小但访存量很大,GPU 算力大量闲置。
- 显存是硬约束:计算慢可以等,显存不够就直接 OOM。KV Cache 挤占的显存,本可以用来放更大的批或更长的上下文。
因此,KV Cache 既是显存问题,也是带宽和吞吐问题。压缩 KV Cache,等于同时缓解显存、带宽和吞吐三重压力,这就是 MQA / GQA 的价值所在。
4.1.6 常见的缓解思路
围绕 KV Cache 的优化大致可以分为几个方向,MQA / GQA 只是其中"从模型结构入手"的一类:
| 思路 | 代表方法 | 核心做法 |
|---|---|---|
| 减少 K/V 份数 | MQA、GQA | 多个 Query 头共享同一份 K/V,直接按比例压缩缓存 |
| 降低数值精度 | FP8 / INT8 KV Cache | 用更低字节数存储 K/V,近似减半显存 |
| 淘汰或稀疏化 | H2O、StreamingLLM、滑动窗口 | 只保留重要的或最近的 token,丢弃其余缓存 |
| 分页管理 | PagedAttention(vLLM) | 像操作系统分页一样管理 KV Cache,减少碎片浪费 |
其中 MQA 和 GQA 的优势在于:它从模型结构层面直接减少了需要缓存的 K/V 份数,不需要额外的工程改造,也不依赖运行时策略。一旦模型按 GQA 训练好,推理时的显存节省是"天生"的。这也是为什么现代开源大模型几乎都采用 GQA 的原因。
理解了 MHA 的 KV Cache 为什么大、大到什么程度,接下来就能自然地理解 MQA 和 GQA 的设计逻辑:它们本质上都是在"每个位置缓存几份 K/V"这个维度上做减法。
多头注意力(MHA)虽然表达能力强,但在推理阶段有一个隐性成本:每生成一个 token,都要把全部 h 个头的 K、V 缓存下来,这就是所谓的 KV Cache。序列越长、头数越多,KV Cache 占用的显存就越大,成为大模型推理的主要瓶颈之一。MQA 和 GQA 正是围绕"共享 K/V"这一思路演化出来的两种折中方案。
4.2 从 MHA 到 MQA:把 K/V 压成一份
标准 MHA 中,每个头都有自己独立的 Q、K、V 投影,h 个头就有 h 份 K 和 h 份 V。MQA(Multi-Query Attention)的核心改动非常直接:所有头共享同一份 K 和 V,只保留各自独立的 Q。
这样一来,KV Cache 从 h 份压缩成 1 份,显存占用直接降到原来的 1/h。代价是每个头不再拥有独立的键值表示,表达能力有所下降,但实践中这种损失往往可以接受,而推理速度的提升非常可观。
4.3 GQA:在 MHA 与 MQA 之间取平衡
GQA(Grouped-Query Attention)是 MHA 和 MQA 的推广形式。它把 h 个 Query 头分成 g 组,每组共享一份 K 和 V。用 g 表示 K/V 的组数,就得到一个连续的谱系:
- g = h:每组只有一个 Query 头,退化为标准 MHA,KV Cache 最大,表达最强。
- g = 1:所有 Query 头共享一份 K/V,退化为 MQA,KV Cache 最小,速度最快。
- 1 < g < h:介于两者之间,是实际工程中最常用的配置。
因此可以这样理解:MHA 和 MQA 是 GQA 的两个端点,GQA 是它们之间的一条连续谱系。调节 g 的大小,就是在"表达质量"和"推理成本"之间滑动一个旋钮。
4.4 现代模型的配置选择
在实际的大模型配置中,GQA 已经成为主流选择。下表列出几种典型配置的对比:
| 方案 | K/V 组数 g | KV Cache 相对大小 | 典型取舍 |
|---|---|---|---|
| MHA | g = h | 1(基准) | 表达最强,显存开销最大 |
| GQA | 1 < g < h | g / h | 质量与成本折中,工程主流 |
| MQA | g = 1 | 1 / h | 速度最快,质量略有损失 |
例如,当 h = 32、g = 8 时,KV Cache 只有 MHA 的 1/4,而表达能力的下降通常很小。这也是很多现代开源模型选择 GQA 的原因:用较小的质量代价换取显著的显存和吞吐收益。
4.5 Uptraining:从 MHA 平滑迁移到 GQA
一个自然的问题是:已经用 MHA 训练好的模型,能不能低成本地改成 GQA?答案是肯定的,常用做法叫 Uptraining。
具体思路是:把原 MHA 中同一组内多个头的 K、V 投影矩阵做均值池化,合并成一份共享的 K、V 投影,作为 GQA 的初始化;Q 投影和输出投影保持不变。然后用少量数据继续训练(通常只占总训练量的很小比例),让模型适应新的共享结构。
这样做的好处是:不需要从头训练,就能把已有的 MHA 模型转换成推理更高效的 GQA 模型,同时尽量保留原有能力。Uptraining 让"训练时用 MHA、推理时用 GQA"成为一条可行的工程路径。
4.5 小结:一张图看懂谱系
从 MHA 到 MQA,再到 GQA,本质上是在同一套注意力机制上调整"K/V 共享程度"这一个维度。理解了 g 这个参数,就理解了整个谱系:g = h 是表达优先的一端,g = 1 是效率优先的一端,而 GQA 则把这条谱系变成了可以自由调节的连续区间。
三兄弟对照表:
| 对比维度 | MHA | GQA | MQA |
|---|---|---|---|
| Q 头数 | h | h | h |
| K/V 组数 g | g = h | 1 < g < h | g = 1 |
| KV Cache 相对大小 | 1(基准) | g / h(如 h = 32、g = 8 时为 1/4) | 1 / h |
| K/V 参数量 | 2 × d_model² | 2 × (g / h) × d_model² | 2 × d_model² / h |
| 表达能力 | 最强(基准) | 接近 MHA,几乎无损 | 有可见损失 |
| 推理速度 | 最慢(Cache 最大) | 接近 MQA | 最快 |
| 典型取舍 | 表达优先,显存开销最大 | 质量与成本折中,工程主流 | 效率优先,质量略有下降 |
5. 总结
自注意力机制通过 Query、Key、Value 三个矩阵,以及"点积、缩放、Softmax、加权求和"四步核心运算,使每个 token 都能高效地聚合全局信息。多头注意力在不增加参数量的前提下,把表示空间拆成多个子空间并行计算,再通过 Concat 和输出投影融合,让模型同时捕捉局部与全局、语法与语义等多种模式。MQA 与 GQA 则沿着"共享 K/V"的方向继续优化,用 g 这一个参数串起从 MHA 到 MQA 的完整谱系,并通过 Uptraining 实现低成本迁移。理解这一机制,是进一步学习 Transformer、BERT、GPT 等现代大模型的重要基础。