L’ensemble des 6 centres de données opérationnels

Payé en crypto · Sans vérification d’identité · Accès root en moins de 5 minutes

Dimensionnement guide · 9 min de lecture

La VRAM qu’un modèle nécessite réellement.

Deux nombres décident : les poids, qui sont fixes, et le cache clef/valeur, qui augmente avec la quantité de contexte servie. Presque toutes les erreurs viennent d’une estimation du second à partir du premier.

En bref

Weights
Paramètres en milliards × octets par paramètre. Un modèle 70B en 4-bit pèse 35 GB.
Cache clef/valeur
2 × couches × têtes KV × dimension de tête × octets, par token. Sans rapport avec le nombre de paramètres.
Overhead
Ajoutez environ 15 % pour les activations, le contexte CUDA et la fragmentation de l’allocateur.
Le piège
Quantifier les poids en 4-bit ne quantifie pas le cache. Il reste en FP16 dans toutes les piles logicielles courantes.

La formule

Aucune règle empirique ne survit ici à l’épreuve d’un second modèle. Le calcul complet tient en trois lignes, et il vaut mieux les faire que de se fier à un multiplicateur.

VRAM totale, en GB
# 1. Weights
weights_gb   = parameters_in_billions × bytes_per_parameter

# 2. KV cache, per token — then multiplied by the context you serve
bytes_per_tok = 2 × layers × kv_heads × head_dim × cache_bytes
cache_gb      = bytes_per_tok × context_tokens × batch / 1024³

# 3. Everything else
total_gb      = (weights_gb + cache_gb) × 1.15

Le 2 s’explique par la présence de deux tenseurs par token, K et V. bytes_per_parameter vaut 2 pour BF16, 1 pour FP8, 0,5 pour 4-bit. cache_bytes est un nombre distinct, et cette séparation est la source d’erreur la plus fréquente — voir ci-dessous.

Poids

La moitié facile. Elle est exactement linéaire par rapport au nombre de paramètres, et la seule décision à prendre est la précision.

Mémoire des poids par précision, pour une sélection de tailles de modèles
Modèle BF16 / FP16FP84-bit (AWQ, GPTQ)
Llama 3.1 8B8B de paramètres 16.0 GB 8.0 GB 4.0 GB
Qwen 3 32B32B de paramètres 64.0 GB 32.0 GB 16.0 GB
Llama 3.3 70B70B de paramètres 140.0 GB 70.0 GB 35.0 GB
Llama 3.1 405B405B de paramètres 810.0 GB 405.0 GB 202.5 GB

La quantification en 4-bit coûte de la qualité, et l’ampleur de cette perte dépend bien plus du modèle que de la méthode. C’est le bon compromis quand cela fait la différence entre une carte et quatre ; c’est un mauvais compromis quand vous êtes déjà à l’aise.

Le cache clef/valeur

La moitié difficile, celle qui décide si une machine est adaptée à 4k et inadéquate à 128k. Elle dépend des couches et des têtes KV — pas de la taille du modèle.

Deux modèles de tailles très différentes, côte à côte. Llama 3.3 70B a 80 couches et 8 têtes KV, donc 320 KB par token. Gemma 3 27B — un tiers des paramètres — a 62 couches et 16 têtes KV, donc 496 KB par token, soit 1.6× de plus. Toute estimation fondée sur le nombre de paramètres se trompe dans le sens inverse.
Taille du cache clef/valeur par modèle et longueur de contexte, en précision de cache FP16, une requête
Modèle Par token 4k de contexte8k de contexte32k de contexte128k de contexte
Llama 3.1 8B 32 couches · 8 têtes KV 128 KB 0.5 GB 1.0 GB 4.0 GB 16.0 GB
Gemma 3 27B 62 couches · 16 têtes KV 496 KB 1.9 GB 3.9 GB 15.5 GB 62.0 GB
Llama 3.3 70B 80 couches · 8 têtes KV 320 KB 1.3 GB 2.5 GB 10.0 GB 40.0 GB
DeepSeek V3 671B-A37B (MoE) Attention latente 70 KB 0.3 GB 0.5 GB 2.2 GB 8.8 GB
Llama 3.1 405B 126 couches · 8 têtes KV 504 KB 2.0 GB 3.9 GB 15.8 GB 63.0 GB

