Accelerate documentation

Usando Local SGD com Accelerate

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Usando Local SGD com Accelerate

O Local SGD é uma técnica de treinamento distribuído em que os gradientes não são sincronizados a cada passo. Assim, cada processo atualiza sua própria versão dos pesos do modelo e, após um número determinado de passos, esses pesos são sincronizados por meio da média entre todos os processos. Isso melhora a eficiência de comunicação e pode levar a um aumento substancial na velocidade de treinamento, especialmente quando o computador não possui um interconector mais rápido, como o NVLink. Diferentemente da acumulação de gradientes (em que melhorar a eficiência de comunicação exige aumentar o tamanho efetivo do lote), o Local SGD não requer alterar o tamanho do lote ou a taxa de aprendizado / agendamento. No entanto, se necessário, o Local SGD também pode ser combinado com a acumulação de gradientes.

Neste tutorial, você verá como configurar rapidamente o Local SGD Accelerate. Em comparação com uma configuração padrão do Accelerate, isso requer apenas duas linhas de código a mais.

Este exemplo usará um loop de treinamento do PyTorch muito simplista que realiza acúmulo de gradiente a cada dois lotes:

device = "cuda"
model.to(device)

gradient_accumulation_steps = 2

for index, batch in enumerate(training_dataloader):
    inputs, targets = batch
    inputs = inputs.to(device)
    targets = targets.to(device)
    outputs = model(inputs)
    loss = loss_function(outputs, targets)
    loss = loss / gradient_accumulation_steps
    loss.backward()
    if (index + 1) % gradient_accumulation_steps == 0:
        optimizer.step()
        scheduler.step()
        optimizer.zero_grad()

Convertendo para o Accelerate

Primeiro, o código mostrado anteriormente será convertido para usar o Accelerate, sem um helper de LocalSGD ou de acúmulo de gradiente:

+ from accelerate import Accelerator
+ accelerator = Accelerator()

+ model, optimizer, training_dataloader, scheduler = accelerator.prepare(
+     model, optimizer, training_dataloader, scheduler
+ )

  for index, batch in enumerate(training_dataloader):
      inputs, targets = batch
-     inputs = inputs.to(device)
-     targets = targets.to(device)
      outputs = model(inputs)
      loss = loss_function(outputs, targets)
      loss = loss / gradient_accumulation_steps
+     accelerator.backward(loss)
      if (index+1) % gradient_accumulation_steps == 0:
          optimizer.step()
          scheduler.step()

Deixando o Accelerate lidar com a sincronização do modelo

O que resta agora é deixar que o Accelerate gerencie a sincronização dos parâmetros do modelo e a acumulação de gradientes para nós. Para simplificar, vamos assumir que precisamos sincronizar a cada 8 passos. Isso é alcançado adicionando uma declaração with LocalSGD e uma chamada local_sgd.step() após cada passo do otimizador:

+local_sgd_steps=8

+with LocalSGD(accelerator=accelerator, model=model, local_sgd_steps=8, enabled=True) as local_sgd:
    for batch in training_dataloader:
        with accelerator.accumulate(model):
            inputs, targets = batch
            outputs = model(inputs)
            loss = loss_function(outputs, targets)
            accelerator.backward(loss)
            optimizer.step()
            scheduler.step()
            optimizer.zero_grad()
+           local_sgd.step()

Por baixo dos panos, o código do Local SGD desativa a sincronização automática de gradientes (mas o acúmulo continua funcionando como esperado!). Em vez disso, ele faz a média dos parâmetros do modelo a cada local_sgd_steps passos (bem como no final do loop de treinamento).

Limitações

A implementação atual funciona apenas com treinamento básico multi-GPU (ou multi-CPU) sem, por exemplo, DeepSpeed.

Referências

Embora não saibamos as origens verdadeiras dessa abordagem simples, a ideia do SGD local é bastante antiga e remonta a pelo menos:

Zhang, J., De Sa, C., Mitliagkas, I., & Ré, C. (2016). Parallel SGD: When does averaging help?. arXiv preprint arXiv:1606.07365.

Atribuímos o termo Local SGD ao seguinte artigo (embora possam existir referências anteriores das quais não temos conhecimento).

Stich, Sebastian Urban. “Local SGD Converges Fast and Communicates Little.” ICLR 2019-International Conference on Learning Representations. No. CONF. 2019.

Update on GitHub