🤖 machine learning

Merge-Bench: Resolve Merge Conflicts with Large Language Models

Dit artikel introduceert Merge-Bench, een groot dataset van real-world merge-conflicten, en presenteert LLMergeJ, een specifiek voor Java getraind model met Group Relative Policy Optimization dat meerdere commerciële LLM's overtreft, hoewel zelfs de beste modellen momenteel minder dan 60% van de conflicten oplossen over 11 programmeertalen heen.

Oorspronkelijke auteurs: Benedikt Schesch, Michael D. Ernst

Gepubliceerd 2026-05-26

📖 4 min leestijd☕ Koffiepauze-leesvoer

CC BY 4.0

Oorspronkelijke auteurs: Benedikt Schesch, Michael D. Ernst

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je voor dat je werkt aan een groepsproject waarbij twee vrienden tegelijk hetzelfde document bewerken. Vriend A wijzigt een alinea en vriend B wijst exact dezelfde alinea aan. Wanneer je hun werk probeert te combineren, raakt de computer in de war en schreeuwt: "Ik weet niet welke versie ik moet behouden!" Dit heet een merge conflict.

Meestal moet een mens tussenbeide komen, beide versies lezen, uitzoeken wat de vrienden eigenlijk bedoelden te doen, en de rommel handmatig oplossen. Dit kost tijd en kan leiden tot fouten.

Dit artikel introduceert een nieuwe manier om computers te leren deze rommel automatisch op te lossen met behulp van "slimme" AI (Large Language Models). Hier is de uitleg van hun werk in eenvoudige termen:

1. Het Probleem: De Computer is Onwetend

Traditionele tools zijn als een robot die alleen naar de letters kijkt. Als vriend A "kat" schreef en vriend B "hond", ziet de robot gewoon een botsing. Het begrijpt niet dat ze misschien over huisdieren spraken, of dat het een typefout was. Het heeft een mens nodig om de intentie uit te leggen.

2. De Oplossing: Een Nieuwe Trainingsgrond (Merge-Bench)

Om een AI te leren deze conflicten op te lossen, heb je een enorme bibliotheek met voorbeelden nodig die laten zien: "Hier was de rommel, en hier is hoe een menselijk expert het opgelost heeft."

De Oude Manier: Andere onderzoekers probeerden deze bibliotheken met de hand te maken of door tests uit te voeren. Dit was traag, duur en soms "valste" de AI door de testantwoorden uit het hoofd te leren in plaats van te leren de code te repareren.
De Nieuwe Manier (Merge-Bench): De auteurs bouwden een gigantische, geautomatiseerde bibliotheek genaamd Merge-Bench. Ze scrapten 7.938 echte conflicten van 1.439 verschillende openbare code-projecten op GitHub.
- De Analogie: Stel je een leraar voor die niet elk huiswerkverslag handmatig hoeft te beoordelen. In plaats daarvan heeft hij een machine die automatisch 8.000 realistische voorbeelden pakt van leerlingen die fouten maken en de correcte antwoorden geschreven door de leraar. Omdat de machine al het werk doet, kunnen ze een bibliotheek hebben die enorm is en nooit opraakt.

3. De Student: LLMergeJ

De auteurs trainden een specifiek AI-model genaamd LLMergeJ (de "J" staat voor Java, de programmeertaal waarop ze zich richtten).

Hoe ze het leerden: In plaats van het model alleen het antwoord te laten zien (zoals een standaardleraar), gebruikten ze een methode genaamd Versterkend Leren.
- De Analogie: Denk eraan als het trainen van een hond. Als de hond de juiste truc raadt, krijgt hij een traktatie. Als hij het verkeerd raadt, krijgt hij niets. Als hij weigert te raden en gewoon zegt "Ik weet het niet" (het conflict behoudend), krijgt hij een kruimel.
- De AI probeerde duizenden keren. Toen het de juiste manier bedacht om de code te combineren, kreeg het een grote beloning. Na verloop van tijd leerde het niet alleen hoe het antwoord eruitzag, maar ook hoe het over het probleem moest nadenken om er te komen.

4. De Resultaten: Kleine Hond, Grote Trucs

Ze testten hun model met 14 miljard parameters (wat relatief klein is voor AI-standaarden) tegen de grootste, duurste commerciële AI-modellen die beschikbaar zijn (zoals Gemini, Claude en Grok).

De Verrassing: Hun kleine, speciaal getrainde model deed het beter dan bijna alle gigantische commerciële modellen. Het loste ongeveer 59% van de conflicten correct op (na het negeren van kleine opmaakverschillen).
De Vergelijking: Het beste commerciële model (Gemini 2.5 Pro) was iets beter, maar het model van de auteurs sloeg de anderen met een aanzienlijke marge.
De Les: Een klein model dat specifiek is getraind op hoe je merge-conflicten oplost met beloningen, is beter dan een gigantisch, algemeen doelmodel dat gewoon één keer werd gevraagd dit te doen.

5. Waarom Dit Belangrijk Is

Geen Valsspelen: Hun testmethode vertrouwt niet op het uitvoeren van codetests (waar AI soms in kan trappen). Het vergelijkt de code direct met wat de menselijke ontwikkelaar daadwerkelijk heeft gedaan.
Schaalbaar: Omdat ze geen mensen nodig hadden om de data te labelen, konden ze de trainingsset zo groot maken als ze wilden.
Taalonafhankelijk: Hoewel ze het model alleen op Java trainden, testten ze de grote commerciële modellen op 11 verschillende talen (C, Python, Rust, enz.). Ze ontdekten dat het gedrag van de AI vergelijkbaar was in alle talen, wat suggereert dat hun methode voor elke programmeertaal kan werken.

Samenvatting

