Ollama : choisir entre q4, q8 et fp16
Choisissez votre quantification Ollama avec des chiffres : comparez la RAM de q4_K_M, q8_0 et fp16, puis mesurez la perte de qualité réelle.
Ce que change la quantification d’Ollama
La quantification d’Ollama stocke chaque poids d’un modèle avec moins de bits que le fichier utilisé pour son entraînement. Une balise qui se termine par q4_K_M conserve environ quatre bits par poids, tandis que fp16 en conserve seize. Le téléchargement représente donc environ un tiers de la taille, et la machine lit environ trois fois moins d’octets pour produire chaque token. Les poids sont arrondis sur une grille plus grossière, mais ne sont pas supprimés. Avec quatre bits, la plupart des modèles répondent presque comme en précision intégrale.
C’est tout le compromis : une empreinte mémoire nettement plus faible et davantage de tokens par seconde, au prix d’une légère perte de précision. La suite explique comment prévoir ces deux aspects pour un modèle donné sur une machine donnée, avant de passer vingt minutes à télécharger un fichier qui ne pourra pas être chargé.
Si Ollama ne fonctionne pas encore, commencez par installer Ollama sur un VPS. Cette page suppose que ollama ls fonctionne déjà.
Lire un tag de quantification Ollama comme q4_K_M
Les modèles locaux sont distribués sous forme de fichiers GGUF, le format utilisé par llama.cpp pour stocker les poids sur disque. Ollama repose sur llama.cpp. Ses tags reprennent donc les noms de quantification de llama.cpp sans les modifier.
Le nombre indique la largeur cible. q4 signifie que la plupart des tenseurs de poids sont encodés sur quatre bits chacun. q8 signifie huit bits. fp16 n’est pas quantifié : il s’agit du modèle en virgule flottante sur seize bits, la précision dans laquelle la plupart des modèles sont publiés.
K indique une K-quant. Les poids sont regroupés en petits blocs. Chaque bloc stocke sa propre échelle à côté des valeurs encodées. Un bloc dont les poids sont tous proches de 0.01 utilise une échelle précise. Un bloc contenant une valeur aberrante élevée utilise une échelle plus grossière. Ces échelles propres à chaque bloc permettent d’utiliser un fichier sur quatre bits. Elles expliquent aussi qu’un fichier sur quatre bits n’utilise jamais exactement quatre bits par poids.
La dernière lettre indique le mélange. S, M et L déterminent le nombre de tenseurs stockés avec une largeur supérieure à la largeur cible. Dans q4_K_M, les tenseurs qui perdent le plus lors de l’arrondi sont stockés sur une largeur supérieure, tandis que la majorité reste sur quatre bits. C’est pourquoi q4_K_M produit de meilleurs résultats que l’ancien q4_0, pour une taille de fichier presque identique.
Demandez à Ollama ce qui est stocké sur le disque au lieu de vous baser sur le nom que vous avez saisi :
ollama pull qwen3:8b-q4_K_M
ollama show qwen3:8b-q4_K_Mollama show affiche architecture, parameters, quantization, context length et embedding length. La ligne quantization fait foi pour un modèle téléchargé il y a plusieurs mois, dont vous ne vous souvenez plus du choix.
Le nombre de bits par poids détermine la taille du fichier
Toute estimation de taille part d’un nombre : le nombre de bits que le format utilise par poids, en moyenne sur l’ensemble du fichier. llama.cpp publie des valeurs mesurées pour Llama 3.1 8B dans sa documentation sur la quantification. Elles s’appliquent également à tout modèle dense de forme similaire.
Les données de ce graphique
[
{
"label": "F16",
"bits_per_weight": 16,
"file_gib": 14.96
},
{
"label": "Q8_0",
"bits_per_weight": 8.5,
"file_gib": 7.95
},
{
"label": "Q6_K",
"bits_per_weight": 6.56,
"file_gib": 6.14
},
{
"label": "Q5_K_M",
"bits_per_weight": 5.7,
"file_gib": 5.33
},
{
"label": "Q4_K_M",
"bits_per_weight": 4.89,
"file_gib": 4.58
},
{
"label": "Q3_K_M",
"bits_per_weight": 3.99,
"file_gib": 3.74
}
]La deuxième colonne de ce tableau est la plus surprenante. Q4_K_M n’utilise pas quatre bits par poids. Il utilise 4.89 bits, car les échelles des blocs et les tenseurs promus occupent eux aussi de l’espace. Q8_0 utilise 8.5 bits au lieu de huit, pour la même raison. Utilisez la valeur mesurée : le calcul obtenu est alors à quelques pour cent près de la taille réelle du fichier :
weight bytes = parameter count x bits per weight / 8
8.03e9 params x 4.89 bits / 8 = 4.91e9 bytes = 4.57 GiBIl s’agit du fichier Q4_K_M de 4.58 GiB, calculé à partir de deux nombres. Cela correspond également, à peu près, à la mémoire occupée par les poids une fois chargés. Ollama ne décompresse rien au chargement : les poids quantifiés restent en mémoire sous la même forme compacte, et chaque bloc est converti au moment de son utilisation.
Ce qu’Ollama fournit réellement pour chaque taille de modèle
La bibliothèque publie une balise q4_K_M, une balise q8_0 et une balise fp16 pour la plupart des familles. Quelques familles plus récentes ne suivent pas ce modèle. Elles apparaissent dans la bibliothèque uniquement avec des balises cloud, sans rien à télécharger quelle que soit la taille. C’est le problème rencontré lorsque vous essayez d’exécuter GLM 5.2 sur un VPS. Voici les tailles de Qwen3 en octobre 2026, relevées dans la liste des balises de la page du modèle. Chaque valeur indique d’abord l’espace disque requis, avant même le chargement en RAM. Deux ou trois modèles suffisent à remplir le volume root d’un petit VPS. Il est donc préférable de savoir où Ollama stocke les modèles téléchargés avant de commencer à accumuler les balises.
Les données de ce graphique
[
{
"label": "Qwen3 4B",
"q4_K_M_gb": 2.6,
"q8_0_gb": 4.4,
"fp16_gb": 8.1
},
{
"label": "Qwen3 8B",
"q4_K_M_gb": 5.2,
"q8_0_gb": 8.9,
"fp16_gb": 16
},
{
"label": "Qwen3 14B",
"q4_K_M_gb": 9.3,
"q8_0_gb": 16,
"fp16_gb": 30
},
{
"label": "Qwen3 32B",
"q4_K_M_gb": 20,
"q8_0_gb": 35,
"fp16_gb": 66
}
]La balise par défaut est importante ici. ollama pull qwen3:8b télécharge exactement les mêmes 5.2 Go que ollama pull qwen3:8b-q4_K_M, car la balise sans suffixe est la version q4_K_M. Q4_K_M n’est pas un compromis proposé à contrecœur par la bibliothèque. C’est la version par défaut choisie en amont. Il est donc logique de commencer par celle-ci pour tout modèle que vous n’avez pas encore testé vous-même. C’est également ce qui guide le choix des balises dans l’exécution de Qwen 3 sur un VPS.
Les ratios restent valables pour chaque ligne. Passer de q4_K_M à q8_0 demande environ 70 % d’espace supplémentaire, et non exactement le double, car les tenseurs d’embedding et de sortie n’évoluent pas comme les autres. fp16 demande environ trois fois plus d’espace que q4_K_M. Un modèle 32B en q4_K_M contient 20 Go de poids. C’est déjà plus que ce qu’un serveur équipé de 16 Go peut contenir avec la moindre fenêtre de contexte. Pour savoir plus largement quels modèles tiennent sur quelle machine, consultez les modèles que vous pouvez auto-héberger.
Pourquoi le cache KV représente un second coût qui dépend du contexte
Les poids représentent un coût fixe. Le cache KV (cache des clés et des valeurs) représente le coût variable. Chaque token de la fenêtre de contexte conserve ses vecteurs de clé et de valeur pour chaque couche. Le cache augmente donc linéairement avec la taille de fenêtre autorisée. Il est alloué pour toute la fenêtre au chargement du modèle, et non au fur et à mesure que la conversation se remplit. C’est pourquoi une longue fenêtre consomme de la mémoire même avec un prompt d’un seul mot.
KV bytes per token = 2 (key and value) x layers x kv_heads x head_dim x bytes_per_element
Qwen3 8B at f16: 2 x 36 x 8 x 128 x 2 = 147456 bytes = 144 KiB per tokenCes valeurs proviennent de la configuration du modèle : 36 couches, 8 têtes de clés/valeurs et une dimension de tête de 128. ollama show fournit l’architecture et le nombre de paramètres, tandis que le config.json du modèle sur Hugging Face fournit le reste. Multipliez le coût par token par la taille de la fenêtre : le cache cesse alors d’être négligeable.
Les données de ce graphique
[
{
"label": "4k",
"kv_cache_gb": 0.6,
"floor_ram_gb": 5.8
},
{
"label": "8k",
"kv_cache_gb": 1.21,
"floor_ram_gb": 6.4
},
{
"label": "16k",
"kv_cache_gb": 2.42,
"floor_ram_gb": 7.6
},
{
"label": "32k",
"kv_cache_gb": 4.83,
"floor_ram_gb": 10
}
]Avec 4096 tokens, la fenêtre par défaut choisie par Ollama lorsque la VRAM est inférieure à 24 GiB (y compris sur un VPS utilisant uniquement le CPU), le cache ajoute 0.6 GB aux poids. Augmentez la fenêtre à 32k : le cache atteint à lui seul 4.83 GB. C’est presque autant de mémoire que les poids quantifiés, et le minimum requis pour le modèle complet passe à 10 GB. Il s’agit d’un minimum, car les buffers de calcul et le système d’exploitation s’y ajoutent. Consultez la valeur réelle dans la colonne SIZE de ollama ps une fois le modèle chargé. Sur un GPU doté de 24 à 48 GiB de VRAM, la fenêtre par défaut est de 32k. À partir de 48 GiB, elle est de 256k. Avec une carte graphique importante, ne partez donc pas du principe que la valeur est de 4k.
La fenêtre est définie sur le serveur, et non par requête, lorsque vous exécutez Ollama comme service :
OLLAMA_CONTEXT_LENGTH=8192 ollama servePour une installation systemd, placez plutôt ce paramètre dans un drop-in :
sudo systemctl edit ollama[Service]
Environment="OLLAMA_CONTEXT_LENGTH=8192"
Environment="OLLAMA_KV_CACHE_TYPE=q8_0"Redémarrez avec sudo systemctl restart ollama, puis vérifiez la colonne CONTEXT de ollama ps pour confirmer la fenêtre avec laquelle le modèle en cours d’exécution a réellement été chargé. OLLAMA_KV_CACHE_TYPE quantifie directement le cache : f16 est la valeur par défaut, q8_0 utilise environ deux fois moins de mémoire que f16, et q4_0 environ quatre fois moins. Il s’agit d’une option globale : tous les modèles de ce serveur utilisent donc le même réglage. La quantification du cache ne prend effet que lorsque Flash Attention est activé. Ollama l’active automatiquement si le backend le prend en charge, et OLLAMA_FLASH_ATTENTION=1 force son activation. Sur une petite machine avec une fenêtre longue, réduire de moitié la taille du cache libère plus de mémoire que toute autre modification isolée. Pour observer ce gain avant de l’adopter, l’article Passer le cache KV de f16 à q8_0 détaille le réglage et la baisse de ollama ps obtenue après le rechargement du modèle. Définir num_ctx et comprendre son coût explique la fenêtre elle-même en détail. Le cache est également dimensionné une fois par slot de requête concurrent, et non une fois par serveur. Autoriser Ollama à traiter deux prompts simultanément double donc la valeur que vous venez de calculer. C’est le principe du calcul présenté dans Choisir le nombre de slots parallèles et la limite de la file d’attente.
Ce qui tient sur un VPS de 8, 16 ou 32 Go
Comptez l’empreinte mémoire des poids, celle du cache KV, puis une marge pour le système d’exploitation et les autres processus. Une marge de 2 Go est confortable sur un petit VPS.
8 Go. Un modèle 4B en q4_K_M occupe 2.6 Go et laisse de la place pour une fenêtre longue. Un modèle 8B en q4_K_M tient avec la fenêtre par défaut de 4k, mais avec très peu de marge. Ne prévoyez pas un modèle 8B avec une fenêtre de 32k ici, car le plancher de 10 Go dépasse déjà la capacité du serveur.
16 Go. Un modèle 8B en q4_K_M avec une fenêtre de 16k ou 32k tient confortablement. Un modèle 14B en q4_K_M représente 9.3 Go de poids et tient avec une fenêtre modeste. Un modèle 8B en q8_0 représente 8.9 Go : il tient donc lui aussi. Comparer ces deux modèles avec vos propres prompts est le meilleur usage que vous puissiez faire d’une heure sur ce sujet.
32 Go. Un modèle 14B en q8_0 (16 Go) et un modèle 32B en q4_K_M (20 Go) se chargent tous les deux. Une version 32B avec une grande fenêtre approchera la limite. Surveillez donc ollama ps au lieu de partir du principe que tout tiendra.
Ce que la quantification dégrade en premier
L’erreur de quantification ne se répartit pas uniformément dans les capacités d’un modèle. La fluidité est la dernière à disparaître. C’est précisément pourquoi les dégâts sont difficiles à détecter : un modèle mal quantifié produit encore des phrases correctes. La précision disparaît en premier. Il s’agit notamment de restituer exactement un numéro de version, une signature d’API ou une date. Les longues chaînes de raisonnement sont aussi touchées : une petite erreur à l’étape deux peut produire une mauvaise réponse à l’étape huit. Les formats de sortie stricts posent également problème : une seule parenthèse incorrecte suffit à faire échouer un appel d’outil.
Ce dernier point constitue le test pratique. Lorsqu’un modèle doit renvoyer du JSON que votre code analyse, les effets de la quantification se manifestent par une erreur d’analyse plutôt que par une prose simplement moins bonne. Vous les voyez donc le jour même. Un agent de programmation est la version la plus exigeante de ce test, car il enchaîne les appels d’outils. pointer un agent vers votre serveur Ollama permet donc de détecter une quantification trop agressive en moins d’une après-midi.
En dessous de quatre bits, la perte devient importante. Les types q3 et deux bits s’adressent aux utilisateurs qui veulent faire tenir un grand modèle sur un matériel limité. Ils constituent une option valable lorsque l’autre possibilité est de ne pas exécuter le modèle du tout. Ils ne doivent pas être le choix par défaut. L’écart entre q4_K_M et q8_0 est suffisamment faible pour qu’un tableau de perplexité publié ne permette pas de trancher selon votre charge de travail. N’essayez donc pas de trancher de cette manière. Testez les deux modèles avec trente de vos propres prompts et examinez les résultats.
Quand q8_0 ou fp16 justifie la RAM
Utilisez q8_0 lorsque la mémoire est réellement disponible et que la tâche tolère mal les petites erreurs : extraction structurée, appels d’outils, code qui doit compiler. Vous achetez alors une marge de sécurité, pas un modèle sensiblement plus intelligent.
Utilisez fp16 pour deux raisons seulement. Soit vous quantifiez vous-même le modèle et avez besoin du fichier source, soit vous mesurez une référence pour déterminer ce que votre build en quatre bits a perdu. Servir le modèle en fp16 consomme trois fois plus de mémoire que q4_K_M, pour une différence que la plupart des utilisateurs ne détectent pas à l’aveugle. Sur une machine équipée uniquement d’un CPU, le débit de tokens tombe également au tiers.
La règle la plus importante, à budget mémoire constant, est la suivante : un modèle plus grand en q4_K_M surpasse généralement un modèle plus petit en q8_0. 9.3 Go de poids pour 14B contre 8.9 Go de poids pour 8B, soit presque la même quantité de RAM (mémoire vive), et le modèle plus grand en sait davantage. Testez cela avec vos propres prompts au lieu de l’accepter sans vérification.
L’inférence sur CPU est limitée par la bande passante mémoire
La plupart des offres VPS n’ont pas de GPU. Le modèle s’exécute donc dans la mémoire système, sur le CPU de l’hôte. La génération est alors limitée par la bande passante mémoire, et non par les calculs, car la production de chaque token nécessite de lire tous les poids une fois. Cela impose un plafond qui n’a rien à voir avec le nombre de cœurs achetés.
tokens per second ceiling = memory bandwidth / bytes read per token
50 GB/s / 5.2 GB = 9.6 tokens/s qwen3 8B q4_K_M
50 GB/s / 8.9 GB = 5.6 tokens/s qwen3 8B q8_0
50 GB/s / 16 GB = 3.1 tokens/s qwen3 8B fp16Cinquante GB/s correspondent approximativement à la valeur théorique d’un hôte équipé de mémoire DDR4-3200 en double canal. Votre part est inférieure, car un VPS partage ce bus avec tous les autres tenants de la machine. Considérez donc ces valeurs comme un plafond que personne n’atteint. La tendance est l’information utile : sur CPU, diviser par deux le nombre de bits par poids double approximativement le débit de tokens. La quantification est le principal levier d’accélération disponible sur une machine sans GPU. Le débit obtenu est acceptable ou non selon le modèle, et Nemotron 3.5 Lightning sur un VPS applique ce calcul à un build précis, avec le tag et la quantité de RAM inclus. L’autre facteur est la longueur de la réponse générée. À dix tokens par seconde, une réponse de six cents tokens prend une minute entière. Limiter la réponse avec num_predict permet donc souvent de réduire davantage le temps d’attente qu’une nouvelle diminution de la précision.
Le traitement du prompt se comporte différemment. La lecture d’un long prompt dépend davantage des calculs que de la bande passante. Des cœurs supplémentaires sont donc utiles à cette étape, mais ils n’améliorent presque pas la vitesse de génération. Une machine qui ingère rapidement un prompt de 4k, puis génère lentement, se comporte normalement.
Ne prenez aucun de ces calculs pour acquis. Mesurez le nombre de tokens par seconde sur votre propre machine avec le même prompt pour chaque quantification, puis laissez vos propres mesures primer sur ces estimations.
Quantifier vous-même un modèle
C’est utile lorsque vous avez effectué un fine-tuning et qu’aucun tag de bibliothèque n’existe. La méthode dépend du format souhaité, car Ollama ne produit plus les K-quants GGUF mesurés sur cette page.
Pour un K-quant tel que q4_K_M, effectuez la quantification avant qu’Ollama ne voie le fichier. Ollama ne quantifie pas les modèles GGUF lors de l’import et refuse --quantize avec une source GGUF. Quantifiez le GGUF non quantifié avec llama-quantize de llama.cpp, puis importez le fichier final. Cette méthode d’import présente un autre problème : une incompatibilité de chat template peut amener le modèle à répondre avec du texte incohérent. La page importer un fichier GGUF dans Ollama explique comment le résoudre. La ligne quantization de ollama show permet de vérifier que le fichier importé correspond bien à la build souhaitée.
Le --quantize propre à Ollama fonctionne uniquement avec les imports safetensors. Pointez un Modelfile vers le répertoire contenant les poids safetensors non quantifiés :
FROM /path/to/safetensors/directoryConstruisez ensuite le modèle :
ollama create --quantize int4 mymodelDans Ollama v0.40.2 (vérifié le 2026-10-11), --quantize accepte int4, int8, nvfp4, mxfp4 et mxfp8. q4 et q8, ainsi que fp4 et fp8, sont considérés comme des alias de int4 et int8. Les noms GGUF tels que q4_K_M, q4_K_S, q8_0, q6_K et q5_K_M sont refusés avec une erreur unsupported quantize type. Ces types ne correspondent pas aux K-quants GGUF présentés dans les tableaux ci-dessus. N’utilisez donc pas les valeurs de bits par poids et de taille de fichier de cette page pour prévoir leurs caractéristiques.
Ce que vous verrez en cas de problème
Tout s’exécute sur le CPU alors que vous vous attendiez à utiliser le GPU. Consultez la colonne PROCESSOR :
ollama psElle affiche 100% GPU, 100% CPU ou une valeur mixte telle que 48%/52% CPU/GPU. Une valeur mixte signifie que les poids et le cache KV ne tenaient pas dans la VRAM (Video RAM, la mémoire de la carte graphique) et qu’une partie du modèle a donc été placée en mémoire système. Les performances chutent alors presque au niveau du CPU seul, car chaque token attend la partie lente. Réduisez la fenêtre de contexte, quantifiez le cache ou utilisez un build plus petit. Ajouter des cœurs ne changera rien.
Le modèle est tué pendant son chargement. Consultez le journal du kernel et celui du service :
sudo dmesg -T | grep -i "out of memory"
sudo journalctl -u ollama -n 50Une ligne contenant Out of memory: Killed process signifie que le total des poids, du cache KV et des buffers a dépassé la mémoire disponible sur la machine. Sur un VPS sans swap configurée, toute la machine peut se bloquer pendant plusieurs secondes avant l’apparition de cette ligne.
Les réponses sont moins bonnes alors que vous n’avez rien modifié. Deux builds du même modèle peuvent coexister dans ollama ls sous des tags différents, et un script qui récupère le nom sans suffixe suivra la cible vers laquelle la bibliothèque pointe désormais. Exécutez ollama show avec le tag exact demandé par votre client et lisez la ligne quantization, au lieu de vous fier au nom indiqué dans votre fichier de configuration.
FAQ
Quelle quantification Ollama dois-je télécharger ?
Commencez par q4_K_M. Il s’agit du tag par défaut fourni par la bibliothèque Ollama pour la plupart des modèles ; ollama pull qwen3:8b et ollama pull qwen3:8b-q4_K_M téléchargent donc le même fichier. Passez à q8_0 uniquement si la mémoire est suffisante et si la tâche tolère mal les petites erreurs, par exemple pour les appels d’outils ou la sortie JSON structurée. Lorsque le budget mémoire est fixe, un modèle plus grand en q4_K_M est généralement plus performant qu’un modèle plus petit en q8_0. Testez donc cette combinaison avant d’utiliser davantage de RAM pour gagner en précision.
q4_K_M signifie-t-il vraiment quatre bits par poids ?
Non. Mesuré sur Llama 3.1 8B, le résultat est de 4.89 bits par poids, car chaque bloc de poids stocke son propre facteur d’échelle et les tenseurs les plus sensibles utilisent un type plus large. Pour la même raison, Q8_0 utilise 8.5 bits, et non huit. Utilisez la valeur mesurée pour vos estimations : le nombre de paramètres multiplié par le nombre de bits par poids, puis divisé par huit, donne la taille du fichier en octets.
De combien de RAM un modèle 8B a-t-il besoin sur un VPS utilisant uniquement le CPU ?
Additionnez les poids, le cache KV et une marge. Qwen3 8B en q4_K_M utilise 5.2 Go pour ses poids. Avec la fenêtre de 4096 tokens par défaut, le cache ajoute 0.6 Go, soit un minimum d’environ 5.8 Go avant de compter les buffers de calcul et le système d’exploitation. Avec une fenêtre de 32k, le cache utilise à lui seul 4.83 Go. Prévoyez 8 Go pour une fenêtre courte et 16 Go pour une fenêtre longue.
Pourquoi mon modèle utilise-t-il 100 % du CPU alors que le serveur possède un GPU ?
Exécutez ollama ps et consultez la colonne PROCESSOR. 100% CPU, ou une répartition telle que 48%/52% CPU/GPU, signifie que les poids et le cache KV ne tenaient pas dans la VRAM. Ollama a donc placé une partie ou la totalité du modèle dans la mémoire système. La cause habituelle est une fenêtre de contexte trop grande pour la capacité de la carte, car le cache est alloué pour l’ensemble de la fenêtre au chargement du modèle. Réduisez la fenêtre avec OLLAMA_CONTEXT_LENGTH, définissez OLLAMA_KV_CACHE_TYPE=q8_0 pour diviser le cache par deux, ou téléchargez une quantification plus petite.