🤖 AI

Self-Improving Code Generation via Semantic Entropy and Behavioral Consensus

Ce papier présente ConSelf, une méthode d'auto-amélioration pour les modèles de langage générant du code qui, sans recourir à des enseignants supérieurs ni à des oracles de test, utilise l'entropie sémantique pour construire un curriculum d'apprentissage et l'optimisation directe par préférence guidée par le consensus pour affiner le modèle.

Auteurs originaux : Huan Zhang, Wei Cheng, Wei Hu

Publié 2026-04-01

📖 5 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : Huan Zhang, Wei Cheng, Wei Hu

Article original sous licence CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Ceci est une explication générée par l'IA de l'article ci-dessous. Elle n'a pas été rédigée ni approuvée par les auteurs. Pour une précision technique, consultez l'article original. Lire la clause de non-responsabilité complète

Imagine que vous essayez d'apprendre à un robot à coder, mais vous n'avez pas de professeur pour lui donner les bonnes réponses, et vous n'avez pas de correcteur pour vérifier si son code fonctionne. C'est un peu comme essayer d'apprendre à nager en étant seul au milieu de l'océan, sans savoir si vous faites le bon mouvement ou si vous coulez.

C'est exactement le défi que relève l'article ConSelf. Les chercheurs de l'Université de Nanjing ont créé une méthode pour que le robot s'améliore tout seul, en utilisant une astuce intelligente basée sur deux concepts clés : l'entropie sémantique (le chaos des comportements) et le consensus (l'accord de la majorité).

Voici comment cela fonctionne, expliqué avec des images simples :

1. Le Problème : Apprendre dans le bruit

D'habitude, pour apprendre, on montre à l'IA des exercices avec la solution. Ici, l'IA doit générer elle-même ses propres exercices et solutions.

Le piège : Parfois, l'IA est tellement perdue sur un problème difficile qu'elle invente 10 solutions différentes, mais toutes sont fausses. Si on lui fait apprendre sur ces erreurs, elle va juste apprendre à faire des erreurs de plus en plus bizarres. C'est comme essayer d'apprendre l'histoire en lisant des livres écrits par des gens qui ne savent pas lire.

2. La Solution : La Méthode ConSelf

L'équipe propose une stratégie en deux étapes, comme un chef d'orchestre qui sélectionne les musiciens et dirige l'entraînement.

