翻译

现在让我们深入了解翻译。这是另一个序列到序列任务，这意味着它是一个可以被表述为从一个序列到另一个序列的问题。从这个意义上说，这个问题与摘要非常接近，您可以将我们在这里看到的改编为其他序列到序列问题，例如

风格迁移: 创建一个模型，翻译以特定风格编写的文本到另一种风格（例如，正式到非正式，或莎士比亚英语到现代英语）
生成式问答: 创建一个模型，根据上下文生成问题的答案

如果您拥有两种（或更多种）语言的足够大的语料库，您可以像我们在因果语言建模部分中那样从头开始训练一个新的翻译模型。但是，微调一个现有的翻译模型会更快，无论是您想要微调到特定语言对的多语言模型（如 mT5 或 mBART），还是您想要微调到您的特定语料库的专门用于从一种语言到另一种语言的翻译的模型。

在本节中，我们将在 KDE4 数据集上微调一个预训练的 Marian 模型，该模型预训练用于从英语到法语的翻译（因为很多 Hugging Face 员工都说法语和英语）。我们将使用的模型是在来自 Opus 数据集的大量法语和英语文本语料库上进行预训练的，该语料库实际上包含 KDE4 数据集。但即使我们使用的预训练模型在预训练期间看到了这些数据，我们也会发现，在微调之后，我们可以得到一个更好的版本。

完成后，我们将得到一个能够做出如下预测的模型

One-hot encoded labels for question answering.

与之前几节一样，您可以使用以下代码找到我们将在 Hub 上训练并上传的实际模型，并双重检查其预测此处。

准备数据

为了从头开始微调或训练一个翻译模型，我们需要一个适合该任务的数据集。如前所述，在本节中我们将使用 KDE4 数据集，但您可以轻松地将代码改编为使用您自己的数据，只要您拥有您想要从中翻译和翻译到的两种语言的句子对即可。如果您需要提醒如何将自定义数据加载到 Dataset 中，请参考第 5 章。

KDE4 数据集

像往常一样，我们使用 load_dataset() 函数下载数据集

from datasets import load_dataset

raw_datasets = load_dataset("kde4", lang1="en", lang2="fr")

如果您想使用不同的语言对，可以通过其代码指定它们。该数据集总共包含 92 种语言；您可以在其数据集卡片上展开语言标签来查看所有语言。

Language available for the KDE4 dataset.

让我们看一下数据集

raw_datasets

DatasetDict({
    train: Dataset({
        features: ['id', 'translation'],
        num_rows: 210173
    })
})

我们有 210,173 对句子，但在一个单一的拆分中，因此我们需要创建自己的验证集。正如我们在第 5 章中看到的，Dataset 具有一个 train_test_split() 方法，可以帮助我们。我们将提供一个种子以实现可重复性

split_datasets = raw_datasets["train"].train_test_split(train_size=0.9, seed=20)
split_datasets

DatasetDict({
    train: Dataset({
        features: ['id', 'translation'],
        num_rows: 189155
    })
    test: Dataset({
        features: ['id', 'translation'],
        num_rows: 21018
    })
})

我们可以将 "test" 键重命名为 "validation"，如下所示

split_datasets["validation"] = split_datasets.pop("test")

现在让我们看一下数据集中的一个元素

split_datasets["train"][1]["translation"]

{'en': 'Default to expanded threads',
 'fr': 'Par défaut, développer les fils de discussion'}

我们得到一个字典，其中包含我们请求的语言对中的两句话。该数据集包含的技术计算机科学术语的一个特殊之处在于，它们都是完全翻译成法语的。但是，法国工程师在谈话时会将大多数计算机科学专用词保留在英语中。例如，在这里，词语 “threads” 可能出现在法语句子中，特别是在技术对话中；但在这个数据集中，它被翻译成了更准确的 “fils de discussion”。我们使用的预训练模型是在更大的法语和英语句子语料库上进行预训练的，它选择了更简单的选项，将词语保留原样。

from transformers import pipeline

model_checkpoint = "Helsinki-NLP/opus-mt-en-fr"
translator = pipeline("translation", model=model_checkpoint)
translator("Default to expanded threads")

[{'translation_text': 'Par défaut pour les threads élargis'}]

另一个这种行为的例子可以从词语 “plugin” 中看出，这个词语并非官方的法语词语，但大多数母语人士都能理解它，并且不会费心去翻译它。在这个 KDE4 数据集中，这个词语被翻译成法语，变成了更正式的 “module d’extension”。

