Un CPU peut exécuter de nombreux modèles quantifiés, tandis qu’un GPU accélère généralement fortement l’inférence grâce à sa bande passante et son parallélisme. Mais la vitesse réelle dépend du modèle, de la quantification, de la mémoire disponible, du contexte et de la part effectivement chargée sur l’accélérateur.
Les phases à distinguer
Le chargement du modèle affecte le démarrage à froid. Le traitement du prompt détermine une partie du temps jusqu’au premier token. La génération mesure les tokens de sortie par seconde. Un benchmark qui ne rapporte qu’un débit moyen masque donc l’attente utilisateur et le coût des longs contextes.
La mémoire est la première contrainte
Les poids quantifiés doivent tenir dans RAM ou VRAM avec les buffers et le cache KV. Si une partie est déportée entre CPU et GPU, le transfert peut limiter le gain. Un contexte plus long et plusieurs requêtes augmentent la mémoire dynamique. Surveillez pression mémoire et éventuel swap, qui peut rendre les résultats inutilisables.
Protocole comparable
Utilisez la même version d’Ollama, le même modèle, la même quantification et les mêmes paramètres. Testez prompts courts et longs, sorties de tailles fixes, démarrage froid puis chaud, et plusieurs requêtes simultanées. Mesurez premier token, débit de génération, latence totale, mémoire, énergie si pertinente et erreurs. Répétez et rapportez les percentiles.
Interpréter le choix
Le CPU peut suffire pour développement, faible trafic ou tâches asynchrones. Le GPU devient logique pour interaction, gros modèles ou concurrence, si la VRAM évite les transferts. Comparez le coût total et non le seul achat : utilisation, énergie, disponibilité et maintenance comptent.
FAQ
Un GPU deux fois plus cher est-il deux fois plus rapide ?
Non. Modèle, VRAM, bande passante et moteur déterminent le gain.
Plus de cœurs CPU suffit-il ?
Pas toujours : bande passante mémoire et instructions prises en charge peuvent dominer.
Peut-on comparer des chiffres trouvés en ligne ?
Ils donnent un ordre de grandeur. Décidez seulement après un test sur votre matériel et votre charge.
Benchmark reproductible via l’API Ollama
~~~python import statistics import requests
def run(model, prompt): response = requests.post( "http://localhost:11434/api/generate", json={"model": model, "prompt": prompt, "stream": False}, timeout=180, ) response.raise_for_status() data = response.json() ns = 1_000_000_000 return { "load_s": data["load_duration"] / ns, "prompt_tps": data["prompt_eval_count"] / (data["prompt_eval_duration"] / ns), "generation_tps": data["eval_count"] / (data["eval_duration"] / ns), "total_s": data["total_duration"] / ns, }
runs = [run("gemma3", "Explique le RAG en 200 mots.") for _ in range(6)] warm = runs[1:] print({key: statistics.median(r[key] for r in warm) for key in warm[0]}) ~~~
Séparez le premier chargement des exécutions chaudes. Utilisez exactement modèle, quantification, contexte, prompt et longueur de sortie identiques sur CPU et GPU. Relevez RAM, VRAM, consommation et concurrence en plus des tokens par seconde. Une mesure mono-requête ne prédit pas le débit serveur : répétez avec plusieurs utilisateurs et observez la latence p95. Vérifiez aussi les journaux Ollama pour confirmer que les couches sont réellement déchargées sur le GPU.