Évaluer les modèles avec Accelerator

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

Dennis Lee

Data Engineer, Amazon

Pourquoi passer un modèle en mode évaluation ?

Mode entraînement
- Dropout : met des neurones à zéro
- Batch normalization

Dropout et batch normalization Schéma d’un réseau de neurones à plusieurs couches (entrée, cachées, sortie). Le dropout s’applique aux couches cachées pour éviter le surapprentissage, et la batch normalization normalise la sortie de chaque couche avant l’activation.

Pourquoi passer un modèle en mode évaluation ?

Mode entraînement
- Dropout : met des neurones à zéro
- Batch normalization
Le mode évaluation désactive ces couches
model.eval() active le mode évaluation

Désactiver les gradients avec torch.no_grad()

L’entraînement nécessite le calcul des gradients
torch.no_grad() désactive les gradients
Appeler model.eval et torch.no_grad :

model.eval()
with torch.no_grad():
    outputs = model(**inputs)

Calcul des gradients en rétropropagation Schéma d’un réseau de neurones illustrant la rétropropagation : les gradients sont calculés à chaque couche pour ajuster les poids. Les erreurs sont propagées de la sortie vers l’arrière à travers les couches cachées pour mettre à jour les poids par descente de gradient.

Préparer un jeu de validation

Charger la fraction de validation du jeu de données MRPC

validation_dataset = load_dataset("glue", "mrpc", split="validation")

Tokeniser le jeu de validation

def encode(examples):
    return tokenizer(examples["sentence1"], 
                      examples["sentence2"],
                      truncation=True,
                      padding="max_length")

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

Cycle d’une époque : boucles d’entraînement et d’évaluation

À chaque époque, itérer sur les jeux d’entraînement et de validation
Exécuter d’abord le modèle en mode entraînement
Puis en mode évaluation et consigner les métriques après l’évaluation

for epoch in range(num_epochs):

    model.train()
    for step, batch in enumerate(train_dataloader):
        # Perform training step

    model.eval()
    for step, batch in enumerate(eval_dataloader):
        # Perform evaluation step

    # Log evaluation metrics

Dans la boucle d’évaluation

metric = evaluate.load("glue", "mrpc")
model.eval()
for step, batch in enumerate(eval_dataloader):

    with torch.no_grad():
        outputs = model(**batch)
    predictions = outputs.logits.argmax(dim=-1)

    predictions, references = accelerator.gather_for_metrics((predictions, batch["labels"]))

    metric.add_batch(predictions=predictions, references=references)

eval_metric = metric.compute()

print(f"Eval metrics: \n{eval_metric}")

Eval metrics: 
{'accuracy': 0.81, 'f1': 0.77}

Consigner les métriques après l’évaluation

Outils de suivi : notebooks qui consignent des métriques ; ex. TensorBoard et MLflow
log_with : utiliser tous les outils de suivi d’expériences
.init_trackers() : initialiser les outils
.log() : suivre accuracy, f1, epoch
.end_training() : terminer le suivi

accelerator = Accelerator(project_dir=".",
                          log_with="all")

accelerator.init_trackers("my_project")


for epoch in range(num_epochs):
    # Training loop is here
    # Evaluation loop is here
    accelerator.log({

        "accuracy": eval_metric["accuracy"],
        "f1": eval_metric["f1"],

    }, step=epoch)


accelerator.end_training()

Passons à la pratique !

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