split_datasets["train"][172]["translation"]

{'en': 'Unable to import %1 using the OFX importer plugin. This file is not the correct format.',
 'fr': "Impossible d'importer %1 en utilisant le module d'extension d'importation OFX. Ce fichier n'a pas un format correct."}

然而，我们的预训练模型坚持使用简洁熟悉的英语词语。

translator(
    "Unable to import %1 using the OFX importer plugin. This file is not the correct format."
)

[{'translation_text': "Impossible d'importer %1 en utilisant le plugin d'importateur OFX. Ce fichier n'est pas le bon format."}]

有趣的是，看看我们微调的模型是否会拾取到数据集的这些特殊之处（剧透警告：会的）。

✏️ 轮到你了！ 另一个经常在法语中使用的英语词语是 “email”。在训练数据集中找到第一个使用这个词语的样本。它被翻译成什么了？预训练模型如何翻译同一个英语句子？

处理数据

你现在应该知道流程了：所有文本都需要转换为一组标记 ID，以便模型可以理解它们。对于此任务，我们需要对输入和目标进行标记。我们的第一个任务是创建我们的tokenizer对象。如前所述，我们将使用 Marian 英语到法语的预训练模型。如果你使用其他语言对，请确保调整模型检查点。 Helsinki-NLP组织提供了超过一千种多种语言的模型。

from transformers import AutoTokenizer

model_checkpoint = "Helsinki-NLP/opus-mt-en-fr"
tokenizer = AutoTokenizer.from_pretrained(model_checkpoint, return_tensors="pt")

你也可以用你喜欢的任何其他模型替换model_checkpoint，来自 Hub，或你保存了预训练模型和标记器的本地文件夹。

💡如果你使用多语言标记器，如 mBART、mBART-50 或 M2M100，你需要通过设置tokenizer.src_lang和tokenizer.tgt_lang到正确的值来在标记器中设置你的输入和目标的语言代码。

我们数据的准备非常简单。只需要记住一件事；你需要确保标记器用输出语言（这里是法语）处理目标。你可以通过将目标传递给标记器__call__方法的text_targets参数来实现。

为了了解它是如何工作的，让我们处理训练集中的每种语言的一个样本

en_sentence = split_datasets["train"][1]["translation"]["en"]
fr_sentence = split_datasets["train"][1]["translation"]["fr"]

inputs = tokenizer(en_sentence, text_target=fr_sentence)
inputs

{'input_ids': [47591, 12, 9842, 19634, 9, 0], 'attention_mask': [1, 1, 1, 1, 1, 1], 'labels': [577, 5891, 2, 3184, 16, 2542, 5, 1710, 0]}

我们可以看到，输出包含与英语句子相关的输入 ID，而与法语句子相关的 ID 存储在labels字段中。如果你忘记指定你正在标记标签，它们将被输入标记器标记，在 Marian 模型的情况下，这将无法正常工作。

wrong_targets = tokenizer(fr_sentence)
print(tokenizer.convert_ids_to_tokens(wrong_targets["input_ids"]))
print(tokenizer.convert_ids_to_tokens(inputs["labels"]))

['▁Par', '▁dé', 'f', 'aut', ',', '▁dé', 've', 'lop', 'per', '▁les', '▁fil', 's', '▁de', '▁discussion', '</s>']
['▁Par', '▁défaut', ',', '▁développer', '▁les', '▁fils', '▁de', '▁discussion', '</s>']

我们可以看到，使用英语标记器预处理法语句子会导致更多标记，因为标记器不认识任何法语单词（除了在英语中也出现的单词，比如“discussion”）。

由于inputs是一个包含我们常用键的字典（输入 ID、注意力掩码等），最后一步是定义我们将应用于数据集的预处理函数。

max_length = 128


def preprocess_function(examples):
    inputs = [ex["en"] for ex in examples["translation"]]
    targets = [ex["fr"] for ex in examples["translation"]]
    model_inputs = tokenizer(
        inputs, text_target=targets, max_length=max_length, truncation=True
    )
    return model_inputs

请注意，我们为输入和输出设置了相同的最大长度。由于我们处理的文本似乎很短，我们使用 128。

💡如果你使用 T5 模型（更具体地说，是t5-xxx检查点中的一个），模型将期望文本输入带有表示当前任务的前缀，例如translate: English to French:。

