Pipeline Parallelism

Le parallélisme de pipeline est une technique avancée d'entraînement distribué conçue pour partitionner un grand réseau de neurones (NN) sur plusieurs périphériques informatiques, tels que des GPU, en séparant le modèle par profondeur. Lorsque les poids du modèle et les états de l'optimiseur d'une architecture moderne dépassent les limites de mémoire d'un seul accélérateur, les ingénieurs divisent les couches séquentielles du réseau en « étapes ». Par exemple, les 10 premières couches peuvent résider sur le GPU 0, tandis que les 10 couches suivantes résident sur le GPU 1. Lors de la passe avant, les données circulent d'un périphérique à l'autre. En chaînant ces périphériques, les chercheurs peuvent entraîner des algorithmes massifs d'apprentissage profond (DL) sans rencontrer d'erreurs de mémoire insuffisante liées au matériel.

Link to this sectionComment fonctionne le parallélisme de pipeline#

Une implémentation naïve consistant à diviser les couches entre les périphériques conduit à des inefficacités sévères appelées « bulles de pipeline ». Étant donné que les couches traitent de manière séquentielle, le GPU 1 reste totalement inactif pendant que le GPU 0 traite les couches initiales. Pour maximiser l'utilisation du matériel, les ordonnanceurs de pipeline modernes divisent la taille de lot globale en « micro-lots » plus petits.

Au lieu d'attendre qu'un lot entier soit terminé, le GPU 0 commence immédiatement à traiter le deuxième micro-lot dès qu'il transmet le premier micro-lot au GPU 1. Des outils comme Microsoft DeepSpeed et la PyTorch Distributed Pipelining API utilisent couramment la stratégie d'ordonnancement 1F1B (One Forward, One Backward). Cette méthode alterne le calcul des passes avant et arrière pour différents micro-lots simultanément, minimisant ainsi considérablement les bulles de pipeline et la consommation de mémoire. Les avancées récentes de 2024 et 2025 introduisent même le Zero Bubble Pipeline Parallelism, une stratégie de prédiction de poids consciente de l'optimiseur qui élimine presque totalement les temps d'inactivité au sein des clusters informatiques.

Link to this sectionDistinction des techniques de parallélisme connexes#

Le parallélisme de pipeline opère au sein d'un écosystème plus large de stratégies informatiques distribuées. Comprendre les différences est crucial pour mettre à l'échelle les modèles d'IA efficacement :

• Parallélisme de modèle : C'est le terme global pour diviser un modèle entre plusieurs périphériques. Le parallélisme de pipeline est une forme très spécifique de parallélisme de modèle qui partitionne l'architecture séquentiellement par profondeur.
• Parallélisme de tenseur : Contrairement aux divisions par profondeur du parallélisme de pipeline, le parallélisme de tenseur fragmente les opérations matricielles individuelles horizontalement entre les GPU. Ces deux techniques sont fréquemment combinées pour maximiser le débit.
• Parallélisme de données : Le parallélisme de données réplique le modèle entier sur chaque GPU et distribue les données d'entraînement parmi eux. Pour des architectures compactes et hautement optimisées de détection d'objets et de segmentation d'image comme le modèle Ultralytics YOLO26, qui tient nativement dans la VRAM d'un seul appareil, le parallélisme de données via DistributedDataParallel (DDP) de PyTorch est la méthode privilégiée pour accélérer l'entraînement.

Link to this sectionApplications concrètes en IA et ML#

La mise à l'échelle d'infrastructures complexes est essentielle pour construire des systèmes d'IA modernes à la pointe de la technologie :

• Entraînement de modèles de fondation : Développer des grands modèles de langage (LLM) et des modèles de fondation gigantesques, comme Llama 3 de Meta, nécessite de combiner le parallélisme de tenseur, de données et de pipeline. Des frameworks comme NVIDIA Megatron-LM exploitent ces stratégies pour entraîner des architectures massives de mélange d'experts (MoE) sur des milliers de GPU sur des plateformes cloud comme AWS SageMaker.
• Diagnostics médicaux haute résolution : Dans le domaine de l'IA dans la santé et de la modélisation scientifique, les scans volumétriques 3D produisent souvent des activations trop massives pour un seul accélérateur. Le pipeline des couches réseau entre les nœuds permet aux hôpitaux de recherche d'entraîner des réseaux profonds sur d'immenses ensembles de données IRM sans compromettre la résolution de l'image.

Link to this sectionExemple de code : Concept de partitionnement des couches#

Historiquement, la distribution des couches entre les périphériques nécessitait un code personnalisé complexe. Aujourd'hui, la logique fondamentale mappe des couches spécifiques à différents identifiants de périphériques. Voici une représentation conceptuelle de la manière dont les étapes du réseau sont divisées entre les périphériques dans PyTorch, posant les bases des opérations parallèles de pipeline :

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"))

Bien que la création de modèles de fondation nécessite une orchestration complexe, le déploiement de projets de vision par ordinateur (CV) rapides et évolutifs est généralement plus simple. Pour un déploiement de modèle rationalisé et une utilisation multi-GPU automatisée, les développeurs font confiance à la plateforme Ultralytics pour mettre à l'échelle les charges de travail automatiquement. En exploitant des conseils d'entraînement de modèle robustes, la plateforme abstrait la gestion de l'infrastructure, permettant aux ingénieurs de se concentrer entièrement sur la création de solutions d'IA précises capables d'inférence en temps réel.