L'IA de demain
FR

← Retour au carnet

Approfondissement · Folio IV

Vérifier coûte moins qu'écrire

Résoudre un sudoku prend du temps ; vérifier une grille remplie prend quelques secondes. Dans beaucoup de problèmes, vérifier est bien plus facile que trouver. L'IA commence à s'appuyer sur cette asymétrie, à deux échelles : le mot et la réponse entière.

Prometteur mise à jour du

I

L'idée, simplement

Un modèle de langage écrit un mot à la fois, et chaque mot l'oblige à relire tous ses poids. Mais vérifier plusieurs mots proposés peut se faire en un seul passage, à peu près aussi vite que d'en écrire un. D'où l'idée : un petit modèle rapide devine, le grand ne fait que confirmer.

À l'échelle d'une réponse entière, la même asymétrie tient : produire beaucoup d'essais, puis laisser un vérificateur (des tests, un vérificateur de preuves, une calculatrice) garder le bon.

II

Comment ça marche

Dans le décodage spéculatif (Google, 2023), le petit modèle propose quelques mots ; le grand calcule, en parallèle, la probabilité qu'il aurait donnée à chacun. Une règle d'acceptation astucieuse garde les bons et retire au sort le premier mauvais, si bien que le texte suit exactement la même loi que celui du grand modèle seul.

Plus le petit modèle devine juste, plus le gain est grand. Les travaux suivants cherchent donc à le faire mieux deviner, notamment en lui donnant accès aux états internes du grand modèle.

Source : Leviathan, Kalman & Matias, Speculative Decoding (ICML 2023)

Fig. K — Proposer, puis vérifier

lechatdortsousunsur

  1. 1. Le petit modèle propose 5 mots
  2. 2. Le grand modèle les vérifie en un passage
  3. 3. Il en garde 3 et corrige le 4e

4 mots écrits pour un seul passage du grand modèle

Schéma illustratif : il montre l'idée, pas des mesures.

Un grand modèle a normalement besoin d'un passage complet par mot. Ici, un passage valide trois mots proposés et corrige le quatrième : quatre mots pour le prix d'un. La règle d'acceptation est conçue pour que le texte final soit exactement celui que le grand modèle aurait écrit seul.
III

Deux échelles de vérification

Établi

EAGLE-3 (2025)

Le modèle qui propose est une petite tête branchée sur les couches internes du grand modèle plutôt qu'un modèle séparé. Accélération rapportée : jusqu'à 6,5 fois, 1,4 fois mieux qu'EAGLE-2, et 1,38 fois plus de débit même avec 64 requêtes servies ensemble.

Source : Li et al., EAGLE-3 (2025)

Prometteur

Large Language Monkeys : essayer souvent, puis vérifier (2024)

Avec 250 essais et les tests des projets eux-mêmes comme vérificateur, un modèle ouvert corrige 56 % de vrais tickets GitHub (SWE-bench Lite) contre 15,9 % en un essai, au-dessus du meilleur résultat en un essai de l'époque (43 %). Cinq essais du modèle bon marché coûtaient moins qu'un essai des modèles chers, et en résolvaient davantage.

Source : Brown et al., Large Language Monkeys (2024)

IV

Les limites

Tout dépend du vérificateur. Pour du code avec des tests ou une preuve mathématique, la vérification est fiable. Pour un essai ou un conseil, il n'y a pas de test automatique : les votes à la majorité et les modèles de notation plafonnent après quelques centaines d'essais, bien en dessous de ce que permettrait un vérificateur parfait. Et le décodage spéculatif accélère l'écriture, pas la réflexion : il ne rend pas le grand modèle plus intelligent.

VI

Ce qu'on aimerait tester

Pour des questions sur les articles d'OrigoTech dont la réponse est un chiffre ou une date, laisser un petit modèle répondre 10 fois et ne garder que les réponses confirmées par le texte de l'article lui-même. Comparer la justesse avec une seule réponse d'un grand modèle.

Haut de page