【学习笔记】2.2 Encoder-Decoder

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

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

2.2.1 Seq2Seq 模型

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

文本分类：输出长度为 1 的目标序列（m=1）。
词性标注：输出与输入序列等长的目标序列（m=n）。
机器翻译：输入和输出序列长度可能不同，例如将中文句子“今天天气真好”翻译为英文句子“Today is a good day.”。

Seq2Seq 的一般思路：

编码（Encoding）：
- 将输入的自然语言序列通过隐藏层编码成能够表征语义的向量（或矩阵），可以理解为更复杂的词向量表示。
解码（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 的结构：

两个线性层：
- 输入经过第一个线性层（全连接层）进行变换。
- 输出再经过第二个线性层进行进一步变换。
ReLU 激活函数：
- 在两个线性层之间加入 ReLU 激活函数，引入非线性。
- ReLU 激活函数的公式为：ReLU(x)=max(0,x)。
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）的主要区别在于统计量的计算方式。

归一化的必要性

梯度爆炸/消失问题：
- 深度神经网络中，每一层的输入是上一层的输出，随着层数增加，输入分布可能因参数变化而发生较大改变。
- 这种分布变化会导致梯度不稳定，影响模型的收敛速度和性能。
预测误差：
- 预测的条件分布始终相同，但各层输出分布不同，导致预测误差增大。

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

小批量（mini-batch）问题：
- 当 mini-batch 较小时，计算的均值和方差不能反映全局统计分布，导致效果变差。
时间维度问题：
- 对于 RNN，不同句子的同一时间步分布可能不同，Batch Norm 的归一化失去意义。
训练与测试不一致：
- 训练时需要保存每个 step 的统计信息，测试时可能出现比训练集更长的句子，导致统计量缺失。
计算开销：
- 每个 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 模型中，残差连接被广泛应用于每个子层（如多头自注意力层和前馈神经网络层）。其主要作用是：

避免梯度消失：允许梯度直接回传到更深层，减少梯度消失问题。
增强信息流动：让高层专注于学习输入与输出之间的残差，而不是直接学习输出。
提高训练效率：通过直接传递输入，减少深层网络的训练难度。

Transformer 中的实现

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

多头自注意力层：
- 输入 x 首先经过层归一化（LayerNorm）。
- 然后通过多头自注意力层（MultiHeadSelfAttention）。
- 最后将注意力层的输出与原始输入 x 相加，形成残差连接。
前馈神经网络层：
- 输入 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 包含两个主要部分：

多头自注意力层（Multi-Head Attention）：
- 用于捕捉输入序列内部的依赖关系。
前馈神经网络（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 包含三个主要部分：

掩码自注意力层（Masked Multi-Head Attention）：
- 使用掩码（Mask）确保每个 token 只能使用该 token 之前的注意力分数。
多头注意力层（Multi-Head Attention）：
- 使用 Encoder 的输出作为 Key 和 Value，当前 Decoder 的输出作为 Query，计算注意力分数。
前馈神经网络（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)