Accumulation de gradients

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

Dennis Lee

Data Engineer, Amazon

Entraînement distribué

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

Entraînement efficace

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

Améliorer l’efficacité d’entraînement

Icônes représentant l’efficacité mémoire, l’efficacité de communication et l’efficacité de calcul.

Améliorer l’efficacité d’entraînement

Icônes représentant l’efficacité mémoire, l’efficacité de communication et l’efficacité de calcul.

Améliorer l’efficacité d’entraînement

Icônes représentant l’efficacité mémoire, l’efficacité de communication et l’efficacité de calcul.

L’accumulation de gradients améliore l’efficacité mémoire

Icônes représentant l’efficacité mémoire, l’efficacité de communication et l’efficacité de calcul.

Le problème des grands lots

Grandes tailles de lot : gradients plus stables, apprentissage plus rapide
La mémoire GPU limite la taille des lots

Schéma montrant que de grands lots peuvent provoquer des erreurs de mémoire, tandis que de plus petits lots permettent de terminer l’entraînement.

Comment fonctionne l’accumulation de gradients ?

Schéma montrant un grand lot découpé en plus petits lots.

Accumulation de gradients : sommer les gradients sur de petits lots
Entraîner comme avec un grand lot effectif
Mettre à jour les paramètres après la somme

Schéma illustrant l’accumulation comme la somme des gradients de plusieurs lots.

PyTorch, Accelerator et Trainer

Graphique comparant facilité d’utilisation et capacité de personnalisation pour PyTorch, Accelerator et Trainer.

PyTorch, Accelerator et Trainer

Graphique comparant facilité d’utilisation et capacité de personnalisation pour PyTorch, Accelerator et Trainer.

PyTorch, Accelerator et Trainer

Graphique comparant facilité d’utilisation et capacité de personnalisation pour PyTorch, Accelerator et Trainer.

Accumulation de gradients avec PyTorch

for index, batch in enumerate(dataloader):
    inputs, targets = (batch["input_ids"], 
                       batch["labels"])
    inputs, targets = (inputs.to(device), 
                       targets.to(device))

Schéma illustrant l’accumulation comme la somme des gradients de plusieurs lots.

Accumulation de gradients avec PyTorch

for index, batch in enumerate(dataloader):
    inputs, targets = (batch["input_ids"], 
                       batch["labels"])
    inputs, targets = (inputs.to(device), 
                       targets.to(device))
    outputs = model(inputs, labels=targets)
    loss = outputs.loss

Schéma illustrant l’accumulation comme la somme des gradients de plusieurs lots.

Accumulation de gradients avec PyTorch

for index, batch in enumerate(dataloader):
    inputs, targets = (batch["input_ids"], 
                       batch["labels"])
    inputs, targets = (inputs.to(device), 
                       targets.to(device))
    outputs = model(inputs, labels=targets)
    loss = outputs.loss
    loss = loss / gradient_accumulation_steps

Schéma illustrant l’accumulation comme la somme des gradients de plusieurs lots.

Accumulation de gradients avec PyTorch

for index, batch in enumerate(dataloader):
    inputs, targets = (batch["input_ids"], 
                       batch["labels"])
    inputs, targets = (inputs.to(device), 
                       targets.to(device))
    outputs = model(inputs, labels=targets)
    loss = outputs.loss
    loss = loss / gradient_accumulation_steps
    loss.backward()

Schéma illustrant l’accumulation comme la somme des gradients de plusieurs lots.

Accumulation de gradients avec PyTorch

for index, batch in enumerate(dataloader):
    inputs, targets = (batch["input_ids"], 
                       batch["labels"])
    inputs, targets = (inputs.to(device), 
                       targets.to(device))
    outputs = model(inputs, labels=targets)
    loss = outputs.loss
    loss = loss / gradient_accumulation_steps
    loss.backward()
    if ((index + 1) 
        % gradient_accumulation_steps == 0):

Schéma illustrant l’accumulation comme la somme des gradients de plusieurs lots.

Accumulation de gradients avec PyTorch

