Petits modèles en boucle : 5 erreurs à éviter en production
Transformeurs en boucle et quantification NVFP4 ont changé ce que font les petits modèles. Cinq erreurs à éviter lors du choix d'un modèle en production.

Une équipe que j'ai conseillée l'an dernier payait environ 4 000 $ par mois pour faire passer des requêtes simples de tri de tickets par une API de modèle de pointe. La charge de travail consistait en de la classification et du résumé court. Un petit modèle de langage tournant sur un seul GPU aurait suffi, mais personne dans l'équipe n'y croyait : la dernière fois qu'ils avaient testé un modèle de moins de 30 Md de paramètres, il avait échoué sur leurs tâches de raisonnement complexes, et ils ne s'étaient plus jamais penchés dessus.
Cet angle mort devient coûteux très vite. La sortie récente d'Inkling 2 Mini, un modèle à poids ouverts de 26,4 Md de paramètres en mélange d'experts qui fait boucler ses couches intermédiaires trois fois par token, a obtenu des scores de codage agentique supérieurs à ceux de tous les modèles ouverts de moins de 100 Md de paramètres, tout en tenant dans environ 20 Go de mémoire. Un modèle qui tourne hors ligne sur un ordinateur portable vient de surpasser sur des tâches de type SWE-bench des modèles plusieurs fois plus grands. L'écart entre « petit » et « capable » s'est tellement réduit que la plupart des règles que les praticiens gardent en tête sur le dimensionnement des modèles sont devenues obsolètes. Voici les cinq erreurs que je vois le plus souvent, et ce qu'il faut faire à la place.
Erreur 1 : considérer le nombre de paramètres comme le plafond des capacités
Le modèle mental que la plupart d'entre nous ont hérité est simple : les paramètres constituent le budget, et les capacités croissent avec ce budget. Ce n'a jamais été tout à fait exact, car les données d'entraînement et le calcul comptent énormément, mais c'était une heuristique utilisable tant que l'architecture ne jouait pas un rôle réel. La boucle en est l'exemple le plus net. Inkling 2 Mini fait passer ses 12 couches intermédiaires (deux blocs de six, sur 24 au total) trois fois pour chaque token, alors que le premier et le dernier bloc ne s'exécutent qu'une fois. L'intuition : les couches du début et de la fin se contentent surtout de traduire entre embeddings et représentations internes, tandis que les couches du milieu portent le raisonnement abstrait. On dépense donc son calcul là où le raisonnement se produit.
L'ablation publiée mérite votre attention : faire boucler les 12 couches du milieu a battu la boucle sur les 12 dernières sur 27 évaluations sur 28, et une baseline sans boucle nécessitait environ 1,5 à 1,9 fois plus de calcul pour atteindre la perte du modèle à boucle centrale. Ce n'est pas un simple réglage marginal. C'est une stratégie d'allocation du calcul différente, qui met en défaut l'heuristique naïve du nombre de paramètres, dans une direction précise et prévisible.
La solution : quand vous évaluez un petit modèle, demandez-vous où va le calcul par token, et pas seulement combien de poids il contient. Un modèle de 26 Md avec 3,4 Md de paramètres actifs et des couches intermédiaires en boucle se rapproche davantage de « un petit modèle qui réfléchit plus longtemps » que de « un petit modèle ». Cela rejoint un point que j'ai déjà défendu : le raisonnement s'entraîne dans les modèles, il ne s'obtient pas par simple prompt, et on commence aussi à l'architecturer directement dans leur conception.
Erreur 2 : confondre raisonnement et connaissance
Voici la partie de l'histoire des modèles en boucle que les praticiens oublient systématiquement, et qui finit par mordre. La boucle améliore le raisonnement. Elle ne crée pas de connaissances. Les faits vivent dans les poids, et le nombre de poids est ce qu'il est. L'équipe d'Inkling 2 Mini est remarquablement franche à ce sujet : sur AA-Omniscience, un benchmark de factualité, le modèle obtient des scores conformes à ceux d'autres modèles de sa taille. Leur variante de recherche à nombre de boucles variable s'est améliorée sur les benchmarks de raisonnement séquentiel et de long contexte à mesure qu'on ajoutait des boucles, jusqu'à dix, soit deux fois le nombre utilisé à l'entraînement. Mais les benchmarks à forte composante de connaissance, comme SimpleQA, n'ont pas bougé avec davantage de passes.
J'ai vu un ami déboguer exactement cette confusion en production. Il avait remplacé un modèle plus gros par un petit modèle orienté raisonnement pour un chatbot de support, constaté un bond de la qualité du raisonnement, et mis en production. Deux semaines plus tard : des références produit inventées et des détails de politique tarifaire fabriqués. Le modèle raisonnait magnifiquement sur des faits qu'il ne contenait tout simplement pas. Un des premiers testeurs sur Hacker News s'est heurté au même mur en deux prompts : en demandant un plugin WordPress exploitant des recoins obscurs de l'API, il a obtenu un code bien structuré, assuré, et faux.
La solution n'est pas « utiliser un modèle plus gros ». Elle est architecturale : associer le petit raisonneur à une couche de recherche documentaire et à des outils. Fait notable, Inkling 2 Mini devance les modèles ouverts comparables sur BrowseComp et DeepSearchQA, des benchmarks qui mesurent la recherche et l'usage d'outils. Un petit modèle avec une bonne discipline d'outils bat souvent un gros modèle qui se remémore des faits périmés, parce que le contexte récupéré est à jour et vérifiable. Ma règle : si les échecs de votre charge de travail sont des échecs de raisonnement, un petit modèle en boucle aide. S'ils sont des échecs de connaissance, corrigez votre recherche documentaire, pas le nombre de paramètres.
Erreur 3 : rejeter d'emblée la quantification en faible précision
Il y a cinq ans, « nous l'avons quantifié en 4 bits » ressemblait à une excuse. On acceptait une vraie perte de qualité en échange d'un matériel plus modeste, et tout ce qui descendait sous 4 bits relevait de l'expérimentation. Cette hypothèse coûte aujourd'hui réellement du budget matériel. Inkling 2 Mini a été entraîné de bout en bout en NVFP4 et est déployé nativement en NVFP4, avec seulement les quatre dernières couches en MXFP8 : la quantification n'est pas une étape de compression après coup, elle fait partie de la recette d'entraînement. Le résultat : une empreinte d'environ 20 Go pour une qualité comparable à celle des pairs en BF16.

