PyTorch Verteiltes Training
Wenn Modelle größer werden und die Datenmenge wächst, kann eine einzelne GPU die Trainingsanforderungen nicht mehr erfüllen.
Verteiltes Training nutzt paralleles Rechnen über mehrere GPUs oder sogar mehrere Maschinen hinweg und verkürzt die Trainingszeit erheblich.
Dieser Abschnitt beschreibt verteilte Trainingstechniken in PyTorch, einschließlich DataParallel, DistributedDataParallel und verteiltem Training mit gemischter Genauigkeit.
1. Grundlagen des verteilten Trainings
1.1 Warum brauchen wir verteiltes Training
Die Größe von Deep-Learning-Modellen wächst Jahr für Jahr, und die Trainingszeit nimmt entsprechend zu. Das Kernziel des verteilten Trainings ist:Rechenaufgaben auf mehrere Recheneinheiten zu verteilen, um das Training großskaliger Modelle und Daten innerhalb einer akzeptablen Zeit abzuschließen.。
Verteiltes Training löst hauptsächlich zwei Probleme:
- Unzureichender Speicher: Die Parameter, Optimiererzustände und Gradienten großer Modelle benötigen eine große Menge GPU-Speicher.
- Übermäßige Trainingszeit: Das Training eines großen Modells auf einer einzelnen GPU kann Wochen oder sogar Monate dauern.
1.2 Zwei Hauptmodi des verteilten Trainings
Verteiltes Training wird hauptsächlich in zwei Modi unterteilt:
| Mode | Prinzip | Anwendungsszenario |
|---|---|---|
| Datenparallelismus | Jede Recheneinheit speichert ein vollständiges Modell; verschiedene Recheneinheiten verarbeiten unterschiedliche Daten. | Das Modell passt in den GPU-Speicher einer einzelnen Karte; große Datenmengen erfordern beschleunigtes Training; kleine Teams mit begrenzten Maschinenressourcen. |
| Modellparallelismus | Das Modell wird auf mehrere Recheneinheiten aufgeteilt; jede Recheneinheit speichert nur einen Teil des Modells. | Das Modell ist zu groß, um auf eine einzelne Karte zu passen; dedizierte Cluster, Multi-Maschinen-Training. |
In tatsächlichen Produktionsumgebungen ist Datenparallelismus der am häufigsten verwendete Ansatz. PyTorch bietet zwei Implementierungen: DataParallel und DistributedDataParallel.
2. DataParallel-Anwendungsleitfaden
2.1 Einzelmaschine-Multi-GPU: DataParallel
DataParallel(DP)Es ist die einfachste von PyTorch bereitgestellte Multi-GPU-Trainingsmethode. Es erfordert nur die Änderung weniger Codezeilen, um mit mehreren GPUs auf einer einzelnen Maschine zu trainieren.
Beispiel
import torch.nn as nn
import torch.optim as optim
# ── Modell-Definition ──────────────────────────────────────
class SimpleModel(nn.Module):
def __init__(self):
super().__init__()
self.net = nn.Sequential(
nn.Linear(128, 256),
nn.ReLU(),
nn.Linear(256, 256),
nn.ReLU(),
nn.Linear(256, 10)
)
def forward(self, x):
return self.net(x)
# Prüfen Sie die Anzahl der verfügbaren GPUs
print(f"Verfügbare GPU-Anzahl: {torch.cuda.device_count()}")
# Modell erstellen und auf GPU verschieben
model = SimpleModel()
# ── Methode 1: DataParallel verwenden (einfachste Möglichkeit)───────
if torch.cuda.device_count() > 1:
model = nn.DataParallel(model)
# Auf GPU verschieben (bei Verwendung von DataParallel werden device_ids automatisch behandelt)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)
# Verlustfunktion und Optimierer
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=1e-3)
# ── Trainingsschleife ──────────────────────────────────────
def train_epoch_dp(model, loader, criterion, optimizer, device):
model.train()
total_loss = 0
correct = 0
total = 0
for inputs, labels in loader:
inputs = inputs.to(device, non_blocking=True)
labels = labels.to(device, non_blocking=True)
optimizer.zero_grad()
outputs = model(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
total_loss += loss.item() * inputs.size(0)
_, predicted = outputs.max(1)
correct += predicted.eq(labels).sum().item()
total += labels.size(0)
return total_loss / total, correct / total
# Simulierte Daten
train_loader = [
(torch.randn(32, 128), torch.randint(0, 10, (32,))) for _ in range(10)
]
# Training starten
for epoch in range(3):
loss, acc = train_epoch_dp(model, train_loader, criterion, optimizer, device)
print(f"Epoche {epoch+1}: Verlust={loss:.4f}, Genauigkeit={acc:.4f}")
print("Datentraining abgeschlossen!")
2.2 Wie DataParallel funktioniert
Der Workflow von DataParallel ist wie folgt:
- Modellreplikation: Das Modell auf jede GPU kopieren
- Datenverteilung: Batch-Daten gleichmäßig auf jede GPU verteilen.
- Parallele Berechnung: Jede GPU berechnet den Forward Pass unabhängig.
- Gradientenaggregation: Gradienten von allen GPUs auf der Haupt-GPU aggregieren.
- Parameteraktualisierung: Die Haupt-GPU aktualisiert die Parameter und synchronisiert sie mit der Haupt-GPU.
Beispiel
model = nn.DataParallel(
module, # Das Modell, das parallelisiert werden soll (erforderlich)
device_ids=[0, 1, 2, 3], # Zu verwendende GPU-Geräte-IDs; standardmäßig werden alle GPUs verwendet
output_device=0, # Gerät, auf dem die Ausgabeergebnisse gesammelt werden; standardmäßig die erste GPU
dim=0 # Dimension, entlang derer die Daten aufgeteilt werden; standardmäßig die Batch-Dimension
)
# Gerät des aktuellen Modells prüfen
print(f"Gerät des Modells: {next(model.parameters()).device}")
# Die tatsächlich verwendeten Geräte prüfen
print(f"Anzahl der verwendeten GPUs: {model.device_ids if hasattr(model, 'device_ids') else 'N/A'}")
DataParallel ist einfach und benutzerfreundlich, hat aber zwei Hauptprobleme: 1) Die Haupt-GPU hat hohen Speicherdruck (sie muss Gradienten aggregieren); 2) die Kommunikationseffizienz zwischen GPUs ist gering. Daher wird offiziell empfohlen, DistributedDataParallel zu verwenden.
3. Ausführliche Erläuterung von DistributedDataParallel
3.1 DDP-Grundlagen
DistributedDataParallel(DDP)Es ist die von PyTorch empfohlene verteilte Trainingsmethode. Im Vergleich zu DataParallel hat DDP die folgenden Vorteile:
- Jede GPU berechnet Gradienten unabhängig, ohne sie auf der Haupt-GPU aggregieren zu müssen.
- Verwendet einen effizienten Algorithmus zur Gradientensynchronisierung (Ring AllReduce).
- Unterstützt Multi-Maschinen-Multi-GPU-Training.
- Schnellere Trainingsgeschwindigkeit und effizientere Speichernutzung.
3.2 DDP Single-Machine-Multi-GPU-Training
Beispiel
import torch.nn as nn
import torch.optim as optim
import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel as DDP
import os
# ── Verteilte Umgebung initialisieren ────────────────────────────
def setup(rank, world_size):
"""Verteilte Umgebung einrichten"""
# Die vom aktuellen Prozess verwendete GPU festlegen
torch.cuda.set_device(rank)
# Prozessgruppe initialisieren
dist.init_process_group(
backend="nccl", # NCCL-Backend verwenden (für GPU empfohlen)
init_method="env://", # Initialisierungsmethode für Umgebungsvariablen
world_size=world_size, # Gesamtzahl der Prozesse
rank=rank # Rang des aktuellen Prozesses
)
def cleanup():
"""Bereinige die verteilte Umgebung"""
dist.destroy_process_group()
# ── Datenlader (verteilte Unterstützung)───────────────────────
def get_distributed_loader(batch_size, world_size):
"""Erstelle einen Datenlader mit verteilter Unterstützung"""
from torch.utils.data import DataLoader, DistributedSampler
# Simuliertes Dataset
dataset = torch.utils.data.TensorDataset(
torch.randn(100, 3, 32, 32),
torch.randint(0, 10, (100,))
)
# DistributedSampler teilt Daten automatisch auf
sampler = DistributedSampler(
dataset,
num_replicas=world_size,
rank=rank,
shuffle=True
)
loader = DataLoader(
dataset,
batch_size=batch_size,
sampler=sampler,
num_workers=2,
pin_memory=True
)
return loader
# ── Modell-Definition ──────────────────────────────────────
class ImageClassifier(nn.Module):
def __init__(self):
super().__init__()
self.features = nn.Sequential(
nn.Conv2d(3, 32, 3, padding=1),
nn.ReLU(),
nn.MaxPool2d(2),
nn.Conv2d(32, 64, 3, padding=1),
nn.ReLU(),
nn.AdaptiveAvgPool2d(1),
nn.Flatten()
)
self.classifier = nn.Linear(64, 10)
def forward(self, x):
x = self.features(x)
x = self.classifier(x)
return x
# ── DDP Trainingsfunktion ──────────────────────────────────
def train_ddp(rank, world_size, epochs=3):
"""Hauptfunktion für verteiltes Training"""
# Initialisieren
setup(rank, world_size)
# Modell erstellen und auf die entsprechende GPU verschieben
model = ImageClassifier().cuda(rank)
# Als DDP-Modell verpacken
ddp_model = DDP(
model,
device_ids=[rank], # Gerät angeben, das vom aktuellen Prozess verwendet wird
output_device=rank,
find_unused_parameters=False # Ob ungenutzte Parameter erkannt werden sollen
)
# Verlustfunktion und Optimierer
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(ddp_model.parameters(), lr=1e-3)
# Datenlader abrufen
loader = get_distributed_loader(batch_size=16, world_size=world_size)
# Trainingsschleife
for epoch in range(epochs):
# Epochennummer zu Beginn jeder Epoche festlegen (wird für das Mischen der Daten verwendet)
loader.sampler.set_epoch(epoch)
for batch_idx, (inputs, labels) in enumerate(loader):
inputs = inputs.cuda(rank, non_blocking=True)
labels = labels.cuda(rank, non_blocking=True)
optimizer.zero_grad()
outputs = ddp_model(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
if rank == 0 and batch_idx % 5 == 0:
print(f"Epoche {epoch+1}, Batch {batch_idx}, Verlust: {loss.item():.4f}")
# Aufräumen
if rank == 0:
print("Training abgeschlossen!")
Bereinigung()
# Hinweis: In der tatsächlichen Ausführung müssen rank und world_size über Kommandozeilenargumente angegeben werden
# Dieser Code muss unabhängig in jedem Prozess ausgeführt werden
3.3 Starten des verteilten Trainings
Das verteilte Training mit PyTorch muss übertorchrunodertorch.distributed.launchgestartet werden. Hier sind die gängigen Startmethoden:
Beispiel
# Datei: train_ddp.py
"""
Verwendung:
torchrun --nproc_per_node=4 train_ddp.py
"""
# Methode 2: Verwendung von python -m (traditionelle Methode)
"""
python -m torch.distributed.launch --nproc_per_node=4 train_ddp.py
"""
# Methode 3: Multi-Node-Multi-GPU-Start
# Maschine 1 (Master-Knoten)
torchrun --nnodes=2 --nproc_per_node=4 --node_rank=0 --master_addr=192.168.1.1 --master_port=29500 train_ddp.py
# Maschine 2 (Worker-Knoten)
torchrun --nnodes=2 --nproc_per_node=4 --node_rank=1 --master_addr=192.168.1.1 --master_port=29500 train_ddp.py
# Parameterbeschreibungen:
# --nproc_per_node: Anzahl der GPUs pro Knoten
# --nnodes: Anzahl der Knoten
# --node_rank: aktueller Knotenindex (beginnend bei 0)
# --master_addr: IP-Adresse des Master-Knotens
# --master_port: Portnummer des Master-Knotens
3.4 Vollständiges DDP-Trainingsskript
Beispiel
import torch
import torch.nn as nn
import torch.optim as optim
import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.utils.data import DataLoader, DistributedSampler
import argparse
import os
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument("--local_rank", type=int, default=-1, help="Automatisch von torchrun übergeben")
parser.add_argument("--epochs", type=int, default=10)
parser.add_argument("--batch_size", type=int, default=32)
parser.add_argument("--lr", type=float, default=1e-3)
return parser.parse_args()
class TrainModel(nn.Module):
def __init__(self):
super().__init__()
self.net = nn.Sequential(
nn.Conv2d(3, 64, 3, padding=1),
nn.ReLU(),
nn.MaxPool2d(2),
nn.Conv2d(64, 128, 3, padding=1),
nn.ReLU(),
nn.AdaptiveAvgPool2d(1),
nn.Flatten(),
nn.Linear(128, 10)
)
def forward(self, x):
return self.net(x)
def setup(rank, world_size):
os.environ["MASTER_ADDR"] = "localhost"
os.environ["MASTER_PORT"] = "12355"
dist.init_process_group("nccl", rank=rank, world_size=world_size)
torch.cuda.set_device(rank)
def cleanup():
dist.destroy_process_group()
def train(rank, world_size, args):
setup(rank, world_size)
# Das Modell erstellen
model = TrainModel().cuda(rank)
model = DDP(model, device_ids=[rank])
# Optimierer und Verlustfunktion
optimizer = optim.Adam(model.parameters(), lr=args.lr)
criterion = nn.CrossEntropyLoss()
# Datensatz
dataset = torch.utils.data.TensorDataset(
torch.randn(1000, 3, 32, 32),
torch.randint(0, 10, (1000,))
)
# DistributedSampler stellt sicher, dass jeder Prozess unterschiedliche Daten sieht
sampler = DistributedSampler(
dataset,
num_replicas=world_size,
rank=rank,
shuffle=True
)
loader = DataLoader(
dataset,
batch_size=args.batch_size,
sampler=sampler,
num_workers=2,
pin_memory=True
)
# Trainingsschleife
for epoch in range(args.epochs):
# Wichtig: Die Epoche in jeder Epoche setzen, um die Datenpartition zu mischen
sampler.set_epoch(epoch)
model.train()
epoch_loss = 0
for inputs, labels in loader:
inputs = inputs.cuda(rank, non_blocking=True)
labels = labels.cuda(rank, non_blocking=True)
optimizer.zero_grad()
outputs = model(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
epoch_loss += loss.item()
# Alle Prozesse synchronisieren, um sicherzustellen, dass jeder Prozess die aktuelle Epoche beendet
dist.barrier()
if rank == 0:
avg_loss = epoch_loss / len(loader)
print(f"Epoche {epoch+1}/{args.epochs}, Verlust: {avg_loss:.4f}")
Bereinigung()
if __name__ == "__main__":
args = parse_args()
# world_size aus Umgebungsvariablen abrufen
world_size = int(os.environ["WORLD_SIZE"])
# rank aus Umgebungsvariablen abrufen (automatisch von torchrun gesetzt)
rank = int(os.environ["RANK"])
if torch.cuda.is_available():
train(rank, world_size, args)
else:
print("Eine CUDA-Umgebung ist erforderlich, um verteiltes Training auszuführen")
Wichtiger Punkt: Jede Epoche muss aufrufen
sampler.set_epoch(epoch), um sicherzustellen, dass die Datenpartition gemischt wird, andernfalls sehen mehrere Prozesse dieselben Daten.
4. Gemischte Präzision im verteilten Training
4.1 DDP + AMP-Kombination
Die Kombination von verteiltem Training mit Mixed-Precision-Training kann die Trainingsgeschwindigkeit weiter verbessern. DDP in PyTorch 2.0+ ist vollständig in AMP integriert.
Beispiel
import torch.nn as nn
import torch.optim as optim
import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.cuda.amp import autocast, GradScaler
class AMPModel(nn.Module):
def __init__(self):
super().__init__()
self.net = nn.Sequential(
nn.Conv2d(3, 64, 3, padding=1),
nn.ReLU(),
nn.MaxPool2d(2),
nn.Conv2d(64, 128, 3, padding=1),
nn.ReLU(),
nn.AdaptiveAvgPool2d(1),
nn.Flatten(),
nn.Linear(128, 10)
)
def forward(self, x):
return self.net(x)
def train_ddp_amp(rank, world_size):
"""Verteiltes + Mixed-Precision-Training"""
# Initialisierung
torch.cuda.set_device(rank)
dist.init_process_group("nccl", rank=rank, world_size=world_size)
# Das Modell erstellen
model = AMPModel().cuda(rank)
model = DDP(model, device_ids=[rank])
# Optimizer und GradScaler
optimizer = optim.Adam(model.parameters(), lr=1e-3)
scaler = GradScaler()
criterion = nn.CrossEntropyLoss()
# Trainingsschleife
model.train()
for inputs, labels in loader:
inputs = inputs.cuda(rank, non_blocking=True)
labels = labels.cuda(rank, non_blocking=True)
optimizer.zero_grad()
# autocast verwenden, um die Präzision automatisch umzuschalten
with autocast(device_type='cuda'):
outputs = model(inputs)
loss = criterion(outputs, labels)
# scaler verwenden, um die Gradientenskalierung zu handhaben
scaler.scale(loss).backward()
# Gradient Clipping (erfordert vorheriges Unscaling)
scaler.unscale_(optimizer)
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
scaler.step(optimizer)
scaler.update()
dist.destroy_process_group()
# Startbefehl
# torchrun --nproc_per_node=4 train_ddp_amp.py
4.2 Gradientensynchronisation im verteilten Training
DDP verwendet denRing AllReduceAlgorithmus zur Gradientensynchronisierung, und er funktioniert wie folgt:
- Jede GPU teilt die Gradienten in n Teile auf (n ist die Anzahl der GPUs)
- Jede GPU tauscht einen Gradiententeil mit einer benachbarten GPU aus
- Nach n-maliger Wiederholung hat jede GPU die vollständigen Gradienten
Beispiel
# 1. Puffergröße für Gradienten-Buckets festlegen
model = DDP(
model,
device_ids=[rank],
gradient_as_bucket_view=True, # Speicher sparen (PyTorch 1.8+)
broadcast_buffers=False, # Puffer nicht übertragen, um die Kommunikation zu reduzieren
bucket_cap_mb=25 # Größe des Gradienten-Buckets (MB)
)
# 2. Modellparameter manuell synchronisieren (falls erforderlich)
# In einigen Szenarien müssen Modellparameter manuell synchronisiert werden
def sync_params(model):
for param in model.parameters():
dist.broadcast(param, src=0)
# 3. Gradientensynchronisierungsstatus überprüfen
# DDP übernimmt die Gradientensynchronisierung automatisch; kein manueller Vorgang erforderlich
# Es kann jedoch wie folgt überprüft werden
for name, param in model.named_parameters():
if param.grad is not None:
print(f"{name}: grad requires_grad={param.grad.requires_grad}")
5. Modellparallelismus und Pipelining
5.1 Einfacher Modellparallelismus
Wenn das Modell zu groß ist, um auf eine einzelne GPU zu passen, muss es über mehrere GPUs aufgeteilt werden.
Beispiel
class ModelParallel(nn.Module):
def __init__(self, num_gpus=2):
super().__init__()
self.num_gpus = num_gpus
# Teil 1: GPU 0
self.features1 = nn.Sequential(
nn.Conv2d(3, 64, 3, padding=1),
nn.ReLU(),
nn.MaxPool2d(2)
).to(f"cuda:0")
# Teil 2: GPU 1
self.features2 = nn.Sequential(
nn.Conv2d(64, 128, 3, padding=1),
nn.ReLU(),
nn.AdaptiveAvgPool2d(1),
nn.Flatten()
).to(f"cuda:1")
# Klassifikator: GPU 0
self.classifier = nn.Linear(128, 10).to(f"cuda:0")
def forward(self, x):
# Daten werden zwischen verschiedenen GPUs übergeben
x = x.to("cuda:0")
x = self.features1(x)
x = x.to("cuda:1")
x = self.features2(x)
x = x.to("cuda:0")
x = self.classifier(x)
return x
# Verwenden
model = ModelParallel(num_gpus=2)
output = model(torch.randn(1, 3, 32, 32))
print(f"Ausgabegerät: {output.device}")
5.2 Pipeline-Parallelismus
PyTorch bietettorch.distributed.pipeline.syncModul (PP-Paket), um Pipeline-Parallelismus zu implementieren, indem das Modell nach Schichten aufgeteilt wird, um eine Rechenpipeline zu bilden.
Beispiel
# pip install torch-pipeline
"""
# Hinweis: Die native PyTorch-Pipeline erfordert eine bestimmte Version oder eine Drittanbieterbibliothek
# Hier demonstrieren wir das Konzept anhand einer vereinfachten Implementierung
from torch.distributed.pipeline.sync import Pipe
class SimpleModel(nn.Module):
def __init__(self):
super().__init__()
self.layer1 = nn.Linear(128, 256)
self.layer2 = nn.Linear(256, 256)
self.layer3 = nn.Linear(256, 10)
def forward(self, x):
x = torch.relu(self.layer1(x))
x = torch.relu(self.layer2(x))
x = self.layer3(x)
return x
# Teile das Modell nach Schichten auf verschiedene GPUs auf
# layer1 -> GPU 0
# layer2 -> GPU 1
# layer3 -> GPU 2
model = SimpleModel()
model.layer1 = model.layer1.cuda(0)
model.layer2 = model.layer2.cuda(1)
model.layer3 = model.layer3.cuda(2)
# Verwende Pipeline, um das Modell zu verbinden
# Hinweis: Die tatsächliche Nutzung erfordert die Installation der entsprechenden Version der Pipeline-Bibliothek
# from torch.distributed.pipeline.sync import Pipe
# model = Pipe(model, chunks=4)
"""
print("Pipeline-Parallelität erfordert eine zusätzliche Installation der Bibliothek torch-pipeline")
print("pip install torch-pipeline-sync")
6. Bewährte Methoden für verteiltes Training
6.1 Tipps zur Leistungsoptimierung
| Optimierungspunkt | Technik | Beschreibung |
|---|---|---|
| Kommunikationsoptimierung | NCCL-Backend verwenden | NCCL ist die beste Wahl für GPUs; schneller als Gloo |
| Datenladen | num_workers und pin_memory setzen | num_workers auf die Anzahl der CPU-Kerne setzen; pin_memory beschleunigt die CPU-zu-GPU-Übertragung |
| Gradientensynchronisation | bucket_cap_mb anpassen | Größere Modelle können den Bucket vergrößern; kleinere Modelle können ihn verkleinern, um die Reaktionsfähigkeit zu verbessern |
| Gemischte Präzision | DDP + AMP | Reduziert das Kommunikationsvolumen; verbessert die Trainingsgeschwindigkeit |
6.2 Häufige Probleme und Lösungen
| Problem | Ursache | Lösung |
|---|---|---|
| Langsame Kommunikation | Unzureichende Netzwerkbandbreite | InfiniBand oder Hochgeschwindigkeitsnetzwerk verwenden |
| Unzureichender GPU-Speicher | Batch-Größe zu groß | Batchgröße reduzieren oder Gradientenakkumulation verwenden |
| Unausgeglichene Last | Ungeeignete Modellpartitionierung | Layer-Verteilung so gleichmäßig wie möglich anpassen |
| Synchronisierungsfehler | Gradient NaN | Gradient-Clipping- und Scaling-Einstellungen prüfen |
6.3 Vollständiges Multi-Maschinen-Multi-GPU-Trainingsskript
Beispiel
import torch
import torch.nn as nn
import torch.optim as optim
import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.utils.data import DataLoader, DistributedSampler
import argparse
import os
class TrainingConfig:
def __init__(self):
self.local_rank = -1
self.epochs = 30
self.batch_size = 32
self.lr = 1e-3
self.num_workers = 4
self.gradient_clip = 1.0
self.use_amp = True
def init_distributed(config):
"""Initialisiert die verteilte Umgebung"""
# Konfiguration aus Umgebungsvariablen abrufen
local_rank = config.local_rank
# NCCL-Konfiguration
os.environ["NCCL_DEBUG"] = "WARN"
torch.cuda.set_device(local_rank)
dist.init_process_group(backend="nccl")
return local_rank
def create_dataloader(dataset, config, world_size, rank):
"""Datenlader erstellen"""
sampler = DistributedSampler(
dataset,
num_replicas=world_size,
rank=rank,
shuffle=True,
drop_last=True
)
loader = DataLoader(
dataset,
batch_size=config.batch_size,
sampler=sampler,
num_workers=config.num_workers,
pin_memory=True,
persistent_workers=True
)
return loader, sampler
def train_epoch(model, loader, criterion, optimizer, scaler, config, rank):
"""Eine Epoche trainieren"""
model.train()
total_loss = 0
correct = 0
total = 0
for inputs, labels in loader:
inputs = inputs.cuda(rank, non_blocking=True)
labels = labels.cuda(rank, non_blocking=True)
optimizer.zero_grad()
if config.use_amp and scaler is not None:
# Training mit gemischter Präzision
with torch.cuda.amp.autocast():
outputs = model(inputs)
loss = criterion(outputs, labels)
scaler.scale(loss).backward()
scaler.unscale_(optimizer)
torch.nn.utils.clip_grad_norm_(model.parameters(), config.gradient_clip)
scaler.step(optimizer)
scaler.update()
else:
# Normales Training
outputs = model(inputs)
loss = criterion(outputs, labels)
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), config.gradient_clip)
optimizer.step()
total_loss += loss.item() * inputs.size(0)
_, predicted = outputs.max(1)
correct += predicted.eq(labels).sum().item()
total += labels.size(0)
return total_loss / total, correct / total
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--local_rank", type=int, default=-1)
args = parser.parse_args()
config = TrainingConfig()
config.local_rank = args.local_rank
rank = init_distributed(config)
world_size = dist.get_world_size()
print(f"Initialisierung von Prozess {rank}/{world_size} abgeschlossen")
# Das Modell erstellen
model = YourModel().cuda(rank)
model = DDP(model, device_ids=[rank])
# Optimierer
optimizer = optim.Adam(model.parameters(), lr=config.lr)
# GradScaler (bei Verwendung gemischter Präzision)
scaler = GradScaler() if config.use_amp else Keine
# Dataset (durch Ihr Dataset ersetzen)
dataset = YourDataset()
loader, sampler = create_dataloader(dataset, config, world_size, rank)
criterion = nn.CrossEntropyLoss()
# Trainingsschleife
for epoch in range(config.epochs):
sampler.set_epoch(epoch)
loss, acc = train_epoch(model, loader, criterion, optimizer, scaler, config, rank)
# Nur auf Rang 0 ausgeben
if rank == 0:
print(f"Epoch {epoch+1}/{config.epochs}: Loss={loss:.4f}, Acc={acc:.4f}")
dist.destroy_process_group()
# Startmethode:
# torchrun --nnodes=2 --nproc_per_node=4 --node_rank=0 --master_addr=192.168.1.1 --master_port=29500 train.py
# torchrun --nnodes=2 --nproc_per_node=4 --node_rank=1 --master_addr=192.168.1.1 --master_port=29500 train.py
Der Schlüssel zum verteilten Training ist: 1) den geeigneten Parallelmodus wählen (Datenparallelität vs. Modellparallelität); 2) DDP anstelle von DataParallel für bessere Leistung verwenden; 3) mit Mixed-Precision-Training kombinieren, um weiter zu beschleunigen; 4) den Data Loader und die Kommunikationsparameter richtig konfigurieren.
7. Monitoring und Debugging beim verteilten Training
7.1 Gängige Monitoring-Tools
Beispiel
def monitor_training(rank, world_size):
"""Status des verteilten Trainings überwachen"""
# 1. Status der Prozessgruppe prüfen
print(f"Rang: {rank}, Weltgröße: {world_size}")
print(f"Backend: {dist.get_backend()}")
print(f"Rang: {dist.get_rank()}")
print(f"CUDA-Gerät: {torch.cuda.current_device()}")
# 2. GPU-Speichernutzung überwachen
if torch.cuda.is_available():
for i in range(torch.cuda.device_count()):
allocated = torch.cuda.memory_allocated(i) / 1024**2
reserved = torch.cuda.memory_reserved(i) / 1024**2
print(f"GPU {i}: belegt {allocated:.1f} MB, reserviert {reserved:.1f} MB")
# 3. Gradientensynchronisation überwachen
# DDP zeichnet Synchronisationszeit automatisch auf
# Detaillierte Protokollierung kann durch Setzen von Umgebungsvariablen aktiviert werden
# os.environ["NCCL_DEBUG"] = "INFO"
# Regelmäßig in der Trainingsschleife aufrufen
monitor_training(rank, dist.get_world_size())
7.2 Debugging-Tipps
- Zuerst auf einer einzelnen Maschine testen, dann auf mehrere Maschinen skalieren
- Verwenden Sie
os.environ["NCCL_DEBUG"] = "INFO"Detaillierte Kommunikationslogs anzeigen - Stellen Sie sicher, dass die Uhren auf allen Maschinen synchronisiert sind (mithilfe von NTP)
- Prüfen Sie, ob die Firewall die NCCL-Kommunikationsports zulässt
Andere ErweiterungenObwohl verteiltes Training Komplexität hinzufügt, ist die dadurch erzielte Leistungsverbesserung erheblich. Für das Training großer Modelle ist es fast eine unverzichtbare Technik.