for index, batch in enumerate(dataloader):
    inputs, targets = (batch["input_ids"], 
                       batch["labels"])
    inputs, targets = (inputs.to(device), 
                       targets.to(device))
    outputs = model(inputs, labels=targets)
    loss = outputs.loss
    loss = loss / gradient_accumulation_steps
    loss.backward()
    if ((index + 1) 
        % gradient_accumulation_steps == 0):
        optimizer.step()
        lr_scheduler.step()
        optimizer.zero_grad()

Schéma illustrant l’accumulation comme la somme des gradients de plusieurs lots.

De PyTorch à Accelerator

Graphique comparant facilité d’utilisation et capacité de personnalisation pour PyTorch, Accelerator et Trainer.

De PyTorch à Accelerator

Graphique comparant facilité d’utilisation et capacité de personnalisation pour PyTorch, Accelerator et Trainer.

Accumulation de gradients avec Accelerator

accelerator = \
    Accelerator(gradient_accumulation_steps=2)

for index, batch in enumerate(dataloader):

        inputs, targets = (batch["input_ids"],
                           batch["labels"])

Schéma illustrant l’accumulation comme la somme des gradients de plusieurs lots.

Accumulation de gradients avec Accelerator

accelerator = \
    Accelerator(gradient_accumulation_steps=2)

for index, batch in enumerate(dataloader):

        inputs, targets = (batch["input_ids"],
                           batch["labels"])
        outputs = model(inputs, 
                        labels=targets)
        loss = outputs.loss

Schéma illustrant l’accumulation comme la somme des gradients de plusieurs lots.

Accumulation de gradients avec Accelerator

accelerator = \
    Accelerator(gradient_accumulation_steps=2)

for index, batch in enumerate(dataloader):
    with accelerator.accumulate(model):
        inputs, targets = (batch["input_ids"],
                           batch["labels"])
        outputs = model(inputs, 
                        labels=targets)
        loss = outputs.loss

Schéma illustrant l’accumulation comme la somme des gradients de plusieurs lots.

Accumulation de gradients avec Accelerator

accelerator = \
    Accelerator(gradient_accumulation_steps=2)

for index, batch in enumerate(dataloader):
    with accelerator.accumulate(model):
        inputs, targets = (batch["input_ids"],
                           batch["labels"])
        outputs = model(inputs, 
                        labels=targets)
        loss = outputs.loss
        accelerator.backward(loss)

Schéma illustrant l’accumulation comme la somme des gradients de plusieurs lots.

Accumulation de gradients avec Accelerator

accelerator = \
    Accelerator(gradient_accumulation_steps=2)

for index, batch in enumerate(dataloader):
    with accelerator.accumulate(model):
        inputs, targets = (batch["input_ids"],
                           batch["labels"])
        outputs = model(inputs, 
                        labels=targets)
        loss = outputs.loss
        accelerator.backward(loss)

Schéma illustrant l’accumulation comme la somme des gradients de plusieurs lots.

Accumulation de gradients avec Accelerator

accelerator = \
    Accelerator(gradient_accumulation_steps=2)

for index, batch in enumerate(dataloader):
    with accelerator.accumulate(model):
        inputs, targets = (batch["input_ids"],
                           batch["labels"])
        outputs = model(inputs, 
                        labels=targets)
        loss = outputs.loss
        accelerator.backward(loss)
        optimizer.step()
        lr_scheduler.step()
        optimizer.zero_grad()

Schéma illustrant l’accumulation comme la somme des gradients de plusieurs lots.

D’Accelerator à Trainer

Graphique comparant facilité d’utilisation et capacité de personnalisation pour PyTorch, Accelerator et Trainer.

D’Accelerator à Trainer

Graphique comparant facilité d’utilisation et capacité de personnalisation pour PyTorch, Accelerator et Trainer.

Accumulation de gradients avec Trainer

training_args = TrainingArguments(output_dir="./results",
                                  evaluation_strategy="epoch",
                                  gradient_accumulation_steps=2)

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.73, 'eval_accuracy': 0.03, 'eval_f1': 0.05}
{'epoch': 2.0, 'eval_loss': 0.68, 'eval_accuracy': 0.19, 'eval_f1': 0.25}

Passons à la pratique !

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

Preparing Video For Download...