w wyl123ly 的博客
MD

Transformer架构详解

44 KB 2026.10.18 原文件

Transformer架构详解

定义

Transformer 是由 个结构相同的编码器层与 个结构相同的解码器层堆叠而成的序列到序列模型;每层由多头注意力子层与逐位置前馈子层组成,每个子层外包残差连接与 LayerNorm。编码器把源序列 映射为同长度的上下文表示序列 ;解码器以 与已生成的目标前缀为输入,输出下一个 token 在词表上的条件分布。

本篇符号约定如下。

符号含义
批大小
源序列长度、目标序列长度
模型维度
注意力头数
每个头的键维度、值维度,
前馈网络中间维度,原论文取
编码器层数,也是解码器层数
词表大小
编码器某层的输入
解码器某层的输入
编码器最终输出,供交叉注意力读取
注意力的查询、键、值、输出投影矩阵
掩码矩阵,允许位置为 0,禁止位置为
LayerNorm 的缩放与平移参数
LayerNorm 分母中的数值稳定项,也用于标签平滑时另行说明
模型全部可训练参数

其余术语在正文首次出现处定义。子层(sublayer)是层内独立计算的模块,包括自注意力、交叉注意力与前馈网络;残差流(residual stream)是贯穿各子层的 维向量序列,每个子层读取它并把自己的输出加回;Post-LN 指先做子层计算与残差相加、再做 LayerNorm;Pre-LN 指先做 LayerNorm、再进入子层,残差相加在子层输出之后;交叉注意力(cross-attention)是查询来自解码器、键与值来自编码器输出的注意力;教师强制(teacher forcing)指训练时用真实前缀作为解码器输入;移位标签(shifted labels)指解码器输入比预测目标右移一位。

为什么重要

循环网络必须按时间步串行计算,位置 的隐状态依赖位置 ,因此训练无法在时间维并行,任意两个位置之间的信息路径长度为 。Transformer 用注意力把任意两个位置直接连接,路径长度为 ,同一层内所有位置可以并行计算;代价是注意力矩阵的 计算与显存开销。这一取舍使训练可以扩展到长序列与大参数量,是 2017 年之后语言模型规模增长的结构前提。

结构每层计算复杂度顺序操作数任意两位置的最大路径长度
自注意力
循环网络
卷积网络

残差连接与 LayerNorm 决定深堆叠能否训练。没有残差时, 层网络的梯度是 个雅可比矩阵的乘积,谱范数略小于 1 就指数衰减,略大于 1 就指数增长;没有归一化时,各层输入尺度随深度漂移,学习率难以统一设定。这两项不是性能技巧,而是把"可以堆很多层"变成事实的必要条件。

Transformer 是后续模型族的共同骨架。编码器-only 路线(BERT与双向编码模型)用双向自注意力做表示学习;解码器-only 路线(GPT系列架构)用因果自注意力做下一 token 预测;编码器-解码器路线保留交叉注意力,适合翻译、摘要等输入输出长度不同的任务。理解每个子层的形状、参数量与梯度通路,是从零实现(从零实现小型GPT指南)与阅读模型代码的前提。

在本库中的位置:本篇承接 注意力机制与QKV、因果注意力与多头注意力 与 位置编码-正弦与RoPE,把组件组装成完整层与完整模型;KV缓存 分析解码阶段的显存与计算,Llama-2架构复盘 给出 Pre-LN、RMSNorm、SwiGLU 与 RoPE 的工程组合。对应学习目标中的"懂原理""能复现""会评估":能画出数据流、逐项算参数量、写出可运行模块,并能定位形状与掩码错误。

原理与推导

1 整体结构与数据流

编码器与解码器的堆叠关系如下。源序列先经过 token 嵌入与位置编码,进入 层编码器;每层先做多头自注意力,再做前馈网络,两个子层各带残差与归一化。编码器输出 被每一层解码器的交叉注意力读取。目标序列右移一位后经过同样的嵌入与位置编码,进入 层解码器;每层依次做掩码自注意力、交叉注意力与前馈网络。最后一层输出经线性层映射到词表维度,softmax 给出下一个 token 的分布。

