0
0

基于Transformer实现中英翻译任务的微调

本文旨在说明如何通过Transfoemers库和pytorch来微调一个中英翻译模型。这里选择开源的opus-mt-zh-en模型来实现微调，提升该模型在特定语料上的性能。入门小白，如果有误还请指导。

1.数据准备

这里选择 translation2019zh 语料作为数据集，它共包含中英文平行语料 520 万对，可以用于训练中英翻译模型。该数据集只划分好了训练集和验证集，分别包含 516 万和 3.9 万个样本，，语料以 json 格式提供，一行是一个中英文对照句子对：

  1. {'english': 'The fact that foreign brands dominate the China market rankles with central government economic planners, and could embolden local officials to take action, analysts say.', 'chinese': '分析人士指出，外国品牌主导中国市场的现实使中央政府的经济规划者们感到愤怒，并有可能使地方官员大胆采取行动。'}

1.1构建数据集

因为准备的语料并没有提供测试集，而且使用五百多万条样本进行训练耗时过长，这里我们只抽取训练集中的前 33 万条数据，并从中划分出 3 万条数据作为验证集，然后将 translation2019zh 中的验证集作为测试集(这一过程通过torch的Dataset来实现)：

  1. from torch.utils.data import Dataset, random_split
  2. import json
  4. max_dataset_size = 330000
  5. train_set_size = 300000
  6. valid_set_size = 30000
  8. class TRANS(Dataset):
  9.     def __init__(self, data_file):
  10.         self.data = self.load_data(data_file)
  11.     
  12.     def load_data(self, data_file):
  13.         Data = {}
  14.         with open(data_file, 'rt', encoding='utf-8') as f:
  15.             for idx, line in enumerate(f):
  16.                 if idx >= max_dataset_size:
  17.                     break
  18.                 sample = json.loads(line.strip())
  19.                 Data[idx] = sample
  20.         return Data
  21.     
  22.     def __len__(self):
  23.         return len(self.data)
  25.     def __getitem__(self, idx):
  26.         return self.data[idx]
  28. //路径根据实际路径替换
  29. data = TRANS('/mnt/workspace/translation/data/translation2019zh_train.json')
  30. train_data, valid_data = random_split(data, [train_set_size, valid_set_size])
  31. test_data = TRANS('/mnt/workspace/translation/data/translation2019zh_valid.json')

1.2数据预处理

因为我们在训练过程中需要先将数据集切分为很多的 mini-batches，然后按批 (batch) 将样本送入模型，并且循环这一过程，每一个完整遍历所有样本的循环称为一个 epoch，这就是torch中DataLoader做的事了。同时需要将文本转换为模型可以接受的 token IDs。对于翻译任务，我们需要运用分词器同时对源文本和目标文本进行编码。

我们会在模型预测出的标签序列与答案标签序列之间计算损失来调整模型参数，因此我们同样需要将填充的 pad 字符设置为 -50（其他不在分词器中的值都可以），以便在使用交叉熵计算序列损失时将它们忽略：

  1. import torch
  2. from transformers import AutoTokenizer
  4. #这是hugging face里的模型，需要科学上网
  5. #model_checkpoint = "Helsinki-NLP/opus-mt-zh-en"
  7. #这是modelscope里的，国内可以直接访问
  8. model_checkpoint ="moxying/opus-mt-zh-en"
  9. tokenizer = AutoTokenizer.from_pretrained(model_checkpoint)
  11. max_input_length = 128
  12. max_target_length = 128
  14. #每次给模型输入4批数据
  15. inputs = [train_data[s_idx]["chinese"] for s_idx in range(4)]
  16. targets = [train_data[s_idx]["english"] for s_idx in range(4)]
  18. model_inputs = tokenizer(
  19.     inputs, 
  20.     padding=True, 
  21.     max_length=max_input_length, 
  22.     truncation=True,
  23.     return_tensors="pt"
  24. )
  25.   #默认情况下分词器会采用源语言的设定来编码文本，要编码目标语言则需要通过上下文管理器
  26.  as_target_tokenizer(),否则中文分词器可能无法识别大部分的英文单词
  27. with tokenizer.as_target_tokenizer(): 
  28.     labels = tokenizer(
  29.         targets, 
  30.         padding=True, 
  31.         max_length=max_target_length, 
  32.         truncation=True,
  33.         return_tensors="pt"
  34.     )["input_ids"]
  36. end_token_index = torch.where(labels == tokenizer.eos_token_id)[1]
  37. for idx, end_idx in enumerate(end_token_index):
  38.     labels[idx][end_idx+1:] = -50

