Accumulation de gradients

Entraînement efficace de 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 causent des erreurs de mémoire, alors que de plus petits lots permettent d’achever l’entraînement.

Comment fonctionne l’accumulation de gradients?

Schéma montrant un grand lot scindé 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 la facilité d’usage et la personnalisation pour PyTorch, Accelerator et Trainer.

PyTorch, Accelerator et Trainer

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

PyTorch, Accelerator et Trainer

Graphique comparant la facilité d’usage et la 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 la facilité d’usage et la personnalisation pour PyTorch, Accelerator et Trainer.

De PyTorch à Accelerator

Graphique comparant la facilité d’usage et la 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 la facilité d’usage et la personnalisation pour PyTorch, Accelerator et Trainer.

D’Accelerator à Trainer

Graphique comparant la facilité d’usage et la 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înement efficace de modèles d’IA avec PyTorch

Preparing Video For Download...