翻译

现在让我们深入研究翻译。这是另一个序列到序列任务，这意味着它是一个可以被表述为从一个序列到另一个序列的问题。从这个意义上说，这个问题与摘要非常接近，你可以将我们在这里看到的内容应用于其他序列到序列问题，例如：

风格迁移：创建一个模型，将特定风格的文本“翻译”成另一种风格（例如，从正式到随意，或从莎士比亚英语到现代英语）
生成式问答：创建一个模型，根据上下文生成问题的答案

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

在本节中，我们将在 KDE4 数据集上微调一个预训练的 Marian 模型，该模型用于将英语翻译成法语（因为许多 Hugging Face 员工都说这两种语言）。KDE4 数据集是 KDE 应用程序的本地化文件数据集。我们将使用的模型已经在从 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”。找到训练数据集中第一个使用这个单词的样本。它是如何翻译的？预训练模型如何翻译相同的英语句子？

处理数据

现在您应该已经知道如何操作了：所有文本都需要转换为 token ID 的集合，以便模型能够理解它们。对于这个任务，我们需要对输入和目标都进行 token 化。我们的首要任务是创建 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>']

正如我们所见，使用英语分词器预处理法语句子会导致更多的 token，因为分词器不认识任何法语单词（除了那些也出现在英语中的单词，如“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:。

⚠️ 我们不关心目标注意力掩码，因为模型不会期望它。相反，与填充 token 对应的标签应设置为 -100，以便在损失计算中忽略它们。这将在后面由我们的数据整理器完成，因为我们正在应用动态填充，但如果您在此处使用填充，您应该调整预处理函数以将所有对应于填充 token 的标签设置为 -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、注意力掩码和 token 类型 ID）。我们的标签也应该填充到标签中遇到的最大长度。而且，如前所述，用于填充标签的填充值应该是 -100，而不是分词器的填充 token，以确保这些填充值在损失计算中被忽略。

这一切都由 DataCollatorForSeq2Seq 完成。与 DataCollatorWithPadding 一样，它接受用于预处理输入的 tokenizer，但它也接受 model。这是因为此数据整理器还将负责准备解码器输入 ID，这些 ID 是标签的移位版本，开头有一个特殊 token。由于不同架构的这种移位略有不同，因此 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 并带有一个注意力掩码，确保它不使用它试图预测的 token 之后的 token，以加快训练速度。在推理期间，我们无法使用这些，因为我们没有标签，因此使用相同的设置评估我们的模型是个好主意。

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

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

BLEU 的一个弱点是它期望文本已经被标记化，这使得比较使用不同标记器的模型之间的分数变得困难。因此，目前翻译模型基准测试中最常用的指标是 SacreBLEU，它通过标准化标记化步骤来解决这个弱点（以及其他弱点）。要使用这个指标，我们首先需要安装 SacreBLEU 库：

!pip install sacrebleu

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

import evaluate

metric = evaluate.load("sacrebleu")

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

我们来试一个例子：

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（分词器会自动对填充 token 执行相同的操作）：

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，这样您就可以将结果上传到模型 Hub。笔记本中有一个方便的函数可以帮助您完成此操作：

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,
)

除了常用的超参数（如学习率、epoch 数量、批次大小和一些权重衰减）外，与前几节相比，这里还有一些变化：

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

请注意，您可以使用 hub_model_id 参数指定要推送到 Hub 的存储库全名（特别是，您必须使用此参数才能推送到组织）。例如，当我们推送到 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}

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

接下来是训练，这也需要一些时间：

trainer.train()

请注意，在训练过程中，每次模型保存（此处为每个 epoch），它都会在后台上传到 Hub。这样，如有必要，您将能够在另一台机器上恢复训练。

训练完成后，我们再次评估我们的模型——希望我们能在 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 还会草拟一份包含所有评估结果的模型卡片并将其上传。这份模型卡片包含元数据，有助于模型 Hub 选择用于推理演示的 widget。通常，无需进行任何说明，因为它可以通过模型类别推断出正确的 widget，但在这种情况下，相同的模型类别可以用于各种序列到序列问题，因此我们指定它是一个翻译模型：

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

此命令返回它刚刚提交的 URL，如果您想检查它：

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

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

如果您想更深入地了解训练循环，我们现在将向您展示如何使用 🤗 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 torch.optim 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,
)

最后，为了将我们的模型推送到 Hub，我们需要在一个工作文件夹中创建一个 Repository 对象。首先登录 Hugging Face Hub，如果您还没有登录的话。我们将根据我们想要给模型设置的模型 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 中的任何内容。这将帮助我们在每个 epoch 结束时上传中间模型。

训练循环

我们现在准备编写完整的训练循环。为了简化其评估部分，我们定义了这个 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() 方法来计算预测，但这是我们基础模型上的一个方法，而不是 🤗 Accelerate 在 prepare() 方法中创建的包装模型。这就是为什么我们首先解包模型，然后调用此方法。

第二点是，与token 分类一样，两个进程可能已将输入和标签填充到不同的形状，因此我们使用 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 处查看我们使用此代码训练的模型。如果您想测试训练循环的任何调整，可以直接通过编辑上面显示的代码来实现！

使用微调模型

我们已经向您展示了如何在模型 Hub 上使用我们微调过的模型进行推理。要在本地 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”这个词的样本上返回了什么？

< > 在 GitHub 上更新

LLM 课程

翻译