🤗 Transformers mette a disposizione la classe Trainer ottimizzata per addestrare modelli 🤗 Transformers, rendendo semplice iniziare l’addestramento senza scrivere manualmente il tuo ciclo di addestramento. L’API Trainer supporta un’ampia gamma di opzioni e funzionalità di addestramento come logging, gradient accumulation e mixed precision.

Inizia caricando il tuo modello e specificando il numero di etichette (labels) attese. Nel dataset Yelp Review dataset card, sai che ci sono cinque etichette:

>>> from transformers import AutoModelForSequenceClassification

>>> model = AutoModelForSequenceClassification.from_pretrained("bert-base-cased", num_labels=5)

Iperparametri per il training

Successivamente, crea una classe TrainingArguments contenente tutti gli iperparametri che si possono regore nonché le variabili per attivare le differenti opzioni di addestramento. Per questa esercitazione puoi iniziare con gli iperparametri di ddestramento predefiniti, ma sentiti libero di sperimentare per trovare la configurazione ottimale per te.

Specifica dove salvare i checkpoints del tuo addestramento:

>>> from transformers import TrainingArguments

>>> training_args = TrainingArguments(output_dir="test_trainer")

Metriche

Trainer non valuta automaticamente le performance del modello durante l’addestramento. Dovrai passare a Trainer una funzione che calcola e restituisce le metriche. La libreria 🤗 Datasets mette a disposizione una semplice funzione accuracy che puoi caricare con la funzione load_metric (guarda questa esercitazione per maggiori informazioni):

>>> import numpy as np
>>> from datasets import load_metric

>>> metric = load_metric("accuracy")

Richiama compute su metric per calcolare l’accuratezza delle tue previsioni. Prima di passare le tue previsioni a compute, hai bisogno di convertirle in logits (ricorda che tutti i modelli 🤗 Transformers restituiscono logits):

>>> def compute_metrics(eval_pred):
...     logits, labels = eval_pred
...     predictions = np.argmax(logits, axis=-1)
...     return metric.compute(predictions=predictions, references=labels)

Se preferisci monitorare le tue metriche di valutazione durante il fine-tuning, specifica il parametro evaluation_strategy nei tuoi training arguments per restituire le metriche di valutazione ad ogni epoca di addestramento:

>>> from transformers import TrainingArguments, Trainer

>>> training_args = TrainingArguments(output_dir="test_trainer", evaluation_strategy="epoch")

Trainer

Crea un oggetto Trainer col tuo modello, training arguments, dataset di training e test, e funzione di valutazione:

>>> trainer = Trainer(
...     model=model,
...     args=training_args,
...     train_dataset=small_train_dataset,
...     eval_dataset=small_eval_dataset,
...     compute_metrics=compute_metrics,
... )

Poi metti a punto il modello richiamando train():

>>> trainer.train()

I modelli 🤗 Transformers supportano anche l’addestramento in TensorFlow usando l’API di Keras.

Convertire dataset nel formato per TensorFlow

Il DefaultDataCollator assembla tensori in lotti su cui il modello si addestrerà. Assicurati di specificare di restituire tensori per TensorFlow in return_tensors:

>>> from transformers import DefaultDataCollator

>>> data_collator = DefaultDataCollator(return_tensors="tf")

Successivamente, converti i datasets tokenizzati in TensorFlow datasets con il metodo to_tf_dataset. Specifica il tuo input in columns e le tue etichette in label_cols:

>>> tf_train_dataset = small_train_dataset.to_tf_dataset(
...     columns=["attention_mask", "input_ids", "token_type_ids"],
...     label_cols=["labels"],
...     shuffle=True,
...     collate_fn=data_collator,
...     batch_size=8,
... )

>>> tf_validation_dataset = small_eval_dataset.to_tf_dataset(
...     columns=["attention_mask", "input_ids", "token_type_ids"],
...     label_cols=["labels"],
...     shuffle=False,
...     collate_fn=data_collator,
...     batch_size=8,
... )

Compilazione e addestramento

Carica un modello TensorFlow col numero atteso di etichette:

>>> import tensorflow as tf
>>> from transformers import TFAutoModelForSequenceClassification

>>> model = TFAutoModelForSequenceClassification.from_pretrained("bert-base-cased", num_labels=5)

Poi compila e fai il fine-tuning del tuo modello usando fit come faresti con qualsiasi altro modello di Keras:

