💬 NLP

Beyond BLEU: A Semantic Evaluation Method for Code Translation

Dit artikel stelt een nieuwe semantische evaluatiemethodologie voor codevertaling voor die gebruikmaakt van compiler-testen om uitvoeringscorrectheid te meten, en toont aan dat op LLM's gebaseerde decompileren aanzienlijk beter presteren dan heuristische benaderingen, terwijl traditionele syntactische metrieken zoals BLEU geen correlatie vertonen met functionele nauwkeurigheid.

Oorspronkelijke auteurs: Julius Näumann, Sven Keidel, Amir Molzam Sharifloo, Mira Mezini

Gepubliceerd 2026-05-08

📖 4 min leestijd☕ Koffiepauze-leesvoer

CC BY 4.0

Oorspronkelijke auteurs: Julius Näumann, Sven Keidel, Amir Molzam Sharifloo, Mira Mezini

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 probeert een recept uit een vreemde taal naar het Engels te vertalen.

De Oude Manier: Woorden Tellen
Traditioneel gebruiken computers bij het controleren of een vertaling goed is, een methode die BLEU heet. Denk hierbij aan een leraar die een vertaling beoordeelt door simpelweg te tellen hoeveel woorden overeenkomen met het origineel, waarbij de betekenis wordt genegeerd.

Het Probleem: Als het originele recept zegt "Voeg een snufje zout toe" en de vertaling zegt "Voeg een klein beetje zout toe", denkt de computer dat ze heel verschillend zijn omdat de woorden niet perfect overeenkomen.
Het Grotere Probleem: Als het origineel zegt "Bak op 180°C" en de vertaling per ongeluk zegt "Bak op 260°C", kan de computer ze toch een hoge score geven omdat de woorden er vergelijkbaar uitzien. Het resultaat? Je krijgt een verbrande cake, maar de computer zegt: "Grootse prestatie!"

De auteurs van dit paper betogen dat voor computercode deze "woorden-tellende" methode nutteloos is. Twee programma's kunnen er op papier volledig verschillend uitzien, maar precies hetzelfde doen (zoals twee verschillende manieren om een schoenveter te strikken). Omgekeerd kunnen twee programma's er bijna identiek uitzien, maar totaal verschillende dingen doen (zoals een recept dat zegt "voeg suiker toe" versus "voeg zout toe").

De Nieuwe Manier: De Proeverij
In plaats van alleen naar de woorden te kijken, stellen de auteurs een "Proeverij"-benadering voor. Ze willen zien of de vertaalde code daadwerkelijk op dezelfde manier werkt als het origineel.

Hier is hoe hun nieuwe methode werkt, met een creatieve analogie:

De Generator (De Chef): Ze gebruiken een tool genaamd Csmith om automatisch duizenden willekeurige, simpele computerprogramma's te "koken". Het is alsof een robotchef duizenden willekeurige, kleine gerechtjes maakt.
Het Referentiegerecht: Ze draaien deze originele programma's en meten een specifiek "smaakprofiel" (een wiskundige checksum) van het resultaat. Dit is hun uitgangspunt.
De Vertaling: Ze voeren de originele code in bij een vertaler (een mensachtig AI-systeem of een traditioneel op regels gebaseerde tool) om de "vertaalde" code te krijgen.
Het Opnieuw Koken: Ze nemen die vertaalde code, koken het opnieuw en meten het nieuwe "smaakprofiel".
Het Oordeel: Als de smaakprofielen perfect overeenkomen, is de vertaling Semantisch Correct. Dit betekent dat de code exact hetzelfde werk doet, zelfs als de woorden er anders uitzien. Als de smaken niet overeenkomen, is de vertaling mislukt, zelfs als de woorden er wel op leken.

Wat Ze Vonden
Ze hebben deze methode getest op twee soorten vertalers:

De Oude School (Heuristisch): Dit zijn traditionele tools die strikte regels volgen.
De Nieuwe AI (LLM): Een groot taalmodel dat is getraind om code te vertalen.

De Resultaten:

De AI Wint: De AI-vertaler was veel beter in het behouden van de "smaak" (de feitelijke functionaliteit) van de code in vergelijking met de oude, op regels gebaseerde tools.
De Oude Metriek is Gebroken: Toen ze keken naar de "woorden-tellende" scores (BLEU), vonden ze geen enkele connectie met of de code daadwerkelijk werkte.
- Soms kreeg de AI een lage score voor woordovereenkomst, maar werkte de code perfect.
- Soms kreeg de AI een hoge score voor woordovereenkomst, maar was de code defect.

De Conclusie
Het paper concludeert dat we moeten stoppen met het beoordelen van codevertalingen op basis van hoezeer ze eruit zien als het origineel. In plaats daarvan moeten we ze beoordelen op basis van of ze zich gedragen als het origineel. De oude manier van woorden tellen is alsof je een auto beoordeelt op basis van hoezeer hij eruit ziet als een Ferrari, terwijl de nieuwe manier is om hem daadwerkelijk te rijden om te zien of hij loopt. De auteurs tonen aan dat de "rijtest" aantoont dat AI veel beter wordt in deze taak, terwijl de "uitziend-als"-test ons in de war brengt.

Technische Samenvatting: Voorbij BLEU: Een Semantische Evaluatiemethode voor Codevertaling

Probleemstelling
Codevertaling, met name decompilatie (het vertalen van lage-niveau binaire bestanden naar hogere-niveau representaties), is een kerncapaciteit van Large Language Models (LLMs). Het evalueren van de correctheid van deze vertalingen blijft echter een aanzienlijke uitdaging. Huidige evaluatiestandaarden vertrouwen sterk op syntactische vergelijkingsmaten zoals BLEU, CodeBLEU en RUBY. Deze maten meten oppervlakkige stringgelijkenis of de structuur van Abstract Syntax Trees (AST), maar slaan er niet in om programmasemantiek vast te leggen.

Het artikel identificeert twee kritieke gebreken in het gebruik van stringgelijkenis voor taken die semantische behoud vereisen:

Valse Negatieven: Functioneel identieke programma's kunnen lage gelijkenisscores krijgen door syntactische variaties, keuzes van identificatoren of compiler-optimalisaties (bijvoorbeeld het herschikken van instructies of het samenvoegen van constanten).
Valse Positieven: Programma's met een hoge tekstuele gelijkenis kunnen afwijkend gedrag vertonen. Bijvoorbeeld, een decompiler kan syntactisch lijken op de bron, maar een instructie verkeerd interpreteren (bijvoorbeeld het verkeerd interpreteren van een lea-instructie als een geheugenlading), wat leidt tot semantische fouten ondanks een hoge BLEU-score.
Bovendien vereisen bestaande testgebaseerde benaderingen handmatige creatie van testgevallen, wat arbeidsintensief is en zelden exhaustief.

Methodologie
Om deze beperkingen aan te pakken, stellen de auteurs een schaalbare evaluatiemethodologie voor, geïnspireerd door compiler-testtechnieken, specifiek met gebruikmaking van Csmith (Yang et al., 2011b). De aanpak verschuift de focus van stringvergelijking naar semantische equivalentievalidatie via uitvoering.

Het proces omvat de volgende stappen:

Programmageneratie: Csmith wordt gebruikt om automatisch willekeurige, compileerbare C-programma's te genereren die willekeurige berekeningen en functiediensten uitvoeren. Dit elimineert handwerk en maakt het mogelijk om willekeurig grote evaluatiesets te creëren.
Referentie-uitvoering: De gegenereerde C-programma's worden gecompileerd naar binaire bestanden op optimalisatieniveaus -O0 en -O3. Tijdens uitvoering berekenen en registreren deze binaire bestanden een CRC-checksum over tussentijdse waarden.
Vertaling en heruitvoering: De resulterende binaire bestanden worden verwerkt door de onder evaluatie staande decompiler (bijvoorbeeld een LLM of heuristisch hulpmiddel) om broncode te produceren. Deze gedecompileerde code wordt vervolgens opnieuw gecompileerd en uitgevoerd.
Semantische validatie: De checksum van het opnieuw uitgevoerde programma wordt vergeleken met de referentie-checksum. Een mismatch wijst op een semantische fout in de vertaling.
Definitie van maatstaf: De auteurs introduceren een Semantische Correctheidsscore, gedefinieerd als het aandeel vertaalde programma's die bij uitvoering overeenkomende checksums produceren:
$\text{Semantische Score} = \frac{\# \text{programma's met correcte checksum}}{\# \text{geteste programma's}}$

Belangrijkste Bijdragen
Het artikel presenteert drie primaire bijdragen:

Een Nieuwe Evaluatiemethodologie: Een raamwerk gebaseerd op geautomatiseerde programmageneratie en semantische checksumvalidatie, toepasbaar op elke taal maar hier geïmplementeerd voor C.
Een Directe Maatstaf: De Semantische Correctheidsscore, die een directe maatstaf biedt voor functionele nauwkeurigheid in plaats van syntactische gelijkenis.
Empirisch Bewijs: Een demonstratie dat syntactische maten (BLEU) slechte voorspellers zijn van functionele nauwkeurigheid in taken voor codevertaling.

Experimentele Resultaten
De methodologie werd toegepast om Meta's LLMCompiler (een model met 13 miljard parameters, fijnge tuned voor binary lifting van x86-assemblage naar LLVM-bytecode) te evalueren tegen state-of-the-art heuristische decompiilers: RetDec en McToll.

Prestatievergelijking: LLMCompiler presteerde aanzienlijk beter dan heuristische benaderingen. Het behaalde semantische correctheidsscores van 0,33 (op -O0-binaire bestanden) en 0,63 (op -O3-binaire bestanden). Daarentegen produceerden noch McToll noch RetDec enige binaire bestanden die succesvol werden uitgevoerd; McToll slaagde er niet in om enige binaire bestanden te liftten, en RetDec produceerde binaire bestanden die ofwel niet compileerden of crashten tijdens runtime.
Correlatieanalyse: De studie berekende round-trip BLEU-scores voor LLMCompiler-uitvoer en vergeleek deze met uitvoeringsresultaten. De resultaten toonden een verwaarloosbare correlatie tussen BLEU-scores en semantische correctheid.
- Voor -O0-binaire bestanden was de punt-bisariale correlatie ( $r$ ) voor BLEU-1 -0,13.
- Voor -O3-binaire bestanden toonde de sterkste voorspeller, CodeBLEU, een correlatie van slechts 0,35.
- Gemiddelde gelijkenisscores voor slagen en falen van testgevallen waren bijna identiek, wat aangeeft dat de verdelingen van syntactische gelijkenis aanzienlijk overlappen, ongeacht functionele correctheid.

Betekenis en Beweringen
Het artikel beweert dat syntactische maten zoals BLEU fundamenteel ongeschikt zijn voor het beoordelen van semantisch behoudende codevertaling. De bevindingen tonen aan dat hoge stringgelijkenis geen garantie biedt voor functionele nauwkeurigheid, en omgekeerd vereist functionele nauwkeurigheid geen hoge stringgelijkenis.

De auteurs positioneren hun werk als een noodzakelijke verschuiving naar uitvoeringsgebaseerde evaluatie. Hoewel ze beperkingen erkennen – specifiek dat het raamwerk momenteel beperkt is tot C-gegenereerde programma's en dat de gegenereerde code buiten de trainingsdistributie van de geëvalueerde modellen kan liggen – stellen ze dat het raamwerk een waardevolle, rigoureuze maatstaf voor prestaties biedt. Een hoge semantische score wijst op sterke toepasbaarheid en semantische equivalentie, wat suggereert dat robuuste modellen zich moeten kunnen generaliseren buiten hun specifieke trainingsdata.

Technische Samenvatting: Voorbij BLEU: Een Semantische Evaluatiemethode voor Codevertaling

Meer zoals dit