Transformer

Transformer 是一种基于 自注意力机制（Self-Attention Mechanism） 的深度学习模型，由 Google 在 2017 年的论文《Attention Is All You Need》中提出。它彻底改变了自然语言处理（NLP）领域，并成为现代 NLP 任务（如机器翻译、文本生成、问答系统等）的主流模型。Transformer 的核心思想是通过 自注意力机制 捕捉输入序列中不同位置之间的依赖关系，从而替代传统的循环神经网络（RNN）和卷积神经网络（CNN）。

以下是 Transformer 的详细介绍：

一、核心思想

Transformer 的核心是 自注意力机制，它允许模型在处理每个位置时，动态地关注输入序列的其他位置，从而捕捉长距离依赖关系。与传统 RNN 或 CNN 相比，Transformer 具有以下优势：

1. 并行计算：自注意力机制允许模型在序列中所有位置上同时计算，显著提高了训练效率。
2. 长距离依赖：直接建模任意位置之间的依赖关系，避免了 RNN 的梯度消失问题。
3. 灵活性：可以处理任意长度的序列，且易于扩展到多模态任务（如图像、语音）。

二、模型结构

Transformer 由 编码器（Encoder） 和 解码器（Decoder） 组成，编码器用于处理输入序列，解码器用于生成输出序列。

1. 编码器（Encoder）

编码器由多个相同的层（Layer）堆叠而成，每一层包含以下两个子层：

• 多头自注意力层（Multi-Head Self-Attention）：捕捉输入序列中不同位置之间的依赖关系。
• 前馈神经网络（Feed-Forward Network）：对每个位置进行非线性变换。

每一层之后还包括 残差连接（Residual Connection） 和 层归一化（Layer Normalization），以稳定训练过程。

2. 解码器（Decoder）

解码器也由多个相同的层堆叠而成，每一层包含以下三个子层：

• 多头自注意力层（Multi-Head Self-Attention）：捕捉解码器输入序列中的依赖关系。
• 编码器-解码器注意力层（Encoder-Decoder Attention）：捕捉解码器输入与编码器输出之间的依赖关系。
• 前馈神经网络（Feed-Forward Network）：对每个位置进行非线性变换。

同样，每一层之后包括残差连接和层归一化。

五、应用场景

Transformer 在 NLP 领域取得了巨大成功，并被广泛应用于以下任务：

1. 机器翻译：如 Google 的翻译系统。
2. 文本生成：如 GPT（Generative Pre-trained Transformer）。
3. 问答系统：如 BERT（Bidirectional Encoder Representations from Transformers）。
4. 文本分类：如情感分析、主题分类。
5. 多模态任务：如图像字幕生成、视觉问答。

六、经典模型

1. BERT：基于 Transformer 的双向预训练模型，通过掩码语言模型（MLM）和下一句预测（NSP）进行预训练。
2. GPT：基于 Transformer 的单向生成式预训练模型，通过自回归语言模型进行预训练。
3. T5：将 NLP 任务统一为文本到文本的任务，基于 Transformer 进行预训练。
4. BART：结合了 BERT 和 GPT 的特点，支持双向编码和单向生成。

七、代码示例（PyTorch）

import torch
import torch.nn as nn
import math

# 位置编码
class PositionalEncoding(nn.Module):
    def __init__(self, d_model, max_len=5000):
        super(PositionalEncoding, self).__init__()
        pe = torch.zeros(max_len, d_model)
        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
        pe[:, 0::2] = torch.sin(position * div_term)
        pe[:, 1::2] = torch.cos(position * div_term)
        pe = pe.unsqueeze(0).transpose(0, 1)
        self.register_buffer('pe', pe)

    def forward(self, x):
        return x + self.pe[:x.size(0), :]

# 多头自注意力
class MultiHeadAttention(nn.Module):
    def __init__(self, d_model, num_heads):
        super(MultiHeadAttention, self).__init__()
        self.num_heads = num_heads
        self.head_dim = d_model // num_heads
        self.scale = self.head_dim ** -0.5
        self.query = nn.Linear(d_model, d_model)
        self.key = nn.Linear(d_model, d_model)
        self.value = nn.Linear(d_model, d_model)
        self.out = nn.Linear(d_model, d_model)

    def forward(self, q, k, v):
        Q = self.query(q)
        K = self.key(k)
        V = self.value(v)
        attn = (Q @ K.transpose(-2, -1)) * self.scale
        attn = attn.softmax(dim=-1)
        out = attn @ V
        return self.out(out)

# Transformer 编码器层
class TransformerEncoderLayer(nn.Module):
    def __init__(self, d_model, num_heads, dim_feedforward=2048):
        super(TransformerEncoderLayer, self).__init__()
        self.self_attn = MultiHeadAttention(d_model, num_heads)
        self.linear1 = nn.Linear(d_model, dim_feedforward)
        self.linear2 = nn.Linear(dim_feedforward, d_model)
        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)
        self.dropout = nn.Dropout(0.1)

    def forward(self, x):
        x = x + self.self_attn(x, x, x)
        x = self.norm1(x)
        x = x + self.dropout(torch.relu(self.linear1(x)))
        x = self.norm2(x)
        return x

八、总结

Transformer 通过自注意力机制和并行计算，解决了传统 RNN 和 CNN 的局限性，成为 NLP 领域的核心技术。其高效性和灵活性使其广泛应用于各种任务，并催生了许多经典模型（如 BERT、GPT）。未来，Transformer 将继续在多模态、轻量化、高效推理等方向演进，推动人工智能的发展。