Accelerate documentation

Inférence de grands modèles

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Inférence de grands modèles

L’une des plus grandes avancées apportées par Accelerate est le Big Model Inference, qui permet d’effectuer de l’inférence avec des modèles qui ne tiennent pas entièrement sur votre carte graphique.

Ce tutoriel vous montre comment utiliser Big Model Inference dans Accelerate et l'écosystème Hugging Face.

Accelerate

Un flux de travail typique pour charger un modèle PyTorch est présenté ci-dessous. ModelClass est un modèle qui dépasse la mémoire GPU de votre appareil (mps ou cuda ou xpu).

import torch

my_model = ModelClass(...)
state_dict = torch.load(checkpoint_file)
my_model.load_state_dict(state_dict)

Avec Big Model Inference, la première étape consiste à initialiser un squelette vide du modèle à l’aide du gestionnaire de contexte init_empty_weights. Cela n’exige aucune mémoire car my_model est « sans paramètres ».

from accelerate import init_empty_weights
with init_empty_weights():
    my_model = ModelClass(...)

Ensuite, les poids sont chargés dans le modèle pour l'inférence.

La méthode load_checkpoint_and_dispatch() charge un point de contrôle dans votre modèle vide et répartit les poids de chaque couche sur tous les appareils disponibles, en commençant par les plus rapides (GPU, MPS, XPU, NPU, MLU, SDAA, MUSA) avant de passer aux plus lents (CPU et disque dur).

Définir device_map="auto" remplit automatiquement tout l’espace disponible sur les GPU d’abord, puis sur le CPU, et enfin sur le disque dur (l’option la plus lente) s’il reste encore insuffisamment de mémoire.

Consultez le guide Concevoir une carte de périphériques pour plus de détails sur la conception de votre propre carte de périphériques.

from accelerate import load_checkpoint_and_dispatch

model = load_checkpoint_and_dispatch(
    model, checkpoint=checkpoint_file, device_map="auto"
)

Si certaines « sections » de couches ne doivent pas être fractionnées, transmettez-les à no_split_module_classes (voir ici pour plus de détails).

Les poids d'un modèle peuvent également être répartis en plusieurs points de contrôle pour économiser de la mémoire, par exemple lorsque le state_dict ne tient pas en mémoire (voir ici pour plus de détails).

Maintenant que le modèle est entièrement dispatché, vous pouvez effectuer l'inférence.

input = torch.randn(2,3)
device_type = next(iter(model.parameters())).device.type
input = input.to(device_type)
output = model(input)

Chaque fois qu'une entrée est transmise à une couche, elle est envoyée du CPU vers le GPU (ou du disque vers le CPU puis vers le GPU), la sortie est calculée, puis la couche est retirée du GPU pour redescendre dans la file. Bien que cela ajoute une certaine surcharge à l'inférence, cela permet d'exécuter un modèle de n'importe quelle taille sur votre système, à condition que la plus grande couche tienne sur votre GPU.

Plusieurs GPU, ou « parallélisme de modèle », peuvent être utilisés, mais un seul GPU sera actif à un instant donné. Cela oblige le GPU à attendre que le GPU précédent lui envoie la sortie. Vous devez lancer votre script normalement avec Python plutôt qu’avec d’autres outils comme torchrun et accelerate launch.

Consultez ci-dessous un exemple complet d’inférence de Big Model.

import torch
from accelerate import init_empty_weights, load_checkpoint_and_dispatch

with init_empty_weights():
    model = MyModel(...)

model = load_checkpoint_and_dispatch(
    model, checkpoint=checkpoint_file, device_map="auto"
)

input = torch.randn(2,3)
device_type = next(iter(model.parameters())).device.type
input = input.to(device_type)
output = model(input)

Écosystème Hugging Face

D’autres bibliothèques de l’écosystème Hugging Face, comme Transformers ou Diffusers, prennent en charge l’inférence de grands modèles dans leurs constructeurs from_pretrained.

Il suffit d'ajouter device_map="auto" dans from_pretrained pour activer l'inférence sur de grands modèles.

Par exemple, chargez le modèle de 11 milliards de paramètres Big Sciences T0pp avec Big Model Inference.

from transformers import AutoModelForSeq2SeqLM

model = AutoModelForSeq2SeqLM.from_pretrained("bigscience/T0pp", device_map="auto")

Après le chargement du modèle, les étapes d’initialisation vide et de dispatch intelligent décrites précédemment sont exécutées, et le modèle est entièrement prêt à exploiter toutes les ressources de votre machine. Grâce à ces constructeurs, vous pouvez également économiser de la mémoire en spécifiant le paramètre torch_dtype pour charger un modèle dans une précision inférieure.

from transformers import AutoModelForSeq2SeqLM

model = AutoModelForSeq2SeqLM.from_pretrained("bigscience/T0pp", device_map="auto", torch_dtype=torch.float16)

Étapes suivantes

Pour une explication plus détaillée de l'inférence de grands modèles, n'oubliez pas de consulter le guide conceptuel !

Update on GitHub