Ajuster les modèles avec Trainer

Entraîner efficacement des modèles d’IA avec PyTorch

Dennis Lee

Data Engineer, Amazon

Préparation des données

Schéma d’entraînement distribué montrant la réplication du modèle et le partitionnement des données.

Entraînement distribué

Organigramme des thèmes : préparation des données, entraînement distribué, entraînement efficace et optimiseurs.

Trainer et Accelerator

Graphique comparant la facilité d’usage et la personnalisation pour Accelerator et Trainer.

Trainer et Accelerator

Graphique comparant la facilité d’usage et la personnalisation pour Accelerator et Trainer.

Booster l’entraînement avec Trainer

Bibliothèque Trainer
```
from transformers import Trainer
```
Exécuter le modèle sur chaque appareil en parallèle
Accélérer l’entraînement, comme sur une chaîne de montage
Revoir les entrées : dataset, modèle, métriques
Développer une analyse de sentiment pour l’e-commerce

Image d’une chaîne de montage automobile, illustrant le traitement en parallèle.

Jeu de données d’avis produit (sentiment)

print(dataset)

DatasetDict({
    train: Dataset({
        features: ['Text', 'Label'],
        num_rows: 1000
    }), ...})

print(f'"{dataset["train"]["Text"][0]}": {dataset["train"]["Label"][0]}')

"I love this product!": positive

Convertir les étiquettes en entiers

def map_labels(example):
    if example["Label"] == "negative":
        return {"labels": 0}

    else:
        return {"labels": 1}

dataset = dataset.map(map_labels)

print(f'First label: {dataset["train"]["labels"][0]}')

First label: 1

Définir le tokenizer et le modèle

Charger le modèle et le tokenizer pré-entraînés :

model = AutoModelForSequenceClassification.from_pretrained("distilbert-base-uncased", 
                                                           num_labels=2)

tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")

Appliquer le tokenizer au champ text :

def encode(examples):

    return tokenizer(examples["Text"], padding="max_length", truncation=True, 
                      return_tensors="pt")

dataset = dataset.map(encode, batched=True)

print(f'The first tokenized review is {dataset["train"]["input_ids"][0]}.')

The first tokenized review is [101, 1045, 2293, 2023, 4031, 999, 102].

Définir les métriques d’évaluation

import evaluate


def compute_metrics(eval_predictions):

    load_accuracy = evaluate.load("accuracy")
    load_f1 = evaluate.load("f1")

    logits, labels = eval_predictions

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

    accuracy = load_accuracy.compute(predictions=predictions, references=labels)[
        "accuracy"
    ]

    f1 = load_f1.compute(predictions=predictions, references=labels)["f1"]

    return {"accuracy": accuracy, "f1": f1}

Arguments d’entraînement

output_dir : Où enregistrer le modèle
Spécifier les hyperparamètres (p. ex., learning_rate et weight_decay)
save_strategy : sauvegarder après chaque époque
evaluation_strategy : évaluer après chaque époque

from transformers import (
    TrainingArguments)

training_args = TrainingArguments(
    output_dir="output_folder",

    learning_rate=2e-5,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=16,
    num_train_epochs=2,
    weight_decay=0.01,

    save_strategy="epoch",
    evaluation_strategy="epoch",
)

Configuration de Trainer

from transformers import Trainer

trainer = Trainer(model=model,

                  args=training_args,

                  train_dataset=dataset["train"],
                  eval_dataset=dataset["validation"],

                  compute_metrics=compute_metrics)

trainer.train()

{'epoch': 1.0, 'eval_loss': 0.79, 'eval_accuracy': 0.00, 'eval_f1': 0.00}
{'epoch': 2.0, 'eval_loss': 0.65, 'eval_accuracy': 0.11, 'eval_f1': 0.15}

print(trainer.args.device)

cpu

Analyse de sentiment pour l’e-commerce

sample_review = "This product is amazing!"

input_ids = tokenizer.encode(sample_review, return_tensors='pt')
print(f"Tokenized review: {input_ids}")

Tokenized review: tensor([[ 101, 2023, 4031, 2003, 6429,  999,  102 ]])

Analyse de sentiment pour l’e-commerce

output = model(input_ids)
print(f"Output logits: {output.logits}")

Output logits: tensor([[ -0.0538, 0.1300 ]])

predicted_label = torch.argmax(output.logits, dim=1).item()
print(f"Predicted label: {predicted_label}")

Predicted label: 1

sentiment = "Negative" if predicted_label == 0 else "Positive"
print(f'The sentiment of the product review is "{sentiment}."')

The sentiment of the product review is "Positive."

Checkpoints avec Trainer

Reprendre depuis le dernier checkpoint, comme mettre un film en pause

trainer.train(resume_from_checkpoint=True)

{'epoch': 3.0, 'eval_loss': 0.29, 'eval_accuracy': 0.37, 'eval_f1': 0.51}
{'epoch': 4.0, 'eval_loss': 0.23, 'eval_accuracy': 0.46, 'eval_f1': 0.58}

Reprendre depuis un checkpoint précis dans le dossier de sortie

trainer.train(resume_from_checkpoint="model/checkpoint-1000")

Passons à la pratique !

Entraîner efficacement des modèles d’IA avec PyTorch