🤖 AI

daVinci-Dev: Agent-native Mid-training for Software Engineering

Le papier présente daVinci-Dev, un cadre pour le mid-training agentique qui exploite une nouvelle stratégie de données « agent-native » combinant des trajectoires contextuellement et environnementalement natives pour surmonter les décalages de distribution, permettant aux modèles de 32B et 72B d'atteindre des performances de pointe sur SWE-Bench Verified avec nettement moins de jetons d'entraînement que les méthodes précédentes.

Auteurs originaux : Ji Zeng, Dayuan Fu, Tiantian Mi, Yumin Zhuang, Yaxing Huang, Xuefeng Li, Lyumanshan Ye, Muhang Xie, Qishuo Hua, Zhen Huang, Mohan Jiang, Hanning Wang, Jifan Lin, Yang Xiao, Jie Sun, Yunze Wu, Pengfei

Publié 2026-01-28

📖 5 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : Ji Zeng, Dayuan Fu, Tiantian Mi, Yumin Zhuang, Yaxing Huang, Xuefeng Li, Lyumanshan Ye, Muhang Xie, Qishuo Hua, Zhen Huang, Mohan Jiang, Hanning Wang, Jifan Lin, Yang Xiao, Jie Sun, Yunze Wu, Pengfei Liu

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

L'Idée Principale : Enseigner à un Robot à Être un Vrai Programmeur

Imaginez que vous vouliez apprendre à un robot comment réparer une voiture en panne.

L'Ancienne Méthode (Post-Entraînement) :
La plupart des modèles d'IA actuels sont comme des étudiants qui ont lu tous les manuels de mécanique de la bibliothèque (Pré-entraînement) mais n'ont jamais touché une clé à molette. Pour leur apprendre à réparer des voitures, les chercheurs leur montrent quelques vidéos d'experts en train de réparer des voitures (Apprentissage Supervisé) et les laissent ensuite s'exercer dans un garage, en les corrigeant uniquement lorsqu'ils commettent une erreur (Apprentissage par Renforcement).

Le Problème : Le « garage » est petit et coûteux à construire. On ne peut s'exercer que sur quelques voitures. De plus, l'étudiant ne voit que la voiture finale réparée, pas le processus désordonné de l'essai, de l'échec, de la vérification du moteur, et de la nouvelle tentative.

La Nouvelle Méthode (daVinci-Dev / Entraînement de Milieu de Parcours Natif pour les Agents) :
Les auteurs de ce papier disent : « Enseignons au robot avant de l'envoyer au garage ». Ils introduisent une étape intermédiaire appelée Entraînement de Milieu de Parcours (Mid-Training).

Au lieu de simplement montrer la voiture finie au robot, ils le nourrissent d'une immense bibliothèque de journaux de réparation réels provenant de millions de mécaniciens de terrain. Ils ne montrent pas seulement le résultat final ; ils montrent toute l'histoire :

Le mécanicien examinant la voiture en panne.
Le mécanicien ouvrant le capot et lisant le manuel.
Le mécanicien tentant une réparation, entendant un bruit bizarre, et réalisant que cela n'a pas fonctionné.
Le mécanicien tentant une autre réparation jusqu'à ce que cela fonctionne.

Ils appellent cela des données « Natives pour les Agents » car elles imitent l'expérience réelle d'un agent (un travailleur) dans le monde réel, plutôt que de simplement mémoriser des faits statiques.

Les Deux Ingrédients Spéciaux

Pour construire cette bibliothèque d'entraînement, l'équipe a créé deux types d'« histoires » (données) à partir de GitHub (un site géant où les programmeurs partagent du code) :

1. Les Histoires « Contextuellement Natives » (La Bibliothèque Large)

