Recherche

Mesuré, avec les données pour le vérifier.

Le raisonnement anticipé n'est pas exact, il a donc été mesuré sur des réponses vérifiables. Chaque tableau ci-dessous a son script et son JSON dans le dépôt, et le journal de recherche garde les notes de travail, les plus récentes d'abord.

Méthode

Des problèmes à réponse numérique connue, tapés en italien en temps réel : 5 à 8 caractères par seconde, quelques pauses naturelles, Entrée juste après le dernier caractère, pas de relecture. Le script est research/thinking_ahead.py ; il tape chaque problème avec et sans raisonnement anticipé et enregistre l'attente du premier mot de la réponse, les tokens de raisonnement au total et ceux qui restent après Entrée, et si la réponse est juste.

Les modèles sont Qwen3 Q4_K_M en mode thinking sur llama.cpp (b11747). La machine de référence est une RTX 2060 avec 6 Go de VRAM (i5-10400, 16 Go DDR4, Windows 11) : Qwen3-4B tient dans la VRAM à environ 83 tok/s, Qwen3-14B non (38 % sur le GPU, environ 5 tok/s). La seconde machine est un MacBook Pro M2 Pro, 16 Go, avec Metal. Deux exécutions des mêmes 24 problèmes diffèrent jusqu'à une seconde en moyenne : comparez des lignes mesurées l'une après l'autre.

Résultats

Raisonnement anticipé, Qwen3-4B sur la RTX 2060, 24 problèmes (research/thinking_ahead.py, données thinking_ahead_4b.json) :

Même exactitude, moins de raisonnement au total (le matériel rassemblé pendant la frappe évite au modèle de repartir de zéro), et presque deux tiers faits avant Entrée. Le cadre des notes compte : un cadre générique donnait 22/24 et une médiane de 4,4 s ; sans cadre, 22/24, 6,9 s et 70 % de raisonnement en plus. Avec le cadre en liste, la ligne d'exemple et un biais de logits contre des mots comme user, incomplete, typing pendant le raisonnement anticipé, la part des phrases des notes portant sur le message lui-même plutôt que sur son contenu est passée de 86 % à 17-26 %.

Réponse exacte d'avance

Qwen3-4B, sans raisonnement, pause avant Entrée avec le texte inchangé : la réponse elle-même est écrite d'avance, et cette partie est exacte (en décodage glouton, identique token par token à celle lancée après Entrée ; vérifié).

Modèles plus gros

Ce que le modèle peut faire avant Entrée est borné par le temps de frappe × sa vitesse d'écriture :

Malgré tout, sur le 14B (6 problèmes, 6/6 correctes dans les deux cas), le raisonnement anticipé divise par deux l'attente moyenne après Entrée : 108 s → 47 s, avec 164 tokens de raisonnement écrits avant Entrée en moyenne. Les exécutions isolées varient beaucoup (le même problème a pris 106 s une fois et 154 s une autre), donc 6 problèmes donnent l'ordre de grandeur. La lecture anticipée gagne d'autant plus que le modèle est gros : le 14B lit un document collé de 3 000 tokens en environ 10 s, entièrement caché pendant que vous tapez.

Deviner la fin (--branches, expérimental). Le raisonnement qui reste après Entrée porte surtout sur la fin du message, qui arrive en dernier. Avec --branches 1, le modèle devine aussi comment vous allez finir et raisonne sur cette hypothèse sur un slot à lui. Mêmes 24 problèmes, deux exécutions chacun : 48/48 correctes, attente moyenne 4,17 s → 3,51 s, dixième le plus lent 7,9 s → 5,3 s, 14 messages sur 48 devinés exactement. Un gain modeste, surtout sur les réponses les plus lentes, pas encore significatif sur 24 problèmes (test des signes p = 0,15). Sur le 14B, aucune branche n'a jamais commencé à raisonner avant Entrée : dans l'appli, une branche n'est donnée qu'aux modèles qui tiennent dans la VRAM.

