Résumé Technique : Préentraînement de Code Contextualisé pour la Génération de Code

1. Énoncé du Problème

Les modèles modernes de génération de code sont principalement entraînés et évalués sur des fonctions isolées accompagnées de descriptions en langage naturel (par exemple, HumanEval, MBPP). Cependant, dans le développement logiciel réel, les fonctions sont rarement implémentées de manière isolée. Les développeurs écrivent généralement d'abord une logique de contrôle de haut niveau, qui invoque ensuite des fonctions utilitaires de bas niveau qui n'ont pas encore été implémentées. Dans ces scénarios, le contexte d'appel (le code qui invoque la fonction cible) fournit des indices exploitables sur le comportement attendu, les formes de données et les exigences de gestion des erreurs, qui sont souvent absents des descriptions en langage naturel ou des signatures de fonction.

Les approches existantes pour la génération de code au niveau du dépôt reposent principalement sur la récupération au moment de l'inférence (par exemple, RepoCoder, GraphCoder) pour récupérer le contexte pertinent. Ces méthodes traitent le contexte comme une ressource externe à récupérer et à ajouter aux invites. Elles rencontrent des limitations lorsque :

1. Aucun extrait de code similaire n'existe dans le dépôt (fonctionnalité nouvelle).
2. La récupération échoue à mettre en évidence le contexte correct en raison de problèmes d'indexation ou de classement.
3. Le modèle n'est pas explicitement entraîné à interpréter et à exploiter les contraintes sémantiques imposées par l'appelant.

Par conséquent, les modèles actuels génèrent souvent du code qui satisfait une description fonctionnelle mais échoue à s'intégrer harmonieusement avec l'utilisation environnante, conduisant à des implémentations qui ne respectent pas les contrats implicites établis par l'appelant.

2. Méthodologie

Les auteurs proposent le Préentraînement de Code Contextualisé, un cadre conscient de l'invoction qui intègre le contexte d'appel directement dans l'objectif de préentraînement des modèles de code. L'approche se compose de trois composants principaux :

A. Construction de Jeu de Données Conscient de l'Invoction

Les auteurs ont développé un pipeline automatisé d'analyse statique pour extraire des paires appelant–appelé à grande échelle à partir de dépôts Python réels.

• Extraction : En utilisant le module ast de Python, le système analyse les fichiers sources pour construire un graphe d'appels bidirectionnel. Il identifie les fonctions cibles et extrait les corps complets de leurs appelants directs en tant que « contexte conscient de l'invoction ».
• Filtrage : Pour garantir la qualité, les auteurs ont filtré 800 dépôts en fonction de leur popularité, de leur état de maintenance et de leur diversité structurelle. Ils ont exclu les jeux de données algorithmiques, le code lié aux tests et les fonctions incomplètes.
• Construction : Le corpus final contient 235 460 fonctions cibles uniques. Chaque instance d'entraînement associe une fonction cible à son en-tête, un extrait de code d'un appelant direct et la docstring en langage naturel de la cible (si disponible). Si une fonction a plusieurs appelants, chaque paire appelant–appelé est traitée comme une instance d'entraînement distincte.

B. Objectif de Préentraînement (CallerGen)

Les auteurs introduisent CallerGen, une famille de modèles préentraînés avec un objectif conscient de l'invoction. La tâche d'entraînement conditionne la génération du corps de la fonction cible sur trois entrées :

