Enhancing Large Language Models with Retrieval Augmented Generation for Software Testing and Inspection Automation

Probleemstelling

De softwareontwikkelcyclus (SDLC) vereist uitgebreide Verificatie en Validatie (V&V) activiteiten, zoals softwaretesten en code-inspectie (review). Hoewel Large Language Models (LLMs) veelbelovend zijn voor het automatiseren van deze taken, kampen ze met een significant probleem: hallucinaties. LLMs genereren vaak zelfverzekerd maar onjuiste informatie, wat leidt tot fouten in gegenereerde testcases of het over het hoofd zien van bugs in code.

Traditionele methoden voor V&V zijn vaak tijdrovend en arbeidsintensief (bijvoorbeeld handmatige inspecties vinden gemiddeld 60% van de fouten). Bestaande geautomatiseerde oplossingen worstelen vaak met de informele aard van documentatie en inconsistenties in code. De kernuitdaging is dus het verbeteren van de betrouwbaarheid en nauwkeurigheid van LLMs in deze kritieke fasen zonder de menselijke kosten en tijd te verhogen.

Methodologie

De auteurs stellen een nieuw kader voor dat Retrieval-Augmented Generation (RAG) integreert in de LLM-pijplijn voor twee specifieke V&V-taken:

1. Automatische Code-inspectie: Het detecteren en classificeren van bugs in broncode.
2. Automatische Generatie van Testcases: Het creëren van unit tests die de code afdekken.

De RAG-Pijplijn:

• Kennisbron: Als externe kennisbasis wordt de MBPP-dataset (Mostly Basic Python Programming) gebruikt, die 1000 crowd-sourced Python-codefragmenten bevat die als "gouden standaard" (foutloos) dienen.
• Embedding: Documenten uit de kennisbron worden omgezet in vectorrepresentaties (embeddings) met behulp van een MiniLM-L6-V2 sentence transformer.
• Retrieval: Wanneer een query (bijv. een stukje code dat geïnspecteerd moet worden) wordt ingediend, zoekt het systeem via cosine-afstand de meest relevante documenten in de vectoropslag.
• Generatie: De gevonden context wordt samengevoegd met de oorspronkelijke prompt en naar de LLM gestuurd. Dit verrijkt de context en helpt de LLM om gebaseerd op feitelijke voorbeelden te redeneren in plaats van te hallucineren.

Experimenteel Opzet:

• Datasets:
  • Voor inspectie: Bug In the Code Stack dataset (4.010 taken, inclusief bug-vrije en buggy code).
  • Voor testgeneratie: TestEval dataset (210 taken van LeetCode).
• Modellen: Verschillende OpenAI-modellen werden getest: GPT-3.5 Turbo, GPT-4 en GPT-4o.
• Vergelijking: De prestaties van LLMs met RAG werden vergeleken met dezelfde modellen zonder RAG, en in het geval van inspectie ook met een menselijke benchmark van 60% nauwkeurigheid.
• Metrieken:
  • Inspectie: Nauwkeurigheid (match/mismatch met ground truth), type-bug detectie.
  • Testgeneratie: Compilatiesucces, uitvoeringssucces, en dekking (line, branch, path coverage) gemeten via pytest-cov en cov@k.
  • Efficiëntie: Runtime.

Belangrijkste Bijdragen

1. Novel Framework: Een geïntegreerde RAG-pijplijn specifiek ontworpen voor software V&V-taken (testgeneratie en code review).
2. Empirische Validatie: Een uitgebreide experimentele studie die aantoont dat RAG de hallucinaties vermindert en de prestaties verbetert ten opzichte van standaard LLMs.
3. Benchmarking: Een gedetailleerde vergelijking van meerdere LLM-modellen (GPT-3.5, GPT-4, GPT-4o) in zowel met als zonder RAG-configuratie, inclusief analyse van runtime-impact.
4. Open Source: De beschikbaarheid van de code en data voor reproduceerbaarheid.

Resultaten

1. Automatische Code-inspectie:

• Nauwkeurigheid: RAG leidde tot een aanzienlijke stijging in de detectienauwkeurigheid.
  • GPT-3.5 Turbo steeg van 66,78% (zonder RAG) naar 90,57% (met RAG).
  • GPT-4 en GPT-4o vertoonden vergelijkbare verbeteringen (van ~73-84% naar ~89-90%).
• Bug-typen: RAG-modellen presteerden consistent beter bij het identificeren van specifieke fouten zoals 'mismatched quotation', 'mismatched bracket' en 'keyword as identifier'.
• Efficiëntie: De runtime-impact varieerde per model. GPT-3.5 Turbo werd langzamer door de retrieval-overhead (+15 min), terwijl GPT-4o juist sneller werd (-8 min), wat suggereert dat de context de generatie voor dit model efficiënter maakte.

2. Automatische Testgeneratie:

• Dekking: RAG-versterkte modellen behaalden over het algemeen een hogere code-dedking (line en branch coverage) en een hogere cov@k score.
  • Voor GPT-3.5 Turbo steeg de branch coverage (bij k=5) van 84,43% naar 87,10%.
• Compilatie en Uitvoering: Er was een duidelijke verbetering in het succespercentage van compilatie en uitvoering bij gebruik van RAG.
• Efficiëntie: GPT-3.5 Turbo werd sneller met RAG (besparing van ~3,5 minuten), terwijl GPT-4o langzamer werd (+14 minuten), wat aangeeft dat de overhead van het ophalen van context voor het grotere model zwaarder weegt dan de winst in generatie-efficiëntie.

Betekenis en Conclusie

Het artikel concludeert dat het integreren van Retrieval-Augmented Generation (RAG) een over het algemeen positieve impact heeft op de automatisering van softwaretesten en inspectie.

• Kostenreductie: Door de nauwkeurigheid te verhogen (vaak boven de menselijke benchmark van 60% uitkomend bij inspectie), wordt de tijd die menselijke testers en inspecteurs kwijt zijn aan het controleren van AI-outputs verminderd.
• Betrouwbaarheid: RAG vermindert hallucinaties aanzienlijk, waardoor LLMs meer betrouwbare partners worden in de SDLC.
• Nuance in Efficiëntie: Hoewel RAG de kwaliteit verbetert, is de impact op de snelheid model-afhankelijk. Voor sommige modellen (zoals GPT-4o in inspectie) versnelt het proces, terwijl het voor andere (zoals GPT-3.5 in testgeneratie) de snelheid kan vertragen door de zoekoverhead.

De auteurs benadrukken dat dit een stap is richting adaptieve, contextbewuste automatisering, maar dat toekomstig werk nodig is om de retrieval-strategieën te optimaliseren (bijv. adaptief ophalen) en de methoden te testen op grotere, industriële datasets.