flowchart TD
    SRC["源序列 token id<br/>(B, T_src)"] --> SE["嵌入 + 位置编码<br/>(B, T_src, d)"]
    SE --> ENC["Encoder × L<br/>自注意力 + FFN"]
    ENC --> MEM["编码器输出 H<br/>(B, T_src, d)"]
    TGT["目标序列(右移一位)<br/>(B, T_tgt)"] --> TE["嵌入 + 位置编码<br/>(B, T_tgt, d)"]
    TE --> DEC["Decoder × L<br/>掩码自注意力 + 交叉注意力 + FFN"]
    MEM --> DEC
    DEC --> LIN["线性层<br/>(B, T_tgt, V)"]
    LIN --> OUT["softmax 后的下一个 token 分布"]

编码器层内部的数据流如下。Pre-LN 结构下,LayerNorm 位于子层输入端;Post-LN 结构下,LayerNorm 位于残差相加之后。两种结构的模块顺序不同,但张量形状相同。

flowchart LR
    X["x<br/>(B,T,d)"] --> LN1["LayerNorm"]
    LN1 --> ATT["多头自注意力"]
    X --> ADD1["+"]
    ATT --> ADD1
    ADD1 --> LN2["LayerNorm"]
    LN2 --> FFN["FFN<br/>d → d_ff → d"]
    ADD1 --> ADD2["+"]
    FFN --> ADD2
    ADD2 --> Y["y<br/>(B,T,d)"]

各张量的形状如下表。表中省略批维与头维的展开细节,第 3 节给出逐步形状。

张量形状说明
输入 id 或 整数张量
嵌入输出 查表后加位置编码
投影后拆分头
注意力分数 查询与键两两内积
单头输出对值加权求和
多头拼接头维合并后过
FFN 中间量逐位置升维
编码器输出 供交叉注意力使用
交叉注意力分数目标位置对源位置
logits词表上的未归一化分数

2 输入嵌入与位置编码

token id 先经嵌入矩阵查表:

原论文把嵌入乘以 ,再加上位置编码,最后做 dropout:

的第 行只依赖位置 ,与 batch 无关,因此对批内所有序列广播。正弦编码、可学习位置嵌入与 RoPE 的对比见 位置编码-正弦与RoPE;本节只关心形状与组合方式。

乘以 的作用是调整两项的相对尺度。正弦编码的范数为 ,若嵌入分量初始尺度约为 1,则两者量级接近;不缩放时嵌入项偏小,位置项在残差流中的占比偏大。该缩放是原论文的实现选择,不属于架构定义;Pre-LN 结构对输入尺度的敏感度低于 Post-LN,但缩放仍影响初始阶段的梯度。

位置编码与嵌入必须逐元素相加,而不是拼接。相加保持维度为 ,后续所有投影矩阵的形状不变;拼接会把维度变为 ,第一层注意力的参数量翻倍,且位置子空间与内容子空间被强制分离,模型无法在同一线性变换中组合两者。位置编码加在嵌入之后、第一层之前,不能只在最后一层加,因为每一层的注意力都需要位置信息。

3 编码器层

3.1 多头自注意力

设层输入为 。对第 个头,用独立的投影得到查询、键、值:

其中 ,。缩放点积注意力为

个头的结果沿最后一维拼接,再乘输出投影:

取 ,则拼接后的维度为 ,输出投影把 维映回 维。全部投影的参数量为

除以 的理由在该篇给出:若 各分量独立、均值 0、方差 1,则内积方差为 ,除以 使 logits 方差回到 1,softmax 不会因维度过大而饱和。多头的作用不是增加参数量,而是在相同总维度下提供 个不同的投影子空间:每个头用 维计算,全部头的计算量与单头 维注意力同阶。

逐步形状如下。设 为 ,,,。

与 相乘:

softmax 逐行作用在最后一维,形状不变。与 相乘:

合并头维:

最后过 ,形状仍为 。编码器自注意力不加因果掩码,因为编码器需要看到完整源序列;若批内有 padding,则用 padding mask 禁止注意力读取填充位置。

3.2 残差与 LayerNorm

原论文采用 Post-LN,编码器层的计算顺序为

先做子层计算,再加残差,最后归一化。 与子层输出形状相同,才能逐元素相加;这要求所有子层保持 维。LayerNorm 在每个位置上独立计算,输入 ,输出 ,归一化维度是最后一维 。

3.3 前馈网络

每个位置独立经过同一个两层网络:

为逐元素激活函数,原论文用 ReLU,现代实现常用 GELU 或 SwiGLU。 是原论文的默认值。参数量为

、 时为 ,占单层参数量的约三分之二。FFN 对每个位置使用相同权重,不跨位置混合;跨位置的信息交换完全由注意力完成。若去掉激活函数, 退化为一个 矩阵,两层结构与一层线性变换等价,深度带来的非线性容量消失。

