From SWE-ZERO to SWE-HERO: Execution-free to Execution-based Fine-tuning for Software Engineering Agents

1. Problématique : Le Goulot d'Étranglement de l'Infrastructure d'Exécution

Le domaine des agents d'ingénierie logicielle (SWE) autonomes repose traditionnellement sur une boucle itérative où l'agent modifie le code, puis exécute des tests dans un environnement isolé (généralement via Docker) pour obtenir un retour d'information. Bien que cette approche soit efficace pour valider les correctifs, elle présente des limites majeures qui entravent le développement d'agents open-source à grande échelle :

• Complexité Infrastructurelle : La création et la maintenance de milliers d'images Docker spécifiques à chaque tâche (résolution de bugs, dépendances complexes) génèrent un surcoût computationnel et de stockage prohibitif.
• Scalabilité des Données : De nombreux dépôts GitHub réels et leurs Pull Requests (PR) sont rejetés car leurs configurations legacy ou complexes empêchent une exécution fiable dans des conteneurs modernes.
• Scalabilité de l'Entraînement : L'orchestration de ces environnements pour l'apprentissage par renforcement (RL) ou le fine-tuning supervisé (SFT) à grande échelle est extrêmement coûteuse et fragile.

L'article postule que cette dépendance absolue à l'exécution physique crée un goulot d'étranglement qui empêche l'exploitation du "long tail" des données GitHub.

2. Méthodologie : La Recette de Fine-Tuning Bifurquée (SWE-ZERO $\to$ SWE-HERO)

Les auteurs proposent une approche en deux étapes pour découpler le raisonnement sémantique de la vérification physique, permettant ainsi une formation plus évolutive et efficace.

Étape 1 : SWE-ZERO (Raisonnement Fondamental sans Exécution)

• Concept : Une phase d'entraînement "execution-free" (sans exécution) qui exploite les "modèles du monde" internes des grands modèles de langage (LLM) pour comprendre la sémantique du code et l'architecture des dépôts sans avoir besoin d'un environnement d'exécution.
• Données : Génération de 300 000 trajectoires à partir de 150 000 PRs GitHub réels.
• Processus : Un agent "enseignant" (Qwen3-Coder-480B) opère dans un bac à sable générique (sandbox) sans accès à l'exécution de code Python ni aux tests. Il est contraint d'identifier les bugs et de proposer des correctifs uniquement par raisonnement statique.
• Filtrage : Un pipeline rigoureux élimine les trajectoires où l'agent tente d'exécuter du code ou utilise des commandes interdites, garantissant que le modèle apprend à raisonner sans "tricher" via l'exécution.
• Avantage : Réduction de 40 % du nombre de tokens par rapport aux approches basées sur l'exécution et accès à des données auparavant inaccessibles.

Étape 2 : SWE-HERO (Raffinement Ancré par l'Exécution)

• Concept : Une phase de raffinement ciblé pour transformer l'intuition sémantique acquise en flux de travail d'ingénierie rigoureux et vérifiés.
• Données : Un ensemble plus petit mais de haute fidélité de 13 000 trajectoires exécutées dans des environnements Docker complets et vérifiés.
• Processus : Le modèle pré-entraîné sur SWE-ZERO est affiné (fine-tuned) sur ces données exécutées. Cela permet au modèle d'apprendre à générer des tests, à interpréter les retours d'erreur et à itérer sur ses solutions.
• Objectif : Combler le fossé entre l'intuition (SWE-ZERO) et la vérification rigoureuse (SWE-HERO).

3. Contributions Clés

1. Nouveau Paradigme d'Entraînement : Introduction d'une recette de fine-tuning en deux étapes qui démontre que l'entraînement massif sans exécution est un prérequis critique pour la performance, avant même d'ajouter la complexité de l'exécution.
2. Jeux de Données Open-Source : Publication de 300k trajectoires SWE-ZERO et 13k trajectoires SWE-HERO, distillées à partir de Qwen3-Coder-480B, ainsi que des modèles agents basés sur la série Qwen2.5-Coder.
3. Modèles SOTA Open-Source : Développement d'une série de modèles (7B, 14B, 32B) qui surpassent les agents open-source existants de taille comparable.
4. Analyse de la Généralisation : Démonstration que l'entraînement sur des données Python (SWE-ZERO) permet une transfert zéro-shot robuste vers d'autres langages (SWE-bench Multilingual).

4. Résultats Expérimentaux

Les résultats sont évalués sur les benchmarks SWE-bench Verified (500 problèmes Python réels) et SWE-bench Multilingual.

• Performance sur SWE-bench Verified :

  • Le modèle SWE-HERO-32B atteint un taux de résolution de 62,2 %, établissant un nouveau record pour les modèles open-source de cette taille.
  • Les modèles de plus petite taille montrent des gains significatifs : SWE-HERO-7B atteint 52,7 % (vs 46,8 % pour SWE-ZERO-7B) et SWE-HERO-14B atteint 60,8 %.
  • Ces performances rivalisent avec des modèles propriétaires massifs (comme GPT-OSS-120B ou MiniMax-M2.5) tout en étant entraînés avec une infrastructure beaucoup plus légère.

• Généralisation Multilingue :

  • Entraîné exclusivement sur des trajectoires Python, SWE-HERO-32B atteint 44,1 % sur le benchmark Multilingue (avec exécution), prouvant que les motifs de raisonnement fondamentaux appris lors de la phase SWE-ZERO sont transférables à d'autres langages de programmation.

• Efficacité et Coût :

  • Les agents SWE-ZERO résolvent les tâches avec 40 % de tokens en moins en évitant les cycles d'exécution et de test inutiles.
  • L'ablation study montre que passer directement à SWE-HERO (sans la phase SWE-ZERO) fait chuter la performance de 62,2 % à 55,7 %, confirmant que la phase sans exécution est un prérequis essentiel pour l'induction de biais de raisonnement.

5. Signification et Impact

Cet article marque un tournant dans la formation des agents d'ingénierie logicielle :

• Démocratisation de l'IA pour le SWE : En éliminant la dépendance à des infrastructures Docker massives pour la majeure partie de l'entraînement, la méthode SWE-ZERO à SWE-HERO rend la création d'agents SWE performants accessible aux communautés open-source et aux organisations aux ressources limitées.
• Validation du Raisonnement Sémantique : L'étude prouve que les LLM frontaux possèdent déjà une compréhension profonde de la sémantique du code et de l'architecture logicielle, suffisante pour résoudre une grande partie des problèmes sans exécution physique. L'exécution n'est nécessaire que pour le raffinement final et la vérification.
• Évolutivité Future : Cette approche ouvre la voie à l'utilisation de volumes de données GitHub beaucoup plus importants (le "long tail") qui étaient auparavant inutilisables, permettant un apprentissage plus robuste et généralisable.

En résumé, SWE-ZERO to SWE-HERO propose une architecture d'entraînement plus intelligente et évolutive, prouvant que l'on peut atteindre des niveaux de performance de pointe en combinant un apprentissage massif basé sur la sémantique avec un raffinement ciblé basé sur l'exécution.