🤖 AI

Self-Improving Code Generation via Semantic Entropy and Behavioral Consensus

Deze paper introduceert ConSelf, een zelfverbeteringsmethode voor codegeneratie die zonder externe supervisie werkt door middel van semantische entropie voor het selecteren van leerzame problemen en consensusgedreven direct preference optimalisatie voor het versterken van betrouwbare oplossingen.

Oorspronkelijke auteurs: Huan Zhang, Wei Cheng, Wei Hu

Gepubliceerd 2026-04-01

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Huan Zhang, Wei Cheng, Wei Hu

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.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 beginnende programmeur bent die zichzelf wil verbeteren. Normaal gesproken heb je twee dingen nodig om goed te leren: een meester (een ervaren leraar die je vertelt wat goed en fout is) en een antwoordenboekje (een lijst met de juiste oplossingen om je werk mee te controleren).

In de wereld van kunstmatige intelligentie (AI) is dit vaak hetzelfde. Om een AI die code schrijft beter te maken, gebruiken onderzoekers vaak een "slimmere" AI als leraar of hebben ze duizenden voorbeelden van perfecte code nodig. Maar wat als je die leraar niet hebt? En wat als je ook geen antwoordenboekje hebt?

Dat is precies het probleem dat dit papier oplost. De onderzoekers van de Universiteit van Nanjing hebben een methode bedacht genaamd ConSelf. Ze laten de AI zichzelf leren, puur op basis van de problemen die ze krijgen en de testcases (de "vragen" die de code moet oplossen), zonder dat er een mens of een super-AI naar kijkt.

Hier is hoe ze dat doen, uitgelegd met een paar creatieve vergelijkingen:

1. Het Probleem: De "Ruis" in de Klas

Stel je voor dat je een klasje hebt met leerlingen die allemaal een moeilijk wiskundeprobleem moeten oplossen.

Situatie A: Het probleem is te moeilijk. Alle leerlingen schrijven een antwoord, maar ze zijn allemaal verkeerd. Als je deze antwoorden gebruikt om te leren, leer je alleen maar fouten. Dit noemen de onderzoekers "ruis".
Situatie B: Het probleem is te makkelijk. Alle leerlingen schrijven het exacte juiste antwoord. Hier is niets meer te leren, want ze kunnen het al.
Situatie C (De Gouden Middenweg): Het probleem is uitdagend. Sommige leerlingen komen dicht bij het juiste antwoord, anderen maken slimme fouten, en weer anderen vinden een heel andere aanpak. Hier zit de leerkracht in: je kunt leren door te kijken naar de verschillen en de redeneringen.

De grootste uitdaging voor een AI die zichzelf traint, is om Situatie C te vinden en Situatie A en B te negeren. Als de AI traint op "Situatie A" (allemaal fouten), wordt ze alleen maar dommer.

2. Oplossing Deel 1: De "Gedragsthermometer" (Semantic Entropy)

Hoe weet de AI of een probleem in Situatie A, B of C zit, zonder een leraar?
Normaal kijken AI-modellen naar hun eigen "zekerheid" (bijvoorbeeld: "Ik denk dat dit antwoord 90% goed is"). Maar dat is vaak een valstrik; een AI kan heel zeker zijn van een volledig verkeerd antwoord.

De onderzoekers hebben een nieuwe thermometer bedacht: Code Semantic Entropy.

De Analogie: In plaats van te vragen "Hoe zeker voel je je?", laten ze de AI hetzelfde probleem 15 keer oplossen, maar dan met een beetje variatie in hoe ze het aanpakken. Vervolgens laten ze deze 15 oplossingen "draaien" op de testcases.
De Meting:
- Als alle 15 oplossingen exact hetzelfde (foute) resultaat geven, is de "entropie" (de chaos) laag. De AI is vastgelopen in één fout. Niet leren.
- Als alle 15 oplossingen totaal verschillende, chaotische resultaten geven, is de entropie heel hoog. De AI weet totaal niet wat ze moet doen. Niet leren.
- Als er een mix is: sommige oplossingen werken goed, andere maken specifieke fouten, en er is een patroon te zien, dan is de entropie "net goed". Dit is het perfecte leermoment.

Deze "gedragsthermometer" helpt de AI om alleen die problemen te kiezen waar ze echt iets van kan leren, en de rest te filteren. Ze bouwen zo een leerplan (curriculum) op maat.

3. Oplossing Deel 2: De "Meerderheidsstem" (Behavioral Consensus)

Nu hebben we een lijst met goede oefenopgaven. Maar hoe leer je van de antwoorden als je niet weet welke het juiste zijn?
Stel je voor dat je een groepje leerlingen hebt die een antwoord hebben bedacht.

Leerling A zegt: "Het antwoord is 42."
Leerling B zegt: "Het antwoord is 42."
Leerling C zegt: "Het antwoord is 100."
Leerling D zegt: "Het antwoord is 42."

