Ajustement multi-GPU avec Distributed Data Parallel (DDP)
Apprenez à utiliser l'interface CLI d'Unsloth pour entraîner sur plusieurs GPU avec Distributed Data Parallel (DDP) !
Supposons que nous disposions de plusieurs GPU et que nous souhaitions affiner un modèle en utilisant tous ces GPU ! Pour ce faire, la stratégie la plus simple est d'utiliser Distributed Data Parallel (DDP), qui crée une copie du modèle sur chaque dispositif GPU, alimente chaque copie avec des échantillons distincts du jeu de données pendant l'entraînement et agrège leurs contributions aux mises à jour des poids à chaque étape de l'optimiseur.
Pourquoi voudrions-nous faire cela ? Eh bien, à mesure que nous ajoutons des GPU au processus d'entraînement, nous augmentons le nombre d'échantillons sur lesquels nos modèles s'entraînent par étape, ce qui rend chaque mise à jour de gradient plus stable et augmente considérablement notre débit d'entraînement à chaque GPU ajouté.
Voici un guide étape par étape sur la façon de procéder en utilisant l'interface en ligne de commande (CLI) d'Unsloth !
Remarque : Unsloth DDP fonctionnera avec n'importe lequel de vos scripts d'entraînement, pas seulement via notre CLI ! Plus de détails ci-dessous.
Installer Unsloth depuis les sources
Nous allons cloner Unsloth depuis GitHub et l'installer. Veuillez envisager d'utiliser un environnement virtuel; nous aimons utiliser uv venv –python 3.12 && source .venv/bin/activate, mais n'importe quel outil de création d'environnement virtuel conviendra.
git clone https://github.com/unslothai/unsloth.git
cd unsloth
pip install .Choisir le modèle cible et le jeu de données pour l'affinage
Dans cette démonstration, nous allons affiner Qwen/Qwen3-8B sur le yahma/alpaca-cleaned jeu de données de chat. Il s'agit d'une charge de travail de Supervised Fine-Tuning (SFT) couramment utilisée lorsqu'on tente d'adapter un modèle de base à un style conversationnel souhaité, ou d'améliorer les performances du modèle sur une tâche en aval.
Utilisez la CLI Unsloth !
Tout d'abord, jetons un coup d'œil au message d'aide intégré à la CLI (nous avons abrégé ici par “...” à divers endroits pour la concision) :
Cela devrait vous donner une idée des options disponibles que vous pouvez passer à la CLI pour entraîner votre modèle !
Pour l'entraînement multi-GPU (DDP dans ce cas), nous utiliserons le torchrun lanceur, qui vous permet de lancer plusieurs processus d'entraînement distribués en environnements mono-nœud ou multi-nœuds. Dans notre cas, nous nous concentrerons sur le cas mono-nœud (c'est-à-dire, une machine) avec deux GPU H100.
Vérifions également l'état de nos GPU en utilisant l'outil en ligne de commande nvidia-smi :
Super ! Nous avons deux GPU H100, comme prévu. Les deux affichent 0MiB d'utilisation mémoire car nous n'entraînons actuellement rien et aucun modèle n'est chargé en mémoire.
Pour démarrer votre exécution d'entraînement, lancez une commande comme la suivante :
Si vous avez plus de GPU, vous pouvez définir --nproc_per_node en conséquence pour les utiliser.
Remarque : Vous pouvez utiliser le torchrun lanceur avec n'importe lequel de vos scripts d'entraînement Unsloth, y compris les scripts convertis depuis nos notebooks Colab gratuits, et DDP sera activé automatiquement lorsque vous vous entraînerez avec >1 GPU !
Regardons à nouveau nvidia-smi pendant que l'entraînement est en cours :
Nous pouvons voir que les deux GPU utilisent maintenant ~19 Go de VRAM par GPU H100 !
En inspectant les journaux d'entraînement, nous constatons que nous pouvons entraîner à un rythme d'environ ~1,1 itérations/s. Cette vitesse d'entraînement est ~constante même lorsque nous ajoutons plus de GPU, donc notre débit d'entraînement augmente ~linéairement avec le nombre de GPU !
Métriques d'entraînement
Nous avons effectué quelques courts affinages LoRA de rang 16 sur unsloth/Llama-3.2-1B-Instruct sur le yahma/alpaca-cleaned jeu de données pour démontrer l'amélioration du débit d'entraînement lors de l'utilisation de l'entraînement DDP avec plusieurs GPU.
La figure ci-dessus compare la perte d'entraînement entre deux affinages LoRA Llama-3.2-1B-Instruct sur 500 étapes d'entraînement, avec un entraînement sur GPU unique (rose) vs. un entraînement DDP multi-GPU (bleu).
Remarquez que les courbes de perte correspondent en échelle et en tendance, mais sont par ailleurs un peu différentes, puisque les processus d'entraînement multi-GPU traitent deux fois plus de données d'entraînement par étape. Cela se traduit par une courbe d'entraînement légèrement différente avec moins de variabilité étape par étape.
La figure ci-dessus trace la progression de l'entraînement pour les mêmes deux affinages.
Remarquez que l'entraînement DDP multi-GPU parcourt une époque des données d'entraînement en deux fois moins d'étapes que l'entraînement sur GPU unique. C'est parce que chaque GPU peut traiter un lot distinct (de taille per_device_train_batch_size) par étape. Cependant, le temps par étape pour l'entraînement DDP est légèrement plus lent en raison de la communication distribuée pour les mises à jour des poids du modèle. À mesure que vous augmentez le nombre de GPU, le débit d'entraînement continuera d'augmenter ~linéairement (mais avec une petite pénalité croissante pour les communications distribuées).
Ces mêmes comportements de perte et de progression d'époque d'entraînement s'appliquent aux affinages QLoRA, dans lesquels nous avons chargé les modèles de base en précision 4 bits afin d'économiser de la mémoire GPU supplémentaire. Cela est particulièrement utile pour entraîner de grands modèles avec des quantités limitées de VRAM GPU :
Comparaison des pertes d'entraînement entre deux affinages QLoRA Llama-3.2-1B-Instruct sur 500 étapes d'entraînement, avec un entraînement sur GPU unique (orange) vs. un entraînement DDP multi-GPU (violet).
Comparaison de la progression de l'entraînement pour les mêmes deux affinages.
Mis à jour
Ce contenu vous a-t-il été utile ?