Résumé technique : Effondrement de l'auto-entraînement récursif dans les LLM de code

1. Énoncé du problème

L'article étudie le risque d'effondrement par auto-entraînement récursif des grands modèles de langage (LLM) spécialisés dans le code. À mesure que les outils de codage par IA (par exemple, GitHub Copilot, Cursor) génèrent de plus en plus de code qui est fusionné dans des dépôts publics, les futurs corpus d'entraînement pourraient être composés en grande partie de code généré par l'IA. Si un modèle est affiné sur des données qu'il a lui-même générées précédemment, et que ces données sont ensuite utilisées pour entraîner l'itération suivante sans contrôle de qualité externe, le système entre dans une boucle d'« auto-consommation ».

Le problème central est que, sans données humaines fraîches ou signaux de qualité exogènes, cette boucle peut mener à un effondrement du modèle :

• Dérive distributionnelle : Le modèle apprend à imiter ses propres sorties précédentes plutôt que la distribution originale des données.
• Amplification des erreurs : Les bugs, la logique incomplète et l'étroitesse stylistique du code généré sont copiés et renforcés dans les générations suivantes.
• Perte de diversité : Le modèle converge vers des sorties à faible variance et de faible qualité, échouant à résoudre efficacement les tâches de programmation.

L'article contraste spécifiquement trois régimes d'entraînement récursif :

1. Sans revue (Non contrôlé) : Tout le code généré est réutilisé.
2. Revue par barrière humaine (Human-Gate) : Le code est filtré par des signaux indépendants du modèle (ex: compilation, analyse statique, tests d'exécution).
3. Revue par barrière d'IA (AI-Self-Gate) : Le LLM de code évalue et filtre ses propres sorties en utilisant des signaux internes (ex: perplexité, auto-notation binaire).

2. Méthodologie

Cadre théorique

Les auteurs formalisent l'entraînement récursif comme un repondérage de distribution à porte (gated distributional reweighting).

• Récursion non contrôlée : La distribution d'entraînement à l'itération $t$ est simplement la distribution de sortie du modèle $p_{\theta_t}(c|x)$. Le modèle suivant minimise la divergence KL par rapport à cette distribution, imposant uniquement la cohérence interne.
• Récursion à porte (Gated) : Un échantillon est accepté avec une probabilité $r(x, c)$. La distribution d'entraînement devient $q_{\theta_t}(c|x) \propto p_{\theta_t}(c|x)r(x, c)$.
• Analyse théorique :
  • Concentration spectrale : Les auteurs prouvent (Proposition 2.1) que le réentraînement récursif amplifie les directions de représentation dominantes tout en supprimant les autres, entraînant un effondrement de la matrice de covariance de l'espace de représentation (réduction du rang/de la diversité).
  • Dégénérescence de l'auto-filtrage par l'IA : L'article prouve (Théorème 2.3) que si un réviseur IA est couplé au générateur (partageant les mêmes paramètres ou la même distribution) et que le réviseur devient « auto-confirmateur » (attribuant des scores élevés aux sorties probables du générateur quel que soit leur niveau de qualité), le mécanisme de filtrage dégénère mathématiquement en un auto-entraînement non contrôlé. Dans ce régime de « tampon de caoutchouc » (rubber-stamp), le filtre perd sa capacité à rejeter les sorties dégradées.
  • Condition de stabilité : L'entraînement par IA avec porte ne permet d'éviter l'effondrement que si le réviseur IA reste calibré sur un standard humain exogène (Théorème 2.6).

Protocole expérimental

• Modèles : Quatre familles de LLM de code ont été testées : SantaCoder (1.1B), StarCoder2-3B, Qwen2.5-Coder-1.5B et Code Llama-7B.
• Benchmarks : HumanEval, MBPP, LiveCodeBench, ainsi que leurs versions augmentées (HumanEval+, MBPP+).
• Protocole : Affinement récursif sur 5 cycles. À chaque cycle, le modèle génère du code, une stratégie de filtrage sélectionne 5 000 échantillons, et le modèle est affiné sur cet ensemble pendant 3 000 étapes.
• Stratégies de filtrage :
  • Vanilla : Aucun filtre.
  • Portes Humaines (Human Gates) : Compile (vérification syntaxique), Quality (métriques statiques comme la répétition/longueur), Compile+Quality.
  • Auto-portes d'IA (AI Self-Gates) : Perplexity (les 25 % les moins probables selon la vraisemblance du modèle), Binary Classifier (les 25 % supérieurs selon le score de différence de logit).

3. Résultats clés

Dégradation universelle

À travers toutes les familles de modèles et toutes les stratégies de filtrage, l'auto-entraînement récursif entraîne une dégradation des performances par rapport à la ligne de base de pré-entraînement.

• Sans revue : S'effondre le plus rapidement et le plus sévèrement. Par exemple, Qwen2.5-Coder est passé d'une base de 0,372 sur HumanEval+ à 0,043 (−88,4 %) au cycle 5.
• Portes Humaines : Ralentissent le taux d'effondrement mais ne l'arrêtent pas. Bien que les filtres Compile et Quality préservent la validité de l'exécution et retardent la dérive sémantique, ils ne peuvent empêcher la dégradation à long terme.
• Auto-portes d'IA : Présentent un mode de défaillance par « tampon de caoutchouc ». Initialement, elles peuvent sélectionner des échantillons performants (le Binary Classifier a obtenu le meilleur score HumanEval+ au cycle 5 pour trois modèles), mais l'efficacité de leur filtrage se dégrade avec le temps.
  • Divergence des métriques : Une découverte critique est la divergence entre le signal interne du filtre et la correction réelle. Pour le Binary Classifier, les scores d'acceptation (la confiance du modèle dans son propre code) ont augmenté alors que la justesse sur les benchmarks chutait. Cela confirme la prédiction théorique que l'auto-porte devient auto-confirmatrice.

Cohérence entre modèles

Le phénomène d'effondrement n'est pas spécifique à une architecture donnée.

• LiveCodeBench : Tous les modèles approchent un pass@1 proche de zéro sur ce benchmark hors distribution au cycle 5 sous un entraînement vanilla, indiquant que l'auto-entraînement récursif dégrade de manière disproportionnée les capacités de raisonnement complexe.
• Magnitude de l'effondrement : Les modèles possédant des distributions initiales plus fortes (ex: Qwen2.5-Coder) ont montré des dérives distributionnelles plus brusques lorsqu'ils étaient contaminés par leurs propres sorties, bien que tous les modèles aient fini par converger vers un « attracteur d'effondrement » de faible performance.

Taux de passage des filtres

• Portes Humaines : Maintiennent des taux de passage stables (ex: Compile reste élevé car il repose sur une exécution externe).
• Auto-portes d'IA : Montrent des taux de passage croissants au fil des cycles (ex: le taux de passage de la Perplexity est passé d'environ 0,17 à 0,24), indiquant une perte de pouvoir discriminant à mesure que la distribution de score interne du modèle dérive avec sa distribution de génération dégradée.

