Accelerate documentation
Tour rapide
Tour rapide
Il existe de nombreuses façons de lancer et d’exécuter votre code en fonction de votre environnement d’entraînement (torchrun, DeepSpeed, etc.) et du matériel disponible. Accelerate propose une interface unifiée pour lancer et entraîner sur différentes configurations distribuées, vous permettant de vous concentrer sur votre code d’entraînement PyTorch plutôt que sur les subtilités de l’adaptation de votre code à ces différentes configurations. Cela vous permet de mettre facilement à l’échelle votre code PyTorch pour l’entraînement et l’inférence sur des configurations distribuées avec du matériel tel que des GPU et des TPU. Accelerate fournit également Big Model Inference pour rendre plus accessible le chargement et l’exécution de l’inférence avec de très grands modèles qui ne tiennent généralement pas en mémoire.
Cette introduction rapide présente les trois fonctionnalités principales d'Accelerate :
- une interface de lancement unifiée en ligne de commande pour les scripts d'entraînement distribué
- une bibliothèque d'entraînement pour adapter le code d'entraînement PyTorch afin de l'exécuter sur différentes configurations distribuées
- Inférence de grands modèles
Interface de lancement unifiée
Accelerate sélectionne automatiquement les valeurs de configuration appropriées pour tout framework d’entraînement distribué donné (DeepSpeed, FSDP, etc.) via un fichier de configuration unifié généré à partir de la commande accelerate config. Vous pouvez également passer explicitement les valeurs de configuration à la ligne de commande, ce qui est utile dans certaines situations, par exemple si vous utilisez SLURM.
Mais dans la plupart des cas, vous devez toujours exécuter accelerate config en premier pour aider Accelerate à prendre en compte votre configuration d'entraînement.
accelerate config
La commande accelerate config crée et enregistre un fichier default_config.yaml dans le dossier de cache d’Accelerate. Ce fichier stocke la configuration de votre environnement d’entraînement, ce qui permet à Accelerate de lancer correctement votre script d’entraînement en fonction de votre machine.
Une fois votre environnement configuré, vous pouvez tester votre installation avec accelerate test, qui lance un court script pour tester l'environnement distribué.
accelerate testAjoutez
--config_fileà la commandeaccelerate testouaccelerate launchpour spécifier l’emplacement du fichier de configuration s’il est enregistré dans un emplacement non par défaut, comme le cache.
Une fois votre environnement configuré, lancez votre script d’entraînement avec accelerate launch !
accelerate launch path_to_script.py --args_for_the_script
Pour en savoir plus, consultez le tutoriel Lancer du code distribué pour obtenir plus d'informations sur le lancement de vos scripts.
Nous disposons également d'un zoo de configurations qui présente un certain nombre de configurations d'exemples minimales préconçues pour divers scénarios que vous pouvez exécuter.
Adapter le code d’entraînement
La principale fonctionnalité suivante d'Accelerate est la classe Accelerator, qui adapte votre code PyTorch pour l'exécuter sur différentes configurations distribuées.
Il suffit d’ajouter quelques lignes de code à votre script d’entraînement pour lui permettre de s’exécuter sur plusieurs GPU ou TPU.
+ from accelerate import Accelerator
+ accelerator = Accelerator()
+ device = accelerator.device
+ model, optimizer, training_dataloader, scheduler = accelerator.prepare(
+ model, optimizer, training_dataloader, scheduler
+ )
for batch in training_dataloader:
optimizer.zero_grad()
inputs, targets = batch
- inputs = inputs.to(device)
- targets = targets.to(device)
outputs = model(inputs)
loss = loss_function(outputs, targets)
+ accelerator.backward(loss)
optimizer.step()
scheduler.step()- Importez et instanciez la classe Accelerator au début de votre script d’entraînement. La classe Accelerator initialise tout ce qui est nécessaire pour l’entraînement distribué et détecte automatiquement votre environnement d’entraînement (une machine avec un GPU, une machine avec plusieurs GPU, plusieurs machines avec plusieurs GPU ou un TPU, etc.) en fonction de la manière dont le code a été lancé.
from accelerate import Accelerator
accelerator = Accelerator()- Supprimez les appels de la forme
.cuda()sur votre modèle et vos données d’entrée. La classe Accelerator place automatiquement ces objets sur l’appareil approprié pour vous.
Cette étape est facultative, mais il est considéré comme une bonne pratique de laisser Accelerate gérer le placement sur les dispositifs. Vous pouvez également désactiver le placement automatique des dispositifs en passant
device_placement=Falselors de l’initialisation de Accelerator. Si vous souhaitez placer explicitement des objets sur un dispositif avec.to(device), assurez-vous d’utiliseraccelerator.deviceà la place. Par exemple, si vous créez un optimiseur avant de placer un modèle suraccelerator.device, l’entraînement échoue sur un TPU.
Accelerate n’utilise pas de transferts non bloquants par défaut pour son placement automatique des appareils, ce qui peut entraîner des synchronisations CUDA potentiellement indésirables. Vous pouvez activer les transferts non bloquants en passant un DataLoaderConfiguration avec
non_blocking=Truedéfini commedataloader_configlors de l’initialisation de Accelerator. Comme d’habitude, les transferts non bloquants ne fonctionneront que si le dataloader a égalementpin_memory=Truedéfini. Soyez prudent : l’utilisation de transferts non bloquants de la GPU vers le CPU peut entraîner des résultats incorrects si cela provoque l’exécution d’opérations CPU sur des tenseurs non prêts.
device = accelerator.device
- Transmettez tous les objets PyTorch pertinents pour l’entraînement (optimiseur, modèle, chargeur(s) de données, planificateur de taux d’apprentissage) à la méthode prepare() dès leur création. Cette méthode enveloppe le modèle dans un conteneur optimisé pour votre configuration distribuée, utilise la version d’Accelerate de l’optimiseur et du planificateur, et crée une version fragmentée de votre chargeur de données pour la distribution sur les GPU ou TPU.
model, optimizer, train_dataloader, lr_scheduler = accelerator.prepare(
model, optimizer, train_dataloader, lr_scheduler
)- Remplacez
loss.backward()par backward() pour utiliser la méthodebackward()correcte pour votre configuration d'entraînement.
accelerator.backward(loss)
Lisez le guide mécanismes internes d’Accelerate pour en savoir plus sur la façon dont Accelerate adapte votre code.
Évaluation distribuée
Pour effectuer une évaluation distribuée, passez votre dataloader de validation à la méthode prepare() :
validation_dataloader = accelerator.prepare(validation_dataloader)
Chaque appareil de votre configuration distribuée ne reçoit qu'une partie des données d'évaluation, ce qui signifie que vous devez regrouper vos prédictions à l'aide de la méthode gather_for_metrics(). Cette méthode exige que tous les tenseurs aient la même taille sur chaque processus. Par conséquent, si vos tenseurs ont des tailles différentes sur chaque processus (par exemple lors d'un bourrage dynamique jusqu'à la longueur maximale d'un lot), vous devez utiliser la méthode pad_across_processes() pour bourrer votre tenseur jusqu'à la plus grande taille entre les processus. Notez que les tenseurs doivent être 1D et que nous concaténons les tenseurs le long de la première dimension.
for inputs, targets in validation_dataloader:
predictions = model(inputs)
# Gather all predictions and targets
all_predictions, all_targets = accelerator.gather_for_metrics((predictions, targets))
# Example of use with a *Datasets.Metric*
metric.add_batch(all_predictions, all_targets)Pour des cas plus complexes (par exemple des tenseurs 2D, l’absence de concaténation de tenseurs, un dictionnaire de tenseurs 3D), vous pouvez passer use_gather_object=True dans gather_for_metrics. Cela renverra la liste des objets après la collecte. Notez que son utilisation avec des tenseurs GPU n’est pas bien prise en charge et est inefficace.
Les données à la fin d'un jeu de données peuvent être dupliquées afin que le lot puisse être divisé également entre tous les travailleurs. La méthode gather_for_metrics() supprime automatiquement les données dupliquées pour calculer une métrique plus précise.
Inférence de grands modèles
Big Model Inference d’Accelerate propose deux fonctionnalités principales, init_empty_weights() et load_checkpoint_and_dispatch(), pour charger de grands modèles destinés à l’inférence qui ne tiennent généralement pas en mémoire.
Consultez le guide Gestion des grands modèles pour l'inférence pour mieux comprendre le fonctionnement de Big Model Inference en profondeur.
Initialisation des poids vides
Le gestionnaire de contexte init_empty_weights() initialise des modèles de toute taille en créant un squelette de modèle et en déplaçant et en plaçant les paramètres au fur et à mesure de leur création sur l’appareil meta de PyTorch. Ainsi, tous les poids ne sont pas chargés immédiatement et seule une petite partie du modèle est chargée en mémoire à la fois.
Par exemple, charger un modèle Mixtral-8x7B vide requiert nettement moins de mémoire que de charger entièrement les modèles et les poids sur le CPU.
from accelerate import init_empty_weights
from transformers import AutoConfig, AutoModelForCausalLM
config = AutoConfig.from_pretrained("mistralai/Mixtral-8x7B-Instruct-v0.1")
with init_empty_weights():
model = AutoModelForCausalLM.from_config(config)Charger et distribuer les poids
La fonction load_checkpoint_and_dispatch() charge les points de contrôle complets ou fractionnés dans le modèle vide et distribue automatiquement les poids sur tous les appareils disponibles.
Le paramètre device_map détermine l’emplacement de chaque couche du modèle. Spécifier "auto" place d’abord les couches sur le GPU, puis sur le CPU, et enfin sur le disque dur sous forme de tenseurs mappés en mémoire s’il reste insuffisamment de mémoire. Utilisez le paramètre no_split_module_classes pour indiquer quels modules ne doivent pas être répartis sur plusieurs appareils (généralement ceux possédant une connexion résiduelle).
from accelerate import load_checkpoint_and_dispatch
model_checkpoint = "your-local-model-folder"
model = load_checkpoint_and_dispatch(
model, checkpoint=model_checkpoint, device_map="auto", no_split_module_classes=['Block']
)Étapes suivantes
Maintenant que vous avez été initié aux fonctionnalités principales d'Accelerate, vos prochaines étapes pourraient inclure :
- Consultez les tutoriels pour une introduction progressive à Accelerate. C’est particulièrement utile si vous débutez avec l’entraînement distribué et la bibliothèque.
- Plongez dans les guides pour découvrir comment utiliser Accelerate pour des cas d'usage spécifiques.
- Approfondissez votre compréhension conceptuelle du fonctionnement interne d'Accelerate en lisant les guides conceptuels.
- Consultez les classes et les commandes dans la référence de l’API pour voir les paramètres et les options disponibles.