4 解码器层

解码器层有三个子层:掩码自注意力、交叉注意力、前馈网络。设层输入为 ,编码器输出为 。Post-LN 下依次为

4.1 掩码自注意力

解码器训练时一次性输入完整目标序列,但位置 只能使用 的信息。定义掩码矩阵

把掩码加到 softmax 之前的分数上:

当 时,,,位置 对位置 的注意力权重为零。softmax 的分母只对 求和,行归一化仍然成立。掩码必须在 softmax 之前加:若先 softmax 再把上三角置零,每行的和不再为 1,输出尺度随位置变化,后续层收到的表示不再位于同一尺度。

的形状为 ,加到 的分数上时对批维与头维广播。批量内每条序列的掩码相同,因此不需要为每个样本构造独立掩码;padding mask 则与样本有关,形状为 ,需要扩展为 后才能与分数相加。

训练时,一次前向即可得到所有位置的预测,因为因果掩码保证位置 的输出只依赖 ,与逐 token 生成的结果一致。这是 Transformer 训练并行性的来源:时间维不需要循环,循环被掩码替代。

4.2 交叉注意力

交叉注意力的查询来自解码器,键与值来自编码器:

分数形状为

每个目标位置对全部源位置计算权重,输出为源位置值向量的加权和,形状 ,合并头后回到 。交叉注意力通常不加因果掩码,因为源序列对每个目标位置都可见;若源序列有 padding,则对键的位置加 padding mask,禁止读取填充。

查询、键、值三者来源不能混。若三者都取自解码器,交叉注意力退化为自注意力,编码器输出完全不被使用;若查询取自编码器而键值也取自编码器,则退化为编码器自注意力,解码器当前状态不参与查询,无法按当前生成位置检索源序列。正确的组合是"查询来自当前解码位置,键与值来自源序列"。

4.3 解码器前馈网络

与编码器相同:逐位置两层网络,,参数量 。三个子层都带残差与 LayerNorm,因此解码器层比编码器层多一个交叉注意力子层与一个 LayerNorm。

5 Post-LN 与 Pre-LN

两种放置方式的差别只在 LayerNorm 与残差相加的先后。Post-LN 为

Pre-LN 为

Post-LN 中,每个子层的输出都经过一次归一化,残差流被反复重新居中与缩放;Pre-LN 中,残差流本身不被归一化,归一化只作用于子层的输入,主路径上是连续的加法。

梯度通路的差异可以直接写出。对 Pre-LN,

从损失到第 层的梯度包含一条不经过 的恒等路径,深层网络的梯度不会因连乘而整体消失。对 Post-LN,

每个 block 的梯度都必须穿过输出端的 LayerNorm 雅可比 。初始化时残差分支输出较小,LayerNorm 的归一化会放大相对变化,使初始阶段的梯度范数整体偏大;层数增加时这种放大在连乘中累积。原论文因此使用 4000 步学习率 warmup,先以小学习率稳定初始阶段。Pre-LN 把归一化移到子层输入端,主路径不含 ,对 warmup 的依赖显著降低,但残差流的方差随深度累积,因为每个 block 都把自己的输出加到一个未归一化的流上;因此 Pre-LN 必须在最后加一个 LayerNorm,再送入输出层。

项目Post-LNPre-LN
计算顺序
主路径归一化每个 block 输出都归一化主路径不归一化
梯度通路必须穿过每个输出 LN含恒等路径
对 warmup 的依赖强弱
残差流方差被每层重置随深度累积
末端处理无需额外 LN需要最终 LN
典型使用原论文、早期实现GPT-2 之后的多数 decoder-only 模型

两种结构都能训练到相同量级的效果,差别主要在优化稳定性与超参数敏感度。复现原论文时用 Post-LN 与 warmup;从零实现现代 decoder-only 模型时用 Pre-LN,代码更简单,深层配置更稳。

6 残差连接的必要性

设第 层的输入输出关系为

对 求雅可比:

从第 层反传到第 0 层,链式法则给出

把乘积展开:

展开式中存在 项,它对应一条不经过任何子层的梯度路径。即使所有 的谱范数都小于 1,梯度仍然可以通过 项直接到达浅层;其余高阶项则提供经过不同层组合的路径。没有残差时,