⚠️我们不关注目标的注意力掩码，因为模型不需要它。相反，与填充标记对应的标签应设置为-100，以便它们在损失计算中被忽略。这将在我们稍后使用数据整理器完成，因为我们正在应用动态填充，但是如果你在这里使用填充，你应该调整预处理函数以将对应于填充标记的所有标签设置为-100。

现在我们可以一次性将预处理应用于我们数据集的所有分割。

tokenized_datasets = split_datasets.map(
    preprocess_function,
    batched=True,
    remove_columns=split_datasets["train"].column_names,
)

现在数据已经预处理过了，我们准备微调我们的预训练模型了！

使用 Trainer API 微调模型

使用Trainer的实际代码与之前相同，只有一点变化：我们在这里使用的是 Seq2SeqTrainer，它是Trainer的一个子类，它将允许我们使用generate()方法从输入中预测输出，从而正确处理评估。当我们讨论指标计算时，我们将更详细地探讨这一点。

首先，我们需要一个实际的模型来微调。我们将使用常用的AutoModel API。

from transformers import AutoModelForSeq2SeqLM

model = AutoModelForSeq2SeqLM.from_pretrained(model_checkpoint)

请注意，这一次我们使用的是一个在翻译任务上训练的模型，并且实际上已经可以使用了，因此不会有关于缺少权重或新初始化权重的警告。

数据整理

我们需要一个数据整理器来处理动态批处理的填充。我们不能像第 3 章那样使用DataCollatorWithPadding，因为它只填充输入（输入 ID、注意力掩码和标记类型 ID）。我们的标签也应该填充到标签中遇到的最大长度。并且，如前所述，用于填充标签的填充值应该为-100，而不是标记器的填充标记，以确保这些填充值在损失计算中被忽略。

所有这些都是由 DataCollatorForSeq2Seq完成的。像DataCollatorWithPadding一样，它接受用于预处理输入的tokenizer，但它也接受model。这是因为此数据整理器还将负责准备解码器输入 ID，它们是带有特殊标记开头的标签的移位版本。由于这种移位对于不同的架构略有不同，DataCollatorForSeq2Seq需要知道model对象。

from transformers import DataCollatorForSeq2Seq

data_collator = DataCollatorForSeq2Seq(tokenizer, model=model)

要在一些样本上测试它，我们只需在来自我们标记的训练集的示例列表上调用它即可。

batch = data_collator([tokenized_datasets["train"][i] for i in range(1, 3)])
batch.keys()

dict_keys(['attention_mask', 'input_ids', 'labels', 'decoder_input_ids'])

我们可以检查我们的标签是否已填充到批次的最大长度，使用-100

batch["labels"]

tensor([[  577,  5891,     2,  3184,    16,  2542,     5,  1710,     0,  -100,
          -100,  -100,  -100,  -100,  -100,  -100],
        [ 1211,     3,    49,  9409,  1211,     3, 29140,   817,  3124,   817,
           550,  7032,  5821,  7907, 12649,     0]])

我们也可以看看解码器输入 ID，以查看它们是否是标签的移位版本。

batch["decoder_input_ids"]

tensor([[59513,   577,  5891,     2,  3184,    16,  2542,     5,  1710,     0,
         59513, 59513, 59513, 59513, 59513, 59513],
        [59513,  1211,     3,    49,  9409,  1211,     3, 29140,   817,  3124,
           817,   550,  7032,  5821,  7907, 12649]])

以下是我们数据集中第一个和第二个元素的标签。

for i in range(1, 3):
    print(tokenized_datasets["train"][i]["labels"])

[577, 5891, 2, 3184, 16, 2542, 5, 1710, 0]
[1211, 3, 49, 9409, 1211, 3, 29140, 817, 3124, 817, 550, 7032, 5821, 7907, 12649, 0]

我们将把这个data_collator传递给Seq2SeqTrainer。接下来，让我们看看指标。

指标

Seq2SeqTrainer添加到其超类Trainer的功能是能够在评估或预测期间使用generate()方法。在训练期间，模型将使用decoder_input_ids，并使用一个注意力掩码来确保它不会使用它试图预测的标记之后的标记，以加快训练速度。在推理期间，我们将无法使用它们，因为我们没有标签，所以最好用相同的设置来评估我们的模型。

