Pipeline Parallelism

Pipeline-Parallelismus ist eine fortschrittliche Technik für verteiltes Training, die darauf ausgelegt ist, ein großes neuronales Netz (NN) über mehrere Rechengeräte wie GPUs hinweg zu partitionieren, indem das Modell in der Tiefe getrennt wird. Wenn die Modellgewichte und Optimizer-Zustände einer modernen Architektur die Speichergrenzen eines einzelnen Beschleunigers überschreiten, unterteilen Entwickler die sequentiellen Schichten des Netzwerks in "Stufen". Zum Beispiel könnten die ersten 10 Schichten auf GPU 0 liegen, während die nachfolgenden 10 Schichten auf GPU 1 liegen. Während des Forward Pass fließen die Daten von einem Gerät zum nächsten. Durch die Kopplung dieser Geräte können Forscher massive Deep-Learning (DL)-Algorithmen trainieren, ohne auf hardwarebedingte Out-of-Memory-Fehler zu stoßen.

Link to this sectionWie Pipeline-Parallelismus funktioniert#

Eine naive Implementierung der Aufteilung von Schichten auf Geräte führt zu erheblichen Ineffizienzen, die als "Pipeline-Bubbles" bekannt sind. Da Schichten sequentiell verarbeitet werden, bleibt GPU 1 völlig untätig, während GPU 0 die ersten Schichten verarbeitet. Um die Hardwareauslastung zu maximieren, unterteilen moderne Pipeline-Scheduler die globale Batch-Größe in kleinere "Micro-Batches".

Anstatt darauf zu warten, dass ein ganzer Batch fertiggestellt wird, beginnt GPU 0 sofort mit der Verarbeitung des zweiten Micro-Batchs, sobald es das erste Micro-Batch an GPU 1 weitergegeben hat. Tools wie Microsoft DeepSpeed und die PyTorch Distributed Pipelining API verwenden häufig die 1F1B (One Forward, One Backward) Scheduling-Strategie. Diese Methode wechselt gleichzeitig zwischen dem Berechnen von Forward- und Backward-Pässen für verschiedene Micro-Batches, was Pipeline-Bubbles und den Speicherverbrauch erheblich minimiert. Neuere Fortschritte der Jahre 2024 und 2025 führen sogar Zero Bubble Pipeline Parallelism ein, eine Optimizer-bewusste Strategie zur Gewichtsvorhersage, die Leerlaufzeiten über Rechencluster hinweg nahezu eliminiert.

Link to this sectionUnterscheidung verwandter Parallelisierungstechniken#

Pipeline-Parallelismus operiert innerhalb eines breiteren Ökosystems von Strategien für verteiltes Rechnen. Das Verständnis der Unterschiede ist entscheidend, um KI-Modelle effektiv zu skalieren:

• Modellparallelismus: Dies ist der übergeordnete Begriff für das Aufteilen eines Modells auf Geräte. Pipeline-Parallelismus ist eine sehr spezifische Form des Modellparallelismus, die die Architektur sequentiell nach Tiefe partitioniert.
• Tensor-Parallelismus: Im Gegensatz zu den tiefenorientierten Aufteilungen des Pipeline-Parallelismus unterteilt Tensor-Parallelismus einzelne Matrixoperationen horizontal über GPUs. Diese beiden Techniken werden häufig kombiniert, um den Durchsatz zu maximieren.
• Datenparallelismus: Datenparallelismus repliziert das gesamte Modell auf jeder GPU und verteilt die Trainingsdaten auf diese. Für kompakte, hochoptimierte Architekturen zur Objekterkennung und Bildsegmentierung, wie das Ultralytics YOLO26-Modell, das nativ in den VRAM eines einzelnen Geräts passt, ist Datenparallelismus mittels PyTorch DistributedDataParallel (DDP) die bevorzugte Methode zur Beschleunigung des Trainings.

Link to this sectionPraxisanwendungen in KI und ML#

Die Skalierung komplexer Infrastrukturen ist für den Aufbau moderner, hochmoderner KI-Systeme unerlässlich:

• Training von Foundation Models: Die Entwicklung gigantischer Large Language Models (LLMs) und Foundation Models wie Metas Llama 3 erfordert die Kombination von Tensor-, Daten- und Pipeline-Parallelismus. Frameworks wie NVIDIA Megatron-LM nutzen diese Strategien, um massive Mixture-of-Experts (MoE)-Architekturen über Tausende von GPUs auf Cloud-Plattformen wie AWS SageMaker zu trainieren.
• Hochauflösende medizinische Diagnostik: In KI im Gesundheitswesen und der wissenschaftlichen Modellierung erzeugen 3D-Volumenscans oft Aktivierungen, die für einen einzelnen Beschleuniger zu massiv sind. Das Pipelining von Netzwerkschichten über Knoten hinweg ermöglicht es Forschungskliniken, tiefe Netzwerke auf riesigen MRI-Datensätzen zu trainieren, ohne die Bildauflösung zu beeinträchtigen.

Link to this sectionCode-Beispiel: Konzept der Schichtpartitionierung#

Historisch gesehen erforderte die Verteilung von Schichten auf Geräte komplexen, benutzerdefinierten Code. Heute bildet die grundlegende Logik spezifische Schichten auf verschiedene Gerätekennungen ab. Unten ist eine konzeptionelle Darstellung, wie Netzwerkstufen in PyTorch über Geräte hinweg aufgeteilt werden, was das Fundament für Pipeline-parallele Operationen bildet:

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 Foundation Models eine komplexe Orchestrierung erfordert, ist die Bereitstellung schneller und skalierbarer Computer-Vision (CV)-Projekte im Allgemeinen einfacher. Für eine optimierte Modellbereitstellung und automatisierte Multi-GPU-Nutzung vertrauen Entwickler auf die Ultralytics Platform, um Workloads automatisch zu skalieren. Unter Nutzung robuster Tipps zum Modelltraining abstrahiert die Plattform das Infrastrukturmanagement, sodass sich Ingenieure vollständig auf den Aufbau präziser KI-Lösungen konzentrieren können, die Echtzeit-Inferenz ermöglichen.