我们使用的 模型会在分词结果的结尾加上特殊 token 

  1. '</s>'

，因此这里通过 

  1. tokenizer.eos_token_id

定位其在 token ID 序列中的索引，然后将其之后的 pad 字符设置为 -50。

翻译模型就是一个典型的Encoder-Decoder架构（也可以叫Seq2Seq ），Encoder 负责编码输入序列，Decoder 负责循环地逐个生成输出 token。因此，对于每一个样本，我们还需要额外准备 decoder input IDs 作为 Decoder 的输入。decoder input IDs 是标签序列的移位，在序列的开始位置增加了一个特殊的“序列起始符”。

考虑到不同模型的移位操作可能存在差异，我们通过模型自带的 

  1. prepare_decoder_input_ids_from_labels

函数来完成。完整的批处理函数为：

  1. import torch
  2. from torch.utils.data import DataLoader
  3. from transformers import AutoModelForSeq2SeqLM
  4. from transformers import AutoTokenizer
  6. #这是hugging face里的模型，需要科学上网
  7. #model_checkpoint = "Helsinki-NLP/opus-mt-zh-en"
  9. #这是modelscope里的，国内可以直接访问
  10. model_checkpoint ="moxying/opus-mt-zh-en"
  11. tokenizer = AutoTokenizer.from_pretrained(model_checkpoint)
  13. max_input_length = 128
  14. max_target_length = 128
  16. device = 'cuda' if torch.cuda.is_available() else 'cpu'
  17. print(f'Using {device} device')
  19. model = AutoModelForSeq2SeqLM.from_pretrained(model_checkpoint)
  20. model = model.to(device)
  22. def collote_fn(batch_samples):
  23.     batch_inputs, batch_targets = [], []
  24.     for sample in batch_samples:
  25.         batch_inputs.append(sample['chinese'])
  26.         batch_targets.append(sample['english'])
  27.     batch_data = tokenizer(
  28.         batch_inputs, 
  29.         padding=True, 
  30.         max_length=max_input_length,
  31.         truncation=True, 
  32.         return_tensors="pt"
  33.     )
  34.     with tokenizer.as_target_tokenizer():
  35.         labels = tokenizer(
  36.             batch_targets, 
  37.             padding=True, 
  38.             max_length=max_target_length,
  39.             truncation=True, 
  40.             return_tensors="pt"
  41.         )["input_ids"]
  42.         batch_data['decoder_input_ids'] = model.prepare_decoder_input_ids_from_labels(labels)
  43.         end_token_index = torch.where(labels == tokenizer.eos_token_id)[1]
  44.         for idx, end_idx in enumerate(end_token_index):
  45.             labels[idx][end_idx+1:] = -100
  46.         batch_data['labels'] = labels
  47.     return batch_data
  49. train_dataloader = DataLoader(train_data, batch_size=32, shuffle=True, collate_fn=collote_fn)
  50. valid_dataloader = DataLoader(valid_data, batch_size=32, shuffle=False, collate_fn=collote_fn)

2.模型微调

前面直接使用 Transformers 库自带的 

  1. AutoModelForSeq2SeqLM

类来构建模型，并且在批处理函数中还调用了模型自带的 

  1. prepare_decoder_input_ids_from_labels

函数，因此下面只需要实现 Epoch 中的”训练循环”和”验证/测试循环”。

使用 

  1. AutoModelForSeq2SeqLM

构造的模型已经封装好了对应的损失函数，并且计算出的损失会直接包含在模型的输出 

  1. outputs

中，可以直接通过 

  1. outputs.loss

获得，因此训练循环为：

  1. from tqdm.auto import tqdm
  3. def train_loop(dataloader, model, optimizer, lr_scheduler, epoch, total_loss):
  4.     progress_bar = tqdm(range(len(dataloader)))
  5.     progress_bar.set_description(f'loss: {0:>7f}')
  6.     finish_batch_num = (epoch-1) * len(dataloader)
  7.     
  8.     model.train()
  9.     for batch, batch_data in enumerate(dataloader, start=1):
  10.         batch_data = batch_data.to(device)
  11.         outputs = model(**batch_data)
  12.         loss = outputs.loss
  14.         optimizer.zero_grad()
  15.         loss.backward()
  16.         optimizer.step()
  17.         lr_scheduler.step()
  19.         total_loss += loss.item()
  20.         progress_bar.set_description(f'loss: {total_loss/(finish_batch_num + batch):>7f}')
  21.         progress_bar.update(1)
  22.     return total_loss