Étape A : Choisir quoi apprendre (L'Entropie Sémantique)

Imaginez que vous demandez à 100 élèves de résoudre une énigme.

Cas 1 (Problème trop facile) : Tout le monde donne la même réponse correcte. Pas besoin d'apprendre, ils savent déjà.
Cas 2 (Problème trop dur) : Tout le monde donne une réponse différente et n'importe quoi. C'est le chaos total. Si vous essayez d'apprendre ici, vous ne comprenez rien.
Cas 3 (Le juste milieu) : La plupart des élèves donnent une réponse similaire, mais quelques-uns se trompent. C'est là qu'il y a de l'apprentissage !

Le ConSelf utilise une mesure appelée "Entropie Sémantique".

Au lieu de regarder ce que l'IA pense (ce qui peut être trompeur), il regarde ce que l'IA fait.
Il fait exécuter toutes les solutions générées par le robot sur des tests.
Si les résultats sont tous différents (chaos), le robot se dit : "C'est trop dur, je ne sais pas faire, je ne vais pas apprendre ici."
Si les résultats sont tous identiques (trop facile ou échec total), il dit : "Je sais déjà faire ou je suis bloqué, inutile de travailler."
Il ne garde que les problèmes où il y a un désaccord modéré : c'est là que l'apprentissage est possible. C'est comme trier les exercices pour ne garder que ceux qui sont "à votre niveau".

Étape B : Apprendre comment apprendre (Le Consensus)

Une fois que le robot a sélectionné les bons problèmes, il doit apprendre de ses propres erreurs. Mais attention : même sur un bon problème, il peut générer une solution "gagnante" qui est en fait fausse.

C'est là qu'intervient le Consensus.

Imaginez un jury de 100 personnes. Si 95 personnes disent "La réponse A est bonne" et 5 disent "La réponse B est bonne", il y a un fort consensus pour la réponse A.
Le ConSelf dit : "Je vais faire confiance à la réponse A, car beaucoup de mes 'versions' sont d'accord. Je vais apprendre de cette réponse avec confiance."
Si le jury est divisé (50 pour A, 50 pour B), le système dit : "Je ne suis pas sûr, je vais apprendre doucement, sans trop me fier à cette réponse."

C'est comme si le robot se disait : "Si tout le monde dans ma tête est d'accord, c'est probablement vrai. S'ils se battent tous, je dois être prudent."

En résumé : Pourquoi c'est génial ?

Pas besoin de professeur : Le robot n'a pas besoin d'un humain ou d'une IA plus intelligente pour lui donner les réponses. Il utilise ses propres tentatives.
Pas besoin de correcteur parfait : Il n'a pas besoin de savoir si la réponse est vraiment juste, il regarde juste si les réponses sont similaires entre elles.
Économie d'énergie : Au lieu d'essayer d'apprendre de tout (ce qui est du gaspillage), il se concentre uniquement sur les problèmes où il peut progresser.

L'analogie finale :
C'est comme un apprenti cuisinier qui veut devenir chef sans maître.

Il cuisine 100 plats différents pour le même ingrédient.
Il goûte tous les plats. S'ils ont tous un goût horrible et différent, il jette l'ingrédient (trop dur). S'ils ont tous le même goût parfait, il passe à autre chose (déjà maîtrisé).
Il garde seulement les plats où 9 cuisiniers sur 10 ont fait un bon plat, et un seul a fait une erreur.
Il apprend de ce groupe majoritaire, en se disant : "Puisque la majorité a réussi, c'est probablement la bonne méthode."

Grâce à cette méthode, les modèles de langage (les robots) deviennent beaucoup plus performants pour écrire du code, même sans aide extérieure, en apprenant à distinguer le chaos de la vraie compétence.

1. Problématique et Contexte

L'amélioration des capacités de génération de code des grands modèles de langage (LLM) repose traditionnellement sur le fine-tuning supervisé (SFT) ou l'optimisation par préférence (DPO). Ces méthodes nécessitent généralement deux ressources coûteuses et souvent indisponibles dans des scénarios réalistes :

Un modèle enseignant supérieur (teacher model) pour générer des solutions de référence.
Des oracles de test fiables (résultats attendus pour les cas de test) pour valider la correction fonctionnelle du code généré.

Dans la pratique, il est facile d'obtenir des descriptions de problèmes et des entrées de test, mais très difficile d'obtenir des solutions de référence et des oracles corrects (le "problème de l'oracle de test"). De plus, dans un cadre non supervisé (sans oracle), l'apprentissage automatique sur des données générées par le modèle lui-même pose un risque majeur : le modèle peut générer des solutions erronées et bruyantes. Si toutes les solutions générées pour un problème donné sont fausses, tout apprentissage basé sur ces données dégrade les performances plutôt que de les améliorer (phénomène de "noisy data").

Question de recherche : Un modèle de langage de code peut-il s'améliorer lui-même sans accès à un modèle enseignant supérieur ni à des oracles de test, en utilisant uniquement les descriptions de problèmes et les entrées de test ?

2. Méthodologie : ConSelf

Les auteurs proposent ConSelf, une approche d'auto-amélioration guidée par le consensus, structurée autour de deux piliers : "Quoi apprendre ?" (sélection des problèmes) et "Comment apprendre ?" (optimisation robuste).

A. Échantillonnage guidé par l'observation

Pour garantir la diversité des candidats, le modèle génère d'abord un ensemble d'observations textuelles (définitions, pièges, stratégies) pour chaque problème. Ces observations servent de conditions pour générer ensuite plusieurs programmes candidats ( $K$ échantillons) par échantillonnage à haute température. Cela crée un pool de solutions diversifié nécessaire à l'analyse comportementale.

B. "Quoi apprendre ?" : Entropie Sémantique du Code et Curriculums

Pour identifier les problèmes "apprenables" (ni trop faciles, ni trop difficiles), les auteurs introduisent une nouvelle métrique : l'Entropie Sémantique du Code (Code Semantic Entropy).

Principe : Contrairement aux métriques de confiance internes (entropie des tokens, vraisemblance négative) qui mesurent l'incertitude linguistique, l'entropie sémantique mesure l'incertitude fonctionnelle.
Calcul :
1. Exécution de tous les programmes candidats sur les entrées de test disponibles.
2. Regroupement des candidats par comportement d'exécution identique (clusters comportementaux).
3. Calcul de l'entropie de Shannon sur la distribution de ces clusters.
Interprétation :
- Une entropie élevée indique une grande divergence comportementale (les candidats produisent des résultats différents), suggérant que le problème est trop difficile ou que le modèle est confus (bruit élevé).
- Une entropie nulle indique que tous les candidats se comportent de manière identique (soit tous corrects, soit tous échouant de la même manière), offrant peu de signal d'apprentissage.
Filtrage : Un curriculum est construit en ne conservant que les problèmes dont l'entropie normalisée se situe dans une plage intermédiaire ( $0 < H_{norm} < \tau$ ), éliminant ainsi les problèmes triviaux et les problèmes inaccessibles.

C. "Comment apprendre ?" : Optimisation par Préférence Guidée par le Consensus (Con-DPO)

Même après filtrage, les données générées contiennent du bruit. Les auteurs proposent Con-DPO (Consensus-driven Direct Preference Optimization) pour atténuer l'impact des paires de préférences erronées.

Score de Consensus : Chaque candidat reçoit un score $R(c)$ basé sur la fréquence de son comportement d'exécution par rapport aux autres candidats. Un comportement partagé par de nombreux candidats indépendants est considéré comme plus fiable.
Construction des paires : Pour chaque problème, le candidat avec le score de consensus le plus élevé est désigné comme "gagnant" ( $y_w$ ) et les autres comme "perdants" ( $y_l$ ).
Objectif pondéré : La fonction de perte DPO standard est modifiée pour pondérer chaque paire par le score de consensus du gagnant :
$\mathcal{L}_{Con-DPO} = -\mathbb{E} [ R(y_w) \cdot \log \sigma(\hat{r}(y_w, y_l)) ]$
Cela permet au modèle d'apprendre agressivement des paires fiables (haut consensus) et prudemment des paires incertaines, réduisant le risque de surapprentissage sur des signaux erronés.

3. Contributions Clés

Entropie Sémantique du Code : Une métrique novatrice pour estimer l'incertitude épistémique d'un modèle sur un problème en se basant sur le comportement d'exécution observable, surpassant les métriques de confiance internes.
Approche ConSelf : Une stratégie d'apprentissage dual combinant un filtrage de curriculum basé sur l'entropie et une optimisation par préférence pondérée par le consensus.
Validation Empirique : Démonstration que l'auto-amélioration est possible sans oracles de test ni modèles enseignants, en utilisant uniquement des entrées de test.

4. Résultats Expérimentaux

Les expériences ont été menées sur trois modèles de base (CodeLlama-7B, DeepSeek-Coder-6.7B, Qwen2.5-Coder-7B) et quatre benchmarks (HumanEval, MBPP, EvalPlus, LiveCodeBench).

Performance Globale : ConSelf améliore significativement les performances par rapport aux modèles de base et aux méthodes de référence (Self-SFT, Self-DPO, PFPO).
- Améliorations relatives moyennes : +3,30 % (CodeLlama), +2,73 % (DeepSeek), +3,95 % (Qwen).
- Les méthodes de base non filtrées (Self-SFT, Self-DPO) dégradent souvent les performances, confirmant la nécessité du filtrage.
Efficacité des Données : ConSelf utilise beaucoup moins de données d'entraînement (en filtrant les problèmes inutiles) tout en obtenant de meilleurs résultats. Par exemple, sur DeepSeek-Coder, il utilise ~6 372 exemples contre ~46 000 pour Self-DPO.
Analyse de l'Entropie : L'entropie sémantique du code montre une corrélation négative forte avec le taux de réussite (pass rate) et une capacité de discrimination (AUC) bien supérieure aux métriques internes (entropie des tokens, NLL) ou à l'entropie sémantique "naïve" (basée sur le texte).
Étude Ablative :
- La suppression du filtrage de curriculum (w/o CC) entraîne la plus forte baisse de performance, prouvant que la sélection des problèmes est plus critique que l'algorithme d'apprentissage lui-même.
- La suppression du poids de consensus (w/o CW) réduit également les performances, confirmant l'utilité de la pondération pour gérer le bruit résiduel.

5. Signification et Impact

Ce travail démontre qu'il est possible de briser la dépendance aux modèles enseignants propriétaires et aux oracles de test coûteux pour l'amélioration des LLMs de code.

Changement de paradigme : Il passe d'une estimation d'incertitude basée sur la "confiance interne" du modèle à une estimation basée sur le comportement fonctionnel observable.
Robustesse : La méthode est applicable même aux modèles "boîte noire" (via API) où les logits internes ne sont pas accessibles.
Principe d'apprentissage : Il établit que pour l'auto-amélioration non supervisée, la qualité du curriculum (sélection des problèmes de difficulté appropriée) est le facteur déterminant, plus que l'algorithme d'optimisation.

En conclusion, ConSelf offre une voie viable et efficace pour l'amélioration continue des modèles de code dans des environnements réalistes où les données de supervision de haute qualité sont rares ou inexistantes.