Part9.第15章：Transformer(下)

整体架构

左半部分是编码器Encoder部分，右边部分是解码器Decoder部分。

编码器

全连接模块实现

class FeedForwardBlock(nn.Module):

    def __init__(self, d_model: int, d_ff: int, dropout: float) -> None:
        super().__init__()
        self.linear_1 = nn.Linear(d_model, d_ff)
        self.dropout = nn.Dropout(dropout)
        self.linear_2 = nn.Linear(d_ff, d_model)

    def forward(self, x):
        # (batch, seq_len, d_model) --> (batch, seq_len, d_ff) --> (batch, seq_len, d_model)
        return self.linear_2(self.dropout(torch.relu(self.linear_1(x))))

全连接模块里定义了两个层，第一个层将每个token embedding的维度从512扩展到2048，然后应用了ReLU激活，接着进行dropout。第二层将每个token embedding的维度从2048重新降维到512。
整个前馈网络可以表示为：
$FFN(x)=W_2⋅Dropout(ReLU(W_1⋅x+b_1))+b_2$

• 维度扩展-压缩模式
  d_model → d_ff → d_model
  先升维（增加表达能力）
  再降维（保持维度一致）

• 位置独立性
  对序列中的每个位置独立应用相同的前馈网络
  每个token的处理不依赖其他位置

Add & Norm 模块实现

class ResidualConnection(nn.Module):

    def __init__(self, features: int, dropout: float) -> None:
        super().__init__()
        self.dropout = nn.Dropout(dropout)
        self.norm = LayerNormalization(features)

    def forward(self, x, sublayer):
        return x + self.dropout(sublayer(self.norm(x)))

• 参数
  features: 特征维度，通常是 d_model
  dropout: dropout概率
• self.dropout = nn.Dropout(dropout)
  用于对子层输出进行正则化
• self.norm = LayerNormalization(features)
  归一化在残差连接中起到稳定训练的作用
• def forward(self, x, sublayer)
  x: 输入张量
  sublayer: 一个子层函数（如自注意力或前馈网络）

整个残差连接可以表示为：
$ResidualConnection(x)=x+Dropout(Sublayer(LayerNorm(x)))$

设计特点

1. 计算顺序：Pre-LN 架构

# Pre-LN: LayerNorm在子层之前
x → LayerNorm → Sublayer → Dropout → + x
# 对比 Post-LN: LayerNorm在残差连接之后
x → Sublayer → Dropout → + x → LayerNorm

Pre-LN（这里实现的）通常训练更稳定
Post-LN 是原始Transformer论文中的设计

2. 残差连接的重要性

残差连接的核心思想
output = input + transformation(input)

• 解决梯度消失: 梯度可以直接通过加法路径反向传播
• 恒等映射: 当子层学习效果不好时，网络可以退化为恒等映射
• 信息保留: 原始信息得到保留，新信息在残差上学习

3. Dropout的位置
   在残差连接之前应用dropout
   防止子层输出过拟合

完整代码

class EncoderBlock(nn.Module):

    def __init__(self, features: int, self_attention_block: MultiHeadAttentionBlock,
                 feed_forward_block: FeedForwardBlock, dropout: float) -> None:
        super().__init__()
        # 定义多头自注意力模块
        self.self_attention_block = self_attention_block
        # 定义全连接模块
        self.feed_forward_block = feed_forward_block
        # 定义两个Add & Norm模块
        self.residual_connections = nn.ModuleList([ResidualConnection(features, dropout) for _ in range(2)])

    def forward(self, x, src_mask):
        # 第一个残差连接，跳过多头注意力模块
        x = self.residual_connections[0](x, lambda x: self.self_attention_block(x, x, x, src_mask))
        # 第二个残差连接，跳过全连接模块
        x = self.residual_connections[1](x, self.feed_forward_block)
        return x


class Encoder(nn.Module):

    def __init__(self, features: int, layers: nn.ModuleList) -> None:
        super().__init__()
        # 传入的6个EncoderBlock
        self.layers = layers
        self.norm = LayerNormalization(features)

    def forward(self, x, mask):
        # 依次调用6个EncoderBlock
        for layer in self.layers:
            x = layer(x, mask)
        # 输出前进行Layer Norm
        return self.norm(x)