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.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 :
- Réplication du modèle: Copier le modèle sur chaque GPU.
- Répartition des données: Répartir uniformément les données du lot sur chaque GPU.
- Calcul parallèle: Chaque GPU calcule indépendamment la passe avant.
- Agrégation des gradients: Agréger les gradients de tous les GPU vers le GPU principal.
- Mise à jour des paramètres: Le GPU principal met à jour les paramètres et les synchronise avec les autres GPU.
Exemple
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.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
# 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
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 appeler
sampler.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.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 :
- Chaque GPU divise les gradients en n parties (n est le nombre de GPU)
- Chaque GPU échange une partie de gradient avec un GPU adjacent
- Après avoir répété n fois, chaque GPU possède les gradients complets
Exemple
# 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
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
# 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
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
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
- Utiliser
os.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
Autres extensionsBien 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.