现在位置: 首页 > PyTorch 教程 > 正文

Transformer 模型

Transformer 模型是一种基于注意力机制的深度学习模型,最初由 Vaswani 等人在 2017 年的论文《Attention is All You Need》中提出。

Transformer 彻底改变了自然语言处理(NLP)领域,并逐渐扩展到计算机视觉(CV)等领域。

Transformer 的核心思想是完全摒弃传统的循环神经网络(RNN)结构,仅依赖注意力机制来处理序列数据,从而实现更高的并行性和更快的训练速度。

以下是 Transformer 架构图,左边为编码器,右边为解码器。

Transformer 模型由 编码器(Encoder) 和 解码器(Decoder) 两部分组成,每部分都由多层堆叠的相同模块构成。

编码器(Encoder)

编码器由 NN 层相同的模块堆叠而成,每层包含两个子层:

  • 多头自注意力机制(Multi-Head Self-Attention):计算输入序列中每个词与其他词的相关性。
  • 前馈神经网络(Feed-Forward Neural Network):对每个词进行独立的非线性变换。

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

解码器(Decoder)

解码器也由 NN 层相同的模块堆叠而成,每层包含三个子层:

  • 掩码多头自注意力机制(Masked Multi-Head Self-Attention):计算输出序列中每个词与前面词的相关性(使用掩码防止未来信息泄露)。
  • 编码器-解码器注意力机制(Encoder-Decoder Attention):计算输出序列与输入序列的相关性。
  • 前馈神经网络(Feed-Forward Neural Network):对每个词进行独立的非线性变换。

同样,每个子层后面都接有残差连接和层归一化。

在 Transformer 模型出现之前,NLP 领域的主流模型是基于 RNN 的架构,如长短期记忆网络(LSTM)和门控循环单元(GRU)。这些模型通过顺序处理输入数据来捕捉序列中的依赖关系,但存在以下问题:

  1. 梯度消失问题:长距离依赖关系难以捕捉。

  2. 顺序计算的局限性:无法充分利用现代硬件的并行计算能力,训练效率低下。

Transformer 通过引入自注意力机制解决了这些问题,允许模型同时处理整个输入序列,并动态地为序列中的每个位置分配不同的权重。


Transformer 的核心思想

1. 自注意力机制(Self-Attention)

自注意力机制是 Transformer 的核心组件。

自注意力机制允许模型在处理序列时,动态地为每个位置分配不同的权重,从而捕捉序列中任意两个位置之间的依赖关系。

  • 输入表示:输入序列中的每个词(或标记)通过词嵌入(Embedding)转换为向量表示。

  • 注意力权重计算:通过计算查询(Query)、键(Key)和值(Value)之间的点积,得到每个词与其他词的相关性权重。

  • 加权求和:使用注意力权重对值(Value)进行加权求和,得到每个词的上下文表示。

公式如下:

\[ \text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V \]

其中:

  • \(Q\) 是查询矩阵,\(K\) 是键矩阵,\(V\) 是值矩阵。
  • \(d_k\) 是向量的维度,用于缩放点积,防止梯度爆炸。

多头注意力(Multi-Head Attention)

为了捕捉更丰富的特征,Transformer 使用多头注意力机制。它将输入分成多个子空间,每个子空间独立计算注意力,最后将结果拼接起来。

  • 多头注意力的优势:允许模型关注序列中不同的部分,例如语法结构、语义关系等。

  • 并行计算:多个注意力头可以并行计算,提高效率。

位置编码(Positional Encoding)

由于 Transformer 没有显式的序列信息(如 RNN 中的时间步),位置编码被用来为输入序列中的每个词添加位置信息。通常使用正弦和余弦函数生成位置编码:

\[ PE_{(pos, 2i)} = \sin\left(\frac{pos}{10000^{2i/d_{\text{model}}}}\right) \] \[ PE_{(pos, 2i+1)} = \cos\left(\frac{pos}{10000^{2i/d_{\text{model}}}}\right) \]

其中:

\(pos\) 是词的位置,\(i\) 是维度索引。

编码器-解码器架构

Transformer 模型由编码器和解码器两部分组成:

  • 编码器:将输入序列转换为一系列隐藏表示。每个编码器层包含一个自注意力机制和一个前馈神经网络。
  • 解码器:
根据编码器的输出生成目标序列。每个解码器层包含两个注意力机制(自注意力和编码器-解码器注意力)和一个前馈神经网络。

前馈神经网络(Feed-Forward Neural Network)

每个编码器和解码器层都包含一个前馈神经网络,通常由两个全连接层组成,中间使用 ReLU 激活函数。

残差连接和层归一化

为了稳定训练过程,每个子层(如自注意力层和前馈神经网络)后面都会接一个残差连接和层归一化(Layer Normalization)。


Transformer 的优势

  1. 并行计算:Transformer 可以同时处理整个输入序列,充分利用现代硬件的并行计算能力。

  2. 长距离依赖:自注意力机制能够捕捉序列中任意两个位置之间的依赖关系,解决了 RNN 的梯度消失问题。

  3. 可扩展性:Transformer 模型可以通过堆叠更多的层来提升性能,例如 BERT 和 GPT 等模型。


Transformer 的应用

  1. 自然语言处理(NLP)

    • 机器翻译(如 Google Translate)

    • 文本生成(如 GPT 系列模型)

    • 文本分类、问答系统等。

  2. 计算机视觉(CV)

    • 图像分类(如 Vision Transformer)

    • 目标检测、图像生成等。

  3. 多模态任务

    • 结合文本和图像的任务(如 CLIP、DALL-E)。


PyTorch 实现 Transformer

以下是一个简单的 PyTorch 实现 Transformer 的示例:

实例

import torch
import torch.nn as nn
import torch.optim as optim

class TransformerModel(nn.Module):
    def __init__(self, input_dim, model_dim, num_heads, num_layers, output_dim):
        super(TransformerModel, self).__init__()
        self.embedding = nn.Embedding(input_dim, model_dim)
        self.positional_encoding = nn.Parameter(torch.zeros(1, 1000, model_dim))  # 假设序列长度最大为1000
        self.transformer = nn.Transformer(d_model=model_dim, nhead=num_heads, num_encoder_layers=num_layers)
        self.fc = nn.Linear(model_dim, output_dim)

    def forward(self, src, tgt):
        src_seq_length, tgt_seq_length = src.size(1), tgt.size(1)
        src = self.embedding(src) + self.positional_encoding[:, :src_seq_length, :]
        tgt = self.embedding(tgt) + self.positional_encoding[:, :tgt_seq_length, :]
        transformer_output = self.transformer(src, tgt)
        output = self.fc(transformer_output)
        return output

# 超参数
input_dim = 10000  # 词汇表大小
model_dim = 512    # 模型维度
num_heads = 8      # 多头注意力头数
num_layers = 6     # 编码器和解码器层数
output_dim = 10000 # 输出维度(通常与词汇表大小相同)

# 初始化模型、损失函数和优化器
model = TransformerModel(input_dim, model_dim, num_heads, num_layers, output_dim)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 假设输入数据
src = torch.randint(0, input_dim, (10, 32))  # (序列长度, 批量大小)
tgt = torch.randint(0, input_dim, (20, 32))  # (序列长度, 批量大小)

# 前向传播
output = model(src, tgt)

# 计算损失
loss = criterion(output.view(-1, output_dim), tgt.view(-1))

# 反向传播和优化
optimizer.zero_grad()
loss.backward()
optimizer.step()

print("Loss:", loss.item())