返回专栏
· 18 分钟阅读

Multi-Head Attention 多头注意力:从并行注意力计算到多子空间信息融合


一、什么是 Multi-Head Attention?

Multi-Head Attention(多头注意力,简称 MHA)是 Transformer 中用于增强信息交互能力的注意力机制。

它的核心思想是:

不只使用一组 Query、Key、Value 计算注意力,而是使用多组不同的投影矩阵,在多个表示子空间中并行执行 Attention,最后将各个注意力头的输出融合。

在单头 Self-Attention 中,模型通过一组 Q、K、V 建立 Token 之间的关联。

而 Multi-Head Attention 使用多个注意力头,每个 Head 都拥有独立的 Q、K、V 投影参数。

例如,一个包含 12 个注意力头的模型,可以同时执行 12 组不同的注意力计算。

flowchart TB
    A["输入隐藏表示 X"] --> B["多组独立线性投影"]

    B --> C["Head 1"]
    B --> D["Head 2"]
    B --> E["Head 3"]
    B --> F["Head 12"]

    C --> G["Concat 拼接"]
    D --> G
    E --> G
    F --> G

    G --> H["输出线性投影"]
    H --> I["Multi-Head Attention 输出"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style D fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style F fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#EAF3EC,stroke:#83A995,color:#315D49
    style I fill:#E5F0E9,stroke:#83A995,color:#315D49

多头注意力并不是简单地将一个 Attention 计算重复多次,而是通过不同的可学习投影矩阵,让每个 Head 在不同的表示子空间中学习信息匹配与聚合方式。

二、为什么需要多头注意力?

理解 Multi-Head Attention,首先需要理解单头注意力的局限。

2.1 单头注意力的计算方式

标准 Scaled Dot-Product Attention:

Attention(Q,K,V)= Softmax\left( \frac{QK^T}{\sqrt{d_k}} \right)V

其中:

  • Q:Query,查询向量。
  • K:Key,键向量。
  • V:Value,值向量。
  • d_k:Key 的特征维度。

假设输入隐藏维度:

d_{model}=768

单头注意力可以直接将 Q、K、V 投影到 768 维空间:

Q,K,V\in\mathbb{R}^{n\times768}

然后执行一次 Attention 计算。

这意味着整个注意力机制只使用一组投影空间进行匹配和信息聚合。

2.2 单一表示空间的限制

自然语言中的 Token 关系具有多样性。

例如:

人工智能正在改变软件开发方式。

模型可能需要同时建模:

  • 人工智能与改变之间的语义关系。
  • 软件与开发之间的组合关系。
  • 主语与谓语之间的语法关系。
  • 不同位置之间的上下文关联。

这些关系并不一定能够通过单一投影空间充分表达。

如果只有一个注意力头,所有信息匹配都需要通过同一组 Q、K、V 投影完成。

多头注意力允许模型使用多组不同的投影参数,学习不同的关联模式。

需要注意:这并不意味着每个 Head 都会自动形成一种明确的语言学功能。实际注意力头可能存在功能重叠,也可能学习到复杂的组合特征。

2.3 多头注意力的核心优势

优势 说明
多子空间建模 在不同投影空间中学习关联关系
并行计算 多个 Head 可以并行执行注意力运算
表达能力 增加注意力机制的表示灵活性
信息融合 将不同 Head 的结果组合成统一表示
端到端学习 各 Head 的投影参数通过训练自动优化

三、多头注意力的整体结构

Multi-Head Attention 可以拆分为五个主要步骤:

  1. 输入隐藏表示。
  2. 生成多组 Q、K、V。
  3. 每个 Head 独立计算 Attention。
  4. 拼接所有 Head 的输出。
  5. 通过输出投影矩阵融合信息。
flowchart TB
    A["输入 X"] --> B["生成多组 Q、K、V"]
    B --> C["多个 Attention Head 并行计算"]
    C --> D["拼接各 Head 输出"]
    D --> E["输出线性投影"]
    E --> F["得到最终输出"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style D fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#E5F0E9,stroke:#83A995,color:#315D49

下面从数学计算角度展开。

四、第一步:生成多组 Q、K、V

假设输入隐藏表示为:

X\in\mathbb{R}^{n\times d_{model}}

其中:

  • n:序列长度。
  • d_{model}:模型隐藏维度。

假设注意力头数量为 h。

经典 Multi-Head Attention 通常将隐藏维度平均分配给每个 Head:

d_k=d_v=\frac{d_{model}}{h}

例如:

d_{model}=768
h=12

则:

d_k=d_v=64

每个 Head 使用独立的投影矩阵:

W_i^Q\in\mathbb{R}^{d_{model}\times d_k}
W_i^K\in\mathbb{R}^{d_{model}\times d_k}
W_i^V\in\mathbb{R}^{d_{model}\times d_v}

第 i 个 Head 的计算为:

Q_i=XW_i^Q
K_i=XW_i^K
V_i=XW_i^V

其中:

Q_i,K_i\in\mathbb{R}^{n\times d_k}
V_i\in\mathbb{R}^{n\times d_v}

4.1 为什么每个 Head 使用独立的投影矩阵?

如果所有 Head 共享同一组 Q、K、V 投影矩阵,那么它们得到的输入表示就会相同。

即使后续计算采用相同结构,也难以形成真正独立的注意力表示。

通过为每个 Head 分配独立参数:

W_1^Q,W_2^Q,\ldots,W_h^Q

模型可以在不同投影空间中学习不同的匹配模式。

例如:

  • Head 1 可能更关注某类局部关联。
  • Head 2 可能更关注远距离信息。
  • Head 3 可能更关注特定上下文特征。

这些是帮助理解的可能性,不是模型对 Head 功能的固定分配。

4.2 多组投影的矩阵实现

实际工程中,通常不会真的为每个 Head 单独调用一次线性层。

更常见的方式是将所有 Head 的投影矩阵合并:

W^Q\in\mathbb{R}^{d_{model}\times(hd_k)}
W^K\in\mathbb{R}^{d_{model}\times(hd_k)}
W^V\in\mathbb{R}^{d_{model}\times(hd_v)}

一次性计算:

Q=XW^Q
K=XW^K
V=XW^V

然后将结果重新组织为多个 Head。

flowchart TB
    A["输入 X"] --> B["Q 线性投影"]
    A --> C["K 线性投影"]
    A --> D["V 线性投影"]

    B --> E["Q 维度重组"]
    C --> F["K 维度重组"]
    D --> G["V 维度重组"]

    E --> H["多个 Query Head"]
    F --> I["多个 Key Head"]
    G --> J["多个 Value Head"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style F fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style G fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style H fill:#E5F0E9,stroke:#83A995,color:#315D49
    style I fill:#E5F0E9,stroke:#83A995,color:#315D49
    style J fill:#E5F0E9,stroke:#83A995,color:#315D49

这种方式能够充分利用矩阵乘法的并行计算能力,减少大量独立小矩阵运算带来的调度开销。

五、第二步:每个 Head 独立执行 Attention

生成多组 Q、K、V 后,每个 Head 独立执行标准 Scaled Dot-Product Attention。

第 i 个 Head:

head_i= Attention(Q_i,K_i,V_i)

展开:

head_i= Softmax\left( \frac{Q_iK_i^T}{\sqrt{d_k}} \right)V_i

每个 Head 都有自己的:

  • Query 表示。
  • Key 表示。
  • Value 表示。
  • 注意力分数矩阵。
  • 注意力权重矩阵。
  • 输出表示。

5.1 每个 Head 的计算维度

假设:

Q_i\in\mathbb{R}^{n\times64}
K_i\in\mathbb{R}^{n\times64}
V_i\in\mathbb{R}^{n\times64}

那么:

Q_iK_i^T\in\mathbb{R}^{n\times n}

经过 Softmax:

A_i\in\mathbb{R}^{n\times n}

最后:

head_i=A_iV_i

得到:

head_i\in\mathbb{R}^{n\times64}

每个 Head 的输出序列长度保持不变,但特征维度为 64。

5.2 多头注意力并行计算

假设有 4 个 Head:

flowchart TB
    A["输入 X"] --> B["Head 1:Attention"]
    A --> C["Head 2:Attention"]
    A --> D["Head 3:Attention"]
    A --> E["Head 4:Attention"]

    B --> F["head 1"]
    C --> G["head 2"]
    D --> H["head 3"]
    E --> I["head 4"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style G fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style H fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style I fill:#F5F8F4,stroke:#B5CBBB,color:#40594A

这些 Head 在数学上相互独立,可以并行执行。

在 GPU 上,实际实现通常将 Head 维度与 Batch 维度结合起来组织计算,以便使用高效的批量矩阵运算。

六、第三步:Concat 拼接所有 Head

所有 Head 计算完成后,需要将输出组合起来。

假设:

head_i\in\mathbb{R}^{n\times d_v}

共有 h 个 Head。

拼接:

H=Concat(head_1,head_2,\ldots,head_h)

得到:

H\in\mathbb{R}^{n\times(hd_v)}

在经典 Transformer 中:

hd_v=d_{model}

因此:

H\in\mathbb{R}^{n\times d_{model}}

6.1 拼接不是求和

Concat 与 Sum 是两种不同的操作。

假设两个 Head 的输出:

head_1=[1,2]
head_2=[3,4]

Concat:

Concat(head_1,head_2)=[1,2,3,4]

Sum:

head_1+head_2=[4,6]

Concat 保留了不同 Head 的特征维度,而 Sum 会将对应位置的特征直接相加。

多头注意力采用 Concat,是为了保留各个 Head 的输出信息,供后续投影层进行融合。

6.2 拼接后的维度

假设:

n=128
h=12
d_v=64

那么:

head_i\in\mathbb{R}^{128\times64}

拼接后:

H\in\mathbb{R}^{128\times768}

此时,隐藏维度重新恢复为 768。

七、第四步:输出线性投影

拼接完成后,还需要经过一个输出投影矩阵:

W^O\in\mathbb{R}^{(hd_v)\times d_{model}}

最终输出:

MultiHead(Q,K,V)= Concat(head_1,\ldots,head_h)W^O

其中:

O=HW^O

在经典配置中:

hd_v=d_{model}

因此:

W^O\in\mathbb{R}^{d_{model}\times d_{model}}

最终:

O\in\mathbb{R}^{n\times d_{model}}

7.1 为什么还需要输出投影?

Concat 只是将不同 Head 的特征放在一起,并没有主动学习如何融合这些特征。

输出投影矩阵 W^O 负责对拼接后的特征进行可学习的线性组合。

它可以:

  • 组合不同 Head 的信息。
  • 学习不同特征维度之间的关系。
  • 将拼接结果映射到模型隐藏维度。
  • 为后续网络层提供统一的表示空间。

7.2 输出投影不是简单的维度恢复

虽然在经典配置中,拼接后维度已经等于 d_{model},但输出投影仍然具有重要作用。

即使输入输出维度相同,矩阵乘法也会重新组合不同 Head 的特征。

因此,输出投影不仅是形状调整,更是多头信息融合的一部分。

八、Multi-Head Attention 的完整数学公式

将所有步骤合并。

8.1 单个 Head

第 i 个 Head:

head_i= Softmax\left( \frac{XW_i^Q(XW_i^K)^T}{\sqrt{d_k}} \right)XW_i^V

8.2 多头拼接

H=Concat(head_1,\ldots,head_h)

8.3 输出投影

O=HW^O

完整公式:

\boxed{ MultiHead(Q,K,V)= Concat(head_1,\ldots,head_h)W^O }

其中:

\boxed{ head_i=Attention(Q_i,K_i,V_i) }

而:

\boxed{ Attention(Q_i,K_i,V_i)= Softmax\left( \frac{Q_iK_i^T}{\sqrt{d_k}} \right)V_i }

完整计算结构:

flowchart TB
    A["输入隐藏表示 X"] --> B["生成多组 Q、K、V"]
    B --> C["各 Head 独立计算 Scaled Dot-Product Attention"]
    C --> D["Concat 拼接"]
    D --> E["输出投影 Wᴼ"]
    E --> F["最终输出 O"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style D fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#E5F0E9,stroke:#83A995,color:#315D49

九、张量维度:多头注意力如何组织数据?

理解 Multi-Head Attention,必须掌握张量维度的变化。

假设:

参数 数值 含义
Batch Size 32 批次大小
Sequence Length 128 序列长度
Hidden Dimension 768 隐藏维度
Head 数量 12 注意力头数量
Head Dimension 64 每个头的维度

满足:

768=12\times64

9.1 输入张量

X\in\mathbb{R}^{32\times128\times768}

9.2 Q、K、V 投影

分别进行线性变换:

Q,K,V\in\mathbb{R}^{32\times128\times768}

9.3 拆分 Head 维度

将最后一个维度拆分为:

768=12\times64

再调整维度顺序:

Q,K,V\in \mathbb{R}^{32\times12\times128\times64}

这里各维度的含义:

  • 32:Batch。
  • 12:Head。
  • 128:Sequence Length。
  • 64:Head Dimension。

9.4 计算 Attention Score

每个 Head 单独计算:

QK^T

得到:

S\in \mathbb{R}^{32\times12\times128\times128}

注意力矩阵的最后两个维度分别对应 Query 位置和 Key 位置。

9.5 Softmax

A=Softmax(S)

得到:

A\in \mathbb{R}^{32\times12\times128\times128}

9.6 聚合 Value

O=AV

得到:

O\in \mathbb{R}^{32\times12\times128\times64}

9.7 合并 Head

将 Head 维度与 Head Dimension 合并:

O\in\mathbb{R}^{32\times128\times768}

9.8 输出投影

经过 W^O 后:

O\in\mathbb{R}^{32\times128\times768}

完整维度变化:

阶段 张量形状
输入 X [32, 128, 768]
Q/K/V 投影 [32, 128, 768]
Head 拆分 [32, 12, 128, 64]
Attention Score [32, 12, 128, 128]
Softmax 权重 [32, 12, 128, 128]
Value 聚合 [32, 12, 128, 64]
Head 合并 [32, 128, 768]
输出投影 [32, 128, 768]

十、多头注意力的参数量

多头注意力的参数量主要来自四组线性投影:

  • Query 投影。
  • Key 投影。
  • Value 投影。
  • Output 投影。

假设:

d_{model}=d

且:

hd_k=hd_v=d

那么:

W^Q,W^K,W^V,W^O

每个矩阵的参数量约为:

d^2

因此总参数量约为:

\boxed{ 4d^2 }

如果每个线性层都包含偏置,则额外增加约:

4d

10.1 参数量示例

假设:

d_{model}=768

则四个投影矩阵的参数量:

4\times768^2
=2,359,296

如果包含四组偏置:

4\times768=3,072

总参数量:

2,362,368

这里没有计算其他 Transformer 组件的参数,例如 FFN、LayerNorm 等。

10.2 Head 数量会不会增加总参数量?

在保持 d_{model} 不变,并且每个 Head 的维度按比例调整时,标准 MHA 的投影参数量基本不随 Head 数量变化。

例如:

Hidden Dimension Head 数量 Head Dimension 总投影参数量(不含偏置)
768 8 96 2,359,296
768 12 64 2,359,296
768 16 48 2,359,296

Head 数量增加时,单个 Head 的维度相应减少。

但这不意味着计算行为完全相同。不同 Head 数量会改变注意力分组、投影空间划分和模型表达方式。

十一、多头注意力的计算复杂度

Multi-Head Attention 的计算主要包括:

  1. Q、K、V 线性投影。
  2. QK 转置点积。
  3. Softmax。
  4. Attention 权重与 V 相乘。
  5. 输出线性投影。

假设:

  • 序列长度为 n。
  • 隐藏维度为 d。
  • Head 数量为 h。
  • 每个 Head 的维度为 d/h。

11.1 Q、K、V 投影

三个线性投影的计算量约为:

3O(nd^2)

11.2 QK 转置点积

每个 Head 的计算量:

O\left(n^2\frac{d}{h}\right)

所有 Head 合计:

h\times O\left(n^2\frac{d}{h}\right)

得到:

O(n^2d)

11.3 Attention 与 V 相乘

复杂度同样约为:

O(n^2d)

11.4 输出投影

复杂度约为:

O(nd^2)

11.5 总复杂度

忽略 Softmax、Mask 等相对较小的操作:

\boxed{ O(nd^2+n^2d) }

更具体地看:

O(4nd^2+2n^2d)

这里的常数系数取决于 FLOPs 计数方式。

需要注意:

  • nd^2 主要来自线性投影。
  • n^2d 主要来自注意力分数计算和 Value 聚合。

当序列长度非常大时,二次项会成为重要的计算与内存瓶颈。

十二、Attention 矩阵为什么容易成为显存瓶颈?

多头注意力需要为每个 Batch、每个 Head 计算一个注意力矩阵:

A\in\mathbb{R}^{B\times h\times n\times n}

其元素数量为:

Bhn^2

假设:

B=32,\quad h=12,\quad n=4096

注意力矩阵元素数量:

32\times12\times4096^2

约为:

6.44\times10^9

如果每个元素使用 FP16 或 BF16,占用 2 字节,仅完整存储一个这样的矩阵就需要约 12 GiB 显存。

实际训练还可能涉及 Softmax 中间结果、反向传播所需数据及其他激活值,因此显存压力更大。

12.1 FlashAttention

FlashAttention 是针对 Attention 计算优化的重要技术。

它通过分块计算、在线 Softmax 和优化 GPU 显存访问,减少完整注意力矩阵的物化与存储。

核心目标:

  • 减少高成本显存读写。
  • 降低中间矩阵的显存占用。
  • 提高 GPU 计算效率。
  • 保持标准注意力计算目标,在数值精度允许的范围内得到等价或近似数值结果。

需要注意,FlashAttention 不改变 Multi-Head Attention 的基本 Q、K、V 结构,而是优化其计算实现。

十三、MHA、MQA、GQA:多头注意力的三种架构

标准 MHA 在每个 Query Head 上都使用独立的 Key 和 Value Head。

但在大语言模型推理时,KV Cache 会占用大量显存。

为了降低 KV Cache 成本,研究和工程实践中出现了 MQA 与 GQA。

13.1 MHA:Multi-Head Attention

标准 MHA:

  • 多个 Query Head。
  • 多个 Key Head。
  • 多个 Value Head。
  • Query Head 与 KV Head 数量相同。

假设:

H_Q=H_K=H_V=16

每个 Query Head 都有对应的 KV Head。

13.2 MQA:Multi-Query Attention

MQA 保留多个 Query Head,但所有 Query Head 共享一组 Key 和 Value。

例如:

H_Q=16
H_{KV}=1

其优势是:

  • 减少 KV Cache 的存储量。
  • 降低推理时读取 KV 数据的带宽需求。
  • 提高部分自回归推理场景下的效率。

但共享 KV 也会改变模型的信息表达方式,可能带来效果与效率之间的权衡。

13.3 GQA:Grouped-Query Attention

GQA 是 MHA 和 MQA 之间的一种折中结构。

多个 Query Head 分组共享一组 Key 和 Value。

例如:

H_Q=16
H_{KV}=4

每 4 个 Query Head 共享一组 KV Head。

13.4 三种结构对比

结构 Query Head KV Head KV 共享方式
MHA 16 16 每个 Query Head 独立使用 KV
MQA 16 1 所有 Query Head 共享 KV
GQA 16 4 每组 Query Head 共享 KV