Transformer 架构细节分析1

1.Transformer总架构

Transformer 由四大部分组成：

1. 输入部分
2. 编码器部分
3. 解码器部分
4. 输出部分

1 输入部分

包含两组嵌入层与位置编码器：

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

Input Embedding和outputEmbedding

Input或ouput单条样本

在程序里常见的数据格式 如果一句话长度是 seq_len=4，那输入可以写成： [15, 982, 4310, 76] 形状一般是： (seq_len,)

Inputs或output一批样本

如果一次输入多句话，要补齐到同样长度： [ [15, 982, 4310, 76, pad, pad], [87, 25, 901, 333, 18, 7] ]

这里 往往是 padding。意思是padding mask

要用 padding mask

如果一个 batch 里句子长短不一样，通常会补齐到同一长度：

• 句子1：10 个 token
• 句子2：6 个 token + 4 个 PAD

这时候就要用padding mask，让模型不要去关注那些补出来的 PAD 位置。

形状一般是： (batch_size, seq_len)

在上述图中Inputs和output

因为 Transformer 本身不能直接处理 “15、982、4310” 这种离散编号，它需要先把每个 token ID 查表变成一个稠密向量。

15 -> [0.12, -0.33, 0.91, ...] 982 -> [0.44, 0.07, -0.12, ...]

这一步就是Input Embedding。

其中d_model是每个 token 向量的维度

转换后张量形状会变成：

(batch_size, seq_len, d_model)

Positional Encoding

Positional Encoding 的数据格式本质上是一个浮点数矩阵，用来给每个位置提供位置信息。

Transformer 中除了单词的 Embedding，还需要使用位置 Embedding 表示单词出现在句子中的位置。因为 Transformer 不采用 RNN 的结构，而是使用全局信息，不能利用单词的顺序信息，而这部分信息对于 NLP 来说非常重要。所以 Transformer 中使用位置 Embedding 保存单词在序列中的相对或绝对位置。

基本形状

PositionalEncoding.shape = (seq_len, d_model)

和 Embedding 的格式要一致:因为它要和 input embedding 直接相加，所以两者形状要匹配。

Input Embedding形状 (batch_size, seq_len, d_model) Positional Encoding形状 (seq_len, d_model) 为了方便 batch 计算： (1, seq_len, d_model) 然后通过广播机制加到每个样本上： x = embedding + positional_encoding

目的:

1. 每个位置都能得到一个不同的向量:

不同的pos会对应不同的sin/cos值，所以：

• 位置 0 的向量不同于位置 1
• 位置 1 不同于位置 2
• …

这样模型就能区分“第几个位置”。

2. 不同维度用不同频率:

公式里这部分：

让不同维度的波动快慢不同。

效果是：

• 有些维度变化很快
• 有些维度变化很慢

这就像用很多不同刻度的尺子一起测位置。
组合起来后，模型更容易区分远近不同的位置。

3. 模型更容易学习“相对位置”

pos 位置

pos = torch.arange(0, max_len).unsqueeze(1) 例子 tensor([0, 1, 2, 3, 4]) # shape = (5,) tensor([ [0], [1], [2], [3], [4] ]) # shape = (5, 1)

为什么要变成(max_len, 1):

因为后面要和 div_term 相乘：pos * div_term pos.shape = (max_len, 1) div_term.shape = (d_model/2,) pos.shape = (1000, 1) div_term.shape = (256,) yTorch 会自动广播，得到： (max_len, d_model/2)

i 是频率通道编号: 对应的是维度组

i=0,表示第0维,第一维 i=1,表示第二维,第三维 ....

倒数代码表示:

div_term = torch.exp(np.log(10000)*(-torch.arange(0,d_model,2)/d_model))

嵌入层代码

