Accelerate documentation

Checkpointing

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v1.15.0).
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