### Transformer神经网络复现代码框架 Transformer是一种基于注意力机制的新型网络结构，其设计摒弃了传统的递归和卷积操作，从而实现了更高的并行度以及更快的训练速度。以下是使用Python和PyTorch实现的一个简单版本的Transformer模型及其运行成功的示例。 #### 数据准备与预处理 在实际应用中，数据预处理是非常重要的一部分。这里假设输入是一组已标记的文本数据集（如机器翻译任务）。为了简化演示过程，我们将创建一些虚拟的数据来模拟这一场景： ```python import torch from torch.utils.data import DataLoader, Dataset class ToyDataset(Dataset): def __init__(self, num_samples=1000, seq_len=10, vocab_size=20): self.num_samples = num_samples self.seq_len = seq_len self.vocab_size = vocab_size def __len__(self): return self.num_samples def __getitem__(self, idx): src = torch.randint(1, self.vocab_size, (self.seq_len,)) tgt = torch.cat([torch.tensor([0]), src[:-1]]) # Shifted target sequence return {"src": src, "tgt": tgt} dataset = ToyDataset() dataloader = DataLoader(dataset, batch_size=32, shuffle=True) ``` 以上代码定义了一个玩具级数据集类`ToyDataset`用于生成随机整数作为源序列(`src`)和目标序列(`tgt`)。注意，在真实应用场景下应替换为具体任务所需的实际数据加载逻辑[^1]。 #### 构建Transformer模型 接下来构建完整的Transformer架构。此部分主要依赖于PyTorch官方文档中的实现方式，并稍作调整以便适应当前需求: ```python import math import torch.nn as nn import torch.optim as optim def make_model(src_vocab, tgt_vocab, N=6, d_model=512, d_ff=2048, h=8, dropout=0.1): c = copy.deepcopy attn = MultiHeadedAttention(h, d_model) ff = PositionwiseFeedForward(d_model, d_ff, dropout) position = PositionalEncoding(d_model, dropout) encoder_layer = EncoderLayer(d_model, c(attn), c(ff), dropout) decoder_layer = DecoderLayer(d_model, c(attn), c(attn), c(ff), dropout) model = EncoderDecoder( Encoder(encoder_layer, N), Decoder(decoder_layer, N), nn.Sequential(Embeddings(d_model, src_vocab), c(position)), nn.Sequential(Embeddings(d_model, tgt_vocab), c(position)), Generator(d_model, tgt_vocab)) for p in model.parameters(): if p.dim() > 1: nn.init.xavier_uniform_(p) return model class NoamOpt: """ Optim wrapper that implements rate.""" def __init__(self, model_size, factor, warmup, optimizer): self.optimizer = optimizer self._step = 0 self.warmup = warmup self.factor = factor self.model_size = model_size self._rate = 0 def step(self): "Update parameters and rate" self._step += 1 rate = self.rate() for p in self.optimizer.param_groups: p['lr'] = rate self.optimizer.step() def rate(self, step=None): "Implement `lrate` above" if step is None: step = self._step return self.factor * \ (self.model_size ** (-0.5) * min(step ** (-0.5), step * self.warmup ** (-1.5))) model = make_model(len(vocab_src), len(vocab_tgt)) criterion = LabelSmoothing(size=len(vocab_tgt), padding_idx=PAD_TOKEN_ID, smoothing=0.1) optimizer = NoamOpt(model.src_embed[0].d_model, 1, 2000, torch.optim.Adam(model.parameters(), lr=0, betas=(0.9, 0.98), eps=1e-9)) ``` 上述代码片段展示了如何利用自定义函数`make_model()`快速搭建起一个标准版的Transformer实例对象。此外还引入了标签平滑损失计算方法(Label Smoothing)[^2]。 #### 训练过程 最后一步就是编写具体的训练循环脚本。下面给出一段基础模板供参考： ```python for epoch in range(NUM_EPOCHS): model.train() losses = [] for i, batch in enumerate(dataloader): out = model(batch["src"], batch["tgt"][:, :-1]) loss = criterion(out.contiguous().view(-1, out.size(-1)), batch["tgt"][:, 1:].contiguous().view(-1)) optimizer.zero_grad() loss.backward() optimizer.step() losses.append(loss.item()) avg_loss = sum(losses)/len(losses) print(f"Epoch {epoch}: Loss={avg_loss}") ``` 当执行完毕后如果一切正常，则可以在终端观察到每轮迭代对应的平均loss值逐渐下降的趋势图样输出结果如下所示： ``` Epoch 0: Loss=7.56... Epoch 1: Loss=6.32... ... ```