【学习笔记】2.2 Encoder-Decoder

参考资料：https://github.com/datawhalechina/happy-llm 

在 Transformer 中，使用注意力机制的是其两个核心组件——Encoder（编码器）和 Decoder（解码器）。

2.2.1 Seq2Seq 模型

Seq2Seq（序列到序列） 是一种经典的自然语言处理（NLP）任务，其目标是将一个自然语言序列 映射到另一个可能不等长的自然语言序列 output = (y_1, y_2, y_3...y_m)。Seq2Seq 是 NLP 中最通用的任务形式，几乎所有 NLP 任务都可以视为 Seq2Seq 的特例，例如：

• 文本分类：输出长度为 1 的目标序列（m=1）。

• 词性标注：输出与输入序列等长的目标序列（m=n）。

• 机器翻译：输入和输出序列长度可能不同，例如将中文句子“今天天气真好”翻译为英文句子“Today is a good day.”。

Seq2Seq 的一般思路：

1. 编码（Encoding）：

   • 将输入的自然语言序列通过隐藏层编码成能够表征语义的向量（或矩阵），可以理解为更复杂的词向量表示。

2. 解码（Decoding）：

   • 将编码得到的向量或矩阵通过隐藏层输出，再解码成对应的自然语言目标序列。

Transformer 模型：

Transformer 是一个经典的 Seq2Seq 模型，最初被应用于机器翻译任务。它由 Encoder（编码器） 和 Decoder（解码器） 组成，具体结构如下：

• Encoder：

  • 包含多个（通常是 6 个）Encoder Layer。

  • 输入源序列进入 Encoder 进行编码，编码结果输出给 Decoder。

• Decoder：

  • 包含多个（通常是 6 个）Decoder Layer。

  • 接收 Encoder 的编码结果，并逐步解码生成目标序列。

Encoder 和 Decoder 内部传统神经网络的经典结构有：前馈神经网络（FNN）、层归一化（Layer Norm）和残差连接（Residual Connection）。

2.2.2 前馈神经网络

前馈神经网络（Feed Forward Neural Network，FFN） 是一种简单的全连接网络结构，用于对输入数据进行非线性变换。

FFN 的结构：

1. 两个线性层：

   • 输入经过第一个线性层（全连接层）进行变换。

   • 输出再经过第二个线性层进行进一步变换。

2. ReLU 激活函数：

   • 在两个线性层之间加入 ReLU 激活函数，引入非线性。

   • ReLU 激活函数的公式为：ReLU(x)=max(0,x)。

3. Dropout 层：

   • 在 FFN 的输出后加入 Dropout 层，用于防止过拟合。

   • Dropout 通过随机丢弃一部分神经元的输出，增强模型的泛化能力。

class MLP(nn.Module):'''前馈神经网络'''def __init__(self, dim: int, hidden_dim: int, dropout: float):super().__init__()# 定义第一层线性变换，从输入维度到隐藏维度self.w1 = nn.Linear(dim, hidden_dim, bias=False)# 定义第二层线性变换，从隐藏维度到输入维度self.w2 = nn.Linear(hidden_dim, dim, bias=False)# 定义dropout层，用于防止过拟合self.dropout = nn.Dropout(dropout)def forward(self, x):# 前向传播函数# 首先，输入x通过第一层线性变换和RELU激活函数# 然后，结果乘以输入x通过第三层线性变换的结果# 最后，通过第二层线性变换和dropout层return self.dropout(self.w2(F.relu(self.w1(x))))

2.2.3 层归一化

层归一化（Layer Norm） 是一种深度学习中的归一化操作，目的是让不同层的输入分布更加一致，从而稳定训练过程并提高模型性能。它与批归一化（Batch Norm）的主要区别在于统计量的计算方式。

归一化的必要性

1. 梯度爆炸/消失问题：

   • 深度神经网络中，每一层的输入是上一层的输出，随着层数增加，输入分布可能因参数变化而发生较大改变。

   • 这种分布变化会导致梯度不稳定，影响模型的收敛速度和性能。