Ce que c'est : Ils ont pris des millions de « Pull Requests » (demandes de modification de code) et ont reconstruit l'histoire complète.
L'Analogie : Imaginez le dossier d'un détective sur une affaire. Il ne montre pas seulement le crime résolu ; il montre le détective en train de lire le journal intime du suspect, de trouver le bon fichier, de faire une supposition, puis de changer d'avis en fonction de nouveaux indices.
Pourquoi cela aide : Cela enseigne à l'IA le flux de travail. Elle apprend qu'avant de modifier un fichier, elle doit d'abord le trouver et le lire. Cela couvre une immense variété de langages et de situations (68,6 milliards de mots de données).

2. Les Histoires « Environnementalement Natives » (La Simulation en Direct)

Ce que c'est : Ils n'ont pas seulement lu des journaux ; ils ont réellement exécuté le code. Ils ont placé un agent d'IA à l'intérieur d'un environnement informatique réel et fonctionnel (un conteneur Docker) et l'ont laissé essayer de corriger des bugs.
L'Analogie : C'est comme mettre l'étudiant dans un vrai garage avec un vrai moteur. L'étudiant tente de serrer un boulon, et le moteur fait un gros clac (une erreur). L'étudiant entend l'erreur, s'arrête, et essaie un autre outil.
Pourquoi cela aide : Cela apprend à l'IA comment réagir à un retour d'information réel. Elle apprend que « si je tape cette commande, l'ordinateur va me hurler un message d'erreur », ce qui est une chose que les livres statiques ne peuvent pas enseigner. Cette partie est plus petite (3,1 milliards de mots) mais de très haute qualité car elle est « réelle ».

Les Résultats : À quel point cela a-t-il fonctionné ?

L'équipe a testé leur nouvel « étudiant » (le modèle daVinci-Dev) sur un examen célèbre appelé SWE-Bench Verified, qui est comme un examen de conduite final pour les ingénieurs logiciels.

Le Score : Leur modèle de 72 milliards de paramètres a obtenu un taux de réussite de 58,5 %.
La Comparaison : Cela a battu la meilleure méthode open-source précédente (Kimi-Dev), qui tournait autour de 48,6 %.
L'Efficacité : Ils ont accompli cela en utilisant moins de la moitié de la quantité de données d'entraînement (tokens) que le précédent détenteur du record. C'est comme obtenir un A+ à un examen en étudiant 50 heures au lieu de 100, parce que le matériel d'étude était bien meilleur.
La Surprise : Bien qu'ils aient commencé avec un modèle de base « général » (Qwen2.5-Base) qui n'était pas spécifiquement entraîné pour le codage, ce nouveau mode d'entraînement l'a rendu meilleur en codage que des modèles qui commençaient comme des « experts en codage ».

Pourquoi cela est important (selon le papier)

Le papier soutient que la plus grande erreur commise dans l'enseignement du codage à l'IA a été de traiter l'IA comme un étudiant qui ne fait que lire des manuels scolaires. Le véritable génie logiciel est une boucle : Trouver le problème → Lire le code → Tenter une correction → Voir si cela casse → Corriger à nouveau.

En nourrissant l'IA de données qui préservent cette boucle (à la fois l'histoire du travail et le retour d'information en temps réel de l'ordinateur), ils ont construit une base beaucoup plus solide.

En bref : Ils n'ont pas seulement appris à l'IA à quoi ressemble le code ; ils lui ont appris comment penser comme un programmeur en simulant le processus désordonné d'essais et d'erreurs du développement logiciel réel.

Résumé Technique : daVinci-Dev : Mid-training natif pour les agents en génie logiciel

1. Énoncé du Problème

