Entraînement distribué PyTorch

Lorsque les modèles deviennent plus grands et que les données augmentent, un seul GPU ne peut plus satisfaire les besoins d'entraînement.

L'entraînement distribué utilise le calcul parallèle sur plusieurs GPU, voire plusieurs machines, ce qui réduit considérablement le temps d'entraînement.

Cette section détaille les techniques d'entraînement distribué dans PyTorch, notamment DataParallel, DistributedDataParallel et l'entraînement distribué en précision mixte.


1. Bases de l'entraînement distribué

1.1 Pourquoi avons-nous besoin de l'entraînement distribué

La taille des modèles d'apprentissage profond augmente d'année en année, et le temps d'entraînement augmente en conséquence. L'objectif principal de l'entraînement distribué est :Répartir les tâches de calcul sur plusieurs unités de calcul afin de terminer l'entraînement de modèles et de données à grande échelle dans un délai acceptable.。

L'entraînement distribué résout principalement deux problèmes :

  • Mémoire insuffisante: Les paramètres, les états de l'optimiseur et les gradients des grands modèles nécessitent une grande quantité de mémoire GPU.
  • Temps d'entraînement excessif: L'entraînement d'un grand modèle sur un seul GPU peut prendre des semaines, voire des mois.

1.2 Deux modes majeurs d'entraînement distribué

L'entraînement distribué se divise principalement en deux modes :

Mode Principe Scénario d'application
Parallélisme de données Chaque unité de calcul stocke un modèle complet ; différentes unités de calcul traitent des données différentes. Le modèle peut tenir dans la mémoire GPU d'une seule carte ; un grand volume de données nécessite un entraînement accéléré ; de petites équipes disposant de ressources matérielles limitées.
Parallélisme de modèle Répartir le modèle sur plusieurs unités de calcul ; chaque unité de calcul ne stocke qu'une partie du modèle. Le modèle est trop grand pour tenir sur une seule carte ; clusters dédiés, entraînement multi-machine.

Dans des environnements de production réels, le parallélisme de données est l'approche la plus couramment utilisée. PyTorch propose deux implémentations : DataParallel et DistributedDataParallel.


2. Guide d'utilisation de DataParallel

2.1 Multi-GPU sur une seule machine : DataParallel

DataParallel(DP)C'est la méthode d'entraînement multi-GPU la plus simple fournie par PyTorch. Il suffit de modifier quelques lignes de code pour effectuer un entraînement avec plusieurs GPU sur une seule machine.

Exemple

import torch
import torch.nn as nn
import torch.optim as optim

# ── Définition du modèle ──────────────────────────────────────
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)


# Vérifier le nombre de GPU disponibles
print(f"Nombre de GPU disponibles : {torch.cuda.device_count()}")

# Créer le modèle et le déplacer vers le GPU
model = SimpleModel()

# ── Méthode 1 : Utiliser DataParallel (méthode la plus simple)───────
if torch.cuda.device_count() > 1:
    model = nn.DataParallel(model)

# Déplacer vers le GPU (si vous utilisez DataParallel, les device_ids sont gérés automatiquement)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)

# Fonction de perte et optimiseur
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=1e-3)

# ── Boucle d’entraînement ──────────────────────────────────────
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


# Données simulées
train_loader = [
    (torch.randn(32, 128), torch.randint(0, 10, (32,))) for _ in range(10)
]

# Démarrer l'entraînement
for epoch in range(3):
    loss, acc = train_epoch_dp(model, train_loader, criterion, optimizer, device)
    print(f"Époque {epoch+1}: Perte={loss:.4f}, Exactitude={acc:.4f}")

print("Entraînement DataParallel terminé !")

2.2 Comment fonctionne DataParallel

Le flux de travail de DataParallel est le suivant :

  1. Réplication du modèle: Copier le modèle sur chaque GPU.
  2. Répartition des données: Répartir uniformément les données du lot sur chaque GPU.
  3. Calcul parallèle: Chaque GPU calcule indépendamment la passe avant.
  4. Agrégation des gradients: Agréger les gradients de tous les GPU vers le GPU principal.
  5. Mise à jour des paramètres: Le GPU principal met à jour les paramètres et les synchronise avec les autres GPU.

Exemple