若每层雅可比的谱范数为 ,梯度范数按 衰减;若 ,按 增长。两种情形都使深层网络难以用统一学习率训练。残差把"连乘"变为"连乘加恒等",最坏情况下仍保留一条不衰减的恒等路径。

残差还改变了学习目标的参数化。若某层的最优变换接近恒等, 只需学习接近零的函数,而不是让一整组权重逼近单位矩阵;后者在有限步梯度下降中更难达到。前向上,残差流把各层输出累加,每一层只需学习一个增量,而不是重新构造完整表示。

残差要求子层输入输出同维,即 。注意力的输出投影与 FFN 的第二层都映射回 ,正是为了满足这一条件。若某一子层改变了维度,残差加法无法进行,必须引入额外的投影,这会增加参数并破坏恒等路径。

7 LayerNorm 的公式与作用维度

对单个位置的向量 ,LayerNorm 计算

其中 是可学习参数, 为逐元素乘法, 取 量级,防止方差为零时除零。减去均值使输出均值为零,除以标准差使输出方差为一,再经 恢复可学习的尺度与偏移。若 、,输出被限制在零均值、范数为 的 维球面上,表达能力由后续线性层提供。

作用维度是最后一维 ,不是批维,也不是序列维。对 的输入,LayerNorm 对每个 组合独立计算 个分量的均值与方差,共 组统计量。PyTorch 中写作

norm = torch.nn.LayerNorm(d)          # normalized_shape = d
y = norm(x)                           # x: (B, T, d) -> y: (B, T, d)

normalized_shape=d 表示对最后一维归一化;若误写成 LayerNorm((B, T)) 或手动对 dim=(0, 1) 求均值,统计量会跨位置、跨样本混合,每个位置的输出依赖于同批其他序列,推理时行为随批组成变化。

与 BatchNorm 的差别在于统计量的来源。BatchNorm 对每个特征在批维上求均值与方差,训练时依赖批内样本,推理时使用滑动平均;批较小或序列长度不一时,统计量噪声大。LayerNorm 对每个样本、每个位置单独归一化,训练与推理的计算完全一致,不依赖批大小,适合变长序列与自回归解码。Transformer 的残差流是逐位置的 维向量,LayerNorm 正好沿特征维作用,不需要跨位置统计。

LayerNorm 的计算量为 ,相对注意力的 可以忽略。它的梯度包含两部分:对输入的缩放与中心化,以及对 的更新。中心化使梯度中与均值方向平行的分量被投影掉,缩放使梯度的尺度与输入方差解耦,这是深层网络能用统一学习率的原因之一。

8 前馈网络作为逐位置非线性变换

前馈网络对序列中每个位置独立作用:

把整条序列写成矩阵:

其中 为全 1 列向量,偏置对每个位置广播。该式说明 FFN 不包含任何跨位置的项: 只依赖 ,与 ()无关。序列中的信息交换全部由注意力完成,FFN 只增加每个位置的非线性变换容量。

两层结构与激活函数缺一不可。若 为恒等映射,

两层线性变换等价于一层 线性变换,参数量从 降为 ,但表达能力也降为线性。若去掉整个 FFN,层内只剩注意力与逐元素归一化,模型无法对每个位置单独做非线性特征组合,注意力输出的每个分量只能线性混合。

是原论文的选择。更大的 增加每个位置的变换容量,参数量与计算量按 线性增长;更小的 降低 FFN 占比,但注意力已经是 ,在短序列上 FFN 的 更容易成为主要计算。、 时 FFN 占单层参数的 66.6%,是参数量的主体;这也是把 作为独立超参数调节的原因。

GELU 是常用的平滑激活:

其中 为标准正态分布的累积分布函数。与 ReLU 相比,GELU 在负值区间有非零输出与梯度,原点附近平滑,训练时梯度更连续;ReLU 计算更简单,原论文使用 ReLU。两者都是逐元素函数,不改变形状。

9 参数量逐项计算

取原论文 base 配置:,,,,,词表 。先算单个编码器层。

注意力投影:四个 矩阵,每个 个权重,加四个长度为 512 的偏置:

两个 LayerNorm:每个含 各 512 个参数:

前馈网络:

单个编码器层合计:

六个编码器层:

解码器层比编码器层多一个交叉注意力子层与一个 LayerNorm。交叉注意力同样有四个 投影与四个偏置,参数量 ;多出的 LayerNorm 为 。单个解码器层:

六个解码器层:

输入嵌入与输出投影共享同一矩阵时,嵌入参数量为

总参数量为

