Transformer架构完全解析：各模块的逐层详解

本文深入剖析Transformer架构的每个组成部分，从输入处理到最终输出，详细讲解其工作原理和设计思想。

一、Transformer总体架构

Transformer架构由四个主要部分组成：

1. 输入部分 - 负责将文本转换为模型可处理的向量表示
2. 输出部分 - 将模型输出转换为实际的文本
3. 编码器部分 - 理解输入文本的语义信息
4. 解码器部分 - 基于编码器的理解和已生成内容生成输出文本

二、输入部分详解

输入部分包含两个核心组件：

• 源文本嵌入层及其位置编码器
• 目标文本嵌入层及其位置编码器
  

2.1 Embedding：从词汇到向量

无论是源文本嵌入还是目标文本嵌入，其核心目的都是将文本中词汇的表示转变为词向量表示。通过将词汇映射到高维向量空间，我们期望在这个空间中捕捉词汇间的语义关系。

词嵌入的核心思想

把这些词看做是高维空间中的坐标点，在理想情况下，语义相近的词汇对应的向量在该空间中彼此靠近。

Transformer的输入处理流程

Transformer使用分词工具将句子拆解成最小单元的token，每个token被编码为一个512维的向量。

示例分析：

• 句子：“用毒毒毒蛇毒蛇会不会被毒毒死”
• 分词结果：10个token
• 每个token：512维向量（由512个数值组成）
  

代码实现解析

class Embeddings(nn.Module):
    def __init__(self, d_model, vocab):
        """
        d_model: 词嵌入维度（通常为512）
        vocab: 词汇表大小
        """
        super(Embeddings, self).__init__()
        self.lut = nn.Embedding(vocab, d_model)
        self.d_model = d_model
        
    def forward(self, x):
        """
        当传给该类的实例化对象参数时，自动调用该类函数
        参数x: 因为Embedding层是首层，所以代表输入给模型的文本通过词汇映射后的张量
        """
        # 将x传给self.lut并与根号下self.d_model相乘作为结果返回
        return self.lut(x) * math.sqrt(self.d_model)

💡 答案：获取输入词向量之后乘以embedding size的开方（√d_model），主要是为了平衡词向量矩阵的数值尺度，确保在后续的加法和线性变换中保持数值稳定性。

🔍 通俗解释：

1. 词向量本身数值较小（比如在-0.1到0.1之间）
2. 后续要加上位置编码（位置编码数值也较小）
3. 如果不放大词向量，位置编码的影响会相对太大
4. 乘以√d_model让词向量"声音更大"，避免被位置编码淹没

📊 数学原理：

• 假设词向量初始值遵循均值为0、方差为1的分布
• 经过嵌入层后，我们希望保持这种分布特性
• 乘以√d_model可以抵消后续线性变换中的缩放效应

2.2 Positional Encoding：捕捉序列顺序信息

因为Transformer不采用RNN的结构，而是使用全局信息，无法直接利用单词的顺序信息，而这部分信息对于NLP任务至关重要。

位置编码用PE表示，其维度与单词Embedding相同。在原始Transformer中，位置编码使用固定公式计算：

位置编码公式

对于位置pos和维度i：

$$P{E}_{(pos,2i)}=\sin \left(\frac{pos}{10000^{2i/d_{\text{model}}}}\right)$$

$$P{E}_{(pos,2i+1)}=\cos \left(\frac{pos}{10000^{2i/d_{\text{model}}}}\right)$$

参数说明：

• pos：单词在句子中的位置（0, 1, 2, …）
• d_model：词嵌入维度（通常为512）
• 2i：偶数维度索引
• 2i+1：奇数维度索引
  

位置编码的优势

✅ 相对位置可计算：固定间距k的位置编码可以通过三角函数公式计算得到，PE(pos+k) 可以用 PE(pos) 计算得到

三角函数关系：

• $\sin (A+B)=\sin (A)\cos (B)+\cos (A)\sin (B)$
• $\cos (A+B)=\cos (A)\cos (B)-\sin (A)\sin (B)$

2.3 最终输入：词向量 + 位置编码

将单词的词嵌入向量和位置编码向量相加，得到Transformer的输入表示：