Un petit modèle qui rassemble pour un gros (--gatherer, expérimental). Un Qwen3-0.6B rapide, également affiné pour cela, qui écrit du matériel pendant que vous tapez pour que le 14B le lise à Entrée. Sur la RTX 2060, il ne bat pas le 14B raisonnant seul à l'avance : 47 s contre 60 s sans entraînement et 79-86 s affiné ; même un matériel idéal écrit à la main donne 62 s, ou 49 s présenté comme le propre raisonnement du modèle. Le 14B le lit, puis refait les calculs. Les questions ouvertes pour qui voudrait poursuivre sont dans le README.

Sur un Mac

MacBook Pro M2 Pro, 16 Go, macOS 26.2, llama.cpp avec Metal ; mêmes scripts et mêmes problèmes.

Le 4B écrit à 54 tok/s sur le M2 Pro (83-87 sur la RTX 2060), les deux attentes sont donc plus longues que sur le PC, et le raisonnement anticipé en enlève à peu près la même part. C'est sur le 14B que le Mac diffère : Metal peut utiliser 12 Go de la mémoire unifiée, le modèle entier est donc sur le GPU et écrit à 18 tok/s. Pendant les exécutions, le Mac a atteint une pression thermique Heavy pendant quelques minutes. Données : thinking_ahead_4b_m2pro.json, thinking_ahead_4b_m2pro_fixed.json, thinking_ahead_14b_m2pro.json.

Essayé, et pourquoi pas

• --recycle (les réponses aux versions précédentes du message comme brouillons n-grammes) : +4 % de vitesse de decode avec une frappe naturelle, +20 % sur du code, premier token légèrement plus tardif.
• --draft (Qwen3-0.6B rédigeant pour le 14B) : sur le GPU, il prend de la VRAM au 14B, qui fait alors tourner plus de couches sur le CPU (4,8 → 3,5 tok/s) ; sur le CPU, il gagne 8 % avec des brouillons de 4 tokens et divise par deux la vitesse de lecture.
• Le raisonnement anticipé comme brouillon pour le décodage spéculatif après Entrée : pas plus rapide sur le 4B (73 tok/s dans les deux cas) et plus lent sur le 14B (5,0 → 3,1 tok/s), parce que les couches sur le CPU calculent chaque token du brouillon et que seuls 11 % des tokens proposés étaient justes. Script : research/notes_as_draft.py.
• IQ4_XS au lieu de Q4_K_M sur le 4B (RTX 4070 SUPER) : 4 % plus rapide, une réponse de moins bonne sur 28. Pas la peine sur le 4B ; sur le 14B, où c'est 31 % plus rapide avec les mêmes réponses, la décision est en cours.

Fait clé appris : sur un modèle réparti entre GPU et CPU, les couches du CPU calculent chaque token qu'on leur donne. Tout ce qui traite plusieurs tokens à la fois coûte au 14B presque proportionnellement. Pour accélérer le 14B, il faut enlever du travail au CPU.

Aide recherchée : Radeon

MAFDET tourne sur les cartes Radeon via la build Vulkan de llama.cpp, mais personne ne l'a encore mesuré sur l'une d'elles. Le chemin Vulkan lui-même est vérifié, sur la RTX 2060 (Qwen3-4B lit 2 103 tokens/s et en écrit 83, à peu près comme avec CUDA). Si vous avez une carte dédiée, RX 5000 ou plus récente, 8 Go ou plus idéalement, une demi-heure environ comblerait ce manque :

1. Installez MAFDET et ouvrez-le une fois : il devrait trouver votre carte, installer llama.cpp Vulkan et télécharger Qwen3-4B. mafdet doctor montre ce qu'il a trouvé.
2. Dans l'appli, Modèles, Mesurer Qwen3-4B.
3. Depuis le dossier MAFDET, avec son environnement actif : python research/thinking_ahead.py radeon_4b.json. Environ 20 minutes ; laissez la machine au repos pendant ce temps.
4. Ouvrez une issue avec la sortie de mafdet doctor, les chiffres de Mesurer et radeon_4b.json.

Recherches connexes

• LiveMind: Low-latency Large Language Models with Simultaneous Inference
• StreamingThinker: Large Language Models Can Think While Reading
• SHANKS: Simultaneous Hearing and Thinking for Spoken Language Models
• Asynchronous Reasoning: Training-Free Interactive Thinking LLMs