DistributedDataParallel (DDP)
Grupos de processos, dist.init_process_group, DistributedSampler e sincronização de gradientes.
DistributedDataParallel (DDP) é uma aula grátis de Learn AI with Python no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn AI with Python, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn AI with Python inclui 4 aulas no total.
O que é DDP
DistributedDataParallel (DDP) é a abordagem de alto desempenho do PyTorch para treinamento com paralelismo de dados. Ela inicia um processo por GPU, cada um contendo uma réplica completa do modelo, e sincroniza os gradientes de forma eficiente. DDP escala quase linearmente entre GPUs e máquinas.
O grupo de processos
DDP coordena os processos por meio de um grupo de processos. Cada processo recebe uma posição exclusiva e conhece o número total de processos. Eles se comunicam por meio de um backend; em GPUs NVIDIA, esse backend é nccl.
init_process_group
Cada processo começa entrando no grupo. dist.init_process_group com backend="nccl" configura a comunicação entre GPUs.
import torch.distributed as dist
import os
dist.init_process_group(backend="nccl")
rank = dist.get_rank()
world_size = dist.get_world_size()Atribuindo o dispositivo
Cada processo deve ser responsável por uma GPU. Use a posição local para definir o dispositivo, de modo que o processo 0 use cuda:0, o processo 1 use cuda:1 e assim por diante.
local_rank = int(os.environ["LOCAL_RANK"])
torch.cuda.set_device(local_rank)
device = torch.device("cuda", local_rank)Envolvendo o modelo
Mova o modelo para sua GPU e, em seguida, envolva-o em DDP com device_ids=[local_rank]. DDP registra ganchos que sincronizarão os gradientes durante a retropropagação.
from torch.nn.parallel import DistributedDataParallel as DDP
model = MyModel().to(device)
model = DDP(model, device_ids=[local_rank])O DistributedSampler
Cada processo deve receber uma parte diferente dos dados, sem sobreposição. O DistributedSampler particiona o conjunto de dados entre as posições, de modo que a união cubra todo o conjunto exatamente uma vez por época.
from torch.utils.data import DataLoader
from torch.utils.data.distributed import DistributedSampler
sampler = DistributedSampler(dataset)
loader = DataLoader(dataset, batch_size=32, sampler=sampler)Embaralhamento por época
Chame sampler.set_epoch(epoch) no início de cada época. Isso inicia novamente a semente do embaralhamento de forma consistente entre os processos, para que cada processo embaralhe da mesma maneira e as partições permaneçam disjuntas.
for epoch in range(epochs):
sampler.set_epoch(epoch)
for x, y in loader:
...Redução global dos gradientes
Durante loss.backward(), DDP executa uma redução global: cada processo envia seus gradientes e recebe o resultado calculado em média, para que todas as réplicas apliquem atualizações idênticas. A redução global ocorre em paralelo com a retropropagação, ocultando o custo da comunicação.
Sem gargalo na GPU 0
Ao contrário de DataParallel, DDP não tem uma GPU central que reúna as saídas. Cada processo calcula sua própria perda e seus gradientes; somente os gradientes são trocados por meio da redução global. Essa simetria explica por que DDP escala muito melhor.
Iniciando com torchrun
torchrun inicia os processos por GPU e define as variáveis de ambiente das posições. --nproc_per_node=4 inicia 4 processos (um por GPU) neste nó.
torchrun --nproc_per_node=4 train.pySalvando somente na posição 0
Todas as posições mantêm pesos idênticos, portanto apenas uma deve gravar o ponto de verificação, para evitar que uma gravação sobrescreva outra. Proteja o salvamento com uma verificação da posição.
if rank == 0:
torch.save(model.module.state_dict(), "model.pt")
dist.barrier()Verificação rápida
Teste seus conhecimentos sobre DDP.
Recapitulação
Você aprendeu sobre DistributedDataParallel:
dist.init_process_group(backend="nccl")entra no grupo de processos- DistributedSampler fornece a cada processo uma parte disjunta dos dados
DDP(model, device_ids=[rank])sincroniza os gradientes por meio da redução global- Inicie com
torchrun --nproc_per_node=4 - Salve somente na posição 0
Perguntas Frequentes
A aula “DistributedDataParallel (DDP)” é grátis?
Sim — o texto completo de “DistributedDataParallel (DDP)” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn AI with Python, atualize para CoddyKit PRO. O curso de Learn AI with Python inclui 4 aulas no total.
O que vou aprender em “DistributedDataParallel (DDP)”?
Grupos de processos, dist.init_process_group, DistributedSampler e sincronização de gradientes. Você pratica Learn AI with Python com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Learn AI with Python?
Nenhuma experiência prévia é necessária. Learn AI with Python no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.
Quanto tempo leva a aula “DistributedDataParallel (DDP)”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Learn AI with Python?
Sim. Cada aula de Learn AI with Python inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Treinamento com várias GPUs usando DataParallel
- DistributedDataParallel (DDP)
- Treinamento com precisão mista usando AMP
- Treinamento eficiente com Hugging Face Accelerate