Calculateur de VRAM

Estimez les besoins en VRAM GPU pour l'inférence LLM, le fine-tuning complet, l'entraînement LoRA et la quantification GGUF. Calculez les poids du modèle, le cache KV, les états d'optimiseur et la surcharge du framework à partir des principes de base, puis vérifiez quels GPU conviennent à votre charge de travail. Gratuit, instantané et totalement privé.

VRAM Calculator

Estimate GPU VRAM requirements for LLM inference, full fine-tuning, LoRA training, and GGUF quantisation. Model weights, KV cache, activations, optimizer states, and framework overhead - all calculated from first principles in your browser.

Model Preset

32 layers · 8 KV heads · head dim 128

Model Architecture

Parameters (Billions)

Transformer Layers

KV Heads (GQA)

Head Dimension

Workload Mode

Weights + KV cache + minimal activations. Smallest footprint.

Weight Precision

Context & Batch

Sequence Length

tokens

51264K128K

Batch Size

reqs

13264

Compare Against GPU

Total VRAM Required

16.57 GB

for inference

8.03B params · FP16 · seq 4,096 · batch 1

Model Weights

14.96 GB

KV Cache

512 MB

Activations

31 MB

Overhead

1.08 GB

NVIDIA RTX 4090 (24 GB) (24 GB)

✅ Fits on a single GPU (69.0% VRAM used)

Single GPU ✓

VRAM Usage16.57 GB / 24 GB (69.0%)

On-prem dev/inference, small models

VRAM Breakdown

Model Weights14.96 GB (90.3%)

KV Cache512 MB (3.0%)

Activations31 MB (0.2%)

Framework Overhead1.08 GB (6.5%)

Precision Comparison (Same Config)

Precision	Weights	Total VRAM	Fits 24 GB?
FP32	29.91 GB	33.14 GB	✗ No
FP16 Selected	14.96 GB	16.57 GB	✓ Yes
BF16	14.96 GB	16.57 GB	✓ Yes
FP8	7.48 GB	8.55 GB	✓ Yes
INT8	7.48 GB	8.55 GB	✓ Yes
INT4	3.74 GB	4.54 GB	✓ Yes

GPU Compatibility

GPU	VRAM	GPUs Needed	Status
NVIDIA RTX 4090 (24 GB)Selected On-prem dev/inference, small models	24 GB	1×	Single GPU
NVIDIA A10G (24 GB) Inference & ML serving	24 GB	1×	Single GPU
NVIDIA L4 (24 GB) Cost-efficient inference	24 GB	1×	Single GPU
NVIDIA RTX 3090 (24 GB) Budget on-prem inference	24 GB	1×	Single GPU
Apple M4 Pro (24 GB unified) Mac inference, small models	24 GB	1×	Single GPU
NVIDIA A100 40 GB Training medium models, inference	40 GB	1×	Single GPU
NVIDIA L40S (48 GB) Inference, multi-modal workloads	48 GB	1×	Single GPU
NVIDIA A40 (48 GB) Inference & fine-tuning	48 GB	1×	Single GPU
Apple M4 Max (48 GB unified) Mac inference, light fine-tuning	48 GB	1×	Single GPU
NVIDIA H100 / H100 PCIe (80 GB) LLM training & production inference	80 GB	1×	Single GPU
NVIDIA A100 80 GB LLM fine-tuning & inference	80 GB	1×	Single GPU
AMD MI250X (128 GB) Large-scale HPC & LLM training	128 GB	1×	Single GPU
Apple M4 Ultra (128 GB unified) On-device Mac inference	128 GB	1×	Single GPU
NVIDIA H200 SXM (141 GB) Largest LLM inference & training	141 GB	1×	Single GPU
AMD MI300X (192 GB) Very large model inference & training	192 GB	1×	Single GPU
NVIDIA RTX 3080 (10 GB) Small model inference only	10 GB	2×	2× Multi-GPU
NVIDIA RTX 4070 (12 GB) Light inference, LoRA tuning	12 GB	2×	2× Multi-GPU
NVIDIA V100 (16 GB) Legacy workloads	16 GB	2×	2× Multi-GPU
NVIDIA RTX 4080 (16 GB) Consumer dev, small inference	16 GB	2×	2× Multi-GPU

Estimation Notes: VRAM estimates use the standard formula: weights × bytes/param + KV cache (2 × layers × KV-heads × head-dim × seq-len × batch × FP16 bytes) + framework overhead (7%). Training estimates include Adam optimizer states and gradients. Actual usage varies by runtime (vLLM, llama.cpp, Transformers), quantisation method, and model architecture specifics. Always leave 10-15% VRAM headroom. All calculations run locally in your browser.

Pourquoi utiliser notre calculateur de VRAM

Planifier du matériel pour les LLM sans mesurer la mémoire GPU conduit souvent à surdimensionner les cartes ou à des erreurs de mémoire insuffisante (OOM) en pleine exécution. Ce calculateur applique la vraie formule de la VRAM plutôt que des règles approximatives, pour dimensionner vos GPU en confiance avant toute location ou achat.

Choisissez entre les modes inférence, fine-tuning complet, entraînement LoRA et quantification GGUF : chaque mode applique la formule adaptée à cette charge de travail et met à jour instantanément les poids, le cache KV, les états d'optimiseur et la surcharge du framework.

Des calculs à partir des principes de base : poids, cache KV, activations, états d'optimiseur, gradients et surcharge du framework, sans approximation.
Totalement privé : vos configurations sont calculées dans votre navigateur et ne sont jamais envoyées à un serveur.
Modes inférence, fine-tuning, LoRA et GGUF, chacun avec sa formule de VRAM spécifique.
Tableau de compatibilité de 19 GPU, dont H100, A100, RTX 4090, AMD MI300X et Apple Silicon.

