🤖 AI

Protocode: Prototype-Driven Interpretability for Code Generation in LLMs

Dit artikel stelt een prototype-gestuurde aanpak voor die gebruikmaakt van AST-gebaseerde analyse om automatisch hoogwaardige In-Context Learning-demonstraties te samplen, waardoor zowel de interpreteerbaarheid als de prestaties van Large Language Models bij codegeneratietaken gelijktijdig worden verbeterd.

Oorspronkelijke auteurs: Krishna Vamshi Bodla, Haizhao Yang

Gepubliceerd 2026-01-22

📖 5 min leestijd🧠 Diepgaand

CC0 1.0

Oorspronkelijke auteurs: Krishna Vamshi Bodla, Haizhao Yang

Oorspronkelijk artikel vrijgegeven aan het publieke domein onder CC0 1.0 (http://creativecommons.org/publicdomain/zero/1.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je voor dat je een zeer slimme, maar lichtelijk verwarde robot probeert te leren hoe hij computercode moet schrijven. Je kunt de robot niet simpelweg een tekstboek geven; in plaats daarvan toon je eerst een paar goede voorbeelden van code aan hem. Dit wordt In-Context Learning (ICL) genoemd. De robot kijkt naar jouw voorbeelden en probeert de stijl en logica ervan te kopiëren om een nieuw probleem op te lossen.

Het probleem is: Welke voorbeelden moet je de robot laten zien?

Als je de robot slechte voorbeelden laat zien, raakt hij in de war en schrijft hij buggy code. Als je hem perfecte voorbeelden laat zien, blinkt hij uit. Maar het vinden van de "perfecte" voorbeelden is moeilijk. De meeste mensen kiezen simpelweg voorbeelden die aan de oppervlakte op elkaar lijken, maar dat werkt niet altijd.

Dit artikel introduceert een nieuwe methode genaamd Protocode om dit op te lossen. Zie dit als een "Slimme Voorbeeldselector" die een speciale kaart gebruikt om de beste voorbeelden te vinden.

Zo werkt het, onderverdeeld in eenvoudige concepten:

1. De "Manifold" Kaart (Het vinden van de vorm van data)

Stel je voor dat al de verschillende programmeerproblemen (zoals "sorteer een lijst" of "bereken een vierkantswortel") punten zijn die zweven in een gigantische, meerdimensionale kamer.

De Oude Manier: Mensen kiezen meestal het punt dat het dichtst bij het punt ligt dat ze proberen op te lossen. Maar soms is het dichtstbijzijnde punt een "valstrik"-voorbeeld dat er weliswaar hetzelfde uitziet, maar een totaal andere logica heeft.
De Protocode Manier: De auteurs realiseerden zich dat deze punten niet zomaar willekeurig verspreid liggen; ze vormen onzichtbare, gebogen vormen (zoals een gekreukeld stuk papier), genaamd manifolds.
De Analogie: Stel je voor dat de data een berglandschap is. De oude methode kiest gewoon de dichtstbijzijnde piek. Protocode kijkt naar de vorm van het berglandschap zelf. Het vindt de "prototypes"—de meest representatieve, perfecte voorbeelden die precies in het hart van een specifieke vallei of piek liggen. Het gebruikt een techniek genaamd Piecewise-Linear Manifold Learning om deze vormen nauwkeurig te traceren, waardoor het gegarandeerd is dat het gekozen voorbeeld echt representatief is voor dat type probleem, en niet slechts een willekeurige buurman.

2. De "Proxy" Anker (De Magneet)

Zodra de kaart is getekend, moet het systeem het beste voorbeeld voor elke categorie kiezen (zoals "Python loops" of "Java classes").

De Analogie: Stel je voor dat je voor elk type code een magneet hebt (een Proxy). Je laat alle trainingsvoorbeelden in de kamer vallen. De magneet trekt de voorbeelden aan die erbij horen.
De Magie: Het systeem kiest niet alleen de dichtstbijzijnde; het leert de magneten te bewegen zodat ze de beste voorbeelden aantrekken en de slechte voorbeelden afstoten. Dit gebeurt met een wiskundige truc genaamd Proxy-Anchor Loss. Dit zorgt ervoor dat het gekozen voorbeeld een "kampioen" is voor zijn groep, waardoor het de meest betrouwbare leraar voor de robot wordt.

3. De "X-Ray" Visie (AST Analyse)

Zodn de robot code heeft geschreven met behulp van deze slimme voorbeelden, hoe weten we dan waarom hij schreef wat hij schreef?

Het Probleem: Meestal is AI-code een "black box". We zien de input en de output, maar we weten niet welk deel van het voorbeeld de robot ertoe heeft aangezet om een specifieke regel te schrijven.
De Oplossing: De auteurs gebruiken een hulpmiddel genaamd een Abstract Syntax Tree (AST). Denk aan code niet als een zin, maar als een stamboom.
- De "bladeren" zijn de individuele woorden (tokens).
- De "takken" zijn de structuren (zoals if-statements, loops of functies).
De Analogie: De auteurs schijnen een röntgenstraal (X-ray) op de code. Ze traceren de "invloed" terug van de output van de robot naar het specifieke voorbeeld dat aan hem werd getoond.
- Resultaat: Ze kunnen zeggen: "De robot gebruikte deze specifieke for-loop structuur omdat hij sterk werd beïnvloed door Voorbeeld A, maar hij gebruikte dit error-handling blok omdat hij werd beïnvloed door Voorbeeld B."
- Dit maakt de code interpreteerbaar. Je kunt precies zien welke delen van de code "veilig" zijn en welke delen mogelijk riskant zijn omdat ze zijn gekopieerd van een zwakker voorbeeld.

Wat hebben ze gevonden?

De onderzoekers hebben dit getest op verschillende AI-modellen (zoals Qwen, Llama en StarCoder) met behulp van een standaard codetest genaamd MBPP.

Betere Resultaten: Wanneer ze hun "Slimme Voorbeeldselector" (Protocode) gebruikten, schreven de robots betere code. Ze slaagden voor meer tests (specifiek de pass@10 metriek, die controleert of de juiste code in de top 10 van gissingen voorkomt) vergeleken met het gebruik van willekeurige voorbeelden of simpelweg de "dichtstbijzijnde" te kiezen.
Het Gevaar van Slechte Voorbeelden: Ze ontdekten dat als je de verkeerde voorbeelden koos (slecht gekozen ICL-demonstraties), de robot zelfs slechter presteerde dan wanneer je hem helemaal geen voorbeelden had gegeven. Dit bewijst dat kwaliteit belangrijker is dan kwantiteit.
Begrip van de Code: De "X-ray" analyse liet zien dat de robot het meest zelfverzekerd was in de gestructureerde delen van de code (zoals datastructuren en functies), maar soms moeite had met complexe foutafhandeling (error handling), ongeacht de gebruikte voorbeelden.

De Kernboodschap

Dit artikel gaat over het leren van AI om een betere student te worden door het betere huiswerk-voorbeelden te geven.

Kies niet alleen vergelijkbare voorbeelden; kies de voorbeelden die echt de "vorm" van het probleem vertegenwoordigen.
Gebruik wiskunde om de "kampioen"-voorbeelden te vinden voor elke categorie.
Kijk onder de motorkap om precies te zien welke voorbeelden de beslissingen van de AI hebben beïnvloed, wat de code veiliger en begrijpelijker maakt.

Door dit te doen, kunnen ontwikkelaars de AI meer vertrouwen, wetende waarom de AI een specifiek stuk code heeft gegenereerd en ervoor te zorgen dat het niet zomaar een slechte gewoonte heeft overgenomen van een slecht voorbeeld.

Technische Samenvatting: Prototype-gestuurde Interpreteerbaarheid voor Codegeneratie in LLM's

Probleemstelling

Hoewel Large Language Models (LLM's) de capaciteiten voor codegeneratie aanzienlijk hebben geavanceerd, brengt hun afhankelijkheid van geautomatiseerde oplossingen risico's met zich mee voor suboptimale of onveilige code. Er bestaat een kritieke kloof in de interpreteerbaarheid van deze modellen, specifiek voor taken gerelateerd aan codegeneratie. Bestaande interpreteerbaarheidsmethoden zijn vaak generiek of computationeel te kostbaar wanneer ze op code worden toegepast. Zo vereisen methoden zoals ASTrust het opslaan van waarschijnlijkheidsverdelingen over de volledige vocabulaire bij elke generatiestap, wat leidt tot een slechte schaalbaarheid met de outputlengte. Daarentegen introduceren methoden zoals Code-Q herhaaldelijk samplen, wat een significante overhead tijdens de inferentie veroorzaakt. Bovendien staat bekend dat de selectie van In-Context Learning (ICL) demonstraties een cruciale impact heeft op de prestaties van het model; slecht gekozen voorbeelden kunnen de prestaties verlagen tot onder het niveau van het basismodel, terwijl efficiënte, principiële samplingstrategieën nog onvoldoende zijn onderzocht.

Methodologie

De auteurs stellen Protocode voor, een framework dat prototype-gestuurde ICL-sampling verenigt met Abstract Syntax Tree (AST)-gegronde attributie om zowel de modelprestaties als de interpreteerbaarheid te verbeteren. De methodologie bestaat uit twee primaire stadia:

1. Prototype Sampling via Joint Manifold en Metric Learning

In plaats van statistische samenvattingen te gebruiken (bijv. klassengemiddelden) die de intrinsieke datageometrie niet goed vastleggen, hanteren de auteurs een manifold-perspectief. Zij gaan ervan uit dat hoogdimensionale representaties liggen op laagdimensionale manifolds.

Manifold Constructie: De methode maakt gebruik van piecewise-lineaire manifold learning. Het deelt niet-lineaire manifolds op in lokaal lineaire regio's door $m$ -dimensionale lineaire submanifolds rond ankerpunten te construeren. Dit wordt bereikt door iteratief dichtstbijzijnde buren toe te voegen en de reconstructiekwaliteit te verifiëren via Principal Component Analysis (PCA).
Metric Learning: Om ervoor te zorgen dat prototypes onderscheidend zijn tussen klassen, integreren de auteurs Proxy-Anchor loss. Dit introduceert leerbare klasse-niveau proxy-vectoren om intra-klasse cohesie en inter-klasse separatie te optimaliseren.
Joint Optimalisatie: Een neuraal netwerk $h_\theta$ wordt getraind om gezamenlijk de manifold learning-doelstelling (het behoud van de lokale geometrische structuur) en de Proxy-Anchor loss (het afdwingen van klasse-separatie) te optimaliseren. Na training worden de momentum-geüpdatete proxy-vectoren gemapt naar hun dichtstbijzijnde trainingsinstanties om te dienen als de uiteindelijke ICL-demonstraties (prototypes).

2. Prototype-Gradient Attributie voor AST-gegronde Interpreteerbaarheid

Om het geheugengebruik van op token-waarschijnlijkheid gebaseerde methoden aan te pakken, stellen de auteurs een attributiemechanisme voor dat geen volledige vocabulaire-verdelingen hoeft op te slaan.

Attributiemechanisme: Invloed wordt geschat met behulp van de gradiënt van de gelijkenis tussen de gesamplede prototype-embeddings en de token-embeddings van de gegenereerde code. Specifiek wordt de dot product tussen de gemiddelde prototype-vector en de latente representatie van een token berekend, waarbij de gradiënt hiervan ten opzichte van de token-embedding dient als een confidence score.
AST Analyse: Deze token-niveau confidence scores worden gepropageerd door de Abstract Syntax Tree (AST). Het proces koppelt tokens aan terminale AST-nodes, die vervolgens hiërarchisch worden geaggregeerd naar non-terminale nodes en uiteindelijk worden gegroepeerd in acht menselijk interpreteerbare Syntax Categorieën (bijv. Beslissingen, Datastructuren, Iteraties, Foutafhandeling). Dit maakt zowel lokale (node-niveau) als globale (categorie-niveau) interpreteerbaarheid mogelijk.

Belangrijkste Bijdragen

Verenigd Framework: Het artikel beweert de eerste te zijn die prototype-gestuurde ICL-sampling verenigt met AST-gegronde attributie voor code-interpreteerbaarheid.
Efficiënte Samplingstrategie: De voorgestelde joint manifold en metric learning-aanpak samplet ICL-demonstraties die zowel geometrisch getrouw zijn aan de lokale datastructuur als semantisch onderscheidend, waardoor de computationele kosten van herhaaldelijk samplen of het opslaan van volledige vocabulaire-waarschijnlijkheden worden vermeden.
Geheugenefficiënte Attributie: Door gebruik te maken van prototype-gradient attributie in plaats van token-waarschijnlijkheden, maakt de methode syntax-bewuste confidence mapping mogelijk zonder de geheugenoverhead die slecht schaalt met de outputlengte.
Syntax-gegronde Verklaringen: Het framework biedt een post-hoc verklarend systeem dat gegenereerde code segmenteert in interpreteerbare syntactische regio's, waardoor wordt geïdentificeerd welke delen van de code het meest worden beïnvloed door de geselecteerde demonstraties.

Experimentele Resultaten

De auteurs evalueerden hun methode op de MBPP en MBPP+ testsets met behulp van zes LLM's, waaronder generieke modellen (Qwen3, Llama3.2, Falcon3) en code-gespecialiseerde modellen (Starcoder, Qwen2.5-Coder, CodeLlama).

Prestaties: De prototype-gebaseerde samplingmethode presteerde consistent beter dan het basismodel (zonder ICL) en andere samplingstrategieën (diversiteits-gebaseerd, gelijkenis-gebaseerd en MBPP few-shot) op de pass@10 metriek bij de meeste modellen. Bijvoorbeeld, op de MBPP-dataset behaalde de voorgestelde methode een pass@10 van 0,122 voor CodeLlama-7B, vergeleken met 0,116 voor het basismodel.
Gevoeligheid voor Demonstraties: De resultaten benadrukten dat modellen voor codegeneratie zeer gevoelig zijn voor de kwaliteit van ICL-demonstraties. Slecht gekozen demonstraties (bijv. die van similarity-based of diversity-based sampling in bepaalde contexten) hadden een negatieve impact op de prestaties, wat soms resulteerde in lagere resultaten dan het basismodel.
AST Analyse Inzichten: De analyse onthulde duidelijke betrouwbaarheidspatronen over syntax categorieën. Modellen vertoonden over het algemeen een hoge confidence in Scope, Datastructuren en Functies. Daarentegen ontving Foutafhandeling consequent de laagste confidence scores over alle modellen heen, wat wijst op een systemische beperking in het genereren van robuuste foutafhandelingslogica.

Betekenis en Claims

Het artikel benadrukt dat efficiënte samplingstrategieën voor ICL niet louter optioneel maar cruciaal zijn voor modelprestaties. De auteurs beweren dat hun aanpak aantoont dat hoogwaardige, geometrisch getrouwe prototypes meer doen dan alleen de nauwkeurigheid verbeteren; ze verbeteren ook de interpreteerbaarheid van het generatieproces. Door specifieke syntactische regio's van de code te koppelen aan de gesamplede prototypes, kunnen ontwikkelaars beter begrijpen "waarom" een model tot een bepaalde output komt.

De auteurs blijven bescheiden over de reikwijdte van hun werk en merken op dat de prototypes uitsluitend zijn gesampled uit de Magicoder-OSS-Instruct dataset. Zij suggereren dat hun methode als een globale metriek kan dienen voor het beoordelen van de kwaliteit van datasets met betrekking tot de effectiviteit van prototypes, en dat toekomstig werk dit naar bredere datasets kan uitbreiden. Daarnaast stellen zij voor dat het framework ontworpen kan worden richting "pre-hoc interpreteerbaarheid", waarbij prototype steering potentieel gebruikt kan worden om modelgedrag te beïnvloeden, hoewel dit een toekomstige richting is en geen huidige implementatie.