Accelerate documentation

Checkpointing

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Checkpointing

Ao treinar um modelo do PyTorch com o Accelerate, você frequentemente pode querer salvar e continuar um estado de treinamento. Para isso, é necessário salvar e carregar o modelo, o otimizador, os geradores de RNG e o GradScaler. Dentro do Accelerate, há duas funções de conveniência para fazer isso rapidamente:

  • Use save_state() para salvar tudo mencionado acima em um local de pasta
  • Use load_state() para carregar tudo que foi armazenado em um save_state anterior

Para personalizar ainda mais onde e como os estados são salvos por meio de save_state(), a classe ProjectConfiguration pode ser utilizada. Por exemplo, se automatic_checkpoint_naming estiver habilitado, cada checkpoint salvo será localizado em Accelerator.project_dir/checkpoints/checkpoint_{checkpoint_number}.

Deve-se observar que a expectativa é de que esses estados provenham do mesmo script de treinamento; eles não devem vir de dois scripts separados.

  • Ao usar register_for_checkpointing(), você pode registrar objetos personalizados para serem armazenados ou carregados automaticamente pelas duas funções anteriores, desde que o objeto tenha uma funcionalidade state_dict e uma funcionalidade load_state_dict. Isso pode incluir objetos como um agendador de taxa de aprendizado.

Abaixo está um breve exemplo usando checkpointing para salvar e recarregar um estado durante o treinamento:

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")

Restaurando o estado do DataLoader

Após retomar de um checkpoint, também pode ser desejável retomar de um ponto específico no DataLoader ativo se o estado foi salvo no meio de uma época. Você pode usar skip_first_batches() para fazer isso.

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