#1.定义模型类，实现词嵌入层 class MyEmbedding(nn.Module): """ 输入： x: 词索引ID， source,源序列文本,(batch_size, src_seq_len)；或者 target,目标序列文本,(batch_size, tgt_seq_len) 输出: x: 词向量，(batch_size, seq_len, d_model) """ # 1.定义__init_方法，初始化词嵌入层 def __init__(self, vocab_size, d_model=512): super().__init__() # 1.初始化参数 self.vocab_size = vocab_size self.d_model = d_model # 2.初始化词嵌入层 self.embedding = nn.Embedding(vocab_size, d_model) # 2.定义forward方法，前向传播 def forward(self, x): # 输入x: 词索引ID，(batch_size, seq_len) # 1.经过词嵌入层 x = self.embedding(x) # 2.经过缩放，* sqrt(d_model) return x*self.d_model**0.5

为什么乘sqrt(d_model)

return x * self.d_model ** 0.5

原因可以简单理解成：

• embedding 的数值规模可能比较小
• 后面要和 positional encoding 相加
• 乘上sqrt(d_model)后，词向量的量级更合适

测试词嵌入层

def test_MyEmbedding(): # 1.定义参数 vocab_size = 2000 d_model = 512 batch_size = 2 seq_len = 10 # 2.创建模型对象 embedding = MyEmbedding(vocab_size, d_model) # 3.准备输入数据 # 模拟词索引ID, (batch_size, seq_len) x = torch.randint(0, vocab_size, (batch_size, seq_len)) print(f"输入词索引x.shape: {x.shape}") # (2, 10) # 4.前向传播，输入词嵌入层 x = embedding(x) # (2, 10, 512) print(f"输出词向量x.shape: {x.shape}")

# 3.定义模型类，实现位置编码 - 要求手敲 class MyPositionalEncoding(nn.Module): """ 输入: x: 词向量，(batch_size, seq_len, d_model) 输出: x: 添加位置编码后的词向量，(batch_size, seq_len, d_model) """ # 1.定义__init_方法 def __init__(self, d_model=512, dropout=0.1, max_len=1000): super().__init__() # 1.初始化参数 self.d_model = d_model self.max_len = max_len if dropout is not None: self.dropout = nn.Dropout(dropout) else: self.dropout = nn.Identity() # 没有激活函数，y=x # 2.定义位置编码, (max_len, d_model) pe = torch.zeros(max_len, d_model) # 3.定义位置编码的索引序列pos, 0~max_len-1 # (max_len, 1) pos = torch.arange(0, max_len).unsqueeze(1) # 4.定义参数，记录10000^(2i/d_model) # a^n = exp(ln(a)*n) # 10000^(-2i/d_model) = exp(ln(10000)*(-2i/d_model)) div_term = torch.exp(np.log(10000)*(-torch.arange(0,d_model,2)/d_model)) # 5.计算位置编码 pe[:,0::2] = torch.sin(pos*div_term) pe[:,1::2] = torch.cos(pos*div_term) # 6.把位置编码升维：2D -> 3D, (max_len, d_model) -> (1, max_len, d_model) pe = pe.unsqueeze(0) # 7.注册位置编码为buffer, pe不参与训练，但会保存到模型文件中 # 等价于self.pe = pe，并且实现了保存模型参数时一起保存pe self.register_buffer('pe', pe) # 2.定义forward方法，前向传播 def forward(self, x): # x: 词向量，(batch_size, seq_len, d_model) # 1.把位置编码添加到词向量中 # (batch_size, seq_len, d_model) + (1, seq_len, d_model) x = x + self.pe[:,:x.size(1),:] # 2.添加dropout return self.dropout(x)

测试MyPositionalEncoding

def test_MyPositionalEncoding(): # 1.定义参数 vocab_size = 2000 d_model = 512 batch_size = 2 seq_len = 10 # 2.创建模型对象 pos_encoding = MyPositionalEncoding(d_model) # 3.创建输入数据 x = torch.randn(batch_size, seq_len, d_model) print(f"输入词向量x.shape: {x.shape}") # 4.前向传播，添加位置编码信息 x = pos_encoding(x) # (2, 10, 512) print(f"添加位置编码的词向量x.shape: {x.shape}")

可视化位置编码pe