4. Contributions

1. Étude empirique de l'effondrement des LLM de code : Fournit une évaluation systématique de l'auto-entraînement récursif à travers cinq régimes de filtrage et quatre familles distinctes de LLM de code, démontrant que l'effondrement est un phénomène transversal aux modèles.
2. Formulation de la revue comme repondérage à porte : Cadre théoriquement la revue de code comme un mécanisme de repondérage d'échantillonnage, expliquant pourquoi les portes exogènes ralentissent l'effondrement tandis que les portes endogènes échouent.
3. Identification de l'exogénéité comme facteur clé : Établit que la différence critique entre un entraînement récursif réussi et un échec réside dans le fait que la règle d'acceptation est exogène (fixe, indépendante du modèle) ou endogène (couplée au générateur).
4. Preuve théorique de la dégénérescence : Prouve que l'auto-filtrage par l'IA dégénère en un auto-entraînement non contrôlé sous des conditions d'auto-confirmation et fournit une analyse spectrale montrant comment le réentraînement récursif concentre la variance de représentation dans un sous-espace de faible dimension.

5. Signification et affirmations

L'article soutient qu'un entraînement stable des LLM de code récursifs nécessite une vérification exogène plutôt qu'une auto-revue couplée au modèle.

• Limitation de la revue par l'IA : L'étude suggère que compter sur des systèmes d'IA pour réviser leur propre code pour de futurs entraînements est intrinsèquement instable. À mesure que le générateur se dégrade, les critères du réviseur dérivent, finissant par accepter des sorties dégradées comme étant de haute qualité (le régime du « tampon de caoutchouc »).
• Rôle des portes humaines : Bien que les portes humaines (compilation, analyse statique) soient plus robustes et préservent la validité de l'exécution, elles sont insuffisantes pour stopper totalement la dérive sémantique à long terme. Elles agissent comme un frein, pas comme un remède.
• Implication pour les systèmes futurs : Ces conclusions mettent en garde contre la boucle d'« auto-consommation » où le code généré par l'IA entre dans les dépôts et est immédiatement utilisé pour entraîner la génération suivante de modèles sans données humaines fraîches ou signaux externes forts. L'article conclut que pour éviter l'effondrement, le signal de vérification doit rester en dehors de la distribution de préférence du modèle lui-même.

Les auteurs restent modestes, notant que leurs expériences se sont concentrées sur Python et des modèles allant jusqu'à 7 milliards de paramètres, et que les horizons plus longs, les modèles plus grands et les portes basées sur l'exécution plus puissantes restent des domaines de recherche ouverts.