Entraîner des modèles avec Accelerator

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

Dennis Lee

Data Engineer, Amazon

Trainer et Accelerator

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

Boucles d’entraînement personnalisées

Trainer : pas de boucles d’entraînement personnalisées
Certaines tâches avancées en IA générative nécessitent deux réseaux

Image d’un réseau antagoniste génératif.

¹ https://www.aitude.com/basics-of-generative-adversarial-network-model/

Trainer et Accelerator

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

Modifier une boucle d’entraînement basique

for batch in dataloader:

    optimizer.zero_grad()

    inputs, targets = batch
    inputs = inputs.to(device)
    targets = targets.to(device)

    outputs = model(inputs)

    loss = outputs.loss

    loss.backward()

    optimizer.step()
    scheduler.step()

Remettre les gradients à zéro
Déplacer les données vers un appareil : .to(device)
Effectuer le passage avant
Calculer la perte cross-entropy
Calculer les gradients (rétropropagation)
Mettre à jour les paramètres et le taux d’apprentissage

Créer un objet Accelerator

Accelerator offre une interface pour l’entraînement distribué

from accelerate import Accelerator
accelerator = Accelerator(
    device_placement=True
)

device_placement (bool, par défaut True) : gère automatiquement le placement sur l’appareil

Définir le modèle et l’optimiseur

Charger un modèle préentraîné

from transformers import AutoModelForSequenceClassification

model = AutoModelForSequenceClassification.from_pretrained(
    "distilbert-base-cased", return_dict=True)

Optimiser les paramètres avec Adam

from torch.optim import Adam

optimizer = Adam(params=model.parameters(), lr=2e-5)

Définir le scheduler

from transformers import get_linear_schedule_with_warmup

lr_scheduler = get_linear_schedule_with_warmup(
      optimizer=optimizer,

      num_warmup_steps=num_warmup_steps,

      num_training_steps=num_training_steps)

optimizer (obj) : optimiseur PyTorch, p. ex. Adam
num_warmup_steps (int) : étapes d’augmentation linéaire du lr, définir à int(num_training_steps * 0.1)
num_training_steps (int) : étapes totales, définir à len(train_dataloader) * num_epochs

Préparer le modèle pour un entraînement efficace

La méthode prepare gère le placement sur l’appareil

model, optimizer, dataloader, lr_scheduler = \
    accelerator.prepare(model,

                        optimizer,

                        dataloader,

                        lr_scheduler)

Construire une boucle d’entraînement avec Accelerator

for batch in dataloader:

    optimizer.zero_grad()

    inputs, targets = batch
    inputs = inputs.to(device)
    targets = targets.to(device)

Remettre les gradients à zéro
Données déjà déplacées vers l’appareil

Construire une boucle d’entraînement avec Accelerator

for batch in dataloader:

    optimizer.zero_grad()

    inputs, targets = batch

Remettre les gradients à zéro
Données déjà déplacées vers l’appareil
Supprimer les lignes qui déplacent manuellement les données

Construire une boucle d’entraînement avec Accelerator

for batch in dataloader:

    optimizer.zero_grad()

    inputs, targets = batch

    outputs = model(inputs)

    loss = outputs.loss
    loss.backward()

Remettre les gradients à zéro
Données déjà déplacées vers l’appareil
Supprimer les lignes qui déplacent manuellement les données
Effectuer un passage avant
Calculer la perte cross-entropy et les gradients

Construire une boucle d’entraînement avec Accelerator

for batch in dataloader:

    optimizer.zero_grad()

    inputs, targets = batch

    outputs = model(inputs)
    loss = outputs.loss

    accelerator.backward(loss)

    optimizer.step()
    scheduler.step()

Remettre les gradients à zéro
Données déjà déplacées vers l’appareil
Supprimer les lignes qui déplacent manuellement les données
Effectuer un passage avant
Calculer la perte cross-entropy et les gradients
Remplacer loss.backward par accelerator
Mettre à jour les paramètres et le taux d’apprentissage

Résumé des changements

Avant Accelerator

Déplacer manuellement les données vers les appareils
- inputs.to(device)
- targets.to(device)
Calculer les gradients avec loss.backward()

Avec Accelerator

Placement automatique et parallélisme des données
- accelerator.prepare(model)
- accelerator.prepare(dataloader)
Synchronisation des gradients via accelerator.backward(loss)
Boucle personnalisable
Convivial, indépendant du matériel, extensible et maintenable

Passons à la pratique !

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