Accelerate documentation

Ganchos de comunicación de DDP

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Ganchos de comunicación de DDP

Los hooks de comunicación de Distributed Data Parallel (DDP) proporcionan una interfaz genérica para controlar cómo se comunican los gradientes entre workers, reemplazando el allreduce estándar en DistributedDataParallel. Se incluyen algunos hooks de comunicación integrados, y los usuarios pueden aplicar fácilmente cualquiera de estos hooks para optimizar la comunicación.

  • Hook de compresión FP16: comprime los gradientes al convertirlos a formato de punto flotante de media precisión (torch.float16), reduciendo la sobrecarga de comunicación.
  • Hook de compresión BF16: Similar a FP16, pero utiliza el formato Brain Floating Point (torch.bfloat16), que puede ser más eficiente en cierto hardware.
  • PowerSGD Hook: un algoritmo avanzado de compresión de gradientes que ofrece altas tasas de compresión y puede acelerar el entrenamiento distribuido limitado por el ancho de banda.

En este tutorial, verás cómo configurar rápidamente los hooks de comunicación de DDP y realizar el entrenamiento con las utilidades proporcionadas en Accelerate, ¡lo cual puede ser tan simple como añadir una sola línea de código nueva! Esto demuestra cómo usar los hooks de comunicación de DDP para optimizar la comunicación de gradientes en el entrenamiento distribuido con la librería Accelerate.

Hook de compresión FP16

PyTorch
Accelerate
import torch
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.distributed.algorithms.ddp_comm_hooks import default_hooks
from accelerate.test_utils.testing import get_backend

device_type, _, _ = get_backend()
device_id = getattr(torch, device_type, torch.cuda).current_device()

class MyModel(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.layer = torch.nn.Linear(10, 10)

    def forward(self, x):
        return self.layer(x)

model = MyModel()
model = DDP(model, device_ids=[device_id])
model.register_comm_hook(state=None, hook=default_hooks.fp16_compress_hook)

# Training loop
for data, targets in data_loader:
    outputs = model(data)
    loss = criterion(outputs, targets)
    loss.backward()
    optimizer.step()
    optimizer.zero_grad()

Hook de compresión BF16

La API del hook de compresión BF16 es experimental y requiere una versión de NCCL posterior a la 2.9.6.

PyTorch
Accelerate
import torch
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.distributed.algorithms.ddp_comm_hooks import default_hooks
from accelerate.test_utils.testing import get_backend

device_type, _, _ = get_backend()
device_id = getattr(torch, device_type, torch.cuda).current_device()

class MyModel(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.layer = torch.nn.Linear(10, 10)

    def forward(self, x):
        return self.layer(x)

model = MyModel()
model = DDP(model, device_ids=[device_id])
model.register_comm_hook(state=None, hook=default_hooks.bf16_compress_hook)

# Training loop
for data, targets in data_loader:
    outputs = model(data)
    loss = criterion(outputs, targets)
    loss.backward()
    optimizer.step()
    optimizer.zero_grad()

PowerSGD Hook

PowerSGD generalmente requiere memoria adicional del mismo tamaño que los gradientes del modelo para habilitar la retroalimentación de error, lo que puede compensar la comunicación comprimida sesgada y mejorar la precisión.

PyTorch
Accelerate
import torch
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.distributed.algorithms.ddp_comm_hooks import powerSGD_hook
from accelerate.test_utils.testing import get_backend

device_type, _, _ = get_backend()
device_id = getattr(torch, device_type, torch.cuda).current_device()

class MyModel(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.layer = torch.nn.Linear(10, 10)

    def forward(self, x):
        return self.layer(x)

model = MyModel()
model = DDP(model, device_ids=[device_id])
state = powerSGD_hook.PowerSGDState(process_group=None)
model.register_comm_hook(state=state, hook=powerSGD_hook.powerSGD_hook)

# Training loop
for data, targets in data_loader:
    outputs = model(data)
    loss = criterion(outputs, targets)
    loss.backward()
    optimizer.step()
    optimizer.zero_grad()

Utilidades de hooks de comunicación de DDP

Hay dos utilidades adicionales para admitir funcionalidades opcionales con los hooks de comunicación.

comm_wrapper

comm_wrapper es una opción para envolver un hook de comunicación con funcionalidad adicional. Por ejemplo, se puede usar para combinar la compresión FP16 con otras estrategias de comunicación. Los wrappers admitidos actualmente son no, fp16 y bf16.

from accelerate import Accelerator, DDPCommunicationHookType, DistributedDataParallelKwargs
import torch

class MyModel(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.layer = torch.nn.Linear(10, 10)

    def forward(self, x):
        return self.layer(x)

# DDP Communication Hook setup
ddp_kwargs = DistributedDataParallelKwargs(
    comm_hook=DDPCommunicationHookType.POWER_SGD,
    comm_wrapper=DDPCommunicationHookType.FP16
)
accelerator = Accelerator(kwargs_handlers=[ddp_kwargs])

model = MyModel()
optimizer = torch.optim.Adam(model.parameters())
data_loader = DataLoader(dataset, batch_size=16)

model, optimizer, data_loader = accelerator.prepare(model, optimizer, data_loader)

# Training loop
for data, targets in data_loader:
    outputs = model(data)
    loss = criterion(outputs, targets)
    accelerator.backward(loss)
    optimizer.step()
    optimizer.zero_grad()

comm_state_option

comm_state_option permite pasar información adicional de estado requerida por ciertos hooks de comunicación. Esto es especialmente útil para hooks con estado, como PowerSGD, que requieren mantener hiperparámetros y estados internos a lo largo de los pasos de entrenamiento. A continuación se muestra un ejemplo que ilustra el uso de comm_state_option con el hook PowerSGD.

from accelerate import Accelerator, DDPCommunicationHookType, DistributedDataParallelKwargs
import torch

class MyModel(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.layer = torch.nn.Linear(10, 10)

    def forward(self, x):
        return self.layer(x)

# DDP Communication Hook setup
ddp_kwargs = DistributedDataParallelKwargs(
    comm_hook=DDPCommunicationHookType.POWER_SGD,
    comm_state_option={"matrix_approximation_rank": 2}
)
accelerator = Accelerator(kwargs_handlers=[ddp_kwargs])

model = MyModel()
optimizer = torch.optim.Adam(model.parameters())
data_loader = DataLoader(dataset, batch_size=16)

model, optimizer, data_loader = accelerator.prepare(model, optimizer, data_loader)

# Training loop
for data, targets in data_loader:
    outputs = model(data)
    loss = criterion(outputs, targets)
    accelerator.backward(loss)
    optimizer.step()
    optimizer.zero_grad()

Para un uso más avanzado y ganchos adicionales, consulte la documentación de ganchos de comunicación de PyTorch DDP.

Update on GitHub