从 RNN 到 GQA:自注意力与多头注意力机制全解析

**摘要:**自注意力机制是 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) 加权求和,得到最终输出

自注意力的计算可以拆成五个连续步骤,每一步都有清晰的输入、输出和目的。

  1. 线性变换 :用三个不同的权重矩阵 W _Q、W _K、W_V 把输入 X 映射为 Q、K、V。这里的"线性变换"就是矩阵乘法,目的是把原始 token 向量投影到更利于查询、匹配和聚合的表示空间中。
  2. 计算注意力分数:对 Q 和 K 做点积,得到 n × n 的分数矩阵 S = QKᵀ。S 的第 i 行第 j 列表示第 i 个 Query 与第 j 个 Key 的相似度,分数越高,表示第 i 个位置越应该关注第 j 个位置。
  3. 缩放:将分数矩阵除以 √dk。这一步可以防止点积过大,保持 softmax 的梯度稳定。
  4. Softmax 归一化:对缩放后的矩阵按行做 softmax,得到注意力权重矩阵 A。每一行的权重都是正数,并且总和为 1,因此可以理解为一个概率分布。
  5. 加权求和:用权重矩阵 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 图示:自注意力计算流程图

下图用流程图表示自注意力从输入到输出的完整计算过程:

flowchart TD A[输入序列 X] --> B[线性变换生成 Q, K, V] B --> C[计算分数矩阵 Q K^T] C --> D[缩放除以 sqrt(d_k)] D --> E[按行 Softmax 归一化] E --> F[加权求和得到输出 O]

如果从矩阵形状变化的角度理解,这个流程可以概括为: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 维,保证输出维度与输入一致,方便后续接残差连接和层归一化。

整个流程可以用下面的流程图表示:

flowchart TD A[输入 X: n x d_model] --> B1[头1: 投影为 Q1,K1,V1] A --> B2[头2: 投影为 Q2,K2,V2] A --> B3[...] A --> B4[头h: 投影为 Qh,Kh,Vh] B1 --> C1[Attention 得到 head1] B2 --> C2[Attention 得到 head2] B3 --> C3[...] B4 --> C4[Attention 得到 headh] C1 --> D[Concat 拼接: n x h*d_v] C2 --> D C3 --> D C4 --> D D --> E[乘以 W_O: n x d_model] E --> F[输出 MultiHead]

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 小结:一张图看懂谱系

flowchart LR A[MHA: g = h 每头独立 K/V] --> B[GQA: 1 < g < h 每组共享 K/V] B --> C[MQA: g = 1 全部共享 K/V] B -.-> D[Uptraining MHA 均值池化 K/V 迁移]

从 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 等现代大模型的重要基础。

相关推荐
Flynn Liang21 分钟前
AI Agent 分层记忆体系实战:用 Redis 五类结构构建可淘汰、可追溯的长短期记忆
数据库·人工智能·redis
CyrusYiVPP25 分钟前
新用户第二周还剩几个?pandas做留存率cohort分析,数据分析实战第6期
人工智能·python
谙弆悕博士35 分钟前
多智能体架构详解:网状去中心化架构(Mesh对等P2P)
人工智能·架构·去中心化·p2p·多智能体·智能体·langgraph
吴佳浩7 小时前
我把 HAMi 摆回一台双卡机器上跑了一遍:GPU 编排的性能账,到底记在谁头上
人工智能·gpu
forest_0911 小时前
《AI 编程 Harness 实战手册》04|审批这道门:点了一百次“允许”,还剩多少作用?
人工智能·算法·prompt·agi
火山引擎开发者社区12 小时前
当 RPA 遇上 Agent:MUA 混合执行 Workflow 深度拆解
人工智能
严肃小白兔12 小时前
第 10/24 期:深度神经网络的自动求导机制与梯度验证
人工智能·神经网络·dnn
火山引擎开发者社区13 小时前
定档12.16-12.18!FORCE原动力大会上海见!
人工智能