Aller à l'outil
JoeLucky

Cliquez sur ★ pour enregistrer un outil

Catégories d'outils

Encodeur/décodeur Base64Visionneuse d'arbre JSONPOPULAIREDécodeur JWTGénérateur d'UUIDEncodeur/décodeur d'URLJSON en CSVCSV en JSONJSON en YAMLYAML en JSONJSON en XMLXML en JSONCSV en YAMLYAML en CSVFormateur JSONFormateur YAMLFormateur XMLFormateur HTMLFormateur CSSTesteur de regexGénérateur de hashAnalyseur CronEncodeur/décodeur d'entités HTMLConvertisseur de basesAnalyseur d'URLVisionneuse et validateur CSVAperçu MarkdownFormateur SQLÉditeur Mermaid en directCalculateur de coût d'API LLMNOUVEAUCalculateur de VRAM pour LLMNOUVEAUVisualiseur de chunks RAGNOUVEAUCoût de stockage cloud (S3, R2, B2)NOUVEAUCalculateur de disponibilité SLANOUVEAU
JoeLucky

Des outils en ligne pratiques, tous au même endroit

Politique de confidentialitéConditions d'utilisation

© 2026 JoeLucky®. Tous droits réservés.

  1. JoeLucky
  2. /Développeur
  3. /Calculateur de VRAM pour LLM

Calculateur de VRAM pour LLM

Estimez la VRAM nécessaire à un LLM et vérifiez s’il tient sur votre GPU.

Signaler

DÉVELOPPEUR SIMILAIRES

Tout voir
Calculateur de coût d'API LLM

Comparez les coûts d’API par requête et par mois pour OpenAI, Anthropic et Gemini, avec la date de vérification.

Ouvrir →
Visualiseur de chunks RAG

Collez un document pour voir le découpage RAG et le coût d’embedding en direct. Rien n’est envoyé.

Ouvrir →
Convertisseur d'unités

Convertissez entre des unités de 12 catégories : longueur, poids, température, surface, volume, etc.

Ouvrir →

💬 Commentaires

?

Aucun commentaire pour le moment. Soyez le premier !

QU'EST-CE QUE Calculateur de VRAM pour LLM ?

Le calculateur de VRAM LLM estime la mémoire dont vous avez besoin pour EXÉCUTER un grand modèle de langage en local ou en auto-hébergement. Total ≈ poids + cache KV + surcoût d'exécution, où poids = paramètres × bits par poids ÷ 8 et cache KV = 2 × couches × têtes KV × dimension de tête × octets par élément × contexte × séquences simultanées. Choisissez un modèle, une quantification et un appareil, et il indique si cela tient, la marge, le contexte le plus long possible et un plafond de vitesse de génération.

Comment l'utiliser ?

  1. Choisissez un modèle (ou saisissez des paramètres, couches, têtes KV et dimension personnalisés) et une quantification des poids.
  2. Définissez la précision du cache KV, la longueur de contexte et le nombre de séquences simultanées.
  3. Choisissez la capacité et le type d'appareil (GPU dédié, mémoire unifiée Apple) et, au besoin, le nombre d'appareils et la bande passante mémoire.
  4. Lisez si cela tient, la répartition de la mémoire, le contexte le plus long et le tableau comparatif par quantification.

Remarques

  • Exemple : Llama 3.1 8B en Q4_K_M avec un contexte de 8 192 tokens et une séquence nécessite environ 4,6 GiB de poids et environ 1 GiB de cache KV, soit environ 7 GiB avec le surcoût par défaut.
  • Les caractéristiques des modèles proviennent des fichiers config.json de Hugging Face et des métadonnées safetensors ; les largeurs de bits de quantification sont des mesures llama.cpp sur Llama-3.1-8B et diffèrent légèrement pour d'autres modèles.
  • Il estime la mémoire pour l'inférence uniquement, pas pour l'entraînement ni le fine-tuning ; l'usage réel varie selon le moteur, le batching et la version de CUDA, gardez donc une marge.
  • Tout est calculé dans votre navigateur.

Questions fréquentes

De combien de VRAM ai-je besoin pour exécuter un LLM ?

Total ≈ poids + cache KV + surcharge d'exécution. Poids = paramètres × bits par poids ÷ 8 ; par exemple, un modèle de 8 milliards de paramètres demande environ 15 Gio en FP16 (16 bits) et environ 4,6 Gio en Q4_K_M (environ 4,9 bits). Le cache KV croît avec la longueur du contexte et le nombre de séquences simultanées ; réglez donc les deux.

Qu'est-ce que le cache KV et pourquoi un contexte plus long consomme-t-il plus de mémoire ?

Pour chaque jeton traité, le modèle conserve les Key et Value de chaque couche afin de ne pas les recalculer pendant la génération. Taille = 2 × couches × têtes KV × dimension de tête × octets par élément × longueur de contexte × séquences ; elle est donc proportionnelle à la longueur du contexte. Les modèles à attention par requêtes groupées (moins de têtes KV) ou à fenêtres glissantes en demandent beaucoup moins.

Quelle quantification choisir ? Qu'est-ce qui distingue Q4, Q5 et Q8 ?

