第 3 章 LLMGPT深度学习

第 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 嵌入):

  • x(1)x^{(1)} 是表示 "Your" 的 dd 维向量,x(2)x^{(2)} 是 "journey" 的向量,以此类推。
  • 目标:为每个输入 x(i)x^{(i)} 算出一个上下文向量 z(i)z^{(i)}(context vector,维度与 xx 相同)。
  • z(i)z^{(i)} 是所有输入 x(1)…x(T)x^{(1)} \dots x^{(T)} 的加权和。

什么叫"上下文向量"?拿 x(2)x^{(2)}(journey)举例,它的上下文向量 z(2)z^{(2)} 就是所有词按权重揉在一起的结果——你可以把它看成 x(2)x^{(2)} 的一个"升级版",除了自己的信息,还融入了与当前任务相关的其他词的信息。

这里有两个词要分清(后面反复用):

  • 注意力分数(attention scores):还没归一化的原始权重,通常记作 ω\omega(希腊字母 omega)。
  • 注意力权重(attention weights):分数经过归一化(加起来等于 1)之后的结果。

第 1 步:算注意力分数

我们拿第二个词当查询(query),即 q(2)=x(2)q^{(2)} = x^{(2)},让它和每个输入做点积(dot product,两个向量对应相乘再求和,用来衡量相似度):

  • ω21=x(1)q(2)⊤\omega_{21} = x^{(1)} q^{(2)\top}
  • ω22=x(2)q(2)⊤\omega_{22} = x^{(2)} q^{(2)\top}
  • ω23=x(3)q(2)⊤\omega_{23} = x^{(3)} q^{(2)\top}
  • ... 一直到 ω2T=x(T)q(2)⊤\omega_{2T} = x^{(T)} q^{(2)\top}

下标 "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) 等价于手动写一层循环累加 ∑kxi[k]⋅query[k]\sum_k x_i[k] \cdot query[k],只是前者是优化过的向量化写法。

第 2 步:把分数归一化,让它们加起来等于 1

算完的分数是一串原始可正可负的数,还需要归一化,让它们加起来等于 1,才能当作"权重"用。最土的办法是直接除以总和,但实践中更推荐用 softmax:它对极端值更稳,训练时的梯度性质也更好。

一个朴素版 softmax 就是"先取指数再除以指数之和",效果同样是归一化到总和为 1。不过这种朴素写法在数值很大或很小时会溢出/下溢(指数会把大数炸上天、把小数值压成 0),所以实际都用 PyTorch 内置的 torch.softmax——它在内部做了数值稳定处理,结果一致但不会爆。

第 3 步:加权求和,得到上下文向量

最后一步,把每个输入 x(i)x^{(i)} 乘上它的注意力权重,再全部加起来,就得到 z(2)z^{(2)}——也就是"用权重把 6 个词揉成一个向量"。

到这里,你其实已经掌握了注意力的全部内核:打分 → 归一化 → 加权求和。剩下的花活,都是在这个骨架上加东西。

一次算完所有词:把上面三步推广开

上面我们只算了第 2 个词。实际上每个词都要算一份上下文向量,于是注意力分数就变成了一个 6×66 \times 6 的矩阵(每个词对每个词的分数)。

手算得用双重循环把两两点积一个个填进去,既慢又啰嗦;改成矩阵乘法一行就能搞定:inputs @ inputs.T 一步算出所有两两分数——这也正是"注意力天生适合并行"的原因之一。接着对分数矩阵按行做 softmax(dim=-1 表示对每一行归一化,于是每行加起来都是 1),拿到注意力权重,再用它去乘输入矩阵,就一次性得到了所有词的上下文向量。

做个对照:之前手算的 z(2)=[0.4419,0.6515,0.5683]z^{(2)} = [0.4419, 0.6515, 0.5683] 会正好出现在结果的第 2 行。

实现带可训练权重的自注意力

现在进入正题。上一节的玩具版本没有可训练权重,意味着模型学不到东西。真正的自注意力——也就是原始 Transformer、GPT 以及绝大多数流行 LLM 用的那种,叫缩放点积注意力(scaled dot-product attention)——只比玩具版多了一点东西:

  • 引入会在训练中更新的权重矩阵。这很关键,只有这样,注意力模块才能学会产出"好的"上下文向量。
  • 具体说,是三个矩阵 WqW_q、WkW_k、WvW_v,把输入 x(i)x^{(i)} 投影成三种不同的向量:

q(i)=x(i) Wqk(i)=x(i) Wkv(i)=x(i) Wvq^{(i)} = x^{(i)}\,W_q \qquad k^{(i)} = x^{(i)}\,W_k \qquad v^{(i)} = x^{(i)}\,W_v

为什么非要分成查询(query)、键(key)、值(value)三种?你可以用图书馆检索来类比:

  • 查询 = 你想找的主题(我用 journey 这个词去搜)。
  • 键 = 每本书的标签(每个词对外展示的"标签")。
  • 值 = 书的实际内容(真正被取走的信息)。

用查询去和每个键比对(点积),得到相关度,再按相关度把各个值加权取回来——这就是注意力的全部流程。

一步步算出来

