自注意力、跨注意力、多头

这一课在哪

上一课讲清了注意力的三个角色:Q、K、V。

但没回答一个基本问题:这三个东西从哪来?

答案不唯一——Q、K、V 的来源不同,就是不同的注意力形态。

三种形态一张表

形态

Q 从哪来

K、V 从哪来

形状

自注意力

序列自己

同一个序列

n × n 方阵

跨注意力

一边(比如解码器)

另一边(比如编码器)

n × m 可不等

多头

不是第四种来源——是把上面任一种拆成 h 份并行做

自注意力:自己看自己

一句话里的每个词,去和同一句话里的所有词比一比。

import torch import torch.nn as nn d_model = 8 # 三个独立的线性层,把同一份输入变换成 Q、K、V query_proj = nn.Linear(d_model, d_model) key_proj = nn.Linear(d_model, d_model) value_proj = nn.Linear(d_model, d_model) x = torch.randn(3, d_model) # 3 个 token,每个 8 维 Q = query_proj(x) # (3, 8) K = key_proj(x) # (3, 8) V = value_proj(x) # (3, 8) print(Q.shape, K.shape, V.shape) # 都是 torch.Size([3, 8])

输入只有一份 x,但用三个不同的矩阵变成了三份。

问题

回答

为什么不用 x 自己当 Q、K、V

那样 QK⊤QK^{\top} 就变成「每个词和自己比」,永远是最大值

三个矩阵是分开的吗

分开的。三层各自训练,参数不共享

它在算什么

「小猫 坐 在 垫子 上」 「坐」这个 token 去和所有 token 比: 小猫 → 分数高(谁在坐?) 坐 → 分数高(自己) 在 → 中等 垫子 → 分数高(坐在哪?) 上 → 低

结果:每个 token 的新表示,都融合了它和别的 token 的关系。

自注意力在干什么,一句话

把每个词的表示,替换成「按相关性加权的所有词的混合」。

所以「坐」的新表示里,会带着「小猫」和「垫子」的信息。

这就是为什么自注意力能理解句子结构——它不是一个个词孤立地看。

跨注意力:一边问,另一边答

Q 来自一个序列,K 和 V 来自另一个序列。

src = torch.randn(5, d_model) # 编码器输出:5 个 token tgt = torch.randn(3, d_model) # 解码器当前:3 个 token Q = query_proj(tgt) # (3, 8) ← 从解码器来 K = key_proj(src) # (5, 8) ← 从编码器来 V = value_proj(src) # (5, 8) ← 从编码器来 scores = Q @ K.T print(scores.shape) # torch.Size([3, 5]) ← 不是方阵!

形状 3 × 5:3 个解码器位置,各自看 5 个编码器位置。

自注意力

跨注意力

Q 来源

序列 A

序列 A

K V 来源

序列 A

序列 B

分数矩阵

n × n

n × m

输出长度

等于输入

等于 Q 的长度

最后一行很关键

跨注意力的输出长度由 Q 决定,不是由 K/V 决定。

所以:你有 3 个位置要算,就给它 3 个 query; 候选有 5 个,就给它 5 个 key。

这就是注意力能「把变长输入压成另一个长度」的原因。

它用在哪

场景

Q 来自

K V 来自

翻译(加注意力)

解码器当前状态

编码器的所有输出

看图说话

解码器当前状态

CNN 提取的图像区域

语音识别

解码器当前状态

音频帧特征

Transformer 解码器

解码器自己

编码器输出

多头:拆开并行看

一个注意力只算一种相关性。但一句话里的关系有很多种:

「小猫 坐 在 垫子 上」 头 1:谁在做动作? 小猫 ↔ 坐 头 2:动作发生在哪? 坐 ↔ 垫子 头 3:语法关系(介词) 在 ↔ 垫子 头 4:词序 / 相邻关系 相邻的词

一个头只能学出一种模式。所以拆成多个头,每个头学一种。

