🤖 machine learning

Merge-Bench: Resolve Merge Conflicts with Large Language Models

Cet article présente Merge-Bench, un jeu de données à grande échelle de conflits de fusion réels, et introduit LLMergeJ, un modèle spécifique au Java entraîné par optimisation de politique relative de groupe qui surpasse plusieurs grands modèles de langage commerciaux, bien que même les meilleurs modèles résolvent actuellement moins de 60 % des conflits dans 11 langages de programmation.

Auteurs originaux : Benedikt Schesch, Michael D. Ernst

Publié 2026-05-26

📖 5 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : Benedikt Schesch, Michael D. Ernst

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 travaillez sur un projet de groupe où deux amis modifient le même document en même temps. L'ami A modifie un paragraphe, et l'ami B modifie exactement le même paragraphe. Lorsque vous tentez de combiner leur travail, l'ordinateur se perd et crie : « Je ne sais pas quelle version conserver ! » C'est ce qu'on appelle un conflit de fusion.

Habituellement, un humain doit intervenir, lire les deux versions, déterminer ce que les amis avaient réellement l'intention de faire, et corriger manuellement le désordre. Cela prend du temps et peut entraîner des erreurs.

Ce papier présente une nouvelle méthode pour apprendre aux ordinateurs à corriger automatiquement ces désordres en utilisant une IA « intelligente » (des Modèles de Langage de Grande Taille). Voici une décomposition de leur travail en termes simples :

1. Le Problème : L'ordinateur est perdu

Les outils traditionnels sont comme un robot qui ne regarde que les lettres. Si l'ami A a écrit « chat » et l'ami B a écrit « chien », le robot ne voit qu'une collision. Il ne comprend pas qu'ils parlaient peut-être d'animaux de compagnie, ou que l'un était une faute de frappe. Il a besoin qu'un humain explique l'intention.

2. La Solution : Un nouveau terrain d'entraînement (Merge-Bench)

Pour enseigner à une IA à résoudre ces conflits, vous avez besoin d'une immense bibliothèque d'exemples montrant « Voici le désordre, et voici comment un expert humain l'a résolu ».

L'ancienne méthode : D'autres chercheurs ont essayé de créer ces bibliothèques à la main ou en exécutant des tests. C'était lent, coûteux, et parfois l'IA « trichait » en mémorisant les réponses des tests plutôt qu'en apprenant à corriger le code.
La nouvelle méthode (Merge-Bench) : Les auteurs ont construit une immense bibliothèque automatisée appelée Merge-Bench. Ils ont extrait 7 938 conflits réels de 1 439 projets de code publics différents sur GitHub.
- L'analogie : Imaginez un professeur qui n'a pas besoin de corriger chaque devoir à la main. Au lieu de cela, il dispose d'une machine qui récupère automatiquement 8 000 exemples réels d'erreurs commises par des élèves et des réponses correctes écrites par le professeur. Parce que la machine fait tout le travail, ils peuvent disposer d'une bibliothèque immense qui ne s'épuise jamais.

3. L'Étudiant : LLMergeJ

Les auteurs ont entraîné un modèle d'IA spécifique nommé LLMergeJ (le « J » signifie Java, le langage de programmation sur lequel ils se sont concentrés).

Comment ils l'ont enseigné : Au lieu de simplement montrer la réponse au modèle (comme un professeur standard), ils ont utilisé une méthode appelée Apprentissage par Renforcement.
- L'analogie : Pensez à l'entraînement d'un chien. Si le chien devine le bon tour, il reçoit une friandise. S'il se trompe, il ne reçoit rien. S'il refuse de deviner et dit simplement « Je ne sais pas » (en préservant le conflit), il reçoit une toute petite miette.
- L'IA a essayé des milliers de fois. Lorsqu'elle trouvait le bon moyen de combiner le code, elle obtenait une grande récompense. Avec le temps, elle a appris non seulement à quoi ressemblait la réponse, mais comment penser au problème pour y parvenir.

4. Les Résultats : Petit chien, grands tours

Ils ont testé leur modèle de 14 milliards de paramètres (qui est relativement petit selon les standards de l'IA) contre les plus grands et les plus coûteux modèles d'IA commerciaux disponibles (comme Gemini, Claude et Grok).

La surprise : Leur petit modèle, entraîné spécifiquement, a mieux performé que presque tous les modèles commerciaux géants. Il a résolu correctement environ 59 % des conflits (en ignorant les différences mineures de mise en forme).
La comparaison : Le meilleur modèle commercial (Gemini 2.5 Pro) était légèrement supérieur, mais le modèle des auteurs a surpassé les autres avec une marge significative.
La leçon : Un petit modèle entraîné spécifiquement sur la façon de résoudre les conflits de fusion en utilisant des récompenses est meilleur qu'un modèle géant à usage général auquel on a simplement demandé de le faire une fois.

5. Pourquoi cela compte

Pas de triche : Leur méthode de test ne repose pas sur l'exécution de tests de code (que l'IA peut parfois tromper). Elle compare directement le code à ce que le développeur humain a réellement fait.
Évolutif : Parce qu'ils n'avaient pas besoin d'humains pour étiqueter les données, ils pouvaient rendre l'ensemble d'entraînement aussi grand qu'ils le voulaient.
Indépendant du langage : Bien qu'ils n'aient entraîné le modèle que sur Java, ils ont testé les grands modèles commerciaux sur 11 langages différents (C, Python, Rust, etc.). Ils ont constaté que le comportement de l'IA était similaire dans tous les langages, suggérant que leur méthode pourrait fonctionner pour n'importe quel langage de programmation.

Résumé