若输入嵌入与输出投影不共享,需再加一份 ,总参数为 。以上计数不含输出层偏置;若计入,需再加 ,对比例没有影响。原论文报告 base 模型约 65M,与本算例的 63.1M 相差约 3%,差异来自词表规模与实现细节的取整;分项比例与量级一致。三部分占比分别为编码器 30.0%、解码器 40.0%、嵌入 30.0%,嵌入不是主要部分,原因是 与 同阶但层数更多时后者增长更快。

计算量可按每 token 每层的乘加次数估算。注意力投影 ;分数与加权求和各需 ,合计 ;FFN 为 。总计

、 时为

其中 FFN 占 ,注意力线性投影占 ,分数与加权求和占 。序列较短时 FFN 是主要计算;序列长度增加到 时,注意力的总计算 超过 FFN 的 ,注意力分数成为瓶颈。注意力分数矩阵的显存为 个元素,、、 时约 个 float32,约 2.1 GB,这是长上下文需要 FlashAttention 一类分块算法的直接原因。

10 训练目标与推理差异

训练时使用教师强制。给定源序列 与目标序列 ,在序列首部加起始符 ,解码器输入为

预测目标为右移一位的标签

位置 的输出经过线性层与 softmax 得到 ,交叉熵损失为

由于因果掩码,一次前向即可并行计算全部 个条件概率,不需要逐步循环。若不做移位,解码器在位置 看到的就是 本身,任务退化为复制输入,损失可以降到接近零而模型没有预测能力。若移位方向相反,位置 看到的是 ,同样造成标签泄漏。

位置 0123
解码器输入BOS
预测目标EOS

原论文还使用标签平滑,把目标分布从 one-hot 改为

损失改为 。标签平滑防止模型对单一 token 输出过高的概率,降低过拟合;它改变的是训练目标,不改变模型结构。批内 padding 位置不参与损失,需用 ignore_index 屏蔽,否则填充 token 的预测会主导梯度。

推理时没有真实前缀可用。编码器对源序列做一次前向,得到 并缓存;解码器从 BOS 开始,每一步把已生成的 token 序列作为输入,取最后一个位置的输出分布,采样或取 argmax 得到下一个 token,再拼回输入。训练与推理的差异如下表。

项目训练推理
输入前缀真实标签(教师强制)模型已生成的 token
并行性整条目标序列一次前向逐 token 自回归
掩码作用保证位置 只看到 同样保证,但每步只有前缀
输出使用全部位置参与损失只取最后一个位置的分布
缓存不需要缓存编码器输出与历史键值

训练与推理的分布差异称为曝光偏差:训练时前缀来自数据分布,推理时前缀来自模型自身,早期错误会改变后续输入。缓解方法包括 scheduled sampling、强化学习目标与更大的数据覆盖,但标准 Transformer 的训练目标本身不消除该差异。解码阶段的键值缓存与显存分析见 KV缓存。

关键直觉

一个 Transformer 层由两个作用不同的部分构成:注意力是唯一的跨位置混合操作,它按内容相似度把其他位置的值向量加权聚合到当前位置;前馈网络是逐位置的非线性变换,它在每个位置上独立地升维、激活、降维。残差流把各子层的输出累加,使每一层只需学习增量;LayerNorm 控制每次读取残差流时的尺度。该表述与第 3 节的 、第 8 节的 逐行独立、第 6 节的 严格对应:去掉注意力则位置之间不再交换信息,去掉 FFN 则每个位置只剩线性混合,去掉残差则深度无法训练。

例子与代码

例 1:参数量逐项核算

以下纯 Python 代码按第 9 节的公式计算各组件参数量,不依赖深度学习框架,输出为实际运行结果。

def count_params(d=512, d_ff=2048, n_layers=6, vocab=37000, tied=True):
    attn = 4 * d * d + 4 * d          # W_Q, W_K, W_V, W_O 与四个偏置
    ln = 2 * d                        # gamma 与 beta
    ffn = d * d_ff + d_ff + d_ff * d + d
    enc_layer = attn + 2 * ln + ffn
    dec_layer = 2 * attn + 3 * ln + ffn
    emb = vocab * d
    total = n_layers * (enc_layer + dec_layer) + emb
    if not tied:
        total += emb
    return attn, ln, ffn, enc_layer, dec_layer, emb, total