class MultiHeadAttention(nn.Module): def __init__(self, d_model=256, num_heads=8): super().__init__() assert d_model % num_heads == 0 self.num_heads = num_heads self.d_k = d_model // num_heads # 每个头的维度 self.w_q = nn.Linear(d_model, d_model) self.w_k = nn.Linear(d_model, d_model) self.w_v = nn.Linear(d_model, d_model) self.w_o = nn.Linear(d_model, d_model) # 输出投影 def forward(self, x): batch, seq_len, _ = x.shape h, d_k = self.num_heads, self.d_k # ① 投影 + 拆头 Q = self.w_q(x).view(batch, seq_len, h, d_k).transpose(1, 2) K = self.w_k(x).view(batch, seq_len, h, d_k).transpose(1, 2) V = self.w_v(x).view(batch, seq_len, h, d_k).transpose(1, 2) # 现在形状是 (batch, h, seq_len, d_k) # ② 每个头各自算注意力 scores = Q @ K.transpose(-2, -1) / (d_k ** 0.5) weights = torch.softmax(scores, dim=-1) out = weights @ V # (batch, h, seq_len, d_k) # ③ 拼回来 out = out.transpose(1, 2).contiguous().view(batch, seq_len, -1) # ④ 输出投影 return self.w_o(out)

形状怎么走

设 batch=2, seq_len=10, d_model=256, num_heads=8:

步

形状

说明

输入 x

(2, 10, 256)

—

w_q(x)

(2, 10, 256)

不变

view(2,10,8,32)

(2, 10, 8, 32)

拆成 8 个头,每个 32 维

transpose(1,2)

(2, 8, 10, 32)

头提到前面,方便批量算

Q @ Kᵀ

(2, 8, 10, 10)

8 个头各一个 10×10

weights @ V

(2, 8, 10, 32)

拼回

(2, 10, 256)

8 × 32 = 256

transpose 那一步为什么必要

(2, 10, 8, 32) 直接做矩阵乘是不行的—— 要算的是最后两个维度之间的乘积。

把头提到第 2 维之后变成 (2, 8, 10, 32), 最后两维就是 10×32,可以批量算 8 个头。

算完再 transpose 回来。

多头的参数量

def count_mha(d_model): # 四个投影矩阵:w_q, w_k, w_v, w_o return 4 * (d_model * d_model + d_model) def count_single(d_model): # 单头也要三个投影(没有 w_o) return 3 * (d_model * d_model + d_model) print(count_single(256)) # 196,608 print(count_mha(256)) # 262,144 print(262144 / 196608) # 1.333

配置

参数

相对

单头,d=256

196,608

1×

8 头,d=256

262,144

1.33×

多头几乎不增加参数

8 个头不是在 256 维上做 8 遍——那样参数是 8 倍。

是把 256 维切成 8 份,每份 32 维, 8 个头各算 32 维的注意力。

所以总计算量和单头差不多,只多了一个输出投影 w_o(+33%)。

头数怎么选

d_model

常见头数

每头维度

256

8

32

512

8

64

768(BERT-base)

12

64

1024(GPT-2 large)

16

64

每头 64 维是个常见的甜点。太小了学不出东西,太大了和单头没区别。

三种形态怎么组合

实际网络里它们是叠起来用的。以 Transformer 为例:

位置

用哪种

Q / KV 来源

编码器第 1~6 层

多头自注意力

都是编码器自己

解码器第 1~6 层的第一个

多头自注意力(带掩码)

都是解码器自己

解码器第 1~6 层的第二个

多头跨注意力

Q 来自解码器,KV 来自编码器

三种形态拼在一起,就是 Transformer。第 37 章会展开。

这一课留下的三个数

数

值

含义

自注意力分数

n × n

方阵

跨注意力分数

n × m

输出长度由 n(Q)决定

多头参数

单头的 1.33 倍

只多一个 w_o

下一课

三种形态都认识了,但还没真正算过一遍。

下一课开始手算——先算自注意力, 从 X 乘 W_q/W_k/W_v 一路算到输出, 每一步都给具体数字。