Evaluating Code Reasoning Abilities of Large Language Models Under Real-World Settings

Dit onderzoek introduceert een nieuwe dataset van 1200 programmeerproblemen die, door gebruik te maken van complexe datatypen en programmeerstructuren uit echte repositories, aantoont dat huidige evaluaties van taalmodellen de werkelijke complexiteit van code-redenering onderschatten.

De kern

Stel je voor dat je een examen moet afleggen voor je rijbewijs. De examinator vraagt je alleen: "Wat gebeurt er als je het stuur naar links draait?" Je antwoordt natuurlijk moeiteloos: "Dan gaat de auto naar links." Je scoort een 10/10. Je voelt je een superchauffeur!

Maar dan komt de echte wereld. Je staat op een drukke kruising in het regenachtige Amsterdam. Er is een fietser aan de linkerkant, een tram die voorbijrijdt, een wegwerper die net een bocht maakt, en de weg is glad. De vraag is nu: "Wat gebeurt er als je nu naar links stuurt?"

Nu is het ineens heel ingewikkeld. De onderzoekers van dit paper hebben ontdekt dat we AI (zoals ChatGPT) precies zo behandelen: we geven ze een "examen" met super simpele vragen, en als ze die goed beantwoorden, roepen we: "Wauw, de AI begrijpt code perfect!" Maar in de echte wereld is code niet zo simpel als een rechte weg; het is die drukke, regenachtige kruising.

Wat is dit onderzoek precies?

De onderzoekers hebben een nieuwe "testrit" bedacht genaamd RE2-Bench. In plaats van alleen simpele rekensommetjes te geven, hebben ze 1.200 echte programmeerproblemen uit de praktijk gehaald.

Het probleem met de huidige tests:
De huidige tests voor AI zijn als een kinderspelletje met blokjes. De blokjes zijn altijd hetzelfde, ze passen altijd perfect in elkaar en er is nooit een obstakel. De AI leert die blokjes uit zijn hoofd en lijkt heel slim.

De nieuwe test (RE2-Bench):
De onderzoekers hebben de "blokjes" vervangen door echte, complexe onderdelen uit echte software (zoals die van grote bedrijven). Denk aan:

