Technische Samenvatting: Voorbij Code-paren: Dialooggebaseerde Datageneratie voor LLM Code-translatie

Probleemstelling

Large Language Models (LLM's) hebben significante capaciteiten getoond in code-translatie voor populaire talen zoals Python en Java. Hun prestaties verslechteren echter aanzienlijk in omgevingen met weinig middelen (low-resource programming domains), zoals Fortran, en gespecialiseerde frameworks (zoals CUDA), waar hoogwaardige parallelle trainingsdata schaars is. Bestaande agent-gebaseerde benaderingen volgen doorgaans een workflow van bron-naar-doel, waarbij uiteindelijke bron–doel code-paren worden geproduceerd. Hoewel deze methoden effectief zijn voor het genereren van syntactisch geldige code, laten ze waardevolle tussenliggende informatie achter—zoals compilerfouten, runtime-diagnostiek en interacties met externe tools—die cruciaal is voor het mogelijk maken van dieper redeneren over programmeersemantiek en functioneel gedrag. Bijgevolg falen modellen die getraind zijn op statische code-paren vaak in het herstellen van fouten of het genereren van functioneel correcte code in complexe translatiescenario's.

Methodologie

De auteurs stellen een geautomatiseerde datasetgeneratie-pipeline voor die verder gaat dan traditionele code-paren door een dual-LLM Questioner–Solver ontwerp te integreren binnen een agent-gebaseerde translatie-workflow. Deze aanpak genereert multi-turn dialogen die het redeneerproces achter de verfijning van de translatie vastleggen.

De Questioner–Solver Module

De kern van het systeem bestaat uit twee verschillende LLM-rollen:

• Questioner (Vraagsteller): Analyseert de huidige staat, maakt gebruik van dialooggeheugen (vorige pogingen, fouten, fixes) en incorporeert externe signalen (compilerfouten, runtime-outputs). Het formuleert gerichte vragen, specificeert beperkingen en controleert op de consistentie tussen bron en doel.
• Solver (Oplosser): Voert translaties uit, genereert unit tests, stelt fixes voor en geeft verificatie-resultaten terug.

Multi-Turn Dialoog Generatie Pipeline

De pipeline verwerkt Source Programming Language (SPL) code via de volgende fasen om geverifieerde dialogen te genereren:

1. Preprocessing: Filtert de broncode om te garanderen dat deze zelfvoorzienend, uitvoerbaar en binnen de context windows past.
2. SPL Unit Test Generatie & Verificatie: De Solver genereert unit tests voor de broncode. De Questioner analyseert de uitvoeringsresultaten; als er fouten optreden, repareert de Solver de tests of de code. Deze loop gaat door totdat de tests slagen (tot een bepaalde drempelwaarde).
3. Initiële Translatie: De Questioner vraagt om een translatie naar de doeltaal, en de Solver produceert de initiële code.
4. Translatie Verificatie & Verfijning: De vertaalde code wordt gecompileerd en uitgevoerd tegen de unit tests. De Questioner evalueert de resultaten en instrueert de Solver om de translatie te verfijnen op basis van fouten. Deze iteratieve loop legt probleemoplossende trajecten vast.
5. Duo-Test Verificatie: Een laatste fase waarborgt de functionele equivalentie tussen de broncode en de vertaalde programma's door de outputs te vergelijken. Succesvolle translaties en hun volledige dialooggeschiedenissen worden opgeslagen als geverifieerde data.

Dataset Constructie

De pipeline produceert twee soorten dataformaten voor fine-tuning:

• Dialoog-niveau: Volledige multi-turn gesprekken die het gehele workflow vastleggen.
• Question–Solution (QS) Paren: Atomaire uitwisselingen geëxtraheerd uit dialogen, waarbij het redeneren wordt gedecomposeerd in fijnmazige stappen.

De auteurs hebben deze pipeline geïnstantieerd voor twee taken: Fortran→C++ en C++→CUDA, waarbij respectievelijk 3.64k en 3.93k dialogen werden gegenereerd. Deze werden verder gedecomposed in meer dan 14.1k (Fortran→C++) en 12.7k (C++→CUDA) QS-paren.

Belangrijkste Bijdragen

1. Geautomatiseerde Dialoog Generatie Pipeline: Een framework dat wordt gedreven door een dual-LLM Questioner–Solver module die externe kennis (compilers, runtimes) integreert in gestructureerde redeneersporen, waarmee verder wordt gegaan dan statische code-paren.
2. Nieuwe Translatie Benchmarks: Grootschalige datasets van geverifieerde translaties met unit tests voor Fortran→C++ en C++→CUDA, vergezeld van drie disjuncte testsuites voor rigoureuze evaluatie.
3. Validatie van Data Structureringsstrategieën: De auteurs tonen aan dat verschillende dataformaten optimaliseren voor verschillende taken. Het decomponeren van dialogen in fijnmazige QS-Paren is zeer effectief voor het beheersen van syntactische complexiteit, terwijl het gebruik van het volledige Dialoog-traject superieur is voor het behoud van semantische correctheid.

Experimentele Resultaten

De auteurs evalueerden de aanpak door mid-size open-weight modellen (CodeLlama-13B, DeepSeek-Coder-6.7B, Qwen2.5-7B) te fine-tunen op de gegenereerde data.

• Functionele Correctheid: Fine-tuning op de gegenereerde data leverde dramatische verbeteringen op. Op de uitdagende C++→CUDA taak steeg de unit test succesrate van het CodeLlama-13B model van 12.5% naar 68.8% (een stijging van >56%) wanneer getraind op QS-Pair data. Op dezelfde wijze zag de Fortran→C++ translatie CodeLlama-13B verbeteren van 42.3% naar 74.1%.
• Debug-Round Winsten: Modellen getraind op dialoogdata vertoonden consistente verbeteringen over meerdere debug-rondes, waarbij ze modellen getraind op statische code-paren overtroffen op het gebied van compilatie, executie en unit-test succes.
• Concurrentie met Propriëtaire Systemen: Een dialoog-getunede Qwen2.5-7B model presteerde aanzienlijk beter dan grotere propriëtaire systemen (Gemini 2.5 Flash, Llama 4 Scout 17B) op sleutelmetrieken zoals compilatie- en executie-succes, wat de kostenefficiëntie van dialoog-gecentreerde supervisie benadrukt.
• CodeBLEU Scores: De gefinetunede modellen vertoonden consistente verbeteringen in CodeBLEU scores, wat duidt op een betere syntactische en structurele afstemming met referentie-oplossingen.

Betekenis

Het artikel stelt dat dialoog-gestuurde supervisie consistent de functionele correctheid verbetert over meerdere open-weight modelfamilies, met name in domeinen met weinig middelen waar traditionele parallelle corpora niet beschikbaar zijn. Door gestructureerd redeneren (compilerfeedback, foutcorrectiestappen) in de dataset in te bedden, stelt de aanpak LLM's in staat om niet alleen het eindresultaat van de translatie te leren, maar ook het proces waarbij correctheid wordt bereikt. De resultaten suggereren dat deze methode een kosteneffectieve weg biedt naar state-of-the-art prestaties voor legacy code modernisering, waardoor kleinere open-weight modellen grotere propriëtaire systemen kunnen evenaren of overtreffen. De auteurs merken op dat hoewel het framework zich richt op functionele correctheid als een noodzakelijke eerste stap, toekomstig werk zich zal richten op het incorporeren van prestatiebewuste evaluatiemetrieken.