T03a Tutorial 3 上半:用 PyTorch 从零写注意力和多头注意力
Tutorial 3 前四个填空:Thinking Machines 例子的五步算法,Attention.forward 的四行代码,多头注意力怎么用 reshape 和 permute 把 128 维切成 4 个头再拼回去。
一句话版
Tutorial 3 要从零写一个 Transformer 来分类手写数字,这一页是上半场:先把注意力层写出来。核心只有四行代码:打分、缩放、softmax、加权求和。多头注意力是在这四行前后各加一次形状变换。
页面里所有张量形状都是按代码推算的,没有实际运行过。
先认识这几个词
读之前最好先懂 L07e 讲的自注意力,以及 Tutorial 2 的 PyTorch 基本写法。
| 词 | 全称 / 读法 | 一句人话 |
|---|---|---|
| query / key / value | 查询 / 键 / 值,简写 q、k、v | 每个元素由三个线性层各变出一个向量:q 去问,k 被问,v 是被取走的内容 |
| 点积 | dot product | 两个向量对应位置相乘再加总,越大表示越相关 |
| softmax | 读「soft max」 | 把一组分数变成全是正数、加起来等于 1 的权重 |
| d_k | key 的维度 | q 和 k 向量有多长;缩放时除以它的平方根 |
| 多头 | multi-head | 把向量切成几段,每段各算一份注意力,最后拼回去 |
| bmm | batch matrix multiply | 一次做很多个矩阵乘法:(n, a, b) 乘 (n, b, c) 得 (n, a, c) |
| permute | 读「per-mute」 | 只调换张量各维的顺序,不改里面的数 |
题目地图
课件发的是带答案版代码,课上让大家按行号填空。上半场四处:
| 填空 | 代码位置 | 要写什么 | 主要失分点 |
|---|---|---|---|
| 一 | Line #34~47,Attention.forward |
打分、缩放、softmax、加权 | permute 写错维度;softmax 沿错维 |
| 二 | Line #63~76,_reshape_to_batches |
把 128 维切成 4 个头 | 直接 reshape 不 permute |
| 三 | Line #84~99,_reshape_from_batches |
把 4 个头拼回来 | 忘了 batch 要先除以头数 |
| 四 | Line #114~125,MultiHeadAttention.forward |
和填空一相同的四步 | 无,抄一遍 |
开始前课件先用两个词的例子 “Thinking Machines” 把算法手算一遍,代码就是这个例子的矩阵版。
概念卡
1. 注意力四步:一个元素怎么从别的元素那里收集信息
人话定义:序列里每个元素拿自己的 q 去和所有元素的 k 比,比出来的分数变成权重,再按权重把大家的 v 加起来,作为自己的新表示。
例子:两个词 Thinking 和 Machines。Thinking 的 q1 与 k1 的点积是 112,与 k2 的是 96。除以 8 得 14 和 12,softmax 后是 0.88 和 0.12。所以 Thinking 的新向量 z1 由 88% 的 v1 和 12% 的 v2 组成。
常见误解
以为 q、k、v 是三份不同的输入 → 自注意力里它们都来自同一个 x,只是各过一个不同的 nn.Linear。三个线性层的参数在训练中各学各的。
回讲义:L07e Transformer 自注意力:去掉循环,只留 attention
2. 为什么要除以 √d_k
人话定义:向量越长,点积的数值越容易变大。分数一大,softmax 就几乎把全部权重压给最大的那一个,其余接近 0,梯度也跟着变得很小。除以 √d_k 把分数拉回一个温和的范围。
例子:代码写 dk = x_q.shape[-1],取 q 的最后一维。单头时 d_k 是 128,除以约 11.31;4 个头时每个头 32 维,除以约 5.66。例子里只差 2 分,权重比已经约 7.4 : 1,可见 softmax 对差距很敏感。
常见误解
以为多头时仍该除以 √128 → 每个头里点积只在 32 维上做,所以 d_k 是 32。代码取的是切头之后 x_q 的最后一维,正好是 32,不用手动改。
回讲义:L07e Transformer 自注意力:去掉循环,只留 attention
3. 多头:切成几段各算各的
人话定义:一个元素和别的元素之间可能同时有好几种关系。多头注意力把 128 维切成 4 段,每段 32 维单独算一份注意力,最后首尾拼回 128 维。
例子:课件里 “The animal didn’t cross the street because it was too tired” 这句,it 在一个头里关注 animal,在另一个头里关注 tired。每个头有自己的分数表,互不影响。
常见误解
以为多头要建 4 套线性层 → 代码只建一个 Linear(128, 128),算完再切成 4 段。一个大矩阵按输出切成 4 块,正好就是 4 个 128 → 32 的小矩阵,两种写法等价。
回讲义:L07d seq2seq 与 attention:翻译时每一步都回头看整句
4. bmm:把「有多少个矩阵」放在第一维
人话定义:torch.bmm 只接受三维张量,第一维是「有多少个独立的矩阵乘法」,后两维才是真正相乘的矩阵。所以多头时要把 batch 和头数合并成第一维。
例子:256 张图、每张 4 个头,合并后第一维是 1024,表示要做 1024 个互不相干的 (28, 32) @ (32, 28),每个得一张 28 × 28 的分数表。
常见误解
以为直接 reshape(1024, 28, 32) 就能切头 → 不先 permute,切出来的每一块会混着不同元素的数据。下面填空二会一步步看。
回讲义:L07e Transformer 自注意力:去掉循环,只留 attention
逐题拆解
热身:Thinking Machines 手算一遍
两个词先各自变成嵌入向量 x1、x2,再分别乘 W^Q、W^K、W^V 得到 q、k、v。课件只给分数,没给向量本身,所以从点积那一步开始看。
一步一步看
目标:跟着 Thinking 的 query 走完四步,看分数怎么变成权重、权重又怎么变成新向量 z1。
表格一列一列往右填,青绿色是这一步新算出来的那一列。
-
点积打分:q1 · k1 = 112,q1 · k2 = 96。
-
除以 √d_k:例子里 d_k = 64,√64 = 8,得 14 和 12。
-
softmax:e^14 / (e^14 + e^12) ≈ 0.88,另一个 0.12,加起来是 1。
-
加权求和:z1 = 0.88 · v1 + 0.12 · v2。
Machines 那一行同理,用 q2 去和 k1、k2 打分,得到 z2。把所有 q 叠成矩阵 Q,就能一次算出全部 z:softmax(QKᵀ / √d_k) V。
填空一:Attention.forward
def forward(self, x):
# x: (batch, seq_len, emb_dim)
x_q = self.linear_q(x)
x_k = self.linear_k(x)
x_v = self.linear_v(x)
qk = torch.bmm(x_q, x_k.permute(0, 2, 1)) # 打分 (batch, seq, seq)
dk = x_q.shape[-1]
qk /= math.sqrt(dk) # 缩放
attn = qk.softmax(-1) # 每行和为 1
out = torch.bmm(attn, x_v) # 加权 (batch, seq, emb)
return out
逐行看三个要点。x_k.permute(0, 2, 1) 只转置后两维,batch 维不动,这就是 Kᵀ。softmax(-1) 沿最后一维做:分数表第 i 行是第 i 个元素对所有元素的打分,这一行归一化才对。最后 bmm(attn, x_v) 用每行权重去加权所有 v。
填空二:把 128 维切成 4 个头
def _reshape_to_batches(self, x):
batch_size, seq_len, emb_dim = x.shape
sub_dim = emb_dim // self.num_heads
x = x.reshape(batch_size, seq_len, self.num_heads, sub_dim)
x = x.permute(0, 2, 1, 3)
x = x.reshape(batch_size * self.num_heads, seq_len, sub_dim)
return x
三步变形缺一不可。第一步 reshape 把每个元素的 128 维切成 4 段。permute 把「头」挪到「元素」前面,让同一个头的 28 个元素排在一起。最后一步把 batch 和头合并,交给 bmm。
一步一步看
目标:跟着 256 张图的一个 batch 走一遍多头注意力,看清每次变形之后形状是什么。
每帧多露出一行,青绿色是这一步新出现的形状。
-
reshape:
(256, 28, 128)变(256, 28, 4, 32),数字一个没变,只是换个看法。 -
permute:变成
(256, 4, 28, 32),头的维度到了元素前面。 -
合并:
(1024, 28, 32),1024 个独立的小注意力问题。 -
打分:
bmm得(1024, 28, 28),每个头一张分数表。 -
加权:再
bmm一次得(1024, 28, 32)。 -
拼回:倒着走一遍,回到
(256, 28, 128)。
填空三:把 4 个头拼回来
def _reshape_from_batches(self, x):
batch_size, seq_len, sub_dim = x.shape
batch_size //= self.num_heads
x = x.reshape(batch_size, self.num_heads, seq_len, sub_dim)
x = x.permute(0, 2, 1, 3)
embed_dim = self.num_heads * sub_dim
x = x.reshape(batch_size, seq_len, embed_dim)
return x
和填空二完全对称。进来时第一维是 1024,先除以头数还原成 256;permute(0, 2, 1, 3) 再把元素挪回头前面;最后把 4 × 32 拼回 128。这里的 permute 参数和填空二一样,因为交换第 1、2 维的逆操作还是它自己。
填空四:MultiHeadAttention.forward
def forward(self, x):
x_q = self.linear_q(x)
x_k = self.linear_k(x)
x_v = self.linear_v(x)
if self.num_heads > 1:
x_q = self._reshape_to_batches(x_q)
x_k = self._reshape_to_batches(x_k)
x_v = self._reshape_to_batches(x_v)
qk = torch.bmm(x_q, x_k.permute(0, 2, 1))
dk = x_q.shape[-1]
qk /= math.sqrt(dk)
attn = qk.softmax(-1)
out = torch.bmm(attn, x_v)
if self.num_heads > 1:
out = self._reshape_from_batches(out)
return out
中间四行和填空一一字不差,课件让大家自己写的就是这一段。MultiHeadAttention 继承自 Attention,三个线性层直接沿用父类的,__init__ 里只多存一个 num_heads。
可以单独运行的版本
下面把两个类和一段形状自检放在一起,复制进一个 .py 文件即可运行,不需要下载数据。本页没有运行过它,注释里的形状是推算值。
import math
import torch
import torch.nn as nn
class Attention(nn.Module):
def __init__(self, emb_dim):
super().__init__()
self.linear_q = nn.Linear(emb_dim, emb_dim)
self.linear_k = nn.Linear(emb_dim, emb_dim)
self.linear_v = nn.Linear(emb_dim, emb_dim)
def forward(self, x):
x_q, x_k, x_v = self.linear_q(x), self.linear_k(x), self.linear_v(x)
qk = torch.bmm(x_q, x_k.permute(0, 2, 1)) / math.sqrt(x_q.shape[-1])
return torch.bmm(qk.softmax(-1), x_v)
class MultiHeadAttention(Attention):
def __init__(self, emb_dim, num_heads):
super().__init__(emb_dim)
self.num_heads = num_heads
def _reshape_to_batches(self, x):
b, s, e = x.shape
sub = e // self.num_heads
x = x.reshape(b, s, self.num_heads, sub).permute(0, 2, 1, 3)
return x.reshape(b * self.num_heads, s, sub)
def _reshape_from_batches(self, x):
bh, s, sub = x.shape
b = bh // self.num_heads
x = x.reshape(b, self.num_heads, s, sub).permute(0, 2, 1, 3)
return x.reshape(b, s, self.num_heads * sub)
def forward(self, x):
x_q, x_k, x_v = self.linear_q(x), self.linear_k(x), self.linear_v(x)
if self.num_heads > 1:
x_q, x_k, x_v = (self._reshape_to_batches(t) for t in (x_q, x_k, x_v))
qk = torch.bmm(x_q, x_k.permute(0, 2, 1)) / math.sqrt(x_q.shape[-1])
attn = qk.softmax(-1)
out = torch.bmm(attn, x_v)
if self.num_heads > 1:
out = self._reshape_from_batches(out)
return out
if __name__ == '__main__':
x = torch.randn(256, 28, 128)
mha = MultiHeadAttention(128, num_heads=4)
print(mha._reshape_to_batches(x).shape) # 推算:torch.Size([1024, 28, 32])
print(mha(x).shape) # 推算:torch.Size([256, 28, 128])
y = mha._reshape_from_batches(mha._reshape_to_batches(x))
print(torch.equal(x, y)) # 推算:True,切了再拼回原样
最后一行能查出切和拼不配套:切了再拼,必须和原来一模一样。它查不出两边一起漏掉 permute 的情况,那样切了再拼仍是原样,但每个头里装的数据已经错了,见变式 2。
课件里的坑
- [与图不符] p.5 和 p.13 的多头注意力图在 Concat 之后还有一个 Linear(原论文的 W^O),代码拼回 128 维就直接返回,没有这一层。图上的结构里,各头的结果要再经一次线性变换混合;代码里各头的结果只是首尾相接。想和图一致,在
__init__里加self.linear_o = nn.Linear(emb_dim, emb_dim),forward最后返回self.linear_o(out),每层多 16,512 个参数。 - [与图不符] p.13 的图画了 8 个头(Z0 到 Z7),代码用的是 4 个头。头数只要能整除 128 就行。
- [课件留白] p.12 的图里每个头有自己的 W^Q、W^K、W^V,代码只建了一个
Linear(128, 128)再切 4 段。两者数学上等价,课件没说明。 - [课件留白] 代码注释说除以 √d_k 是为了避免 softmax 输入过大导致梯度消失,没有说多头时 d_k 应取每个头的维度。代码恰好取对了,自己改写时要留意。
课后 10 分钟:考点复习
这 10 分钟怎么用:先遮住必背清单默写七条;再做完整例题,全程手算;最后做两道变式题,先写形状再写代码。
必背
- 注意力四步:q 和每个 k 点积打分、除以 √d_k、沿最后一维 softmax、用权重对 v 加权求和
- Thinking Machines 例子:分数 112、96,除以 8 得 14、12,softmax 得 0.88、0.12
- torch.bmm(Q, K.permute(0, 2, 1)) 得到 (batch, seq, seq) 的分数表,每行是一个元素对全部元素的打分
- 除以 √d_k 防止点积过大让 softmax 一边倒、梯度变小;d_k 取 q 的最后一维
- 多头切分:(B, S, E) → reshape (B, S, h, E/h) → permute(0, 2, 1, 3) → reshape (B·h, S, E/h)
- 本例 B = 256、S = 28、E = 128、h = 4:切头后 (1024, 28, 32),分数表 (1024, 28, 28)
- 代码用一个 Linear(128, 128) 再切 4 段,等价于每个头各有一个 128 → 32 的小矩阵;课件图里 Concat 后的输出 Linear 代码没写
完整例题
三个元素,d_k = 4。q1 = (1, 1, 1, 1);k1 = (1, 1, 1, 1),k2 = (1, 1, 0, 0),k3 = (0, 0, 0, 0);v1 = (1, 0),v2 = (0, 1),v3 = (0, 0)。求第 1 个元素的注意力权重和输出 z1(保留两位小数)。
第一步,点积。 q1·k1 = 4,q1·k2 = 2,q1·k3 = 0。
第二步,缩放。 √d_k = √4 = 2,分数变成 2、1、0。
第三步,softmax。 e² ≈ 7.39,e¹ ≈ 2.72,e⁰ = 1,总和约 11.11。权重约 0.67、0.24、0.09,加起来是 1。
第四步,加权求和。 z1 = 0.67·(1, 0) + 0.24·(0, 1) + 0.09·(0, 0) = (0.67, 0.24)。
k3 是全零向量,它的分数是 0,权重仍有 0.09。softmax 不会给任何元素正好 0 的权重。
变式题(先自己做)
变式 1 把模型改成 emb_dim = 96、num_heads = 6,batch 为 32,序列长 28。(a)切头后 x_q 的形状?(b)分数表的形状?(c)dk 等于几?(d)能不能用 num_heads = 5?
提示
套必背第 5 条的三步变形。头数必须能整除 emb_dim。
参考答案与自检(非官方评分标准)
(a)sub_dim = 96 / 6 = 16,形状 (32 × 6, 28, 16) = (192, 28, 16)。
(b)(192, 28, 28)。分数表的后两维永远是序列长 × 序列长,和 emb_dim 无关。
(c)16,代码取切头后 x_q 的最后一维。
(d)不能。96 不能被 5 整除,emb_dim // 5 = 19,19 × 5 = 95 ≠ 96,第一次 reshape 就报错。
自检:(b)答出「和 emb_dim 无关」才算真懂分数表的含义。
变式 2 有人把 _reshape_to_batches 写成一行 return x.reshape(batch_size * self.num_heads, seq_len, sub_dim),省掉中间的 reshape 和 permute。会报错吗?结果对吗?
提示
拿 batch = 1、seq = 2、emb = 4、2 个头的小例子,把元素 1 的 4 个数记作 a1 a2 a3 a4,元素 2 记作 b1 b2 b3 b4,看直接 reshape 成 (2, 2, 2) 后第一块里装的是什么。
参考答案与自检(非官方评分标准)
不报错,元素总数一样,形状也对得上,但结果是错的。按内存顺序,数据是 a1 a2 a3 a4 b1 b2 b3 b4。直接 reshape 成 (2, 2, 2),第一块是 [[a1, a2], [a3, a4]],被当成「头 0 的两个元素」,其实是元素 1 的两半。正确做法下头 0 应是 [[a1, a2], [b1, b2]]。注意力于是在同一个元素的不同段之间做,不再是元素之间。
自检:说出「不报错但算错」并能指出第一块装了什么,算对。
闪卡自测
q、k、v 在自注意力里从哪来?
都来自同一个输入 x,各过一个 nn.Linear(emb_dim, emb_dim)。
x_k.permute(0, 2, 1) 做了什么?
把后两维转置,batch 维不动,得到 Kᵀ。
softmax 为什么沿最后一维做?
分数表第 i 行是第 i 个元素对所有元素的打分,要让每一行的权重和为 1。
Thinking Machines 例子里为什么除以 8?
例子里 d_k = 64,√64 = 8。
只差 2 分的两个分数,softmax 后权重比大约多少?
e² ≈ 7.4,约 7.4 : 1,也就是 0.88 对 0.12。
本例切头后的形状?
(1024, 28, 32):256 张图 × 4 个头,每个头 28 个元素、每个 32 维。
为什么要把 batch 和头合并成一维?
torch.bmm 只接受三维张量,第一维是独立矩阵乘法的个数。
拼回时 permute 的参数为什么和切头时一样?
两次都是交换第 1、2 维,交换两次就回到原样。
多头时 d_k 取多少?
每个头的维度,本例是 32,√32 ≈ 5.66。
代码少了课件图里的哪一层?
Concat 之后的输出 Linear(W^O)。
下一步
- 不看代码,把
Attention.forward的四行默写出来,标出每行之后的形状。 - 用完整例题的数据,再以 q2 = k2 = (1, 1, 0, 0) 为 query 算一遍第 2 个元素的权重和 z2。
- 跑一遍「可以单独运行的版本」,对照注释里的推算形状。
- 下半场把注意力装进 Transformer 层,再拼成整个分类器,见 T03b。
个人整理的学习笔记,不是官方材料;数字与结论以课件和讲师为准。