# Description des paramètres clés de DataParallel
model = nn.DataParallel(
    module,                    # Le modèle à paralléliser (requis)
    device_ids=[0, 1, 2, 3],   # ID des périphériques GPU à utiliser ; par défaut, tous les GPU sont utilisés
    output_device=0,            # Périphérique de regroupement des résultats de sortie ; par défaut, le premier GPU
    dim=0                      # Dimension selon laquelle les données sont réparties ; par défaut, la dimension du lot
)

# Vérifier le périphérique du modèle actuel
print(f"Périphérique du modèle : {next(model.parameters()).device}")

# Vérifier les périphériques réellement utilisés
print(f"Nombre de GPU utilisés : {model.device_ids if hasattr(model, 'device_ids') else 'N/A'}")

DataParallel est simple et facile à utiliser, mais présente deux problèmes principaux : 1) le GPU principal subit une forte pression mémoire (il doit agréger les gradients) ; 2) l’efficacité de communication entre les GPU est faible. Par conséquent, la recommandation officielle est d’utiliser DistributedDataParallel.


3. Explication détaillée de DistributedDataParallel

3.1 Bases de DDP

DistributedDataParallel(DDP)Il s'agit de la méthode d'entraînement distribué recommandée par PyTorch. Comparé à DataParallel, DDP présente les avantages suivants :

  • Chaque GPU calcule les gradients indépendamment, sans avoir besoin de les agréger sur le GPU principal.
  • Utilise un algorithme efficace de synchronisation des gradients (Ring AllReduce).
  • Prend en charge l'entraînement multi-machine et multi-GPU.
  • Vitesse d'entraînement plus rapide et utilisation de la mémoire plus efficace.

3.2 Entraînement DDP mono-machine multi-GPU

Exemple

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

# ── Initialiser l'environnement distribué ────────────────────────────
def setup(rank, world_size):
    """Configurer l'environnement distribué"""
    # Définir le GPU utilisé par le processus actuel
    torch.cuda.set_device(rank)

    # Initialiser le groupe de processus
    dist.init_process_group(
        backend="nccl",           # Utiliser le backend NCCL (recommandé pour GPU)
        init_method="env://",     # Méthode d'initialisation par variable d'environnement
        world_size=world_size,    # Nombre total de processus
        rank=rank                 # Rang du processus courant
    )


def cleanup():
    """Nettoyer l'environnement distribué"""
    dist.destroy_process_group()


# ── Chargeur de données (prise en charge distribuée)───────────────────────
def get_distributed_loader(batch_size, world_size):
    """Créer un chargeur de données avec prise en charge distribuée"""
    from torch.utils.data import DataLoader, DistributedSampler

    # Jeu de données simulé
    dataset = torch.utils.data.TensorDataset(
        torch.randn(100, 3, 32, 32),
        torch.randint(0, 10, (100,))
    )

    # DistributedSampler répartit automatiquement les données
    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


# ── Définition du modèle ──────────────────────────────────────
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


# ── Fonction d'entraînement DDP ──────────────────────────────────
def train_ddp(rank, world_size, epochs=3):
    """Fonction principale pour l'entraînement distribué"""
    # Initialiser
    setup(rank, world_size)

    # Créer le modèle et le déplacer vers le GPU correspondant
    model = ImageClassifier().cuda(rank)

    # L'envelopper en tant que modèle DDP
    ddp_model = DDP(
        model,
        device_ids=[rank],        # Spécifier le périphérique utilisé par le processus actuel
        output_device=rank,
        find_unused_parameters=False  # Indique s'il faut détecter les paramètres inutilisés
    )

    # Fonction de perte et optimiseur
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(ddp_model.parameters(), lr=1e-3)

    # Obtenir le chargeur de données
    loader = get_distributed_loader(batch_size=16, world_size=world_size)

    # Boucle d'entraînement
    for epoch in range(epochs):
        # Définir le numéro d'époque au début de chaque époque (utilisé pour mélanger les données)
        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"Époque {epoch+1}, Lot {batch_idx}, Perte : {loss.item():.4f}")

    # Nettoyage
    if rank == 0:
        print("Entraînement terminé !")
    nettoyage()


# Remarque : lors de l'exécution réelle, vous devez spécifier rank et world_size via des arguments de ligne de commande
# Ce code doit s'exécuter indépendamment dans chaque processus

3.3 Lancement de l'entraînement distribué