La frontière des capacités des grands modèles de langage (LLM) en génie logiciel s'est déplacée de la génération de code à coup unique vers l'ingénierie logicielle agentique, où les modèles doivent naviguer, éditer et tester de manière autonome des dépôts complexes. Bien que les approches de pointe actuelles reposent sur le post-entraînement (Fine-tuning supervisé suivi d'un apprentissage par renforcement), ce paradigme fait face à des limitations critiques :

Rareté et décalage des données : Le post-entraînement est contraint par les capacités intrinsèques du modèle de base et la quantité limitée de trajectoires exécutables de haute qualité disponibles. La plupart des données d'entraînement consistent en des artefacts statiques et terminés (ex: commits fusionnés) qui manquent de la séquence de boucles action-observation inhérente au développement réel.
Décalage de distribution : Les données d'entraînement traditionnelles montrent ce qui a été produit mais occultent comment un développeur ou un agent a découvert des fichiers, examiné le contexte et affiné de manière itérative les solutions en fonction du retour des tests. Cela crée un fossé entre les distributions d'entraînement statiques et l'environnement dynamique et riche en retours de l'utilisation réelle.
Mid-training sous-exploré : Bien que le mid-training (MT) se soit avéré transformateur pour des domaines comme les mathématiques et le code, les efforts existants pour le génie logiciel adoptent souvent une approche factorisée, synthétisant des échantillons isolés pour des tâches atomiques (ex: localisation ou édition) sans préserver le contexte procédural et la dynamique d'interaction qu'un agent expérimente.

2. Méthodologie : Mid-Training Natif pour les Agents

Le papier propose daVinci-Dev, une approche systématique de mid-training agentique qui instille des comportements agentiques fondamentaux avant le post-entraînement. L'innovation centrale est la construction de Données Natives pour Agents, définies comme une supervision qui préserve le flux complet d'informations et la dynamique environnementale du génie logiciel réel.

La méthodologie repose sur deux types de trajectoires complémentaires :

A. Trajectoires Contextuellement Natives ( $D_{ctx}$ )

Objectif : Fournir une large couverture et une grande diversité en préservant le contexte de développement complet.
Source : Construites à partir de Pull Requests (PR) GitHub.
Synthèse : Au lieu de factoriser les PR en tâches isolées, les auteurs reconstruisent des flux de travail complets. Pour chaque PR, ils regroupent :
- Description du problème : La spécification du problème.
- Fichiers pertinents : Contenu complet des fichiers au commit de base (simulant la phase de "lecture").
- Éditions temporelles : Une séquence de commits avec des messages de commit raffinés et des diffs de code (simulant la phase d' "édition").
- Raisonnement contextuel : Résumés générés par LLM faisant le pont entre le problème et les éditions.
Échelle : 68,6 milliards de tokens dérivés de plus de 10 millions de PR à travers divers langages (sous-ensemble Général) et des dépôts axés sur Python (sous-ensemble Python).

B. Trajectoires Environnementalement Natives ( $D_{env}$ )

Objectif : Fournir une authenticité d'interaction et capturer la boucle de rétroaction itérative (Édition $\to$ Test $\to$ Révision).
Source : Environnements exécutables réels dérivés de PR GitHub.
Synthèse : En utilisant le framework SWE-AGENT et GLM-4.6, les auteurs génèrent des rollouts d'agents dans des environnements Docker contenant de véritables tests unitaires.
- L'agent interagit avec l'environnement, recevant des observations réelles (sorties d'outils, échecs de tests, erreurs d'exécution).
- Les trajectoires ne sont pas filtrées par succès ; les trajectoires réussies et échouées sont incluses pour enseigner le débogage et la gestion des erreurs.
Échelle : 3,1 milliards de tokens (environ 74k trajectoires), divisés en ensembles réussis ( $D_{env}^{pass}$ ) et échoués ( $D_{env}^{fail}$ ).

C. Pipeline d'Entraînement

Les modèles (basés sur Qwen2.5-Base) subissent un processus en deux étapes :

Mid-Training (MT) : Entraînement sur les vastes corpus natifs pour agents non étiquetés ( $D_{ctx}$ et/ou $D_{env}$ ). Cela déplace la distribution des capacités du modèle pour qu'elle soit plus "prête pour l'agent".
Post-Entraînement : Fine-tuning supervisé (SFT) sur des trajectoires agentiques de haute qualité (ex: $D_{env}^{pass}$ ou des jeux de données publics comme SWE-smith) pour aligner le modèle avec des structures spécifiques.

3. Contributions Clés

Formulation du Mid-Training Natif pour les Agents : Le papier définit et implémente un paradigme de mid-training qui traite le comportement agentique comme un objectif de premier rang, allant au-delà de l'entraînement par sous-tâches factorisées pour une supervision holistique préservant le contexte.
Construction de Données à Grande Échelle : Les auteurs publient une recette pratique pour construire deux jeux de données complémentaires :
- Un corpus contextuellement natif de 68,6 milliards de tokens ( $D_{ctx}$ ) préservant les flux de travail complets des PR.
- Un corpus environnementallement natif de 3,1 milliards de tokens ( $D_{env}$ ) capturant les boucles de rétroaction d'exécution authentiques.
Performance État de l'Art : Les modèles résultants, daVinci-Dev-32B et daVinci-Dev-72B, atteignent de nouveaux résultats records sur SWE-Bench Verified parmi les recettes d'entraînement ouvertes utilisant des structures agentiques, malgré un départ de modèles de base non spécialisés en code.
Efficacité des Ressources : L'approche atteint une performance supérieure en utilisant moins de la moitié des tokens de mid-training (73,1B vs ~150B) par rapport à la recette ouverte précédente (KIMI-DEV), démontrant une densité d'information et une efficacité de token plus élevées.

4. Résultats Expérimentaux

Évalués sur SWE-Bench Verified en utilisant la structure SWE-AGENT :

Gains de Performance :
- daVinci-Dev-72B : Atteint un taux de résolution de 58,5 %, surpassant l'ancien SOTA ouvert (KIMI-Dev à 48,6 % avec SFT+RL) et dépassant les baselines utilisant un SFT fort seul.
- daVinci-Dev-32B : Atteint un taux de résolution de 56,1 %, établissant un nouveau SOTA pour les modèles 32B utilisant des structures agentiques, malgré un départ d'un modèle de base non-codeur (Qwen2.5-32B-Base).
Robustesse : La recette de mid-training produit des gains constants à travers différents régimes de post-entraînement (SFT Faible vs SFT Fort) et différentes échelles de modèles (32B vs 72B).
Généralisation : Les modèles montrent des améliorations significatives sur les benchmarks de génération de code généraux (HumanEval, EvalPlus) et les tâches de raisonnement scientifique (GPQA, SciBench), suggérant que le mid-training agentique favorise des compétences de raisonnement transférables.
Lois d'Échelle (Scaling Laws) : Le papier observe une forte relation log-linéaire entre les étapes d'entraînement et la performance ( $R^2 \approx 0,90$ ), indiquant que le paradigme n'a pas encore saturé et bénéficie d'une mise à l'échelle supplémentaire.

5. Signification et Revendications

Le papier soutient que les données natives pour agents sont le chaînon manquant critique pour le passage à l'échelle des agents de génie logiciel. En comblant le décalage de distribution entre les données d'entraînement statiques et les environnements de déploiement dynamiques, les auteurs démontrent que :

Comportements Fondamentaux : Les capacités agentiques (localisation, édition itérative, raffinement piloté par les tests) peuvent être instillées lors du mid-training, créant une fondation plus solide pour le post-entraînement ultérieur.
Synergie des Types de Données : La combinaison de données contextuellement natives (pour la largeur et la diversité du code) et de données environnementalement natives (pour la profondeur et l'authenticité du feedback) est essentielle. Les données contextuellement natives seules améliorent la performance, mais l'ajout de trajectoires environnementalement natives permet au modèle d'internaliser la dynamique d'exécution.
Scalabilité : L'approche offre une voie évolutive pour le développement futur des agents, en tirant parti de la vaste disponibilité des dépôts publics et de la vérification automatisée des environnements pour s'étendre au-delà des limitations actuelles de langage et de tâche.

Les auteurs concluent que leur travail fournit un "investissement computationnel substantiel" (jeux de données, recettes, checkpoints) à la communauté pour faciliter la recherche ultérieure dans ce paradigme encore peu exploré.