Treinamento com várias GPUs usando DataParallel
nn.DataParallel, balanceamento da memória da GPU, gargalos de largura de banda e quando DDP é melhor.
Treinamento com várias GPUs usando DataParallel é uma aula grátis de Learn AI with Python no CoddyKit. Esta é a aula 1 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.
Por que usar várias GPUs
Os modelos e lotes modernos ultrapassam a memória e a capacidade de processamento de uma única GPU. Usar várias GPUs permite treinar modelos maiores ou processar lotes maiores em menos tempo de execução. PyTorch oferece várias maneiras de fazer isso; a mais simples é DataParallel.
Paralelismo de dados
O paralelismo de dados replica o modelo em cada GPU e divide cada lote de entrada entre elas. Cada GPU calcula sua parte; depois, os gradientes são combinados para manter todas as réplicas sincronizadas.
nn.DataParallel
nn.DataParallel envolve um modelo em uma única linha. Você informa os identificadores das GPUs que deseja usar, e PyTorch distribui as entradas e reúne as saídas automaticamente.
import torch
import torch.nn as nn
model = MyModel().cuda()
model = nn.DataParallel(model, device_ids=[0, 1])Divisão automática do lote
Durante a passagem direta, DataParallel divide o lote ao longo da dimensão 0 entre as GPUs listadas. Um lote de 64 em duas GPUs se torna dois sublotes de 32. Cada GPU executa o mesmo modelo em seu sublote, em paralelo.
# batch of 64 with device_ids=[0, 1]
# GPU 0 processes samples 0..31
# GPU 1 processes samples 32..63Média dos gradientes
Durante a passagem reversa, os gradientes de cada GPU são reunidos no dispositivo principal e calculados em média (na prática, somados e redimensionados), para que a atualização do modelo reflita o lote inteiro. Em seguida, as réplicas são sincronizadas novamente para a próxima etapa.
Um ciclo de treinamento normal
A melhor parte é que seu ciclo de treinamento quase não muda. Você move os dados para a GPU principal e chama o modelo envolvido normalmente; DataParallel cuida da distribuição internamente.
for x, y in loader:
x, y = x.cuda(), y.cuda()
optimizer.zero_grad()
out = model(x) # auto-split across GPUs
loss = criterion(out, y)
loss.backward() # gradients averaged
optimizer.step()O desequilíbrio da GPU 0
DataParallel tem uma falha conhecida: a GPU principal (geralmente a GPU 0) reúne todas as saídas e calcula a perda, portanto assume memória e processamento adicionais. Com muitas GPUs, a GPU 0 se torna um gargalo e pode ficar sem memória antes das outras.
Um processo, muitas threads
DataParallel é executado em um único processo Python e usa threads para controlar as GPUs. O bloqueio global do interpretador do Python e o custo adicional da distribuição e reunião limitam a eficiência de escalabilidade, especialmente com mais de 2 a 4 GPUs.
Por que DDP é preferível
Por esses motivos, DistributedDataParallel (DDP) é recomendado para trabalhos sérios com várias GPUs. DDP executa um processo por GPU, sincroniza os gradientes com uma redução global eficiente e evita o gargalo da GPU 0, proporcionando escalabilidade quase linear.
Quando DataParallel ainda é adequado
DataParallel é aceitável para experimentos rápidos em uma única máquina com 2 GPUs, quando sua simplicidade de uma linha compensa a ineficiência. Para treinamento em vários nós ou com muitas GPUs, prefira DDP.
Armadilha comum: salvamento
O dicionário de estado de um modelo envolvido tem o prefixo module.. Para salvar um ponto de verificação limpo, salve model.module.state_dict() para que ele seja carregado corretamente em um modelo não envolvido posteriormente.
torch.save(model.module.state_dict(), "model.pt")Verificação rápida
Teste seus conhecimentos sobre DataParallel.
Recapitulação
Você aprendeu sobre treinamento com várias GPUs usando DataParallel:
nn.DataParallel(model, device_ids=[0, 1])replica o modelo e divide os lotes- Os gradientes são calculados em média entre as GPUs a cada etapa
- O desequilíbrio da GPU 0 e o design de processo único limitam a escalabilidade
- Prefira DDP para muitas GPUs ou treinamento em vários nós
Perguntas Frequentes
A aula “Treinamento com várias GPUs usando DataParallel” é grátis?
Sim — o texto completo de “Treinamento com várias GPUs usando DataParallel” é 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 “Treinamento com várias GPUs usando DataParallel”?
nn.DataParallel, balanceamento da memória da GPU, gargalos de largura de banda e quando DDP é melhor. 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 1 de 4.
Quanto tempo leva a aula “Treinamento com várias GPUs usando DataParallel”?
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