从零实现Transformer英译汉模型：代码解析与实战指南

作者：沙与沫2025.10.11 16:50浏览量：13

简介：本文通过解析Transformer模型核心代码，结合英译汉机器翻译实战案例，系统讲解注意力机制、编码器-解码器架构、位置编码等关键模块的实现细节，并提供完整训练流程与优化建议。

一、Transformer模型核心架构解析

Transformer模型彻底改变了序列到序列（Seq2Seq）任务的实现方式，其核心创新在于完全摒弃循环神经网络（RNN）结构，转而采用自注意力机制（Self-Attention）实现并行计算。在英译汉任务中，编码器负责处理英文源句，解码器生成中文目标句，两者通过多头注意力机制实现信息交互。

1.1 自注意力机制实现

自注意力机制是Transformer的核心组件，其计算过程可分为三个步骤：

  1. import torch
  2. import torch.nn as nn
  4. class MultiHeadAttention(nn.Module):
  5.     def __init__(self, embed_size, heads):
  6.         super().__init__()
  7.         self.embed_size = embed_size
  8.         self.heads = heads
  9.         self.head_dim = embed_size // heads
  11.         # 线性变换矩阵
  12.         self.values = nn.Linear(self.head_dim, self.head_dim, bias=False)
  13.         self.keys = nn.Linear(self.head_dim, self.head_dim, bias=False)
  14.         self.queries = nn.Linear(self.head_dim, self.head_dim, bias=False)
  15.         self.fc_out = nn.Linear(heads * self.head_dim, embed_size)
  17.     def forward(self, values, keys, query, mask):
  18.         N = query.shape[0]  # 批次大小
  19.         value_len, key_len, query_len = values.shape[1], keys.shape[1], query.shape[1]
  21.         # 分割多头
  22.         values = values.reshape(N, value_len, self.heads, self.head_dim)
  23.         keys = keys.reshape(N, key_len, self.heads, self.head_dim)
  24.         queries = query.reshape(N, query_len, self.heads, self.head_dim)
  26.         # 线性变换
  27.         values = self.values(values)
  28.         keys = self.keys(keys)
  29.         queries = self.queries(queries)
  31.         # 计算注意力分数
  32.         energy = torch.einsum("nqhd,nkhd->nhqk", [queries, keys])
  33.         if mask is not None:
  34.             energy = energy.masked_fill(mask == 0, float("-1e20"))
  36.         attention = torch.softmax(energy / (self.embed_size ** (1/2)), dim=3)
  38.         # 加权求和
  39.         out = torch.einsum("nhql,nlhd->nqhd", [attention, values])
  40.         out = out.reshape(N, query_len, self.heads * self.head_dim)
  42.         # 输出投影
  43.         out = self.fc_out(out)
  44.         return out

代码中torch.einsum实现了高效的矩阵运算，energy计算查询向量与键向量的点积，通过masked_fill处理填充位置，最后通过softmax归一化得到注意力权重。多头机制使模型能同时关注不同位置的信息，提升翻译准确性。

1.2 位置编码设计

由于Transformer缺乏时序信息，需通过位置编码（Positional Encoding）注入序列顺序信息：

  1. class PositionalEncoding(nn.Module):
  2.     def __init__(self, embed_size, max_len=5000):
  3.         super().__init__()
  4.         self.embedding = nn.Embedding(max_len, embed_size)
  5.         self.embed_size = embed_size
  7.     def forward(self, x):
  8.         position = torch.arange(0, x.shape[1], dtype=torch.float).unsqueeze(1)
  9.         div_term = torch.exp(torch.arange(0, self.embed_size, 2).float() * (-math.log(10000.0) / self.embed_size))
  10.         pe = torch.zeros(x.shape[1], self.embed_size)
  11.         pe[:, 0::2] = torch.sin(position * div_term)
  12.         pe[:, 1::2] = torch.cos(position * div_term)
  13.         return x + pe.unsqueeze(0)

正弦和余弦函数的组合使模型能学习相对位置关系，div_term中的指数衰减确保高频位置信息优先传递。

二、英译汉模型实战实现

完整英译汉系统包含数据预处理、模型构建、训练优化三个核心阶段。