attn, ln, ffn, enc, dec, emb, total = count_params()
for name, value in [("attention", attn), ("layernorm", ln), ("ffn", ffn),
                    ("encoder_layer", enc), ("decoder_layer", dec),
                    ("embedding", emb), ("total_tied", total),
                    ("total_untied", total + emb)]:
    print(f"{name:16s} {value:>12,d}")
print("share", f"{6*enc/total:.1%}", f"{6*dec/total:.1%}", f"{emb/total:.1%}")
attention           1,050,624
layernorm               1,024
ffn                 2,099,712
encoder_layer       3,152,384
decoder_layer       4,204,032
embedding          18,944,000
total_tied         63,082,496
total_untied       82,026,496
share 30.0% 40.0% 30.0%

代码把每个子层的参数写成 与 的表达式,再按层数累加。attention 的 包含四个投影与偏置;layernorm 的 是一组 ;ffn 的 包含两层权重与偏置。total_tied 只计一份嵌入,total_untied 再加一份输出投影。若把 误取为 ,单个前馈网络从 降为 ,每层少 个参数,六个编码器层与六个解码器层合计少 ,约占总参数的 30%。若漏算全部线性层偏置,编码器每层少 、解码器每层少 ,总计少 ,相对 6,300 万可以忽略,但逐项核对时会出现不一致。

例 2:掩码必须在 softmax 之前

以下 NumPy 代码在 NumPy 2.3.5 下运行,比较"先加 再 softmax"与"先 softmax 再把上三角置零"的差别。

import numpy as np

def softmax(x, axis=-1):
    e = np.exp(x - x.max(axis=axis, keepdims=True))
    return e / e.sum(axis=axis, keepdims=True)

scores = np.array([[1.0, 2.0, 3.0],
                   [1.0, 2.0, 3.0],
                   [1.0, 2.0, 3.0]])
causal = np.triu(np.ones((3, 3), dtype=bool), k=1)   # 上三角为 True,表示禁止
correct = softmax(np.where(causal, -np.inf, scores))
wrong = softmax(scores)
wrong[causal] = 0.0
print(np.round(correct, 4))
print(correct.sum(axis=1))
print(np.round(wrong, 4))
print(wrong.sum(axis=1))
[[1.     0.     0.    ]
 [0.2689 0.7311 0.    ]
 [0.09   0.2447 0.6652]]
[1. 1. 1.]
[[0.09   0.     0.    ]
 [0.09   0.2447 0.    ]
 [0.09   0.2447 0.6652]]
[0.09003057 0.33475904 1.        ]

correct 的三行和均为 1,位置 0 只能看到自己,权重为 1;位置 1 在位置 0 与自身之间分配,权重分别为 0.2689 与 0.7311;位置 2 看到全部三个位置。wrong 先对完整行做 softmax,再把禁止位置置零,行和变为 0.09、0.3348、1,不再归一化。若把这样的权重送入后续层,不同位置的输出尺度不同,位置 0 的输出被压缩到原尺度的约 9%,梯度尺度也随之缩小。正确做法是在指数运算之前把禁止位置的 logits 设为 ,使 直接给出 0,分母只对允许位置求和。

例 3:Pre-LN TransformerBlock 与因果性检验

以下代码在 PyTorch 2.0 及以上运行,实现 Pre-LN、GELU、可切换因果掩码的单层模块,并检验掩码是否真的阻止了未来信息。本机未安装 PyTorch,形状与参数量已按定义核对。

import math
import torch
import torch.nn as nn

class CausalSelfAttention(nn.Module):
    def __init__(self, d_model, n_heads):
        super().__init__()
        assert d_model % n_heads == 0
        self.n_heads = n_heads
        self.d_head = d_model // n_heads
        self.q_proj = nn.Linear(d_model, d_model)
        self.k_proj = nn.Linear(d_model, d_model)
        self.v_proj = nn.Linear(d_model, d_model)
        self.o_proj = nn.Linear(d_model, d_model)

    def forward(self, x, causal=True):
        B, T, _ = x.shape
        q = self.q_proj(x).view(B, T, self.n_heads, self.d_head).transpose(1, 2)
        k = self.k_proj(x).view(B, T, self.n_heads, self.d_head).transpose(1, 2)
        v = self.v_proj(x).view(B, T, self.n_heads, self.d_head).transpose(1, 2)
        scores = q @ k.transpose(-2, -1) / math.sqrt(self.d_head)   # (B,h,T,T)
        if causal:
            mask = torch.full((T, T), float("-inf"), device=x.device, dtype=scores.dtype)
            mask = torch.triu(mask, diagonal=1)                     # 上三角为 -inf
            scores = scores + mask                                  # 广播到 (B,h,T,T)
        attn = torch.softmax(scores, dim=-1)
        out = attn @ v                                              # (B,h,T,d_head)
        out = out.transpose(1, 2).contiguous().view(B, T, -1)       # (B,T,d_model)
        return self.o_proj(out)

