Résumé technique : L'abstention de tâche pour les modèles de langage larges dans la génération de code

Définition du problème

L'article aborde la question critique des hallucinations dans les modèles de langage larges (LLM) appliqués à la génération de code. Alors que la recherche existante se concentre largement sur l'hallucination d'échantillon (détection de fragments de code individuels qui ne s'exécutent pas ou ne répondent pas aux exigences), ce travail identifie une source d'erreur plus fondamentale : l'hallucination au niveau de la tâche. Cela se produit lorsqu'un LLM est intrinsèquement peu susceptible de résoudre une tâche de codage spécifique en raison de prompts ambigus ou des limitations inhérentes du modèle, indépendamment du nombre d'échantillons qu'il génère.

Les auteurs formalisent le problème de l'abstention de tâche : déterminer si un LLM doit refuser de répondre à un prompt de génération de code spécifique pour éviter de produire du code fonctionnellement incorrect. L'objectif est de définir une fonction de refus $r(x)$ qui identifie les tâches où la probabilité de générer une solution correcte est faible, spécifiquement lorsque la métrique $H@k$ (la probabilité que $k$ échantillons générés aléatoirement soient tous incorrects) dépasse une tolérance au risque définie par l'utilisateur $\alpha$.

Méthodologie : CODEREFUSER

L'approche proposée, CODEREFUSER, est construite sur le cadre Learn Then Test (LTT), utilisant des tests d'hypothèses multiples pour fournir des garanties théoriques rigoureuses et sans distribution. La méthode opère en deux phases :

1. Phase de calibration

• Construction de l'ensemble de calibration : Contrairement aux tâches NLP standard, l'ensemble de calibration est composé de prompts de tâche appariés avec des cas de test oracle (vérité terrain).
• Définition du risque d'admission : Le risque est défini comme la probabilité qu'une tâche soit admise (non refusée) mais que le LLM échoue à générer une solution correcte dans $k$ tentatives ($H@k$).
• Fonctions de score : Pour gérer la diversité syntaxique du code sémantiquement équivalent, les auteurs proposent des fonctions de score basées sur l'exécution plutôt que des métriques linguistiques statiques. Elles reposent sur le regroupement (clustering) des échantillons de code en fonction de leurs résultats d'exécution par rapport aux cas de test :
  • Rapport de cluster (CR) : Mesure la proportion d'échantillons appartenant au cluster sémantique dominant (consensus du modèle).
  • Entropie sémantique (SE) : Quantifie l'incertitude de la tâche en mesurant la diversité de la distribution des clusters résultants.
• Sélection du seuil : En utilisant des tests d'hypothèses multiples, la méthode identifie un ensemble de seuils valides ($\Lambda_{valid}$) garantissant que le risque d'admission reste inférieur à la tolérance $\alpha$ avec une haute confiance ($1-\delta$).

2. Phase de test

• Génération duale : Pour un nouveau prompt de test, le LLM génère à la fois des solutions de code et des cas de test correspondants.
• Filtrage dual Échantillon-Test (STDF) : Un mécanisme novateur pour résoudre le problème selon lequel les cas de test générés par le LLM peuvent être invalides ou défectueux.
  • Filtrage par taux d'erreur : Supprime les cas de test qui provoquent des échecs d'exécution généralisés à travers la population d'échantillons.
  • Filtrage par diversité de sortie : Supprime les cas de test qui induisent une entropie sémantique élevée (indiquant un comportement indéfini ou des entrées invalides) tout en limitant le ratio de pruning pour éviter de rejeter des tests valides.
• Prise de décision : Les cas de test affinés sont utilisés pour regrouper les échantillons de code. La décision d'abstention est prise en appliquant les seuils calibrés aux scores de Rapport de cluster ou d'Entropie sémantique. Si les critères ne sont pas remplis, le modèle s'abstient.

Contributions clés

1. Formalisation de l'abstention de tâche : L'article introduit et formalise le concept d'abstention au niveau de la tâche dans la génération de code, le distinguant de la détection d'hallucination au niveau de l'échantillon.
2. Cadre à garanties théoriques : Il propose une méthode fondée sur les tests d'hypothèses multiples qui fournit une garantie rigoureuse et sans distribution selon laquelle le risque d'accepter une « mauvaise » tâche est contrôlé en dessous d'un seuil spécifié.
3. Évaluation basée sur l'exécution avec STDF : Les auteurs introduisent un schéma de notation basé sur les résultats d'exécution à l'exécution et un mécanisme de Filtrage dual Échantillon-Test (STDF). Cela permet au système de fonctionner sans dépendre de cas de test oracle pendant la phase de test, tout en atténuant le bruit introduit par les tests générés par le modèle.
4. Dépendance minimale aux oracles : L'approche ne nécessite des cas de test oracle que pendant la phase de calibration, la rendant pratique pour le déploiement où des tests de vérité terrain ne sont pas disponibles pour chaque nouvelle tâche.

Résultats expérimentaux

Les auteurs ont évalué CODEREFUSER sur les benchmarks HumanEval et MBPP en utilisant quatre LLM de code open-source (DeepSeek-Coder, Qwen2.5-Coder, CodeLlama et WizardCoder).

• Performance : CODEREFUSER a nettement surpassé les bases de référence existantes, y compris les méthodes statiques (PPL, NLI, CLM) et les détecteurs basés sur l'exécution (CodeHalu, Execution). En moyenne, il a obtenu une amélioration absolue de 26,5 % de la précision d'abstention par rapport au meilleur concurrent existant.
• Statique vs Exécution : Les expériences ont démontré que les méthodes statiques (même avec des tailles d'échantillons quadruplées) n'ont pas réussi à égaler les performances des méthodes basées sur l'exécution, confirmant que l'exécution du code est nécessaire pour une estimation précise du risque dans ce domaine.
• Transférabilité : La méthode a montré une transférabilité robuste, maintenant des performances élevées lorsque la calibration a été effectuée sur MBPP et les tests sur HumanEval, malgré le décalage de distribution.
• Contrôle du risque : Les résultats empiriques ont confirmé les garanties théoriques, montrant que le risque d'admission a été contrôlé avec succès en dessous de la tolérance cible $\alpha$ dans plus de 90 % des cas. De plus, CODEREFUSER a atteint ce contrôle du risque avec un taux d'abstention significativement plus faible (refusant moins de tâches valides) par rapport aux méthodes de base comme PPL.

Importance et revendications

L'article revendique représenter une avancée vers la génération de code par LLM prouvée correcte. En permettant aux modèles de dire avec confiance « Je ne sais pas » pour les tâches qu'ils sont peu susceptibles de résoudre, l'approche fournit un mécanisme fiable pour une génération de code plus sûre et plus robuste.

Les auteurs reconnaissent modestement les limites :

• Décalage de distribution : La garantie théorique repose sur l'hypothèse que les données de calibration et de test sont indépendantes et identiquement distribuées (i.i.d.). Bien que les expériences montrent une robustesse face à des décalages modérés, des déviations extrêmes du monde réel pourraient affaiblir les garanties.
• Déterminisme : La méthode suppose que les tâches ont des solutions déterministes. Elle peut ne pas s'appliquer directement aux systèmes logiciels non déterministes ou interactifs.
• Portée linguistique : L'évaluation actuelle est limitée au Python ; l'efficacité dans d'autres langues (par exemple, C, Java) avec des caractéristiques de mémoire ou de pointeurs différentes nécessite une évaluation ultérieure.

Le travail ne propose pas de nouvelles applications, mais plutôt une couche de sécurité fondamentale qui peut être intégrée dans les flux de travail existants de génération de code pour atténuer le risque d'hallucination.