正如我们在第 1 章中所看到的，解码器通过逐个预测标记来执行推理——这在 🤗 Transformers 中由generate()方法在幕后实现。如果我们设置predict_with_generate=True，Seq2SeqTrainer将允许我们使用该方法进行评估。

用于翻译的传统指标是 BLEU 分数，它在 2002 年的一篇文章中由 Kishore Papineni 等人提出。BLEU 分数评估翻译与标签的接近程度。它不衡量模型生成的输出的可理解性或语法正确性，而是使用统计规则来确保生成的输出中的所有单词也出现在目标中。此外，还有一些规则会惩罚重复相同的单词（如果它们在目标中没有重复），以及输出比目标更短的句子（以避免模型输出像“the”这样的句子）。

BLEU 的一个缺点是它期望文本已经过标记，这使得很难比较使用不同标记器的模型之间的分数。因此，今天用于基准测试翻译模型的最常用指标是 SacreBLEU，它通过标准化标记步骤解决了这个问题（以及其他问题）。要使用此指标，我们首先需要安装 SacreBLEU 库。

!pip install sacrebleu

然后我们可以像我们在第 3 章中所做的那样，通过evaluate.load()加载它。

import evaluate

metric = evaluate.load("sacrebleu")

此指标将接受文本作为输入和目标。它被设计为接受几个可接受的目标，因为同一个句子的翻译通常有多个可接受的版本——我们使用的 dataset 只提供了一个，但在 NLP 中，发现提供多个句子作为标签的 dataset 并不少见。因此，预测应该是一个句子列表，但参考应该是一个句子列表的列表。

让我们试一个例子。

predictions = [
    "This plugin lets you translate web pages between several languages automatically."
]
references = [
    [
        "This plugin allows you to automatically translate web pages between several languages."
    ]
]
metric.compute(predictions=predictions, references=references)

{'score': 46.750469682990165,
 'counts': [11, 6, 4, 3],
 'totals': [12, 11, 10, 9],
 'precisions': [91.67, 54.54, 40.0, 33.33],
 'bp': 0.9200444146293233,
 'sys_len': 12,
 'ref_len': 13}

这得到了 46.75 的 BLEU 分数，相当不错——作为参考， “Attention Is All You Need”论文中的原始 Transformer 模型在英语和法语之间的类似翻译任务中获得了 41.8 的 BLEU 分数！（有关counts和bp等各个指标的更多信息，请参阅 SacreBLEU 存储库。）另一方面，如果我们尝试使用两种常见的翻译模型会产生的糟糕的预测类型（大量重复或太短），我们将获得相当差的 BLEU 分数。

predictions = ["This This This This"]
references = [
    [
        "This plugin allows you to automatically translate web pages between several languages."
    ]
]
metric.compute(predictions=predictions, references=references)

{'score': 1.683602693167689,
 'counts': [1, 0, 0, 0],
 'totals': [4, 3, 2, 1],
 'precisions': [25.0, 16.67, 12.5, 12.5],
 'bp': 0.10539922456186433,
 'sys_len': 4,
 'ref_len': 13}

predictions = ["This plugin"]
references = [
    [
        "This plugin allows you to automatically translate web pages between several languages."
    ]
]
metric.compute(predictions=predictions, references=references)

{'score': 0.0,
 'counts': [2, 1, 0, 0],
 'totals': [2, 1, 0, 0],
 'precisions': [100.0, 100.0, 0.0, 0.0],
 'bp': 0.004086771438464067,
 'sys_len': 2,
 'ref_len': 13}

分数可以在 0 到 100 之间，越高越好。

要从模型输出到指标可以使用的文本，我们将使用tokenizer.batch_decode()方法。我们只需要清理标签中的所有-100（标记器会自动对填充标记做同样的事情）。

import numpy as np


def compute_metrics(eval_preds):
    preds, labels = eval_preds
    # In case the model returns more than the prediction logits
    if isinstance(preds, tuple):
        preds = preds[0]

    decoded_preds = tokenizer.batch_decode(preds, skip_special_tokens=True)

    # Replace -100s in the labels as we can't decode them
    labels = np.where(labels != -100, labels, tokenizer.pad_token_id)
    decoded_labels = tokenizer.batch_decode(labels, skip_special_tokens=True)

    # Some simple post-processing
    decoded_preds = [pred.strip() for pred in decoded_preds]
    decoded_labels = [[label.strip()] for label in decoded_labels]

    result = metric.compute(predictions=decoded_preds, references=decoded_labels)
    return {"bleu": result["score"]}