🔗 最终输入 = 词嵌入向量 + 位置编码向量

# 输入处理流程
input_embeddings = word_embeddings(tokens)  # 词嵌入
positional_embeddings = positional_encoding(input_embeddings)  # 位置编码
final_input = input_embeddings + positional_embeddings  # 相加得到最终输入

🚀 两者分工：

• 词嵌入：提供单词的语义信息
• 位置编码：提供单词在序列中的位置信息

三、编码器（Encoder）部分

编码器部分由N个编码器层堆叠而成（原始论文中N=6）。每个编码器层包含两个核心子层：

3.1 编码器层结构

每个编码器层 = 
    子层1: 多头自注意力 + 残差连接 + 层归一化
    子层2: 前馈神经网络 + 残差连接 + 层归一化

3.2 注意力机制：模型的核心

注意力机制是Transformer最核心的创新。我们首先理解基础的缩放点积注意力。

3.2.1 缩放点积注意力（Scaled Dot-Product Attention）

计算流程：

输入 → 线性变换 → Q, K, V → 点积 → 缩放 → Softmax → 加权求和 → 输出

矩阵表示：
$$\text{Attention}(Q,K,V)=\text{softmax}\left(\frac{Q{K}^T}{\sqrt{d_k}}\right)V$$

Q、K、V的含义

Q,K,V正是通过 Self-Attention 的输入进行线性变换得到的。
首先模型使用三个权重矩阵W_Q、W_K、W_V分别和每一个词向量进行相乘，这样每个矩阵可以得到三个向量Q、K、V

K（Key）：能为其他词提供什么（类似标签、索引）
V（Value）：词实际包含的内容信息

💡答案：
使用不同的权重矩阵（Wq和Wk）生成Q和K，最根本的目的是为了赋予模型捕捉"非对称关系"的能力。
如果Q和K使用同一个权重矩阵，那么注意力机制就退化成了一个简单的、对称的“相似度匹配”，无法有效表达像“主语-动词”、“修饰-被修饰”这种具有方向性的语法和语义关系。
例如：
使用同一个权重矩阵（W = Wq = Wk）
这种情况下，计算词A对词B的注意力分数，与计算词B对词A的注意力分数，在理论上是完全对称的。 因为点积操作 (A·W) · (B·W)^T
本质上等于 (B·W) · (A·W)^T。这意味着模型认为“A关注B”和“B关注A”的重要性是相同的。

后果：
模型被限制在一个“相似度匹配”的模式里。它只能找到哪些词在语义空间里很接近，但无法建模它们之间具体的、有方向性的关系。这极大地限制了模型的表达能力和性能。

🔄 对比分析：

情况一：使用相同权重矩阵

# 假设W = Wq = Wk
Q = X * W
K = X * W
# 注意力分数计算
attention_scores = Q @ K.T  # 对称操作

⚠️ 问题：A→B的注意力分数等于B→A的注意力分数，无法建模有方向的关系（如"主语→动词"）。

情况二：使用不同权重矩阵

Q = X * Wq
K = X * Wk
# 注意力分数计算
attention_scores = Q @ K.T  # 非对称操作

✅ 优势：可以学习到非对称的关系，更好地捕捉语法和语义结构。

3.2.2 注意力计算步骤详解

（1）MatMul：矩阵乘法

计算Q和K的转置的点积，得到注意力分数矩阵：

# 计算注意力分数
scores = torch.matmul(Q, K.transpose(-2, -1))

每个分数表示一个查询（query）与所有键（key）的相似度。分数越高，关注度越高。

（2）Scale：缩放操作

将分数除以缩放因子（键向量维度的平方根）：
目的是避免点积过大导致梯度消失，防止梯度爆炸。

# 缩放操作
scores = scores / math.sqrt(d_k)

💡 答案：对注意力得分进行缩放（除以√d_k）的主要目的是控制点积得分的方差，防止其过大导致softmax函数进入>梯度饱和区，从而避免梯度消失问题，确保训练稳定性和效率。
📐 数学推导：
假设q和k是d_k维向量，每个元素独立同分布，均值为0，方差为1：

• q·k的均值为0
• q·k的方差为d_k
  当d_k较大时，点积的绝对值可能很大，导致softmax梯度很小。
  🎯 缩放效果：
  缩放后，q·k/√d_k的方差为1，使得softmax输入保持在合理范围。

