Using Mutation-Analysis to Examine an LLM's Ability to Summarize Code

Technische Samenvatting: Het gebruik van Mutatie-analyse om het vermogen van een LLM te onderzoeken om code te samenvatten

Probleemstelling
Nu ontwikkelaars steeds vaker vertrouwen op Large Language Models (LLM's) voor het samenvatten van code om documentatie, testen en reviews te ondersteunen, ontstaat er een kritiek punt van zorg met betrekking tot de nauwkeurigheid van deze samenvattingen. LLM's genereren vaak zelfverzekerde beschrijvingen gebaseerd op de bedoelde logica of bekende algoritmische patronen van de code, in plaats van op het werkelijke gedrag van de code. Dit verschil is bijzonder gevaarlijk wanneer subtiele wijzigingen, zoals randgevallen of kleine logische aanpassingen, de werking van een programma veranderen zonder dat het uiterlijk verandert. Bestaande evaluatiemethoden, die vertrouwen op n-gram overlap-metrieken (BLEU, ROUGE) of LLM-gebaseerde evaluatoren, falen vaak in het correleren met menselijk oordeel wat betreft semantische correctheid. Bovendien is er een gebrek aan systematische kaders om te bepalen of een gegenereerde samenvatting daadwerkelijk de onderliggende werking van de code volgt of slechts reflectieert van oppervlakkige tekstuele patronen.

Methodologie: Mutatie-gebaseerde Evaluatie
De auteurs stellen een mutatie-gebaseerde evaluatiemethodologie voor om direct te testen of de samenvatting van een LLM de specifieke logica van de verstrekte code weerspiegelt. De kern van het uitgangspunt is dat als een samenvatting het gedrag van de code accuraat beschrijft, deze moet veranderen wanneer het gedrag van de code wordt gewijzigd. Het experimentele proces bestaat uit drie hoofdfasen:

1. Genereren van Mutanten: Gerichte mutaties worden geïnjecteerd in de originele codesamples. Deze mutaties worden gecategoriseerd in drie typen:

   • Statement-mutaties: Het verwijderen, dupliceren of herordenen van statements om de executievolgorde te wijzigen.
   • Waarde-mutaties: Het wijzigen van parameters of constante waarden.
   • Beslissings-mutaties: Het wijzigen van rekenkundige of logische operatoren om de beslissingslogica te beïnvloeden.
     Mutaties worden op specifieke locaties geplaatst (begin, midden, eind) om aandachtmechanismen te testen.

2. Genereren van Samenvattingen: De LLM krijgt de instructie ("Leg de volgende code snippet in gewone mensentaal uit") om samenvattingen te genereren voor zowel de originele code als de gemuteerde varianten. De temperatuur wordt ingesteld op 0 om deterministische output te garanderen.

3. Vergelijken van Samenvattingen: Menselijke evaluatoren vergelijken de samenvatting van de gemuteerde code met de originele. Een resultaat wordt geclassificeerd als Positief als de samenvatting de gedragsverandering expliciet reflecteert (bijv. het vermelden van een andere conditie of een andere retourwaarde). Het wordt geclassificeerd als Negatief als de samenvatting identiek blijft aan de originele beschrijving of de verwachte algoritmische intentie beschrijft in plaats van het werkelijke gemuteerde gedrag.

Belangrijkste Bijdragen
De primaire bijdrage van dit werk is de vestiging van mutatie-analyse als een systematisch evaluatiekader voor code-samenvatting. De auteurs valideren deze methodologie via drie complementaire experimenten:

1. Gecontroleerde Synthetische Dataset: 12 Python-programma's verspreid over vier complexiteitscategorieën (Enkele Functie, Enkele Klasse, Meerdere Klassen, Multi-threaded) met in totaal 324 mutaties.
2. Validatie met Menselijke Code: Evaluatie op 50 programma's uit de Less Basic Python Problems (LBPP) dataset om te waarborgen dat de bevindingen generaliseren buiten door modellen gegenereerde code.
3. Cross-Model Vergelijking: Een directe vergelijking tussen GPT-4 en GPT-5.2 met behulp van dezelfde LBPP-subset om generationele verbeteringen te meten.

Belangrijkste Resultaten

• Impact van Complexiteit: Voor GPT-4 neemt de nauwkeurigheid van de samenvatting scherp af naarmate de programmacomplexiteit toeneemt. De nauwkeurigheid daalt van 76,5% voor single-function programma's naar 17,3% voor multi-threaded systemen. Programmagrootte correleert ook negatief met nauwkeurigheid (mediaan 60 LOC voor positieve gevallen versus 116 LOC voor negatieve gevallen).
• Mutatietype en Locatie: Mutatietype en locatie hebben over het algemeen een zwakker effect op de nauwkeurigheid vergeleken met complexiteit. Echter, waarde-mutaties worden vaak betrouwbaarder gedetecteerd dan statement- of beslissings-mutaties, behalve in multi-threaded contexten waar waarde-mutaties significant degraderen.
• Foutmodi: De analyse identificeert twee primaire foutmodi:
  1. Abstractie: De samenvatting is te hoog niveau en laat de gemuteerde logica volledig weg.
  2. Intentie-hallucinatie: Het model beschrijft het verwachte gedrag van een bekend algoritme (bijv. Merge Sort, Kruskal's) in plaats van het werkelijke gemuteerde gedrag, waarbij afwijkingen van canonieke patronen worden genegeerd.
• Menselijke Code: De geobserveerde foutpatronen in synthetische data houden stand in menselijke code (LBPP), waarbij GPT-4 een detectiegraad van mutaties van 49,3% bereikt. Dit bevestigt dat de beperkingen geen artefacten zijn van door modellen gegenereerde code.
• Modelgeneraties: GPT-5.2 vertoont een substantiële verbetering ten opzichte van GPT-4, met een detectiegraad van 85,3% op de LBPP-dataset (een stijging van 36,0 procentpunt). GPT-5.2 vertoont ook een nieuwe capaciteit om mutaties te identificeren als "bugs" of "fouten" in bijna de helft van de gedetecteerde gevallen. Het worstelt echter nog steeds met complexe controleflow-wijzigingen en slaagt er niet in om implementatiedetails van standaardpatronen te onderscheiden in ongeveer 15% van de gevallen.

Betekenis en Claims
Het artikel beweert dat mutatie-analyse een praktische, reproduceerbare stresstest biedt om te beoordelen of door LLM gegenereerde samenvattingen het programma-gedrag reflecteren in plaats van oppervlakkige patronen. De auteurs positioneren deze methodologie als een noodzakelijke voorloper van verbetering, die een manier biedt om:

• Modellen, prompts en datasets direct te vergelijken onder gecontroleerde omstandigheden.
• Te verifiëren of verbeteringen in samenvatting (via fine-tuning, prompting of nieuwe modellen) echt zijn in plaats van louter stilistisch.
• IDE-ontwikkelaars en onderzoekers te voorzien van meetbare metrieken om te bepalen of het wisselen van modellen of het aanpassen van tools tastbare voordelen oplevert voor specifieke use cases.

De auteurs blijven bescheiden en merken op dat hoewel GPT-5.2 aanzienlijke vooruitgang boekt, een succespercentage van 85,3% op eenvoudige single-function code nog steeds een niet-verwaarloosbare foutmarge achterlaat die problematisch kan zijn voor systemen met een hoog risico. Het werk claimt niet het probleem van codebegrip op te lossen, maar biedt een rigoureuze methode om de kloof te meten tussen de samenvatting van een LLM en de werkelijke logica van de code.