De auteurs bouwden een enorme, geautomatiseerde sportschool (Merge-Bench) om een specifieke AI-atleet (LLMergeJ) te trainen om code-conflicten op te lossen. Door een beloningsgebaseerd trainsysteem te gebruiken, leerden ze een relatief kleine AI om de grootste, duurste AI-modellen te overtreffen in deze specifieke taak, wat bewijst dat gespecialiseerde training beter is dan algemene omvang als het gaat om het oplossen van software-rommel.

`), 0 anders.
* $R_{format}$ : 1 als de output correcte Markdown-opmaak gebruikt, 0 anders.
* $R_{resolution}$ : 1,0 voor een exacte tekstuele overeenkomst, 0,5 voor een genormaliseerde overeenkomst van de broncode, 0,1 voor het behouden van het conflict (geen oplossing), en 0 voor incorrecte samenvoegingen.

Voordeel t.o.v. SFT: In tegenstelling tot Supervised Fine-Tuning (SFT), dat alleen kan leren van de uiteindelijke output, optimaliseert GRPO het redeneerproces en behandelt het de onvoorspelbaarheid van de grondwahrheid (waar meerdere syntactisch verschillende oplossingen geldig kunnen zijn) door het gebruik van groepsrelatieve voordelen. Dit voorkomt dat het model overpast op specifieke syntactische patronen.

Belangrijkste bijdragen

Merge-Bench: Een grootschalig, schaalbaar benchmark dat resistent is tegen beloningsovertreding en geen handmatige annotatie vereist.
Testvrije evaluatie: Een methodologie die testuitvoering omzeilt, waardoor schaalbare training en evaluatie mogelijk zijn zonder de kwetsbaarheden van beloningen gebaseerd op testsets.
Human-Filter-Free SWE-RL: Een versterkingsleertaak voor software-engineering die internet-grootschalige data gebruikt zonder menselijke filtering of handmatige aanpassingen.
LLMergeJ: Het eerste model dat is getraind met online RL voor het oplossen van samenvoegconflicten, wat aantoont dat een model met 14 miljard parameters aanzienlijk grotere commerciële modellen kan overtreffen.

Resultaten

Prestaties in Java

Op de Java-subset van Merge-Bench (806 conflicten):

LLMergeJ (14B) behaalde 48,8% exacte tekstuele overeenkomst en 58,9% genormaliseerde overeenkomst van de broncode.
Vergelijking: LLMergeJ presteerde beter dan drie grote commerciële LLM's (Claude Opus 4, o3 Pro en Grok 4) en een Qwen3-14B SFT-baseline. Het bleef alleen Gemini 2.5 Pro (62,5% genormaliseerde overeenkomst) voor.
SFT-baseline: Zelfs toen de SFT-baseline werd getraind op dezelfde data met hyperparameters die specifiek voor de testset waren geoptimaliseerd, behaalde deze slechts 36,6% exacte overeenkomst en 44,7% genormaliseerde overeenkomst, wat de superioriteit van de GRPO-benadering voor deze taak onderstreept.
Gedragsanalyse:
- Aggressieve oplossers (LLMergeJ, Gemini 2.5 Pro, o3 Pro): Hoog vertrouwen, waarbij 51–62% van de conflicten wordt opgelost, met lage behoudspercentages voor conflicten (3–21%).
- Conservatieve oplossers (Grok 4, Llama 4 Maverick): Hoge behoudspercentages voor conflicten (40–86%), wat onzekerheid aangeeft.
- Modellen met moeite met opmaak: Sommige modellen (bijv. QwQ 32B, R1 1.5B) slaagden er niet in de Markdown-opmaakinstructies te volgen, wat leidde tot ongeldige output.

Prestaties over talen heen

De auteurs evalueerden zes state-of-the-art commerciële modellen over 11 talen (C, C++, C#, Go, Java, JavaScript, PHP, Python, Ruby, Rust, TypeScript).

Moeilijkheidsgraad van talen: C bleek het moeilijkst te samenvoegen, terwijl Java, PHP en Python het makkelijkst waren.
Stabiliteit: De prestaties van commerciële LLM's waren grotendeels stabiel over de verschillende talen.
Generalisatie: De gedragspatronen (bijv. welke modellen agressief versus conservatief zijn) bleven consistent over de talen, wat suggereert dat de technieken mogelijk generaliseren, hoewel LLMergeJ zelf alleen op Java is getraind.

Betekenis en claims

Het artikel beweert dat LLMergeJ aantoont dat kleine, gespecialiseerde modellen die met versterkingsleer zijn getraind, concurrerende of superieure prestaties kunnen leveren ten opzichte van massale commerciële modellen voor specifieke software-engineeringtaken. Het werk benadrukt dat:

Versterkingsleer (GRPO) superieur is aan SFT voor samenvoegconflicten omdat het redeneren optimaliseert en de ambiguïteit van meerdere geldige oplossingen aankan zonder de prestaties te verslechteren.
Schaalbaarheid haalbaar is zonder menselijke annotatie, wat een knelpunt in huidige SWE-benchmarks zoals SWE-Bench aanpakt.
Parameter-efficiëntie: Een model met 14 miljard parameters kan wedijveren met modellen met ordes van grootte meer parameters wanneer het wordt getraind met de juiste methodologie en data.

De auteurs houden een bescheiden standpunt, waarbij ze beperkingen erkennen zoals de mogelijkheid van fouten in de grondwahrheid, de mogelijkheid van datalekken in commerciële trainingssets, en het feit dat de training beperkt was tot Java. Ze merken op dat de groottebeperkingen van de dataset de meest complexe samenvoegproblemen kunnen uitsluiten, wat mogelijk leidt tot een overschatting van de prestaties op alle real-world conflicten.