Accelerate documentation

Ganchos de Comunicação DDP

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Ganchos de Comunicação DDP

Os hooks de comunicação do Distributed Data Parallel (DDP) fornecem uma interface genérica para controlar como os gradientes são comunicados entre os workers, substituindo o allreduce padrão em DistributedDataParallel. Alguns hooks de comunicação integrados são fornecidos, e os usuários podem aplicar facilmente qualquer um desses hooks para otimizar a comunicação.

  • Hook de compressão FP16: Comprime os gradientes convertendo-os para o formato de ponto flutuante de meia precisão (torch.float16), reduzindo a sobrecarga de comunicação.
  • Hook de compressão BF16: Similar ao FP16, mas usa o formato Brain Floating Point (torch.bfloat16), que pode ser mais eficiente em determinados hardwares.
  • PowerSGD Hook: Um algoritmo avançado de compressão de gradiente que oferece altas taxas de compressão e pode acelerar o treinamento distribuído limitado por largura de banda.

Neste tutorial, você verá como configurar rapidamente os hooks de comunicação do DDP e executar o treinamento com as utilidades fornecidas no Accelerate, o que pode ser tão simples quanto adicionar apenas uma nova linha de código! Isso demonstra como usar os hooks de comunicação do DDP para otimizar a comunicação de gradientes no treinamento distribuído com a biblioteca Accelerate.

Hook de compressão 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 compressão BF16

A API do Hook de Compressão BF16 é experimental e requer uma versão do NCCL posterior à 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

O PowerSGD geralmente requer memória extra do mesmo tamanho que os gradientes do modelo para habilitar o feedback de erro, o que pode compensar a comunicação comprimida com viés e melhorar a precisão.

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

Utilitários de hooks de comunicação DDP

Há duas utilidades adicionais para suportar funcionalidades opcionais com os hooks de comunicação.

comm_wrapper

comm_wrapper é uma opção para encapsular um hook de comunicação com funcionalidades adicionais. Por exemplo, pode ser usado para combinar a compressão FP16 com outras estratégias de comunicação. Os wrappers atualmente suportados são no, fp16 e 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 passar informações adicionais de estado necessárias para determinados hooks de comunicação. Isso é particularmente útil para hooks com estado, como PowerSGD, que exigem a manutenção de hiperparâmetros e estados internos entre as etapas de treinamento. Abaixo está um exemplo que mostra o uso de comm_state_option com o 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 um uso mais avançado e hooks adicionais, consulte a documentação de Hooks de Comunicação do PyTorch DDP.

Update on GitHub