Table des Matières
Un LLM on-premise a besoin d'assez de mémoire GPU pour trois choses : les poids du modèle, un cache clé-valeur (KV) pour chaque requête en cours, et le fonctionnement du moteur. Un modèle de 72 milliards de paramètres en 8 bits occupe environ 73 Go pour ses seuls poids : même un pilote demande une carte de 96 Go ou deux cartes de 48 Go, et plus d'utilisateurs demandent plus de cache.
Points clés
- Les poids occupent environ 2 Go par milliard de paramètres en précision 16 bits, environ la moitié en 8 bits et le quart en 4 bits (Hugging Face).
- Le cache KV augmente avec chaque token gardé en mémoire. Pour Qwen2.5-72B, il représente environ 0,33 Mo par token en 16 bits : une question documentaire de 6 500 tokens demande donc environ 2,1 Go, d'après la configuration du modèle.
- Dimensionnez pour les requêtes en cours, pas pour les utilisateurs inscrits. Quelques centaines d'utilisateurs n'envoient parfois qu'une poignée de requêtes au même instant.
- La vitesse de génération est limitée surtout par la bande passante mémoire, pas par la puissance de calcul (NVIDIA). Les modèles à mélange d'experts n'utilisent qu'une partie de leurs poids pour chaque token et répondent plus vite (Hugging Face).
- Mesurez avec vos propres prompts et votre moteur d'inférence avant de commander le matériel.
Qu'est-ce qui occupe la mémoire GPU quand un LLM tourne ?
Trois éléments se partagent la mémoire du GPU.
Les poids. Ce sont les paramètres du modèle. Charger un modèle de X milliards de paramètres demande environ 2 × X Go en précision bfloat16 (Hugging Face). La quantification en 8 ou 4 bits réduit ce besoin ; notre guide de l'IA souveraine on-premise donne un tableau pour les tailles de modèles courantes.
Le cache KV. Pendant la génération, le modèle conserve les clés et les valeurs calculées pour chaque token précédent, afin de ne pas les recalculer à chaque étape. Ce cache croît linéairement avec le nombre de tokens (Hugging Face). Chaque requête en cours a le sien.
Le surcoût d'exécution. Les activations, le runtime CUDA et les tampons du moteur d'inférence. Dans cet article, nous leur réservons 10 % de la mémoire GPU. C'est une hypothèse ; vérifiez le chiffre réel dans les journaux de votre moteur d'inférence.
La mémoire des poids est fixe une fois le modèle et la précision choisis. La mémoire du cache dépend de l'usage qu'en font vos équipes : c'est pourquoi un dimensionnement fondé sur le seul modèle tombe à côté.
Comment calcule-t-on le cache KV ?
NVIDIA donne la formule : cache KV par token en octets = 2 × nombre de couches × (nombre de têtes × dimension d'une tête) × octets par valeur (NVIDIA). Le facteur 2 compte les clés et les valeurs. Dans l'exemple de NVIDIA, Llama 2 7B en 16 bits demande environ 2 Go de cache pour une seule séquence de 4 096 tokens.
De nombreux modèles récents, dont celui de l'exemple ci-dessous, utilisent l'attention à requêtes groupées (GQA), qui ne stocke qu'un petit nombre de têtes clé-valeur, par exemple 2, 4 ou 8, au lieu d'une par tête de requête, et conserve presque tout le gain mémoire de l'attention multi-requêtes, plus radicale (Hugging Face). Pour ces modèles, utilisez dans la formule le nombre de têtes clé-valeur. Il figure dans le fichier config.json du modèle.
Un exemple chiffré avec Qwen2.5-72B-Instruct, un modèle de 72,7 milliards de paramètres qui cite le français et l'arabe parmi ses langues prises en charge (fiche du modèle). Sa configuration indique 80 couches, 64 têtes d'attention, 8 têtes clé-valeur et une dimension cachée de 8 192, soit 8 192 ÷ 64 = 128 dimensions par tête.
- Par token, en 16 bits : 2 × 80 × 8 × 128 × 2 octets = 327 680 octets, soit environ 0,33 Mo.
- Par question documentaire : un prompt RAG de 6 000 tokens plus une réponse de 500 tokens, la charge que nous avons chiffrée dans notre comparatif de coûts, occupe 6 500 tokens : environ 2,1 Go.
- Par requête longue : à 32 768 tokens, la longueur fixée dans le fichier de configuration, une requête demanderait environ 10,7 Go.
- Pour 20 questions documentaires en cours : environ 42,6 Go, soit plus de la moitié de la taille des poids en 8 bits.
Deux réglages modifient ces chiffres. Stocker le cache en FP8 au lieu de 16 bits divise par deux le nombre d'octets par valeur ; vLLM le permet et indique que le GPU peut alors garder plus de tokens en mémoire (vLLM). Limiter la longueur de contexte maximale et le nombre maximal de séquences simultanées réduit aussi la mémoire utilisée (vLLM).
La langue compte aussi. Un même texte peut produire des nombres de tokens très différents selon la langue, avec des écarts allant jusqu'à 15 fois dans certains cas (Petrov et al., 2023). Passez un échantillon de vos documents en arabe et en français dans le tokenizer du modèle avant de fixer le nombre de tokens par requête.
Combien de requêtes une usine envoie-t-elle en même temps ?
Le nombre de requêtes en cours est égal au débit d'arrivée multiplié par la durée de chaque requête. Pour 300 utilisateurs qui posent 20 questions par jour ouvré, avec 15 % des 6 000 questions de la journée concentrées sur l'heure la plus chargée (hypothèse), la pointe atteint 900 questions par heure, soit 0,25 par seconde. Si chaque réponse prend 25 secondes, environ 6 requêtes sont en cours en moyenne.
Les arrivées ne sont pas régulières : dans l'exemple ci-dessous, nous dimensionnons donc pour 20 requêtes en cours, un peu plus de trois fois la moyenne (hypothèse). Remplacez ces chiffres par les journaux de votre pilote : utilisateurs, questions par jour, tokens par question et heure de pointe.
À quelle vitesse le modèle répondra-t-il ?
Générer chaque token oblige à lire les poids du modèle dans la mémoire du GPU, et NVIDIA décrit l'inférence comme souvent limitée par la bande passante mémoire (« memory-bandwidth bound »), en particulier pour les poids (NVIDIA). Une limite haute approximative pour une requête est la bande passante mémoire divisée par le nombre d'octets de poids lus par token.
Pour un modèle dense de 72,7 milliards de paramètres en 8 bits, soit environ 73 Go, sur une carte offrant 1 597 Go/s de bande passante, cela donne au mieux environ 22 tokens par seconde pour une requête seule, soit environ 23 secondes pour une réponse de 500 tokens. Les moteurs d'inférence regroupent les requêtes par lots afin que le coût de chargement des poids soit partagé entre de nombreuses requêtes (NVIDIA). Le débit total augmente ; la vitesse d'une réponse isolée reste sous cette limite.
Les modèles à mélange d'experts (MoE) changent l'équation. Tous leurs paramètres doivent résider en mémoire, mais seule une partie sert pour chaque token (Hugging Face). Le modèle gpt-oss-120b d'OpenAI compte 117 milliards de paramètres dont 5,1 milliards actifs, et tient sur un seul GPU de 80 Go (fiche du modèle). Sur une carte RTX PRO 6000 Blackwell, Hardware Corner a mesuré 148 tokens par seconde en génération avec un contexte de 12 000 tokens et 62 Go de mémoire utilisée, avec llama.cpp et un seul utilisateur.
Quels GPU de datacenter pour quels modèles ?
Les caractéristiques proviennent des pages produit de NVIDIA, vérifiées en novembre 2026. La dernière colonne est notre calcul pour un modèle d'environ 72 milliards de paramètres en 8 bits, en utilisant 90 % de la mémoire.
| GPU | Mémoire | Bande passante | Puissance max. | Liaison entre GPU | Modèle 72B en 8 bits |
|---|---|---|---|---|---|
| L40S | 48 Go GDDR6 | 864 Go/s | 350 W | Pas de NVLink ; PCIe Gen4 | Demande 2 cartes ; environ 14 Go pour le cache |
| H100 SXM | 80 Go | 3,35 To/s | Jusqu'à 700 W | NVLink 900 Go/s | Ne tient pas sur 1 carte |
| H100 NVL | 94 Go | 3,9 To/s | 350 à 400 W | NVLink 600 Go/s | Tient ; environ 12 Go pour le cache |
| RTX PRO 6000 Blackwell Server Edition | 96 Go GDDR7 | 1 597 Go/s | Jusqu'à 600 W | PCIe Gen5 ; NVLink non mentionné | Tient ; environ 14 Go pour le cache |
| H200 NVL | 141 Go | 4,8 To/s | Jusqu'à 600 W | Pont NVLink à 2 ou 4 voies, 900 Go/s | Tient ; environ 54 Go pour le cache |
NVIDIA présente les chiffres du H200 comme préliminaires. Les prix changent souvent ; notre comparatif de coûts donne des chiffres sourcés pour une configuration.
Quand faut-il plus d'un GPU ?
La documentation de vLLM fixe l'ordre : si le modèle tient sur un seul GPU, l'inférence distribuée est probablement inutile ; s'il tient sur un serveur à plusieurs GPU, utilisez le parallélisme de tenseurs ; au-delà d'un serveur, combinez parallélisme de tenseurs et parallélisme de pipeline (vLLM). Le parallélisme de tenseurs répartit des couches individuelles entre les GPU (NVIDIA) : la liaison entre les cartes compte donc. Pour les serveurs dont les GPU n'ont pas de NVLink, comme le L40S, vLLM recommande plutôt le parallélisme de pipeline, en invoquant un surcoût de communication plus faible.
Un second GPU se justifie aussi pour d'autres raisons que la taille : il apporte de la redondance et de la place pour la partie recherche d'un système RAG, comme le modèle d'embeddings. La RTX PRO 6000 Server Edition prend en charge le MIG, qui divise une carte en jusqu'à quatre instances isolées (NVIDIA).
Exemple chiffré : un assistant documentaire pour 300 utilisateurs
Cible : Qwen2.5-72B, requêtes de 6 500 tokens, 20 requêtes en cours, cache KV en 16 bits, 10 % de la mémoire réservés au surcoût d'exécution. Ici, 1 Go correspond à 10⁹ octets.
| Configuration | Mémoire totale | Utilisable (90 %) | Poids | Reste pour le cache | Requêtes possibles |
|---|---|---|---|---|---|
| 1 × RTX PRO 6000, poids en 8 bits | 96 Go | 86,4 Go | 72,7 Go | 13,7 Go | environ 6 |
| 2 × RTX PRO 6000, poids en 16 bits | 192 Go | 172,8 Go | 145,4 Go | 27,4 Go | environ 12 |
| 2 × RTX PRO 6000, poids en 8 bits | 192 Go | 172,8 Go | 72,7 Go | 100,1 Go | environ 47 |
| 1 × H200 NVL, poids en 8 bits | 141 Go | 126,9 Go | 72,7 Go | 54,2 Go | environ 25 |
Seules les deux dernières atteignent la cible de 20 avec de la marge. La carte unique couvre à peu près la charge moyenne de 6, mais pas les pointes. Les chiffres des poids en 8 bits sont approximatifs, car les formats quantifiés stockent quelques données d'échelle supplémentaires. Hugging Face n'a constaté presque aucune dégradation en 8 bits dans son exemple (Hugging Face), mais testez la qualité sur vos propres questions avant de retenir cette option.
De quoi d'autre le serveur a-t-il besoin ?
- Alimentation et refroidissement. Quatre cartes de jusqu'à 600 W chacune peuvent consommer 2,4 kW avant les processeurs, la mémoire et les ventilateurs. Vérifiez la puissance disponible dans la baie, l'onduleur et la capacité de refroidissement de la salle qui accueillera le serveur avant de commander.
- Stockage. Les fichiers de modèle ont à peu près la taille des poids ; Hardware Corner indique que le fichier gpt-oss-120b qu'il a testé pesait 65 Go. Gardez la version précédente du modèle sur disque pour pouvoir revenir en arrière.
- Un environnement de test. Un GPU plus petit pour essayer les nouvelles versions de modèles et les prompts avant qu'ils n'arrivent aux utilisateurs.
- Architecture réseau. Si le site est isolé, prévoyez comment les modèles et les mises à jour y entrent. Voir notre guide du déploiement d'IA air-gapped.
Comment dimensionner votre propre serveur ?
- Retenez deux ou trois modèles candidats et vérifiez leurs licences et leurs langues.
- Lisez le
config.jsonde chaque modèle et calculez le cache KV par token. - Mesurez les tokens par requête sur un échantillon de vraies questions en arabe, en français et en anglais, avec les passages récupérés. Notre guide RAG pour les manuels de maintenance explique comment les prompts sont construits.
- Estimez les requêtes en cours à partir des utilisateurs attendus, des questions par jour et de l'heure de pointe.
- Additionnez les poids, le cache pour la pointe et le surcoût d'exécution, puis choisissez une configuration GPU avec de la marge.
- Faites un test de charge de la configuration retenue avec votre moteur d'inférence avant de signer la commande.
Si vous hésitez encore entre la recherche documentaire et l'entraînement sur vos documents, lisez d'abord fine-tuning ou RAG pour un assistant industriel, car les deux approches n'ont pas les mêmes besoins matériels.
Ce que nous avons constaté chez KABAS AI
DALILE tourne sur les serveurs du client et répond à des questions à partir de documents, de tableurs et de bases de données : le dimensionnement du matériel fait donc partie de la préparation de chaque déploiement. Les chiffres de cet article sont publics ; ce ne sont pas des mesures faites chez des clients. La leçon pratique de cette méthode est de mesurer avant d'acheter : un échantillon de vraies questions, leur nombre de tokens et la pointe attendue déterminent le serveur davantage que le nom du modèle. Notre équipe de conseil peut faire ce calcul avec vos propres documents et chiffres d'usage.
Sources
Caractéristiques vérifiées en novembre 2026. Elles changent avec les nouvelles versions des produits ; revérifiez-les avant de commander.
- NVIDIA: Mastering LLM Techniques, Inference Optimization
- Hugging Face: Optimizing LLMs for speed and memory
- Hugging Face: Mixture of Experts explained
- Qwen2.5-72B-Instruct, fiche du modèle
- Qwen2.5-72B-Instruct, config.json
- openai/gpt-oss-120b, fiche du modèle
- vLLM: Quantized KV cache
- vLLM: Conserving memory
- vLLM: Parallelism and scaling
- Petrov et al., Language Model Tokenizers Introduce Unfairness Between Languages, 2023
- Hardware Corner: Testing GPT-OSS 120B on RTX Pro 6000 Blackwell
- NVIDIA L40S GPU
- NVIDIA H100 Tensor Core GPU
- NVIDIA RTX PRO 6000 Blackwell Server Edition
- NVIDIA H200 Tensor Core GPU
Questions fréquentes
Combien de mémoire GPU faut-il pour un modèle de 70 milliards de paramètres ?
Pour les poids seuls, environ 140 Go en précision 16 bits, environ 70 Go en 8 bits et environ 35 Go en 4 bits, selon la règle empirique de Hugging Face d'environ 2 Go par milliard de paramètres en bfloat16. Il faut ensuite de la mémoire pour le cache KV de chaque requête en cours et pour le fonctionnement du moteur : un modèle de 70 milliards de paramètres en 8 bits ne tient donc pas de façon utile sur un seul GPU de 80 Go.
Peut-on faire tourner un LLM on-premise sur une carte graphique grand public ou de station de travail ?
Les petits modèles peuvent tourner sur des cartes de 16 à 32 Go ; OpenAI indique que gpt-oss-20b fonctionne avec 16 Go de mémoire. Pour un assistant partagé par de nombreux utilisateurs, regardez plutôt les cartes serveur : les L40S et RTX PRO 6000 Server Edition de NVIDIA, par exemple, disposent de 48 Go et 96 Go de mémoire ECC et sont conçues pour les serveurs en rack. Quelle que soit la carte, testez-la sous la charge attendue.
Vaut-il mieux acheter un gros GPU ou plusieurs petits ?
Si le modèle et son cache tiennent sur un GPU, un seul GPU est plus simple : la documentation de vLLM indique que l'inférence distribuée est alors probablement inutile. Plusieurs GPU permettent de servir des modèles plus grands ou davantage de requêtes simultanées, mais les cartes doivent échanger des données, et vLLM recommande une autre façon de répartir le modèle quand elles n'ont pas de NVLink. Deux cartes apportent aussi une certaine redondance.
La quantification dégrade-t-elle la qualité des réponses ?
Elle le peut. Hugging Face ne constate presque aucune dégradation en 8 bits dans son exemple et précise que les résultats en 4 bits peuvent s'écarter davantage de la pleine précision. Passez votre propre jeu de questions réelles sur la version quantifiée et la version non quantifiée avant de choisir, et vérifiez séparément les réponses en arabe et en français.
Combien d'utilisateurs un serveur GPU peut-il servir ?
Cela dépend du nombre de requêtes en cours au même moment, de la longueur de chaque prompt et du délai de réponse acceptable, pas du nombre d'utilisateurs inscrits. Estimez les requêtes en cours comme le nombre de requêtes par seconde multiplié par la durée d'une réponse en secondes, dimensionnez le cache KV pour ce nombre avec une marge, puis confirmez par un test de charge avec vos propres prompts.