（3）Mask：掩码操作（可选）

在解码器中，为了阻止关注到未来的信息，需要进行掩码：

# 创建下三角掩码矩阵
mask = torch.tril(torch.ones(seq_len, seq_len))
mask = mask.masked_fill(mask == 0, float('-inf'))
scores = scores + mask

（4）Softmax：归一化

对分数进行softmax归一化，得到注意力权重：

# Softmax归一化
attn_weights = F.softmax(scores, dim=-1)

🎯 Softmax的作用：

1. 将分数转换为概率分布（0~1之间）
2. 较高的得分得到增强，较低的分数被抑制
3. 每个查询的权重之和为1
   
   例如“用”和第一个毒关联程度最高，和第二个、第三个毒的权重就比较低。
   这样将输出转换为服从概率分布的数字，使得每个查询的权重之和为1。
   
   输出层的数据，经过softmax函数转换后的结果，即可满足概率表达式的特性。
   因此，输出层的数据转化成概率表达式后的输出值，就有了新的意义。对分类问题来说，不同大小的概率值表示，这个结果属于不同类别的可能性大小。

示例：

原始分数：3, 1, -3
softmax结果：0.88, 0.12, 0.00

含义：
- 属于"第一类"的概率是88%
- 属于"第二类"的概率是12%
- 属于"第三类"的概率是0%

通过softmax函数，将神经网络的输出结果转化成概率表达式。找到最大概率项，为其分类。

（5）MatMul：加权求和

知道每个词的关联程度还不够，接下来还需要将注意力权重与值矩阵V相乘，得到加权的值向量：

# 加权求和
output = torch.matmul(attn_weights, V)

输出向量Z包含了句子中每一个词以及对其他词含义的理解。

💡 答案：Transformer选择点乘注意力是基于计算复杂度和实践效果的权衡。

📊 对比分析：

特性	点乘注意力	加法注意力
计算复杂度	O(n²d)	O(n²d²)
参数数量	较少	较多
并行性	易于并行化	较难并行化
实际效果	在多数任务上表现更好	理论灵活但计算成本高

对于d=512的情况，点乘注意力计算效率远高于加法注意力。

3.3 多头注意力（Multi-Head Attention）

3.3.1 多头注意力的设计思想

由于自注意力机制往往只能让一个词对其他词产生单一的关注和理解，但现实中的句子往往有多方面的语义信息。多头注意力的设计允许模型从不同角度关注不同信息。

🔄 工作流程：

1. 将输入拆分成h个头（h=8），拆成了8组N*64维的词向量组
2. 每个头独立进行自注意力计算
3. 将结果拼接起来合成N*512维的向量
4. 通过线性层融合
   

💡 答案：对每个头进行降维主要是为了在保持总计算量和参数数量基本不变的前提下，增加注意力机制的表示能力和多样性。
📊 数学分析：
假设：

• 输入维度：d_model = 512
• 头数：h = 8
• 每个头维度：d_k = d_v = 512/8 = 64
  参数数量对比：

1. 不降维（每个头512维）：

• 参数数量：3×8×512² = 6,291,456
• 计算量：8倍于单头注意力

2. 降维后（每个头64维）：

• 参数数量：3×512² = 786,432
• 计算量与单头注意力相当
  ✅ 优势：
• 以相同成本获得多个不同的注意力视角
• 每个头可以专注于不同类型的特征和关系
• 提高模型的表示能力和泛化能力

💡 答案：多个头可以"分工合作"，从不同角度分析关系。每个头可以关注不同类型的语法或语义关系，例如：

• 一个头关注主谓关系
• 一个头关注修饰关系
• 一个头关注指代关系
  通过多头机制，模型能够同时捕捉词与词之间的多种不同类型的关系，而不是仅限于一种模式。

在标准的Transformer中，多头注意力的计算过程如下：

• 对输入的查询(Q)、键(K)、值(V)分别进行h次不同的线性变换
• 在每个头上并行计算缩放点积注意力
• 将所有头的输出拼接起来
• 通过最后的线性变换得到最终输出