Moins de bits rendent les poids plus petits et généralement plus rapides, au prix de la qualité. Q8_0 est proche de l'original, Q5_K_M et Q6_K sont des compromis courants, Q4_K_M est le point de départ habituel quand la mémoire est juste, et la perte de qualité devient sensible en dessous de Q3. Le tableau montre si chaque niveau tient avec vos réglages actuels.

Comment la mémoire est-elle comptée pour les modèles MoE (mixture of experts) ?

Tous les experts doivent être chargés ; les poids utilisent donc le total des paramètres, et non les paramètres actifs pour chaque jeton. La vitesse de génération, en revanche, dépend des paramètres ACTIFS, ce qui explique pourquoi les modèles MoE utilisent souvent beaucoup de mémoire sans être particulièrement lents.

Le modèle peut-il utiliser toute la mémoire unifiée d'un Mac Apple Silicon ?

En général non. Par défaut, le système ne laisse le GPU utiliser qu'une partie de la mémoire unifiée (environ deux tiers à trois quarts) ; choisir « Mémoire unifiée Apple » considère donc 75 % comme utilisable. Choisissez « Part utilisable personnalisée » pour correspondre à votre réglage réel.

Comment plusieurs GPU sont-ils gérés ?

Les poids et le cache KV sont supposés répartis à parts égales entre les cartes, et chaque carte supporte sa propre surcharge d'exécution fixe, de sorte que le total est légèrement supérieur à celui d'une seule carte. La répartition réelle (parallélisme tensoriel ou en pipeline) et la surcharge de communication dépendent du moteur ; gardez donc une marge supplémentaire.

Quelle est la précision ? Cela couvre-t-il l'entraînement ou le fine-tuning ?

C'est une estimation de planification pour l'INFÉRENCE uniquement : poids, cache KV et une surcharge ajustable. L'usage réel varie selon le moteur (vLLM, llama.cpp et autres), le batching, la version de CUDA et les réglages de KV paginé. L'entraînement et le fine-tuning demandent bien plus de mémoire (gradients, état de l'optimiseur, activations) et sortent du cadre de cet outil.

Comment le plafond de vitesse de génération est-il estimé ?

Générer chaque jeton lit une fois les poids actifs ; à une taille de lot de 1, le plafond est donc d'environ « bande passante mémoire ÷ octets de poids lus par jeton ». C'est une limite théorique qui ignore les limites de calcul, les lectures du cache KV et la surcharge logicielle ; la vitesse réelle est donc généralement plus basse. Il n'apparaît qu'après la saisie de la bande passante de votre appareil.

Appareil

Tailles courantes
Type d'appareil
Avancé : surcharge d'exécution
%
Tient — Cette configuration peut être chargée sur cet appareil.
Poids4,58 GiB
Cache KV1,00 GiB
Surcharge d'exécution1,46 GiB
Total7,03 GiB
Nécessaire par appareil7,03 GiB
Utilisable par appareil22,08 GiB
Marge15,05 GiB
Contexte le plus long qui tient sur cet appareil131 456
Nombre maximal de séquences simultanées à ce contexte16
Plafond de vitesse de génération (approx., tokens/s)—

Tous les niveaux de quantification (réglages actuels)

Tous les niveaux de quantification (réglages actuels)
QuantificationbpwPoidsTotalTient ?
FP323229,92 GiB34,91 GiBNon
FP161614,96 GiB18,45 GiBOui
Q8_08.50087,95 GiB10,74 GiBOui
FP887,48 GiB10,23 GiBOui
Q6_K6.56336,14 GiB8,75 GiBOui
Q5_K_M5.70365,33 GiB7,87 GiBOui
Q5_K_S5.57045,21 GiB7,73 GiBOui
Q4_K_M4.89444,58 GiB7,03 GiBOui
Q4_K_S4.66724,36 GiB6,80 GiBOui
Q3_K_L4.29794,02 GiB6,42 GiBOui
Q3_K_M3.9963,74 GiB6,11 GiBOui
Q3_K_S3.64293,41 GiB5,75 GiBOui
Q2_K3.15932,95 GiB5,25 GiBOui

Les spécifications des modèles proviennent des fichiers config.json de Hugging Face et des métadonnées safetensors (vérifiées le 2026-10-20) ; les valeurs de bpw des quantifications sont des mesures llama.cpp sur Llama-3.1-8B et diffèrent légèrement pour d'autres modèles.

Il s'agit d'une estimation de planification de la mémoire nécessaire pour EXÉCUTER (inférer) un modèle, pas pour l'entraîner ou l'affiner. L'usage réel varie selon le moteur (vLLM, llama.cpp, TensorRT-LLM…), le batching et la version de CUDA : gardez de la marge.

Formules et hypothèses
  • Poids = paramètres × bits par poids ÷ 8.
  • Cache KV = 2 × couches × têtes KV × dimension d'une tête × octets par élément × contexte × séquences ; les couches à fenêtre glissante (p. ex. Gemma 2) comptent au plus la longueur de la fenêtre.
  • Surcharge d'exécution = un montant fixe par appareil + une part des poids ; ce sont des règles empiriques que vous pouvez ajuster.
  • Avec plusieurs appareils, poids et cache sont supposés se répartir équitablement et chaque appareil paie la surcharge fixe.
  • Plafond de vitesse = bande passante mémoire ÷ octets de poids lus par token (batch 1, calcul ignoré).