L'entraînement distribué PyTorch doit être lancé viatorchrunoutorch.distributed.launch. Voici les méthodes de lancement courantes :

Exemple

# Méthode 1 : Utilisation de torchrun (recommandé, PyTorch 2.0+)
# Fichier : train_ddp.py

"""
Utilisation :
torchrun --nproc_per_node=4 train_ddp.py
"
""

# Méthode 2 : Utilisation de python -m (méthode traditionnelle)
"""
python -m torch.distributed.launch --nproc_per_node=4 train_ddp.py
"
""

# Méthode 3 : Lancement multi-nœuds multi-GPU
# Machine 1 (nœud maître)
torchrun --nnodes=2 --nproc_per_node=4 --node_rank=0 --master_addr=192.168.1.1 --master_port=29500 train_ddp.py

# Machine 2 (nœud de travail)
torchrun --nnodes=2 --nproc_per_node=4 --node_rank=1 --master_addr=192.168.1.1 --master_port=29500 train_ddp.py

# Descriptions des paramètres :
# --nproc_per_node : nombre de GPU par nœud
# --nnodes : nombre de nœuds
# --node_rank : indice du nœud actuel (à partir de 0)
# --master_addr : adresse IP du nœud maître
# --master_port : numéro de port du nœud maître

3.4 Script complet d'entraînement DDP

Exemple

# Script complet d'entraînement DDP (enregistrer sous 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="Transmis automatiquement par torchrun")
    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)

    # Créer le modèle
    model = TrainModel().cuda(rank)
    model = DDP(model, device_ids=[rank])

    # Optimiseur et fonction de perte
    optimizer = optim.Adam(model.parameters(), lr=args.lr)
    criterion = nn.CrossEntropyLoss()

    # Jeu de données
    dataset = torch.utils.data.TensorDataset(
        torch.randn(1000, 3, 32, 32),
        torch.randint(0, 10, (1000,))
    )

    # DistributedSampler garantit que chaque processus voit des données différentes
    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
    )

    # Boucle d'entraînement
    for epoch in range(args.epochs):
        # Important : définir l'epoch à chaque epoch pour mélanger la partition de données
        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()

        # Synchroniser tous les processus pour garantir que chaque processus termine l'epoch en cours
        dist.barrier()

        if rank == 0:
            avg_loss = epoch_loss / len(loader)
            print(f"Époque {epoch+1}/{args.epochs}, Perte : {avg_loss:.4f}")

    nettoyage()


if __name__ == "__main__":
    args = parse_args()

    # Obtenir world_size à partir des variables d'environnement
    world_size = int(os.environ["WORLD_SIZE"])

    # Obtenir rank à partir des variables d'environnement (défini automatiquement par torchrun)
    rank = int(os.environ["RANK"])

    if torch.cuda.is_available():
        train(rank, world_size, args)
    else:
        print("L'environnement CUDA est requis pour exécuter l'entraînement distribué")

Point clé : chaque époque doit appelersampler.set_epoch(epoch), pour garantir que la partition de données est mélangée, sinon plusieurs processus verront les mêmes données.


4. Précision mixte dans l'entraînement distribué

4.1 Combinaison DDP + AMP

Combiner l'entraînement distribué avec l'entraînement en précision mixte peut encore améliorer la vitesse d'entraînement. DDP dans PyTorch 2.0+ est entièrement intégré avec AMP.

Exemple

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):
    """Entraînement distribué + précision mixte"""
    # Initialisation
    torch.cuda.set_device(rank)
    dist.init_process_group("nccl", rank=rank, world_size=world_size)

    # Créer le modèle
    model = AMPModel().cuda(rank)
    model = DDP(model, device_ids=[rank])

    # Optimiseur et GradScaler
    optimizer = optim.Adam(model.parameters(), lr=1e-3)
    scaler = GradScaler()

    criterion = nn.CrossEntropyLoss()

    # Boucle d'entraînement
    model.train()
    for inputs, labels in loader:
        inputs = inputs.cuda(rank, non_blocking=True)
        labels = labels.cuda(rank, non_blocking=True)

        optimizer.zero_grad()

        # Utiliser autocast pour basculer automatiquement la précision
        with autocast(device_type='cuda'):
            outputs = model(inputs)
            loss = criterion(outputs, labels)

        # Utiliser scaler pour gérer la mise à l'échelle des gradients
        scaler.scale(loss).backward()

        # Écrêtage du gradient (nécessite d'abord une dé-mise à l'échelle)
        scaler.unscale_(optimizer)
        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

        scaler.step(optimizer)
        scaler.update()

    dist.destroy_process_group()


