💬 NLP

Function-Aware Fill-in-the-Middle as Mid-Training for Coding Agent Foundation Models

Ce document introduit le pré-entraînement de type « fill-in-the-middle » (FIM) sensible aux fonctions, une approche auto-supervisée qui exploite la similitude structurelle entre les boucles d'agents de codage et les appels de fonctions pour augmenter considérablement les performances des agents de codage sur des benchmarks tels que SWE-Bench, tout en préservant simultanément les capacités générales de codage et d'utilisation d'outils souvent dégradées par le post-entraînement standard.

Auteurs originaux : Yubo Wang, Jiarong Liang, Yuxuan Zhang, Xuye Liu, Cong Wei, Yuyu Zhang, Ping Nie, Wenhu Chen

Publié 2026-07-15

📖 6 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : Yubo Wang, Jiarong Liang, Yuxuan Zhang, Xuye Liu, Cong Wei, Yuyu Zhang, Ping Nie, Wenhu Chen

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 enseigniez à un robot comment corriger des bugs dans une immense et désordonnée bibliothèque de code. Habituellement, nous enseignons ces robots en les laissant lire des livres du début à la fin, de gauche à droite. Mais il y a un problème : quand un robot va réellement corriger un bug, il ne se contente pas de lire vers l'avant. Il fait un pas, regarde ce qui s'est passé (peut-être qu'un outil a renvoyé une erreur), puis décide de ce qu'il doit faire ensuite. C'est une boucle : Action → Observation → Étape suivante.

Le cerveau du robot suit une boucle : l'Action du Robot est comme un appel de fonction dans un code informatique normal.

L'Action du Robot est comme une fonction qui en appelle une autre.
L'Observation du Robot est comme cette fonction qui renvoie une valeur.
L'Étape Suivante du Robot est comme le reste du code utilisant cette valeur.

La grande idée ? Au lieu de simplement lire le code vers l'avant, les auteurs ont appris à leurs modèles de robots à jouer à un jeu de « texte à trous » avec ces appels de fonctions. Ils appellent cela le Function-Aware Fill-in-the-Middle (FIM) Mid-Training (Entraînement intermédiaire par remplissage au milieu sensible aux fonctions).

Le Jeu : « Devine la pièce manquante »

Imaginez que vous avez une histoire où un personnage (l'« appelant ») demande à un ami (le « appelé ») d'accomplir une tâche, mais le travail réel de l'ami est caché. Le robot doit deviner ce que l'ami a fait et expliquer pourquoi il l'a fait, en se basant uniquement sur le contexte avant et après.

Pour rendre ce jeu efficace, les auteurs n'ont pas simplement choisi des mots au hasard pour les cacher. Ils ont utilisé une carte spéciale du code (un « Graphe de Dépendance de Programme » ou Program Dependency Graph) pour trouver les puzzles parfaits. Ils ont cherché des fonctions qui étaient :

Assez complexes pour constituer un bon défi (ni trop faciles, ni impossibles).
Assez prévisibles pour que le robot puisse réellement les déduire grâce aux indices environnants.

Ils ont également fait écrire au robot une « note de raisonnement » (une Chaîne de Pensée ou Chain-of-Thought) avant d'écrire le code manquant, le forçant ainsi à réfléchir avant d'agir, tout comme un programmeur humain le ferait.

Les Résultats : Est-ce que ça marche ?

Les auteurs ont testé cette méthode sur trois cerveaux de robots différents (modèles) : deux issus de la famille Qwen2.5-Coder (7 milliards et 14 milliards de paramètres) et un issu de la nouvelle famille Qwen3 (8 milliards de paramètres). Ils ont entraîné ces robots sur un ensemble massif de données de 2,6 milliards de tokens (mots et symboles) provenant de 968 dépôts de code Python réels.

Voici ce qu'ils ont trouvé :

Meilleure correction de bugs : Testés sur un benchmark célèbre appelé SWE-Bench-Verified (qui simule des problèmes logiciels réels), les robots se sont nettement améliorés.
- Le modèle 7B s'est amélioré de +2,8 %.
- Le modèle 14B s'est amélioré de +3,0 %.
- Le modèle 8B s'est amélioré de +3,2 %.
Encore meilleur sur les tâches plus simples : Sur une version plus légère du test (SWE-Bench-Lite), les gains étaient encore plus élevés, avec le modèle 8B bondissant de +5,4 %.
Cela fonctionne partout : Ces améliorations se sont produites même lorsque les robots étaient entraînés avec différentes méthodes par la suite. Cela suggère que l'entraînement « fill-in-the-middle » leur a donné une base solide qui perdure, peu importe la façon dont ils sont polis plus tard.

La Surprise : Cela n'a pas cassé les autres compétences

Généralement, quand on entraîne un robot pour qu'il soit un super-spécialiste (comme un agent de correction de bugs), il oublie comment faire d'autres choses, comme écrire du code simple ou utiliser des outils. Les auteurs craignaient que cela ne se produise.

Mais le « mid-training » a en fait sauvé les autres compétences des robots !

Sans cet entraînement supplémentaire, les robots devenaient moins bons pour écrire du code de manière autonome (en chutant sur des benchmarks comme LiveCodeBench).
Avec l'entraînement FIM, ils n'ont pas seulement maintenu leur niveau, ils sont devenus meilleurs (+11,1 % sur LiveCodeBench).
Même si les données d'entraînement étaient uniquement du code Python, les robots sont devenus meilleurs pour utiliser des outils dans des contextes complètement différents (comme τ-bench et BFCL), ce qui suggère qu'ils ont appris une compétence générale de « réflexion sur la cause et l'effet » qui se transfère d'une tâche à l'autre.

Ce qu'ils ont explicitement écarté

Les auteurs ont pris soin de préciser ce que cette méthode n'est pas :

Ce n'est pas juste copier un professeur intelligent : Ils ont testé si le robot se contentait de mémoriser les réponses d'une IA puissante (Gemini-3-Flash) qui a aidé à générer les données d'entraînement. Ils ont découvert que même lorsque le robot générait ses propres notes de raisonnement, il s'améliorait toujours. Donc, la magie n'est pas simplement de « copier le professeur », c'est la structure même du jeu.
Ce n'est pas un remède miracle pour tout : La méthode fonctionne mieux lorsque le code est modulaire (découpé en fonctions nettes). Si le code est un script géant et désordonné où tout est mélangé, la méthode fonctionne moins bien car elle ne peut pas trouver de puzzles clairs de type « appel de fonction » à résoudre.
Ce n'est pas encore prouvé pour tous les langages : Les données d'entraînement étaient uniquement en Python. Bien que les robots soient devenus meilleurs dans d'autres tâches, les auteurs admettent qu'ils n'ont pas encore prouvé que cela fonctionne pour Java, C++ ou Rust.

À quel point sont-ils sûrs d'eux ?

Les auteurs sont assez confiants dans leurs chiffres car ils ont effectué les tests trois fois avec différentes graines aléatoires (random seeds) pour s'assurer que les résultats n'étaient pas dus à la chance. Ils ont mesuré les améliorations avec précision (par exemple, +2,8 %, +3,0 %) et ont montré que les robots résolvaient systématiquement plus de problèmes et commettaient moins d'erreurs lorsqu'ils étaient bloqués.

Ils suggèrent que cette étape de « mid-training » est un maillon manquant crucial. C'est comme donner au robot un type d'entraînement spécifique à la salle de sport avant de l'envoyer dans le monde réel, afin de s'assurer qu'il possède les bons muscles pour gérer la boucle complexe « agir, observer et continuer » sans perdre ses autres capacités.

Résumé Technique : Le Fill-in-the-Middle sensible aux fonctions comme Mid-Training pour les modèles de fondation d'agents de codage

Énoncé du Problème

Les agents de codage conçus pour résoudre des problèmes d'ingénierie logicielle réels reposent sur une structure de conditionnement spécifique : maintenir un historique ( $h_t$ ), échantillonner une action ( $a_t$ ), recevoir une observation externe ( $o_{t+1}$ ), et poursuivre le raisonnement basé sur la trace complète. Bien que le pré-entraînement de code standard (prédiction du prochain jeton de gauche à droite) expose les modèles au code, il n'optimise que rarement ce cycle spécifique « action $\to$ observation $\to$ continuation ». Par conséquent, un écart existe entre le pré-entraînement du modèle de base et les exigences des pipelines de post-entraînement agentiques (ex: SWE-Gym, R2E-Gym).

De plus, l'objectif standard de Fill-in-the-Middle (FIM) utilisé dans le pré-entraînement de code est mal aligné avec le raisonnement des agents pour trois raisons :

Frontières Arbitraires : Le masquage par intervalles aléatoires peut couper à travers des expressions, échouant ainsi à capturer les dépendances au niveau de la fonction.
Absence de Raisonnement : Le FIM standard exige une génération directe sans étapes de raisonnement intermédiaire (Chain-of-Thought), contrairement au modèle « réfléchir-puis-agir » des agents.
Signal Amorti : Lorsque le FIM est dissous dans un pré-entraînement massif, le biais structurel est dilué à travers des billions de jetons non apparentés avant que le post-entraînement agentique ne commence.

Méthodologie

Les auteurs proposent le Function-Aware FIM Mid-Training, une étape d'auto-supervision dédiée insérée entre le pré-entraînement et le post-entraînement agentique. Cette approche exploite l'isomorphisme structurel entre l'étape d'un agent de codage et un site d'appel de fonction dans le code ordinaire :

Contexte/Historique : Le code pré-appel établissant l'intention.
Action/Appel : L'appel de fonction lui-même.
Observation/Retour : La valeur calculée par l'appelé (en dehors du scope immédiat).
Continuation : Le code en aval consommant la valeur de retour.

Composants Clés

Sélection de Cibles Sensible aux Fonctions :
Au lieu de segments aléatoires, la méthode sélectionne des cibles de masquage à la granularité de la fonction en utilisant l'analyse de Graphe de Dépendance de Programme (PDG).
- Score de Complexité ( $\hat{H}$ ) : Mesure la difficulté intrinsèque basée sur les lignes de code (LoC), la complexité cyclomatique de McCabe et la profondeur d'imbrication.
- Score d'Inférabilité ( $\hat{I}$ ) : Mesure à quel point une fonction est récupérable à partir de son contexte, en agrégeant les signaux provenant des arguments de l'appelant, des dépendances de l'appelé, des signatures de types, des docstrings et des membres de classe frères.
- Critère de Sélection : Les cibles sont sélectionnées via une combinaison de type moyenne harmonique de $\hat{H}$ et $\hat{I}$ , pénalisant les cibles qui sont soit trop triviales, soit impossibles à apprendre même avec un contexte complet.
Augmentation par Chaîne de Pensée (CoT) :
Pour les cibles sélectionnées, le modèle est entraîné à générer un raisonnement étape par étape avant le corps de la fonction.
- Génération : Un modèle frontal (Gemini-3-Flash) génère le raisonnement et un corps candidat basé uniquement sur le contexte du fichier masqué (sans accès à la vérité terrain).
- Filtrage : Un modèle juge filtre les paires selon la faisabilité et la qualité.
- Format d'Entraînement : Le prompt d'entraînement suit <fim_prefix> ... <fim_suffix> ... <fim_middle> <rationale> <body>. Cela force le modèle à apprendre la structure « réfléchir-puis-agir ».
Curation des Données :
Le corpus se compose de 968 dépôts Python décontaminés provenant de GitHub (2,6 milliards de jetons). Les dépôts chevauchant les sources de SWE-Bench sont supprimés, et les commits sont limités à une date antérieure aux commits de base de SWE-Bench pour éviter la fuite de données lors des tests.

Contributions Clés

Analogie Structurelle : Présenter les sites d'appel de fonction comme l'analogue à lels échelle internet du cycle action–observation–continuation d'un agent, motivant le FIM à granularité de fonction comme un biais structurel auto-supervisé.
Design de Pipeline : Un pipeline de mid-training combinant la sélection basée sur le PDG, un double critère complexité–inférabilité, et des rationales CoT intégrées.
Validation de la Robustesse : Démontrer des gains constants à travers différentes tailles de modèles (Qwen2.5-Coder 7B/14B, Qwen3-8B), différents pipelines de post-entraînement (R2E-Gym, SWE-Smith, SWE-Lego) et différentes familles de modèles de base.
Transfert Trans-Domaine : Montrer qu'un corpus de mid-training uniquement en Python améliore les performances sur des benchmarks d'utilisation d'outils non-codage ( $\tau$ -bench, BFCL) et préserve les capacités de codage générales (LiveCodeBench) qui se dégradent typiquement lors du post-entraînement agentique.
Libération Open Source : Publication du corpus décontaminé de 968 dépôts, du pipeline de sélection et des checkpoints mid-entraînés.

Résultats Expérimentaux

Performance Agentique In-Domain

La méthode a été évaluée sur SWE-Bench-Verified et SWE-Bench-Lite.

Qwen2.5-Coder-7B : +2,8 % de gain sur Verified, +3,7 % sur Lite (vs. post-entraînement seul).
Qwen2.5-Coder-14B : +3,0 % de gain sur Verified, +4,0 % sur Lite.
Qwen3-8B : +3,2 % de gain sur Verified, +5,4 % sur Lite.
Indépendance du Pipeline : Des gains ont été observés à travers les pipelines R2E-Gym, SWE-Smith et SWE-Lego, indiquant que le biais n'est pas spécifique à une seule distribution de données.

Préservation des Capacités et Transfert Trans-Domaine

Le post-entraînement agentique seul s'est avéré dégrader significativement les capacités non-cibles (ex: LiveCodeBench a chuté de 13,1 points pour le modèle 14B).

Restauration : L'ajout du mid-training avant le post-entraînement a restauré la performance de LiveCodeBench de +11,1 points, comblant presque l'écart avec le plafond de l'instruction-tuning.
Utilisation d'Outils : Malgré le fait que le corpus ne contienne que du code Python et aucune trajectoire d'utilisation d'outils, le mid-training a amélioré les performances sur $\tau$ -bench (+3,9) et BFCL (+2,4). Cela sert de preuve que le biais inductif de l'appel de fonction se transfère au raisonnement d'utilisation d'outils général.

Analyse Comportementale

L'analyse des trajectoires d'agents a révélé :

Récupération d'Erreurs : L'agent mid-entraîné a récupéré des observations négatives (ex: stack traces) à un taux de 28,8 % contre 24,8 % pour la baseline.
Itérer et Vérifier : Le modèle a adopté une politique d'éditions plus nombreuses et de trajectoires plus longues (23,6 étapes contre 15,1), réduisant les échecs de type « no-patch » d'un ordre de grandeur.
Granularité : Les gains ont été plus prononcés sur les tâches nécessitant de raisonner sur les dépendances inter-fonctions au sein d'un même fichier (+9,1 points sur les tâches multi-fonctions), confirmant l'hypothèse d'isomorphisme structurel.

Signification et Revendications

L'article affirme que le code source contient un « approvisionnement à l'échelle d'Internet de signaux pertinents pour les agents » sous la forme de sites d'appel de fonctions. En entraînant explicitement les modèles à raisonner de manière bidirectionnelle sur ces dépendances via un FIM sensible aux fonctions, la méthode installe un biais structurel qui :

Améliore la Performance des Agents : Augmente directement les taux de succès sur les benchmarks d'ingénierie logicielle.
Atténue l'Oubli Catastrophique : Prévient l'érosion des capacités générales de codage et d'utilisation d'outils souvent causée par le post-entraînement agentique spécialisé.
Généralise : Les bénéfices se transfèrent à travers les familles de modèles et aux tâches de raisonnement d'utilisation d'outils non-codage, suggérant que le biais inductif appris est fondamental au cycle de raisonnement de l'agent plutôt qu'à la génération de code Python spécifique.

Les auteurs notent des limites, notamment la dépendance à un corpus uniquement en Python, la dépendance à un enseignant frontal (Gemini-3-Flash) pour la génération de CoT (bien que le self-CoT récupère la majeure partie des gains), et l'hypothèse de structures de code modulaires.