def show_pe(): # 0.定义参数 d_model = 16 max_len = 1000 seq_len = 100 batch_size = 4 # 1.创建位置编码层 pos_enc = MyPositionalEncoding( d_model=d_model, dropout=0, max_len=max_len ) # 2.创建全零张量，模拟输入词向量，(batch_size,seq_len,d_model) x = torch.zeros(batch_size, seq_len, d_model) # 3.输入位置编码层 y = pos_enc(x) # 4.绘制位置编码曲线 plt.figure(figsize=(12, 6)) embed_range = np.arange(5,8) plt.plot(np.arange(seq_len), y[0,:,embed_range].detach()) plt.legend(["d_model="+str(i) for i in embed_range]) plt.show()

这里的图像周期随着i的增加而不断变大,以下是周期公式

2 编码器部分

• 由N 个编码器层堆叠而成
• 每层包含2 个子层连接结构：
  1. 多头自注意力+ AddNorm(残差连接 + LayerNorm)
  2. 前馈网络+ AddNorm(残差连接 + LayerNorm)

红色圈中的部分为Multi-Head Attention，是由多个Self-Attention组成的，可以看到 Encoder block 包含一个 Multi-Head Attention,Multi-Head Attention 上方还包括一个 Add & Norm 层，Add 表示残差连接 (Residual Connection) 用于防止网络退化，Norm 表示 Layer Normalization，用于对每一层的激活值进行归一化。

Self-Attention 结构

上图是 Self-Attention 的结构，在计算的时候需要用到矩阵Q(查询),K(键值),V(值)。在实际中，Self-Attention 接收的是输入(单词的表示向量x组成的矩阵X) 或者上一个 Encoder block 的输出。而Q,K,V正是通过 Self-Attention 的输入进行线性变换得到的。

Self-Attention 的输出

得到矩阵 Q, K, V之后就可以计算出 Self-Attention 的输出了，计算的公式如下：

公式中计算矩阵Q和K每一行向量的内积，为了防止内积过大，因此除以 dk 的平方根。Q乘以K的转置后，得到的矩阵行列数都为 n，n 为句子单词数，这个矩阵可以表示单词之间的 attention 强度。下图为Q乘以 KT ，1234 表示的是句子中的单词。

得到QKT 之后，使用 Softmax 计算每一个单词对于其他单词的 attention 系数，公式中的 Softmax 是对矩阵的每一行进行 Softmax，即每一行的和都变为 1.

得到 Softmax 矩阵之后可以和V相乘，得到最终的输出Z。

上图中 Softmax 矩阵的第 1 行表示单词 1 与其他所有单词的 attention 系数，最终单词 1 的输出 Z1 等于所有单词 i 的值 Vi 根据 attention 系数的比例加在一起得到，如下图所示：

Multi-Head Attention

在上一步，我们已经知道怎么通过 Self-Attention 计算得到输出矩阵 Z，而多头注意力机制，就是将Q,K,V的特征维度拆分为多个头，然后分别计算注意力，然后合并，最后经过线性变换得到输出。比如特征维度为512，拆分为8个头，每个头维度为64，分别计算注意力，然后合并，经过线性变换，得到最终的输出。

从上图可以看到 Multi-Head Attention 包含多个 Self-Attention 层，首先将输入X分别传递到 h 个不同的 Self-Attention 中，计算得到 h 个输出矩阵Z。下图是 h=8 时候的情况，此时会得到 8 个输出矩阵Z。

得到 8 个输出矩阵 Z1 到 Z8 之后，Multi-Head Attention 将它们拼接在一起(Concat)，然后传入一个Linear层，得到 Multi-Head Attention 最终的输出Z。

Multi-Head Attention的作用

如果只有一个注意力头：

• 所有信息只能在一个注意力空间中建模
• 容易只关注某一类关系（比如局部或全局）

多头注意力可以：

• 同时关注不同类型的关系
• 提高模型的表达能力和稳定性
• 保持计算并行（GPU 友好）

Multi-Head Attention的计算过程

Add & Norm

Add & Norm 层由 Add 和 Norm 两部分组成，其计算公式如下：

