Auto-vérification par l'IA : la recherche qui change tout

Le résultat contre-intuitif

Demandez à une IA « est-ce que ce code est correct ? » et elle répondra oui, même quand il est faux. C’est bien documenté. Huang et al. (ICLR 2024) ont prouvé que les LLMs ne peuvent pas auto-corriger leur raisonnement sans retour externe. L’auto-évaluation naïve ne fonctionne pas.

Mais voici ce que la plupart des gens ignorent : la vérification structurée multi-perspective fonctionne énormément.

La différence ne réside pas dans le fait que l’IA se vérifie elle-même. C’est la manière dont la vérification est conçue qui compte.

Les preuves

MPSC : +15,91% sur HumanEval

Huang et al. (ACL 2024) ont introduit le Multi-Perspective Self-Consistency (MPSC). Au lieu de demander « est-ce correct ? », ils ont fait vérifier le même code par l’IA depuis trois angles indépendants :

1. Perspective du code : la logique d’implémentation tient-elle ?
2. Perspective de la spécification : correspond-elle aux exigences ?
3. Perspective des tests : les tests générés indépendamment passent-ils ?

Quand ces trois perspectives s’accordent, la confiance est élevée. Quand elles divergent, quelque chose ne va pas.

Résultat : +15,91% de précision sur HumanEval. Pas grâce à un meilleur modèle. Grâce à une meilleure architecture de vérification.

Self-Refine : environ 20% d’amélioration moyenne

Madaan et al. (NeurIPS 2023) ont montré que les boucles itératives d’auto-feedback, où l’IA critique sa propre sortie puis révise en fonction de cette critique, produisent environ 20% d’amélioration en moyenne sur l’ensemble des tâches.

L’élément clé : le feedback doit être structuré. « Améliore-le » ne fonctionne pas. « Vérifie les cas limites dans la gestion d’erreurs, vérifie que les types de retour correspondent à l’interface, et confirme que la requête base de données gère les valeurs null » fonctionne.

Réflexion : 91% pass@1

Shinn et al. (NeurIPS 2023) ont atteint 91% pass@1 sur HumanEval en utilisant une mémoire de réflexion verbale. Après chaque tentative échouée, l’IA écrit une « réflexion » sur ce qui n’a pas fonctionné et pourquoi. Ces réflexions persistent d’une tentative à l’autre, créant une mémoire croissante des erreurs à éviter.

C’est essentiellement l’équivalent IA d’un document d’auto-apprentissage.

Self-Debugging : +2 à 12% de précision

Chen et al. (ICLR 2024) ont prouvé que le « rubber duck debugging » fonctionne pour les LLMs. Quand on demande à l’IA d’expliquer son code étape par étape et de vérifier chaque étape par rapport à la spécification, elle détecte des bugs qu’elle avait manqués lors de la génération.

CoVe : 50 à 70% d’hallucinations en moins

Dhuliawala et al. (ACL 2024) ont développé le Chain-of-Verification (CoVe), qui réduit les faits hallucinés de 50 à 70%. L’IA génère des questions de vérification sur sa propre sortie, y répond indépendamment, et révise en fonction des contradictions.

La distinction cruciale

Ce qui échoue : « IA, vérifie si ce code est correct. »

Ce qui fonctionne : « Vérifie ce code du point de vue logique : explique le raisonnement étape par étape. Maintenant vérifie du point de vue des cas limites : quelles entrées pourraient casser ceci ? Maintenant vérifie du point de vue des tests : génère 5 tests et exécute-les. Maintenant compare les trois résultats. »

La différence est l’architecture de vérification. On ne demande pas à l’IA de se vérifier elle-même. On conçoit un système où l’IA est forcée de vérifier depuis plusieurs angles indépendants qui triangulent vers la vérité.

C’est ce qu’enseigne la Vérification Paranoïaque. Pas la revue de code manuelle : la conception de systèmes de vérification.

Pourquoi cela vous concerne

Chaque développeur utilisant l’IA génère du code. Presque personne ne conçoit la vérification. C’est là où se situe l’écart de compétences.

Les développeurs qui apprendront à concevoir une auto-vérification IA multi-angle livreront un meilleur code plus rapidement que :

• Les développeurs qui font aveuglément confiance à la sortie de l’IA
• Les développeurs qui revoient manuellement chaque ligne (ce qui ne passe pas à l’échelle)

Dix passes de vérification IA coûtent environ 0,50 $. Une heure de revue humaine coûte 50 à 75 $. L’économie n’est même pas comparable, si vous savez concevoir le système.

Sources : Huang et al., “LLMs Cannot Self-Correct” (ICLR 2024) · Huang et al., “MPSC” (ACL 2024) · Madaan et al., “Self-Refine” (NeurIPS 2023) · Shinn et al., “Reflexion” (NeurIPS 2023) · Chen et al., “Self-Debugging” (ICLR 2024) · Dhuliawala et al., “CoVe” (ACL 2024)