IA locale lente : avant d'acheter une carte graphique, vérifiez ces réglages
Votre IA locale rame ? Le problème vient presque toujours d'un réglage logiciel par défaut, pas du matériel. Voici l'ordre des vérifications à faire.

Quelqu’un investit dans une machine pour faire tourner une IA en local, suit un tutoriel et se retrouve avec un modèle qui répond à moins d’un mot par seconde. Le réflexe, c’est d’incriminer le matériel et de commencer à chiffrer une carte graphique plus puissante. Dans la majorité des cas, ce réflexe est le mauvais. Le vrai coupable, ce sont souvent les réglages par défaut du tutoriel lui-même — et rien ne vous prévient, aucun message d’erreur ne s’affiche.
C’est cet écart entre ce qu’une machine peut faire et ce qu’elle fait réellement qui nous intéresse ici. Un testeur curieux, Alex Ziskind, a fait une série de benchmarks méthodiques sur un mini-PC, en changeant un réglage à la fois, et les résultats parlent plus fort que n’importe quelle fiche technique. Avant de sortir la carte bleue pour du silicium neuf, il existe un ordre précis de vérifications à faire d’abord. Ce n’est d’ailleurs pas la première fois que DecodeStack tombe sur ce schéma : la disparition soudaine de l’accès à un modèle d’IA tenait elle aussi à la couche logicielle, pas au matériel qu’on a sous les yeux.
La machine et le modèle, en deux mots
Le banc d’essai de Ziskind était un Khadas Mind Pro, un mini-PC construit autour de la famille de puces Panther Lake d’Intel (Core Ultra X7 358H ou X9 388H selon la config), avec jusqu’à 64 Go de mémoire LPDDR5X partagée et une connexion Thunderbolt 4. Peu importe : cette machine n’est qu’un prétexte. Elle représente n’importe quel ordinateur récent capable de faire tourner un modèle de langage en local — laptop gaming, Mac à mémoire unifiée, tour de bureau avec carte graphique dédiée. La méthode de diagnostic qui suit s’applique quel que soit le boîtier, parce qu’elle vise la façon dont le logiciel utilise le matériel, pas le matériel lui-même.
Le modèle testé était Qwen3.8-27B, un modèle open weight de 27 milliards de paramètres publié par l’équipe Qwen d’Alibaba sous licence permissive — open weight, ça veut dire que le fabricant publie le modèle déjà entraîné, gratuitement, sans révéler pour autant les données ou le code qui ont servi à le construire. Il a été choisi parce qu’il est assez gros pour mettre la mémoire d’une machine grand public sous tension, sans nécessiter une carte de data center. Le logiciel qui le fait tourner s’appelle llama.cpp, le moteur open source que la plupart des outils d’IA locale (LM Studio, Ollama, et d’autres) utilisent en coulisses derrière une interface plus conviviale. Tout ce qui suit est un réglage de llama.cpp : ça s’applique donc partout où llama.cpp travaille, pas seulement sur cette machine précise.
Premier réflexe : le modèle tient-il vraiment dans la mémoire rapide
Une fois chargé, un modèle de langage doit vivre quelque part que le processeur peut atteindre vite : soit la mémoire vidéo dédiée d’une carte graphique, soit, sur les machines à mémoire partagée comme celle-ci, une réserve commune où puisent à la fois le CPU et les cœurs graphiques. La plupart des tutoriels vous disent de pousser toutes les couches du modèle vers cette mémoire rapide avec un réglage nommé --n-gpu-layers (souvent abrégé -ngl), généralement fixé à 99, 999 ou -1 — trois façons de dire « tout mettre sur la carte graphique, peu importe la place disponible ».
C’est le réglage que la plupart des guides copient-collent sans réfléchir, et les chiffres de Ziskind montrent exactement pourquoi c’est un problème. Avec 60 des 64 couches du modèle forcées sur la mémoire graphique — presque le maximum, sans l’être tout à fait — le débit tombait à 0,82 token par seconde, soit à peu près un mot toutes les une à deux secondes. En retenant manuellement quatre couches de plus, pour se limiter à 56 couches sur la carte graphique au lieu de 60, le même montage grimpait à 14 tokens par seconde — environ dix-sept fois plus vite, sur le même matériel, avec le même modèle.

