Entraînement multi-GPU avec DataParallel
nn.DataParallel, équilibrage de la mémoire GPU, goulots d’étranglement de la bande passante, situations où DDP est préférable.
Entraînement multi-GPU avec DataParallel est une leçon Learn AI with Python gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn AI with Python, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn AI with Python comprend 4 leçons au total.
Pourquoi utiliser plusieurs GPU
Les modèles et les lots modernes dépassent la mémoire et la puissance de calcul d'un seul GPU. L'utilisation de plusieurs GPU vous permet d'entraîner des modèles plus grands ou de traiter des lots plus volumineux en moins de temps écoulé. PyTorch propose plusieurs méthodes pour y parvenir ; la plus simple est DataParallel.
Parallélisme des données
Le parallélisme des données réplique le modèle sur chaque GPU et répartit chaque lot d'entrée entre eux. Chaque GPU effectue les calculs sur sa partition, puis les gradients sont combinés afin que toutes les répliques restent synchronisées.
nn.DataParallel
nn.DataParallel encapsule un modèle en une seule ligne. Vous lui transmettez les identifiants des GPU à utiliser, et PyTorch se charge automatiquement de répartir les entrées et de rassembler les sorties.
import torch
import torch.nn as nn
model = MyModel().cuda()
model = nn.DataParallel(model, device_ids=[0, 1])Répartition automatique du lot
Lors de la propagation avant, DataParallel répartit le lot le long de la dimension 0 entre les GPU indiqués. Un lot de 64 éléments sur deux GPU devient deux sous-lots de 32 éléments. Chaque GPU exécute le même modèle en parallèle sur son sous-lot.
# batch of 64 with device_ids=[0, 1]
# GPU 0 processes samples 0..31
# GPU 1 processes samples 32..63Moyenne des gradients
Lors de la rétropropagation, les gradients de chaque GPU sont rassemblés sur le périphérique principal et moyennés (ils sont en pratique additionnés puis mis à l'échelle), afin que la mise à jour du modèle tienne compte de l'ensemble du lot. Les répliques sont ensuite resynchronisées pour l'étape suivante.
Une boucle d'entraînement normale
Le meilleur aspect est que votre boucle d'entraînement change à peine. Vous déplacez les données vers le GPU principal et appelez le modèle encapsulé comme d'habitude ; DataParallel se charge de la répartition en arrière-plan.
for x, y in loader:
x, y = x.cuda(), y.cuda()
optimizer.zero_grad()
out = model(x) # auto-split across GPUs
loss = criterion(out, y)
loss.backward() # gradients averaged
optimizer.step()Le déséquilibre du GPU 0
DataParallel présente un défaut bien connu : le GPU principal (généralement le GPU 0) rassemble toutes les sorties et calcule la perte, ce qui lui impose une charge supplémentaire en mémoire et en calcul. Avec de nombreux GPU, le GPU 0 devient un goulot d'étranglement et peut manquer de mémoire avant les autres.
Un seul processus, plusieurs fils d'exécution
DataParallel s'exécute dans un seul processus Python et utilise des fils d'exécution pour piloter les GPU. Le verrou global de l'interpréteur Python ainsi que la surcharge liée à la répartition et au rassemblement limitent l'efficacité de la mise à l'échelle, en particulier au-delà de 2 à 4 GPU.
Pourquoi DDP est privilégié
Pour ces raisons, DistributedDataParallel (DDP) est recommandé pour les travaux sérieux impliquant plusieurs GPU. DDP exécute un processus par GPU, synchronise les gradients grâce à une réduction globale efficace et évite le goulot d'étranglement du GPU 0, ce qui permet une mise à l'échelle presque linéaire.
Quand DataParallel reste adapté
DataParallel convient aux expériences rapides sur une seule machine équipée de 2 GPU, où sa simplicité en une ligne compense son manque d'efficacité. Pour un entraînement sur plusieurs nœuds ou avec de nombreux GPU, préférez DDP.
Piège courant : l'enregistrement
Le dictionnaire d'état d'un modèle encapsulé possède le préfixe module.. Pour enregistrer un point de contrôle propre, utilisez model.module.state_dict() afin de pouvoir le charger correctement dans un modèle désencapsulé ultérieurement.
torch.save(model.module.state_dict(), "model.pt")Vérification rapide
Testez vos connaissances sur DataParallel.
Récapitulatif
Vous avez appris l'entraînement sur plusieurs GPU avec DataParallel :
nn.DataParallel(model, device_ids=[0, 1])réplique le modèle et répartit les lots- Les gradients sont moyennés entre les GPU à chaque étape
- Le déséquilibre du GPU 0 et la conception en processus unique limitent la mise à l'échelle
- Préférez DDP pour de nombreux GPU ou un entraînement sur plusieurs nœuds
Questions Fréquemment Posées
La leçon « Entraînement multi-GPU avec DataParallel » est-elle gratuite ?
Oui — le texte complet de « Entraînement multi-GPU avec DataParallel » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn AI with Python, passe à CoddyKit PRO. Le cours Learn AI with Python comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Entraînement multi-GPU avec DataParallel » ?
nn.DataParallel, équilibrage de la mémoire GPU, goulots d’étranglement de la bande passante, situations où DDP est préférable. Tu pratiques Learn AI with Python avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Learn AI with Python ?
Aucune expérience préalable n'est requise. Learn AI with Python sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.
Combien de temps prend la leçon « Entraînement multi-GPU avec DataParallel » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Learn AI with Python ?
Oui. Chaque leçon Learn AI with Python inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Entraînement multi-GPU avec DataParallel
- DistributedDataParallel (DDP)
- Entraînement en précision mixte avec AMP
- Entraînement efficace avec Hugging Face Accelerate