>>> model.compile(
...     optimizer=tf.keras.optimizers.Adam(learning_rate=5e-5),
...     loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
...     metrics=tf.metrics.SparseCategoricalAccuracy(),
... )

>>> model.fit(tf_train_dataset, validation_data=tf_validation_dataset, epochs=3)

Trainer si occupa del ciclo di addestramento e ti consente di mettere a punto un modello con una sola riga di codice. Per chi preferisse scrivere un proprio ciclo di addestramento personale, puoi anche fare il fine-tuning di un modello 🤗 Transformers in PyTorch nativo.

A questo punto, potresti avere bisogno di riavviare il tuo notebook o eseguire il seguente codice per liberare un po’ di memoria:

del model
del pytorch_model
del trainer
torch.cuda.empty_cache()

Successivamente, postprocessa manualmente il tokenized_dataset per prepararlo ad essere allenato.

1. Rimuovi la colonna text perché il modello non accetta testo grezzo come input:

   Copied

   >>> tokenized_datasets = tokenized_datasets.remove_columns(["text"])

2. Rinomina la colonna label in labels perché il modello si aspetta che questo argomento si chiami labels:

   Copied

   >>> tokenized_datasets = tokenized_datasets.rename_column("label", "labels")

3. Imposta il formato del dataset per farti restituire tensori di PyTorch all’interno delle liste:

   Copied

   >>> tokenized_datasets.set_format("torch")

Poi crea un piccolo sottocampione del dataset come visto precedentemente per velocizzare il fine-tuning:

>>> small_train_dataset = tokenized_datasets["train"].shuffle(seed=42).select(range(1000))
>>> small_eval_dataset = tokenized_datasets["test"].shuffle(seed=42).select(range(1000))

DataLoader

Crea un DataLoader per i tuoi datasets di train e test così puoi iterare sui lotti di dati:

>>> from torch.utils.data import DataLoader

>>> train_dataloader = DataLoader(small_train_dataset, shuffle=True, batch_size=8)
>>> eval_dataloader = DataLoader(small_eval_dataset, batch_size=8)

Carica il tuo modello con il numero atteso di etichette:

>>> from transformers import AutoModelForSequenceClassification

>>> model = AutoModelForSequenceClassification.from_pretrained("bert-base-cased", num_labels=5)

Ottimizzatore e learning rate scheduler

Crea un ottimizzatore e il learning rate scheduler per fare il fine-tuning del modello. Usa l’ottimizzatore AdamW di PyTorch:

>>> from torch.optim import AdamW

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

Crea il learning rate scheduler predefinito da Trainer:

>>> from transformers import get_scheduler

>>> num_epochs = 3
>>> num_training_steps = num_epochs * len(train_dataloader)
>>> lr_scheduler = get_scheduler(
...     name="linear", optimizer=optimizer, num_warmup_steps=0, num_training_steps=num_training_steps
... )

Infine specifica come device da usare una GPU se ne hai una. Altrimenti, l’addestramento su una CPU può richiedere diverse ore invece di un paio di minuti.

>>> import torch

>>> device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
>>> model.to(device)

Ottimo, adesso possiamo addestrare! 🥳

Training loop

Per tenere traccia dei tuoi progressi durante l’addestramento, usa la libreria tqdm per aggiungere una progress bar sopra il numero dei passi di addestramento:

>>> from tqdm.auto import tqdm

>>> progress_bar = tqdm(range(num_training_steps))

>>> model.train()
>>> for epoch in range(num_epochs):
...     for batch in train_dataloader:
...         batch = {k: v.to(device) for k, v in batch.items()}
...         outputs = model(**batch)
...         loss = outputs.loss
...         loss.backward()

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

Metriche

Proprio come è necessario aggiungere una funzione di valutazione del Trainer, è necessario fare lo stesso quando si scrive il proprio ciclo di addestramento. Ma invece di calcolare e riportare la metrica alla fine di ogni epoca, questa volta accumulerai tutti i batch con add_batch e calcolerai la metrica alla fine.

>>> metric = load_metric("accuracy")
>>> model.eval()
>>> for batch in eval_dataloader:
...     batch = {k: v.to(device) for k, v in batch.items()}
...     with torch.no_grad():
...         outputs = model(**batch)

...     logits = outputs.logits
...     predictions = torch.argmax(logits, dim=-1)
...     metric.add_batch(predictions=predictions, references=batch["labels"])

>>> metric.compute()