验证/测试循环负责评估模型的性能。对于翻译任务，经典的评估指标是 BLEU 值，用于度量两个词语序列之间的一致性，但是其并不会衡量语义连贯性或者语法正确性。

由于计算 BLEU 值需要输入分好词的文本，而不同的分词方式会对结果造成影响，因此现在更常用的评估指标是 SacreBLEU，它对分词的过程进行了标准化。SacreBLEU 直接以未分词的文本作为输入，并且对于同一个输入可以接受多个目标作为参考。虽然我们使用的 translation2019zh 语料对于每一个句子只有一个参考，也需要将其包装为一个句子列表

在“验证/测试循环”中，我们首先通过 

  1. model.generate()

函数获取预测结果，然后将预测结果和正确标签都处理为 SacreBLEU 接受的文本列表形式（这里我们将标签序列中的 -50 替换为 pad token ID 以便于分词器解码），最后送入到 SacreBLEU 中计算 BLEU 值：

  1. from sacrebleu.metrics import BLEU
  2. bleu = BLEU()
  4. def test_loop(dataloader, model):
  5.     preds, labels = [], []
  6.     
  7.     model.eval()
  8.     for batch_data in tqdm(dataloader):
  9.         batch_data = batch_data.to(device)
  10.         with torch.no_grad():
  11.             generated_tokens = model.generate(
  12.                 batch_data["input_ids"],
  13.                 attention_mask=batch_data["attention_mask"],
  14.                 max_length=max_target_length,
  15.             ).cpu().numpy()
  16.         label_tokens = batch_data["labels"].cpu().numpy()
  17.         
  18.         decoded_preds = tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)
  19.         label_tokens = np.where(label_tokens != -100, label_tokens, tokenizer.pad_token_id)
  20.         decoded_labels = tokenizer.batch_decode(label_tokens, skip_special_tokens=True)
  22.         preds += [pred.strip() for pred in decoded_preds]
  23.         labels += [[label.strip()] for label in decoded_labels]
  24.     bleu_score = bleu.corpus_score(preds, labels).score
  25.     print(f"BLEU: {bleu_score:>0.2f}\n")
  26.     return bleu_score

3.保存模型

这里会根据模型在验证集上的性能来调整超参数以及选出最好的模型权重，然后将选出的模型应用于测试集以评估最终的性能。这里我们继续使用 AdamW 优化器，并且通过 

  1. get_scheduler()

函数定义学习率调度器：

  1. from transformers import AdamW, get_scheduler
  3. learning_rate = 2e-5
  4. epoch_num = 3
  6. optimizer = AdamW(model.parameters(), lr=learning_rate)
  7. lr_scheduler = get_scheduler(
  8.     "linear",
  9.     optimizer=optimizer,
  10.     num_warmup_steps=0,
  11.     num_training_steps=epoch_num*len(train_dataloader),
  12. )
  14. total_loss = 0.
  15. best_bleu = 0.
  16. for t in range(epoch_num):
  17.     print(f"Epoch {t+1}/{epoch_num}\n-------------------------------")
  18.     total_loss = train_loop(train_dataloader, model, optimizer, lr_scheduler, t+1, total_loss)
  19.     valid_bleu = test_loop(valid_dataloader, model, mode='Valid')
  20.     if valid_bleu > best_bleu:
  21.         best_bleu = valid_bleu
  22.         print('saving new weights...\n')
  23.         torch.save(model.state_dict(), f'epoch_{t+1}_valid_bleu_{valid_bleu:0.2f}_model_weights.bin')
  24. print("Done!")