其中X表示 Multi-Head Attention 或者 Feed Forward 的输入，MultiHeadAttention(X) 和 FeedForward(X) 表示输出 (输出与输入X维度是一样的，所以可以相加)

Add指X+MultiHeadAttention(X)，是一种残差连接，通常用于解决多层网络训练的问题，可以让网络只关注当前差异的部分，在 ResNet 中经常用到

这里：

• x 是输入
• F(x) 是网络这一层学到的变换
• y 是最后输出

为什么残差连接很重要

它主要解决深层网络训练困难的问题，比如：

• 网络很深时，信息容易在传递中变弱
• 梯度反向传播时容易消失
• 深层模型反而可能比浅层更难训练

残差连接能让：

• 信息更容易直接传下去
• 梯度更容易往回传
• 深网络更稳定、更容易训练

残差连接就是把输入直接加到层输出上，让网络只学习“需要改多少”，从而更容易训练深层模型。

Norm指 Layer Normalization(层归一化)，通常用于 RNN 结构，Layer Normalization 会将每一层神经元的输入都转成均值方差都一样的，这样可以加快收敛。

它像是给每一层的输出“校准一下尺度”。

因为神经网络里，不同层输出的数值范围可能忽大忽小。
如果范围太乱，后面的层就会学得很吃力。

LayerNorm 做的事就是：

先把数值拉回一个比较稳定的区间，再交给下一步处理。

总结:

• 残差连接：保留原信息
• LayerNorm：把数值尺度整理好

数据在Multi-Head Attention和Add & Norm的流通格式

Multi-Head Attention

以上的T是seq_len

Add & Norm

以上的T是seq_len

Feedforward 前反馈层:

Feed Forward 层比较简单，是一个两层的全连接层，第一层的激活函数为 Relu，第二层不使用激活函数，对应的公式如下。

X是输入，Feed Forward 最终得到的输出矩阵的维度与X一致。

它到底干了些什么:

让这个词把“看完别人后拿到的信息”，自己再加工一遍,把自己内部表示往"想要""那个方向调强一点，
把""不想要""那个方向压弱一点。

为什么每个位置都单独做:

因为每个 token 在经过 Attention 后，都已经拿到了属于自己的上下文信息。

所以接下来就轮到它自己加工自己。

也就是说：

• 第1个 token 自己处理
• 第2个 token 自己处理
• 第3个 token 自己处理

彼此不交流
因为交流已经在 Attention 那一步做过了。

数据格式:

(batch_size, seq_len, d_model) → (batch_size, seq_len, d_ff) → (batch_size, seq_len, d_model)

由于要保持原数据和数据趋于稳定,所以还要经过add&norm层的操作

3.组成 Encoder

通过上面描述的 Multi-Head Attention, Feed Forward, Add & Norm 就可以构造出一个 Encoder block，Encoder block 接收输入矩阵 X(n×d) ，并输出一个矩阵 O(n×d) 。通过多个 Encoder block 叠加就可以组成 Encoder。

第一个 Encoder block 的输入为句子单词的表示向量矩阵，后续 Encoder block 的输入是前一个 Encoder block 的输出，最后一个 Encoder block 输出的矩阵就是编码信息矩阵 C，这一矩阵后续会用到 Decoder 中。

代码暂时没有

4.掩码(mask)

Mask 是什么:

Mask 用来在注意力计算中“遮掉”不该被看的位置信息——它决定某个 Query 是否可以关注某个 Key（作用在注意力分数上，而不是直接去掉输入 token）。

本质与实现:

• 本质：屏蔽注意力分数（QK^T），通常用 0/1 或布尔矩阵表示。
• 如何实现：在 softmax 前把被屏蔽的位置填入大负值（如 -1e9 或 -inf），使其概率接近 0

Padding mask的作用是，在 Transformer 处理一批长度不同的序列时，把后面为了对齐长度而补上的PAD位置屏蔽掉，避免模型在计算注意力时把这些没有实际意义的补位当成真实内容去关注；这样模型只会把注意力分配给真正的 token，从而减少无效信息干扰，提高计算结果的准确性。在上文已有所应用

