# Estimateur de mémoire du modèle

Un aspect très difficile lors de l’exploration des modèles potentiels à utiliser sur votre machine est de savoir à quel point un modèle peut être *gros* pour tenir en mémoire avec votre appareil actuel (comme le chargement du modèle sur CUDA ou XPU).

Pour atténuer ce problème, Accelerate propose une interface en ligne de commande via `accelerate estimate-memory`. Ce tutoriel vous guide dans son utilisation, vous explique à quoi vous attendre et, à la fin, vous renvoie vers la démonstration interactive hébergée sur le Hub, qui vous permet même de publier ces résultats directement sur le dépôt du modèle !

Nous prenons actuellement en charge la recherche de modèles utilisables dans `timm` et `transformers`.

    Cette API charge le modèle en mémoire sur le périphérique `meta`, de sorte que nous ne téléchargeons pas réellement les poids complets du modèle en mémoire, et nous n’en avons pas besoin. Par conséquent, il est tout à fait possible de mesurer des modèles de 8 milliards de paramètres (ou plus), sans avoir à se soucier de savoir si votre CPU peut le supporter !

## Démonstrations Gradio

Voici quelques démos gradio liées à ce qui a été décrit ci-dessus. La première est l’espace officiel d’estimation de la mémoire de Hugging Face, qui utilise directement Accelerate :

	<iframe src="https://hf-accelerate-model-memory-usage.hf.space?__theme=light" width="850" height="1600"
    >

    <iframe src="https://hf-accelerate-model-memory-usage.hf.space?__theme=dark" width="850" height="1600"
    >

Un membre de la communauté a repris cette idée et l’a développée davantage, vous permettant de filtrer directement les modèles et de vérifier si vous pouvez exécuter un LLM particulier compte tenu des contraintes GPU et des configurations LoRA. Pour l’essayer, consultez [ici](https://huggingface.co/spaces/Vokturz/can-it-run-llm) pour plus de détails.

## La commande

Lors de l’utilisation de `accelerate estimate-memory`, vous devez indiquer le nom du modèle que vous souhaitez utiliser, éventuellement le framework utilisé par ce modèle (s’il ne peut pas être détecté automatiquement), ainsi que les types de données dans lesquels vous voulez charger le modèle.

Par exemple, voici comment nous pouvons calculer l'empreinte mémoire de `bert-base-cased` :

```bash
accelerate estimate-memory bert-base-cased
```

Cela téléchargera le `config.json` pour `bert-based-cased`, chargera le modèle sur le périphérique `meta` et indiquera l’espace qu’il occupera :

Mémoire utilisée pour charger `bert-base-cased` :

| dtype   | Couche la plus volumineuse | Taille totale | Entraînement à l'aide d'Adam |
|---------|---------------|------------|---------------------|
| float32 | 84,95 Mo      | 418,18 Mo  | 1,61 Go             |
| float16 | 42,47 Mo      | 206,59 Mo  | 826.36 Mo           |
| int8    | 21,24 Mo      | 103,29 Mo  | 413,18 Mo           |
| int4    | 10,62 Mo      | 51,65 Mo   | 206,59 Mo           |

Par défaut, elle renvoie tous les dtypes pris en charge (de `int4` à `float32`), mais si vous êtes intéressé par des types spécifiques, vous pouvez les filtrer.

### Bibliothèques spécifiques

Si la bibliothèque source ne peut pas être déterminée automatiquement (comme ce serait possible dans le cas de `bert-base-cased`), un nom de bibliothèque peut être transmis.

```bash
accelerate estimate-memory HuggingFaceM4/idefics-80b-instruct --library_name transformers
```

Utilisation de la mémoire pour le chargement de `HuggingFaceM4/idefics-80b-instruct` :

| dtype   | Couche la plus volumineuse | Taille totale | Entraînement à l'aide d'Adam |
|---------|---------------|------------|---------------------|
| float32 | 3,02 Go       | 297,12 Go  | 1,16 To             |
| float16 | 1,51 Go       | 148,56 Go  | 594.24 Go           |
| int8    | 772.52 Mo     | 74,28 Go   | 297,12 Go           |
| int4    | 386.26 Mo     | 37,14 Go   | 148,56 Go           |

```bash
accelerate estimate-memory timm/resnet50.a1_in1k --library_name timm
```

Mémoire utilisée pour charger `timm/resnet50.a1_in1k` :

| dtype   | Couche la plus volumineuse | Taille totale | Entraînement à l'aide d'Adam |
|---------|---------------|------------|---------------------|
| float32 | 9,0 Mo        | 97,7 Mo    | 390.78 Mo           |
| float16 | 4,5 Mo        | 48,85 Mo   | 195,39 Mo           |
| int8    | 2,25 Mo       | 24,42 Mo   | 97,7 Mo             |
| int4    | 1,12 Mo       | 12,21 Mo   | 48,85 Mo            |

### dtypes spécifiques

Comme mentionné précédemment, bien que nous renvoyions par défaut `int4` via `float32`, tout type de données peut être utilisé parmi `float32`, `float16`, `int8` et `int4`.

Pour ce faire, passez-les après avoir spécifié `--dtypes` :

```bash
accelerate estimate-memory bert-base-cased --dtypes float32 float16
```

Mémoire utilisée pour charger `bert-base-cased` :

| dtype   | Couche la plus volumineuse | Taille totale | Entraînement à l'aide d'Adam |
|---------|---------------|------------|---------------------|
| float32 | 84,95 Mo      | 413,18 Mo  | 1,61 Go             |
| float16 | 42,47 Mo      | 206,59 Mo  | 826.36 Mo           |

## Limites de cette calculatrice

Cette calculatrice vous indique la quantité de mémoire nécessaire pour charger le modèle, *non* pour effectuer l'inférence.

Ce calcul est précis à quelques % près de la valeur réelle, ce qui en fait une très bonne estimation de la quantité de mémoire nécessaire. Par exemple, le chargement de `bert-base-cased` nécessite réellement `413.68 MB` lorsqu’il est chargé sur CUDA en pleine précision, et le calculateur estime `413.18 MB`.

Lors de l’inférence, vous pouvez vous attendre à une surcharge pouvant atteindre 20 %, comme l’ont constaté [EleutherAI](https://blog.eleuther.ai/transformer-math/). Nous menons des recherches afin d’obtenir une estimation plus précise de ces valeurs et mettrons à jour cette calculatrice dès que ce sera fait.

