💬 NLP

Evaluating and Achieving Controllable Code Completion in Code LLM

Cet article introduit le Controllable Code Completion Benchmark (C3-Bench) pour remédier au manque d'évaluation du respect des instructions dans les LLM de code, révèle des écarts de performance significatifs entre les modèles open-source et propriétaires, et propose un pipeline de synthèse de données permettant à un modèle affiné d'atteindre des résultats de pointe sur le nouveau benchmark.

Auteurs originaux : Jiajun Zhang, Zeyu Cui, Lei Zhang, Jian Yang, Jiaxi Yang, Qiang Liu, Zilei Wang, Binyuan Hui, Liang Wang, Junyang Lin

Publié 2026-01-23

📖 5 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : Jiajun Zhang, Zeyu Cui, Lei Zhang, Jian Yang, Jiaxi Yang, Qiang Liu, Zilei Wang, Binyuan Hui, Liang Wang, Junyang Lin

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

Imaginez que vous êtes un chef étoilé (l'IA) travaillant dans une cuisine très occupée. Pendant longtemps, la façon de tester ces chefs était simple : nous leur donnions un plat à moitié cuit (le code avant la partie manquante) et un autre plat à moitié cuit après lui (le code après la partie manquante), et nous leur demandions de remplir le milieu. Si le plat final avait bon goût (passait les tests unitaires), le chef recevait une étoile d'or.

Le Problème : La « Recette » Manquait
Les auteurs de cet article soutiennent que cette ancienne façon de tester est défectueuse. Dans le monde réel, un chef de cuisine ne se contente pas de dire : « Remplis le milieu ». Il dit : « Remplis le milieu, mais utilise uniquement des ingrédients végétariens », ou « Remplis le milieu, mais fais en sorte qu'il fasse exactement trois lignes de long », ou encore « Remplis le milieu, mais utilise un type de couteau spécifique ».

Les modèles d'IA actuels sont excellents pour faire en sorte que le plat ait bon goût, mais ils ignorent souvent les instructions spécifiques sur la manière de le préparer. Ils pourraient utiliser de la viande alors que vous avez demandé des légumes, ou écrire un paragraphe alors que vous avez demandé une seule ligne. Les anciens tests ne l'ont pas détecté car ils ne vérifiaient que si la nourriture était comestible, et non si le chef avait écouté la commande.

La Solution : C3-Bench (Le test de « Suivi d'Instructions »)
Pour corriger cela, l'équipe a créé un nouveau test appelé C3-Bench (Controllable Code Completion Benchmark). Considérez cela comme une nouvelle compétition de cuisine, beaucoup plus stricte.

Au lieu de simplement demander une pièce de code manquante, chaque test de C3-Bench vient avec une instruction spécifique et détaillée. Ils ont divisé ces instructions en deux catégories principales :

Les instructions de « Comment faire » (Contrôle de l'implémentation) :
- Analogie : « Construisez un pont, mais vous devez utiliser une conception suspendue, et non une conception à poutres. »
- own L'IA doit écrire du code qui fonctionne et qui suit un style, un algorithme ou une structure spécifique. Par exemple, « Triez cette liste en utilisant une méthode de tri spécifique » ou « Gérez les erreurs de cette manière spécifique ».
Les instructions de « Taille » (Contrôle de l'échelle) :
- Analogie : « Écrivez une phrase qui fait exactement 10 mots », ou « Écrivez un paragraphe qui fait exactement 3 phrases ».
- L'IA doit générer du code qui respecte une limite de taille stricte, comme exactement 5 lignes de code, ni plus, ni moins.

Ce Qu'Ils Ont Découvert
L'équipe a testé plus de 40 modèles d'IA différents (tant des modèles gratuits et open-source que des modèles fermés et coûteux) sur ce nouveau test. Voici ce qu'ils ont découvert :

Les modèles Open-Source « Trop Confiants » : Sur les anciens tests, de nombreux modèles d'IA gratuits et open-source performaient aussi bien que les modèles haut de gamme, coûteux et fermés. Cependant, sur ce nouveau test C3-Bench, ils ont énormément peiné. Il s'avère qu'ils avaient « mémorisé » les anciens tests mais ne savaient pas réellement comment suivre des instructions complexes. Ils étaient comme des étudiants qui avaient mémorisé le corrigé mais qui ne savaient pas résoudre un nouveau problème avec une variante.
Le Fossé : Il existe un énorme fossé entre les modèles qui peuvent simplement « faire fonctionner le code » et les modèles qui peuvent « faire fonctionner le code exactement comme vous l'avez demandé ». Même certains des modèles les plus intelligents et les plus coûteux ont eu du mal avec les instructions de « Taille » (comme écrire exactement le bon nombre de lignes).
La Correction : Les auteurs n'ont pas seulement pointé le problème ; ils ont construit une solution. Ils ont créé un pipeline pour générer automatiquement des milliers de nouveaux exemples d'entraînement où une IA écrit du code et suit une instruction spécifique. Ils ont utilisé ces données pour entraîner une nouvelle version de leur modèle, appelée Qwen2.5-Coder-C3.
Le Résultat : Ce nouveau modèle est devenu le meilleur pour suivre les instructions dans la complétion de code, battant presque tout le monde sur le nouveau test tout en restant performant sur les anciens tests.

Ce Qu'il faut Retenir
Cet article introduit une nouvelle façon de mesurer les compétences de codage de l'IA qui compte réellement pour une utilisation dans le monde réel : L'IA sait-elle écouter ?

Ils ont découvert que de nombreux modèles d'IA actuels sont comme des musiciens talentueux qui jouent les bonnes notes mais ignorent les changements de tempo du chef d'orchestre. En créant ce nouveau benchmark et une méthode pour entraîner les modèles à mieux écouter, les auteurs aident les développeurs à construire des outils d'IA qui ne se contentent pas d'écrire du code, mais qui écrivent le bon code selon les besoins spécifiques et détaillés de l'utilisateur. Ils ont mis toutes leurs données et leurs modèles à disposition des autres pour les utiliser et les améliorer.

Résumé technique : C3-Bench : Évaluer et réaliser la complétion de code contrôlable dans les LLM de code

Énoncé du problème

Bien que les grands modèles de langage (LLM) aient considérablement fait progresser les capacités de complétion de code, les méthodologies d'évaluation actuelles restent insuffisantes pour les scénarios réels de génie logiciel. Les benchmarks traditionnels (ex. : HumanEval, CrossCodeEval, SAFIM) évaluent principalement la correctitude fonctionnelle du code généré en fonction du contexte, en s'appuyant souvent sur des tests unitaires ou des mesures de similitude. Cependant, ils négligent largement un aspect critique de la programmation assistée par LLM : la capacité du modèle à suivre des instructions utilisateur fines lors du processus de complétion. Dans le développement réel, les développeurs exigent fréquemment que les modèles génèrent du code qui soit non seulement fonctionnellement correct, mais qui respecte également des contraintes d'implémentation spécifiques, des exigences structurelles ou des limitations de portée. L'absence de benchmarks évaluant rigoureusement cette capacité de « suivi d'instructions » dans la complétion de code crée un fossé entre la performance des benchmarks et l'utilité pratique.

Méthodologie

1. Définition de la Complétion de Code Contrôlable (C3)

Les auteurs introduisent le concept de Complétion de Code Contrôlable (CCC), étendant le tuple traditionnel $(P, S, G, T)$ (Préfixe, Suffixe, Vérité de terrain, Test unitaire) pour inclure $I$ (Instruction Fine-Grained). La tâche exige que le modèle génère un code intermédiaire $G$ tel que $M(P, S, I) \rightarrow G$ , satisfaisant à la fois la correctitude fonctionnelle (vérifiée par $T$ ) et l'adhérence à l'instruction (alignement avec $I$ ).

2. Construction de C3-Bench

Le Controllable Code Completion Benchmark (C3-Bench) comprend 2 195 tâches Python de haute qualité dérivées de HumanEval et SAFIM, enrichies par un pipeline de synthèse en quatre étapes :

Extraction de code intermédiaire : Utilisation d'arbres de syntaxe abstraite (AST) pour extraire des blocs de code logiquement complets et masquer des nœuds pour créer divers segments intermédiaires.
Génération d'implémentations équivalentes : Génération de multiples implémentations fonctionnellement équivalentes pour le même contexte afin de tester l'adhérence aux instructions.
Filtrage des données : Garantie de la lisibilité du code (PEP8), d'une longueur appropriée et d'une diversité d'implémentation significative.
Génération d'instructions :
- Complétion par contrôle d'implémentation (ICC) : Tâches exigeant des stratégies d'implémentation spécifiques (ex. : approches algorithmiques, flux de contrôle, structures de données). Comprend 1 286 instances avec tests unitaires.
- Complétion par contrôle d'échelle (SCC) : Tâches exigeant la génération de code dans des limites de portée précises (ex. : nombre de lignes spécifique, blocs d'instructions). Comprend 909 instances sans tests unitaires, se concentrant sur la conformité structurelle.

3. Métriques d'évaluation

Pass@1 : Mesure la correctitude fonctionnelle via les tests unitaires (ICC uniquement).
Taux de suivi d'instructions (IF) : Mesure l'adhérence à des exigences spécifiques, évaluée uniquement sur les cas fonctionnellement corrects.
Similitude d'édition (ES) : Une métrique d'analyse statique pour la validation préliminaire de la qualité.
Jugement automatisé : Un système basé sur un LLM (utilisant Claude3.5-Sonnet) valide l'adhérence aux instructions avec un accord de 98 % par rapport aux experts humains.

4. Entraînement du modèle (Qwen2.5-Coder-C3)

Pour remédier à la rareté des données d'entraînement pour la complétion par instruction, les auteurs ont développé un pipeline de synthèse automatisé :

Génération de graines (Seeds) : Utilisation de Claude3.5-Sonnet pour créer 1 000 paires de graines de haute qualité.
Synthèse à grande échelle : Utilisation de Qwen2.5-Coder-32B-Instruct pour générer 200 000 paires instruction-complétion à partir de dépôts GitHub.
Affinage (Fine-Tuning) : Application d'un apprentissage supervisé (SFT) sur les variantes Qwen2.5-Coder-1.5B et 32B en utilisant les données synthétisées, aboutissant à Qwen2.5-Coder-C3.

Résultats Clés

1. Écarts de performance dans le suivi d'instructions

Les évaluations exhaustives de plus de 40 LLM mainstream (open-source et propriétaires) révèlent des limitations significatives :

Open-Source vs Propriétaire : Bien que les modèles open-source égalent ou dépassent souvent les modèles propriétaires sur les benchmarks de correctitude fonctionnelle traditionnels (ex. : CrossCodeEval, RepoEval), ils présentent un écart de performance substantiel dans les capacités de suivi d'instructions sur C3-Bench.
Sensibilité aux instructions : Le retrait des instructions des prompts entraîne une chute significative des taux IF, tandis que le Pass@1 reste largement inchangé, confirmant que les modèles actuels ne priorisent pas intrinsèquement l'adhérence aux instructions sur la génération fonctionnelle.
Défis de contrôle d'échelle : Les modèles éprouvent des difficultés particulières avec les tâches de Complétion par Contrôle d'Échelle (SCC), indiquant des limitations dans les objectifs d'entraînement concernant les contraintes de portée de code.

2. Efficacité du C3-Tuning

Le modèle Qwen2.5-Coder-C3 atteint des performances de pointe (SOTA) sur C3-Bench :

Il démontre des améliorations substantielles des taux IF par rapport à son homologue de base ajusté par instruction (ex. : +23,7 % d'IF sur l'ICC pour le modèle 32B).
Il surpasse les modèles propriétaires de pointe (ex. : GPT-4o, série o1) dans les tâches de contrôle d'échelle tout en maintenant des performances compétitives sur les benchmarks conventionnels.
Les résultats suggèrent que les modèles open-source peuvent faire du surapprentissage (overfitting) sur les benchmarks fonctionnels existants et manquer de généralisation dans les scénarios contrôlables, mais cela peut être remédié par une synthèse de données ciblée.

3. Corrélation avec les capacités avancées

Le classement des modèles sur C3-Bench montre de fortes corrélations avec les performances sur les tâches nécessitant une compréhension étendue du contexte (ExecRepoBench) et l'évaluation des préférences humaines (Chatbot Arena-Coding), suggérant que la capacité de suivi d'instructions est un indicateur (proxy) d'une compréhension plus large du code.

Signification et Revendications

L'article affirme que C3-Bench constitue le premier benchmark guidé par instruction pour la complétion de code, adressant un angle mort critique dans les paysages d'évaluation actuels. Sa signification réside dans :

Révéler une surestimation systématique : Démontrer que les benchmarks existants surestiment systématiquement les capacités des modèles dans les scénarios de développement réels, riches en instructions.
Combler le fossé : Identifier que les LLM de code open-source, malgré une forte performance fonctionnelle, accusent un retard par rapport aux modèles propriétaires en matière d'adhérence aux instructions, un écart qui peut être comblé par la synthèse de données ciblée.
Avancer le développement Open-Source : Fournir un pipeline simple et reproductible pour synthétiser des données de complétion par instruction, permettant à la communauté d'améliorer les modèles open-source sans dépendre de données propriétaires.

Les auteurs concluent que les recherches futures doivent donner la priorité aux capacités de suivi d'instructions dans les LLM de code pour garantir leur fiabilité et leur contrôlabilité dans les applications de génie logiciel du monde réel. Tout le code, les jeux de données et les modèles sont en open-source pour faciliter la recherche ultérieure.