# Inférence de grands modèles

L'une des plus grandes avancées apportées par Accelerate est le [Big Model Inference](../concept_guides/big_model_inference), qui vous 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).

```py
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 ».

```py
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()](/docs/accelerate/main/fr/package_reference/big_modeling#accelerate.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.

> [!TIP]
> Consultez le guide [Concevoir une carte de périphériques](../concept_guides/big_model_inference#designing-a-device-map) pour plus de détails sur la conception de votre propre carte de périphériques.

```py
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](../concept_guides/big_model_inference#loading-weights) 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](../concept_guides/big_model_inference#sharded-checkpoints) pour plus de détails).

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

```py
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.

```py
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](https://huggingface.co/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel.from_pretrained).

Il suffit d'ajouter `device_map="auto"` dans [from_pretrained](https://huggingface.co/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel.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.

```py
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.

```py
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](../concept_guides/big_model_inference) !