Les auteurs ont construit une immense salle de sport automatisée (Merge-Bench) pour entraîner un athlète IA spécifique (LLMergeJ) à résoudre les conflits de code. En utilisant un système d'entraînement basé sur des récompenses, ils ont appris à une IA relativement petite à surpasser les plus grands et les plus coûteux modèles d'IA dans cette tâche spécifique, prouvant qu'un entraînement spécialisé bat la taille générale lorsqu'il s'agit de corriger les désordres logiciels.

`), 0 sinon.
* $R_{format}$ : 1 si la sortie utilise un formatage Markdown correct, 0 sinon.
* $R_{resolution}$ : 1,0 pour une correspondance textuelle exacte, 0,5 pour une correspondance de code source normalisée, 0,1 pour la préservation du conflit (aucune résolution), et 0 pour des fusions incorrectes.

Avantage par rapport au SFT : Contrairement au Fine-Tuning Supervisé (SFT), qui ne peut apprendre que des sorties finales, GRPO optimise le processus de raisonnement et gère l'imprévisibilité de la vérité terrain (où plusieurs solutions syntaxiquement différentes peuvent être valides) en utilisant des avantages relatifs de groupe. Cela empêche le modèle de surajuster à des motifs syntaxiques spécifiques.

Contributions Clés

Merge-Bench : Un benchmark à grande échelle et évolutif, résistant au piratage de récompenses et ne nécessitant aucune annotation manuelle.
Évaluation sans exécution de tests : Une méthodologie qui contourne l'exécution des tests, permettant un entraînement et une évaluation évolutifs sans les vulnérabilités des récompenses basées sur des suites de tests.
SWE-RL sans filtre humain : Une tâche d'apprentissage par renforcement pour l'ingénierie logicielle qui utilise des données à l'échelle d'Internet sans filtrage humain ni ajustements manuels.
LLMergeJ : Le premier modèle entraîné avec un RL en ligne pour la résolution de conflits de fusion, démontrant qu'un modèle de 14 milliards de paramètres peut surpasser des modèles commerciaux nettement plus grands.

Résultats

Performance en Java

Sur le sous-ensemble Java de Merge-Bench (806 conflits) :

LLMergeJ (14B) a obtenu 48,8 % de correspondance textuelle exacte et 58,9 % de correspondance de code source normalisée.
Comparaison : LLMergeJ a surpassé trois grands modèles de langage commerciaux (Claude Opus 4, o3 Pro et Grok 4) ainsi qu'une ligne de base SFT Qwen3-14B. Il n'a été devancé que par Gemini 2.5 Pro (62,5 % de correspondance normalisée).
Ligne de base SFT : Même lorsque la ligne de base SFT a été entraînée sur les mêmes données avec des hyperparamètres optimisés spécifiquement pour l'ensemble de tests, elle n'a obtenu que 36,6 % de correspondance exacte et 44,7 % de correspondance normalisée, soulignant la supériorité de l'approche GRPO pour cette tâche.
Analyse comportementale :
- Résolveurs agressifs (LLMergeJ, Gemini 2.5 Pro, o3 Pro) : Confiance élevée, résolution de 51 à 62 % des conflits, avec de faibles taux de préservation des conflits (3 à 21 %).
- Résolveurs conservateurs (Grok 4, Llama 4 Maverick) : Taux élevés de préservation des conflits (40 à 86 %), indiquant une incertitude.
- Modèles en difficulté avec le formatage : Certains modèles (par exemple, QwQ 32B, R1 1,5B) n'ont pas suivi les instructions de formatage Markdown, conduisant à des sorties invalides.

Performance Transversale aux Langues

Les auteurs ont évalué six modèles commerciaux de pointe dans 11 langues (C, C++, C#, Go, Java, JavaScript, PHP, Python, Ruby, Rust, TypeScript).

Difficulté des langues : Le C a été jugé le plus difficile à fusionner, tandis que le Java, le PHP et le Python étaient les plus faciles.
Stabilité : La performance des LLM commerciaux était largement stable à travers les langues.
Généralisation : Les schémas comportementaux (par exemple, quels modèles sont agressifs par rapport aux conservateurs) sont restés cohérents à travers les langues, suggérant que les techniques peuvent se généraliser, bien que LLMergeJ lui-même n'ait été entraîné que sur du Java.

Importance et Revendications

L'article affirme que LLMergeJ démontre que de petits modèles spécialisés entraînés par apprentissage par renforcement peuvent atteindre des performances compétitives ou supérieures par rapport aux modèles commerciaux massifs pour des tâches spécifiques d'ingénierie logicielle. Le travail met en évidence que :

L'apprentissage par renforcement (GRPO) est supérieur au SFT pour les conflits de fusion car il optimise le raisonnement et gère l'ambiguïté de multiples solutions valides sans dégrader les performances.
L'évolutivité est réalisable sans annotation humaine, répondant à un goulot d'étranglement dans les benchmarks actuels d'ingénierie logicielle comme SWE-Bench.
Efficacité des paramètres : Un modèle de 14 milliards de paramètres peut rivaliser avec des modèles ayant plusieurs ordres de grandeur de paramètres de plus lorsqu'ils sont entraînés avec la bonne méthodologie et les bonnes données.

Les auteurs adoptent une position modeste, reconnaissant des limitations telles que la possibilité d'erreurs dans la vérité terrain, la possibilité de fuites de données dans les ensembles d'entraînement commerciaux, et le fait que l'entraînement était limité au Java. Ils notent que les contraintes de taille de l'ensemble de données peuvent exclure les problèmes de fusion les plus complexes, conduisant potentiellement à une surestimation des performances sur tous les conflits réels.