class TransformerBlock(nn.Module):
    def __init__(self, d_model=512, n_heads=8, d_ff=2048):
        super().__init__()
        self.ln1 = nn.LayerNorm(d_model)
        self.attn = CausalSelfAttention(d_model, n_heads)
        self.ln2 = nn.LayerNorm(d_model)
        self.ffn = nn.Sequential(
            nn.Linear(d_model, d_ff),
            nn.GELU(),
            nn.Linear(d_ff, d_model),
        )

    def forward(self, x, causal=True):
        x = x + self.attn(self.ln1(x), causal=causal)   # 子层读归一化后的输入
        x = x + self.ffn(self.ln2(x))                   # 残差相加保留恒等路径
        return x

torch.manual_seed(0)
block = TransformerBlock()
x = torch.randn(2, 5, 512)
y = block(x)
print("x:", tuple(x.shape), "y:", tuple(y.shape))
print("params:", sum(p.numel() for p in block.parameters()))

x2 = x.clone()
x2[:, -1, :] += 1.0                                  # 只改最后一个位置
y2 = block(x2)
print("prefix unchanged:", torch.allclose(y[:, :-1], y2[:, :-1], atol=1e-6))
print("last changed:", not torch.allclose(y[:, -1], y2[:, -1], atol=1e-6))

y3 = block(x, causal=False)                          # 关闭掩码作为对照
y4 = block(x2, causal=False)
print("no mask, prefix unchanged:", torch.allclose(y3[:, :-1], y4[:, :-1], atol=1e-6))
x: (2, 5, 512) y: (2, 5, 512)
params: 3152384
prefix unchanged: True
last changed: True
no mask, prefix unchanged: False

代码分为注意力与层两个模块。注意力先做四个线性投影,把 维拆成 个头;分数除以 后,若开启因果开关,就构造上三角为 的掩码并加到分数上,softmax 后与值相乘,合并头维,再过输出投影。层按 Pre-LN 组合:ln1 的输出进入注意力,注意力输出与原始 x 相加;ln2 的输出进入 FFN,FFN 输出再与残差流相加。全模块没有 dropout,因此同一输入的前向结果完全确定。单层模块不包含模型末端的 LayerNorm:Pre-LN 的最终归一化位于第 层之后、输出投影之前,属于模型级组件,不属于单个 block。

输出第一行确认形状从 到 ,第二行给出参数量 3,152,384,与第 9 节的单层公式一致。因果性检验只修改位置 4 的输入:开启掩码时,位置 0 至 3 的查询看不到位置 4 的键与值,输出必须逐元素不变,prefix unchanged 为 True;位置 4 自己的输出会变化,last changed 为 True。关闭掩码后,位置 4 的键值进入所有查询的加权和,前缀输出随之改变,no mask, prefix unchanged 为 False。这一组对照直接验证了掩码的作用位置与因果性。

形状追踪如下表。view 与 transpose 不改变元素总数,只重排维度;contiguous 在合并头维前把内存布局恢复为连续,否则 view 可能报错。

步骤形状
输入 x
ln1(x)
q_proj(x)
view + transpose
scores
softmax(scores)
attn @ v
transpose + view
o_proj
第一次残差相加
ln2
FFN 第一层
GELU
FFN 第二层
第二次残差相加

若把 mask 加在 softmax 之后,前缀不变性检验仍可能通过,因为未来位置的权重被置零;但行和不再为 1,输出尺度错误,训练损失下降更慢。若把 mask 加到错误的维度,例如对 掩码取转置,模型会看到未来而看不到过去,训练损失异常低而生成质量极差。若把 Pre-LN 写成 Post-LN 但保留 x + attn(ln1(x)) 的写法,LayerNorm 的位置与残差顺序不一致,深层训练会不稳定。若忘记 contiguous(),在某些 PyTorch 版本与形状下 view 会抛出 RuntimeError。

易错点

以下六条均可在形状推导或代码运行中直接检验。

1. LayerNorm 的作用维度写错:Transformer 的 LayerNorm 沿特征维 归一化,对 产生 组统计量;若对批维或序列维归一化,推理结果会依赖同批样本或序列长度,且与训练时行为不一致。

