Évaluer des modèles avec Accelerator

Entraînement efficace de 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
- Normalisation par lot

Dropout et normalisation par lot Un schéma d’un réseau neuronal à plusieurs couches : entrée, couches cachées et sortie. Le dropout est appliqué aux couches cachées pour éviter le surapprentissage, et la normalisation par lot 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
- Normalisation par lot
Le mode évaluation désactive ces couches
model.eval() active le mode évaluation

Désactiver les gradients avec torch.no_grad()

L’entraînement requiert le calcul de gradients
torch.no_grad() désactive les gradients
Appelez model.eval et torch.no_grad :

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

Calcul des gradients en rétropropagation Un schéma d’un réseau neuronal illustrant la rétropropagation, où les gradients sont calculés à chaque couche pour ajuster les poids. Il montre comment les erreurs se propagent de la sortie vers l’arrière à travers les couches cachées pour mettre à jour les poids par descente de gradient.

Préparer un ensemble de validation

Charger l’ensemble de validation MRPC

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

Tokeniser l’ensemble 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 entraînement et validation
D’abord, exécuter le modèle en mode entraînement
Puis en mode évaluation et consigner les métriques après

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}")

Métriques d’évaluation : 
{'accuracy': 0.81, 'f1': 0.77}

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

Outils de suivi : notebooks de journalisation; ex. TensorBoard et MLflow
log_with : utiliser tous les outils de suivi d’expériences
.init_trackers() : initialiser les outils de suivi
.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înement efficace de modèles d’IA avec PyTorch