多头注意力

本质就三步

① 若干个自注意力,各自处理同一份输入(各有各的 W) ② 把它们的结果拼接起来 ③ 用一个线性投影压回原来大小

就这些。所谓「多头」,就是同时跑好几个自注意力, 每个关注不同的东西。

实际计算时为了快,几个头会打包成一个大矩阵一次算完—— 但数学上就是上面三步,一步不多。

手算一遍

取 dmodel=4d_{\text{model}} = 4,2 个头, 每个头 2 维。2 个 token:

x1=[1001],x2=[0110]x_1 = \begin{bmatrix} 1 & 0 & 0 & 1 \end{bmatrix}, \qquad x_2 = \begin{bmatrix} 0 & 1 & 1 & 0 \end{bmatrix}

为了能手算,W 取得很简单

头 1 只取前两维,头 2 只取后两维。

真实模型里这些 W 是训练出来的,不会这么整齐。 但流程完全一样。

① 头 1 先算

投影之后(这里 q、k、v 用同一份,只看流程):

q1=k1=v1=[10],q2=k2=v2=[01]q_1 = k_1 = v_1 = \begin{bmatrix} 1 & 0 \end{bmatrix}, \qquad q_2 = k_2 = v_2 = \begin{bmatrix} 0 & 1 \end{bmatrix}

打分,除以 2\sqrt{2}:

QK⊤2=[0.7071000.7071]\frac{QK^{\top}}{\sqrt{2}} = \begin{bmatrix} 0.7071 & 0 \\ 0 & 0.7071 \end{bmatrix}

softmax:

A1=[0.66980.33020.33020.6698]A_1 = \begin{bmatrix} 0.6698 & 0.3302 \\ 0.3302 & 0.6698 \end{bmatrix}

加权求和:

o1(1)=[0.66980.3302],o2(1)=[0.33020.6698]o_1^{(1)} = \begin{bmatrix} 0.6698 \\ 0.3302 \end{bmatrix}, \qquad o_2^{(1)} = \begin{bmatrix} 0.3302 \\ 0.6698 \end{bmatrix}

② 头 2 再算一遍

它看的是后两维,所以数字正好反过来:

q1=[01],q2=[10]q_1 = \begin{bmatrix} 0 & 1 \end{bmatrix}, \qquad q_2 = \begin{bmatrix} 1 & 0 \end{bmatrix}

分数和 softmax 跟头 1 一模一样(结构相同),但加权的是不同的 v:

o1(2)=[0.33020.6698],o2(2)=[0.66980.3302]o_1^{(2)} = \begin{bmatrix} 0.3302 \\ 0.6698 \end{bmatrix}, \qquad o_2^{(2)} = \begin{bmatrix} 0.6698 \\ 0.3302 \end{bmatrix}

这一步能看出「多头」的意义

同一个 x1x_1,头 1 给出的结果是 [0.6698,0.3302][0.6698, 0.3302],头 2 给出的是 [0.3302,0.6698][0.3302, 0.6698]。

两个头关注的东西不一样,所以结果不一样。

如果只用一个头,就只有一种看法。

③ 拼接

把两个头的结果直接接在一起,长度从 2 变回 4:

token1:[0.66980.33020.33020.6698]\text{token}_1: \begin{bmatrix} 0.6698 & 0.3302 & 0.3302 & 0.6698 \end{bmatrix}
token2:[0.33020.66980.66980.3302]\text{token}_2: \begin{bmatrix} 0.3302 & 0.6698 & 0.6698 & 0.3302 \end{bmatrix}

前两维来自头 1,后两维来自头 2。

④ 过 WoW_o

out=Wo⋅拼接结果\text{out} = W_o \cdot \text{拼接结果}

WoW_o 是 4×44 \times 4 的矩阵, 把拼接后的 4 维混合一遍再输出 4 维。

W_o 不能省

只拼接的话,前两维和后两维永远是两段分开的信息, 后续层没法把它们当整体用。

WoW_o 让两个头的结果互相看一眼, 真正融合成一个向量。

而且它保持维度不变——残差要相加,维度必须一样。

PyTorch 里有现成的

import torch.nn as nn attn = nn.MultiheadAttention( embed_dim=512, # 输入输出维度 num_heads=8, # 头数 batch_first=True, # 输入是 (batch, 长度, 维度) ) out, weights = attn(query, key, value)

一句话说清每个参数:

参数

意思

embed_dim

输入和输出的维度,必须是头数的整数倍

num_heads

跑几个自注意力

batch_first

默认 False,输入形状是 (长度, batch, 维度)

batch_first 是第一个坑

默认 batch_first=False,输入要写成 (长度, batch, 维度)——和大部分 PyTorch 层反着来。

写成 (batch, 长度, 维度) 不报错,但会把 batch 当长度算, 结果全错。

建议手动加 batch_first=True,省得记。

三个输入

它收三个参数 query, key, value,正好对应三种用法:

用法

怎么传

在哪

自注意力

attn(x, x, x)

编码器

跨注意力

attn(y, enc_out, enc_out)

解码器中间那层

掩蔽自注意力

attn(y, y, y, attn_mask=m)

解码器第一层

两个 mask 参数

别搞混,它们管的是两件事:

参数

屏蔽什么

形状

attn_mask

谁不许看谁(因果掩码)

(L, L)

key_padding_mask

哪些是补出来的 padding

(batch, L)

它返回两个东西

out, weights = attn(q, k, v) # out : 注意力输出,形状和 query 一样 # weights : 注意力权重,形状 (batch, 目标长度, 源长度)

第二个是送你的——训练用不上,但想看「模型在关注哪里」时直接拿来画。 第 36.12 课用自写实现画的那张对齐图,用这个现成的就不用自己存了。

一个数:参数

m = nn.MultiheadAttention(embed_dim=512, num_heads=8) print(sum(p.numel() for p in m.parameters())) # 1,050,624 print(m.in_proj_weight.shape) # torch.Size([1536, 512]) print(m.out_proj.weight.shape) # torch.Size([512, 512])

in_proj_weight 是 (1536, 512)—— 1536 = 3 × 512,就是把 WqW_q、WkW_k、WvW_v 三个矩阵叠在一起存。

这一行就说明了「实际计算用一个大矩阵」是什么意思: 三个投影合成一个,八个头也共用它。

参数和头数无关

4 × (512×512 + 512) = 1,050,624, 改成 16 个头还是这个数。

因为头数只是决定怎么切,不决定有多少权重。

这一课留下的三个数

数

值

含义

每个头维度

512 / 8 = 64

8 个头平分 512

in_proj_weight

(1536, 512)

3 × 512,三个投影叠在一起

总参数

1,050,624

和头数无关

下一课

零件全齐了。下一课自己手写一遍完整的 Transformer, 然后把 PyTorch 官方那个 nn.Transformer 拿来对照。