Multi-Head Attention 包含多个 Self-Attention 层，首先将输入X分别传递到 h 个不同的 Self-Attention 中，计算得到 h 个输出矩阵Z。

如图，Transformer将输入拆成8个10*64维的向量组
这8个组单独计算，得到8个输出矩阵Z1–Z8
得到 8 个输出矩阵 Z1 到 Z8 之后，Multi-Head Attention 将它们拼接在一起 (Concat)，然后传入一个Linear层，得到 Multi-Head Attention 最终的输出Z。

可以看到 Multi-Head Attention 输出的矩阵Z与其输入的矩阵X的维度是一样的。
上面就是多头自注意力机制，他是Transformer中最核心的模块，经过这个操作，一个句子中复杂的语义信息就被我们用向量的方式表示出来了

3.4 Add & Norm：残差连接和层归一化

3.4.1 残差连接（Add）

残差连接将层的输入直接加到输出上：

# 残差连接实现
def residual_connection(x, sublayer):
    """
    x: 输入
    sublayer: 子层函数（如多头注意力或前馈网络）
    """
    return x + sublayer(x)

公式表示：
$$\text{Output}=\text{LayerNorm}(x+\text{Sublayer}(x))$$

💡 答案：残差连接的主要意义在于缓解深度神经网络中的梯度消失问题。

简单说：如果某一层最优解是什么都不做，那么输出Y = F(X) = 0，导致梯度信息无法向后传播
因此在多头自注意力机制后面，Transformer加入和残差连接，这样可以有效防止梯度消失

🔧 工作原理：

1. 提供梯度直接传播的"高速通道"
2. 使网络可以学习残差映射，而不是完整的映射
3. 即使深层网络，梯度也能有效反向传播

3.4.2 层归一化（Norm）

层归一化对每一层的激活值进行标准化：
Norm指 Layer Normalization，通常用于 RNN 结构，Layer Normalization 会将每一层神经元的输入都转成均值方差都一样的，这样可以加快收敛。
如果每层输出的分布波动较大，容易导致梯度爆炸或梯度消失，影响模型的学习效率。而 Layer Normalization 可以在特征维度上对数据进行标准化，将均值调整为 0，方差调整为 1，让模型训练更稳定、更高效。

class LayerNorm(nn.Module):
    def __init__(self, features, eps=1e-6):
        super(LayerNorm, self).__init__()
        self.a_2 = nn.Parameter(torch.ones(features))
        self.b_2 = nn.Parameter(torch.zeros(features))
        self.eps = eps
        
    def forward(self, x):
        mean = x.mean(-1, keepdim=True)
        std = x.std(-1, keepdim=True)
        return self.a_2 * (x - mean) / (std + self.eps) + self.b_2

🎯 层归一化的作用：

1. 将每一层神经元的输入转成均值方差都一样的分布
2. 加快模型收敛速度
3. 提高训练稳定性

3.5 前馈神经网络（Feed Forward Network）

前馈神经网络对自注意力机制的输出进行非线性变换：
因为之前的计算无论多复杂，函数的输出结果本质上是线性的，只能表示一条直线
激活后可以拟合各种复杂的曲线

公式表示：
$$\text{FFN}(x)=\max (0,x{W}_1+b_1)W_2+b_2$$

💡 答案：原始Transformer使用ReLU作为激活函数。
🔧 ReLU函数：

• 公式：$\text{ReLU}(x)=\max (0,x)$
  ✅ 优点：
• 计算简单，速度快
• 在正区间缓解梯度消失
• 稀疏激活（约50%神经元被激活）
  ⚠️ 缺点：
• 负区间梯度为0（"Dead ReLU"问题）
• 输出不是零中心的

🔄 后续改进：

• BERT、GPT等模型采用GELU（高斯误差线性单元）
• GELU在正负区间都有梯度，表现更好

3.6 编码器的完整结构

通过上面描述的 Multi-Head Attention, Feed Forward, Add & Norm 就可以构造出一个 Encoder block，Encoder block 接收输入矩阵，并输出一个矩阵 。通过多个 Encoder block 叠加就可以组成 Encoder。
第一个 Encoder block 的输入为句子单词的表示向量矩阵，后续 Encoder block 的输入是前一个 Encoder block 的输出，最后一个 Encoder block 输出的矩阵就是编码信息矩阵X_out，这一矩阵后续会用到 Decoder 中。