Documentation du serveur llama.cpp — la doc officielle du réglage --n-gpu-layers évoqué plus haut.
Le mécanisme n’a rien de mystérieux. Quand un modèle ne tient pas proprement dans la réserve de mémoire rapide, le système doit sans cesse faire des allers-retours de données, et ces allers-retours coûtent bien plus de temps que de simplement laisser une petite tranche du modèle sur le chemin système, plus lent mais plus spacieux. Le réglage « toutes les couches » part du principe que ça rentre parfaitement. Quand ce n’est pas le cas, rien ne vous avertit : le modèle charge quand même, répond quand même, juste au ralenti. C’est le contre-exemple central de cette histoire, et il va à l’encontre d’une idée reçue des tutoriels : mettre plus de couches sur la carte graphique n’est pas toujours plus rapide. Ça cesse de l’être dès que le budget mémoire est dépassé.
Deuxième réflexe : comment le modèle a été compressé
Avant même de toucher au nombre de couches, il vaut la peine de vérifier comment le fichier du modèle a été compressé — un procédé appelé quantification. Les poids d’un modèle en pleine précision pèsent des masses de mémoire énormes, donc presque tous les modèles distribués pour un usage domestique ont déjà été allégés en représentant chaque nombre avec moins de bits, ce qui sacrifie un peu de précision numérique contre un fichier plus léger. Le piège, c’est que tous les schémas de quantification à la même profondeur de bits ne se valent pas en efficacité.
Le test de Ziskind a comparé deux versions du même modèle, toutes deux annoncées « 4 bits » mais construites avec des schémas internes différents : un fichier Q4_K_M d’environ 18 Go, et un fichier IQ4_XS plus compact, d’environ 13 Go. En passant au fichier plus léger, le modèle tenait entièrement dans la réserve de mémoire rapide, ce qui a quasiment doublé le débit, de 14 à 27 tokens par seconde. Pour vérifier si ce fichier plus petit répondait moins bien, le test a mesuré la perplexité, un score standard qui évalue la qualité de prédiction d’un modèle sur du texte réel (plus bas, c’est mieux — c’est la référence habituelle pour ce genre de comparaison). Les deux fichiers ont obtenu le même score de 6,8 sur le benchmark Wikitext-2, un échantillon de texte largement utilisé pour ce type de mesure, ce qui veut dire que le fichier plus léger n’était pas mesurablement moins bon sur cette comparaison précise. Ce n’est pas une garantie universelle valable pour tout modèle et tout usage, mais ça montre que le schéma le plus compact mérite d’être essayé avant de supposer qu’un fichier plus petit donne forcément une réponse plus faible.
La leçon pratique : un modèle qui tient presque souvent ne rate qu’un format de quantification pour tenir complètement — et c’est là, dans ce « complètement », que se joue la vraie vitesse.
Troisième réflexe : laisser un petit modèle deviner à la place du gros
La troisième technique testée par Ziskind s’appelle le décodage spéculatif, et ce n’est pas une nouveauté : c’est une fonctionnalité stable et bien documentée de llama.cpp. L’idée : plutôt que de faire générer chaque mot par le gros modèle de 27 milliards de paramètres, un modèle « brouillon » beaucoup plus petit devine une courte suite de mots à venir, et le gros modèle vérifie cette proposition en un seul passage au lieu de générer mot par mot. Quand les propositions du petit modèle sont correctes — ce qui arrive souvent sur du texte ordinaire — le gros modèle confirme plusieurs mots d’un coup au lieu de les calculer un par un.
Dans une comparaison isolée, testée à part des deux correctifs précédents (mémoire et quantification), activer le décodage spéculatif a à peu près doublé le débit, de 5 à 11 tokens par seconde, sans changer la qualité des réponses puisque le gros modèle vérifie toujours chaque mot. Il y a aussi un réglage fin à connaître ici : le nombre de mots que le petit modèle est autorisé à deviner avant que le gros ne vienne vérifier, souvent nommé draft-max ou équivalent dans la configuration. La valeur par défaut documentée par llama.cpp pour ce réglage est 3, un chiffre volontairement prudent. Ziskind a constaté qu’augmenter cette valeur dégradait les performances au lieu de les améliorer, parce qu’une proposition plus longue et non vérifiée a plus de chances de se tromper quelque part au milieu — et une seule erreur dans la série oblige le gros modèle à jeter et refaire tout le passage. Le réglage par défaut existe pour une bonne raison ; il faut le voir comme un point de départ à tester, pas comme une limite à contourner.

