Acumulación de gradientes

Entrenamiento eficiente de modelos de IA con PyTorch

Dennis Lee

Data Engineer, Amazon

Entrenamiento distribuido

Diagrama de flujo con los temas del curso: preparación de datos, entrenamiento distribuido, entrenamiento eficiente y optimizadores.

Entrenamiento eficiente

Diagrama de flujo con los temas del curso: preparación de datos, entrenamiento distribuido, entrenamiento eficiente y optimizadores.

Mejorar la eficiencia del entrenamiento

Iconos que representan eficiencia de memoria, de comunicación y computacional.

Mejorar la eficiencia del entrenamiento

Iconos que representan eficiencia de memoria, de comunicación y computacional.

Mejorar la eficiencia del entrenamiento

Iconos que representan eficiencia de memoria, de comunicación y computacional.

La acumulación de gradientes mejora la eficiencia de memoria

Iconos que representan eficiencia de memoria, de comunicación y computacional.

El problema de los lotes grandes

Lotes grandes: gradientes más estables y aprendizaje más rápido
La memoria de la GPU limita el tamaño de lote

Diagrama que muestra que lotes grandes pueden causar errores de memoria, mientras que lotes pequeños permiten completar el entrenamiento.

¿Cómo funciona la acumulación de gradientes?

Diagrama que muestra un lote grande dividido en lotes pequeños.

Acumulación de gradientes: suma gradientes en lotes pequeños
Entrena como si fuera un lote grande
Actualiza los parámetros tras sumar gradientes

Diagrama que muestra la acumulación como suma de gradientes de varios lotes.

PyTorch, Accelerator y Trainer

Gráfico que compara facilidad de uso vs. capacidad de personalización para PyTorch, Accelerator y Trainer.

PyTorch, Accelerator y Trainer

Gráfico que compara facilidad de uso vs. capacidad de personalización para PyTorch, Accelerator y Trainer.

PyTorch, Accelerator y Trainer

Gráfico que compara facilidad de uso vs. capacidad de personalización para PyTorch, Accelerator y Trainer.

Acumulación de gradientes con PyTorch

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

Diagrama que muestra la acumulación como suma de gradientes de varios lotes.

Acumulación de gradientes con 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

Diagrama que muestra la acumulación como suma de gradientes de varios lotes.

Acumulación de gradientes con 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

Diagrama que muestra la acumulación como suma de gradientes de varios lotes.

Acumulación de gradientes con 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()

Diagrama que muestra la acumulación como suma de gradientes de varios lotes.

Acumulación de gradientes con 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):

Diagrama que muestra la acumulación como suma de gradientes de varios lotes.

Acumulación de gradientes con 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()

Diagrama que muestra la acumulación como suma de gradientes de varios lotes.

De PyTorch a Accelerator

Gráfico que compara facilidad de uso vs. capacidad de personalización para PyTorch, Accelerator y Trainer.

De PyTorch a Accelerator

Gráfico que compara facilidad de uso vs. capacidad de personalización para PyTorch, Accelerator y Trainer.

Acumulación de gradientes con Accelerator

accelerator = \
    Accelerator(gradient_accumulation_steps=2)

for index, batch in enumerate(dataloader):

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

Diagrama que muestra la acumulación como suma de gradientes de varios lotes.

Acumulación de gradientes con 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

Diagrama que muestra la acumulación como suma de gradientes de varios lotes.

Acumulación de gradientes con 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

Diagrama que muestra la acumulación como suma de gradientes de varios lotes.

Acumulación de gradientes con 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)

Diagrama que muestra la acumulación como suma de gradientes de varios lotes.

Acumulación de gradientes con 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)

Diagrama que muestra la acumulación como suma de gradientes de varios lotes.

Acumulación de gradientes con 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()

Diagrama que muestra la acumulación como suma de gradientes de varios lotes.

De Accelerator a Trainer

Gráfico que compara facilidad de uso vs. capacidad de personalización para PyTorch, Accelerator y Trainer.

De Accelerator a Trainer

Gráfico que compara facilidad de uso vs. capacidad de personalización para PyTorch, Accelerator y Trainer.

Acumulación de gradientes con 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}

¡Vamos a practicar!

Entrenamiento eficiente de modelos de IA con PyTorch

Preparing Video For Download...