### Transformer模型完整案例代码 以下是基于PyTorch实现的一个完整的Transformer模型代码示例。该代码涵盖了Encoder和Decoder的结构，并包含了一个简单的训练流程。 ```python import torch import torch.nn as nn import torch.optim as optim # 定义Transformer模型 class TransformerModel(nn.Module): def __init__(self, src_vocab_size, tgt_vocab_size, d_model, num_heads, num_layers, dropout=0.1): super(TransformerModel, self).__init__() self.encoder_embedding = nn.Embedding(src_vocab_size, d_model) self.decoder_embedding = nn.Embedding(tgt_vocab_size, d_model) self.positional_encoding = PositionalEncoding(d_model, dropout) self.transformer = nn.Transformer(d_model, num_heads, num_layers, num_layers, d_model * 4, dropout) self.fc_out = nn.Linear(d_model, tgt_vocab_size) def forward(self, src, tgt): src_embedded = self.positional_encoding(self.encoder_embedding(src)) tgt_embedded = self.positional_encoding(self.decoder_embedding(tgt)) output = self.transformer(src_embedded, tgt_embedded) output = self.fc_out(output) return output # 定位编码模块 class PositionalEncoding(nn.Module): def __init__(self, d_model, dropout=0.1, max_len=5000): super(PositionalEncoding, self).__init__() self.dropout = nn.Dropout(p=dropout) 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(0).transpose(0, 1) self.register_buffer('pe', pe) def forward(self, x): x = x + self.pe[:x.size(0), :] return self.dropout(x) # 模型参数 src_vocab_size = 10000 # 假设源语言词汇表大小 tgt_vocab_size = 10000 # 假设目标语言词汇表大小 d_model = 512 # 输入和输出张量的特征维度[^2] num_heads = 8 # 多头注意力机制的头数 num_layers = 6 # 编码器和解码器堆叠的层数 dropout = 0.1 # Dropout概率 # 初始化模型、损失函数和优化器 model = TransformerModel(src_vocab_size, tgt_vocab_size, d_model, num_heads, num_layers, dropout) criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=0.0001) # 训练数据（假设） src = torch.randint(0, src_vocab_size, (10, 32)) # 源序列，形状为 (seq_len, batch_size) tgt = torch.randint(0, tgt_vocab_size, (10, 32)) # 目标序列，形状为 (seq_len, batch_size) # 训练循环 for epoch in range(10): # 假设训练10个epoch optimizer.zero_grad() output = model(src, tgt[:-1]) # 解码器输入为移位后的目标序列 loss = criterion(output.view(-1, tgt_vocab_size), tgt[1:].reshape(-1)) # 忽略首个标记 loss.backward() optimizer.step() print(f"Epoch {epoch+1}, Loss: {loss.item()}") # 测试模型 with torch.no_grad(): test_src = torch.randint(0, src_vocab_size, (10, 1)) # 测试输入 test_tgt = torch.tensor([[0]]) # 开始标记 for _ in range(9): # 生成长度为10的序列 output = model(test_src, test_tgt) next_word = torch.argmax(output[-1], dim=-1) test_tgt = torch.cat([test_tgt, next_word.unsqueeze(0)], dim=0) print("Generated sequence:", test_tgt.squeeze().tolist()) ``` 上述代码展示了如何构建一个完整的Transformer模型，并通过简单的训练和推理流程进行演示。模型的核心组件包括嵌入层、位置编码、多头注意力机制以及前馈神经网络[^1]。 ### 注意事项 - 在实际应用中，需要根据具体任务调整超参数，例如`d_model`、`num_heads`、`num_layers`等。 - 数据预处理是Transformer模型成功的关键之一。对于自然语言处理任务，通常需要对文本进行分词、编码和填充[^2]。 - 如果应用于时间序列预测任务，可以参考时间融合Transformer模型的设计思路[^3]。