Calculateur de VRAM GPU pour LLM locaux
Un modèle 7B en 4 bits demande environ 3,3 Gio pour les poids, et un modèle de la classe Llama 3.1 8B ajoute environ 1 Gio de cache KV pour 8 192 tokens de contexte.
Mode d’emploi
- Choisissez un modèle prédéfini pour remplir paramètres, couches, têtes KV et dimension de tête, ou choisissez Personnalisé et saisissez les valeurs du config.json du modèle.
- Réglez les bits de quantification des poids (4 pour Q4, 16 pour FP16) et la précision du cache KV.
- Saisissez la longueur de contexte en tokens et la taille de lot, c'est-à-dire le nombre de séquences traitées en même temps.
- Lisez le total et sa répartition en poids, cache KV et surcoût. Le tableau indique sur quelles tailles de GPU courantes le modèle tient.
Méthode de calcul
Mémoire des poids = paramètres × bits ÷ 8 octets. Un modèle de 7 milliards de paramètres en 4 bits occupe 7 000 000 000 × 0,5 = 3,5 Go, soit 3,26 Gio. En 16 bits, cela fait 14 Go, ce qui correspond à la règle de 2 Go par milliard de paramètres en bfloat16 du guide Hugging Face "Optimizing LLMs for Speed and Memory".
Cache KV = 2 × couches × têtes KV × dimension de tête × longueur de contexte × taille de lot × octets par valeur. Le 2 correspond aux clés et aux valeurs. Hugging Face donne la forme par token, 2 × 2 × couches × têtes KV × dimension de tête pour des valeurs 16 bits, dans l'article "Unlocking Longer Generation with Key-Value Cache Quantization".
Le surcoût se saisit en pourcentage des poids plus du cache KV. Il représente le contexte CUDA, les tampons d'activation et la fragmentation mémoire. Les 10 % par défaut sont une hypothèse, pas une mesure.
Tous les résultats sont en Gio (1 Gio = 1 073 741 824 octets). Les fabricants de GPU écrivent "24 Go" pour une carte de 24 Gio, donc le tableau compare directement le total à 8, 12, 16, 24, 48 et 80. C'est une estimation. La consommation réelle varie selon le framework (llama.cpp, vLLM, Ollama, Transformers), les noyaux et la façon dont le cache est alloué.
Ce qui remplit la VRAM
Deux choses dominent. Les poids sont fixés dès que le modèle et la quantification sont choisis. Le cache KV grandit avec chaque token du contexte et chaque séquence du lot : avec un long contexte ou beaucoup d'utilisateurs en parallèle, un modèle qui "tenait" ne tient soudain plus.
Les modèles à attention par groupes de requêtes (GQA) ont moins de têtes KV que de têtes d'attention, ce qui réduit le cache de plusieurs fois. Le champ des têtes KV compte donc plus que le nombre de têtes d'attention. Vérifiez num_key_value_heads dans le config.json du modèle.
Taille des poids par milliard de paramètres
| Bits par poids | Gio par milliard de paramètres | Exemple : modèle 8B |
|---|---|---|
| 16 (FP16 / BF16) | 1,86 | 14,90 GiB |
| 8 (INT8 / Q8) | 0,93 | 7,45 GiB |
| 6 (Q6) | 0,70 | 5,59 GiB |
| 5 (Q5) | 0,58 | 4,66 GiB |
| 4 (Q4) | 0,47 | 3,73 GiB |
| 3 (Q3) | 0,35 | 2,79 GiB |
| 2 (Q2) | 0,23 | 1,86 GiB |
Origine des modèles prédéfinis
- config.json de chaque dépôt : huggingface.co/Qwen/Qwen2.5-{7B,14B,32B,72B}, huggingface.co/Qwen/Qwen3-{8B,32B}, huggingface.co/mistralai/Mistral-7B-v0.3, huggingface.co/mistralai/Mistral-Nemo-Base-2407, huggingface.co/microsoft/phi-4.
- Llama 3.1 8B et 70B : les config.json de Meta sont soumis à accord sur Hugging Face, les valeurs viennent donc du tableau 3 de l'article de Meta "The Llama 3 Herd of Models" (arXiv 2407.21783). Gemma 2 9B et 27B : tableau 1 du rapport de Google "Gemma 2" (arXiv 2408.00118).
- Le nombre de paramètres est le total safetensors affiché par l'API Hugging Face pour chaque dépôt. Quand le config.json n'a pas de head_dim, l'outil utilise hidden_size ÷ têtes d'attention.
Questions fréquentes
De combien de VRAM a besoin un modèle 7B en 4 bits ?
Environ 3,3 Gio pour les poids seuls. Avec un contexte de 8 192 tokens sur un modèle de la classe Llama 3.1 8B, le cache KV ajoute environ 1 Gio, soit près de 5 Gio avec le surcoût. Une carte de 8 Go suffit, avec de la marge pour un contexte plus long.
Une carte de 24 Go peut-elle faire tourner un modèle 32B ?
En 4 bits, oui. Qwen2.5 32B compte environ 32,76 milliards de paramètres, donc les poids occupent près de 15,3 Gio. Avec 8 192 tokens de contexte, le cache KV pèse 2 Gio, et avec 10 % de surcoût le total avoisine 19 Gio.
Pourquoi ma consommation réelle diffère-t-elle de l'estimation ?
Les frameworks n'ont pas le même surcoût. vLLM réserve à l'avance l'essentiel du GPU pour son cache KV et préempte des requêtes quand la place manque, llama.cpp alloue d'emblée le cache du contexte complet, et les K-quants GGUF stockent des valeurs d'échelle en plus, donc leurs bits effectifs dépassent le chiffre nominal. Augmentez les bits ou le surcoût en cas d'erreur de mémoire.
Cela fonctionne-t-il pour les modèles à mélange d'experts ?
Les poids doivent quand même tenir en mémoire : saisissez le nombre total de paramètres, pas les paramètres actifs. Le cache KV ne dépend que des couches d'attention, donc prenez les couches et les têtes KV du config. Les modèles prédéfinis ici sont denses.
Gemma 2 utilise une fenêtre glissante. L'estimation est-elle plus basse ?
Gemma 2 alterne des couches locales à fenêtre de 4 096 tokens et des couches globales. L'outil compte le contexte complet sur toutes les couches ; c'est donc une borne haute pour Gemma 2 quand le contexte dépasse la fenêtre.