DDP

DistributedDataParallel (DDP) maintient une copie complète du modèle sur chaque GPU. Chaque GPU traite un fragment de données non chevauchant via un passage avant et un passage arrière. Avant l'étape de l'optimiseur, une opération all-reduce moyenne les gradients sur tous les GPU afin que chaque copie du modèle reste identique. Utilisez DDP lorsque votre modèle tient sur un seul GPU.

                         ┌─────────────────┐
                         │  training data  │
                         └────────┬────────┘
               ┌──────────────────┼──────────────────┐
               │ shard 0          │ shard 1          │ shard 2
               ▼                  ▼                  ▼
        ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
        │   model     │    │   model     │    │   model     │
        │  (copy 0)   │    │  (copy 1)   │    │  (copy 2)   │
        │   GPU 0     │    │   GPU 1     │    │   GPU 2     │
        └──────┬──────┘    └──────┬──────┘    └──────┬──────┘
               │ grads            │ grads            │ grads
               └──────────────────┼──────────────────┘
                               all-reduce
                          (average gradients)
               ┌──────────────────┼──────────────────┐
               ▼                  ▼                  ▼
        ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
        │  optimizer  │    │  optimizer  │    │  optimizer  │
        │    step     │    │    step     │    │    step     │
        └─────────────┘    └─────────────┘    └─────────────┘
          (identical)        (identical)        (identical)

DDP s’active automatiquement lorsque vous lancez avec un lanceur multi-processus tel que Accelerate.

# 4 GPUs on one machine
accelerate launch --num_processes 4 train.py

Configurer DDP

Passez ces TrainingArguments pour contrôler le comportement de DDP.

• gradient_accumulation_steps() détermine quand effectuer l’all-reduce. Trainer ignore l’all-reduce aux étapes d’accumulation intermédiaires et ne l’exécute que sur le dernier micro-lot. Par exemple, avec gradient_accumulation_steps=4, l’all-reduce s’exécute toutes les 4 passes arrière.
• ~TrainingArguments.ddp_find_unused_parameters parcourt le graphe autograd à la fin du passage avant pour les paramètres qui ne recevront pas de gradient et les marque comme prêts afin qu’ils ne bloquent pas l’all-reduce. Ne pas utiliser avec ~TrainingArguments.gradient_checkpointing car le gradient checkpointing supprime les activations intermédiaires et les recalcule à la volée.
• ~TrainingArguments.ddp_bucket_cap_mb est la taille du bucket pour le regroupement des gradients en une seule opération all-reduce lors de la passe arrière. Un bucket plus grand signifie moins d'appels all-reduce et moins de surcharge de lancement.
• ~TrainingArguments.ddp_broadcast_buffers synchronise les tampons du modèle (tels que les statistiques courantes de BatchNorm) depuis le rang 0 vers tous les autres rangs au début de chaque passe avant. Désactivez cette option si votre modèle n’utilise que LayerNorm. Ne l’utilisez pas avec ~TrainingArguments.gradient_checkpointing.
• ~TrainingArguments.ddp_backend définit le backend de communication. Utilisez "nccl" pour les GPU NVIDIA (par défaut et le plus rapide), "gloo" pour l’entraînement sur CPU ou le débogage, et "xccl", "hccl" ou "cncl" pour les autres matériels.
• ddp_timeout() définit la limite de temps pour que tous les processus et opérations (all-reduce, broadcast) s’achèvent. Si un processus reste bloqué, par exemple lors du chargement lent d’un grand modèle, le dépassement de délai déclenche une erreur au lieu de bloquer indéfiniment.

from transformers import TrainingArguments

args = TrainingArguments(
    ...,
    gradient_accumulation_steps=4,
    ddp_backend="nccl",
    ddp_find_unused_parameters=False,
    ddp_bucket_cap_mb=25,
    ddp_broadcast_buffers=True,
    ddp_timeout=1800,
)

Étapes suivantes

• Voir FSDP pour l’entraînement de modèles trop volumineux pour tenir sur une seule GPU.
• Voir DeepSpeed pour l'optimisation ZeRO et le déchargement.
• Lisez le chapitre Data Parallelism du The Ultra-Scale Playbook pour plus d'informations sur le fonctionnement de DDP.