一文读懂Transformer架构中的编码器

最新推荐文章于 2025-03-14 10:57:44 发布

AI Agent开发

最新推荐文章于 2025-03-14 10:57:44 发布

阅读量1.6k

点赞数 29

文章标签： transformer 深度学习人工智能大模型 AI大模型 LLM ai

本文链接：https://blog.csdn.net/m0_56255097/article/details/144593726

版权

Transformer架构是由Vaswani等人在2017年提出的一种神经网络架构，主要用于自然语言处理任务。它的核心组成部分是编码器（Encoder）和解码器（Decoder），本篇将为各位同学介绍一下如何创建Transformer中的编码器（Encoder）。

一、如何理解编码器（Encoder）

Transformer架构中的编码器（Encoder）是模型的核心组成部分之一，主要用于处理输入序列并将其编码为连续的向量表示。我们可以从以下几方面去理解编码器：

1. 结构概述

Transformer编码器由多个相同的层叠加而成，每一层主要由两个子层组成：

多头自注意力机制（Multi-Head Self-Attention）
前馈神经网络（Feed-Forward Neural Network）

每个子层后面都有一个残差连接（Residual Connection）和层归一化（Layer Normalization）。

2. 多头自注意力机制

自注意力机制允许模型在处理输入时关注到序列中不同位置的信息。在多头自注意力机制中，输入向量首先被线性变换为查询（Query）、键（Key）和值（Value）三部分。步骤如下：

(1) 线性变换：对于输入序列中的每个词，生成对应的查询、键和值向量。

(2) 计算注意力权重：通过对查询向量与所有键向量进行点积，计算出注意力权重。然后通过Softmax函数将这些权重归一化。

(3) 加权求和：将得到的权重与对应的值向量进行加权求和，得到每个词的新的表示。

(4) 多头机制：上述过程会并行进行多个头（h），每个头都有独立的参数，最后将所有头的输出拼接在一起，经过线性变换得到最终的输出。

3. 前馈神经网络

每个自注意力层后面是一个前馈神经网络，该网络对每一个位置的输出进行独立的非线性变换。通常由两个线性变换和一个ReLU激活函数组成。

4. 残差连接与层归一化

在每个子层（自注意力和前馈网络）之后，都会添加残差连接，意味着子层的输入将与输出相加。这有助于缓解深度网络中的梯度消失问题。接下来是层归一化，确保每一层的输出在训练过程中保持稳定。

5. 位置编码

由于Transformer不使用递归或卷积结构，因此需要位置编码（Positional Encoding）来提供序列中词的位置信息。位置编码与输入嵌入相加，让模型理解词的顺序。

Transformer编码器通过自注意力机制有效地捕捉输入序列中词之间的关系，结合前馈神经网络、残差连接和层归一化，构成了功能强大的特征提取模块。这种架构不仅在自然语言处理领域取得了优异的表现，还被广泛应用于其他任务，如图像处理和生成模型等。

二、构建编码器（Encoder）

下面是一个使用 PyTorch 构建 Transformer 编码器的完整代码示例，各位同学在各种应用中构建编码器时可以参考以下方法：

import torch
import torch.nn as nn
import torch.nn.functional as F
# 定义多头自注意力机制
class MultiHeadAttention(nn.Module):
    def __init__(self, embed_size, heads):
        super(MultiHeadAttention, self).__init__()
        self.embed_size = embed_size
        self.heads = heads
        self.head_dim = embed_size // heads
        assert (
            self.head_dim * heads == embed_size
        ), "嵌入尺寸必须能被头数整除"
        self.values = nn.Linear(embed_size, embed_size, bias=False)
        self.keys = nn.Linear(embed_size, embed_size, bias=False)
        self.queries = nn.Linear(embed_size, embed_size, bias=False)
        self.fc_out = nn.Linear(embed_size, embed_size)
    def forward(self, x):
        N = x.shape[0]  # 批次大小
        seq_length = x.shape[1]  # 序列长度
        # 通过线性层生成键、值、查询
        values = self.values(x)
        keys = self.keys(x)
        queries = self.queries(x)
        # 将数据分为多个头
        values = values.view(N, seq_length, self.heads, self.head_dim)
        keys = keys.view(N, seq_length, self.heads, self.head_dim)
        queries = queries.view(N, seq_length, self.heads, self.head_dim)
        values = values.permute(0, 2, 1, 3)  # (N, heads, seq_length, head_dim)
        keys = keys.permute(0, 2, 1, 3)      # (N, heads, seq_length, head_dim)
        queries = queries.permute(0, 2, 1, 3) # (N, heads, seq_length, head_dim)
        # 计算注意力分数
        energy = torch.einsum("nqhd,nkhd->nqkh", [queries, keys])  # (N, queries, keys, heads)
        attention = F.softmax(energy / (self.embed_size ** (1 / 2)), dim=3)  # 归一化
        # 加权求和
        out = torch.einsum("nqkh,nvhd->nqhd", [attention, values]).reshape(N, seq_length, self.heads * self.head_dim)
        return self.fc_out(out)
# 定义前馈神经网络
class FeedForward(nn.Module):
    def __init__(self, embed_size, forward_expansion):
        super(FeedForward, self).__init__()
        self.fc1 = nn.Linear(embed_size, forward_expansion)
        self.fc2 = nn.Linear(forward_expansion, embed_size)
    def forward(self, x):
        return self.fc2(F.relu(self.fc1(x)))
# 定义编码器层
class EncoderLayer(nn.Module):
    def __init__(self, embed_size, heads, forward_expansion, dropout):
        super(EncoderLayer, self).__init__()
        self.attention = MultiHeadAttention(embed_size, heads)
        self.norm1 = nn.LayerNorm(embed_size)
        self.norm2 = nn.LayerNorm(embed_size)
        self.feed_forward = FeedForward(embed_size, forward_expansion)
        self.dropout = nn.Dropout(dropout)
    def forward(self, x):
        attention = self.attention(x)
        x = self.dropout(self.norm1(attention + x))  # 残差连接和层归一化
        forward = self.feed_forward(x)
        x = self.dropout(self.norm2(forward + x))  # 残差连接和层归一化
        return x
# 定义整个编码器
class Encoder(nn.Module):
    def __init__(self, embed_size, num_layers, heads, forward_expansion, dropout, input_dim):
        super(Encoder, self).__init__()
        self.layers = nn.ModuleList(
            [
                EncoderLayer(embed_size, heads, forward_expansion, dropout)
                for _ in range(num_layers)
            ]
        )
        self.dropout = nn.Dropout(dropout)
        self.embedding = nn.Embedding(input_dim, embed_size)
    def forward(self, x):
        N, seq_length = x.shape
        x = self.dropout(self.embedding(x))  # 嵌入层
        for layer in self.layers:
            x = layer(x)  # 逐层传递
        return x
# 测试编码器
if __name__ == "__main__":
    embed_size = 256  # 嵌入维度
    num_layers = 6    # 编码器层数
    heads = 8         # 注意力头数
    forward_expansion = 512  # 前馈网络的扩展维度
    dropout = 0.1     # dropout 概率
    input_dim = 10000  # 输入词汇表大小
    x = torch.randint(0, input_dim, (32, 10))  # 模拟输入 (批次大小, 序列长度)
    encoder = Encoder(embed_size, num_layers, heads, forward_expansion, dropout, input_dim)
    out = encoder(x)
    print(out.shape)  # 输出的形状