🎯 编码器的作用：理解输入文本的语义信息，生成上下文感知的表示。

四、解码器（Decoder）部分

解码器结构与编码器相似，但存在重要区别：

4.1 解码器层结构

解码器每个层包含三个子层：

1. 掩蔽多头自注意力层（Masked Multi-Head Self-Attention）
2. 编码器-解码器注意力层（Encoder-Decoder Multi-Head Attention）
3. 前馈神经网络层（Feed Forward Network）

4.2 掩蔽多头自注意力（Masked Multi-Head Attention）

4.2.1 掩蔽的目的

在解码器中，为了保证自回归特性（只能看到当前和之前的token，不能看到未来的token），需要使用掩蔽操作。
Decoder block 的第一个 Multi-Head Attention 采用了 Masked 操作，因为在翻译的过程中是顺序翻译的，即翻译完第 i 个单词，才可以翻译第 i+1 个单词。通过 Masked 操作可以防止第 i 个单词知道 i+1 个单词之后的信息。

掩蔽矩阵示例：

序列长度 = 4
掩蔽矩阵（下三角矩阵）：
[[1, 0, 0, 0],
 [1, 1, 0, 0],
 [1, 1, 1, 0],
 [1, 1, 1, 1]]

💡 答案：Padding mask确保模型只关注序列中有意义的部分，忽略填充位置。
🔧 实现步骤：

1. 创建mask矩阵（1表示有效token，0表示padding）
2. 在softmax之前将padding位置的注意力分数设置为负无穷
3. softmax后这些位置的权重变为0

Decoder 可以在训练的过程中使用 Teacher Forcing 并且并行化训练，
即将正确的单词序列 ( I have a cat) 和对应输出 (I have a cat ) 传递到 Decoder。
那么在预测第 i 个输出时，就要将第 i+1 之后的单词掩盖住，注意 Mask 操作是在 Self-Attention 的 Softmax 之前使用的，下面用 0 1 2 3 4 5 分别表示 “ I have a cat ”。

第一步：
创建Mask矩阵
Decoder 的输入矩阵和 Mask 矩阵，输入矩阵包含 “ I have a cat” (0, 1, 2, 3, 4) 五个单词的表示向量，Mask 是一个 5×5 的矩阵。在 Mask 可以发现单词 0 只能使用单词 0 的信息，而单词 1 可以使用单词 0, 1 的信息，即只能使用之前的信息。

第二步：
计算 Q @ K.T
接下来的操作和之前的 Self-Attention 一样，通过输入矩阵X计算得到Q,K,V矩阵。

第三步：
将mask矩阵加到原始的注意力分数 S（masked）= S + M
我们在 Softmax 之前需要使用Mask矩阵遮挡住每一个单词之后的信息，遮挡操作如下：


Softmax操作
padding位置的softmax输出将为0

每一行的和都为 1。但是单词 0 在单词 1, 2, 3, 4 上的 attention score 都为 0。
第四步：
使用S(masked)与矩阵 V相乘，得到输出 Z，则单词 1 的输出向量Z1 是只包含单词 1 信息的。

通过上述步骤就可以得到一个 Mask Self-Attention 的输出矩阵Zi ，然后和 Encoder 类似，通过 Multi-Head Attention 拼接多个输出Zi，然后计算得到第一个 Multi-Head Attention 的输出Z，Z与输入X维度一样，我们这里称为A_mask。
为了保证训练和推理的一致性，每预测一个结果之后，和真实的单词比对，如果存在偏差，计算损失函数，再反向传播，根据误差结果调整模型参数、各种权重矩阵，直到学习好为止。

4.3 编码器-解码器注意力（交叉注意力）

4.3.1 交叉注意力的作用

交叉注意力允许解码器在生成每个目标词时，动态关注输入序列中最相关的部分。

🔗 输入来源：

• Q（查询）：来自解码器的上一层的输出
• K（键）和V（值）：来自编码器的最终输出，以此来参考整个Encoder的上下文信息