• Grote stapels informatie: Niet alleen een simpel getalletje, maar een hele doos vol met verschillende soorten gegevens die in elkaar zitten (zoals een digitale kluis met verschillende vakjes).
• De "Dominosteen-factor": In echte code heeft één actie vaak een kettingreactie. Als je aan knop A draait, verandert er iets in kamer B, wat vervolgens een alarm af laat gaan in kamer C.
• Andere gereedschappen: De code gebruikt ook tools van andere programmeurs (API's), wat het nog ingewikkelder maakt.

De schokkende ontdekking

De onderzoekers verdeelden de vragen in twee groepen: Lage Complexiteit (de simpele blokjes) en Hoge Complexiteit (de drukke kruising).

Toen ze de slimste AI-modellen lieten meedoen, gebeurde er iets opvallends:
Zodra de vragen van "simpel" naar "echt" gingen, stortte de score van de AI volledig in!

• Bij het voorspellen van de input (wat gaat erin?) zakte de score met wel 37%.
• Bij het voorspellen van de output (wat komt eruit?) zakte de score met 36%.
• Bij het begrijpen van keuzes in de code (als dit gebeurt, doe dan dat) zakte de score zelfs met bijna 49%!

Waarom is dit belangrijk?

Dit onderzoek is een belangrijke waarschuwing. Het zegt eigenlijk: "We zijn de AI een beetje te veel aan het complimenteren."

Als we AI willen gebruiken om echte software te schrijven of te repareren, mogen we ze niet alleen testen op simpele puzzeltjes. We moeten ze testen in de "echte wereld", met alle chaos, de ingewikkelde kettingreacties en de enorme hoeveelheden informatie die daar bij komen kijken.

Kortom: De AI is een kampioen in het spelen van schaken op een leeg bord, maar we moeten nu gaan kijken of ze ook kunnen overleven in een drukke stad met verkeer, regen en honderden regels verkeerslichten.

Technische samenvatting

Technische Samenvatting: Evaluatie van Code-redeneervermogen van LLM's in Real-World Settings

1. Het Probleem (The Problem)

Huidige evaluaties van de redeneervermogens van Large Language Models (LLM's) op het gebied van code zijn vaak gebaseerd op te eenvoudige datasets (zoals CRUXEval of HumanEval). Deze benchmarks bevatten voornamelijk standalone functies met primitieve datatypen (zoals integers en strings) en weinig onderlinge afhankelijkheden. Dit creëert een vertekend beeld: LLM's scoren hoog op deze eenvoudige taken, maar hun vermogen om te generaliseren naar echte softwareprojecten — die gekenmerkt worden door complexe objecten, API-aanroepen, diepe nesting en inter-class afhankelijkheden — is onbekend. Er is een gebrek aan benchmarks die de werkelijke complexiteit van de echte wereld reflecteren.

2. Methodologie (Methodology)

De auteurs introduceren RE2-Bench (Realistic Reasoning benchmark), een dataset van 1.200 redeneerproblemen. De methodologie omvat drie kernonderdelen:

• Dataset Constructie: Problemen zijn verzameld uit bestaande benchmarks en direct gemined uit populaire GitHub Python-repositories en SWE-bench. Om realistische context te bieden, gebruiken ze dynamic slicing: een methode wordt gepresenteerd samen met alle methoden die direct of indirect worden aangeroepen tijdens de uitvoering.
• Variabele Serialisatie: In tegenstelling tot eerdere studies, die alleen primitieve types gebruiken, gebruikt RE2-Bench statische en dynamische analyse om complexe, aangepaste objecten recursief te decomponeren en te converteren naar een JSON-structuur. Dit stelt het model in staat om de interne staat van complexe objecten te "begrijpen".
• Complexiteitscategorisering: De auteurs gebruiken negen verschillende metrieken (zoals cyclomatische complexiteit, geneste constructen, en afhankelijkheden tussen klassen) om problemen te categoriseren. Via een majority-vote mechanisme en statistische validatie (Silhouette Analysis en Davies–Bouldin Index) worden de problemen verdeeld in twee groepen: Lower Complexity (LC) en Higher Complexity (HC).

3. Belangrijkste Bijdragen (Key Contributions)

• RE2-Bench & RE2-Bench-lite: Een nieuwe, robuuste benchmark die de kloof overbrugt tussen academische tests en echte softwareontwikkeling.
• Geautomatiseerde Pipeline: Een systeem dat complexe variabelen kan serialiseren en de uitvoering van LLM-voorspellingen kan valideren via testexecutie (in plaats van alleen tekstvergelijking).
• Taxonomie van Fouten: Een systematische categorisering van 18 soorten redeneerfouten (bijv. Call Stack Confusion, Loop Variable Misunderstanding, en Incorrect Type Resolution), wat inzicht geeft in waar modellen tekortschieten.
• Nieuwe Evaluatiemetrieken: Introductie van $RS_{partial}$ om de mate van gedeeltelijke correctheid te meten, wat een eerlijker beeld geeft bij complexe objecten dan een binaire succes/faal-metriek.

4. Resultaten (Results)

De evaluatie van tien LLM's (waaronder reasoning-modellen en algemene modellen) op vier taken (input-, output-, loop- en branch-predictie) toonde significante bevindingen:

• Prestatiedaling: Er is een drastische daling in prestaties wanneer modellen overgaan van LC- naar HC-problemen. De gemiddelde daling in succes ($RS$) is:
  • Input-predictie: 37,36%
  • Output-predictie: 36,16%
  • Loop-predictie: 20,90%
  • Branch-predictie: 48,60%
• Redeneringsrichting: Modellen presteren beter bij forward reasoning (output voorspellen) dan bij backward reasoning (input voorspellen).
• Impact van Constructen: Diep geneste constructen (loops en conditionele statements) zijn de grootste uitdaging voor de redeneervermogens van LLM's.
• Reasoning Effort: Modellen die specifiek zijn getraind voor intensiever redeneren (hoge 'reasoning effort') presteren consistent beter, maar de daling bij toenemende complexiteit blijft aanwezig.

5. Betekenis (Significance)

Dit onderzoek bewijst dat de huidige claims over de superieure code-redeneervermogens van LLM's grotendeels geïnfleerd of onrealistisch zijn, omdat ze gebaseerd zijn op te eenvoudige scenario's. RE2-Bench biedt een noodzakelijk instrument voor de volgende generatie LLM-ontwikkeling: het stelt ontwikkelaars in staat om modellen gericht te trainen op de structurele en logische complexiteit die essentieel is voor echte software engineering, in plaats van enkel te optimaliseren voor eenvoudige algoritmen.