### 数据集下载与Transformer模型训练和测试 #### 数据集下载 要下载 `cmn-eng` 翻译数据集，可以参考以下步骤。通常，该数据集可以从公开的自然语言处理资源中获取，例如 TensorFlow 的官方示例或 GitHub 上的相关项目。 以下是下载和预处理数据集的代码示例： ```python import os import urllib.request import zipfile # 下载 cmn-eng 数据集 url = "https://download.pytorch.org/tutorial/data.zip" data_dir = "./data" os.makedirs(data_dir, exist_ok=True) zip_path = os.path.join(data_dir, "data.zip") urllib.request.urlretrieve(url, zip_path) # 解压数据集 with zipfile.ZipFile(zip_path, 'r') as zip_ref: zip_ref.extractall(data_dir) # 数据路径 file_path = os.path.join(data_dir, "data", "cmn.txt") print(f"Data downloaded and extracted to {file_path}") ``` #### 数据预处理 在下载并解压数据后，需要对数据进行预处理以适应 Transformer 模型的需求。预处理包括分词、构建词汇表、填充序列等操作[^3]。 以下是预处理的代码示例： ```python import re from torchtext.data.utils import get_tokenizer from torchtext.vocab import build_vocab_from_iterator def preprocess_line(line): """预处理每行数据""" en, cmn = line.strip().split('\t') en = re.sub(r"[^a-zA-Z.!?]+", r" ", en.lower()) cmn = re.sub(r"[^a-zA-Z\u4e00-\u9fff.!?]+", r" ", cmn.lower()) return en, cmn def generate_tokens(file_path): """生成 token 列表""" tokenizer_en = get_tokenizer('basic_english') tokenizer_cmn = lambda x: list(x) # 中文按字符分词 with open(file_path, 'r', encoding='utf-8') as f: for line in f: en, cmn = preprocess_line(line) yield tokenizer_en(en) yield tokenizer_cmn(cmn) # 构建词汇表 vocab = build_vocab_from_iterator(generate_tokens(file_path), specials=["<unk>", "<pad>", "<bos>", "<eos>"]) vocab.set_default_index(vocab["<unk>"]) # 示例：将句子转换为 token ID def text_to_token_ids(text, tokenizer, vocab): tokens = tokenizer(text) return [vocab[token] for token in tokens] example_text = "I have an apple" tokenizer_en = get_tokenizer('basic_english') token_ids = text_to_token_ids(example_text, tokenizer_en, vocab) print(f"Token IDs: {token_ids}") ``` #### Transformer 模型训练 使用 PyTorch 实现 Transformer 模型，并完成训练过程。以下是一个简化的训练流程： 1. **定义模型结构**：使用 PyTorch 提供的 `nn.Transformer` 模块。 2. **准备数据**：将数据集划分为训练集和验证集，并创建 DataLoader。 3. **训练模型**：定义损失函数（如 `CrossEntropyLoss`）和优化器（如 `Adam`），并进行迭代训练。 以下是模型定义和训练的代码示例： ```python import torch.nn as nn import torch.optim as optim class TransformerModel(nn.Module): def __init__(self, vocab_size, d_model, nhead, num_layers): super().__init__() self.embedding = nn.Embedding(vocab_size, d_model) self.transformer = nn.Transformer(d_model, nhead, num_layers, num_layers) self.fc_out = nn.Linear(d_model, vocab_size) def forward(self, src, tgt): src_emb = self.embedding(src) tgt_emb = self.embedding(tgt) output = self.transformer(src_emb, tgt_emb) return self.fc_out(output) # 初始化模型 vocab_size = len(vocab) d_model = 512 nhead = 8 num_layers = 6 model = TransformerModel(vocab_size, d_model, nhead, num_layers) # 定义损失函数和优化器 criterion = nn.CrossEntropyLoss(ignore_index=vocab["<pad>"]) optimizer = optim.Adam(model.parameters(), lr=0.0001) # 训练循环（简化版） for epoch in range(10): # 假设训练 10 个 epoch model.train() total_loss = 0 for batch in train_loader: # 假设已有 DataLoader src, tgt = batch optimizer.zero_grad() output = model(src, tgt[:-1]) # Decoder 输入为 tgt[:-1] loss = criterion(output.view(-1, vocab_size), tgt[1:].view(-1)) # 目标为 tgt[1:] loss.backward() optimizer.step() total_loss += loss.item() print(f"Epoch {epoch+1}, Loss: {total_loss / len(train_loader)}") ``` #### 模型测试 在测试阶段，需要生成目标序列。对于 Transformer 模型，通常采用自回归方式逐词生成目标序列。具体实现如下： ```python def translate_sentence(sentence, model, tokenizer, vocab, max_len=50): model.eval() src = text_to_token_ids(sentence, tokenizer, vocab) src_tensor = torch.tensor([src]).long() tgt = [vocab["<bos>"]] for _ in range(max_len): tgt_tensor = torch.tensor([tgt]).long() with torch.no_grad(): output = model(src_tensor, tgt_tensor) next_word_idx = output.argmax(dim=-1)[-1].item() if next_word_idx == vocab["<eos>"]: break tgt.append(next_word_idx) translated_words = [vocab.lookup_token(idx) for idx in tgt[1:]] return " ".join(translated_words) example_sentence = "I have an apple" translated = translate_sentence(example_sentence, model, tokenizer_en, vocab) print(f"Translated: {translated}") ``` ### 注意事项 - 数据预处理是关键步骤，确保分词和词汇表构建正确。 - 在训练过程中，建议监控验证集上的性能以防止过拟合。 - 测试阶段的生成方法可以进一步优化，例如引入 Beam Search。