第 3 章 编码注意力机制
第 3 章 编码注意力机制
本章来源:本文整理自 LLMs-from-scratch 仓库的 ch03/01_main-chapter-code/ch03.ipynb,原书为 Sebastian Raschka《Build a Large Language Model (From Scratch)》。
这章要解决什么问题
第 1 章我们说过,LLM 的架构根基是 Transformer,而 Transformer 的心脏就是注意力(attention)。第 2 章我们把文字变成了一个个向量(token 嵌入)。那么问题来了:
一堆各自独立的向量,怎么才能"互相交流",理解一句话的整体意思?
这就是这一章要解决的事。我们要亲手写出注意力机制,而且是从最简陋的版本一步步打磨成 GPT 真正用的版本:
没有权重的基础自注意力 → 带可训练权重的自注意力 → 因果注意力(不许偷看未来) → 多头注意力(多位专家同时看)读完之后,你会拥有一个能直接塞进 GPT 的注意力模块。这一章是本部分最核心的一章,代码量也最大,但别怕——它的主线其实只有一句话:让每个词按"相关程度"去加权邻居的信息。
用大白话讲原理
先看个老问题:逐字翻译为什么不靠谱
在 Transformer 之前,机器翻译常用编码器-解码器 RNN(recurrent neural network,循环神经网络)。套路是:编码器先读完整句源语言,把整句话压成一个隐藏状态(hidden state,可以理解成网络的"记忆"),再把这一坨记忆交给解码器去生成译文。
问题出在"压成一坨"上:
- 原文越长,压得越狠,信息丢得越多——就像把一本书硬塞进一张便利贴。
- 逐词翻译行不通,因为两种语言的语序、语法结构不一样。中文说"我昨天在公园看到一只很可爱的猫",英文可能得说"I saw a very cute cat in the park yesterday",你没法按位置一一对应。
关键点:把整句信息压缩进单一隐藏状态,长句子必然失真。我们需要一种机制,让解码器在生成每个词时,能回头直接查看原文的每个词,而不是只依赖那坨被压扁的记忆。
注意力:让每个词自己去找"该看谁"
注意力的思路非常朴素:生成某个输出词时,不要只看那个压缩记忆,而是允许模型直接访问所有输入 token,并自己判断该重点看谁。
举个你每天都在做的例子:你读"我走进银行,河堤边风很大"这句话时,"银行"到底是存钱的地方还是河岸?你需要回头看"河堤"这个词才能确定。这个"回头看、判断谁和当前词最相关"的动作,就是注意力。
自注意力(self-attention)更进一步:它让序列里的每个位置都能和同一序列里的所有其它位置互动,算出彼此的相关性,然后按相关性加权融合。注意"self"这个字——它是自己跟自己算,输入和参与计算的来源是同一段文本。
自注意力长什么样?先看一个极简玩具版
在动真格之前,作者先给了一个没有任何可训练权重的极简版本(3.3.1 节)。它不是 Transformer 里真正用的注意力,纯粹为了让你看清"加权求和"这套动作。
假设输入是一句已经嵌入成向量的文本,比如 "Your journey starts with one step"(按第 2 章的流程变成了 token 嵌入):
- 是表示 "Your" 的 维向量, 是 "journey" 的向量,以此类推。
- 目标:为每个输入 算出一个上下文向量 (context vector,维度与 相同)。
- 是所有输入 的加权和。
什么叫"上下文向量"?拿 (journey)举例,它的上下文向量 就是所有词按权重揉在一起的结果——你可以把它看成 的一个"升级版",除了自己的信息,还融入了与当前任务相关的其他词的信息。
这里有两个词要分清(后面反复用):
- 注意力分数(attention scores):还没归一化的原始权重,通常记作 (希腊字母 omega)。
- 注意力权重(attention weights):分数经过归一化(加起来等于 1)之后的结果。
第 1 步:算注意力分数
我们拿第二个词当查询(query),即 ,让它和每个输入做点积(dot product,两个向量对应相乘再求和,用来衡量相似度):
- ... 一直到
下标 "21" 的意思是:用第 2 个元素当查询,去和第 1 个元素算。
为了把过程看清楚,书里用一句话 "Your journey starts with one step" 举例,把它按第 2 章的流程嵌成 6 个 3 维向量(行是词、列是嵌入维度,故意把维度设得很小方便手算):Your = [0.43, 0.15, 0.89]、journey = [0.55, 0.87, 0.66]、starts = [0.57, 0.85, 0.64]、with = [0.22, 0.58, 0.33]、one = [0.77, 0.25, 0.10]、step = [0.05, 0.80, 0.55]。
有了这组输入,把查询(第 2 个词 journey)依次和 6 个词做点积,就得到它对应的 6 个注意力分数。点积其实就是"逐元素相乘再求和"的简写——torch.dot(x_i, query) 等价于手动写一层循环累加 ,只是前者是优化过的向量化写法。
第 2 步:把分数归一化,让它们加起来等于 1
算完的分数是一串原始可正可负的数,还需要归一化,让它们加起来等于 1,才能当作"权重"用。最土的办法是直接除以总和,但实践中更推荐用 softmax:它对极端值更稳,训练时的梯度性质也更好。
一个朴素版 softmax 就是"先取指数再除以指数之和",效果同样是归一化到总和为 1。不过这种朴素写法在数值很大或很小时会溢出/下溢(指数会把大数炸上天、把小数值压成 0),所以实际都用 PyTorch 内置的 torch.softmax——它在内部做了数值稳定处理,结果一致但不会爆。
第 3 步:加权求和,得到上下文向量
最后一步,把每个输入 乘上它的注意力权重,再全部加起来,就得到 ——也就是"用权重把 6 个词揉成一个向量"。
到这里,你其实已经掌握了注意力的全部内核:打分 → 归一化 → 加权求和。剩下的花活,都是在这个骨架上加东西。
一次算完所有词:把上面三步推广开
上面我们只算了第 2 个词。实际上每个词都要算一份上下文向量,于是注意力分数就变成了一个 的矩阵(每个词对每个词的分数)。
手算得用双重循环把两两点积一个个填进去,既慢又啰嗦;改成矩阵乘法一行就能搞定:inputs @ inputs.T 一步算出所有两两分数——这也正是"注意力天生适合并行"的原因之一。接着对分数矩阵按行做 softmax(dim=-1 表示对每一行归一化,于是每行加起来都是 1),拿到注意力权重,再用它去乘输入矩阵,就一次性得到了所有词的上下文向量。
做个对照:之前手算的 会正好出现在结果的第 2 行。
实现带可训练权重的自注意力
现在进入正题。上一节的玩具版本没有可训练权重,意味着模型学不到东西。真正的自注意力——也就是原始 Transformer、GPT 以及绝大多数流行 LLM 用的那种,叫缩放点积注意力(scaled dot-product attention)——只比玩具版多了一点东西:
- 引入会在训练中更新的权重矩阵。这很关键,只有这样,注意力模块才能学会产出"好的"上下文向量。
- 具体说,是三个矩阵 、、,把输入 投影成三种不同的向量:
为什么非要分成查询(query)、键(key)、值(value)三种?你可以用图书馆检索来类比:
- 查询 = 你想找的主题(我用 journey 这个词去搜)。
- 键 = 每本书的标签(每个词对外展示的"标签")。
- 值 = 书的实际内容(真正被取走的信息)。
用查询去和每个键比对(点积),得到相关度,再按相关度把各个值加权取回来——这就是注意力的全部流程。
一步步算出来
真正动手前,先把维度定好。GPT 里输入输出维度通常相同,但书里故意设成不同,方便你追踪每个矩阵的形状变化:输入嵌入维度 ,输出维度 (即投影后的 q/k/v 和上下文向量都是 2 维)。
然后初始化三个权重矩阵 、、,形状都是 。书里为了讲解方便把 requires_grad 设成 False(让输出干净、可复现);真要训练,得设成 True。
有了权重,用它们把输入投影成查询、键、值三种向量:x @ W_query、x @ W_key、x @ W_value——于是 6 个 token 从 3 维被投影进了 2 维空间。接着算分数:对某个查询,把它和 6 个键分别做点积,就得到它对应的 6 个分数;写成矩阵形式就是 query @ keys.T。
然后进入缩放这一步,也是"缩放点积注意力"名字的由来——在 softmax 之前,先把分数除以嵌入维度的平方根 ,代码里就是 d_k**0.5。
为什么要除以 ?因为点积会把数值"放大",维度越高、分数越大,直接送进 softmax 会让分布变得极其尖锐(几乎全压在一个词上),梯度也就不好使了。除以 相当于把分数拉回一个温和的范围,让训练更稳。
最后,用 softmax 把缩放后的分数归一化成注意力权重,再对值向量加权求和,就得到上下文向量:attn_weights @ values。
写成 SelfAttention_v1 和 v2 两个类
把上面这套动作封装成模块,就是自注意力类。书里给了两个版本:
SelfAttention_v1:直接用nn.Parameter(torch.rand(...))定义三个可训练权重矩阵 、、,在forward里依次做投影、算分数、缩放、softmax、加权求和。SelfAttention_v2:把上面三个nn.Parameter换成nn.Linear。禁用偏置时,nn.Linear等价于一次矩阵乘法,但好处不只是代码更短——它自带了更合理的权重初始化方案,训练会更稳,所以后续章节都采用这个写法。
下面是 SelfAttention_v2 的完整实现,前面手工推演的每一步都被收进了 forward:
import torch
import torch.nn as nn
class SelfAttention_v2(nn.Module):
def __init__(self, d_in, d_out, qkv_bias=False):
super().__init__()
self.W_query = nn.Linear(d_in, d_out, bias=qkv_bias)
self.W_key = nn.Linear(d_in, d_out, bias=qkv_bias)
self.W_value = nn.Linear(d_in, d_out, bias=qkv_bias)
def forward(self, x):
keys = self.W_key(x)
queries = self.W_query(x)
values = self.W_value(x)
attn_scores = queries @ keys.T # 未归一化分数 omega
attn_weights = torch.softmax(
attn_scores / keys.shape[-1]**0.5, # 除以 sqrt(d_k) 做缩放
dim=-1
)
context_vec = attn_weights @ values
return context_vec注意:把 v1 和 v2 的输出拿来对比会不一样,这不是 bug——它们用了不同的初始权重,仅此而已。(练习里有个做法是把权重手动拷进另一个版本,验证两者只是初始化方式不同。)
因果注意力:不许偷看未来
到此为止的注意力有个"作弊"问题。LLM 的任务是预测下一个词,但如果我们让它算上下文向量时能看到后面的词,那就等于考试前偷看了答案。 训练时它看似表现完美,实际推理时却根本没法用——因为生成时未来还没发生。
因果注意力(causal attention)就是来解决这个问题的:把注意力矩阵主对角线以上的权重全部掩掉(mask),确保每个词只能看自己和它前面的词,看不到后面。
用掩码盖住未来的分数
掩码怎么加,有一个容易踩的坑。先看"笨办法":用 PyTorch 的 tril(下三角)函数生成一个主对角线及以下为 1、其余为 0 的矩阵,再去乘已经算好的注意力权重,对角线以上的分数就被清零了。
但这里有个问题:掩码如果加在 softmax 之后,会破坏 softmax 建立的概率分布(原本每行加起来是 1,现在被砍掉一部分,就不等于 1 了),补救办法是再手动做一次归一化。
更聪明的做法是:在进 softmax 之前就动手,用 triu(上三角)生成掩码,把对角线以上的未归一化分数用 masked_fill 直接设成负无穷。这样 softmax 之后那些位置自然变成 0,剩下的权重自动加起来等于 1,一步到位。
一句话记住:掩码加在 softmax 之前(用负无穷),比加在 softmax 之后(再重新归一化)更简洁也更稳。
用 dropout 减少过拟合
dropout 是一种防过拟合的常用手段:训练时随机"丢掉"一部分神经元输出。在注意力里,它通常加在两个地方之一——计算完注意力权重之后,或者权重与值相乘之后。这里选前者(更常见)。
本例为了效果明显,用了 50% 的 dropout 率(随机丢一半)——别担心,真正训练 GPT 时用的是更低的 0.1 或 0.2。实现上就是一行 nn.Dropout(0.5):把它作用在一个 6×6 的全 1 矩阵上,你会看到大约一半的格子变成 0、其余变成 2。
为什么剩下的从 1 变成了 2?因为被丢掉的值要按 的因子放大,50% dropout 就放大 2 倍(1/0.5 = 2),这样整体期望值不变。
注意:dropout 的输出可能因操作系统不同而略有差异,这是 PyTorch 的一个已知问题(见 PyTorch issue #121595)。另外,dropout 只在训练时生效,推理时会自动关闭。
把因果 + dropout 打包成 CausalAttention
现在把前面这些成果——q/k/v 投影、缩放点积、因果掩码、dropout——整合成一个能直接使用的类 CausalAttention。它比 SelfAttention_v2 多两处:一是注册一个上三角的因果掩码,二是加一层 dropout。
为了支持第 2 章数据加载器产出的**批(batch)**输入(比如把同一句话复制两份,形状就是 (2, 6, 3)),forward 里加上了批维度 b,并改用 transpose(1, 2) 来适配多维张量。掩码用 register_buffer 注册,这样它会随模型一起在设备间迁移、但不会被当成训练参数。
class CausalAttention(nn.Module):
def __init__(self, d_in, d_out, context_length,
dropout, qkv_bias=False):
super().__init__()
self.d_out = d_out
self.W_query = nn.Linear(d_in, d_out, bias=qkv_bias)
self.W_key = nn.Linear(d_in, d_out, bias=qkv_bias)
self.W_value = nn.Linear(d_in, d_out, bias=qkv_bias)
self.dropout = nn.Dropout(dropout) # 新增:dropout 层
# 新增:注册因果掩码(上三角为 1),register_buffer 让它随模型迁移设备但不算训练参数
self.register_buffer('mask', torch.triu(torch.ones(context_length, context_length), diagonal=1))
def forward(self, x):
b, num_tokens, d_in = x.shape # 新增批维度 b
# 若 num_tokens 超过 context_length,下面的掩码会报错;
# 实际中不会有问题,因为第 4-7 章的 LLM 会确保输入不超过 context_length
keys = self.W_key(x)
queries = self.W_query(x)
values = self.W_value(x)
attn_scores = queries @ keys.transpose(1, 2) # 转置最后两个维度,适配批
attn_scores.masked_fill_( # 新增;带 _ 的是原地操作
self.mask.bool()[:num_tokens, :num_tokens], -torch.inf) # 截取到 token 数,兼容短于 context_size 的批
attn_weights = torch.softmax(
attn_scores / keys.shape[-1]**0.5, dim=-1
)
attn_weights = self.dropout(attn_weights) # 新增:对注意力权重做 dropout
context_vec = attn_weights @ values
return context_vec多头注意力:一次请好几位专家
一个注意力头只能从一个角度看句子(一套 q/k/v 投影)。但一句话的信息是多维的——语法结构、语义关系、指代对象……**多头注意力(multi-head attention)**的思路就是:并行跑好几个注意力头,每个头用自己的一套线性投影,各自关注不同的表示子空间,最后把结果合并。相当于同时请好几位专家,各看各的重点。
最直观的做法:堆叠多个单头(MultiHeadAttentionWrapper)
前面写的带因果掩码的 CausalAttention 就是单头注意力(single-head attention)。想要多头?最省事的办法是把它当成积木堆起来:用 nn.ModuleList 造出 num_heads 个独立的因果注意力头,在 forward 里让每个头各自算一遍,最后用 torch.cat 把它们的输出在最后一维拼接起来,就成了 MultiHeadAttentionWrapper。
这里要留意输出维度:每个头内部的 q/k/v 与上下文向量维度是 d_out(比如 2),因为有 2 个头,拼接之后最终输出维度变成 。这个类直观好用,但用起来稍显笨重,于是有了下面更高效的写法。
更优雅的做法:拆权重(MultiHeadAttention)
MultiHeadAttentionWrapper 直观又好用,但可以写一个等效、更高效的独立类 MultiHeadAttention。思路不再是把多个头拼起来,而是先建一份大的 ,再把权重拆给各个头:
class MultiHeadAttention(nn.Module):
def __init__(self, d_in, d_out, context_length, dropout, num_heads, qkv_bias=False):
super().__init__()
assert (d_out % num_heads == 0), \
"d_out must be divisible by num_heads" # 输出维度必须能被头数整除
self.d_out = d_out
self.num_heads = num_heads
self.head_dim = d_out // num_heads # 每个头的维度:把投影维度降下来以匹配目标输出维度
self.W_query = nn.Linear(d_in, d_out, bias=qkv_bias)
self.W_key = nn.Linear(d_in, d_out, bias=qkv_bias)
self.W_value = nn.Linear(d_in, d_out, bias=qkv_bias)
self.out_proj = nn.Linear(d_out, d_out) # 用于合并各头输出的线性层
self.dropout = nn.Dropout(dropout)
self.register_buffer(
"mask",
torch.triu(torch.ones(context_length, context_length),
diagonal=1)
)
def forward(self, x):
b, num_tokens, d_in = x.shape
# 和 CausalAttention 一样:若 num_tokens 超过 context_length,
# 下面的掩码会报错;实际中不会,因为 LLM(第 4-7 章)会保证输入不超过 context_length
keys = self.W_key(x) # 形状: (b, num_tokens, d_out)
queries = self.W_query(x)
values = self.W_value(x)
# 通过增加一个 num_heads 维度,隐式地把矩阵拆给多个头
# 展开最后一维: (b, num_tokens, d_out) -> (b, num_tokens, num_heads, head_dim)
keys = keys.view(b, num_tokens, self.num_heads, self.head_dim)
values = values.view(b, num_tokens, self.num_heads, self.head_dim)
queries = queries.view(b, num_tokens, self.num_heads, self.head_dim)
# 转置: (b, num_tokens, num_heads, head_dim) -> (b, num_heads, num_tokens, head_dim)
keys = keys.transpose(1, 2)
queries = queries.transpose(1, 2)
values = values.transpose(1, 2)
# 计算带因果掩码的缩放点积注意力(即自注意力)
attn_scores = queries @ keys.transpose(2, 3) # 每个头分别做点积
# 原始掩码截取到 token 数并转成布尔值
mask_bool = self.mask.bool()[:num_tokens, :num_tokens]
# 用掩码把注意力分数填成 -inf
attn_scores.masked_fill_(mask_bool, -torch.inf)
attn_weights = torch.softmax(attn_scores / keys.shape[-1]**0.5, dim=-1)
attn_weights = self.dropout(attn_weights)
# 形状: (b, num_tokens, num_heads, head_dim)
context_vec = (attn_weights @ values).transpose(1, 2)
# 合并各头,其中 self.d_out = self.num_heads * self.head_dim
context_vec = context_vec.contiguous().view(b, num_tokens, self.d_out)
context_vec = self.out_proj(context_vec) # 可选投影层
return context_vec注意:这个类和
MultiHeadAttentionWrapper本质上是同一件事的更高效写法。两者输出看起来不同,只是因为随机初始化不同——它们都完全可用,都会被用在后面几章的 GPT 里。
关于输出维度的一点说明:
MultiHeadAttentionWrapper因为拼接,输出维度是d_out * num_heads(即 )。MultiHeadAttention更友好,直接由d_out控制输出维度——设d_out = 2就是 2,不管几个头。- 事后看来,用
d_out = 4来调用MultiHeadAttention可能更直观,这样它和d_out = 2的MultiHeadAttentionWrapper输出维度就一致了(读者曾指出)。
另外,MultiHeadAttention 里加了个 self.out_proj 线性投影层。它只是个不改变维度的线性变换;在 LLM 里用它是标准惯例,但并非严格必需(有研究表明去掉它不影响建模表现)。如果你想要更紧凑高效的实现,也可以考虑 PyTorch 自带的 torch.nn.MultiheadAttention。
attn_scores = queries @ keys.transpose(2, 3) 这行乍看有点绕,理解的关键是:PyTorch 的矩阵乘法能直接处理 4 维张量,它在最后两个维度之间做矩阵乘,并对前面的每一"组"(每个头)重复一遍。所以这一句,等价于"把每个头单独拎出来、各自做一次矩阵乘、再把结果堆回去"——只是写成批量运算更紧凑、效率也更高。
小结与延伸
- 参考 ./multihead-attention.ipynb:它是"第 2 章数据加载器 + 本章多头注意力类"的精简版,后面几章训练 GPT 时会用到。
- 练习解答见 ./exercise-solutions.ipynb。
关键概念
- 注意力分数(attention scores):未归一化的权重,用查询和键的点积算出。
- 注意力权重(attention weights):注意力分数经 softmax 归一化、总和为 1 的结果。
- 上下文向量(context vector):输入关于某个查询的加权和,融入了所有相关输入的信息。
- 查询 / 键 / 值(query / key / value):输入经 、、 投影成的三种向量。用查询找键(算相关度),再取回值。
- 缩放点积注意力(scaled dot-product attention):GPT 等模型用的自注意力,分数除以 以稳定训练。
- 因果注意力(causal attention):掩掉未来 token,保证每个预测只依赖前面的词。把上三角分数设成 (softmax 前),一步完成掩码与归一化。
- dropout:训练时随机丢弃一部分注意力权重、并把保留的按 放大,用于减少过拟合(推理时关闭)。
- 多头注意力(multi-head attention):并行跑多个注意力头,用不同线性投影关注不同表示子空间。两种实现:拼接多个单头(
MultiHeadAttentionWrapper)或拆分权重(MultiHeadAttention)。
动手练习
- 基础自注意力:为什么玩具版(无权重)里, 是"所有输入的加权和"?试着说明如果所有注意力权重相等, 会退化成什么。
- 缩放因子:如果不除以 会发生什么?请从"点积随维度增大而变大"这个角度,解释它对 softmax 分布和梯度的影响。
- 因果掩码的位置:为什么把掩码加在 softmax 之前(用 )比加在 softmax 之后再重新归一化更优雅?
- 多头维度:当
num_heads=2时,MultiHeadAttentionWrapper(d_out=2)的输出维度是多少?MultiHeadAttention(d_out=2)呢?要让两者输出维度相同,MultiHeadAttention里的d_out该设成多少? - 手写验证:把
SelfAttention_v1的权重手动拷进SelfAttention_v2(用nn.Parameter赋同样的值),验证两者输出一致——这能帮你确认二者的唯一差别就是初始化方式。
练习的完整实现与解答见仓库的 ch03/01_main-chapter-code/exercise-solutions.ipynb。