Accelerate documentation

Checkpointing

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Checkpointing

Al entrenar un modelo de PyTorch con Accelerate, es posible que a menudo desee guardar y continuar un estado de entrenamiento. Para ello, es necesario guardar y cargar el modelo, el optimizador, los generadores de RNG y el GradScaler. Dentro de Accelerate hay dos funciones de conveniencia para lograrlo rápidamente:

  • Use save_state() para guardar todo lo mencionado anteriormente en una carpeta
  • Use load_state() para cargar todo lo que se guardó en una save_state anterior

Para personalizar aún más dónde y cómo se guardan los estados a través de save_state(), se puede utilizar la clase ProjectConfiguration. Por ejemplo, si automatic_checkpoint_naming está habilitado, cada checkpoint guardado se ubicará en Accelerator.project_dir/checkpoints/checkpoint_{checkpoint_number}.

Cabe señalar que se espera que esos estados provengan del mismo script de entrenamiento; no deben provenir de dos scripts separados.

  • Al utilizar register_for_checkpointing(), puede registrar objetos personalizados para que se almacenen o carguen automáticamente desde las dos funciones anteriores, siempre que el objeto tenga una funcionalidad state_dict y una load_state_dict. Esto podría incluir objetos como un programador de tasa de aprendizaje.

A continuación se muestra un ejemplo breve que utiliza el checkpointing para guardar y recargar un estado durante el entrenamiento:

from accelerate import Accelerator
import torch

accelerator = Accelerator(project_dir="my/save/path")

my_scheduler = torch.optim.lr_scheduler.StepLR(my_optimizer, step_size=1, gamma=0.99)
my_model, my_optimizer, my_training_dataloader = accelerator.prepare(my_model, my_optimizer, my_training_dataloader)

# Register the LR scheduler
accelerator.register_for_checkpointing(my_scheduler)

# Save the starting state
accelerator.save_state()

device = accelerator.device
my_model.to(device)

# Perform training
for epoch in range(num_epochs):
    for batch in my_training_dataloader:
        my_optimizer.zero_grad()
        inputs, targets = batch
        inputs = inputs.to(device)
        targets = targets.to(device)
        outputs = my_model(inputs)
        loss = my_loss_function(outputs, targets)
        accelerator.backward(loss)
        my_optimizer.step()
    my_scheduler.step()

# Restore the previous state
accelerator.load_state("my/save/path/checkpointing/checkpoint_0")

Restaurar el estado del DataLoader

Tras reanudar desde un punto de control, también puede ser deseable reanudar desde un punto específico del DataLoader activo si el estado se guardó a mitad de una época. Puedes usar skip_first_batches() para hacerlo.

from accelerate import Accelerator

accelerator = Accelerator(project_dir="my/save/path")

train_dataloader = accelerator.prepare(train_dataloader)
accelerator.load_state("my_state")

# Assume the checkpoint was saved 100 steps into the epoch
skipped_dataloader = accelerator.skip_first_batches(train_dataloader, 100)

# After the first iteration, go back to `train_dataloader`

# First epoch
for batch in skipped_dataloader:
    # Do something
    pass

# Second epoch
for batch in train_dataloader:
    # Do something
    pass
Update on GitHub