Causal mask的作用是，在 Transformer 的解码过程中屏蔽当前位置后面的 token，让模型在预测当前词时只能看到自己和前面的内容，不能提前看到后面的正确答案；这样可以防止训练时“偷看未来”，保证生成过程符合从左到右逐步预测的规则。

模拟代码实现

1.定义函数，生成填充掩码张量padding_mask: (batch_size, seq_len)

# 导包 import torch import numpy as np import matplotlib.pyplot as plt # 设置中文字体 plt.rcParams['font.sans-serif'] = ['SimHei'] plt.rcParams['axes.unicode_minus'] = False # 1.定义函数，生成填充掩码张量padding_mask: (batch_size, seq_len) def demo01(): # 0.设置随机种子 torch.manual_seed(4) # 1.定义参数 batch_size = 6 seq_len = 10 # 2.初始化填充掩码张量为全1张量 # padding_mask: (batch_size, seq_len) padding_mask = torch.ones(batch_size, seq_len, dtype=torch.bool) # print(padding_mask) # 3.随机生成填充掩码的有效长度，有效长度内都设置为False lens = torch.randint(5,seq_len+1,(batch_size,)) # for循环来实现有效长度内的填充掩码都设置为False,padding_mask[i,:lens[i]]=False for i in range(batch_size): padding_mask[i, :lens[i]] = False # print(padding_mask) # 4.可视化掩码矩阵 plt.matshow(padding_mask) plt.title("填充掩码矩阵") plt.show()

2.定义函数，生成因果掩码张量causal_mask: (tgt_seq_len, tgt_seq_len)

def demo02(): # 1.定义参数 seq_len = 10 # 2.创建因果掩码张量(seq_len,seq_len) causal_mask = torch.triu(torch.ones(seq_len, seq_len), diagonal=1).to(dtype=torch.bool) # print(torch.ones(seq_len, seq_len)) # print(causal_mask) # 3.可视化因果掩码矩阵 plt.matshow(causal_mask) plt.title("因果掩码矩阵") plt.show()

3.定义函数，演示masked_fill实现将掩码张量的True替换为-1e9

def demo03(): # 1.创建张量，模拟注意力分数scores = QK^T/sqrt(d_k), (batch_size, tgt_seq_len, src_seq_len) seq_len = 10 batch_size = 2 scores = torch.randn(batch_size, seq_len, seq_len) print(f"原始注意力分数scores:{scores.shape}") # 2.创建掩码张量，因果掩码：(seq_len, seq_len) causal_mask = torch.triu(torch.ones(seq_len, seq_len), diagonal=1).to(dtype=torch.bool) # 3.使用masked_fill函数把掩码张量的True替换为-1e9 scores_masked = torch.masked_fill(scores, causal_mask==True, -1e9) print(f"替换后的注意力分数scores:{scores.shape}") # 4.可视化注意力分数矩阵热力图 plt.matshow(scores[0]) plt.title("无掩码的注意力分数矩阵") plt.colorbar() plt.show() plt.matshow(scores_masked[0]) plt.title("带掩码的注意力分数矩阵") plt.colorbar() plt.show() # 5.可视化注意力权重矩阵热力图 attention_weights = torch.softmax(scores, dim=-1) plt.matshow(attention_weights[0]) plt.title("无掩码注意力权重矩阵") plt.colorbar() plt.show() attention_weights_masked = torch.softmax(scores_masked, dim=-1) plt.matshow(attention_weights_masked[0]) plt.title("带掩码的注意力权重矩阵") plt.colorbar() plt.show()

5.解码器部分

解码器部分:

• 由N个解码器层堆叠而成
• 每个解码器层由三个子层连接结构组成
  • 一个多头自注意力层 + 层归一化&残差连接
  • 一个多头注意力层 + 层归一化&残差连接
  • 一个前馈网络层 + 层归一化&残差连接
• 注意：主流工程实现，通常在N个解码器层之后，添加一个LayerNorm层