Calculateur de matériel pour LLM

Cache KV

Jusqu'à 262144 pour qwen3-*. La qualité se dégrade au-delà du contexte natif.

qwen3-32b · Q4_K_M · KV=Q8

poids ~17.6 GB · KV 131 KB/token · requis ~36.8 GB pour 131,072

Goulot d'étranglement: KV 47% / poids 48% / overhead 5%

  • 2x RTX 3090max 131,07243-64 tok/s
  • RTX 4090 48GBmax 131,07229-43 tok/s

Unités décimales : 1 Go=109 octets1\,\text{Go} = 10^{9}\,\text{octets}, 1 Ko=103 octets1\,\text{Ko} = 10^{3}\,\text{octets}. Jamais de Gio ni de Kio.

Le déchargement sur le CPU n'est pas compté comme une façon de faire tenir le modèle ; mmap n'influe que sur le temps de chargement, pas sur le calcul de la VRAM.

Estimation du décodage seul ; le préremplissage (lecture d'un long contexte) n'est pas modélisé, alors que sur les MoE géants, c'est lui le véritable goulot d'étranglement.

decode-only estimate; anchors: llama.cpp single stream, 2026-09

À propos de ces estimations

  • Décodage à flux unique (taille de lot=1\text{taille de lot} = 1) calibré sur des mesures llama.cpp, septembre 2026.
  • Unités décimales : 1 Go=109 octets1\,\text{Go} = 10^{9}\,\text{octets}. Les machines à mémoire unifiée réservent 4 Go au système.
  • Le décodage MoE ne lit que les experts actifs, avec un facteur de 0,35× (limité par la latence).
  • Un cache KV en Q8 divise par deux la mémoire du cache avec une perte de qualité négligeable.

À propos de cet outil

Ce calculateur estime si un grand modèle de langage (LLM) tient sur un GPU ou un Mac donné, et à quelle vitesse il générerait du texte. Il s'adresse aux personnes qui font tourner des modèles en local avec llama.cpp et des outils similaires. La quantification stocke les poids du modèle avec une précision réduite, ce qui diminue l'empreinte mémoire au prix d'une légère perte de qualité ; ce calculateur compte 0,55 octet par paramètre pour Q4_K_M. Le cache KV conserve les données d'attention de chaque token du contexte.

Deux caractéristiques du matériel décident du résultat. La capacité mémoire détermine si les poids et le contexte souhaité peuvent seulement être chargés, tandis que la bande passante mémoire détermine la vitesse à laquelle les tokens apparaissent une fois le modèle chargé. Une carte dotée de beaucoup de mémoire mais d'une faible bande passante, comme un ancien GPU de centre de données, peut contenir un gros modèle et pourtant générer lentement.

Fonctionnement

Dans « Trouver du matériel », choisissez un modèle, une quantification et une précision de cache KV, puis saisissez la longueur de contexte et la vitesse minimale que vous acceptez, en tokens par seconde ; YaRN est facultatif. L'outil liste les machines qui conviennent, avec leurs besoins en mémoire et leurs fourchettes de vitesse. Dans « Vérifier mon matériel », choisissez une machine, les quantifications à comparer et un contexte cible pour voir quels modèles tiennent.

La mémoire requise correspond à la taille des poids, plus le cache KV pour tout le contexte, plus un surcoût fixe de 2 Go. Les poids en Go valent le nombre de milliards de paramètres multiplié par le nombre d'octets par paramètre : 0,55 pour Q4_K_M, 0,65 pour Q5_K_M, 0,75 pour Q6_K, 1,07 pour Q8_0 et 2,0 pour BF16. Le cache occupe 2×L×Hkv×dhead2 \times L \times H_{kv} \times d_{head} octets par token en Q8, et le double en FP16, où L est le nombre de couches. La vitesse de décodage est estimée entre 50 % et 75 % de la bande passante effective du matériel divisée par la taille des poids actifs, avec des facteurs d'efficacité plus bas pour le matériel hors CUDA, comme les GPU AMD et les puces Apple.

Exemple

Pour qwen3-32b en Q4_K_M avec un cache KV en Q8, les poids occupent 32×0,55=17,632 \times 0{,}55 = 17{,}6 Go et le cache 131,072 Ko par token. Sur une RTX 4090 de 24 Go, après 2 Go de surcoût et une réserve de 0,5 Go, environ 29 754 tokens de contexte tiennent en mémoire : un objectif de 32 768 tokens n'est donc pas atteint. La vitesse de décodage estimée est de 28,6 à 43,0 tokens par seconde.

Prenons maintenant llama3.3-70b en Q4_K_M sur un M4 Max doté de 128 Go de mémoire unifiée. Les poids demandent 70×0,55=38,570 \times 0{,}55 = 38{,}5 Go et le cache Q8 163,84 Ko par token ; un contexte de 32 768 tokens nécessite donc environ 45,9 Go au total, et même le contexte natif complet de 131 072 tokens tient après la réserve de 4 Go. Le goulot d'étranglement, c'est la vitesse : l'estimation n'est que d'environ 5,0 à 7,4 tokens par seconde, car chaque token lit la totalité des 38,5 Go de poids avec une bande passante de 546 Go/s.

Hypothèses et limites

Les estimations ne couvrent que le décodage à flux unique, calibré sur des mesures llama.cpp ; le temps de traitement du prompt n'est pas modélisé. La mémoire est comptée en gigaoctets décimaux, avec un surcoût fixe de 2 Go et une réserve de 0,5 Go sur les GPU dédiés ou de 4 Go sur les machines à mémoire unifiée. Le déchargement sur le CPU et les chargements partiels ne sont pas pris en compte. Les listes de modèles et de matériel sont des catalogues figés, et les vitesses réelles varient selon les pilotes et les réglages.

Questions fréquentes

De combien de VRAM ai-je besoin pour faire tourner un LLM en local ?

En gros, de la taille des poids quantifiés, plus le cache KV pour votre longueur de contexte, plus un certain surcoût. Une quantification sur 4 bits demande un peu plus d'un demi-gigaoctet par milliard de paramètres pour les seuls poids : un modèle 32B a donc besoin d'environ 18 Go avant même le contexte. Les longs contextes pèsent vite lourd ; vérifiez donc la taille du cache pour la longueur visée avant d'acheter du matériel.

Que signifie Q4_K_M ?

Q4_K_M est un type de quantification GGUF de llama.cpp qui stocke la plupart des poids sur environ 4 bits avec la méthode k-quant, certains tenseurs étant conservés en précision plus élevée. C'est un choix par défaut courant, car il équilibre taille de fichier et qualité de sortie. Q5_K_M et Q6_K conservent plus de détails pour une taille plus grande, tandis que Q8_0 est proche du modèle d'origine en qualité.

Pourquoi la vitesse de génération est-elle limitée par la bande passante mémoire ?

Quand le modèle génère un token à la fois, le matériel doit lire en mémoire tous les poids actifs pour chaque token. Le nombre de tokens par seconde vaut donc à peu près la bande passante mémoire divisée par la taille des poids actifs. C'est pourquoi une quantification plus légère tourne plus vite sur la même machine, et pourquoi la bande passante compte davantage que la puissance de calcul brute pour discuter avec un modèle en local.

Pourquoi les modèles à mélange d'experts demandent-ils beaucoup de mémoire tout en étant rapides ?

Un modèle à mélange d'experts (MoE) doit garder tous ses experts en mémoire, mais chaque token n'en utilise que quelques-uns. Les besoins en mémoire suivent le nombre total de paramètres, tandis que la vitesse de décodage suit le nombre, plus faible, de paramètres actifs. Par exemple, qwen3-30b-a3b a besoin de mémoire pour 30 milliards de paramètres, mais n'en lit qu'environ 3 milliards par token.

Pourquoi mes tokens par seconde mesurés diffèrent-ils de l'estimation ?

L'estimation est une fourchette calibrée sur le décodage à flux unique de llama.cpp : d'autres logiciels, les pilotes, la taille des lots et les limites thermiques font varier les chiffres réels à la hausse comme à la baisse. Le traitement du prompt n'est pas modélisé ; les longs prompts ajoutent donc un temps d'attente avant l'apparition du premier token. Si une partie du modèle est déchargée en RAM système, la vitesse tombe bien en dessous de l'estimation, car le calculateur ne compte que les modèles qui tiennent entièrement en mémoire.

Lien avec vos valeurs

Ajoutez ces paramètres à l'adresse de cette page pour l'ouvrir avec les valeurs déjà remplies, par exemple pour partager un calcul ou pour y renvoyer depuis un assistant IA. Le résultat est calculé dans le navigateur : le HTML de la page montre un exemple avec les valeurs par défaut, et l'outil définit l'attribut data-url-params une fois les valeurs du lien appliquées.

ParamètreValeurSi absent
modeCalcull'une des valeurs : need, hardwareneed par défaut
modelModèlel'une des valeurs : qwen3-8b, qwen3-14b, qwen3-30b-a3b, qwen3-32b, llama3.1-8b, llama3.3-70b, qwen3-235b-a22b, qwen3-480b-a22b, qwen3-4b, gpt-oss-20b, gpt-oss-120b, deepseek-r1-distill-qwen-32b, qwen3-coder-30b-a3b, phi-4, qwen2.5-coder-32b; utilisé avec mode = needqwen3-32b par défaut
quantQuantificationl'une des valeurs : Q4_K_M, Q5_K_M, Q6_K, Q8_0, BF16; utilisé avec mode = needQ4_K_M par défaut
context_tokensContexte (tokens)nombre entier; autorisé : ≥ 0; utilisé avec mode = need131072 par défaut
min_tokens_per_sTok/s minimumnombre; autorisé : ≥ 0; utilisé avec mode = need20 par défaut
hardwareMatériell'une des valeurs : rtx_3090, rtx_4090, rtx_4090_48gb, rtx_5090, tesla_p40, tesla_p100_16gb, tesla_v100_32gb, mi50_32gb, 2x_rtx_3090, m4_pro, m5_pro, m5_max, m4_max, m3_ultra, dgx_spark_gb10, dgx_station_gb300; utilisé avec mode = hardwarertx_4090 par défaut
quantsQuantificationsvaleurs séparées par des virgules : 2,4,4,6; utilisé avec mode = hardwareQ4_K_M,Q8_0 par défaut
target_context_tokensContexte ciblenombre entier; autorisé : ≥ 0; utilisé avec mode = hardware131072 par défaut
kv_cacheCache KVl'une des valeurs : q8, fp16q8 par défaut
yarn_tokensYaRN (facultatif)nombre entier; autorisé : 1–262144facultatif

Exemples

  • ?model=llama3.3-70b&quant=Q5_K_M&context_tokens=32768&kv_cache=fp16&min_tokens_per_s=15
  • ?hardware=m4_max&quants=Q4_K_M,Q6_K&target_context_tokens=65536

Écrivez les décimales avec un point. Encodez un espace en %20, + en %2B, # en %23 et & en %26.

Éléments de résultat: [data-result-block="llm-hardware"]