Cas d'usage courants

De la sélection du matériel à la planification des entraînements, voici les scénarios où une estimation fiable de la VRAM fait gagner du temps et de l'argent.

Choisir un GPU pour l'inférence LLM : vérifier si un modèle 70B tient sur une seule A100 80 Go ou nécessite deux GPU.
Planifier des entraînements de fine-tuning : le fine-tuning complet avec Adam demande souvent 3 à 6 fois la mémoire de l'inférence.
Optimiser le cache KV pour les longs contextes : voir la VRAM supplémentaire pour passer de 4K à 32K ou 128K tokens.
Choisir la bonne quantification GGUF : comparer Q4, Q5 et Q8 et leur compromis qualité/mémoire.
Exécuter des modèles sur du matériel grand public : savoir quels modèles quantifiés tiennent dans 12, 16 ou 24 Go de VRAM.
Planifier un budget d'entraînement LoRA : voir l'impact du rang choisi sur la mémoire nécessaire.

Comment la VRAM est calculée et ses limites

La VRAM est la mémoire de la carte graphique, pas la RAM système : les poids, le cache KV, les activations et les tampons du framework doivent tenir simultanément dans ce budget fixe. La quantité nécessaire dépend du nombre de paramètres, de la précision numérique, de la longueur de séquence et de la taille de lot, ainsi que du type de charge de travail (inférence, entraînement ou LoRA). Nous utilisons les mêmes formules que vLLM, Transformers et llama.cpp en interne.

Le calculateur fournit des estimations de niveau ingénierie, pas des mesures exactes : l'usage réel peut varier de ±10-20 % selon le runtime, l'implémentation du modèle, la capture de graphes CUDA et la fragmentation mémoire. Tous les calculs s'exécutent localement dans votre navigateur.

Indiquez les paramètres du modèle et la précision : un modèle 7B en FP16 pèse ~14 Go et ~3,5 Go en INT4.
Ajoutez le cache KV à partir des couches, têtes KV, dimension de tête, longueur de séquence et lot ; le GQA le réduit fortement.
Pour l'entraînement, ajoutez les gradients et les états de l'optimiseur Adam : environ 12 octets de plus par paramètre en fine-tuning complet.
Ajoutez la surcharge du framework : nous réservons 7 % pour PyTorch, CUDA et la fragmentation mémoire.

Foire aux questions

Un calculateur de VRAM estime la mémoire GPU nécessaire pour charger et exécuter un grand modèle de langage. Il calcule le stockage des poids du modèle (paramètres × octets par précision), le cache KV (à partir de la longueur de séquence, de la taille de lot et de l'architecture d'attention), les activations et, pour l'entraînement, les états d'optimiseur et les gradients. Tout s'exécute dans votre navigateur, sans envoi de données.

Le nombre de paramètres figure généralement dans le nom du modèle (7B, 70B, 405B). Pour des valeurs exactes, consultez le fichier config.json du modèle sur Hugging Face et cherchez le champ "num_parameters". Nos préréglages incluent des nombres de paramètres précis pour des modèles populaires comme Llama 3.1, Qwen2.5, Mistral et Gemma 2.

Lors d'un fine-tuning complet, le GPU doit stocker les poids du modèle, des tenseurs de gradient de même taille et l'état de l'optimiseur Adam (premier moment, second moment et poids maîtres FP32), soit environ 12 octets supplémentaires par paramètre. Pour un modèle 7B en BF16, l'inférence demande ~14 Go, mais l'entraînement complet nécessite ~60-80 Go.

Le cache KV stocke les clés et valeurs d'attention de tous les tokens précédents. Sa taille = 2 × couches × têtes KV × dimension de tête × longueur de séquence × taille de lot × octets. Il croît linéairement avec le contexte : passer de 4K à 128K tokens le multiplie par 32. Le GQA réduit les têtes KV et diminue fortement sa taille.

Le mode GGUF calcule la mémoire des poids comme paramètres × (bits de quantification / 8) octets. Le cache KV est toujours stocké en FP16, quelle que soit la quantification des poids. Q4_K_M (≈4 bits) offre le meilleur équilibre entre qualité et mémoire pour les utilisateurs de llama.cpp et d'Ollama.

Le GQA réduit le nombre de têtes clé et valeur à une fraction des têtes de requête. Comme le cache KV évolue avec les têtes KV, le GQA peut le réduire de 4 fois ou plus. Llama 3.1 utilise 8 têtes KV contre 32 têtes de requête. Saisissez num_key_value_heads depuis config.json pour des estimations précises.

En FP16, un modèle 70B nécessite environ 140 Go rien que pour les poids, et tient sur deux cartes H100 80 Go. En INT4, les poids tombent à ~35 Go, ce qui tient sur une seule H100. Le tableau de compatibilité GPU indique le nombre minimal de GPU pour chaque carte de votre configuration.

Le calculateur utilise la formule théorique standard sur laquelle reposent tous les runtimes. L'attention paginée de vLLM peut ajouter 5-15 % de surcharge. llama.cpp mappe les poids en mémoire et peut exécuter des modèles plus grands. La marge de surcharge de 7 % couvre l'essentiel des écarts entre runtimes. Validez toujours par un petit test avant de déployer en production.

Oui. Le calculateur de VRAM s'exécute entièrement côté client dans votre navigateur. Les paramètres d'architecture, les précisions et les réglages de contexte sont traités localement sur votre appareil et ne sont jamais envoyés à un serveur. Aucun compte ni inscription n'est requis.