Accelerate documentation
Checkpointing
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_stateanterior
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_dicty unaload_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