Accelerate documentation

Inférence distribuée

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Inférence distribuée

L'inférence distribuée peut se répartir en deux catégories :

  1. Charger un modèle entier sur chaque GPU et envoyer des morceaux d'un lot à travers la copie du modèle de chaque GPU à la fois
  2. Charger des parties d'un modèle sur chaque GPU et traiter une seule entrée à la fois

Ce guide couvre la première parenthèse. Pour la seconde, consultez Big Model Inference.

Envoi automatique des morceaux d'un lot à chaque modèle chargé

C'est la solution la plus gourmande en mémoire, car elle exige que chaque GPU conserve une copie complète du modèle en mémoire à un instant donné.

Normalement, lors de cette opération, les utilisateurs envoient le modèle sur un appareil spécifique pour le charger depuis le CPU, puis déplacent chaque invite sur un appareil différent.

Un pipeline de base utilisant la bibliothèque diffusers pourrait ressembler à ceci :

import torch
import torch.distributed as dist
from diffusers import DiffusionPipeline

pipe = DiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5", torch_dtype=torch.float16)

Suivi de l'exécution de l'inférence basée sur le prompt spécifique :

def run_inference(rank, world_size):
    dist.init_process_group("nccl", rank=rank, world_size=world_size)
    pipe.to(rank)

    if torch.distributed.get_rank() == 0:
        prompt = "a dog"
    elif torch.distributed.get_rank() == 1:
        prompt = "a cat"

    result = pipe(prompt).images[0]
    result.save(f"result_{rank}.png")

On remarquera qu'il faut vérifier le rang pour savoir quel prompt envoyer, ce qui peut s'avérer un peu fastidieux.

Un utilisateur pourrait alors également penser qu’avec Accelerate, utiliser Accelerator pour préparer un dataloader pour ce type de tâche serait également un moyen simple de gérer cela. (Pour en savoir plus, consultez la section correspondante dans le Quick Tour)

Peut-il s'en charger ? Oui. Ajoute-t-il cependant du code superflu ? Oui aussi.

Avec Accelerate, nous pouvons simplifier ce processus en utilisant le gestionnaire de contexte Accelerator.split_between_processes() (qui existe également dans PartialState et AcceleratorState). Cette fonction divise automatiquement les données que vous lui transmettez (qu’il s’agisse d’un prompt, d’un ensemble de tenseurs, d’un dictionnaire de données antérieures, etc.) entre tous les processus (avec un potentiel remplissage) afin que vous puissiez les utiliser immédiatement.

Réécrivons l’exemple ci-dessus en utilisant ce gestionnaire de contexte :

import torch
from accelerate import PartialState  # Can also be Accelerator or AcceleratorState
from diffusers import DiffusionPipeline

pipe = DiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5", torch_dtype=torch.float16)
distributed_state = PartialState()
pipe.to(distributed_state.device)

# Assume two processes
with distributed_state.split_between_processes(["a dog", "a cat"]) as prompt:
    result = pipe(prompt).images[0]
    result.save(f"result_{distributed_state.process_index}.png")

Ensuite, pour lancer le code, nous pouvons utiliser Accelerate :

Si vous avez généré un fichier de configuration à utiliser avec accelerate config :

accelerate launch distributed_inference.py

Si vous disposez d'un fichier de configuration spécifique que vous souhaitez utiliser :

accelerate launch --config_file my_config.json distributed_inference.py

Sinon, si vous ne souhaitez pas créer de fichiers de configuration et lancer sur deux GPU :

Note : Vous recevrez certains avertissements concernant des valeurs estimées en fonction de votre système. Pour les supprimer, vous pouvez exécuter accelerate config default ou passer par accelerate config pour créer un fichier de configuration.

accelerate launch --num_processes 2 distributed_inference.py

Nous avons désormais réduit le code de base nécessaire pour fractionner ces données à quelques lignes de code, très facilement.

Mais que se passe-t-il si la répartition des prompts sur les GPU est inégale ? Par exemple, que se passe-t-il si nous avons 3 prompts mais seulement 2 GPU ?

Sous le gestionnaire de contexte, la première GPU reçoit les deux premiers prompts et la deuxième GPU le troisième, garantissant que tous les prompts sont répartis et qu'aucun surcoût n'est nécessaire.

Cependant, que se passerait-il si nous voulions ensuite effectuer une opération sur les résultats de tous les GPU ? (Par exemple, les regrouper et effectuer un certain type de post-traitement) Vous pouvez passer apply_padding=True pour vous assurer que les listes de prompts sont remplies jusqu'à la même longueur, les données supplémentaires étant prises depuis le dernier échantillon. De cette façon, tous les GPU auront le même nombre de prompts, et vous pourrez ensuite regrouper les résultats.

Ceci n'est nécessaire que lors de la tentative d'exécuter une action telle que la collecte des résultats, où les données sur chaque appareil doivent avoir la même longueur. L'inférence de base ne l'exige pas.

Par exemple :

import torch
from accelerate import PartialState  # Can also be Accelerator or AcceleratorState
from diffusers import DiffusionPipeline

pipe = DiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5", torch_dtype=torch.float16)
distributed_state = PartialState()
pipe.to(distributed_state.device)

# Assume two processes
with distributed_state.split_between_processes(["a dog", "a cat", "a chicken"], apply_padding=True) as prompt:
    result = pipe(prompt).images

Sur la première GPU, les prompts seront ["a dog", "a cat"], et sur la seconde GPU, ils seront ["a chicken", "a chicken"]. Assurez-vous de supprimer l'échantillon final, car il sera un doublon du précédent.

Vous trouverez des exemples plus complexes ici, par exemple comment l’utiliser avec des LLM.

Update on GitHub