Addestramento multi-GPU con DataParallel
nn.DataParallel, bilanciamento della memoria GPU, colli di bottiglia della banda, quando DDP è preferibile
Addestramento multi-GPU con DataParallel è una lezione Learn AI with Python gratuita su CoddyKit. Questa è la lezione 1 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.
Perché utilizzare più GPU
I modelli e i batch moderni superano la memoria e la capacità di calcolo di una singola GPU. L'uso di più GPU consente di addestrare modelli più grandi o elaborare batch più ampi in meno tempo effettivo. PyTorch offre diversi modi per farlo; il più semplice è DataParallel.
Parallelismo dei dati
Il parallelismo dei dati replica il modello su ogni GPU e suddivide ogni batch di input tra di esse. Ogni GPU esegue i calcoli sulla propria partizione, quindi i gradienti vengono combinati affinché tutte le repliche rimangano sincronizzate.
nn.DataParallel
nn.DataParallel avvolge un modello con una sola riga. È sufficiente passargli gli ID delle GPU da utilizzare e PyTorch gestisce automaticamente la distribuzione degli input e la raccolta degli output.
import torch
import torch.nn as nn
model = MyModel().cuda()
model = nn.DataParallel(model, device_ids=[0, 1])Suddivisione automatica dei batch
Durante il passaggio forward, DataParallel suddivide il batch lungo la dimensione 0 tra le GPU elencate. Un batch di 64 elementi su due GPU diventa due sotto-batch da 32. Ogni GPU esegue in parallelo lo stesso modello sul proprio sotto-batch.
# batch of 64 with device_ids=[0, 1]
# GPU 0 processes samples 0..31
# GPU 1 processes samples 32..63Media dei gradienti
Durante il passaggio backward, i gradienti calcolati su ciascuna GPU vengono raccolti sul dispositivo principale e sottoposti a media (in pratica, sommati e ridimensionati), così l'aggiornamento del modello riflette l'intero batch. Le repliche vengono quindi nuovamente sincronizzate per il passaggio successivo.
Un normale ciclo di addestramento
La parte migliore è che il ciclo di addestramento cambia appena. Sposti i dati sulla GPU principale e chiami il modello avvolto come di consueto; DataParallel gestisce la distribuzione 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()Lo squilibrio della GPU 0
DataParallel presenta un difetto noto: la GPU principale (di solito la GPU 0) raccoglie tutti gli output e calcola la loss, quindi sostiene un carico aggiuntivo di memoria e calcolo. Con molte GPU, la GPU 0 diventa un collo di bottiglia e potrebbe esaurire la memoria prima delle altre.
Un singolo processo, molti thread
DataParallel viene eseguito in un singolo processo Python e utilizza thread per gestire le GPU. Il global interpreter lock di Python e l'overhead della distribuzione e raccolta limitano l'efficienza della scalabilità, soprattutto oltre le 2-4 GPU.
Perché si preferisce DDP
Per questi motivi, DistributedDataParallel (DDP) è consigliato per un uso serio di più GPU. DDP esegue un processo per GPU, sincronizza i gradienti con un all-reduce efficiente ed evita il collo di bottiglia della GPU 0, offrendo una scalabilità quasi lineare.
Quando DataParallel è ancora adatto
DataParallel è una scelta accettabile per esperimenti rapidi su una singola macchina con 2 GPU, dove la sua semplicità, ottenibile con una sola riga, compensa l'inefficienza. Per l'addestramento su più nodi o con molte GPU, scelga invece DDP.
Errore comune: il salvataggio
Lo state dict di un modello avvolto presenta il prefisso module.. Per salvare un checkpoint pulito, salvi model.module.state_dict(), così in seguito potrà essere caricato correttamente in un modello non avvolto.
torch.save(model.module.state_dict(), "model.pt")Verifica rapida
Metta alla prova le Sue conoscenze di DataParallel.
Riepilogo
Ha appreso l'addestramento su più GPU con DataParallel:
nn.DataParallel(model, device_ids=[0, 1])replica il modello e suddivide i batch- I gradienti vengono sottoposti a media tra le GPU a ogni passaggio
- Lo squilibrio della GPU 0 e l'architettura a processo singolo limitano la scalabilità
- Preferisca DDP per molte GPU o per l'addestramento su più nodi
Domande Frequenti
La lezione «Addestramento multi-GPU con DataParallel» è gratuita?
Sì — il testo completo di «Addestramento multi-GPU con DataParallel» è 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 «Addestramento multi-GPU con DataParallel»?
nn.DataParallel, bilanciamento della memoria GPU, colli di bottiglia della banda, quando DDP è preferibile 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 1 di 4.
Quanto tempo richiede la lezione «Addestramento multi-GPU con DataParallel»?
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