DistributedDataParallel (DDP)
Gruppi di processi, dist.init_process_group, DistributedSampler, sincronizzazione dei gradienti
DistributedDataParallel (DDP) è una lezione Learn AI with Python gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Learn AI with Python, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Learn AI with Python include 4 lezioni in totale.
Che cos'è DDP
DistributedDataParallel (DDP) è l'approccio ad alte prestazioni di PyTorch per l'addestramento in parallelo sui dati. Avvia un processo per GPU, ciascuno con una replica completa del modello, e sincronizza i gradienti in modo efficiente. DDP offre una scalabilità quasi lineare tra GPU e macchine.
Il gruppo di processi
DDP coordina i processi tramite un gruppo di processi. Ogni processo riceve un rank univoco e conosce il world size totale. Comunicano attraverso un backend; sulle GPU NVIDIA tale backend è nccl.
init_process_group
Ogni processo inizia unendosi al gruppo. dist.init_process_group con backend="nccl" configura la comunicazione da GPU a GPU.
import torch.distributed as dist
import os
dist.init_process_group(backend="nccl")
rank = dist.get_rank()
world_size = dist.get_world_size()Assegnazione del dispositivo
Ogni processo dovrebbe gestire una sola GPU. Utilizzi il rank locale per impostare il dispositivo, in modo che il processo 0 utilizzi cuda:0, il processo 1 utilizzi cuda:1 e così via.
local_rank = int(os.environ["LOCAL_RANK"])
torch.cuda.set_device(local_rank)
device = torch.device("cuda", local_rank)Avvolgimento del modello
Sposti il modello sulla relativa GPU, quindi lo avvolga in DDP con device_ids=[local_rank]. DDP registra hook che sincronizzano i gradienti durante la propagazione all'indietro.
from torch.nn.parallel import DistributedDataParallel as DDP
model = MyModel().to(device)
model = DDP(model, device_ids=[local_rank])Il DistributedSampler
Ogni processo deve visualizzare una partizione diversa dei dati, senza sovrapposizioni. Il DistributedSampler suddivide il dataset tra i rank, in modo che la loro unione copra l'intero dataset esattamente una volta per epoca.
from torch.utils.data import DataLoader
from torch.utils.data.distributed import DistributedSampler
sampler = DistributedSampler(dataset)
loader = DataLoader(dataset, batch_size=32, sampler=sampler)Mescolamento a ogni epoca
Chiami sampler.set_epoch(epoch) all'inizio di ogni epoca. In questo modo il mescolamento viene inizializzato nuovamente e in modo coerente tra i processi, così ogni rank mescola i dati allo stesso modo e le partizioni rimangono disgiunte.
for epoch in range(epochs):
sampler.set_epoch(epoch)
for x, y in loader:
...All-reduce dei gradienti
Durante loss.backward(), DDP esegue un all-reduce: ogni processo invia i propri gradienti e riceve il risultato medio, così tutte le repliche applicano aggiornamenti identici. L'all-reduce si sovrappone alla propagazione all'indietro, nascondendo il costo della comunicazione.
Nessun collo di bottiglia sulla GPU 0
A differenza di DataParallel, DDP non ha una GPU centrale che raccolga gli output. Ogni processo calcola la propria loss e i propri gradienti; vengono scambiati solo i gradienti tramite all-reduce. È questa simmetria che consente a DDP di scalare molto meglio.
Avvio con torchrun
torchrun avvia i processi per GPU e imposta le variabili d'ambiente relative ai rank. --nproc_per_node=4 avvia 4 processi (uno per GPU) su questo nodo.
torchrun --nproc_per_node=4 train.pySalvataggio solo sul rank 0
Tutti i rank contengono pesi identici, quindi solo uno dovrebbe scrivere il checkpoint per evitare sovrascritture. Protegga il salvataggio con un controllo del rank.
if rank == 0:
torch.save(model.module.state_dict(), "model.pt")
dist.barrier()Verifica rapida
Metta alla prova le Sue conoscenze di DDP.
Riepilogo
Ha appreso DistributedDataParallel:
dist.init_process_group(backend="nccl")unisce il processo al gruppo di processi- DistributedSampler assegna a ogni rank una partizione disgiunta dei dati
DDP(model, device_ids=[rank])sincronizza i gradienti tramite all-reduce- Avvii con
torchrun --nproc_per_node=4 - Salvi solo sul rank 0
Domande Frequenti
La lezione «DistributedDataParallel (DDP)» è gratuita?
Sì — il testo completo di «DistributedDataParallel (DDP)» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Learn AI with Python, passa a CoddyKit PRO. Il corso Learn AI with Python include 4 lezioni in totale.
Cosa imparerò in «DistributedDataParallel (DDP)»?
Gruppi di processi, dist.init_process_group, DistributedSampler, sincronizzazione dei gradienti Eserciti Learn AI with Python con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Learn AI with Python?
Non è richiesta alcuna esperienza precedente. Learn AI with Python su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.
Quanto tempo richiede la lezione «DistributedDataParallel (DDP)»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Learn AI with Python?
Sì. Ogni lezione Learn AI with Python include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Addestramento multi-GPU con DataParallel
- DistributedDataParallel (DDP)
- Addestramento a precisione mista con AMP
- Addestramento efficiente con Hugging Face Accelerate