L'effet en aval est frappant. L'équipe d'Unsloth, qui connaît mieux que quiconque les galères de la quantification, a remarqué que ces modèles natifs en faible précision réagissent étonnamment bien à une quantification supplémentaire, avec selon les rapports environ 90 % d'accord top-1 même en 1 bit. Une version GGUF est apparue sur Hugging Face quelques jours après la sortie, et des praticiens le font déjà tourner sur un MacBook Pro dans l'avion (l'équipe a littéralement montré comment il construisait un simulateur de vol jouable hors ligne en plein vol) et sur des GPU grand public comme la 7900XTX.
La solution : arrêtez de voir la quantification comme une dégradation, et demandez-vous si le modèle a été entraîné en faible précision. Si c'est le cas, l'artefact en 4 bits (ou moins) est le citoyen de première classe, et votre calcul de dimensionnement « il nous faut 80 Go de VRAM » est à refaire. Si vous explorez ce que cela permet pour les déploiements hors ligne, nous avons présenté les schémas d'architecture dans construire un LLM qui fonctionne hors ligne et le volet matériel dans faire tourner des LLM sur votre propre matériel.
Erreur 4 : comparer les modèles une seule fois, puis figer le choix
L'erreur la plus coûteuse n'est pas technique, elle est procédurale. Les équipes organisent un comparatif au lancement d'une fonctionnalité, choisissent un modèle et traitent cette décision comme définitive. Or la frontière capacité par paramètre évolue plus vite que la plupart des cycles d'achat. Inkling 2 Mini a obtenu 48,2 % sur DeepSWE v1.1 et 46,5 % sur Vals Index v2.2, en tête de tous les modèles ouverts de moins de 100 Md de paramètres totaux, et il décode plus vite que des modèles aux performances similaires, car un MoE à 3,4 Md de paramètres actifs lit beaucoup moins de poids par token qu'un modèle dense de 27 Md. Un choix de modèle fait il y a neuf mois n'est plus une décision, c'est une habitude jamais remise en question.
Mais refaire un comparatif de façon naïve est un piège en soi. Les classements publics mesurent ce que leurs auteurs ont jugé intéressant, pas ce que fait votre produit. C'est le problème central derrière pourquoi les benchmarks IA passent à côté de l'essentiel du travail réel, et les petits modèles l'aggravent, car leur profil est plus irrégulier : Inkling 2 Mini est le meilleur de sa catégorie en codage agentique, mais n'obtient qu'un score moyen de 50,0 % sur MultiChallenge et de 33,4 % sur ComplexConstraints, derrière Qwen3.8-27B sur les deux. Si votre charge de travail est un chat multi-tours très contraint, les chiffres de codage ne vous concernent pas.
La solution : maintenez une petite suite d'évaluation versionnée, construite à partir de votre trafic de production, avec 200 à 500 cas réels dont les sorties correctes sont connues, et testez chaque nouvelle version de modèle dessus chaque trimestre. C'est moins coûteux qu'il n'y paraît, et cela détecte les surprises dans les deux sens : les modèles meilleurs que leurs benchmarks ne le laissent croire (un commentateur a noté qu'Inkling 2 Small « semblait meilleur que ce que les benchmarks suggéraient ») et ceux qui brillent dans les classements mais échouent sur vos prompts très contraints. Prévoyez une journée par trimestre. Cela se rentabilisera la première fois que cela vous permettra de descendre d'un niveau de modèle.
Erreur 5 : ignorer le côté coût du bilan
Les discussions sur le choix d'un modèle obsèdent sur la précision et traitent le coût comme une réflexion après coup. C'est à rebours en production, où la courbe de coût détermine ce qui est réellement faisable. Le Hazy Research Lab de Stanford a réalisé des premières mesures d'intelligence par joule sur Inkling 2 Mini et obtenu 0,703, contre 0,430 pour Qwen3.6-35B-A3B, 0,159 pour Gemma-4-26B-A4B et 0,036 pour Qwen3.5-27B. Ce n'est pas un gain de quelques pourcents, c'est un autre régime. Et l'effet se cumule : un modèle qui atteint ses réponses en moins de tokens (tout l'argument de la boucle est de raisonner sans écrire le raisonnement) dépense moins en calcul comme en latence par tâche.
La conséquence pratique qui me motive le plus est la densité multi-agents. Comme c'est un petit MoE, vous pouvez loger les caches KV de plusieurs agents dans la VRAM d'un seul GPU. La démo de 20 villageois simulés alimentés par un seul MacBook hors ligne est sympathique, mais la version sérieuse serait une douzaine d'agents de production sur un DGX Spark ou une simple station de travail, au lieu d'une flotte d'appels d'API facturés au token avec des transferts de données. Nous avons écrit sur la tendance plus large vers ce niveau de modèles dans pourquoi les LLM de niveau flash sont la véritable histoire de l'efficacité en inférence, et les petits modèles en boucle renforcent nettement cet argument.
La solution : bâtissez votre modèle de coût autour du coût par tâche accomplie, et non du coût par token. La boucle ajoute du temps réel par token (ces couches du milieu tournent trois fois, et le calcul de bande passante mémoire implique des lectures répétées), donc une comparaison naïve des tokens par seconde peut induire en erreur dans les deux sens. Mesurez de bout en bout : la tâche a-t-elle été résolue, combien de tokens a-t-elle demandés, quelle énergie et quelle latence a-t-elle consommées. Un modèle inférieur de 20 % par token, mais qui résout la tâche en deux fois moins de tokens avec moins de relances, gagne à tous les coups.

Que faire concrètement dès lundi
- Auditez vos dépenses API par type de tâche. Tout ce qui relève de la classification, de l'extraction, du routage ou de courtes boucles agentiques est candidat à un modèle local de moins de 30 Md. Chiffrez-le.
- Séparez votre suite d'évaluation entre échecs de raisonnement et échecs de connaissance. Les petits modèles en boucle corrigent les premiers. La recherche documentaire corrige les seconds. Ne les confondez pas.
- Vérifiez si votre modèle candidat a été entraîné en faible précision. Si oui, testez d'abord l'artefact en 4 bits au lieu de le tester en dernier : c'est sa forme native.
- Comparez sur votre propre trafic, chaque trimestre. Les scores publics sont un outil de présélection, pas une décision.
- Prototypez une charge de travail multi-agents sur du matériel local. L'économie des agents persistants change complètement quand il n'y a plus de compteur au token.
Le changement de fond ne tient pas à un modèle en particulier. Les grandes directions de recherche des laboratoires de pointe (la boucle, l'entraînement sensible à la quantification, l'élagage agressif d'experts avec réparation) arrivent désormais dans les poids ouverts en quelques mois, dimensionnées pour le matériel que vous possédez déjà. Les praticiens qui gagneront les prochaines années ne seront pas ceux qui ont les plus gros budgets d'API. Ce seront ceux qui réexaminent leurs hypothèses sur les modèles selon un calendrier, car ces hypothèses ont une durée de vie plus courte que le code.
Un petit modèle qui raisonne bien et récupère honnêtement l'information bat un gros modèle qui se souvient avec assurance et raisonne paresseusement, sur le coût, sur la latence, et souvent sur la précision.