# Commande de lancement
# torchrun --nproc_per_node=4 train_ddp_amp.py

4.2 Synchronisation des gradients en entraînement distribué

DDP utiliseRing AllReducealgorithme pour la synchronisation des gradients, et cela fonctionne comme suit :

  1. Chaque GPU divise les gradients en n parties (n est le nombre de GPU)
  2. Chaque GPU échange une partie de gradient avec un GPU adjacent
  3. Après avoir répété n fois, chaque GPU possède les gradients complets

Exemple

# Configuration relative à la synchronisation des gradients DDP

# 1. Définir la taille du tampon pour les buckets de gradients
model = DDP(
    model,
    device_ids=[rank],
    gradient_as_bucket_view=True,  # Économiser la mémoire (PyTorch 1.8+)
    broadcast_buffers=False,        # Ne pas diffuser les tampons pour réduire la communication
    bucket_cap_mb=25               # Taille du bucket de gradients (MB)
)

# 2. Synchroniser manuellement les paramètres du modèle (si nécessaire)
# Dans certains scénarios, les paramètres du modèle doivent être synchronisés manuellement
def sync_params(model):
    for param in model.parameters():
        dist.broadcast(param, src=0)

# 3. Vérifier l'état de synchronisation des gradients
# DDP gère automatiquement la synchronisation des gradients ; aucune opération manuelle n'est nécessaire
# Mais il est possible de le vérifier de la manière suivante
for name, param in model.named_parameters():
    if param.grad is not None:
        print(f"{name}: grad requires_grad={param.grad.requires_grad}")

5. Parallélisme de modèle et pipeline

5.1 Parallélisme de modèle simple

Lorsque le modèle est trop grand pour tenir sur un seul GPU, il doit être réparti sur plusieurs GPU.

Exemple

# Exemple de parallélisme de modèle : placer différentes couches du modèle sur différents GPU

class ModelParallel(nn.Module):
    def __init__(self, num_gpus=2):
        super().__init__()
        self.num_gpus = num_gpus

        # Partie 1 : GPU 0
        self.features1 = nn.Sequential(
            nn.Conv2d(3, 64, 3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2)
        ).to(f"cuda:0")

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

        # Classifieur : GPU 0
        self.classifier = nn.Linear(128, 10).to(f"cuda:0")

    def forward(self, x):
        # Les données sont transmises entre différents GPU
        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


# Utiliser
model = ModelParallel(num_gpus=2)
output = model(torch.randn(1, 3, 32, 32))
print(f"Périphérique de sortie : {output.device}")

5.2 Parallélisme de pipeline

PyTorch fournittorch.distributed.pipeline.syncmodule (paquet PP) pour implémenter le parallélisme de pipeline, en divisant le modèle par couches pour former un pipeline de calcul.

Exemple

# Exemple de parallélisme de pipeline (nécessite l'installation de la dépendance torch-pipeline)
# pip install torch-pipeline

"""
# Remarque : le pipeline natif de PyTorch nécessite une version spécifique ou une bibliothèque tierce
# Ici, nous démontrons le concept avec une implémentation simplifiée

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


# Répartir le modèle sur différents GPU par couches
# 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)

# Utiliser Pipeline pour connecter le modèle
# Remarque : l'utilisation réelle nécessite l'installation de la version correspondante de la bibliothèque pipeline
# from torch.distributed.pipeline.sync import Pipe
# model = Pipe(model, chunks=4)
"""

print("Le parallélisme de pipeline nécessite l'installation supplémentaire de la bibliothèque torch-pipeline")
print("pip install torch-pipeline-sync")

6. Bonnes pratiques pour l'entraînement distribué

6.1 Conseils d'optimisation des performances

Élément d'optimisation Technique Description
Optimisation de la communication Utiliser le backend NCCL NCCL est le meilleur choix pour les GPU ; plus rapide que Gloo
Chargement des données Définir num_workers et pin_memory Définir num_workers sur le nombre de cœurs CPU ; pin_memory accélère le transfert CPU vers GPU
Synchronisation des gradients Ajuster bucket_cap_mb Les modèles plus grands peuvent augmenter le bucket ; les modèles plus petits peuvent le diminuer pour améliorer la réactivité
Précision mixte DDP + AMP Réduit le volume de communication ; améliore la vitesse d'entraînement

