Transformer 大语言模型（LLM）基石 - Transformer架构详解 - 编码器（Encoder）详解以及算法实现

锋哥原创的Transformer 大语言模型（LLM）基石视频教程：

https://www.bilibili.com/video/BV1X92pBqEhV

课程介绍

本课程主要讲解Transformer简介，Transformer架构介绍，Transformer架构详解，包括输入层，位置编码，多头注意力机制，前馈神经网络，编码器层，解码器层，输出层，以及Transformer Pytorch2内置实现，Transformer基于PyTorch2手写实现等知识。

Transformer 大语言模型（LLM）基石 - Transformer架构详解 - 编码器（Encoder）详解以及算法实现

编码器结构：

多头自注意力 (MHA)：每个位置对整句做"信息汇聚"。
前馈网络 (FFN)：逐位置的两层 MLP（常用维度 d_ff=4×d_model）。
残差连接 + LayerNorm：稳定训练、加速收敛。

代码实现：

复制代码

# 编码器层
class EncoderLayer(nn.Module):

    def __init__(self, d_model, self_attention, d_ff, dropout=0.1):
        super().__init__()
        self.d_model = d_model
        self.self_attention = self_attention  # 多头自注意力机制
        self.feed_forward = d_ff  # 前馈神经网络
        self.residual_connection1 = ResidualConnection(d_model, dropout)  # 残差连接
        self.residual_connection2 = ResidualConnection(d_model, dropout)  # 残差连接

    def forward(self, x):
        """
           前向传播
           参数:
               x: 输入张量 [batch_size, seq_len, d_model]
               mask: 掩码张量 [batch_size, seq_len, seq_len]
           返回:
               编码器层的输出张量
           """
        # 多头自注意力机制
        x1 = self.residual_connection1(x, lambda x: self.self_attention(x, x, x))  # 多头自注意力机制
        x2 = self.residual_connection2(x1, lambda x: self.feed_forward(x))  # 前馈神经网络
        return x2


# 编码器 （由多个编码器层堆叠）
class Encoder(nn.Module):

    def __init__(self, num_layers, layer):
        super().__init__()
        self.layers = nn.ModuleList([copy.deepcopy(layer) for _ in range(num_layers)])
        self.norm = LayerNorm(layer.d_model)

    def forward(self, x):
        """
           前向传播
           输入:
               x: 输入张量 [batch_size, seq_len, d_model]
           返回:
               编码器的输出张量 [batch_size, seq_len, d_model]
           """
        for layer in self.layers:
            x = layer(x)
        return self.norm(x)


# 测试编码器
def test_encoder():
    vocab_size = 2000  # 词表大小
    embedding_dim = 512  # 词嵌入维度大小
    embeddings = Embeddings(vocab_size, embedding_dim)
    embed_result = embeddings(torch.tensor([[1999, 2, 99, 4, 5], [66, 2, 3, 22, 5], [66, 2, 3, 4, 5]]))
    positional_encoding = PositionalEncoding(embedding_dim)
    positional_result = positional_encoding(embed_result)
    mha = MultiHeadAttention(d_model=512, num_heads=8)  # 多头自注意力机制
    ffn = FeedForward(d_model=512, d_ff=2048)  # 前馈神经网络
    encoder_layer = EncoderLayer(d_model=512, self_attention=mha, d_ff=ffn)  # 编码器层
    # 实例化编码器对象
    encoder = Encoder(num_layers=6, layer=encoder_layer)
    encoder_result = encoder(positional_result)
    print('encoder_result.shape:', encoder_result.shape)


if __name__ == '__main__':
    test_encoder()

运行测试：