2. 预测误差：

   • 预测的条件分布始终相同，但各层输出分布不同，导致预测误差增大。

批归一化（Batch Norm）的局限性

1. 小批量（mini-batch）问题：

   • 当 mini-batch 较小时，计算的均值和方差不能反映全局统计分布，导致效果变差。

2. 时间维度问题：

   • 对于 RNN，不同句子的同一时间步分布可能不同，Batch Norm 的归一化失去意义。

3. 训练与测试不一致：

   • 训练时需要保存每个 step 的统计信息，测试时可能出现比训练集更长的句子，导致统计量缺失。

4. 计算开销：

   • 每个 step 都需要保存和计算 batch 统计量，耗时且耗力。

代码实现：

class LayerNorm(nn.Module):''' Layer Norm 层'''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 = epsdef forward(self, x):# 在统计每个样本所有维度的值，求均值和方差mean = x.mean(-1, keepdim=True) # mean: [bsz, max_len, 1]std = x.std(-1, keepdim=True) # std: [bsz, max_len, 1]# 注意这里也在最后一个维度发生了广播return self.a_2 * (x - mean) / (std + self.eps) + self.b_2

2.2.4 残差连接

在 Transformer 模型中，残差连接被广泛应用于每个子层（如多头自注意力层和前馈神经网络层）。其主要作用是：

1. 避免梯度消失：允许梯度直接回传到更深层，减少梯度消失问题。

2. 增强信息流动：让高层专注于学习输入与输出之间的残差，而不是直接学习输出。

3. 提高训练效率：通过直接传递输入，减少深层网络的训练难度。

Transformer 中的实现

在 Transformer 的 Encoder 和 Decoder 中，每个子层的输出不仅包括上一层的输出，还包括上一层的输入。具体公式如下：

1. 多头自注意力层：

   

   • 输入 x 首先经过层归一化（LayerNorm）。

   • 然后通过多头自注意力层（MultiHeadSelfAttention）。

   • 最后将注意力层的输出与原始输入 x 相加，形成残差连接。

2. 前馈神经网络层：

   

   • 输入 x 首先经过层归一化（LayerNorm）。

   • 然后通过前馈神经网络（FNN）。

   • 最后将 FNN 的输出与原始输入 x 相加，形成残差连接。

代码实现

# 注意力计算
h = x + self.attention.forward(self.attention_norm(x))
# 经过前馈神经网络
out = h + self.feed_forward.forward(self.fnn_norm(h))

2.2.5 Encoder

Transformer 的 Encoder 是由多个 Encoder Layer 组成的模块，每个 Encoder Layer 包含两个主要部分：

1. 多头自注意力层（Multi-Head Attention）：

   • 用于捕捉输入序列内部的依赖关系。

2. 前馈神经网络（Feed Forward Network，FFN）：

   • 用于对自注意力层的输出进行非线性变换。

每个子层（多头自注意力层和前馈神经网络层）都使用 残差连接 和 层归一化（Layer Norm）。

Encoder Layer 的实现

class EncoderLayer(nn.Module):'''Encoder层'''def __init__(self, args):super().__init__()# 一个 Layer 中有两个 LayerNorm，分别在 Attention 之前和 MLP 之前self.attention_norm = LayerNorm(args.n_embd)# Encoder 不需要掩码，传入 is_causal=Falseself.attention = MultiHeadAttention(args, is_causal=False)self.fnn_norm = LayerNorm(args.n_embd)self.feed_forward = MLP(args)def forward(self, x):# Layer Normnorm_x = self.attention_norm(x)# 自注意力h = x + self.attention.forward(norm_x, norm_x, norm_x)# 经过前馈神经网络out = h + self.feed_forward.forward(self.fnn_norm(h))return out

• 输入：x 是输入序列的嵌入表示。

• 层归一化：在多头自注意力层和前馈神经网络之前分别应用层归一化。

• 残差连接：每个子层的输出加上原始输入，形成残差连接。

