Un CPU peut-il exécuter un LLM ?
Oui, les CPU modernes (par exemple Intel Core de 10e génération ou plus récent, AMD Ryzen 5000 ou plus récent, Apple série M) peuvent exécuter des modèles de 3–8B à environ 8–30 tokens par seconde estimés avec une RAM double canal. C'est généralement 5–10× plus lent qu'un GPU dédié, voire davantage, mais cela n'exige aucune VRAM. Un PC avec 8–32 GB de RAM système peut exécuter des modèles qui demanderaient autrement une carte graphique dédiée.
L'inférence sur CPU échange de la vitesse contre de l'accessibilité : aucun pilote GPU à configurer et aucune limite de VRAM, seulement la RAM système. Pour les usages occasionnels (un chatbot pour un seul utilisateur, le traitement de documents hors ligne), le mode CPU seul est praticable.
La vitesse dépend de la bande passante mémoire, pas de la fréquence du processeur : chaque token généré lit une fois tout le fichier du modèle en RAM, donc tokens par seconde ≈ bande passante mémoire ÷ taille du fichier (un plafond ; la vitesse réelle est inférieure). llama.cpp, sur lequel repose Ollama, utilise aussi les instructions vectorielles du CPU comme AVX2 ou ARM NEON lorsque le processeur les prend en charge.
📍 En une phrase
Les CPU modernes peuvent exécuter des LLM de 3B à 8B à environ 8–30 tokens par seconde estimés avec la quantification Q4_K_M et llama.cpp ou Ollama, selon la vitesse de la RAM et la taille du modèle.
💬 En termes simples
Oui. Un portable ou un PC de bureau ordinaire avec assez de RAM peut exécuter localement un petit modèle d'IA sans GPU. Ce sera plus lent qu'avec un GPU, mais assez rapide pour les tâches où vous n'attendez pas la réponse en temps réel.
Quels sont les meilleurs LLM sur CPU seul en 2026 ?
Parmi les cinq modèles comparés ici, Phi-4 Mini (3.8B, Q4_K_M) est le meilleur choix polyvalent sur CPU seul en 2026 : environ 15–25 tok/s estimés avec une RAM double canal, pour un fichier de 2.5 GB. Le tableau classe les cinq modèles par taille de fichier, RAM requise et vitesse estimée. Les vitesses sont les propres estimations de PromptQuorum, dérivées du plafond de bande passante mémoire (DDR4-3200 double canal = 51.2 GB/s, DDR5-5600 = 89.6 GB/s, divisé par la taille du fichier Ollama), pour un PC de bureau double canal de 16 GB ; ce ne sont pas des mesures de laboratoire. Une RAM simple canal divise le résultat par deux. Gemma 4 E2B est l'estimation la moins certaine, car une partie de son fichier de 4.6 GB est constituée de tables d'embeddings ; vérifiez votre propre vitesse avec `ollama run <model> --verbose`.
Modèle | Paramètres | Fichier (Ollama) | RAM min. | tok/s est. | Idéal pour |
|---|---|---|---|---|---|
| Phi-4 Mini | 3.8B | 2.5 GB | 3 GB | 15–25 | Chat général, aide au code |
| Llama 3.2 3B | 3B | 2.0 GB | 2.5–3 GB | 18–30 | Fichier le plus petit, équilibré |
| Gemma 4 E2B | 2.3B eff. / 5.1B total | 4.6 GB | 5–6 GB | 8–14 | Contexte 128K, entrée image |
| Qwen3 8B | 8B | 5.2 GB | 6 GB | 8–15 | Meilleure qualité, 16 GB de RAM |
| DeepSeek-R1 7B | 7B (distillé Qwen) | 4.7 GB | 6 GB | 8–14 | Raisonnement, maths |
Quelle est la différence de vitesse entre CPU et GPU ?
L'inférence sur CPU est généralement 5–10× plus lente qu'avec un GPU dédié, voire davantage, car le GPU a une bande passante mémoire 7–20× supérieure : la DDR4-3200 double canal offre 51.2 GB/s, une RTX 3060 12 GB 360 GB/s et une RTX 4090 1 008 GB/s. Le tableau applique la règle de la bande passante (plafond = bande passante ÷ taille du fichier) au fichier Phi-4 Mini de 2.5 GB. Les plafonds sont des limites hautes ; les vitesses estimées sont des approximations PromptQuorum (environ 75–100 % du plafond sur une installation saine), pas des mesures de laboratoire. Les bandes passantes des GPU proviennent des spécifications publiées par NVIDIA. Apple Silicon ne figure pas dans le tableau, car Ollama utilise le GPU par défaut sur un Mac : la règle du CPU seul ne s'y applique pas de la même façon.
Matériel | Bande passante | Modèle | Plafond tok/s | tok/s est. |
|---|---|---|---|---|
| PC de bureau DDR4-3200 double canal (CPU) | 51.2 GB/s | Phi-4 Mini 2.5 GB | ~20 | 15–20 |
| PC de bureau DDR5-5600 double canal (CPU) | 89.6 GB/s | Phi-4 Mini 2.5 GB | ~36 | 25–32 |
| Portable DDR4-3200 simple canal (CPU) | 25.6 GB/s | Phi-4 Mini 2.5 GB | ~10 | 7–10 |
| RTX 3060 12 GB (GPU) | 360 GB/s | Phi-4 Mini 2.5 GB | ~144 | Généralement 5–10× le CPU |
| RTX 4090 24 GB (GPU) | 1 008 GB/s | Phi-4 Mini 2.5 GB | ~403 | Jusqu'à ~20× le plafond DDR4 |
De combien de RAM chaque modèle CPU seul a-t-il besoin ?
Règle pratique : taille du fichier du modèle + environ 500 MB de surcharge = RAM minimale, plus davantage pour un long contexte. Un fichier de 2.0 GB demande environ 2.5–3 GB de RAM système libre. Les tailles de fichier sont celles des téléchargements Ollama vérifiés sur ollama.com ; les longueurs de contexte sont les maximums indiqués par Ollama, tandis que le contexte par défaut d'Ollama est de 4096 tokens, sauf si vous définissez `OLLAMA_CONTEXT_LENGTH` :
Modèle | Fichier (Ollama) | RAM min. | Confortable | Longueur de contexte |
|---|---|---|---|---|
| Llama 3.2 3B | 2.0 GB | 2.5–3 GB | 6 GB | 128K |
| Phi-4 Mini 3.8B | 2.5 GB | 3 GB | 6 GB | 128K |
| Gemma 4 E2B | 4.6 GB | 5–6 GB | 8 GB | 128K |
| DeepSeek-R1 7B | 4.7 GB | 6 GB | 8 GB | 128K |
| Qwen3 8B | 5.2 GB | 6 GB | 8–16 GB | 40K |
Comment activer l'inférence sur CPU seul ?
Ollama (le plus simple) : lancez `ollama run phi4-mini`. Ollama utilise le CPU lorsqu'il ne trouve aucun GPU pris en charge. Pour forcer le CPU sur une machine équipée d'un GPU, définissez `CUDA_VISIBLE_DEVICES=-1` (NVIDIA) ou `OLLAMA_VULKAN=0` (GPU Vulkan, y compris certains GPU intégrés) avant de démarrer Ollama, puis vérifiez la colonne PROCESSOR de `ollama ps`. LM Studio : réglez le curseur GPU offload sur 0 couche au chargement du modèle. llama.cpp : utilisez `--n-gpu-layers 0` pour désactiver le déchargement sur GPU.
ollama run phi4-mini
# in a second terminal, while the model is loaded:
ollama ps # PROCESSOR column should read 100% CPUComment maximiser la vitesse d'inférence sur CPU ?
La bande passante mémoire et la taille du fichier déterminent la vitesse sur CPU : une RAM double canal et un fichier Q4_K_M apportent donc les plus grands gains. Conseils précis :
- Remplissez les deux canaux mémoire — deux barrettes de RAM identiques doublent la bande passante mémoire de crête par rapport à une seule barrette, soit le gain de vitesse le plus important sur un PC à CPU seul.
- Utilisez la quantification Q4_K_M — le fichier est environ 70 % plus petit qu'en FP16 pour une légère perte de qualité, et comme le décodage sur CPU est limité par la bande passante, un fichier plus petit génère plus vite dans à peu près la même proportion.
- Réduisez la fenêtre de contexte — un contexte plus long agrandit le cache KV et ralentit le traitement du prompt. Définissez `OLLAMA_CONTEXT_LENGTH=2048` (la valeur par défaut d'Ollama est 4096) ou `/set parameter num_ctx 2048` dans `ollama run`.
- Quantifiez le cache KV — `OLLAMA_FLASH_ATTENTION=1` avec `OLLAMA_KV_CACHE_TYPE=q8_0` réduit à peu près de moitié la mémoire du cache KV par rapport à la valeur par défaut f16, ce qui aide surtout sur les machines de 8 GB.
- Gardez le modèle chargé — Ollama décharge un modèle après 5 minutes par défaut. `OLLAMA_KEEP_ALIVE=30m` évite de recharger le fichier à chaque session.
- Vérifiez le nombre de threads — Ollama choisit les threads automatiquement ; dans llama.cpp, réglez `-t` sur votre nombre de cœurs physiques. Fermez les applications gourmandes en mémoire pour que le modèle ne bascule pas en swap.
Quand choisir le CPU plutôt que le GPU ?
Cas d'usage | CPU | GPU |
|---|---|---|
| Chat en temps réel (latence < 1 s) | ⚠️ Utilisable à 15+ tok/s (est.) ; plus lent en simple canal | ✅ Généralement 5–10× plus rapide |
| Traitement par lots (documents, logs) | ✅ Convient (la vitesse compte moins) | ⚠️ Surdimensionné |
| API de production (budget limité) | ✅ Utilise le matériel existant | ⚠️ Coût et consommation d'un GPU en plus |
| Appareil edge (Raspberry Pi) | ✅ Souvent la seule option | ❌ Options GPU limitées |
| Développement / tests locaux | ✅ Consomme moins, plus silencieux | ⚠️ Surdimensionné |
| Fine-tuning de LLM | ❌ Impraticable (bien plus lent) | ✅ Bien plus rapide |
Questions fréquentes sur les LLM sur CPU seul
Quelle est la vitesse de l'inférence sur CPU seul par rapport à un GPU ?
Pour Phi-4 Mini (fichier de 2.5 GB), le plafond du CPU est d'environ 20 tok/s avec de la DDR4-3200 double canal (51.2 GB/s) et d'environ 36 tok/s avec de la DDR5-5600 double canal (89.6 GB/s) ; l'estimation de PromptQuorum est de 15–25 tok/s en pratique. Un GPU dédié a une bande passante mémoire bien supérieure (RTX 3060 : 360 GB/s, RTX 4090 : 1 008 GB/s) ; il est donc généralement 5–10× plus rapide, voire plus. Ce sont des estimations, pas des mesures de laboratoire.
Quel est le plus petit modèle qui produit encore des réponses cohérentes sur CPU ?
La qualité chute vite en dessous d'environ 2B de paramètres. Llama 3.2 3B (fichier de 2.0 GB) et Phi-4 Mini (3.8B, 2.5 GB) sont les choix les plus petits de ce guide et offrent un chat utilisable avec 8 GB de RAM. Pour des fichiers encore plus petits, consultez le guide des LLM locaux les plus rapides pour PC bas de gamme.
Puis-je exécuter un modèle 13B sur CPU ?
Oui, mais c'est lent. Un modèle 13B en Q4_K_M représente un fichier d'environ 8 GB et demande 12 GB ou plus de RAM système. Le plafond de bande passante est d'environ 6 tok/s avec de la DDR4-3200 double canal (51.2 ÷ 8) et d'environ 11 tok/s avec de la DDR5-5600, et la vitesse réelle est inférieure. Cela convient au traitement par lots plutôt qu'au chat en direct.
L'inférence sur CPU utilise-t-elle le GPU ?
Pas si vous le désactivez. Avec `CUDA_VISIBLE_DEVICES=-1` (NVIDIA), `OLLAMA_VULKAN=0` (GPU Vulkan) ou llama.cpp `--n-gpu-layers 0`, l'inférence s'exécute uniquement sur le CPU et la RAM système. Vérifiez la colonne PROCESSOR de `ollama ps` pour le confirmer.
L'inférence sur CPU seul est-elle stable ?
Elle évite les pannes propres aux GPU, comme les plantages de pilote et les erreurs de mémoire GPU saturée. Le principal risque restant est le manque de RAM système, qui pousse le modèle vers le swap et ralentit fortement la génération ; vous le maîtrisez par le choix du modèle et la longueur du contexte.
Dois-je ajuster les paramètres pour les CPU Apple Silicon ?
En général non. Ollama utilise le GPU Apple via Metal par défaut, ainsi que la mémoire unifiée de la puce ; un Mac n'est donc pas un cas de CPU seul. La bande passante mémoire varie selon la puce, et la même règle s'applique : tokens par seconde ≈ bande passante mémoire ÷ taille du fichier du modèle.
De combien de VRAM un modèle 7B a-t-il besoin en mode CPU seul ?
Aucune VRAM dédiée. Un modèle 7B en Q4_K_M (le fichier Ollama deepseek-r1:7b fait 4.7 GB) demande environ 6 GB de RAM système pour fonctionner confortablement. C'est l'avantage central de l'inférence sur CPU seul : ni GPU ni VRAM requis.
Puis-je faire du fine-tuning d'un LLM sur CPU ?
Techniquement oui, mais c'est impraticable : l'entraînement est bien plus lent sur un CPU que sur un GPU. Utilisez le mode CPU seul pour l'inférence et passez à un GPU pour tout fine-tuning ou entraînement.
Puis-je exécuter plusieurs modèles en même temps sur CPU ?
C'est techniquement possible si la RAM le permet, mais peu pratique. Les modèles chargés ensemble se disputent la même bande passante mémoire, donc chacun génère plus lentement. Exécutez un seul modèle à la fois pour la meilleure vitesse, et consultez `OLLAMA_NUM_PARALLEL` et `OLLAMA_KEEP_ALIVE` dans la FAQ d'Ollama si vous servez plusieurs requêtes.
Quels sont les risques de sécurité de l'inférence sur CPU seul ?
L'exécution locale signifie que vos prompts n'ont pas à quitter votre machine, ce qui supprime le risque de transmission d'une API cloud. Les risques restants sont ceux de tout logiciel local : gardez le système d'exploitation à jour et la machine physiquement sécurisée, car des données sensibles peuvent toujours se trouver non chiffrées sur le disque.
Y a-t-il une différence de vitesse entre Ollama et llama.cpp sur CPU ?
PromptQuorum ne l'a pas mesurée. Ollama repose sur llama.cpp, donc les deux s'appuient sur le même type d'optimisations CPU, et tout écart vient surtout de la gestion des threads et des réglages par défaut. Commencez avec les réglages par défaut d'Ollama et utilisez llama.cpp si vous avez besoin d'options plus fines comme `-t`. Comparez les deux sur votre propre machine avec `ollama run <model> --verbose`.
L'inférence sur CPU seul est-elle praticable sur un vieux portable avec 8–10 GB de RAM ?
Oui, avec un petit modèle. Llama 3.2 3B (2.0 GB) ou Phi-4 Mini (2.5 GB) tiennent dans 8–10 GB de RAM. Sur un portable DDR4-3200 simple canal, le plafond est d'environ 10 tok/s pour Phi-4 Mini ; attendez-vous donc à environ 5–10 tok/s estimés : suffisant pour un chatbot léger ou du traitement par lots, lent pour un échange rapide en chat.
Les CPU peuvent-ils exécuter des LLM ?
Oui. Les CPU modernes (par exemple Intel Core de 10e génération ou plus récent, AMD Ryzen 5000 ou plus récent) peuvent exécuter des modèles de 3–8B à environ 8–30 tok/s estimés avec une RAM double canal, selon la taille du modèle. C'est généralement 5–10× plus lent qu'un GPU dédié, voire davantage, mais cela n'exige aucune VRAM dédiée.
Quel est le meilleur LLM sur CPU seul ?
Parmi les modèles comparés ici, Phi-4 Mini (3.8B, fichier de 2.5 GB) est le meilleur choix polyvalent, à environ 15–25 tok/s estimés. Pour le fichier le plus petit, Llama 3.2 3B (2.0 GB, est. 18–30 tok/s). Pour la qualité avec 16 GB de RAM, Qwen3 8B (5.2 GB, est. 8–15 tok/s). Gemma 4 E2B représente un téléchargement de 4.6 GB : ce n'est donc pas le choix de la vitesse.
De combien de RAM ai-je besoin pour l'inférence sur CPU seul ?
Appliquez la règle : taille du fichier du modèle + environ 500 MB de surcharge, plus davantage pour un long contexte. Phi-4 Mini (2.5 GB) demande environ 3 GB, Llama 3.2 3B (2.0 GB) environ 2.5–3 GB, Gemma 4 E2B (4.6 GB) environ 5–6 GB et Qwen3 8B (5.2 GB) environ 6 GB.
Comment activer le mode CPU seul ?
Dans Ollama, lancez `ollama run phi4-mini` ; il utilise le CPU lorsqu'aucun GPU pris en charge n'est trouvé. Pour forcer le CPU sur une machine équipée d'un GPU, définissez `CUDA_VISIBLE_DEVICES=-1` ou `OLLAMA_VULKAN=0`. Dans llama.cpp, utilisez `--n-gpu-layers 0`. Dans LM Studio, réglez le GPU offload sur 0 couche. Confirmez avec `ollama ps`.
L'inférence sur CPU est-elle praticable en production ?
Oui, si vous n'avez pas besoin d'une latence en temps réel. Le traitement par lots, les API asynchrones et les workflows hors ligne fonctionnent sur un CPU. Un CPU sert un utilisateur à faible vitesse ; pour un chat interactif à latence inférieure à 1 seconde ou pour de nombreux utilisateurs simultanés, utilisez un GPU.
Quels modèles CPU seul gèrent le mieux un long contexte ?
Sur Ollama, Gemma 4 E2B, Phi-4 Mini, Llama 3.2 3B et DeepSeek-R1 7B indiquent une fenêtre de contexte de 128K et Qwen3 8B de 40K. Le contexte par défaut d'Ollama n'est que de 4096 tokens, sauf si vous définissez `OLLAMA_CONTEXT_LENGTH`. Un long contexte n'est pas gratuit sur un CPU : le traitement du prompt croît avec le nombre de tokens chargés et le cache KV grossit, si bien qu'une très grande fenêtre peut mettre plusieurs minutes à se remplir avant l'apparition du premier token. Si vous n'avez pas besoin de toute la fenêtre, limitez-la avec `OLLAMA_CONTEXT_LENGTH` et les réponses reviendront sensiblement plus vite.
Étapes suivantes
- LLM locaux les plus rapides pour PC bas de gamme — PC ancien ou limité ? Vitesses estimées selon la RAM →
- Quantification des LLM expliquée — Pourquoi Q4_K_M compte pour la vitesse sur CPU →
- Meilleurs LLM locaux pour le code — Modèles de code légers qui tournent sur CPU →
Pourquoi les LLM sur CPU seul comptent pour les déploiements sensibles à la confidentialité
UE / RGPD : lorsqu'un modèle s'exécute hors ligne sur votre propre CPU, les prompts et les documents n'ont pas à quitter l'appareil, ce qui, pour de nombreuses petites équipes, est un moyen techniquement simple d'éviter les questions de transfert vers des pays tiers au titre de l'art. 44 du RGPD. L'application du RGPD, du règlement européen sur l'IA ou d'autres obligations dépend de qui déploie le système et dans quel but ; ce guide ne constitue pas un avis juridique, et la conformité globale dépend de l'ensemble de votre configuration, pas seulement de l'architecture d'inférence.
Environnements hors ligne et à faible connectivité : les modèles CPU fonctionnent sans connexion internet fiable. Un fichier de modèle comme Phi-4 Mini, téléchargé une seule fois, peut s'exécuter sans autre accès réseau, ce qui aide dans les régions où la connexion est instable ou la bande passante limitée.
Quelles sont les erreurs courantes d'inférence sur CPU ?
- Utiliser du FP16 au lieu de Q4_K_M. Un fichier Phi-4 Mini en FP16 fait environ 7.6 GB contre 2.5 GB en Q4_K_M ; le plafond de bande passante tombe donc d'environ 20 à environ 7 tok/s avec de la DDR4-3200 double canal. Utilisez des modèles GGUF quantifiés pour l'inférence sur CPU.
- Oublier de forcer le CPU seul dans llama.cpp. Sans options explicites, une version avec GPU peut décharger des couches. Définissez `--n-gpu-layers 0` pour un mode CPU pur.
- N'utiliser qu'une seule barrette de RAM. Un seul canal mémoire divise par deux la bande passante de crête, donc le même modèle génère à peu près deux fois moins vite. Installez deux barrettes identiques avant d'acheter un CPU plus rapide.
- Choisir un modèle trop gros. Phi-4 Mini (2.5 GB, plafond d'environ 20 tok/s avec de la DDR4-3200 double canal) est bien plus confortable à l'usage interactif que DeepSeek-R1 7B (4.7 GB, plafond d'environ 11 tok/s). Adaptez la taille du modèle à la bande passante mémoire, pas seulement à la RAM libre.
- Utiliser le mauvais tag Ollama. `ollama run phi` charge Phi-2, pas Phi-4 Mini. Utilisez `ollama run phi4-mini` et consultez ollama.com/library pour les tags exacts des modèles.
Sources
- llama.cpp sur GitHub — inférence CPU, options de threads et de déchargement GPU
- FAQ Ollama — longueur de contexte, type de cache KV, keep-alive et répartition CPU/GPU dans ollama ps
- Documentation GPU d'Ollama — forcer le CPU seul, OLLAMA_VULKAN et GPU pris en charge
- Bibliothèque Ollama : phi4-mini — 2.5 GB, contexte 128K
- Bibliothèque Ollama : llama3.2 — fichier 3B de 2.0 GB, contexte 128K
- Bibliothèque Ollama : gemma4 — téléchargement e2b de 4.6–7.5 GB, contexte 128K, 2.3B de paramètres effectifs / 5.1B au total
- Bibliothèque Ollama : qwen3 — fichier 8B de 5.2 GB, contexte 40K
- Bibliothèque Ollama : deepseek-r1 — fichier 7B de 4.7 GB, distillé de Qwen2.5
- Fiche du modèle Microsoft Phi-4-mini-instruct — Hugging Face
- Spécifications NVIDIA GeForce RTX 3060 — bande passante mémoire
- Spécifications NVIDIA GeForce RTX 4090 — bande passante mémoire
- Résumé de Gemma 4 E2B — llm-stats (source tierce)