翻译自： Fine-tuning a model with the Trainer API 。

Transformers 提供了一个 Trainer 类，处理微调在数据集上提供的任何预训练模型。 完成所有数据预处理工作后，只需执行几个步骤即可定义 Trainer。 最困难的部分可能是准备运行 Trainer.train() 的环境，因为它在 CPU 上运行速度非常慢。 如果没有设置 GPU，可以在 Google Colab 上访问免费的 GPU 或 TPU。 下面的代码示例假设已经完成了数据预处理的操作:

                        
                          from datasets import load_dataset
from transformers import AutoTokenizer, DataCollatorWithPadding

raw_datasets = load_dataset("glue", "mrpc")
checkpoint = "bert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)

def tokenize_function(example):
    return tokenizer(example["sentence1"], example["sentence2"], truncation=True)

tokenized_datasets = raw_datasets.map(tokenize_function, batched=True)
data_collator = DataCollatorWithPadding(tokenizer=tokenizer)

                        
                      

map函数与DataCollatorWithPadding函数请查阅： Processing the data 。

Traning(训练)

定义 Trainer 之前的第一步是定义一个 TrainingArguments 类，该类将包含 Trainer 用于训练和评估的所有超参数。 必须提供的唯一参数是保存训练模型的目录以及checkpoint。 对于其余所有内容，可以保留默认值，这对于基本的微调应该非常有效.

                        
                          from transformers import TrainingArguments

training_args = TrainingArguments("test-trainer")

                        
                      

第二步是定义我们的模型。 使用 AutoModelForSequenceClassification 类，它带有两个标签:

                        
                          from transformers import AutoModelForSequenceClassification

model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)

                        
                      

一旦我们有了模型，我们就可以通过传递迄今为止构建的所有对象来定义 Trainer --- Model 、 training_args 、 training 和 validation datasets 、 data_collator 和 tokenizer :

                        
                          from transformers import Trainer

trainer = Trainer(
    model,
    training_args,
    train_dataset=tokenized_datasets["train"],
    eval_dataset=tokenized_datasets["validation"],
    data_collator=data_collator,
    tokenizer=tokenizer,
)

                        
                      

要在数据集上微调模型，我们只需调用训练器的 train() 方法:

                        
                          trainer.train()

                        
                      

这将开始微调（在 GPU 上应该需要几分钟）并每 500 步报告一次训练损失。 但是，它不会告诉你模型的表现有多好（或多差）。 这是因为:

1. 我们没有告诉训练器在训练期间通过将 evaluation_strategy 设置为“ steps ”（评估每个 eval_steps ）或“ epoch ”（在每个 epoch 结束时评估）来进行评估。
2. 我们没有为训练器提供 compute_metrics() 函数来在所述评估期间计算指标（否则评估只会打印损失，这不是一个非常直观的数字）。

Evaluation(评估)

让我们看看如何构建一个有用的 compute_metrics() 函数并在下次训练时使用它。 该函数必须采用 EvalPrediction 对象（这是一个带有预测字段和 label_ids 字段的命名元组），并将返回一个将字符串映射到浮点数的字典（字符串是返回的指标的名称，浮点数是它们的值）。 为了从我们的模型中获得一些预测，我们可以使用 Trainer.predict() 方法:

                        
                          predictions = trainer.predict(tokenized_datasets["validation"])
print(predictions.predictions.shape, predictions.label_ids.shape)

## 输出
(408, 2) (408,)

                        
                      

Predict() 方法的输出是另一个具有三个字段的命名元组：预测、label_ids 和指标。 指标字段将仅包含传递的数据集的损失，以及一些时间指标（预测所需的总时间和平均时间）。 一旦我们完成了 compute_metrics() 函数并将其传递给Trainer，该字段还将包含 compute_metrics() 返回的指标。 结果所展示的预测是一个形状为 408 x 2 的二维数组（408 是我们使用的数据集中的元素数量）。 这些是我们传递给 predict() 的数据集每个元素的logits。 为了将它们转换为可以与标签进行比较的预测，我们需要在第二个轴上获取最大值的索引:

                        
                          import numpy as np

preds = np.argmax(predictions.predictions, axis=-1)

                        
                      

我们现在可以将这些预测与标签进行比较。 为了构建我们的 compute_metric() 函数，我们将依赖于HuggingFace Evaluate库中的指标。 我们可以像加载数据集一样轻松地加载与 MRPC 数据集关联的指标，这次使用 evaluate.load() 函数。 返回的对象有一个 compute() 方法，我们可以用它来进行度量计算:

                        
                          import evaluate

metric = evaluate.load("glue", "mrpc")
metric.compute(predictions=preds, references=predictions.label_ids)

## 输出：
{'accuracy': 0.8578431372549019, 'f1': 0.8996539792387542}

                        
                      

获得的确切结果可能会有所不同，因为 Model Head 部分的随机初始化可能会改变它实现的指标。 在这里，我们可以看到我们的模型在验证集上的准确率为 85.78%，F1 得分为 89.97。 这些是用于评估 GLUE 基准的 MRPC 数据集结果的两个指标。 BERT 论文中的表格报告了基本模型的 F1 分数为 88.9，这是非case的模型，而我们目前使用的是case的模型，这解释了更好的结果。 将所有内容包装在一起，我们得到了 compute_metrics() 函数:

                        
                          def compute_metrics(eval_preds):
    metric = evaluate.load("glue", "mrpc")
    logits, labels = eval_preds
    predictions = np.argmax(logits, axis=-1)
    return metric.compute(predictions=predictions, references=labels)

                        
                      

为了查看它在每个epoch结束时报告指标的实际使用情况，下面是我们如何使用这个 compute_metrics() 函数定义一个新的 Trainer

                        
                          training_args = TrainingArguments("test-trainer", evaluation_strategy="epoch")
model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)

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

                        
                      

请注意，我们创建了一个新的 TrainingArguments ，其评估策略设置为“ epoch ”和一个新模型 - 否则，我们将继续训练已经训练过的模型。 要启动新的训练运行，我们执行:

                        
                          trainer.train()

                        
                      

这次，除了训练损失之外，它将在每个时期结束时报告验证损失和指标。 同样，由于模型的Model Head初始化，你达到的确切准确度/F1 分数可能与我们发现的有所不同，但它应该处于相同的范围内。 Trainer 将在多个 GPU 或 TPU 上开箱即用，并提供许多选项，例如混合精度训练（在训练参数中使用 fp16 = True）.

最后此篇关于聊聊预训练模型的微调的文章就讲到这里了,如果你想了解更多关于聊聊预训练模型的微调的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。