• 多头自注意力：self.attention 对归一化后的输入进行自注意力计算。

• 前馈神经网络：self.feed_forward 对归一化后的输入进行非线性变换。

Encoder 的实现

整个 Encoder 由多个 Encoder Layer 组成，并在最后加入一个 Layer Norm 实现规范化：

class Encoder(nn.Module):'''Encoder 块'''def __init__(self, args):super(Encoder, self).__init__() # 一个 Encoder 由 N 个 Encoder Layer 组成self.layers = nn.ModuleList([EncoderLayer(args) for _ in range(args.n_layer)])self.norm = LayerNorm(args.n_embd)def forward(self, x):"分别通过 N 层 Encoder Layer"for layer in self.layers:x = layer(x)return self.norm(x)

• 输入：x 是输入序列的嵌入表示。

• 多层 Encoder Layer：输入依次通过每个 Encoder Layer。

• 最终层归一化：在所有 Encoder Layer 之后，对输出进行一次层归一化。

输出

通过 Encoder 的输出是输入序列编码后的结果，可以用于后续的解码器（Decoder）或其他任务。

2.2.6 Decoder

Transformer 的 Decoder 由多个 Decoder Layer 组成，每个 Decoder Layer 包含三个主要部分：

1. 掩码自注意力层（Masked Multi-Head Attention）：

   • 使用掩码（Mask）确保每个 token 只能使用该 token 之前的注意力分数。

2. 多头注意力层（Multi-Head Attention）：

   • 使用 Encoder 的输出作为 Key 和 Value，当前 Decoder 的输出作为 Query，计算注意力分数。

3. 前馈神经网络（Feed Forward Network，FFN）：

   • 对多头注意力层的输出进行非线性变换。

每个子层（掩码自注意力层、多头注意力层和前馈神经网络层）都使用 残差连接 和 层归一化（Layer Norm）。

Decoder Layer 的实现

class DecoderLayer(nn.Module):'''解码层'''def __init__(self, args):super().__init__()# 一个 Layer 中有三个 LayerNorm，分别在 Mask Attention 之前、Self Attention 之前和 MLP 之前self.attention_norm_1 = LayerNorm(args.n_embd)# Decoder 的第一个部分是 Mask Attention，传入 is_causal=Trueself.mask_attention = MultiHeadAttention(args, is_causal=True)self.attention_norm_2 = LayerNorm(args.n_embd)# Decoder 的第二个部分是 类似于 Encoder 的 Attention，传入 is_causal=Falseself.attention = MultiHeadAttention(args, is_causal=False)self.ffn_norm = LayerNorm(args.n_embd)# 第三个部分是 MLPself.feed_forward = MLP(args)def forward(self, x, enc_out):# Layer Normnorm_x = self.attention_norm_1(x)# 掩码自注意力x = x + self.mask_attention.forward(norm_x, norm_x, norm_x)# 多头注意力norm_x = self.attention_norm_2(x)h = x + self.attention.forward(norm_x, enc_out, enc_out)# 经过前馈神经网络out = h + self.feed_forward.forward(self.fnn_norm(h))return out

• 输入：

  • x 是 Decoder 的输入序列的嵌入表示。

  • enc_out 是 Encoder 的输出。

• 多层 Decoder Layer：输入依次通过每个 Decoder Layer。

• 最终层归一化：在所有 Decoder Layer 之后，对输出进行一次层归一化。

完整的 Transformer 模型

将 Encoder 和 Decoder 拼接起来，再加入 Embedding 层，就可以搭建出完整的 Transformer 模型：

class Decoder(nn.Module):'''解码器'''def __init__(self, args):super(Decoder, self).__init__() # 一个 Decoder 由 N 个 Decoder Layer 组成self.layers = nn.ModuleList([DecoderLayer(args) for _ in range(args.n_layer)])self.norm = LayerNorm(args.n_embd)def forward(self, x, enc_out):"Pass the input (and mask) through each layer in turn."for layer in self.layers:x = layer(x, enc_out)return self.norm(x)