[深度学习]transformer是什么(介绍)

关键词

NLP领域的绝对领导者, 序列数据, 上下文依赖, 例如机器翻译, 文本摘要, 大型语言模型.

并行计算, 没有循环, 没有卷积, 自注意力机制.

对算力要求很大, 如果你有很厉害的算力gpu, tpu等资源作为支持.

1. Transformer 是什么？

Transformer 是一种基于自注意力机制（Self-Attention） 的神经网络架构，由 Google 团队在 2017 年的论文《Attention is All You Need》中首次提出。它彻底改变了序列建模（尤其是自然语言处理）的传统方法，取代了 RNN 和 LSTM 等循环神经网络。

---

2. Transformer 的架构特点

• 完全基于注意力机制：无需循环或卷积操作。
• 并行化计算：显著提升训练速度。
• 核心组件 ：
  • 编码器（Encoder）：处理输入序列
  • 解码器（Decoder）：生成输出序列
  • 多头注意力（Multi-Head Attention）：捕捉序列中不同位置的依赖关系
  • 位置编码（Positional Encoding）：注入序列顺序信息

---

3. 主要解决的问题

1. 长距离依赖问题：传统 RNN 难以处理长序列中的依赖关系，Transformer 的自注意力机制能直接关联任意距离的元素。
2. 训练效率问题：RNN 的序列化计算无法并行，Transformer 的并行计算大幅提升训练速度。
3. 核心应用领域 ：
   • 机器翻译（如 Google Translate）
   • 文本生成（如 GPT 系列）
   • 文本分类/情感分析
   • 语音识别
   • 图像生成（如 Vision Transformer）

---

完整代码示例：文本分类 Transformer

以下是一个使用 PyTorch 实现的简化版 Transformer 用于文本分类的完整示例：

import torch
import torch.nn as nn
import torch.optim as optim
from torchtext.data import Field, BucketIterator, TabularDataset

# 1. 定义 Transformer 模型
class TextClassificationTransformer(nn.Module):
    def __init__(self, vocab_size, embed_dim, num_heads, num_layers, hidden_dim, num_classes):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embed_dim)
        self.pos_encoder = PositionalEncoding(embed_dim)
        encoder_layer = nn.TransformerEncoderLayer(
            d_model=embed_dim, nhead=num_heads, dim_feedforward=hidden_dim
        )
        self.transformer_encoder = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)
        self.fc = nn.Linear(embed_dim, num_classes)
    
    def forward(self, x):
        # x: [seq_len, batch_size]
        x = self.embedding(x)  # [seq_len, batch_size, embed_dim]
        x = self.pos_encoder(x)
        x = self.transformer_encoder(x)  # [seq_len, batch_size, embed_dim]
        x = x.mean(dim=0)  # 全局平均池化 [batch_size, embed_dim]
        return self.fc(x)  # [batch_size, num_classes]

# 2. 位置编码层
class PositionalEncoding(nn.Module):
    def __init__(self, d_model, max_len=5000):
        super().__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() * (-torch.log(torch.tensor(10000.0)) / d_model))
        pe[:, 0::2] = torch.sin(position * div_term)
        pe[:, 1::2] = torch.cos(position * div_term)
        pe = pe.unsqueeze(1)  # [max_len, 1, d_model]
        self.register_buffer('pe', pe)
    
    def forward(self, x):
        x = x + self.pe[:x.size(0), :]
        return x

# 3. 数据预处理
TEXT = Field(tokenize='spacy', lower=True, include_lengths=True)
LABEL = Field(sequential=False, use_vocab=False)

train_data, test_data = TabularDataset.splits(
    path='./data',
    train='train.csv',
    test='test.csv',
    format='csv',
    fields=[('text', TEXT), ('label', LABEL)]
)

TEXT.build_vocab(train_data, max_size=10000)
train_loader, test_loader = BucketIterator.splits(
    (train_data, test_data),
    batch_size=32,
    sort_key=lambda x: len(x.text),
    sort_within_batch=True
)

# 4. 训练配置
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = TextClassificationTransformer(
    vocab_size=len(TEXT.vocab),
    embed_dim=128,
    num_heads=4,
    num_layers=2,
    hidden_dim=256,
    num_classes=2
).to(device)

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 5. 训练循环
for epoch in range(10):
    for batch in train_loader:
        text, lengths = batch.text
        labels = batch.label.to(device)
        
        optimizer.zero_grad()
        outputs = model(text.to(device))
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
    
    print(f'Epoch {epoch+1}, Loss: {loss.item():.4f}')

# 6. 测试评估
correct = 0
total = 0
with torch.no_grad():
    for batch in test_loader:
        text, lengths = batch.text
        labels = batch.label.to(device)
        outputs = model(text.to(device))
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f'Test Accuracy: {100 * correct / total:.2f}%')

---

关键组件说明：

1. 多头注意力（Multi-Head Attention）

   nn.MultiheadAttention(embed_dim=128, num_heads=4)

   • 允许模型同时关注不同表示子空间的信息

2. 位置编码（PositionalEncoding）

   • 使用正弦/余弦函数编码位置信息
   • 解决 Transformer 缺乏顺序感知的问题

3. 前馈网络（Feed Forward）

   nn.Sequential(
       nn.Linear(embed_dim, hidden_dim),
       nn.ReLU(),
       nn.Linear(hidden_dim, embed_dim)
   )

---

实际应用建议：

1. 预训练模型 ：实际应用中推荐使用 HuggingFace 的 Transformers 库：

   from transformers import BertForSequenceClassification
   model = BertForSequenceClassification.from_pretrained('bert-base-uncased')

2. 超参数调整 ：

   • 增加层数（num_layers）提升模型容量
   • 增大隐藏维度（hidden_dim）增强表示能力
   • 调整注意力头数（num_heads）优化特征提取

Transformer 已成为 NLP 的基石架构，后续的 BERT、GPT 等里程碑模型均基于此架构构建。