Pipeline Parallelism

Pipeline Parallelism ist eine fortgeschrittene distributed training-Technik, die entwickelt wurde, um ein großes neural network (NN) über mehrere Rechengeräte wie GPUs hinweg aufzuteilen, indem das Modell in der Tiefe getrennt wird. Wenn die model weights und Optimizer-Zustände einer modernen Architektur die Speicherlimits eines einzelnen Beschleunigers überschreiten, unterteilen Ingenieure die sequenziellen Schichten des Netzwerks in „Stufen“. Beispielsweise können sich die ersten 10 Schichten auf GPU 0 befinden, während die nachfolgenden 10 Schichten auf GPU 1 liegen. Während des forward pass fließt die Daten von einem Gerät zum nächsten. Durch die Verknüpfung dieser Geräte können Forscher massive deep learning (DL)-Algorithmen trainieren, ohne auf hardwarebedingte out-of-memory errors zu stoßen.

Wie Pipeline-Parallelismus funktioniert#

Eine naive Implementierung der Aufteilung von Schichten auf verschiedene Geräte führt zu gravierenden Ineffizienzen, die als „Pipeline-Blasen“ bekannt sind. Da Schichten nacheinander verarbeitet werden, bleibt GPU 1 völlig im Leerlauf, während GPU 0 die anfänglichen Schichten verarbeitet. Um die Hardwareauslastung zu maximieren, unterteilen moderne Pipeline-Scheduler die globale batch size in kleinere „Mikro-Batches“.

Anstatt darauf zu warten, dass ein ganzer Batch fertiggestellt wird, beginnt GPU 0 sofort mit der Verarbeitung des zweiten Mikro-Batches, sobald sie den ersten Mikro-Batch an GPU 1 übergeben hat. Tools wie Microsoft DeepSpeed und die PyTorch Distributed Pipelining API verwenden häufig die 1F1B (One Forward, One Backward) scheduling strategy. Diese Methode wechselt sich bei der gleichzeitigen Berechnung von Vorwärts- und Rückwärtsdurchläufen für verschiedene Mikro-Batches ab, wodurch Pipeline-Blasen und der Speicherverbrauch erheblich minimiert werden. Neuere Entwicklungen aus den Jahren 2024 und 2025 führen sogar Zero Bubble Pipeline Parallelism ein, eine Optimizer-bewusste Gewichtsvorhersagestrategie, die Leerlaufzeiten in Rechenclustern nahezu eliminiert.

Unterscheidung 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 Parallelism: Im Gegensatz zur tiefenbezogenen Aufteilung des Pipeline-Parallelismus verteilt der Tensor-Parallelismus einzelne Matrixoperationen horizontal auf GPUs. Diese beiden Techniken werden häufig kombiniert, um den Durchsatz zu maximieren.
• Data Parallelism: Der Datenparallelismus repliziert das gesamte Modell auf jeder GPU und verteilt die Trainingsdaten auf diese. Für kompakte, hochgradig optimierte object detection- und image segmentation-Architekturen wie das Ultralytics YOLO26-Modell, das nativ in den VRAM eines einzelnen Geräts passt, ist der Datenparallelismus über PyTorchs DistributedDataParallel (DDP) die bevorzugte Methode zur Beschleunigung des Trainings.

Praxisanwendungen in KI und ML#

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

• Training 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.
• High-Resolution Medical Diagnostics: In AI in healthcare und der wissenschaftlichen Modellierung erzeugen dreidimensionale volumetrische Scans oft Aktivierungen, die für einen einzelnen Beschleuniger zu massiv sind. Das Pipelining von Netzwerkschichten über Knoten hinweg ermöglicht es Forschungskrankenhäusern, tiefe Netzwerke auf enormen MRI-Datensätzen zu trainieren, ohne die Bildauflösung zu beeinträchtigen.

Code-Beispiel: Konzept der Schichtpartitionierung#

Historisch gesehen erforderte das Verteilen von Schichten über Geräte hinweg komplexen, maßgeschneiderten Code. Heute ordnet die zugrunde liegende Logik spezifische Schichten verschiedenen Gerätekennungen zu. Unten ist eine konzeptionelle Darstellung zu sehen, wie Netzwerkstufen in PyTorch auf Geräte aufgeteilt werden, womit das Fundament für parallele Pipeline-Operationen gelegt wird:

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 ein optimiertes model deployment und eine automatisierte Multi-GPU-Nutzung vertrauen Entwickler auf die Ultralytics Platform, um Workloads automatisch zu skalieren. Mithilfe robuster model training tips abstrahiert die Plattform das Infrastrukturmanagement, sodass sich Ingenieure ganz auf die Entwicklung präziser KI-Lösungen konzentrieren können, die real-time inference ermöglichen.