Multi-GPU-Training mit DataParallel
nn.DataParallel, Ausbalancieren des GPU-Speichers, Bandbreitenengpässe, wann DDP besser geeignet ist.
Multi-GPU-Training mit DataParallel ist eine kostenlose Learn AI with Python-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Learn AI with Python-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Learn AI with Python-Kurs umfasst insgesamt 4 Lektionen.
Warum mehrere GPUs
Moderne Modelle und Batches überschreiten den Speicher und die Rechenleistung einer einzelnen GPU. Mit mehreren GPUs können Sie größere Modelle trainieren oder größere Batches in kürzerer tatsächlicher Zeit verarbeiten. PyTorch bietet dafür mehrere Möglichkeiten; die einfachste ist DataParallel.
Datenparallelismus
Datenparallelismus repliziert das Modell auf jeder GPU und teilt jeden Eingabe-Batch auf diese GPUs auf. Jede GPU berechnet ihren Teil, anschließend werden die Gradienten zusammengeführt, sodass alle Replikate synchron bleiben.
nn.DataParallel
nn.DataParallel verpackt ein Modell in einer einzigen Zeile. Sie übergeben die zu verwendenden GPU-IDs, und PyTorch übernimmt automatisch das Verteilen der Eingaben und das Zusammenführen der Ausgaben.
import torch
import torch.nn as nn
model = MyModel().cuda()
model = nn.DataParallel(model, device_ids=[0, 1])Automatische Aufteilung des Batches
Während des Forward-Passes teilt DataParallel den Batch auf Dimension 0 auf die angegebenen GPUs auf. Ein Batch mit 64 Elementen auf zwei GPUs wird zu zwei Teil-Batches mit jeweils 32 Elementen. Jede GPU führt dasselbe Modell parallel auf ihrem Teil-Batch aus.
# batch of 64 with device_ids=[0, 1]
# GPU 0 processes samples 0..31
# GPU 1 processes samples 32..63Gradientenmittelung
Im Backward-Pass werden die Gradienten der einzelnen GPUs auf dem primären Gerät gesammelt und gemittelt (effektiv summiert und skaliert), sodass das Modell-Update den gesamten Batch berücksichtigt. Anschließend werden die Replikate für den nächsten Schritt erneut synchronisiert.
Ein gewöhnlicher Trainings-Loop
Das Beste daran: Ihr Trainings-Loop ändert sich kaum. Sie verschieben die Daten auf die primäre GPU und rufen das verpackte Modell wie gewohnt auf; DataParallel übernimmt die Verteilung im Hintergrund.
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()Das Ungleichgewicht auf GPU 0
DataParallel hat einen bekannten Nachteil: Die primäre GPU (meist GPU 0) sammelt alle Ausgaben und berechnet den Loss, sodass sie zusätzliche Speicher- und Rechenlast trägt. Bei vielen GPUs wird GPU 0 zum Engpass und kann vor den anderen GPUs keinen Speicher mehr haben.
Ein Prozess, viele Threads
DataParallel läuft in einem einzelnen Python-Prozess und verwendet Threads, um die GPUs anzusteuern. Der globale Interpreter-Lock von Python und der Scatter/Gather-Overhead begrenzen die Skalierungseffizienz, insbesondere bei mehr als 2 bis 4 GPUs.
Warum DDP bevorzugt wird
Aus diesen Gründen wird DistributedDataParallel (DDP) für anspruchsvolle Multi-GPU-Arbeiten empfohlen. DDP führt einen Prozess pro GPU aus, synchronisiert Gradienten mit einem effizienten All-Reduce und vermeidet den Engpass auf GPU 0, wodurch eine nahezu lineare Skalierung erreicht wird.
Wann DataParallel noch ausreicht
DataParallel ist für schnelle Experimente auf einem einzelnen Rechner mit 2 GPUs akzeptabel, wenn die einfache Verwendung in einer Zeile die geringere Effizienz aufwiegt. Für Training über mehrere Knoten oder mit vielen GPUs sollten Sie stattdessen DDP verwenden.
Häufige Falle: Speichern
Der State Dict eines verpackten Modells hat das Präfix module.. Um einen sauberen Checkpoint zu speichern, verwenden Sie model.module.state_dict(), damit er später korrekt in ein unverpacktes Modell geladen werden kann.
torch.save(model.module.state_dict(), "model.pt")Kurztest
Testen Sie Ihr Wissen über DataParallel.
Zusammenfassung
Sie haben Multi-GPU-Training mit DataParallel kennengelernt:
nn.DataParallel(model, device_ids=[0, 1])repliziert das Modell und teilt die Batches auf- Die Gradienten werden bei jedem Schritt über die GPUs gemittelt
- Das Ungleichgewicht auf GPU 0 und das Design mit einem einzigen Prozess begrenzen die Skalierung
- Bevorzugen Sie DDP für viele GPUs oder Training über mehrere Knoten
Häufig gestellte Fragen
Ist die Lektion „Multi-GPU-Training mit DataParallel“ kostenlos?
Ja — der vollständige Text von „Multi-GPU-Training mit DataParallel“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Learn AI with Python-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Learn AI with Python-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Multi-GPU-Training mit DataParallel“?
nn.DataParallel, Ausbalancieren des GPU-Speichers, Bandbreitenengpässe, wann DDP besser geeignet ist. Du übst Learn AI with Python mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Learn AI with Python zu starten?
Keine Vorkenntnisse erforderlich. Learn AI with Python auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.
Wie lange dauert die Lektion „Multi-GPU-Training mit DataParallel“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Learn AI with Python-Lektion Code schreiben und ausführen?
Ja. Jede Learn AI with Python-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Multi-GPU-Training mit DataParallel
- DistributedDataParallel (DDP)
- Mixed-Precision-Training mit AMP
- Effizientes Training mit Hugging Face Accelerate