Documentation du décodage spéculatif de llama.cpp — la doc du moteur lui-même sur la technique décrite ci-dessus.
Ce que le câble n’a (presque) rien à voir avec l’affaire
Un dernier résultat mérite d’être signalé, parce qu’il corrige une idée reçue courante : sur une machine à mémoire partagée ou unifiée, la connexion qui relie les composants — ici l’interface propriétaire Mind Link de Khadas, un connecteur basé sur PCIe donné pour jusqu’à 15,8 gigaoctets par seconde, et non un port Thunderbolt ou USB4 standard — est rarement le goulot d’étranglement qu’on lui prête. Pendant une génération de texte ordinaire dans ce test, le trafic réel sur ce lien tournait autour de 2 mégaoctets par seconde, une fraction minuscule de sa capacité nominale. Le facteur limitant pour la vitesse d’un modèle de langage local est presque toujours la bande passante mémoire — la vitesse à laquelle les données circulent entre la réserve de mémoire et les cœurs de calcul qui font les opérations — et non le lien de transport entre les composants. Changer de câble ou de port ne fera quasiment jamais bouger l’aiguille sur ce type de charge de travail ; c’est le système mémoire lui-même qui pose le plafond.
Mettre les vérifications dans le bon ordre
Aucune des trois techniques ci-dessus n’est nouvelle. Quantification, décodage spéculatif et déchargement manuel des couches existent dans llama.cpp depuis longtemps, et quiconque a traîné sur des forums d’IA locale a probablement croisé les trois séparément. Ce que ce test montre bien, c’est ce qui se passe quand on les vérifie dans l’ordre, et ce qui se passe quand le réglage le plus copié-collé joue activement contre vous.
Un ordre raisonnable, généralisable à n’importe quelle machine faisant tourner llama.cpp sous n’importe quelle interface :
- Confirmer que le modèle tient réellement dans la réserve de mémoire rapide au nombre de couches choisi, plutôt que de supposer que le réglage maximal est sans risque par défaut.
- Essayer un format de quantification plus compact à la même profondeur de bits, avant de conclure que le modèle doit perdre en qualité pour gagner en taille.
- Activer le décodage spéculatif si un petit modèle brouillon compatible existe pour la même famille de modèles, et laisser le réglage de profondeur du brouillon à sa valeur par défaut documentée, sauf si des tests prouvent le contraire.
- Laisser de côté les liens de transport (Thunderbolt, USB4, PCIe) dans le diagnostic pour les configurations à mémoire partagée ; ils sont rarement la contrainte.
L’ordre compte, parce que chaque étape change ce que la suivante doit résoudre. Corriger d’abord le problème de mémoire rend souvent les gains de compression et de décodage spéculatif plus importants, puisque le modèle ne se bat plus contre son propre placement.
Questions fréquentes
Pourquoi mettre le nombre de couches GPU au maximum rend parfois une IA locale plus lente, pas plus rapide ?
Le réglage « toutes les couches » force chaque couche du modèle sur la mémoire graphique rapide, même quand le modèle n’y tient pas proprement. Quand ça ne rentre pas, le système doit sans arrêt faire des allers-retours de données, ce qui coûte bien plus de temps que de laisser une petite portion du modèle sur le chemin mémoire système, plus lent.
Un fichier de modèle quantifié plus petit veut-il dire des réponses forcément moins bonnes ?
Pas automatiquement : ça dépend du schéma de compression précis, pas seulement de la profondeur de bits. Dans un test documenté, un format 4 bits plus compact a obtenu exactement le même score qu’un format 4 bits plus gros sur un benchmark de perplexité standard, tout en tournant nettement plus vite parce qu’il tenait entièrement en mémoire.
Qu’est-ce que le décodage spéculatif, en clair ?
Le décodage spéculatif laisse un petit modèle « brouillon » rapide deviner plusieurs mots à venir, qu’un modèle plus gros vérifie ensuite en un seul passage au lieu de générer chaque mot un par un. Quand les propositions sont correctes — ce qui est fréquent sur du texte ordinaire — ça double à peu près la vitesse de sortie sans changer la qualité de la réponse finale.
La vitesse du Thunderbolt ou de l’USB4 est-elle le goulot d’étranglement d’un modèle de langage local ?
Sur une machine à mémoire partagée ou unifiée, le lien de transport entre les composants est rarement le facteur limitant pour la vitesse d’un modèle de langage. Le trafic réel de données sur ce lien pendant la génération de texte ne représente typiquement qu’une petite fraction de sa capacité nominale ; c’est la bande passante mémoire, pas la vitesse du câble, qui fixe le plafond pratique.
Faut-il acheter du nouveau matériel si son IA locale tourne au ralenti ?
Pas forcément. Avant d’acheter du matériel neuf, vérifiez si le modèle tient proprement dans la mémoire rapide disponible, essayez un format de quantification plus efficace, et activez le décodage spéculatif si un modèle brouillon compatible existe. Ce sont des ajustements logiciels gratuits qui, dans les cas testés, ont apporté des gains de vitesse bien plus importants que ce que le matériel seul aurait laissé espérer.