Pipeline Parallelism

Pipeline-Parallelismus ist eine fortgeschrittene Technik für das verteilte Training, bei der ein großes neuronales Netzwerk (NN) auf mehrere Rechengeräte wie GPUs verteilt wird, indem das Modell entlang seiner Tiefe aufgeteilt wird. Wenn die Modellgewichte und Optimierungszustände einer modernen Architektur die Speicherkapazität eines einzelnen Beschleunigers überschreiten, teilen Ingenieure die aufeinanderfolgenden Netzwerkschichten in „Stufen“ auf. Beispielsweise könnten sich die ersten 10 Schichten auf GPU 0 und die nächsten 10 Schichten auf GPU 1 befinden. Während des Vorwärtsdurchlaufs fließen die Daten von einem Gerät zum nächsten. Durch das Verketten dieser Geräte können Forschende umfangreiche Deep-Learning-(DL)-Algorithmen trainieren, ohne auf hardwarebedingte Speicherüberlauffehler zu stoßen.

Funktionsweise des Pipeline-Parallelismus#

Eine naive Implementierung, bei der die Schichten auf Geräte verteilt werden, führt zu erheblichen Ineffizienzen, die als „Pipeline-Blasen“ bezeichnet werden. Da die Schichten sequenziell verarbeitet werden, bleibt GPU 1 vollständig ungenutzt, während GPU 0 die anfänglichen Schichten verarbeitet. Um die Hardwarenutzung zu maximieren, teilen moderne Pipeline-Planer die globale Batchgröße in kleinere „Mikro-Batches“ auf.

Anstatt auf den Abschluss eines gesamten Batches zu warten, beginnt GPU 0 sofort mit der Verarbeitung des zweiten Mikro-Batches, sobald es den ersten Mikro-Batch an GPU 1 übergeben hat. Werkzeuge wie Microsoft DeepSpeed und die PyTorch Distributed Pipelining API verwenden häufig die 1F1B-(Ein Vorwärtsdurchlauf, ein Rückwärtsdurchlauf)-Planungsstrategie. Bei dieser Methode werden Vorwärts- und Rückwärtsdurchläufe für verschiedene Mikro-Batches abwechselnd und gleichzeitig berechnet, wodurch Pipeline-Blasen und Speicherverbrauch deutlich reduziert werden. Neuere Entwicklungen aus den Jahren 2024 und 2025 führen sogar den Pipeline-Parallelismus ohne Blasen ein, eine gewichtsoptimiererbewusste Strategie zur Gewichtsvorhersage, die die Leerlaufzeit in Rechenclustern nahezu vollständig beseitigt.

Abgrenzung verwandter Parallelisierungstechniken#

Pipeline-Parallelismus ist Teil eines umfassenderen Ökosystems von Strategien für verteiltes Rechnen. Für die effektive Skalierung von KI-Modellen ist es entscheidend, die Unterschiede zu verstehen:

• Modellparallelismus: Dies ist der Oberbegriff für die Aufteilung eines Modells auf mehrere Geräte. Pipeline-Parallelismus ist eine sehr spezifische Form des Modellparallelismus, bei der die Architektur sequenziell entlang ihrer Tiefe aufgeteilt wird.
• Tensorparallelismus: Im Gegensatz zur Aufteilung entlang der Tiefe beim Pipeline-Parallelismus verteilt der Tensorparallelismus einzelne Matrixoperationen horizontal auf mehrere GPUs. Diese beiden Techniken werden häufig kombiniert, um den Durchsatz zu maximieren.
• Datenparallelismus: Beim Datenparallelismus wird das gesamte Modell auf jeder GPU repliziert und die Trainingsdaten werden auf diese verteilt. Für kompakte, hochoptimierte Architekturen zur Objekterkennung und Bildsegmentierung wie das Modell Ultralytics YOLO26, das nativ in den VRAM eines einzelnen Geräts passt, ist Datenparallelismus über PyTorch DistributedDataParallel (DDP) die bevorzugte Methode zur Beschleunigung des Trainings.

Praktische Anwendungen in KI und maschinellem Lernen#

Die Skalierung komplexer Infrastrukturen ist entscheidend für die Entwicklung moderner KI-Systeme auf dem neuesten Stand der Technik:

• Training von Basismodellen: Die Entwicklung gigantischer großer Sprachmodelle (LLMs) und Basismodelle wie Metas Llama 3 erfordert die Kombination aus Tensor-, Daten- und Pipeline-Parallelismus. Frameworks wie NVIDIA Megatron-LM nutzen diese Strategien, um umfangreiche Expertenmischungs-(MoE)-Architekturen auf Tausenden von GPUs auf Cloud-Plattformen wie AWS SageMaker zu trainieren.
• Medizinische Diagnostik mit hoher Auflösung: Beim Einsatz von KI im Gesundheitswesen und bei der wissenschaftlichen Modellierung erzeugen dreidimensionale Volumenscans häufig Aktivierungen, die zu umfangreich für einen einzelnen Beschleuniger sind. Durch die Pipeline-Verarbeitung von Netzwerkschichten über mehrere Knoten hinweg können Forschungskliniken tiefe Netzwerke auf umfangreichen MRI-Datensätzen trainieren, ohne die Bildauflösung zu beeinträchtigen.

Codebeispiel: Konzept der Schichtpartitionierung#

Früher erforderte die Verteilung von Schichten auf mehrere Geräte komplexen, individuell erstellten Code. Heute ordnet die grundlegende Logik bestimmte Schichten verschiedenen Gerätekennungen zu. Nachfolgend siehst du eine konzeptionelle Darstellung, wie Netzwerkstufen in PyTorch auf mehrere Geräte verteilt werden und damit die Grundlage für Pipeline-Parallelismus bilden:

import torch.nn as nn


class SimplePipelineModel(nn.Module):
    def __init__(self):
        super().__init__()
        # Stage 1 is assigned to the first GPU
        self.stage1 = nn.Sequential(nn.Linear(1024, 1024), nn.ReLU()).to("cuda:0")
        # Stage 2 is assigned to the second GPU
        self.stage2 = nn.Sequential(nn.Linear(1024, 1024), nn.ReLU()).to("cuda:1")

    def forward(self, x):
        # The forward pass seamlessly crosses device boundaries
        x_out = self.stage1(x.to("cuda:0"))
        return self.stage2(x_out.to("cuda:1"))

Während die Erstellung von Basismodellen eine komplexe Orchestrierung erfordert, ist die Bereitstellung schneller und skalierbarer Projekte im Bereich des maschinellen Sehens (CV) im Allgemeinen einfacher. Für eine optimierte Modellbereitstellung und die automatisierte Nutzung mehrerer GPUs verlassen sich Entwickler auf die Ultralytics Platform, um Workloads automatisch zu skalieren. Mithilfe bewährter Tipps zum Modelltraining abstrahiert die Plattform die Infrastrukturverwaltung, sodass sich Ingenieure ganz auf die Entwicklung präziser KI-Lösungen mit Echtzeit-Inferenz konzentrieren können.