Zelfs zonder dat je het echte antwoord kent, is het logisch om te denken dat 42 waarschijnlijk het juiste antwoord is, omdat de meerderheid het daarover eens is.

De onderzoekers gebruiken dit principe in hun methode Con-DPO:

Ze kijken naar alle oplossingen die de AI heeft gegenereerd.
Ze geven een "stem" aan de oplossing die het vaakst voorkomt (de consensus).
Als de AI een oplossing produceert die overeenkomt met de meerderheid, wordt die oplossing beloond.
Als de AI een "uitbijter" produceert (een oplossing die niemand anders heeft), wordt die genegeerd of minder zwaar gewogen.

Dit voorkomt dat de AI leert van toevallige fouten. Het is alsof je een jury hebt die beslist wat "waarschijnlijk goed" is, in plaats van blindelings op één stem te vertrouwen.

Samenvatting: Waarom werkt dit?

Deze methode is slim omdat het twee stappen combineert:

Kiezen wat je leert: Door te kijken naar hoe chaotisch het gedrag van de AI is (de "thermometer"), kiest ze alleen de problemen die net op haar niveau liggen.
Leren hoe je leert: Door te vertrouwen op wat de "meeste versies" van zichzelf doen (de "meerderheidsstem"), leert ze betrouwbaar zonder dat er een leraar nodig is.

Het resultaat?
De AI wordt beter in het schrijven van code, zelfs zonder dat er dure leraars of perfecte antwoordenboeken bij komen kijken. Het is alsof je een student laat studeren met een groepje vrienden: ze praten over de problemen, filteren de onmogelijke vragen eruit, en vertrouwen op wat de meeste vrienden zeggen. Zo wordt iedereen slimmer, zonder dat er een professor bij hoeft te zijn.

Titel: Self-Improving Code Generation via Semantic Entropy and Behavioral Consensus

Auteurs: Huan Zhang, Wei Cheng, Wei Hu (Nanjing University)
Publicatie: ICPC '26 (2026)

1. Probleemstelling

Het verbeteren van de codegeneratiecapaciteiten van Large Language Models (LLMs) vereist doorgaans toezicht via Supervised Fine-Tuning (SFT) of Preference Optimization (zoals DPO). Deze methoden zijn echter afhankelijk van dure externe hulpbronnen:

Krachtige "leraar"-modellen: Om referentieoplossingen te genereren.
Betrouwbare testorakels: Om de correctheid van gegenereerde code te verifiëren (de "test oracle problem").

In realistische scenario's zijn probleemomschrijvingen en testinvoer vaak makkelijk beschikbaar, maar zijn referentieoplossingen en betrouwbare orakels schaars en duur. Bestaande zelflerende methoden die proberen zonder deze hulpbronnen te werken, lopen vaak vast op ruis:

Voor problemen die het model nog niet kan, zijn alle gegenereerde oplossingen fout. Zelfs als deze fouten divers zijn, bieden ze geen betrouwbare leerrichting.
Voor problemen die het model al beheerst, is er geen leermarge.
Het trainen op deze "ruis" leidt tot prestatiedalingen in plaats van verbetering.

De centrale onderzoeksvraag is: Kan een code-LLM zichzelf verbeteren zonder toegang tot een superieure leraar of vooraf bestaande testorakels, en alleen gebruikmakend van probleemomschrijvingen en testinvoer?

2. Methodologie: ConSelf

De auteurs stellen ConSelf voor, een zelflerende aanpak die rust op twee pijlers: het bepalen van wat er moet worden geleerd (curriculum) en hoe er moet worden geleerd (optimalisatie).

A. Curriculum Curation via Code Semantic Entropy (Wat te leren?)

Om te bepalen welke problemen geschikt zijn voor zelfverbetering, introduceren de auteurs een nieuwe metriek: Code Semantic Entropy.

Observatie-Gestuurde Sampling: Het model genereert eerst diverse "observaties" (hints, strategieën, valkuilen) voor een probleem. Vervolgens genereert het op basis van elke observatie meerdere kandidaat-codes.
Uitvoering en Clustering: Deze kandidaatcodes worden uitgevoerd op de beschikbare testinvoer. De uitvoeringsresultaten worden gegroepeerd in clusters op basis van identieke outputgedragingen.
Entropy Berekening: De Code Semantic Entropy ( $H(p)$ $H (p)$ ) wordt berekend als de Shannon-entropie over de verdeling van deze gedragsclusters.
- Hoge Entropy: Het model produceert veel verschillende, inconsistent gedrag (vaak fouten). Dit wijst op onzekerheid en een gebrek aan een coherente strategie. Deze problemen worden gefilterd.
- Nul Entropy: Alle kandidaten zijn functioneel identiek. Dit kan betekenen dat het probleem te makkelijk is (alles correct) of dat het model vastzit in een specifieke fout. Ook deze worden gefilterd.
- Gemiddelde Entropy: Het model produceert een mix van gedrag, wat aangeeft dat het probleem "leerbaar" is en ruimte biedt voor verbetering.
Filtering: Alleen problemen met een genormaliseerde entropy binnen een bepaald bereik $(0, \tau)$ worden opgenomen in het trainingscurriculum.

