← COMP5541 全部讲次
T03a · 第 10 周

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。

表格一列一列往右填,青绿色是这一步新算出来的那一列。

  1. 点积打分:q1 · k1 = 112,q1 · k2 = 96。

    第 1 步:Thinking 的 q1 分别与 Thinking 的 k1、Machines 的 k2 做点积,得 112 和 96

  2. 除以 √d_k:例子里 d_k = 64,√64 = 8,得 14 和 12。

    第 2 步:两个分数各除以 8,112 变 14,96 变 12

  3. softmax:e^14 / (e^14 + e^12) ≈ 0.88,另一个 0.12,加起来是 1。

    第 3 步:14 和 12 经 softmax 变成权重 0.88 和 0.12,两者之和为 1

  4. 加权求和:z1 = 0.88 · v1 + 0.12 · v2。

    第 4 步:权重分别乘 v1、v2 再相加,得到 Thinking 的新表示 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 走一遍多头注意力,看清每次变形之后形状是什么。

每帧多露出一行,青绿色是这一步新出现的形状。

  1. reshape:(256, 28, 128) 变 (256, 28, 4, 32),数字一个没变,只是换个看法。

    多头第 1 步:线性层输出 (256, 28, 128) 经 reshape 变成 (256, 28, 4, 32),128 维切成 4 段

  2. permute:变成 (256, 4, 28, 32),头的维度到了元素前面。

    多头第 2 步:permute(0, 2, 1, 3) 后形状 (256, 4, 28, 32),头的维度移到序列维前面

  3. 合并:(1024, 28, 32),1024 个独立的小注意力问题。

    多头第 3 步:reshape 合并 batch 和头,形状 (1024, 28, 32)

  4. 打分:bmm 得 (1024, 28, 28),每个头一张分数表。

    多头第 4 步:q 与 k 转置做 bmm,得到 (1024, 28, 28) 的分数表,softmax 沿最后一维

  5. 加权:再 bmm 一次得 (1024, 28, 32)。

    多头第 5 步:权重表 (1024, 28, 28) 乘 v (1024, 28, 32),得到每个元素 32 维的新表示

  6. 拼回:倒着走一遍,回到 (256, 28, 128)。

    多头第 6 步:经 _reshape_from_batches 倒着变形,4 个头的 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 分钟怎么用:先遮住必背清单默写七条;再做完整例题,全程手算;最后做两道变式题,先写形状再写代码。

必背

  1. 注意力四步:q 和每个 k 点积打分、除以 √d_k、沿最后一维 softmax、用权重对 v 加权求和
  2. Thinking Machines 例子:分数 112、96,除以 8 得 14、12,softmax 得 0.88、0.12
  3. torch.bmm(Q, K.permute(0, 2, 1)) 得到 (batch, seq, seq) 的分数表,每行是一个元素对全部元素的打分
  4. 除以 √d_k 防止点积过大让 softmax 一边倒、梯度变小;d_k 取 q 的最后一维
  5. 多头切分:(B, S, E) → reshape (B, S, h, E/h) → permute(0, 2, 1, 3) → reshape (B·h, S, E/h)
  6. 本例 B = 256、S = 28、E = 128、h = 4:切头后 (1024, 28, 32),分数表 (1024, 28, 28)
  7. 代码用一个 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)。

下一步

  1. 不看代码,把 Attention.forward 的四行默写出来,标出每行之后的形状。
  2. 用完整例题的数据,再以 q2 = k2 = (1, 1, 0, 0) 为 query 算一遍第 2 个元素的权重和 z2。
  3. 跑一遍「可以单独运行的版本」,对照注释里的推算形状。
  4. 下半场把注意力装进 Transformer 层,再拼成整个分类器,见 T03b。
下一讲 →
T03b T03b Tutorial 3 下半:把注意力装成 Transformer 层,拼出图像分类器

个人整理的学习笔记,不是官方材料;数字与结论以课件和讲师为准。