2.1 数据预处理流程

  1. 分词处理：使用BPE（Byte Pair Encoding）算法处理中英文词汇，解决未登录词问题
  2. 对齐处理：确保中英文句子长度匹配，长句截断，短句填充
  3. 数值化：构建词汇表，将文本转换为索引序列
    ```python
    from tokenizers import BytePairBPETokenizer

训练BPE分词器

tokenizer = BytePairBPETokenizer()
tokenizer.train_from_iterator([“ “.join(sent) for sent in en_sentences], vocab_size=30000)
tokenizer.save_model(“bpe_tokenizer”)

数值化函数

def tokenize_en(text):
return tokenizer.encode(text).ids

def tokenize_zh(text):

  1. # 中文分词器需单独处理
  2. pass
  2. ## 2.2 完整模型架构
  3. ```python
  4. class Transformer(nn.Module):
  5.     def __init__(self, src_vocab_size, trg_vocab_size, src_pad_idx, embed_size=256, num_layers=6, heads=8, forward_expansion=4, dropout=0.1, max_length=100):
  6.         super().__init__()
  7.         self.src_word_embedding = nn.Embedding(src_vocab_size, embed_size)
  8.         self.src_position_embedding = PositionalEncoding(embed_size, max_length)
  9.         self.trg_word_embedding = nn.Embedding(trg_vocab_size, embed_size)
  10.         self.trg_position_embedding = PositionalEncoding(embed_size, max_length)
  12.         self.encoder = Encoder(embed_size, num_layers, heads, forward_expansion, dropout, max_length)
  13.         self.decoder = Decoder(embed_size, num_layers, heads, forward_expansion, dropout, max_length)
  14.         self.fc_out = nn.Linear(embed_size, trg_vocab_size)
  15.         self.src_pad_idx = src_pad_idx
  17.     def make_src_mask(self, src):
  18.         src_mask = (src != self.src_pad_idx).unsqueeze(1).unsqueeze(2)
  19.         return src_mask
  21.     def forward(self, src, trg):
  22.         src_seq_length, N = src.shape
  23.         trg_seq_length, N = trg.shape
  25.         src = self.src_word_embedding(src)
  26.         src = self.src_position_embedding(src)
  27.         trg = self.trg_word_embedding(trg)
  28.         trg = self.trg_position_embedding(trg)
  30.         src_mask = self.make_src_mask(src)
  32.         enc_src = self.encoder(src, src_mask)
  33.         out = self.decoder(trg, enc_src, src_mask)
  34.         out = self.fc_out(out)
  35.         return out

模型采用6层编码器-解码器结构，每层包含多头注意力、残差连接和层归一化。make_src_mask函数生成填充位置掩码，防止模型关注无效位置。

2.3 训练优化技巧

  1. 标签平滑：缓解过拟合，提升模型泛化能力
    1. criterion = nn.CrossEntropyLoss(label_smoothing=0.1)

  2. 学习率调度：采用Noam优化器实现动态学习率调整

    1. class NoamOpt:
    2.  def __init__(self, model_size, factor, warmup, optimizer):
    3.      self.optimizer = optimizer
    4.      self.warmup = warmup
    5.      self.factor = factor
    6.      self.model_size = model_size
    7.      self._step = 0
    9.  def step(self):
    10.      self._step += 1
    11.      rate = self.calculate_rate()
    12.      for p in self.optimizer.param_groups:
    13.          p['lr'] = rate
    14.      self.optimizer.step()
    16.  def calculate_rate(self):
    17.      return self.factor * (self.model_size ** (-0.5) * min(self._step ** (-0.5), self._step * self.warmup ** (-1.5)))
  3. 混合精度训练：使用FP16加速训练，减少显存占用

三、性能优化与部署建议

  1. 模型压缩：采用知识蒸馏将大模型参数压缩至1/4，保持90%以上性能
  2. 量化技术：8位整数量化使模型体积减小75%，推理速度提升3倍
  3. 服务化部署：使用TorchScript导出模型，通过TensorRT优化推理性能
    1. # 模型导出示例
    2. traced_model = torch.jit.trace(model, (src_tensor, trg_tensor))
    3. traced_model.save("transformer.pt")

实际应用中，建议采用以下优化策略：

  1. 使用动态批次处理提升GPU利用率
  2. 实现缓存机制存储常用翻译结果
  3. 集成N-best列表和覆盖惩罚机制提升翻译质量

Transformer模型在英译汉任务中展现出卓越性能，通过深入理解其代码实现机制，开发者能更有效地进行模型调优和部署。本文提供的完整实现方案和优化建议，为工业级机器翻译系统开发提供了坚实基础。

最热文章