4.完整代码

  1. import random
  2. import os
  3. import numpy as np
  4. import torch
  5. from torch.utils.data import Dataset, DataLoader, random_split
  6. from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
  7. from transformers import AdamW, get_scheduler
  8. from sacrebleu.metrics import BLEU
  9. from tqdm.auto import tqdm
  10. import json
  11. from modelscope import snapshot_download
  13. def seed_everything(seed=1029):
  14.     random.seed(seed)
  15.     os.environ['PYTHONHASHSEED'] = str(seed)
  16.     np.random.seed(seed)
  17.     torch.manual_seed(seed)
  18.     torch.cuda.manual_seed(seed)
  19.     torch.cuda.manual_seed_all(seed)
  20.     torch.backends.cudnn.deterministic = True
  22. device = 'cuda' if torch.cuda.is_available() else 'cpu'
  23. print(f'Using {device} device')
  24. seed_everything(42)
  26. max_dataset_size = 220000
  27. train_set_size = 200000
  28. valid_set_size = 20000
  30. max_input_length = 128
  31. max_target_length = 128
  33. batch_size = 32
  34. learning_rate = 1e-5
  35. epoch_num = 3
  37. class TRANS(Dataset):
  38.     def __init__(self, data_file):
  39.         self.data = self.load_data(data_file)
  40.     
  41.     def load_data(self, data_file):
  42.         Data = {}
  43.         with open(data_file, 'rt', encoding='utf-8') as f:
  44.             for idx, line in enumerate(f):
  45.                 if idx >= max_dataset_size:
  46.                     break
  47.                 sample = json.loads(line.strip())
  48.                 Data[idx] = sample
  49.         return Data
  50.     
  51.     def __len__(self):
  52.         return len(self.data)
  54.     def __getitem__(self, idx):
  55.         return self.data[idx]
  57. data = TRANS('/mnt/workspace/translation/data/translation2019zh_train.json')
  58. train_data, valid_data = random_split(data, [train_set_size, valid_set_size])
  59. test_data = TRANS('/mnt/workspace/translation/data/translation2019zh_valid.json')
  61. model_checkpoint = snapshot_download('moxying/opus-mt-zh-en')
  62. tokenizer = AutoTokenizer.from_pretrained(model_checkpoint)
  63. model = AutoModelForSeq2SeqLM.from_pretrained(model_checkpoint)
  64. model = model.to(device)
  66. def collote_fn(batch_samples):
  67.     batch_inputs, batch_targets = [], []
  68.     for sample in batch_samples:
  69.         batch_inputs.append(sample['chinese'])
  70.         batch_targets.append(sample['english'])
  71.     batch_data = tokenizer(
  72.         batch_inputs, 
  73.         padding=True, 
  74.         max_length=max_input_length,
  75.         truncation=True, 
  76.         return_tensors="pt"
  77.     )
  78.     with tokenizer.as_target_tokenizer():
  79.         labels = tokenizer(
  80.             batch_targets, 
  81.             padding=True, 
  82.             max_length=max_target_length,
  83.             truncation=True, 
  84.             return_tensors="pt"
  85.         )["input_ids"]
  86.         batch_data['decoder_input_ids'] = model.prepare_decoder_input_ids_from_labels(labels)
  87.         end_token_index = torch.where(labels == tokenizer.eos_token_id)[1]
  88.         for idx, end_idx in enumerate(end_token_index):
  89.             labels[idx][end_idx+1:] = -100
  90.         batch_data['labels'] = labels
  91.     return batch_data
  93. train_dataloader = DataLoader(train_data, batch_size=batch_size, shuffle=True, collate_fn=collote_fn)
  94. valid_dataloader = DataLoader(valid_data, batch_size=batch_size, shuffle=False, collate_fn=collote_fn)
  95. test_dataloader = DataLoader(test_data, batch_size=batch_size, shuffle=False, collate_fn=collote_fn)
  97. def train_loop(dataloader, model, optimizer, lr_scheduler, epoch, total_loss):
  98.     progress_bar = tqdm(range(len(dataloader)))
  99.     progress_bar.set_description(f'loss: {0:>7f}')
  100.     finish_batch_num = (epoch-1) * len(dataloader)
  101.     
  102.     model.train()
  103.     for batch, batch_data in enumerate(dataloader, start=1):
  104.         batch_data = batch_data.to(device)
  105.         outputs = model(**batch_data)
  106.         loss = outputs.loss
  108.         optimizer.zero_grad()
  109.         loss.backward()
  110.         optimizer.step()
  111.         lr_scheduler.step()
  113.         total_loss += loss.item()
  114.         progress_bar.set_description(f'loss: {total_loss/(finish_batch_num + batch):>7f}')
  115.         progress_bar.update(1)
  116.     return total_loss
  118. bleu = BLEU()
  120. def test_loop(dataloader, model):
  121.     preds, labels = [], []
  122.     
  123.     model.eval()
  124.     for batch_data in tqdm(dataloader):
  125.         batch_data = batch_data.to(device)
  126.         with torch.no_grad():
  127.             generated_tokens = model.generate(
  128.                 batch_data["input_ids"],
  129.                 attention_mask=batch_data["attention_mask"],
  130.                 max_length=max_target_length,
  131.             ).cpu().numpy()
  132.         label_tokens = batch_data["labels"].cpu().numpy()
  133.         
  134.         decoded_preds = tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)
  135.         label_tokens = np.where(label_tokens != -100, label_tokens, tokenizer.pad_token_id)
  136.         decoded_labels = tokenizer.batch_decode(label_tokens, skip_special_tokens=True)
  138.         preds += [pred.strip() for pred in decoded_preds]
  139.         labels += [[label.strip()] for label in decoded_labels]
  140.     bleu_score = bleu.corpus_score(preds, labels).score
  141.     print(f"BLEU: {bleu_score:>0.2f}\n")
  142.     return bleu_score
  144. optimizer = AdamW(model.parameters(), lr=learning_rate)
  145. lr_scheduler = get_scheduler(
  146.     "linear",
  147.     optimizer=optimizer,
  148.     num_warmup_steps=0,
  149.     num_training_steps=epoch_num*len(train_dataloader),
  150. )
  152. total_loss = 0.
  153. best_bleu = 0.
  154. for t in range(epoch_num):
  155.     print(f"Epoch {t+1}/{epoch_num}\n-------------------------------")
  156.     total_loss = train_loop(train_dataloader, model, optimizer, lr_scheduler, t+1, total_loss)
  157.     valid_bleu = test_loop(valid_dataloader, model)
  158.     if valid_bleu > best_bleu:
  159.         best_bleu = valid_bleu
  160.         print('saving new weights...\n')
  161.         torch.save(
  162.             model.state_dict(), 
  163.             f'epoch_{t+1}_valid_bleu_{valid_bleu:0.2f}_model_weights.bin'
  164.         )
  165. print("Done!")