2. 残差顺序与归一化位置混用:Post-LN 是 ,Pre-LN 是 ;把 Pre-LN 的残差写法与 Post-LN 的末端结构拼在一起,或 Pre-LN 忘记最终 LayerNorm,都会使深层训练发散或表示尺度失控。

3. 掩码时机与广播错误:掩码必须在 softmax 之前以加性 加入,形状 广播到 ;softmax 后置零破坏行归一化,掩码转置则泄漏未来信息,掩码未放到正确设备会直接报错。

4. 位置编码相加方式错误:位置编码必须与 token 嵌入逐元素相加且维度为 ,在进入第一层之前加入一次;拼接会改变维度,只在最后一层加则前几层没有位置信息,广播时把 加到批维也会错位。

5. 标签移位方向错误:解码器输入应为 ,目标是 ;不移位会使模型直接看到答案,反向移位则看到未来标签,两种错误都会让训练损失异常低而推理无效。

6. 交叉注意力的 Q/K/V 来源错误:查询必须来自解码器当前层,键与值必须来自编码器输出;三者都取自解码器会退化为自注意力,查询取自编码器则解码器状态无法参与检索。

关联笔记

  • 前置 注意力机制与QKV:第 3 节的缩放点积注意力、 与多头拆分以该篇的推导为基础,本篇只补充层内组合与形状。
  • 前置 因果注意力与多头注意力:解码器的掩码自注意力直接使用该篇的因果掩码实现,掩码时机与广播规则相同。
  • 前置 位置编码-正弦与RoPE:第 2 节的嵌入相加、位置编码维度与长上下文行为由该篇给出推导与代码。
  • 后续 KV缓存:第 10 节的解码过程在工程上通过缓存历史键值加速,该篇给出显存公式与 prefill/decode 的计算特征。
  • 后续 Llama-2架构复盘:该篇把本篇的 Pre-LN、FFN 与注意力替换为 RMSNorm、SwiGLU、RoPE 与分组查询注意力的具体配置。

达标检测

  • [ ] 画出编码器-解码器的数据流,写出嵌入、注意力、FFN、logits 各张量的形状,说明批维与头维在何处展开与合并,并指出交叉注意力中 Q、K、V 的来源。
  • [ ] 写出 Post-LN 与 Pre-LN 的层公式,说明两者在梯度通路上的差别,以及 Pre-LN 为什么需要末端 LayerNorm。
  • [ ] 从 推出 的展开式,指出恒等项的作用。
  • [ ] 对 、、、 逐项计算注意力、LayerNorm、FFN、嵌入与总参数量,误差不超过 1%。
  • [ ] 解释掩码为什么必须在 softmax 之前加入,并说明 softmax 后置零会导致行和与梯度出现什么问题。
  • [ ] 运行例 3 的代码,报告参数量与三项因果性检验结果,并把 causal 改为 False 后解释输出变化。
  • [ ] 给定解码器输入与标签,写出正确的移位方式,并指出不移位、反向移位各自造成的标签泄漏。

参考来源

  • Vaswani et al., "Attention Is All You Need", arXiv:1706.03762 —— 对应本篇第 1 至 4 节的整体架构、编码器/解码器层、多头注意力、位置编码相加、第 9 节参数量配置与第 10 节标签平滑。
  • d2l.ai《动手学深度学习》"注意力机制与 Transformer" 一章 —— 对应第 3 节多头注意力的形状变换、第 4 节掩码实现与第 10 节教师强制的训练流程。
  • Stanford CS224n 关于 Transformer 的讲义 —— 对应第 5 节 Post-LN/Pre-LN 的稳定性讨论、第 6 节残差梯度通路与第 7 节 LayerNorm 的作用维度。
  • Raschka, Build a Large Language Model (From Scratch), 2024, 第 4 章 —— 对应第 3 节 Pre-LN 模块的组织方式、第 8 节 GELU 前馈网络与第 9 节的参数量核对方法。
  • PyTorch 官方文档 torch.nn.LayerNorm 与 torch.nn.MultiheadAttention —— 对应第 7 节 normalized_shape 的语义与第 3 节多头注意力的输入输出形状约定。
  • Touvron et al., "Llama 2: Open Foundation and Fine-Tuned Chat Models", arXiv:2307.09288 —— 对应第 5 节现代 decoder-only 模型的 Pre-LN 类结构与第 8 节前馈网络的工程变体。