在多头交叉注意力层，经过掩码多头自注意力层计算得到的A_mask中每一个token和encoder输出向量X_out中的所有token，计算注意力权重，并加权求和
交叉注意力机制的目的：融合编码器理解到的语义信息，实现输入与输出之间的语义对齐。

💡 答案：Encoder和Decoder通过交叉注意力机制进行交互，这实现了类似传统Seq2Seq模型中注意力机制的功能。
🔄 交互过程：

1. 编码器处理输入序列，生成上下文表示
2. 解码器通过交叉注意力查询编码器的输出
3. 编码器的K和V作为交叉注意力的键值对
4. 解码器的Q作为查询，决定关注编码器输出的哪些部分

五、输出部分详解

输出部分包含两个核心层：

• 线性层
• softmax层
  
  N个Encoder计算出一个向量Y_out，也是512维
  接下来要将向量映射成真实的单词

5.1 线性层的作用

线性层是一个全连接层，通过对上一步的线性变化得到指定维度的输出，也就是转换维度的作用。
一个真实的单词来源于一个固定大小的词表Vocab，需要将512维的Y_out映射成Vocab_size的向量
我们通过一个线性变换实现：

公式表示：
$$\text{logits}=Y_{\text{out}}\times W+b$$

其中：

• $Y_{\text{out}}$：解码器输出的512维向量
• $W$：512×vocab_size的权重矩阵
• $b$：vocab_size的偏置向量
• $\text{logits}$：每个词汇的得分

🎯 核心任务：将512维的向量映射到词表大小（如30000维）的空间中。

5.2 Softmax层的作用

使最后一维的向量中的数字缩放到0-1的概率值域内，并满足它们的和为1。

# Softmax计算概率分布
probs = F.softmax(logits, dim=-1)

# 选择概率最大的词
predicted_token = torch.argmax(probs, dim=-1)

🔍 输出流程：

1. 对logits进行softmax归一化
2. 得到每个词汇的概率分布
3. 使用argmax选择概率最大的词汇
4. 循环生成直到遇到结束符

💡
答案：Transformer的并行化主要体现在Encoder端的自注意力机制和前馈网络，以及训练时Decoder的掩码自注意力机制。

✅ 可以并行化的部分：

1. Encoder完全并行：可以同时处理整个输入序列
2. 训练时Decoder：通过掩码防止信息泄露，可以并行处理目标序列
3. 注意力计算：矩阵乘法可以高度并行化

⚠️ 无法并行化的部分：

• 推理时Decoder：必须串行，因为需要依赖前面生成的token来预测下一个token
• 自回归生成：必须采用逐个生成的方式

🔧 并行化策略对比：

阶段	并行性	原因
Encoder处理	完全并行	输入序列已知，无依赖关系
Decoder训练	可以并行	使用掩码和Teacher Forcing
Decoder推理	串行	自回归生成，依赖前序输出

六、总结与展望

6.1 Transformer的核心创新

🚀 Transformer的三大创新：

1. 自注意力机制：完全替代RNN，解决长距离依赖问题
2. 位置编码：弥补注意力机制缺失的位置信息
3. 多头注意力：从多个角度捕捉不同类型的语义关系

6.2 实践建议

💡 使用Transformer的建议：

1. 选择合适的模型大小：根据任务复杂度和计算资源选择层数、头数和维度
2. 优化位置编码：对于特定任务，可考虑学习的位置编码
3. 注意训练技巧：使用适当的学习率调度、梯度裁剪等技术

6.3 未来发展方向

🔮 Transformer的演进：

1. 效率优化：如Linformer、Performer等降低计算复杂度的变体
2. 结构改进：如Transformer-XL解决长序列问题
3. 多模态融合：如Vision Transformer将注意力机制应用于图像领域

Transformer架构已经成为现代NLP的基石，其设计思想和实现细节值得深入理解和掌握。通过本文的详细解析，希望读者能够全面理解Transformer的每个组件及其工作原理。

---

📚 参考资料：

1. Vaswani, A., et al. (2017). Attention Is All You Need.
2. The Illustrated Transformer by Jay Alammar
3. Hugging Face Transformers Documentation

💬 欢迎讨论：
如果您对Transformer有任何疑问或想分享您的使用经验，欢迎在评论区留言交流！