6.2 Problèmes courants et solutions

Problème Cause Solution
Communication lente Bande passante réseau insuffisante Utiliser InfiniBand ou un réseau haut débit
Mémoire GPU insuffisante Taille de lot trop grande Réduire la taille du lot ou utiliser l'accumulation de gradient
Charge déséquilibrée Partitionnement de modèle déraisonnable Ajuster la répartition des couches pour qu'elle soit aussi uniforme que possible
Erreur de synchronisation Gradient NaN Vérifier les paramètres d'écrêtage et de mise à l'échelle du gradient

6.3 Script complet d'entraînement multi-machine multi-GPU

Exemple

# Modèle complet de script d'entraînement multi-nœuds multi-GPU

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):
    """Initialiser l'environnement distribué"""
    # Obtenir la configuration à partir des variables d'environnement
    local_rank = config.local_rank

    # Configuration NCCL
    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):
    """Créer un chargeur de données"""
    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):
    """Entraîner une époque"""
    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:
            # Entraînement en précision mixte
            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:
            # Entraînement normal
            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"Initialisation du processus {rank}/{world_size} terminée")

    # Créer le modèle
    model = YourModel().cuda(rank)
    model = DDP(model, device_ids=[rank])

    # Optimiseur
    optimizer = optim.Adam(model.parameters(), lr=config.lr)

    # GradScaler (si utilisation de la précision mixte)
    scaler = GradScaler() if config.use_amp else Aucune

    # Jeu de données (remplacez par votre jeu de données)
    dataset = YourDataset()
    loader, sampler = create_dataloader(dataset, config, world_size, rank)

    criterion = nn.CrossEntropyLoss()

    # Boucle d'entraînement
    for epoch in range(config.epochs):
        sampler.set_epoch(epoch)

        loss, acc = train_epoch(model, loader, criterion, optimizer, scaler, config, rank)

        # Afficher uniquement sur le rang 0
        if rank == 0:
            print(f"Époque {epoch+1}/{config.epochs}: Perte={loss:.4f}, Préc={acc:.4f}")

    dist.destroy_process_group()


# Méthode de lancement :
# 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

La clé de l'entraînement distribué est : 1) choisir le mode de parallélisme approprié (parallélisme de données vs parallélisme de modèle) ; 2) utiliser DDP au lieu de DataParallel pour de meilleures performances ; 3) combiner avec l'entraînement en précision mixte pour accélérer davantage ; 4) configurer correctement le chargeur de données et les paramètres de communication.


7. Surveillance et débogage de l'entraînement distribué

7.1 Outils de surveillance courants

Exemple

# Code de surveillance de l'entraînement distribué

def monitor_training(rank, world_size):
    """Surveiller l'état de l'entraînement distribué"""
    # 1. Vérifier l'état du groupe de processus
    print(f"Rang : {rank}, Taille du monde : {world_size}")
    print(f"Backend : {dist.get_backend()}")
    print(f"Rang : {dist.get_rank()}")
    print(f"Périphérique CUDA : {torch.cuda.current_device()}")

    # 2. Surveiller l'utilisation de la mémoire GPU
    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} : alloué {allocated:.1f} MB, réservé {reserved:.1f} MB")

    # 3. Surveiller la synchronisation des gradients
    # DDP enregistre automatiquement le temps de synchronisation
    # La journalisation détaillée peut être activée en définissant des variables d'environnement
    # os.environ["NCCL_DEBUG"] = "INFO"


# Appeler périodiquement dans la boucle d'entraînement
monitor_training(rank, dist.get_world_size())

7.2 Conseils de débogage

  • Testez d'abord sur une seule machine, puis passez à plusieurs machines
  • Utiliseros.environ["NCCL_DEBUG"] = "INFO"Afficher les journaux de communication détaillés
  • Assurez-vous que les horloges de toutes les machines sont synchronisées (à l'aide de NTP)
  • Vérifiez si le pare-feu autorise les ports de communication NCCL

Bien que l'entraînement distribué ajoute de la complexité, l'amélioration des performances qu'il apporte est significative. Pour l'entraînement de grands modèles, c'est presque une technique essentielle.

Autres extensions