现在，我们准备微调我们的模型了！

微调模型

第一步是登录 Hugging Face，这样你就可以将你的结果上传到模型中心。笔记本中有一个方便的函数可以帮助你完成此操作

from huggingface_hub import notebook_login

notebook_login()

这将显示一个窗口，你可以在其中输入你的 Hugging Face 登录凭据。

如果你没有在笔记本中工作，只需在你的终端中输入以下代码

huggingface-cli login

完成此操作后，我们可以定义我们的 Seq2SeqTrainingArguments。与 Trainer 一样，我们使用 TrainingArguments 的一个子类，其中包含一些额外的字段

from transformers import Seq2SeqTrainingArguments

args = Seq2SeqTrainingArguments(
    f"marian-finetuned-kde4-en-to-fr",
    evaluation_strategy="no",
    save_strategy="epoch",
    learning_rate=2e-5,
    per_device_train_batch_size=32,
    per_device_eval_batch_size=64,
    weight_decay=0.01,
    save_total_limit=3,
    num_train_epochs=3,
    predict_with_generate=True,
    fp16=True,
    push_to_hub=True,
)

除了通常的超参数（如学习率、迭代次数、批量大小和一些权重衰减）外，与我们在前几节中看到的相比，这里有一些更改

我们没有设置任何常规评估，因为评估需要一段时间；我们只会在训练之前和之后评估一次我们的模型。
我们设置 fp16=True，这将加快现代 GPU 上的训练速度。
我们设置 predict_with_generate=True，如上所述。
我们使用 push_to_hub=True 在每个迭代结束时将模型上传到模型中心。

请注意，你可以使用 hub_model_id 参数指定要推送到仓库的完整名称（特别是，你必须使用此参数推送到组织）。例如，当我们将模型推送到 huggingface-course 组织时，我们在 Seq2SeqTrainingArguments 中添加了 hub_model_id="huggingface-course/marian-finetuned-kde4-en-to-fr"。默认情况下，使用的仓库将在你的命名空间中，并以你设置的输出目录命名，因此在我们的例子中，它将是 "sgugger/marian-finetuned-kde4-en-to-fr"（这就是我们在本节开头链接的模型）。

💡 如果您正在使用的输出目录已经存在，它需要是您要推送到仓库的本地克隆。如果不是，您在定义 Seq2SeqTrainer 时会收到错误，并且需要设置一个新名称。

最后，我们将所有内容传递给 Seq2SeqTrainer

from transformers import Seq2SeqTrainer

trainer = Seq2SeqTrainer(
    model,
    args,
    train_dataset=tokenized_datasets["train"],
    eval_dataset=tokenized_datasets["validation"],
    data_collator=data_collator,
    tokenizer=tokenizer,
    compute_metrics=compute_metrics,
)

在训练之前，我们首先看看我们的模型获得的分数，以再次确认我们在微调时没有使事情变得更糟。此命令将花费一些时间，因此您可以在它执行时去喝杯咖啡

trainer.evaluate(max_length=max_length)

{'eval_loss': 1.6964408159255981,
 'eval_bleu': 39.26865061007616,
 'eval_runtime': 965.8884,
 'eval_samples_per_second': 21.76,
 'eval_steps_per_second': 0.341}

39 的 BLEU 分数还不错，这反映了我们的模型已经擅长将英语句子翻译成法语句子。

接下来是训练，这也会花费一些时间

trainer.train()

请注意，在训练过程中，每次模型被保存（这里，每个迭代）都会在后台上传到模型中心。这样，你就可以在必要时在另一台机器上恢复训练。

训练完成后，我们再次评估我们的模型——希望我们能在 BLEU 分数中看到一些改进！

trainer.evaluate(max_length=max_length)

{'eval_loss': 0.8558505773544312,
 'eval_bleu': 52.94161337775576,
 'eval_runtime': 714.2576,
 'eval_samples_per_second': 29.426,
 'eval_steps_per_second': 0.461,
 'epoch': 3.0}

这几乎是 14 个点的改进，这很棒。

最后，我们使用 push_to_hub() 方法确保我们上传了模型的最新版本。Trainer 还草拟了一个包含所有评估结果的模型卡并将其上传。此模型卡包含元数据，有助于模型中心为推理演示选择小部件。通常，无需说任何话，因为它可以从模型类推断出正确的小部件，但在这种情况下，同一个模型类可用于各种序列到序列问题，因此我们指定它是一个翻译模型

