L'arithmétique de la VRAM¶

Le calcul complet, avec les valeurs réelles du config.json.

La formule¶

\[ \text{VRAM} = \underbrace{P \times b}_{\text{poids}} + \underbrace{n \times c}_{\text{cache KV}} + \underbrace{S}_{\text{état linéaire}} + \text{marge} \]

Symbole	Signification	Valeur
\(P\)	paramètres	27,729 G (recalculés)
\(b\)	octets par paramètre	2 (BF16), 1 (FP8), 0,5 (4 bits)
\(n\)	jetons en contexte	jusqu'à 1 000 000
\(c\)	octets de cache par jeton	65 536 (64 KiO)
\(S\)	état récurrent DeltaNet	0,159 Go, constant

La marge couvre les activations intermédiaires et la fragmentation : ce chapitre retient 90 % de la VRAM comme réellement utilisable.

Poste 1 — Les poids¶

Précision	Poids
BF16	55,46 Go
FP8	27,73 Go
4 bits	13,86 Go

Le dépôt officiel affiche 55,6 Go en BF16 — l'écart de 0,26 % avec le calcul valide le décompte. Voir Vérification des paramètres.

Poste 2 — Le cache clé-valeur¶

\[ c = L_{kv} \times 2 \times H_{kv} \times d_h \times b_c = 16 \times 2 \times 4 \times 256 \times 2 = 65\,536\ \text{octets} \]

Seules 16 des 64 couches — celles à attention complète — alimentent le cache.

Contexte	Cache
8 192	0,54 Go
32 768	2,15 Go
131 072	8,59 Go
262 144 (natif)	17,18 Go
524 288	34,36 Go
1 000 000 (étendu)	65,54 Go

Le contrefactuel¶

Si les 64 couches étaient en attention complète :

\[ c = 64 \times 4\,096 = 262\,144\ \text{octets} = 256\ \text{KiO par jeton} \]

Architecture	Cache à 262 144
16 couches complètes (réel)	17,18 Go
64 couches complètes (hypothétique)	68,72 Go

L'hybride économise 75 % du cache

C'est le chiffre décisif pour un usage local, et il n'est publié nulle part.

Poste 3 — L'état récurrent¶

\[ 48\ \text{couches} \times 48\ \text{têtes} \times 128 \times 128 \times 4\ \text{octets} \approx 0{,}159\ \text{Go} \]

Constant, quelle que soit la longueur du contexte. Négligeable, mais compté dans les tableaux qui suivent.

Ce que tient réellement votre carte¶

Cache en BF16, 90 % de VRAM utile, une seule séquence à la fois.

Poids en 4 bits (13,86 Go)¶

Carte	VRAM	Contexte utilisable
RTX 4090 / 5080	24 Go	~115 600 jetons
RTX 5090	32 Go	~225 500 jetons
L40S / RTX Pro 6000	48 Go	~445 200 jetons
H100 / H200	80 Go	~884 700 jetons
Mac 128 Go unifiés	~110 Go utiles	le million complet

Poids en FP8 (27,73 Go)¶

Carte	Contexte utilisable
RTX 4090 24 Go	ne charge pas
RTX 5090 32 Go	~13 900 jetons
L40S 48 Go	~233 600 jetons
H100 80 Go	~673 100 jetons
Mac 128 Go	le million complet

Poids en BF16 (55,46 Go)¶

Carte	Contexte utilisable
RTX 4090, 5090, L40S	ne charge pas
H100 80 Go	~250 000 jetons
Mac 128 Go	~662 000 jetons

Les trois seuils à retenir¶

24 Go — le seuil d'entrée

En 4 bits, une RTX 4090 tient 115 600 jetons. C'est largement de quoi analyser un dépôt de code moyen ou un long document.

C'est la configuration qui rend ce modèle intéressant pour un particulier.

48 Go — le seuil confortable

Une L40S ou une RTX Pro 6000 dépasse la fenêtre native de 262 144 jetons, en 4 bits comme en FP8.

C'est le point d'équilibre du modèle : assez de VRAM pour la précision recommandée en agentique et pour tout le contexte natif.

32 Go — le seuil piège

Une RTX 5090 tient 225 500 jetons en 4 bits, mais seulement 13 900 en FP8 — les poids en occupent presque toute la mémoire.

Si votre usage est agentique, où le FP8 est recommandé, 32 Go est une configuration frustrante. Voir Quantification.

La concurrence¶

Tout ce qui précède suppose une séquence à la fois. En service, le cache est proportionnel au nombre de requêtes simultanées.

Sur une carte de 48 Go avec des poids en 4 bits (~29,4 Go disponibles) :

Requêtes simultanées	Contexte par requête
1	~445 000 jetons
2	~222 000 jetons
4	~112 000 jetons
16	~28 000 jetons
64	~7 000 jetons

L'erreur de dimensionnement classique

On teste seul, tout va bien. On met en service, seize utilisateurs se connectent, et le contexte s'effondre ou les requêtes partent en file d'attente.

Pour un usage multi-utilisateur, la grandeur à budgéter est concurrence × contexte, jamais le contexte seul.

Recommandations¶

Objectif	Matériel
Conversation, contexte court, un utilisateur	24 Go en 4 bits
Codage sur dépôt (~100 K jetons)	24 Go en 4 bits suffit
Fenêtre native complète (262 K)	48 Go, 4 bits ou FP8
Agentique de qualité (FP8 minimum)	48 Go
Contexte au-delà de 500 K	80 Go
Le million de jetons	Mac 128 Go ou multi-GPU
Service multi-utilisateur	dimensionner sur `concurrence × contexte`

Rejouer le calcul¶

python3 verif-qwen3-8-27b.py

Le script produit tous les tableaux ci-dessus à partir du config.json publié.

À retenir¶

Ce chapitre en cinq points

La VRAM, c'est poids + cache + état + marge, jamais les poids seuls.
Le cache vaut 64 KiO par jeton, soit 17,18 Go au contexte natif — plus que les poids en 4 bits.
Une RTX 4090 en 4 bits tient ~115 600 jetons.
48 Go dépasse la fenêtre native en 4 bits comme en FP8 : c'est le point d'équilibre.
32 Go est un seuil piège : confortable en 4 bits, presque inutilisable en FP8.

Chapitre suivant : Le coût du cache clé-valeur.