5.模型测试

训练完成后，我们加载在验证集上性能最优的模型权重，汇报其在测试集上的性能由于 

  1. AutoModelForSeq2SeqLM

对整个解码过程进行了封装，我们只需要调用 

  1. generate()

函数就可以自动通过 beam search 找到最佳的 token ID 序列，因此我们只需要再使用分词器将 token ID 序列转换为文本就可以获得翻译结果：

  1. model.load_state_dict(torch.load('epoch_1_valid_bleu_53.38_model_weights.bin'))
  3. model.eval()
  4. with torch.no_grad():
  5.     print('evaluating on test set...')
  6.     sources, preds, labels = [], [], []
  7.     for batch_data in tqdm(test_dataloader):
  8.         batch_data = batch_data.to(device)
  9.         generated_tokens = model.generate(
  10.             batch_data["input_ids"],
  11.             attention_mask=batch_data["attention_mask"],
  12.             max_length=max_target_length,
  13.         ).cpu().numpy()
  14.         label_tokens = batch_data["labels"].cpu().numpy()
  16.         decoded_sources = tokenizer.batch_decode(
  17.             batch_data["input_ids"].cpu().numpy(), 
  18.             skip_special_tokens=True, 
  19.             use_source_tokenizer=True
  20.         )
  21.         decoded_preds = tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)
  22.         label_tokens = np.where(label_tokens != -100, label_tokens, tokenizer.pad_token_id)
  23.         decoded_labels = tokenizer.batch_decode(label_tokens, skip_special_tokens=True)
  25.         sources += [source.strip() for source in decoded_sources]
  26.         preds += [pred.strip() for pred in decoded_preds]
  27.         labels += [[label.strip()] for label in decoded_labels]
  28.     bleu_score = bleu.corpus_score(preds, labels).score
  29.     print(f"Test BLEU: {bleu_score:>0.2f}\n")

可以看到，经过微调，模型在测试集上的 BLEU 值达到了 54.87，证明了我们对模型的微调是成功的。（没有微调之前的值为42左右）

标签： transformer 深度学习 人工智能
本文转载自: https://blog.csdn.net/WB231444/article/details/140737820
版权归原作者 星辰境末 所有， 如有侵权，请联系我们删除。
登录后发布评论

“基于Transformer实现中英翻译任务的微调”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？

文章导航
没有找到文章内容分段。。。