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
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:

  1. Modellreplikation: Das Modell auf jede GPU kopieren
  2. Datenverteilung: Batch-Daten gleichmäßig auf jede GPU verteilen.
  3. Parallele Berechnung: Jede GPU berechnet den Forward Pass unabhängig.
  4. Gradientenaggregation: Gradienten von allen GPUs auf der Haupt-GPU aggregieren.
  5. Parameteraktualisierung: Die Haupt-GPU aktualisiert die Parameter und synchronisiert sie mit der Haupt-GPU.

Beispiel

# Beschreibung der wichtigsten DataParallel-Parameter
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
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

# Methode 1: Verwendung von torchrun (empfohlen, PyTorch 2.0+)
# 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

# Vollständiges DDP-Trainingsskript (speichern als train_ddp.py)
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 aufrufensampler.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
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:

  1. Jede GPU teilt die Gradienten in n Teile auf (n ist die Anzahl der GPUs)
  2. Jede GPU tauscht einen Gradiententeil mit einer benachbarten GPU aus
  3. Nach n-maliger Wiederholung hat jede GPU die vollständigen Gradienten

Beispiel

# DDP-Konfiguration zur Gradientensynchronisierung

# 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

# Beispiel für Modellparallelismus: verschiedene Schichten des Modells auf verschiedene GPUs verteilen

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

# Beispiel für Pipeline-Parallelismus (erfordert die Installation der Abhängigkeit torch-pipeline)
# 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

# Vollständige Vorlage für ein Multi-Node-Multi-GPU-Trainingsskript

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

# Monitoring-Code für verteiltes Training

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 Sieos.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

Obwohl 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.

Andere Erweiterungen