1. L'en-tête de la fonction (signature).
2. L'extrait de code d'un appelant direct (le contexte d'appel).
3. La docstring en langage naturel.

Le modèle apprend à maximiser la vraisemblance de générer le corps de fonction correct étant donné ces indices contextuels. Cette approche a été appliquée à deux architectures :

• Encodeur-Décodeur : CodeT5-small (60M) et CodeT5-base (220M).
• Décodeur-seulement : Qwen2.5-Coder-0.5B.

C. Référence : CallerEval

Pour évaluer les modèles dans des conditions réalistes, les auteurs ont construit CallerEval, une nouvelle référence comportant 263 tâches de génération au niveau de la fonction.

• Conception : Les tâches sont tirées de dépôts distincts de l'ensemble d'entraînement pour éviter les fuites de données. Chaque tâche inclut la fonction cible, ses appelants réels et une suite de tests comportementaux.
• Construction des Tests : Comme de nombreuses fonctions cibles manquent de tests unitaires existants, les auteurs ont conçu un protocole pour reconstruire des tests comportementaux légers. Ces tests sont dérivés des modèles d'utilisation observés dans les appelants (par exemple, comment les valeurs de retour sont accessibles ou comment les exceptions sont gérées), garantissant que l'évaluation reflète le « contrat » imposé par l'appelant.
• Évaluation : La performance est mesurée à l'aide de Pass@k (correction fonctionnelle via exécution) et de métriques statiques (CodeBLEU, ROUGE-L).

3. Contributions Clés

1. Formalisation de la Tâche : L'article formalise la « génération de code avec contextes d'appel » comme un cadre de tâche distinct, soulignant que les contextes d'appel sont des signaux critiques pour guider l'implémentation dans des scénarios de développement réalistes.
2. Modèle CallerGen : Les premiers modèles de code préentraînés avec des objectifs conscients de l'invoction. CallerGen est le premier à conditionner explicitement la génération sur les contextes d'appel pendant la phase de préentraînement, plutôt que de se fier uniquement à la récupération au moment de l'inférence.
3. Référence CallerEval : Une nouvelle référence conçue pour évaluer les modèles dans des scénarios pilotés par l'appelant, comportant des paires appelant–appelé réalistes et des protocoles de test conscients du comportement qui vont au-delà des simples descriptions fonctionnelles.
4. Évaluation Complète : Des expériences extensives démontrant que l'entraînement conscient de l'invoction améliore les performances à travers différentes échelles et architectures de modèles, en particulier dans les scénarios où le contexte d'appel est disponible.

4. Résultats Expérimentaux

Les auteurs ont évalué CallerGen par rapport à neuf références de pointe (incluant CodeGen, PanGu-Coder, DeepSeek-Coder et Qwen-Coder) sur les deux références publiques CoderEval et la nouvelle CallerEval.

Performance dans les Paramètres avec Appelant Disponible

• CallerGen a systématiquement surpassé les références de taille similaire. Par exemple, CallerGen-base (220M) a obtenu 16,58 % de Pass@1 sur CallerEval avec des entrées complètes (En-tête + Appelant + NL), surpassant significativement CodeGen-350M (8,97 %) et PanGu-300M (11,79 %).
• CallerGen-qwen (0.5B) a obtenu 22,81 % de Pass@1 sur CallerEval, dépassant largement Qwen2.5-Coder-0.5B-Instruct (6,16 %) ajusté par instruction et réduisant l'écart avec des modèles beaucoup plus grands (par exemple, Qwen2.5-Coder-32B-Instruct à 20,99 %).
• Les modèles ont montré une plus grande robustesse ; la baisse de performance lors du passage de CoderEval (plus facile) à CallerEval (plus difficile) a été significativement plus faible pour CallerGen que pour les références.

Performance dans les Paramètres sans Appelant

• Même sans contexte d'appel (En-tête uniquement ou En-tête + NL), CallerGen est resté compétitif, égalant ou surpassant souvent des modèles de taille similaire. Par exemple, CallerGen-0.5B a obtenu 13,92 % de Pass@1 sur CallerEval (En-tête + NL), surpassant Qwen2.5-Coder-0.5B-Instruct (9,13 %).
• Cependant, les auteurs notent que tous les modèles ont subi une baisse de performance dans les paramètres sans appelant, soulignant que le contexte d'appel est un composant crucial pour une génération de haute qualité.

Ablation et Analyse

• Sémantique vs Longueur : Les études d'ablation ont révélé que les gains proviennent de preuves sémantiques (comment la valeur de retour est utilisée, le flux de contrôle autour de l'appel) plutôt que simplement d'une augmentation de la longueur de l'invite. Le remplacement du contexte de l'appelant par du code non pertinent de même longueur a entraîné une baisse de performance.
• Supervision Multi-Appelant : L'entraînement avec plusieurs appelants par fonction a amélioré la capacité du modèle à utiliser les preuves de l'appelant au moment de l'inférence, suggérant que le modèle apprend à concilier des contraintes d'utilisation diverses.

5. Signification et Revendications

L'article revendique que les contextes d'appel sont une source riche et fiable d'intention sémantique qui sont actuellement sous-utilisés dans la génération de code. En traitant le contexte d'appel comme un signal de conditionnement explicite pendant le préentraînement, les modèles peuvent apprendre à générer du code qui n'est pas seulement fonctionnellement correct, mais aussi cohérent comportementalement avec son environnement d'utilisation.

Les auteurs soutiennent que si la récupération au moment de l'inférence (augmenter les invites avec du contexte) est utile, elle est insuffisante si le modèle lui-même n'a pas appris à interpréter et à exploiter les contraintes d'invoction. CallerGen démontre que le préentraînement conscient de l'invoction permet aux modèles de :

1. Déduire des contrats comportementaux implicites à partir du code de l'appelant.
2. Générer des implémentations qui s'intègrent harmonieusement avec les bases de code existantes.
3. Atteindre des performances de pointe par rapport à leur taille de paramètres, surpassant souvent des modèles significativement plus grands.

Le travail conclut que l'intégration des contextes d'appel est essentielle pour faire progresser la génération de code vers des scénarios réalistes de développement logiciel au niveau du dépôt. Les auteurs reconnaissent des limites, notant que leur pipeline actuel est spécifique à Python et repose sur une analyse statique, ce qui peut rencontrer des défis avec des fonctionnalités dynamiques, mais ils postulent que le principe fondamental de la génération conditionnée par l'invoction est indépendant du langage.