Lisez la dernière colonne avant la première. À un contexte de 4k, le cache est une erreur d’arrondi pour chaque modèle ici ; à 128k, il dépasse le poids d’un modèle 70B en 4-bit. DeepSeek V3 fait exception parce que son attention latente compresse le cache par conception — c’est ce qui le rend utilisable à contexte long malgré le fait qu’il soit le plus gros modèle de la liste.

Où les estimations se trompent

Dimensionner le cache à partir du nombre de paramètres. L’erreur la plus fréquente, celle illustrée ci-dessus. Un modèle 27B peut nécessiter plus de cache qu’un modèle 70B.

Supposer que des poids en 4-bit impliquent un cache en 4-bit. Ce n’est pas le cas. AWQ et GPTQ ne quantifient que les poids ; le cache reste en FP16 sauf si vous activez explicitement le FP8 KV. Un modèle 70B en 4-bit et avec un contexte de 128k pèse 35 GB de poids et 40 GB de cache.

Dimensionner pour une seule requête. Le cache est par séquence simultanée. Servir huit utilisateurs à la fois nécessite huit fois plus de cache — voir ci-dessous.

Oublier la marge. Les activations, le contexte CUDA et la fragmentation de l’allocateur sont réels. 15 % est une marge délibérément prudente ; l’ignorer complètement, c’est ainsi qu’un modèle qui « tient » échoue au chargement.

Additionner la VRAM totale de plusieurs cartes. Quatre cartes de 24 GB ne font pas une carte de 96 GB. Le parallélisme tensoriel peut répartir un modèle sur plusieurs cartes, mais chaque couche doit alors se synchroniser via l’interconnexion — voir le guide NVLink.

Dimensionner un MoE d’après ses paramètres actifs. DeepSeek V3 active 37B de paramètres par token, mais vous devez conserver la totalité des 671B en mémoire. Les paramètres actifs prédisent la vitesse ; le nombre total de paramètres décide si le modèle se charge, tout simplement.

Exemples détaillés

Mémoire totale nécessaire, poids plus cache plus marge, avec un contexte de 8k et une requête. C’est le même calcul que le configurateur applique à chaque configuration du catalogue.

VRAM totale nécessaire avec un contexte de 8k, par modèle et précision
Modèle BF16 / FP16FP84-bit (AWQ, GPTQ) Le plus petit nœud qui tient
Llama 3.1 8B 8B de paramètres 20 GB 10 GB 6 GB NVIDIA L4 $125/mois · sur une carte · ~34 tok/s
Mistral Small 24B 24B de paramètres 57 GB 28 GB 15 GB NVIDIA L4 $125/mois · sur une carte · ~11 tok/s
Gemma 3 27B 27B de paramètres 67 GB 33 GB 20 GB NVIDIA L4 $125/mois · sur une carte · ~10 tok/s
Qwen 3 32B 32B de paramètres 76 GB 38 GB 21 GB NVIDIA L4 $125/mois · sur une carte · ~8 tok/s
Llama 3.3 70B 70B de paramètres 164 GB 82 GB 43 GB 2 × NVIDIA L4 $285/mois · réparti sur le nœud · ~7 tok/s
Mixtral 8×22B (MoE) 39B actifs sur 141B 326 GB 163 GB 83 GB 4 × NVIDIA L4 $564/mois · réparti sur le nœud · ~4 tok/s
Qwen 3 235B-A22B (MoE) 22B actifs sur 235B 542 GB 271 GB 137 GB 8 × NVIDIA L4 $1,106/mois · réparti sur le nœud · ~10 tok/s
DeepSeek V3 671B-A37B (MoE) 37B actifs sur 671B 1,544 GB 772 GB 386 GB 8 × NVIDIA A100 PCIe $7,906/mois · réparti sur le nœud · ~37 tok/s
Llama 3.1 405B 405B de paramètres 936 GB 468 GB 237 GB 10 × NVIDIA L4 $1,371/mois · réparti sur le nœud · ~3 tok/s

