我们先把话说在前头：这几年大大小小的生成式模型层出不穷，可你要是把市面上一堆模型的架构图叠在一起看，会发现底层骨架几乎都写着同一个名字——Transformer。这篇就是把Transformer从头到尾彻底拆开揉碎，从注意力机制的来龙去脉到每个组件的数学细节，从训练时的数据流向到推理时的自回归过程，全给你梳理清楚。不管你是刚入门的小白，还是已经跑过几个模型的进阶玩家，这篇文章都值得你从头到尾过一遍，最好能收藏起来当工具书翻。
我希望达到的效果是：看完这篇，你能在脑子里凭记忆画出Transformer的完整结构图，能解释清楚为什么需要位置编码，能明白多头注意力在并行计算时到底在做什么，能理解训练和推理两个阶段的本质区别。这些东西单独拎出来每个都不难，但串在一起时很容易把人绕晕。我给它们安排了一条从零开始的理解路径。
1. 先搞明白：Transformer到底是在解决什么问题
1.1 序列建模的两种老思路，以及它们的天花板
说到序列生成任务，比如机器翻译、文本摘要、语音识别，传统方案长期被两类模型垄断：一类是循环神经网络及其变体，另一类是卷积神经网络。
RNN的思路很直观：一个词一个词地处理输入，用一个隐藏状态把前面看过的信息滚雪球式地往后传。打个比方，你读一句话的时候，是逐字往过看的，看后面的时候得记着前面出现过的内容。这个机制在短句上表现很好，但一旦句子超过几十个词，早期的信息经过多步传递后会严重衰减，这就是常说的长距离依赖问题。LSTM和GRU通过引入门控机制让信息衰减得慢一些，但本质还是没有跳出“必须按顺序一步步走”的框架——这一步算完才能算下一步，天然没法并行。
卷积神经网络的思路则是把句子当成一条一维信号，用卷积核扫描局部窗口，像用一个固定大小的渔网在句子序列上滑动。卷积的好处是计算可以高度并行，局部窗口内的特征提取也很高效。但坏处也很明显：每一层卷积只能看到窗口范围内的词，想捕捉长距离关系就必须不断堆叠层数，窗口才能一层层往外扩。这让模型变得很深，训练成本高，且远距离信息的路径绕来绕去，丢失概率不小。
这两种方案本质都在做同一件事：把一个序列中各个位置的信息沿着某种路径“搬运”到其他位置。RNN的搬运路径是时间步递推路径，CNN的搬运路径是卷积窗口叠加路径。
而Transformer换了一个根本性的思路——我不搞路径了，任何两个位置之间直接建立连接，一步到位，想你的时候不需要经过中间人。
这就是注意力机制诞生的逻辑背景。
1.2 自注意力机制的基本直觉：给序列中的每个词建立直接连接
S什么叫做一步到位？我们以“小明想去公园散步，因为那里很安静”这句话为例。当模型读到“那里”这个词时，需要把“那里”和“公园”关联起来。如果用RNN，这个关联需要经过从“公园”到“那里”之间所有词的多次状态更新才能建立起来；而自注意力机制直接把“那里”和“公园”的距离视为一步，通过计算两者之间的相关性分数直接完成信息交换。
具体操作上，自注意力机制为序列中的每个词生成三个向量：查询向量、键向量和值向量。如果拿检索来类比：查询向量是你手里的搜索关键词，键向量是所有候选项的标签，值向量是候选项的实际内容。系统拿着查询向量去和每个键向量做匹配，得到一组相关性分数，再根据分数高低把所有值向量做加权求和——相关性越高，贡献越大。这样每个位置的新表示，就融合了全序列所有位置的信息。
这套机制有一个直接的工程红利：计算整个序列所有位置之间的相关性分数，本质上是一连串的矩阵运算，而这种运算在GPU上可以高度并行完成。Transformer因此成了第一个可以不按顺序处理序列的主流模型架构。
1.3 从宏观视角看Transformer的整体架构
标准的Transformer采用编码器-解码器架构，适合处理“输入一段序列，输出另一段序列”的任务。以机器翻译为例，给定一句中文，编码器负责把整句中文转化成一串富含语义的向量，解码器则根据这些向量逐词生成英文。
编码器由多个结构完全相同的层堆叠而成，每一层内部有两个子层：第一个子层是多头自注意力，第二个子层是前馈网络。两个子层外面都包了残差连接和层归一化。
解码器的主体结构和编码器类似，但在每层中多加了一个子层：编码器-解码器注意力层，负责让当前要生成的词去“查询”编码器输出的信息。此外，解码器内部的第一个自注意力子层被加了掩码，保证它在预测当前位置时只能看到当前位置之前的词，不能偷看未来的词。这个设计在后面写训练代码时尤为重要。
把这座架构拆开来，最需要吃透的核心是四点：注意力机制本身、多头注意力的运作方式、位置编码、残差连接与归一化的作用。接下来逐个攻克。
2. 自注意力机制的数学原理与实践细节
2.1 从输入向量到Q、K、V：三个矩阵完成了一次特征投影
自注意力机制的起点是输入序列的向量表示。假设输入序列长度为n，每个词的嵌入维度是d_model，整个输入序列就可以表示为一个矩阵，形状为(n, d_model)。在实践中通常把多个样本拼成一个批次，形状为(batch_size, n, d_model)。
接下来每一步都围绕三个权重矩阵展开：查询投影矩阵W_Q、键投影矩阵W_K、值投影矩阵W_V。这三个矩阵的形状都是(d_model, d_k)，而d_k就是每个注意力头所处理的维度。第二版的注意力论文中，还专门加了一项细节：输出投影矩阵的形状是(d_k, d_head)。
投影计算过程就是矩阵乘法：查询矩阵等于输入矩阵乘以W_Q，键矩阵等于输入矩阵乘以W_K，值矩阵等于输入矩阵乘以W_V。经过投影后，形状变为(batch_size, n, d_k)。
一个很容易被忽视的细节是：Q、K、V虽然来自同一个输入矩阵，但它们各自乘以的权重矩阵完全不同，这意味解码器可以学习到同一序列在不同语义空间下的三种表征——一种用于发出查询，一种用于接收匹配，一种用于承载内容。
2.2 注意力分数的计算过程：从点积到Softmax
在多头注意力机制中，每个注意力头独立计算各自的注意力分数。核心操作是拿查询矩阵与键矩阵做矩阵乘法，得到形状为(batch_size, n, n)的分数矩阵。
每个元素表示该头在当前位置对所有输入位置的相关性匹配程度。分数越高，说明当前位置对那个位置越关注。
点积结果有三个值得注意的特性：第一，随着嵌入维度的增大，点积结果的数值规模也会随之增长，容易把后续的Softmax函数推入饱和区；第二，Softmax在饱和区内的梯度会变小，导致训练变慢；第三，为了缓解这个问题，注意力论文中在点积结果上除以了d_k的平方根，这个操作就叫做缩放点积注意力。
为什么要除以d_k的平方根？这个选择背后有概率统计的依据。当查询向量和键向量都是零均值、单位方差的独立随机变量时，它们的点积均值仍然为零，但方差会变成d_k。除以d_k的平方根后，点积结果的方差会被拉回1附近，从而让Softmax输入更稳定。
实验中有个直观体验：如果把维数变大，比如d_k从64提到512，却不做缩放，注意力分布会迅速变得极端——几乎所有权重集中到极少数几个位置上，模型退化成硬选择，这对优化非常不利。缩放就是个简单便宜的自适应归一化手段。
完成了分数计算后，沿最后一个维度做Softmax归一化，让每一行的所有元素之和为1。这一步把分数变成了概率分布，含义是当前位置分配给序列中各个位置的信息权重。Softmax的注意力分布也天然具备可解释性：直接观察权重分布就能看出模型在生成某个词时到底在“看”输入的哪些位置。
2.3 从概率权重到上下文向量：加权的意义
有了概率分布之后，最后一步就是用这个权重分布去加权求和值矩阵。计算结果是每个位置的新向量，形状仍然是(batch_size, n, d_k)。每个位置的向量都是整个值向量序列的凸组合，因此它携带了全序列的综合信息。
把整个过程用数学语言串一遍：
- 注意力分数矩阵 = Q乘以K的转置
- 缩放后的分数矩阵 = 注意力分数矩阵除以d_k的平方根
- 权重矩阵 = Softmax(缩放后的分数矩阵)
- 上下文向量 = 权重矩阵乘以V
这段流程里，矩阵乘法占了绝对主导。PyTorch里典型的实现不到十行代码就能写完，大批量的并行矩阵运算给GPU练了个痛快。通常我建议第一次实现的人别上来就用现成的multi_head_attention_forward封装，先手动跑一遍这个小流程，会对整个机制产生一种“我懂它在做什么”的踏实感。
注意：缩放因子是d_k的平方根，不是d_model的平方根，也不是其他值。d_k是单个注意力头内部的维度。假设d_model=512，头数h=8，那么d_k=64，缩放因子就是8。这个细节面试和实际调试中都容易踩坑。
3. 多头注意力：为什么一个头不够用，要八个？
3.1 单头注意力的局限：平均化的困境
单个注意力头最大的问题在于：它将所有注意力集中在一套相关性定义下，难以同时捕捉多种不同类型的关系。
回到“小明去公园散步，因为那里很安静”这个例子。假设现在模型要预测“那里”指代什么，需要同时用到两种关系：一种是语法层面的指代关系（“那里”指“公园”），另一种是语义层面的因果或关联关系（“安静”和“公园”相关）。单一注意力头只能选一种偏好——指望一个头同时建模两种关系，最终结果往往是两边都模糊。多头注意力解决的正是这个困境：不同的头负责关注不同类型的关系。
3.2 多个头各自为战，最后拼接融合
多头注意力的运作方式与单头几乎相同，只是把输入等分到h个头中，每个头独立进行缩放点积注意力计算，相当于模型在h个不同的子空间中并行运行了h次注意力机制。
每个头的输入维度从d_model缩到d_k，计算结束后，把h个头的输出在最后一维上拼接起来，形状恢复到(batch_size, n, d_model)，再乘一个输出投影矩阵W_O，完成跨头的信息融合。
如果把d_model=512，h=8，那么每个头的d_k=64。8个头的输出拼接后刚好是512维。这个尺寸设计是经过精心安排的：总计算量和单头注意力保持相同，没有额外增加FLOPs，却赋予了模型多角度的信息捕捉能力。
关于每个头是否会“各学各的”，网上常见的一个误区是认为多头只是把向量切成几段分别计算，没有信息交流。实际上拼接后的输出投影矩阵W_O允许模型在多头之间做线性组合，相当于在头与头之间建立了一条信息通道，最终输出可以混合各个子空间的信息。
3.3 什么时候该用多头，什么时候单头也够用
经验上，头数太少会导致表达能力不足；头数太多则可能把有限的数据分散到过多子空间，反而让每个头学到的东西变得重复。
实践中的折中方案是：大多数情况下保持d_model在256到1024之间，头数取8到16之间，保证d_k在32到128之间。头数超过16后，收益递减明显，计算和显存开销却线性增长。
有一种常见误区需要纠正：并非用更多头就一定更好。有研究指出，很多头学到的内容高度相似，剪枝掉一部分头对整体效果影响很小。所以建议大家把注意力集中在外层功能的堆叠上，不必过分追求头数。
4. 位置编码：给并行处理加上“顺序感”
4.1 位置信息丢失问题，以及为什么非解决不可
上文的整个注意力机制有一个致命盲区：如果我把一句话里的词换一下顺序，注意力分数会完全不变。原因是矩阵乘法本质上是对集合的操作，它对词的位置不敏感。而语言恰恰是强顺序依赖的：“小明打了小红”和“小红打了小明”，完全相反的意思，计算机单看嵌入向量却察觉不到区别。
于是位置信息必须显式注入到输入向量中。
4.2 三角函数的选取逻辑：为什么用正弦和余弦
Transformer原文采用了一种优雅的方案：用不同频率的正弦和余弦函数来生成位置编码。
公式分两种，针对位置pos和维度索引i：
- 编码值(pos, 2i) = sin(pos / 10000^(2i/d_model))
- 编码值(pos, 2i+1) = cos(pos / 10000^(2i/d_model))
当i从0增长到d_model/2时，分母从1涨到10000，对应的三角函数周期越来越长。这种设计有几个好处：首先，生成任意位置编码都不需要额外参数，推理时遇到超长序列也能即时算出位置编码；其次，不同位置得到各不相同的向量，模型可以根据向量模式推断出相对位置关系；第三，正弦和余弦的组合能够把位置信息按照不同频率进行编码，这对不同间隔的远近关系都提供了区分度。
一个简化理解方式是：把位置想象成温度计，正弦和余弦的不同频率像刻度一样记录变化的规律。
4.3 可学习位置嵌入与三角函数方案怎么选
后来的很多模型没有套用三角函数位置编码，而是改成了可学习位置嵌入。做法很简单：把位置编号当成索引，查一张形状为(max_len, d_model)的位置表。
可学习位置嵌入的优势是灵活，完全靠数据驱动去学习哪些位置特征有用。三角函数的优势是无参、可外推、不需要学习曲线。但值得注意的是，可学习方案在超出max_len时就会有尴尬——没有超出范围的编号可用。热门模型中，很多已经改用旋转位置编码等方法，这是对序列长度外推的更大胆尝试，基础原理我们有机会单独写一篇。
4.4 位置编码到底加在哪个位置才对
位置编码与词嵌入相加的方式是：同一个位置的词嵌入向量和位置编码向量按元素相加，得到模型的输入。
实操中比较常见的一个坑是：忘记在输入和位置编码之间做缩放。原版Transformer的做法是对词嵌入先乘以根号d_model，让嵌入的方差与位置编码的振幅相匹配。加上位置编码后的向量进模型，在稳定性上表现更佳。
位置编码的细节还有个容易被忽视的点：它加在编码器和解码器各自的输入上。两个模块各有位置编码，虽然公式一样，但独立存储独立叠加。
5. 残差连接与层归一化：让深层网络真正训练得动
5.1 残差连接解决退化问题
对于一个深度网络，即使把层数堆得很深，如果没有残差连接，梯度在反向传播时容易逐层衰减，导致浅层几乎接收不到更新信号。这在训练早期尤其致命。
残差连接的做法非常简单：每个子层输出 = 子层函数(输入) + 输入。这样，梯度可以通过跳线直接流到浅层，而子层本身只需要学习“增量”即可，无需从头重建原始信息。这在Transformer的训练中获得了一种非常独特的稳定作用。
实践经验：即便只加两三层Transformer，残差连接的作用尚不明显；一旦层数超过6层，对训练收敛的作用会非常显著。层数越深，越能感受到残差存在的必要性。
5.2 层归一化到底在哪一步做才有效
归一层放在残差连接之后，这是原版的结构，即子层输出先加残差输入，再做层归一化。
后来出现了Pre-Norm的变体，把归一化放在子层处理之前，两种做法各有优劣。Post-Norm贴合原版，但训练时需要额外的预热策略来保证稳定；Pre-Norm在深层训练中更稳，但有时会牺牲部分表达能力。
实操中新人建议直接使用Pre-Norm，省心，稳定，收敛更快。如果你要复刻原版效果，再切回Post-Norm逐步调试。
层归一化本身的做法是：对每个样本的每个位置上的向量，在特征维上计算均值和方差，然后做标准化并缩放偏移。和BN不同，层归一化不依赖批次统计数据，因此在样本数量较小或动态序列长度的场景下更友好。
5.3 前馈网络为什么少不掉
注意力层负责捕捉位置间的关系，但注意力本质上是一个基于加权求和的线性混合过程。为了给模型注入非线性表达能力，每个编码器和解码器层还会接一个前馈网络：先经过线性变换升维到约4倍宽度，经过激活函数，再降维回原维度。
这个结构的含义是：注意力负责“看哪里”，而前馈网络负责“怎么理解看到的东西”。有研究表明，前馈网络实际上充当了记忆存储的角色，大量事实性知识都分布在这层参数中。
6. 编码器与解码器的完整装配与数据流
6.1 编码器的层次堆叠逻辑
编码器的每层都由三个核心块组成：多头自注意力子层、残差连接与层归一化、前馈网络子层。多个这样的层垂直堆叠，底层吃的是词嵌入加位置编码，顶层输出的是整个输入序列的语义向量序列。
编码器输出的向量序列有形状(batch_size, n, d_model)。这个输出本身即可用作文本分类、句向量提取等任务，但在序列生成场景里，它还要进一步传给解码器作为跨层查询来源。
6.2 解码器里那层“掩码”在锻造什么
解码器在生成第几个词时，只能使用之前已经生成的词。如果在训练时放任自注意力看到全部序列，模型就能直接“偷看”答案，相当于考试时带上了未来的考卷。
掩码的运作方式是：在计算注意力分数时，将未来位置对应区域的值替换为一个极大的负数，比如-1e9。Softmax经过这样处理后，注意力权重在这些位置会趋近于零，等于模型完全看不到未来信息。
编码器和解码器的数据流关系也值得点透：解码器每一层除了自己内部的掩码自注意力外，还用一个“编码器-解码器注意力”子层来查询编码器的输出。查询来自解码器当前层，键和值来自编码器输出，这允许生成过程随时把输入序列的信息结合进来——在机器翻译场景中，就是模型在生成英文单词时反复回看中文原句。
6.3 一个完整的训练样本，走一遍前向流程
用机器翻译为例，模型输入是一句中文，标签是一句英文。训练时中文经过编码器得到语义向量；英文被嵌入后加掩码信息输入解码器；编码器输出作为键和值参与解码器每层注意力的计算；解码器最终的输出通过一个线性层映射到目标语言词汇表的logits；损失函数和one-hot标签计算交叉熵。
这一整套流程有一个专门的术语叫教师强制，意思是解码器在训练时使用真实的正确答案序列作为输入，而不是使用自己上一时刻生成的词。这个设计能大幅加速训练收敛。代价则是训练与推理之间存在暴露偏差——训练时看到的都是正确答案，推理时却要靠自己的输出往前滚。缓解手段包括计划采样、强化学习微调等，这是后话。
7. 核心实现：一份可直接参考的PyTorch伪代码
写代码之前先说清楚，下面这份实现是为了帮助理解架构而精简过的教学版本，不是最高效的工业级写法，但所有关键结构都和原版论文一一对应。建议你逐行读，先别看结论。
import math import torch import torch.nn as nn import torch.nn.functional as F class MultiHeadAttention(nn.Module): def __init__(self, d_model, n_heads, dropout=0.1): super().__init__() assert d_model % n_heads == 0 self.d_model = d_model self.n_heads = n_heads self.d_k = d_model // n_heads self.w_q = nn.Linear(d_model, d_model) self.w_k = nn.Linear(d_model, d_model) self.w_v = nn.Linear(d_model, d_model) self.w_o = nn.Linear(d_model, d_model) self.dropout = nn.Dropout(dropout) def forward(self, query, key, value, mask=None): batch_size = query.size(0) # 线性投影后拆分多头 q = self.w_q(query).view(batch_size, -1, self.n_heads, self.d_k).transpose(1, 2) k = self.w_k(key).view(batch_size, -1, self.n_heads, self.d_k).transpose(1, 2) v = self.w_v(value).view(batch_size, -1, self.n_heads, self.d_k).transpose(1, 2) # 缩放点积注意力 scores = torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(self.d_k) if mask is not None: scores = scores.masked_fill(mask == 0, float('-inf')) attn_weights = F.softmax(scores, dim=-1) attn_weights = self.dropout(attn_weights) context = torch.matmul(attn_weights, v) # 拼接多头结果并输出 context = context.transpose(1, 2).contiguous().view( batch_size, -1, self.d_model ) return self.w_o(context) class FeedForward(nn.Module): def __init__(self, d_model, d_ff, dropout=0.1): super().__init__() self.linear1 = nn.Linear(d_model, d_ff) self.linear2 = nn.Linear(d_ff, d_model) self.dropout = nn.Dropout(dropout) def forward(self, x): return self.linear2(self.dropout(F.relu(self.linear1(x)))) class EncoderLayer(nn.Module): def __init__(self, d_model, n_heads, d_ff, dropout=0.1): super().__init__() self.self_attn = MultiHeadAttention(d_model, n_heads, dropout) self.feed_forward = FeedForward(d_model, d_ff, dropout) self.norm1 = nn.LayerNorm(d_model) self.norm2 = nn.LayerNorm(d_model) self.dropout = nn.Dropout(dropout) def forward(self, x, mask=None): x = x + self.dropout(self.self_attn(x, x, x, mask)) x = self.norm1(x) x = x + self.dropout(self.feed_forward(x)) x = self.norm2(x) return x class DecoderLayer(nn.Module): def __init__(self, d_model, n_heads, d_ff, dropout=0.1): super().__init__() self.masked_self_attn = MultiHeadAttention(d_model, n_heads, dropout) self.cross_attn = MultiHeadAttention(d_model, n_heads, dropout) self.feed_forward = FeedForward(d_model, d_ff, dropout) self.norm1 = nn.LayerNorm(d_model) self.norm2 = nn.LayerNorm(d_model) self.norm3 = nn.LayerNorm(d_model) self.dropout = nn.Dropout(dropout) def forward(self, x, enc_output, src_mask=None, tgt_mask=None): x = x + self.dropout(self.masked_self_attn(x, x, x, tgt_mask)) x = self.norm1(x) x = x + self.dropout(self.cross_attn(x, enc_output, enc_output, src_mask)) x = self.norm2(x) x = x + self.dropout(self.feed_forward(x)) x = self.norm3(x) return x class PositionalEncoding(nn.Module): def __init__(self, d_model, max_len=512): super().__init__() pe = torch.zeros(max_len, d_model) position = torch.arange(0, max_len).unsqueeze(1).float() div_term = torch.exp( torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model) ) pe[:, 0::2] = torch.sin(position * div_term) pe[:, 1::2] = torch.cos(position * div_term) pe = pe.unsqueeze(0) self.register_buffer('pe', pe) def forward(self, x): x = x + self.pe[:, :x.size(1)] return x class Transformer(nn.Module): def __init__(self, src_vocab, tgt_vocab, d_model=512, n_heads=8, d_ff=2048, n_layers=6, dropout=0.1, max_len=512): super().__init__() self.encoder_embed = nn.Embedding(src_vocab, d_model) self.decoder_embed = nn.Embedding(tgt_vocab, d_model) self.pos_enc = PositionalEncoding(d_model, max_len) self.encoder_layers = nn.ModuleList([ EncoderLayer(d_model, n_heads, d_ff, dropout) for _ in range(n_layers) ]) self.decoder_layers = nn.ModuleList([ DecoderLayer(d_model, n_heads, d_ff, dropout) for _ in range(n_layers) ]) self.out_proj = nn.Linear(d_model, tgt_vocab) self.dropout = nn.Dropout(dropout) self.d_model = d_model def forward(self, src, tgt, src_mask=None, tgt_mask=None): src_emb = self.dropout(self.pos_enc(self.encoder_embed(src) * math.sqrt(self.d_model))) enc_output = src_emb for layer in self.encoder_layers: enc_output = layer(enc_output, src_mask) tgt_emb = self.dropout(self.pos_enc(self.decoder_embed(tgt) * math.sqrt(self.d_model))) dec_output = tgt_emb for layer in self.decoder_layers: dec_output = layer(dec_output, enc_output, src_mask, tgt_mask) logits = self.out_proj(dec_output) return logits代码中的几个细节值得单独说明：
第一，位置编码用了register_buffer而不是普通张量，这样位置编码会随模型一起迁移到GPU，且不会在反向传播中被更新。
第二，mask参数传入后直接应用masked_fill，把被掩码区域变成负无穷，而不是先经过矩阵运算再过滤。这一做法的关键在于绕过Softmax的敏感区间，让后续的归一化稳定。
第三，多头拆分用了view加transpose的组合，得到的张量形状是(batch_size, n_heads, seq_len, d_k)。如果不做transpose，后续矩阵乘法的维度就对应不上。
8. 训练与推理的大不同：教师强制、逐词生成与束搜索
8.1 训练阶段为什么能并行出整个句子
训练阶段最让初学者迷惑的一点是：既然生成是一个词一个词来的，为什么训练时能一次性把一个完整的句子全喂进去？
答案就在于刚才说的教师强制。训练时用真实目标序列作为解码器输入，并且只算“预测下一个词”的交叉熵损失。由于序列中每个位置的预测相互独立，所有位置的损失可以一次性算完，整个目标序列可以一整条并行进模型。
这也解释了为什么掩码在训练时如此关键。如果不加掩码，模型在预测第3个词时就能看到真实的第4、5个词，等同于作弊。掩码确保了每个位置只能使用当前位置之前的信息。
8.2 推理阶段的逐步生成流程
到了推理阶段，没有真实答案可用，模型只能自食其力：最开始给解码器喂一个起始标记，得到第一个词的分布；采样或取概率最大的词作为新输入的一部分，再重新过一遍解码器，逐步得到后续词；直到模型预测出结束标记为止。
因此推理阶段的计算效率远低于训练阶段，每一步都要让整个解码器跑一遍。为了缓解速度问题，工程上会把已经生成过的词对应的键值向量缓存下来（KV Cache），后续只需计算新词的注意力，省去重复计算。这个优化在实际部署中几乎是标配。
8.3 束搜索等生成策略的取舍
朴素贪心解码每次取概率最大的词，速度最快，但容易陷入局部最优，比如反复产生“我我我”这种重复片段。
束搜索保存了多条候选路径，每一步保留得分最高的K条路径，最后综合打分。束宽越大，生成质量越高，但计算开销也越大。对话、翻译这类对精度要求高的任务适合束搜索；开放生成场景则更适合用采样，配合温度参数控制随机性。
实操中，束宽的取值通常取4到8之间，超出后收益不明显。重复惩罚因子也需要调，具体值因数据集而异，建议用验证集多试几次。
9. 参数表与数据流速查：一张表看懂所有尺寸
这里整理了一份常用基础配置下的参数速查表，对应的是机器翻译场景里比较经典的Transformer base设置。
| 模块 | 形状/参数 | 说明 |
|---|---|---|
| 词嵌入矩阵 | vocab_size × d_model | 输入输出侧各有独立嵌入矩阵 |
| 位置编码 | max_len × d_model | 一般为512×512 |
| W_Q/W_K/W_V | d_model × d_model | 多头模式下内部切分 |
| W_O | d_model × d_model | 拼接后的输出投影 |
| 前馈第一层 | d_model × d_ff | 一般为512×2048 |
| 前馈第二层 | d_ff × d_model | 2048×512 |
| 层归一化 | 两个可学习标量 | 每个子层一组 |
| 输出投影 | d_model × vocab_size | 映射到词汇表分布 |
数据流维度可以这样梳理：
- 嵌入后输入形状(n, 512)
- 多头拆分后每个头形状(n, 64)
- 自注意力输出的上下文形状(n, 512)
- 经过前馈网络后形状恢复(n, 512)
- 多层堆叠后输出形状(n, 512)
- 解码器最终输出经输出投影得到(n, vocab_size)
如果你自己实现模型时维度对不上，沿着这条链逐层打印张量形状排查，99%的问题能立刻定位。
10. 实操中绕不开的坑，以及经验型排查思路
10.1 训练不收敛或震荡剧烈
新写的Transformer训练时loss迟迟不降，最常见的原因之一是学习率策略不对。原版Transformer搭配的是带预热(warmup)的Adam优化器，前期用一个较小的学习率慢慢起步，后面再逐渐衰减，直接用一个固定较大的学习率很容易导致震荡。
如果确认学习率没问题，下一步就该检查参数初始化，留意是否有无穷大或空值。还可以打印一下注意力矩阵的值，看看是不是出现了极其稀疏的分布。
10.2 推理时输出全是<unk>或重复词
这通常指向两个方向：一是词表太小或分词太粗糙，生僻词被映射成了未登录词；二是训练阶段使用了教师强制，推理时模型从未见过自己生成的序列，偏差被逐步放大。解决办法可以是训练时随机用模型自己的输出替代真实目标词，也可以微调阶段加入强化学习策略。
10.3 显存不足
显存溢出的元凶通常是注意力矩阵的平方级扩张。序列长度翻倍，注意力矩阵会变为原来的四倍。缓解手段有梯度累积、混合精度、减少批次大小，以及对长序列任务改用稀疏注意力或增量式注意力。
10.4 热门的变体怎么选
如果你想做的是生成散文或对话，基于解码器架构的模型更合适。如果你想做的是翻译或摘要，编码器-解码器架构依然是正统选择。理解了原版Transformer，再看这些变体基本上就是理解结构上的增删和细节上的调整，不会有根本性的障碍。
11. 关于“Transformer”扩展方向：从NLP到多模态再到决策领域
Transformer从诞生起就不是NLP的专利。
在语音识别里，它被用来建模音频序列的长程依赖；在视觉领域，ViT把图像切成固定大小的块，每个块当一个“词”送入Transformer做分类，效果在大规模数据下超过了传统卷积网络。值得多说一句的是，ViT的出现让计算机视觉社区意识到，通用架构统一处理多种模态是可行的。很多架构层面的讨论都诞生于这个洞察。
在推荐系统、时序预测、强化学习决策模型等领域，Transformer也陆续被引入。它的核心卖点始终是：任意两个位置之间的直接交互，以及由此带来的灵活性和可扩展性。
所以，虽然我们的场景大多围绕NLP，但把Transformer的原理学扎实了，相当于拿到了一把可以开很多扇门的通用钥匙。
我在实际使用中的体会是：真正把每一步的原理弄清楚之后，后面无论看什么模型的论文都会快很多。那些炫目的新模型，绝大多数依旧是“注意力加上一些结构性改进”的组合。花一个周末把这个基础啃透，绝对值得。
