Accelerate documentation

Usar Local SGD con Accelerate

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Usar Local SGD con Accelerate

Local SGD es una técnica de entrenamiento distribuido en la que los gradientes no se sincronizan en cada paso. Por lo tanto, cada proceso actualiza su propia versión de los pesos del modelo y, tras un número determinado de pasos, estos pesos se sincronizan promediando entre todos los procesos. Esto mejora la eficiencia de comunicación y puede conducir a una aceleración sustancial del entrenamiento, especialmente cuando un equipo carece de un interconexión más rápida, como NVLink. A diferencia de la acumulación de gradientes (donde mejorar la eficiencia de comunicación requiere aumentar el tamaño de lote efectivo), Local SGD no requiere cambiar el tamaño de lote ni la tasa de aprendizaje / su programación. Sin embargo, si es necesario, Local SGD también puede combinarse con la acumulación de gradientes.

En este tutorial verás cómo configurar rápidamente Local SGD Accelerate. En comparación con una configuración estándar de Accelerate, esto requiere solo dos líneas de código adicionales.

Este ejemplo utilizará un bucle de entrenamiento de PyTorch muy simplista que realiza la acumulación de gradientes cada dos 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()

Convertirlo a Accelerate

Primero, el código mostrado anteriormente se convertirá para usar Accelerate sin un LocalSGD ni un helper de acumulación de gradientes:

+ 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()

Dejar que Accelerate gestione la sincronización del modelo

Lo único que queda ahora es dejar que Accelerate se encargue de la sincronización de los parámetros del modelo y de la acumulación de gradientes por nosotros. Por simplicidad, supongamos que necesitamos sincronizar cada 8 pasos. Esto se logra añadiendo una declaración with LocalSGD y una llamada local_sgd.step() después de cada paso del optimizador:

+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 debajo, el código de Local SGD desactiva la sincronización automática de gradientes (¡pero la acumulación sigue funcionando como se espera!). En su lugar, promedia los parámetros del modelo cada local_sgd_steps pasos (así como al final del bucle de entrenamiento).

Limitaciones

La implementación actual solo funciona con el entrenamiento básico multi-GPU (o multi-CPU) sin, por ejemplo, DeepSpeed.

Referencias

Aunque no conocemos los verdaderos orígenes de este enfoque sencillo, la idea de SGD local es bastante antigua y se remonta al menos a:

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

Atribuimos el término Local SGD al siguiente artículo (aunque podrían existir referencias anteriores de las que no tenemos conocimiento).

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

Update on GitHub