La dernière colonne indique le nœud le moins cher de notre catalogue qui contient le modèle en 4-bit et avec un contexte de 8k, avec le débit de génération en flux unique que permet la bande passante mémoire. Les chiffres de débit sont délibérément prudents et calibrés sur des mesures publiées — considérez-les comme un plancher, pas une promesse.

Servir plus d’une requête

C’est ici qu’une machine dimensionnée pour une démonstration devient une machine incapable de servir un produit. Les poids se paient une fois ; le cache se paie par séquence simultanée.

VRAM totale pour Llama 3.3 70B en 4-bit, par requêtes simultanées et contexte
Requêtes simultanées 4k de contexte8k de contexte32k de contexte
1 requête 42 GB une carte de 80 GB 43 GB une carte de 80 GB 52 GB une carte de 80 GB
4 requêtes 46 GB une carte de 80 GB 52 GB une carte de 80 GB 86 GB un H200
16 requêtes 63 GB une carte de 80 GB 86 GB un H200 224 GB nœud multi-GPU
64 requêtes 132 GB un H200 224 GB nœud multi-GPU 776 GB nœud multi-GPU

Llama 3.3 70B en 4-bit pèse 35 GB de poids, quoi que vous fassiez. Tout ce qui dépasse 35 GB dans ce tableau est du cache. C’est pourquoi « ça tournait bien sur mon ordinateur portable » et « ça s’est effondré en production » désignent le même modèle sur la même carte.

Deux façons de récupérer de la mémoire de cache. Activez le cache clef/valeur en FP8 si votre pile logicielle le permet — cela divise par deux les chiffres ci-dessus, pour une perte de qualité généralement invisible. Et plafonnez --max-model-len au contexte que vous servez réellement : vLLM réserve du cache pour le maximum déclaré, donc déclarer 128k quand vous servez 8k gaspille seize fois la mémoire dont vous avez besoin.

Quelle machine cela implique

Trois règles pratiques qui découlent de tout ce qui précède, dans l’ordre de leur importance.

  1. Une seule carte vaut mieux que plusieurs, chaque fois que c’est possible. Pas de répartition, pas de synchronisation entre les couches, pas d’interconnexion à prendre en compte. Si votre modèle, à votre contexte, tient sur une seule carte, achetez cette carte.
  2. Dimensionnez pour votre contexte réel et votre concurrence réelle, pas pour le maximum annoncé du modèle. Le maximum annoncé est une capacité, pas une obligation.
  3. Quand vous devez répartir, préférez NVLink. Répartir sur quatre cartes PCIe fonctionne ; répartir sur quatre cartes NVLink fonctionne et est nettement plus rapide. Le guide suivant explique précisément quand cette différence justifie son coût.

Le configurateur effectue ce calcul en direct sur les 41 configurations : choisissez un modèle, une précision et une longueur de contexte, et il indique quels nœuds le contiennent, lesquels le contiennent sur une seule carte, et ce que coûte chacun par mois. Il applique la formule de cette page, donc si vous contestez notre calcul, vous pouvez désormais dire exactement où.

Vérifiez votre propre modèle sur chacune des machines que nous louons.

Le configurateur effectue ce calcul pour les 41 configurations, avant que vous ne payiez quoi que ce soit.

Se connecter

Console, factures et accès hors bande.

Pas encore de compte ?

Il n’y a pas d’inscription séparée. Votre compte est créé au moment où vous passez votre première commande — vous choisissez l’e-mail et le mot de passe à l’étape de paiement, et la console est ouverte au moment où la machine l’est.

Configurer un serveur

Language