B. Consensus-Driven Direct Preference Optimization (Hoe te leren?)

Voor het trainen gebruiken de auteurs een verbeterde versie van DPO, genaamd Con-DPO.

Het Probleem met Standaard DPO: Standaard DPO behandelt elke voorkeurspaar (winnaar vs. verliezer) als even betrouwbaar. In een zelflerende setting zonder orakels zijn deze labels echter ruisbevat.
Behavioral Consensus Score: De auteurs berekenen een "consensus score" ( $R(y_w)$ ) voor elke kandidaatoplossing. Deze score is gebaseerd op hoe vaak het gedragspatroon van een kandidaat voorkomt onder de andere gegenereerde oplossingen. Een patroon dat door veel onafhankelijke samples wordt gedeeld, wordt als betrouwbaarder beschouwd.
Gewogen Loss: De DPO-loss functie wordt aangepast door de consensus score van de winnaar als gewicht te gebruiken:
$L_{Con-DPO} = -E [R(y_w) \cdot \log\sigma(\hat{r}(y_w, y_l))]$
Dit zorgt ervoor dat het model agressiever leert van betrouwbare (hoge consensus) paren en voorzichtig leert van onzekere paren, waardoor het risico op overfitting op ruis wordt geminimaliseerd.

3. Belangrijkste Resultaten

De auteurs hebben ConSelf getest op drie open-source backbone-modellen (CodeLlama-7B, DeepSeek-Coder-6.7B, Qwen2.5-Coder-7B) en vier benchmarks (HumanEval, MBPP, EvalPlus, LiveCodeBench).

Prestatieverbetering: ConSelf behaalde consistente verbeteringen ten opzichte van de basismodellen en andere zelflerende baselines (zoals Self-SFT, Self-DPO, PFPO).
- Qwen2.5-Coder-7B: +3.95% relatieve verbetering.
- CodeLlama-7B: +3.30% relatieve verbetering.
- DeepSeek-Coder-6.7B: +2.73% relatieve verbetering.
Data-efficiëntie: Door het filteren van niet-leerbare problemen, traint ConSelf op een veel kleiner dataset (bijv. slechts ~~6.000 voorbeelden voor DeepSeek-Coder) dan ongefiltreerde methoden (~~46.000+), maar levert dit betere resultaten op.
Validatie van Metrieken:
- Code Semantic Entropy bleek een veel betere indicator voor modelonzekerheid dan interne metrics (zoals token-entropy of negatieve log-likelihood) of naïeve semantische entropie (gebaseerd op tekst). Het had een sterke correlatie met daadwerkelijke probleemoplossing.
- Interne metrics faalden vaak om correcte van incorrecte code te onderscheiden, terwijl gedragsgebaseerde metrics dit wel deden.
Ablatie-studie: Het verwijderen van het curriculum-filtering (w/o CC) leidde tot de grootste prestatiedaling, wat aantoont dat het selecteren van de juiste problemen belangrijker is dan het optimalisatie-algoritme zelf. Consensus-gewichting (w/o CW) leverde een verdere, significante verfijning op.

4. Bijdragen en Significantie

De belangrijkste bijdragen van dit werk zijn:

Code Semantic Entropy: Een nieuwe, robuuste metriek die modelonzekerheid meet op basis van uitvoeringsgedrag in plaats van interne modelstaten. Dit lost het probleem op dat tekstuele diversiteit niet noodzakelijk betekent dat de code functioneel correct is.
ConSelf Framework: Een complete zelflerende pipeline die zonder dure externe supervisie werkt door een dual-strategie te combineren:
- Curriculum Curation: Filteren van problemen op basis van leerbaarheid (entropy).
- Robust Optimization: Consensus-gedreven DPO om ruis in zelfgegenereerde labels te mitigeren.
Praktische Relevantie: De methode maakt het mogelijk voor ontwikkelaars om code-modellen te verbeteren met alleen toegang tot probleemomschrijvingen en testinvoer, wat de kosten en complexiteit van het trainen van state-of-the-art code-modellen drastisch verlaagt. Het adresseert direct de "test oracle problem" in software engineering.

Conclusie:
ConSelf bewijst dat zelfverbetering van code-LLMs haalbaar is zonder superieure leraren of perfecte testorakels, mits men gebruikmaakt van gedragsgebaseerde onzekerheidsmetrieken om het curriculum te sturen en consensusmechanismen om de leerstabiliteit te waarborgen. Dit opent de deur tot meer toegankelijke en kostenefficiënte methoden voor het trainen van gespecialiseerde code-modellen.