Calcul de VRAM

Chaque question « est-ce que ça tourne sur ma carte » est de l'arithmétique, pas du folklore. La VRAM totale, ce sont les poids, plus le cache KV, plus une tranche fixe d'activations et de frais généraux moteur. Si vous savez multiplier des paramètres par des bits, vous savez dimensionner une machine avant d'y dépenser quoi que ce soit. Cette page donne la formule, des tableaux détaillés, et une démarche en 16 GB que vous pouvez copier pour n'importe quelle carte.

La formule

VRAM totale   = poids + cache KV + frais généraux
poids (GB)    = paramètres (B) × bits par poids ÷ 8
cache KV      = octets par jeton × longueur de contexte   (voir [cache KV](/guide/kv-cache))
frais généraux ≈ 1–2 GB (activations, contexte pilote, tampons, fragmentation)

Bits effectifs par poids pour les quants GGUF courants : Q4_K_M ≈ 4.8, Q5_K_M ≈ 5.7, Q6_K ≈ 6.6, Q8_0 ≈ 8.5. Multipliez les paramètres par cela, divisez par 8, et vous êtes à quelques pourcents de la taille du fichier sur disque.

Règles empiriques à mémoriser, en GB par milliard de paramètres :

• Q4_K_M ≈ 0.6 GB — le cheval de trait quotidien
• Q5_K_M ≈ 0.7 GB
• Q6_K ≈ 0.8 GB — quasi sans perte à l'œil nu
• Q8_0 ≈ 1.1 GB — transparent, environ le double du coût Q4
• fp16/bf16 = 2.0 GB — territoire de l'entraînement et du fine-tuning sérieux

Exemples détaillés

La taille du cache KV dépend de l'architecture. Les modèles GQA modernes tournent à environ 128–256 KB par jeton en KV fp16 pour les classes 8B–32B, et autour de 320 KB pour la classe 70B. La formule exacte vit sur cache KV ; ici nous nous contentons de l'ajouter. Les frais généraux sont budgétés à 1.5 GB par ligne.

Q4_K_M (~4.8 bits par poids) :

Q6_K (~6.6 bits par poids) :

Deux motifs à intérioriser. Q6_K coûte ~35–40% de plus que Q4_K_M — souvent la différence entre un palier GPU et le suivant. Et le KV à contexte 32k n'est pas une erreur d'arrondi : sur les petits modèles il rivalise avec les poids eux-mêmes. Les vieux designs MHA (ère Llama-2) portaient des caches KV 4–8× plus gros, voilà pourquoi le contexte 32k exigeait du matériel exotique et pas les modèles GQA.

OOM au chargement vs OOM en pleine génération

• Au chargement : les poids seuls dépassent la VRAM libre. Le moteur refuse de démarrer, ou échange des couches vers le CPU et rampe. Honnête, immédiat, facile à diagnostiquer.
• En pleine génération : les poids tiennent, mais le cache KV grossit jeton par jeton. Une session fraîche marche bien ; quarante tours plus tard, après un dump RAG ou un fichier collé, le cache mange votre marge et le processus meurt en pleine réponse. C'est le sournois — dimensionnez toujours pour le contexte que vous atteindrez réellement, pas pour le premier prompt.

Regardez cela se produire en direct :

watch -n1 nvidia-smi --query-gpu=memory.used,memory.total --format=csv

Feuille de dimensionnement : la démarche 16 GB

1. Budget utilisable : 16 GB × 0.85 ≈ 13.6 GB. Bureau, navigateur et pilote réservent déjà 0.5–1 GB ; 10–20% de marge est la règle, pas un luxe.
2. Rêve : 32B Q4_K_M — 19.2 GB de poids seuls. Mort-né.
3. Réaliste : 14B Q4_K_M à contexte 8k : 8.4 + 1.6 + 1.5 = 11.5 GB. Tient avec ~15% de marge. Livrez-le.
4. Maintenant vous voulez 32k de contexte : 8.4 + 6.4 + 1.5 = 16.3 GB. Hors budget.
5. Trois correctifs — choisissez-en un ou combinez :
   • Quantifiez le cache KV en q8_0 : 6.4 → 3.2 GB, total 13.1 GB. Dedans.
   • Descendez les poids en Q4_K_S ou IQ4_XS, économisant encore ~0.5–1 GB.
   • Descendez à 8B Q6_K : 6.6 + 4.2 + 1.5 = 12.3 GB, spacieux.

Les mêmes cinq étapes valent pour une carte 8 GB, une carte 24 GB ou une brique bi-GPU 48 GB. Budgéter, rêver, soustraire, ajuster.

Laissez toujours de la marge

Les moteurs allouent des tampons de travail par slot de lot, la fragmentation s'accumule sur un serveur de longue durée, et la concurrence multiplie le KV par requête active. Une config qui « tient juste » dans un bench ponctuel fera un OOM en production. 10–20% de libre est l'impôt pour rester debout. Pour ce qui tient à chaque palier de carte en pratique, voir paliers de GPU ; pour pourquoi les bits de quant sont ce qu'ils sont, voir quantification.

Voir aussi : quantification · cache KV · paliers de GPU