Technische Samenvatting: RGFL: Reasoning Guided Fault Localization voor Automated Program Repair met Large Language Models

Probleemstelling

Automated Program Repair (APR) vertrouwt zwaar op Fault Localization (FL) om de specifieke codegebieden te identificeren die verantwoordelijk zijn voor een bug voordat er geprobeerd wordt een fix te genereren. In moderne, grootschalige software-repositories (vaak met miljoenen tokens) is het verstrekken van de volledige codebase aan Large Language Models (LLM's) onhaalbaar vanwege beperkingen in het contextvenster. Daarom moeten APR-systemen eerst een kleine, relevante subset van de code isoleren.

Traditionele FL-technieken (bijv. spectrum-gebaseerde analyse, statische analyse of informatie-retrieval op basis van lexicale gelijkenis) falen vaak in het vastleggen van diepe semantische links tussen bugrapporten en code, vooral wanneer bugs voortkomen uit subtiele logische fouten of domeinspecifieke gedragingen. Hoewel recente LLM-gebaseerde benaderingen proberen fouten te lokaliseren door code te extraheren op basis van gelijkenis of door modellen te vragen relevante functies op te sommen, ontbreekt het hen vaak aan expliciete redenering over waarom een specifiek code-element relevant is. Dit kan leiden tot de selectie van oppervlakkig gerelateerde maar causaal incorrecte elementen, wat de daaropvolgende reparatiefase belemmert.

Methodologie

De auteurs stellen RGFL (Reasoning Guided Fault Localization) voor, een nieuwe hiërarchische aanpak die expliciete LLM-redenering integreert in de lokalisatie-pipeline. De methode is ontworpen als een modulaire verbetering voor bestaande pipeline-gebaseerde APR-systemen (specifiek geïntegreerd met Agentless).

Kerncomponenten

1. Hiërarchische Redeneringsmodule:
   In plaats van een LLM te vragen om een grote set kandidaten simultaan te rangschikken (wat de aandacht kan verwateren), verwerkt RGFL kandidaten individueel.

   • File-Level Localization: Het systeem haalt eerst een kandidaatset van bestanden op met behulp van een combinatie van LLM-prompting en embedding-gebaseerde zoekopdrachten. Voor elk kandidaatbestand wordt de LLM gepromptt om een natuurlijke taalverklaring te generen over de functionaliteit van het bestand in de context van het specifieke bugrapport. Deze verklaringen worden vervolgens gebruikt om de bestanden opnieuw te rangschikken.
   • Element-Level Localization: Binnen de hoogst gerangschikte bestanden extraheert het systeem klassen, functies en globale variabelen. Vergelijkbaar met het niveau van de bestanden, genereert de LLM redenering voor elk element met betrekking tot de relevantie voor de bug. Deze redeneringsoutputs dienen als het signaal voor het rangschikken.

2. Tweestaps-rangschikkingsschema:
   De methode maakt gebruik van een tweestaps-rangschikkingsproces dat combineert:

   • LLM-gebaseerde Rangschikking: De LLM evalueert de gegenereerde redenering tegen het bugrapport om een gerangschikte lijst te produceren.
   • Embedding-gebaseerde Rangschikking: Als vergelijking en alternatief worden de gegenereerde redenering en bugrapporten ge-embedded (met modellen zoals Gemini-embedding-001, Voyage 3.5, of text-embedding-3-small) en gerangschikt via cosinus-gelijkenis. De studie stelt vast dat directe LLM-rangschikking beter presteert dan embedding-gebaseerde rangschikking van de redenering.

3. Integratie en Omvang:

   • RGFL vervangt de file- en element-lokalisatiefases van de Agentless-pipeline, maar laat de line-level localization en patch generation ongewijzigd. De auteurs beargumenteren dat redenering op regelniveau (line-level) slecht gedefinieerd is voor geïsoleerde regels en computationeel te kostbaar is voor grote repositories.
   • Het systeem gebruikt een "Reasoning-first" strategie: gegeven een vaste set kandidaten, legt de LLM elk exemplaar individueel uit voordat er gerangschikt wordt.

Belangrijkste Bijdragen

1. Nieuwe Hiërarchische Redeneringsmodule: Het ontwerp van een systeem waarbij LLM's gestructureerde, bug-specifieke verklaringen genereren voor kandidaat-bestanden en -elementen, waarbij deze verklaringen als het primaire signaal voor rangschikking dienen in plaats van ruwe code-gelijkenis.
2. Systematische Evaluatie en Ablatie: De auteurs integreren RGFL in Agentless en voeren een systematische studie uit om de impact van file- versus element-lokalisatie te isoleren. Ze introduceren een counterfactual upper-bound analyse om te kwantificeren hoeveel elke lokalisatiefase bijdraagt aan het uiteindelijke succes van de reparatie.
3. Cross-Dataset en Cross-Language Validatie: De evaluatie wordt uitgevoerd op SWE-bench Verified, SWE-bench Lite, en SWE-bench Java, waarbij zowel Python- als Java-projecten worden behandeld.
4. Verfijnde Foutentaxonomie: De paper categoriseert fouten in file-level, element-level, line-level en repair-level misses, waarbij gecontroleerde counterfactual injecties van grondwaarheid (ground-truth) worden gebruikt om prestatie-upper bounds te schatten.

Experimentele Resultaten

De evaluatie toont consistente verbeteringen over state-of-the-art baselines, inclusief Agentless, OpenHands en AutoCodeRover.

• File-Level Localization (SWE-bench Verified):

  • Hit@1 verbeterde van 71,4% (Agentless) naar 85% (RGFL).
  • MRR verbeterde van 81,8% naar 88,8%.
  • Embedding-gebaseerde herrangschikking van redenering slaagde er niet in om de prestaties van directe LLM-rangschikking te evenaren, wat de noodzaak van natuurlijke taalredenering boven vector-gelijkenis alleen benadrukt.

• Element-Level Localization:

  • Exact Match (binnen de top-3 bestanden) steeg van 36% (Agentless) naar 69% (RGFL).
  • Dit vertegenwoordigt een verbetering van 91,67% ten opzichte van het baseline Agentless-systeem.

• End-to-End Repair Success:

  • Het integreren van RGFL in Agentless verhoogde de Resolved Rate op SWE-bench Verified van 51,6% naar 58,2%.
  • Dit komt overeen met een absolute verbetering van 12,8% in end-to-end reparatiesucces.

• Generaliseerbaarheid:

  • RGFL behield superieure prestaties op SWE-bench Java, waarbij het baselines zoals OpenHands en OrcaLoca versloeg, wat robuustheid over programmeertalen aantoont.

• Counterfactual Analyse:

  • De studie onthulde dat hoewel fouten in de file-lokalisatie minder frequent zijn, het corrigeren ervan de hoogste opbrengst per instantie oplevert.
  • Interessant genoeg, in sommige gevallen waar het juiste bestand werd geïdentificeerd, maakte het verstrekken van alleen het bestand (zonder specifieke element-lokalisatie) het model in staat om correcte patches te genereren, terwijl het overmatig beperken van het model tot specifieke elementen soms tot falen leidde. Dit suggereert dat de granulariteit van lokalisatie-instructies zorgvuldig gebalanceerd moet worden.

Betekenis en Claims

De paper claimt dat expliciete redenering een kritiek, onderbenut mechanisme is in LLM-gebaseerde APR. Door de paradigma te verschuiven van "het selecteren van elementen die gerelateerd klinken" naar "het selecteren van elementen die causaal verantwoordelijk zijn voor de fout", verkleint RGFL de zoekruimte voor reparatie-agents aanzienlijk.

De auteurs stellen dat hun werk een praktisch mechanisme biedt om LLM's aan te passen aan grote, real-world softwaresystemen waar contextlimieten een bottleneck vormen. De resultaten suggereren dat de kosten van extra redenering (ongeveer 3,7x de computationele kosten per sample) gerechtvaardigd zijn door de substantiële winst in lokalisatienauwkeurigheid en het uiteindelijke reparatiesucces. De paper concludeert dat hoewel fault localization een cruciale stap is, de optimale manier om lokalisatie-informatie aan het reparatiemodel te presenteren (file vs. element vs. line) een open onderzoeksgebied blijft, aangezien overmatig granulaire beperkingen soms het vermogen van het model om een correcte patch te synthetiseren kunnen hinderen.