trainer.push_to_hub(tags="translation", commit_message="Training complete")

此命令返回它刚刚执行的提交的 URL，如果你想检查它

'https://huggingface.co/sgugger/marian-finetuned-kde4-en-to-fr/commit/3601d621e3baae2bc63d3311452535f8f58f6ef3'

在此阶段，你可以使用模型中心上的推理小部件测试你的模型并与你的朋友分享。你已经成功地在翻译任务上微调了一个模型——恭喜！

如果你想更深入地研究训练循环，我们现在将向你展示如何使用 🤗 Accelerate 做同样的事情。

自定义训练循环

现在让我们看一下完整的训练循环，这样你就可以轻松地自定义你需要的部分。它看起来很像我们在第 2 节和第 3 章中所做的。

准备所有用于训练的内容

您已经多次看到了这一切，因此我们将快速浏览代码。首先，我们将从我们的数据集构建 DataLoader，在将数据集设置为 "torch" 格式后，以便获得 PyTorch 张量

from torch.utils.data import DataLoader

tokenized_datasets.set_format("torch")
train_dataloader = DataLoader(
    tokenized_datasets["train"],
    shuffle=True,
    collate_fn=data_collator,
    batch_size=8,
)
eval_dataloader = DataLoader(
    tokenized_datasets["validation"], collate_fn=data_collator, batch_size=8
)

接下来，我们将重新实例化我们的模型，以确保我们不是从之前开始微调，而是从预训练的模型重新开始

model = AutoModelForSeq2SeqLM.from_pretrained(model_checkpoint)

然后我们将需要一个优化器

from transformers import AdamW

optimizer = AdamW(model.parameters(), lr=2e-5)

一旦我们有了所有这些对象，我们可以将它们发送到 accelerator.prepare() 方法。请记住，如果你想在 Colab 笔记本中使用 TPU 进行训练，你需要将所有这些代码移到一个训练函数中，并且该函数不应该执行任何实例化 Accelerator 的单元格。

from accelerate import Accelerator

accelerator = Accelerator()
model, optimizer, train_dataloader, eval_dataloader = accelerator.prepare(
    model, optimizer, train_dataloader, eval_dataloader
)

现在，我们将 train_dataloader 发送到 accelerator.prepare() 后，我们可以使用它的长度计算训练步骤数量。请记住，我们应该始终在准备数据加载器之后执行此操作，因为该方法将更改 DataLoader 的长度。我们使用从学习率到 0 的经典线性调度

from transformers import get_scheduler

num_train_epochs = 3
num_update_steps_per_epoch = len(train_dataloader)
num_training_steps = num_train_epochs * num_update_steps_per_epoch

lr_scheduler = get_scheduler(
    "linear",
    optimizer=optimizer,
    num_warmup_steps=0,
    num_training_steps=num_training_steps,
)

最后，为了将模型推送到模型中心，我们需要在工作文件夹中创建一个 Repository 对象。首先登录到 Hugging Face 模型中心，如果你还没有登录。我们将从我们要给模型的模型 ID 中确定仓库名称（随意用自己的选择替换 repo_name；它只需要包含你的用户名，这就是 get_full_repo_name() 函数所做的）

from huggingface_hub import Repository, get_full_repo_name

model_name = "marian-finetuned-kde4-en-to-fr-accelerate"
repo_name = get_full_repo_name(model_name)
repo_name

'sgugger/marian-finetuned-kde4-en-to-fr-accelerate'

然后我们可以在本地文件夹中克隆该仓库。如果它已经存在，该本地文件夹应该是我们正在使用的仓库的克隆

output_dir = "marian-finetuned-kde4-en-to-fr-accelerate"
repo = Repository(output_dir, clone_from=repo_name)

我们现在可以通过调用 repo.push_to_hub() 方法将保存在 output_dir 中的任何内容上传。这将帮助我们在每个迭代结束时上传中间模型。

训练循环

我们现在准备编写完整的训练循环。为了简化其评估部分，我们定义了这个 postprocess() 函数，它接受预测和标签，并将它们转换为我们的 metric 对象所期望的字符串列表