真正动手前,先把维度定好。GPT 里输入输出维度通常相同,但书里故意设成不同,方便你追踪每个矩阵的形状变化:输入嵌入维度 din=3d_{in} = 3,输出维度 dout=2d_{out} = 2(即投影后的 q/k/v 和上下文向量都是 2 维)。

然后初始化三个权重矩阵 WqueryW_{query}、WkeyW_{key}、WvalueW_{value},形状都是 3×23 \times 2。书里为了讲解方便把 requires_grad 设成 False(让输出干净、可复现);真要训练,得设成 True。

有了权重,用它们把输入投影成查询、键、值三种向量:x @ W_query、x @ W_key、x @ W_value——于是 6 个 token 从 3 维被投影进了 2 维空间。接着算分数:对某个查询,把它和 6 个键分别做点积,就得到它对应的 6 个分数;写成矩阵形式就是 query @ keys.T。

然后进入缩放这一步,也是"缩放点积注意力"名字的由来——在 softmax 之前,先把分数除以嵌入维度的平方根 dk\sqrt{d_k},代码里就是 d_k**0.5。

为什么要除以 dk\sqrt{d_k}?因为点积会把数值"放大",维度越高、分数越大,直接送进 softmax 会让分布变得极其尖锐(几乎全压在一个词上),梯度也就不好使了。除以 dk\sqrt{d_k} 相当于把分数拉回一个温和的范围,让训练更稳。

最后,用 softmax 把缩放后的分数归一化成注意力权重,再对值向量加权求和,就得到上下文向量:attn_weights @ values。

写成 SelfAttention_v1 和 v2 两个类

把上面这套动作封装成模块,就是自注意力类。书里给了两个版本:

  • SelfAttention_v1:直接用 nn.Parameter(torch.rand(...)) 定义三个可训练权重矩阵 WqW_q、WkW_k、WvW_v,在 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?因为被丢掉的值要按 1/(1−dropout_rate)1/(1-\text{dropout\_rate}) 的因子放大,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 个头,拼接之后最终输出维度变成 2×2=42 \times 2 = 4。这个类直观好用,但用起来稍显笨重,于是有了下面更高效的写法。

更优雅的做法:拆权重(MultiHeadAttention)

MultiHeadAttentionWrapper 直观又好用,但可以写一个等效、更高效的独立类 MultiHeadAttention。思路不再是把多个头拼起来,而是先建一份大的 Wquery/Wkey/WvalueW_{query}/W_{key}/W_{value},再把权重拆给各个头:

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(即 2×2=42 \times 2 = 4)。
  • 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 维张量,它在最后两个维度之间做矩阵乘,并对前面的每一"组"(每个头)重复一遍。所以这一句,等价于"把每个头单独拎出来、各自做一次矩阵乘、再把结果堆回去"——只是写成批量运算更紧凑、效率也更高。

小结与延伸

关键概念

  • 注意力分数(attention scores):未归一化的权重,用查询和键的点积算出。
  • 注意力权重(attention weights):注意力分数经 softmax 归一化、总和为 1 的结果。
  • 上下文向量(context vector):输入关于某个查询的加权和,融入了所有相关输入的信息。
  • 查询 / 键 / 值(query / key / value):输入经 WqW_q、WkW_k、WvW_v 投影成的三种向量。用查询找键(算相关度),再取回值。
  • 缩放点积注意力(scaled dot-product attention):GPT 等模型用的自注意力,分数除以 dk\sqrt{d_k} 以稳定训练。
  • 因果注意力(causal attention):掩掉未来 token,保证每个预测只依赖前面的词。把上三角分数设成 −∞-\infty(softmax 前),一步完成掩码与归一化。
  • dropout:训练时随机丢弃一部分注意力权重、并把保留的按 1/(1−p)1/(1-p) 放大,用于减少过拟合(推理时关闭)。
  • 多头注意力(multi-head attention):并行跑多个注意力头,用不同线性投影关注不同表示子空间。两种实现:拼接多个单头(MultiHeadAttentionWrapper)或拆分权重(MultiHeadAttention)。

动手练习

  1. 基础自注意力:为什么玩具版(无权重)里,z(i)z^{(i)} 是"所有输入的加权和"?试着说明如果所有注意力权重相等,z(2)z^{(2)} 会退化成什么。
  2. 缩放因子:如果不除以 dk\sqrt{d_k} 会发生什么?请从"点积随维度增大而变大"这个角度,解释它对 softmax 分布和梯度的影响。
  3. 因果掩码的位置:为什么把掩码加在 softmax 之前(用 −∞-\infty)比加在 softmax 之后再重新归一化更优雅?
  4. 多头维度:当 num_heads=2 时,MultiHeadAttentionWrapper(d_out=2) 的输出维度是多少?MultiHeadAttention(d_out=2) 呢?要让两者输出维度相同,MultiHeadAttention 里的 d_out 该设成多少?
  5. 手写验证:把 SelfAttention_v1 的权重手动拷进 SelfAttention_v2(用 nn.Parameter 赋同样的值),验证两者输出一致——这能帮你确认二者的唯一差别就是初始化方式。

练习的完整实现与解答见仓库的 ch03/01_main-chapter-code/exercise-solutions.ipynb。