def postprocess(predictions, labels):
    predictions = predictions.cpu().numpy()
    labels = labels.cpu().numpy()

    decoded_preds = tokenizer.batch_decode(predictions, skip_special_tokens=True)

    # Replace -100 in the labels as we can't decode them.
    labels = np.where(labels != -100, labels, tokenizer.pad_token_id)
    decoded_labels = tokenizer.batch_decode(labels, skip_special_tokens=True)

    # Some simple post-processing
    decoded_preds = [pred.strip() for pred in decoded_preds]
    decoded_labels = [[label.strip()] for label in decoded_labels]
    return decoded_preds, decoded_labels

训练循环看起来很像第 2 节和第 3 章中的那些，在评估部分有一些区别——所以让我们专注于此！

需要注意的第一件事是我们使用 generate() 方法计算预测，但这在我们基础模型上的一个方法，而不是在 prepare() 方法中创建的包装模型 🤗 Accelerate 上。这就是为什么我们首先解包模型，然后调用此方法。

第二件事是，与令牌分类一样，两个进程可能将输入和标签填充到不同的形状，因此我们使用 accelerator.pad_across_processes() 在调用 gather() 方法之前使预测和标签具有相同的形状。如果我们不这样做，评估将要么出错，要么永远挂起。

from tqdm.auto import tqdm
import torch

progress_bar = tqdm(range(num_training_steps))

for epoch in range(num_train_epochs):
    # Training
    model.train()
    for batch in train_dataloader:
        outputs = model(**batch)
        loss = outputs.loss
        accelerator.backward(loss)

        optimizer.step()
        lr_scheduler.step()
        optimizer.zero_grad()
        progress_bar.update(1)

    # Evaluation
    model.eval()
    for batch in tqdm(eval_dataloader):
        with torch.no_grad():
            generated_tokens = accelerator.unwrap_model(model).generate(
                batch["input_ids"],
                attention_mask=batch["attention_mask"],
                max_length=128,
            )
        labels = batch["labels"]

        # Necessary to pad predictions and labels for being gathered
        generated_tokens = accelerator.pad_across_processes(
            generated_tokens, dim=1, pad_index=tokenizer.pad_token_id
        )
        labels = accelerator.pad_across_processes(labels, dim=1, pad_index=-100)

        predictions_gathered = accelerator.gather(generated_tokens)
        labels_gathered = accelerator.gather(labels)

        decoded_preds, decoded_labels = postprocess(predictions_gathered, labels_gathered)
        metric.add_batch(predictions=decoded_preds, references=decoded_labels)

    results = metric.compute()
    print(f"epoch {epoch}, BLEU score: {results['score']:.2f}")

    # Save and upload
    accelerator.wait_for_everyone()
    unwrapped_model = accelerator.unwrap_model(model)
    unwrapped_model.save_pretrained(output_dir, save_function=accelerator.save)
    if accelerator.is_main_process:
        tokenizer.save_pretrained(output_dir)
        repo.push_to_hub(
            commit_message=f"Training in progress epoch {epoch}", blocking=False
        )

epoch 0, BLEU score: 53.47
epoch 1, BLEU score: 54.24
epoch 2, BLEU score: 54.44

完成此操作后，你应该有一个模型，其结果与使用 Seq2SeqTrainer 训练的模型非常相似。你可以检查我们使用此代码训练的模型，位于 huggingface-course/marian-finetuned-kde4-en-to-fr-accelerate。如果你想测试对训练循环的任何调整，你可以直接通过编辑上面显示的代码来实现它们！

使用微调的模型

我们已经向您展示了如何在模型中心使用我们微调的模型和推理小部件。要将其在本地用于 `pipeline`，我们只需指定正确的模型标识符即可。

from transformers import pipeline

# Replace this with your own checkpoint
model_checkpoint = "huggingface-course/marian-finetuned-kde4-en-to-fr"
translator = pipeline("translation", model=model_checkpoint)
translator("Default to expanded threads")

[{'translation_text': 'Par défaut, développer les fils de discussion'}]

正如预期的那样，我们的预训练模型将其知识适应了我们对其进行微调的语料库，并且没有保留英文单词“threads”，而是将其翻译成法语官方版本。对于“plugin”也是如此。

translator(
    "Unable to import %1 using the OFX importer plugin. This file is not the correct format."
)

[{'translation_text': "Impossible d'importer %1 en utilisant le module externe d'importation OFX. Ce fichier n'est pas le bon format."}]

这是领域适应的另一个很好的例子！

✏️ **轮到你了！** 模型在包含你之前标识的“email”单词的样本中返回了什么？

NLP 课程

翻译