🤖 machine learning

When the Next Step Is Not One Step: Distribution-Aware Execution Modeling for Concurrent Go Programs

Dit artikel introduceert een distributiebewuste executiemodelleringsbenadering voor concurrente Go-programma's die de nondeterminisme van de scheduler benut om een 7B-model te verfijnen op empirische eventdistributies, waarbij staat-van-de-kunst nauwkeurigheid en verbeterde kalibratie op echte bugvoorspellingen wordt bereikt, terwijl ook formele garanties worden geboden voor het detecteren van specifieke goroutine-lekken.

Oorspronkelijke auteurs: Kaviru Hapuarachchi

Gepubliceerd 2026-06-17

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Kaviru Hapuarachchi

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 robot probeert te leren de volgende zet in een spel schaken te voorspellen. Als het een standaard schaakspel is, staan de regels vast: als je een pion hierheen beweegt, moet de tegenstander op een specifieke manier reageren. De robot hoeft alleen maar het patroon te onthouden.

Maar stel je nu voor dat er een chaotisch, lawaaierig spel schaken wordt gespeeld in een kamer waar drie verschillende mensen tegelijkertijd proberen de stukken te bewegen en een willekeurige wind het bord rondblaast. Soms, als je een pion beweegt, blaast de wind hem omver. Soms grijpt een speler een stuk voordat je het kunt bewegen. Soms besluit de tegenstander om een heel ander stuk te verplaatsen.

Dit is het probleem met computerprogramma's die meerdere taken tegelijk uitvoeren (concurrente programma's).

Dit artikel pakt precies die chaos aan. Hier is de uitleg in eenvoudige termen:

Het Probleem: "Eén Antwoord" vs. "Veel Mogelijke Antwoorden"

In de traditionele informatica gaan we er meestal van uit dat wanneer een programma draait, het een rechte lijn volgt. Als je het dezelfde invoer geeft, geeft het dezelfde uitvoer.

De Oude Manier: Onderzoekers trainden AI-modellen om de ene volgende stap te voorspellen die een programma zou nemen. Ze behandelden het programma als een rechte lijn.
De Realiteit: In concurrente programma's (zoals die geschreven zijn in de programmeertaal Go), is de "scheduler" (het deel van de computer dat bepaalt welke taak wanneer draait) als een chaotische scheidsrechter. Als je hetzelfde programma twee keer draait, kan het A dan B doen, of B dan A. Beiden zijn correct. Beiden zijn geldig.

Als je een AI traint om slechts één antwoord te raden voor een situatie waarin er eigenlijk drie geldige antwoorden zijn, raakt de AI in de war. Het is alsof je een weervoorspeller vraagt om te voorspellen: "Het gaat regenen", terwijl de realiteit is: "Het kan regenen, het kan sneeuwen of het kan zonnig zijn", en de AI kiest gewoon één optie en hoopt het beste.

De Oplossing: De "Weersverwachting" Voorspellen

De auteurs realiseerden zich dat ze de chaos niet als een fout moesten behandelen. In plaats daarvan behandelden ze de chaos als data.

Draai het vele malen: Ze namen een programma en draalden het honderden keren.
Tel de uitkomsten: Ze merkten op dat hoewel de volgorde veranderde, er bepaalde patronen ontstonden. Bijvoorbeeld: "Gebeurtenis A" gebeurde 60% van de tijd, "Gebeurtenis B" 30% van de tijd, en "Gebeurtenis C" 10% van de tijd.
Leer de AI de distributie: In plaats van de AI te leren om "Gebeurtenis A" te raden, leerden ze de AI de volledige voorspelling te raden: "Er is een kans van 60% op A, 30% op B en 10% op C."

Ze gebruikten een speciale wiskundige truc (een "KL-doelstelling") om een AI-model met 7 miljard parameters te trainen om deze echte wereldpercentages te matchen, in plaats van alleen maar één winnaar te raden.

De Resultaten: Werkt het?

Ze testten dit op echte, rommelige code van beroemde systemen zoals Kubernetes en Google's gRPC.

De AI vs. De Experts: De gefinetunede AI (getraind op minder dan 1.000 voorbeelden) had de volgende stap goed in 36,2% van de gevallen.
De Concurrentie: Dit versloeg een zeer krachtige, vooraf getrainde AI (Gemini 3.5 Flash) die helemaal niet op dit specifieke type probleem was getraind (die slechts 34,8% goed had).
De "Kalibratie" Overwinning: Nog belangrijker was dat de nieuwe AI beter was in het weten wanneer hij het niet zeker wist. Als de situatie chaotisch was, zei de AI: "Ik weet het niet zeker, het kan van alles zijn." Als de situatie voorspelbaar was, zei hij: "Ik weet het vrij zeker." De oude manier van trainen zorgde ervoor dat de AI vaker zelfverzekerd fout zat.

De Limieten: Waar ligt het plafond?

Het paper is zeer eerlijk over wat de AI nog niet kan:

Het Nauwkeurigheidplafond: De AI vlakt af rond de 35–36% nauwkeurigheid. Hij kan niet veel hoger komen omdat sommige gebeurtenissen zo zeldzaam zijn (zoals een specifiek type glitch) dat de AI ze nooit genoeg ziet om ze te leren.
Het "Eén Stap"-Probleem: De AI is geweldig in het voorspellen van de zeer volgende zet. Maar als je hem vraagt om de volgende 10 zetten achter elkaar te voorspellen, valt hij na ongeveer één stap uit elkaar. Het is als een persoon die je kan vertellen wat er in de volgende seconde van een film gebeurt, maar als je hem vraagt het hele plot te voorspellen, begint hij dingen te verzinnen.

De Ontdekking van de "Leak"

De auteurs ontdekten ook een specifieke "handtekening" voor een type computerbug genaamd een "goroutine leak" (waarbij een taak vastloopt en nooit klaar is).

Ze bewezen wiskundig dat als een taak vastloopt in een specifiek type wachtlus, de kans dat deze ooit "wakker wordt" nul is.
Dit is niet iets wat de AI heeft geleerd door te gokken; het is een regel van het universum (de regels van de Go programmeertaal). De AI leerde correct dat "Wakker worden" onmogelijk is in dit specifieke scenario, wat een goed teken is dat het de logica begrijpt, en niet alleen getallen memoriseert.

Samenvatting

Het paper zegt: "Probeer een chaotisch systeem met meerdere paden niet te dwingen in een enkele rechte lijn. Laat de AI in plaats daarvan de hele kaart van mogelijkheden zien. Het zal niet perfect zijn, en het kan nog geen lange ketens van gebeurtenissen voorspellen, maar het wordt veel beter in het begrijpen van de aard van de chaos en in het weten wanneer het aan het gokken is."

Ze hebben hun code, data en tools vrijgegeven zodat anderen kunnen proberen voort te bouwen op deze "chaos-bewuste" aanpak.

Technische Samenvatting: Distributie-bewuste Executiemodellering voor Concurrente Go-programma's

Probleemstelling
Het trainen van taalmodellen om de volgende stap in een concurrent programma te voorspellen, is fundamenteel anders dan bij sequentiële code vanwege de nondeterministische scheduler. Bij sequentiële executie leidt een specifieke staat en instructie tot één enkele deterministische volgende staat. In concurrente Go-programma's kan eenzelfde executieprefix echter op een legitieme manier leiden tot meerdere verschillende volgende gebeurtenissen (bijv. een blokkering, een start, of een unblock) afhankelijk van hoe de scheduler de goroutines door elkaar weeft.

Standaard Code World Models (CWMs) die getraind worden met cross-entropy loss, gaan ervan uit dat er één correct label per input is. Wanneer deze worden toegepast op concurrente traces, dwingt dit het model om één willekeurig resultaat van een random proces te memoriseren, waardoor het de onderliggende dynamiek niet kan vatten. Deze beperking is kritiek omdat concurrency-bugs (deadlocks, data races, goroutine leaks) inherent afhankelijk zijn van de scheduler en geen sequentiële analogen hebben. Bestaande benchmarks en modellen falen vaak in het adresseren van deze nondeterminisme, door het als ruis te behandelen in plaats van als een structurele eigenschap van de executie.

Methodologie
De auteurs stellen voor om de voorspelling van de volgende gebeurtenis te herformuleren als distributie-schatting in plaats van puntvoorspelling. In plaats van een model te trainen om één enkele volgende gebeurtenis te raden, aggregeert de aanpak geobserveerde volgende gebeurtenissen uit meerdere runs van hetzelfde programma om een empirische distributie te vormen.

Dataverzameling: De studie maakt gebruik van 130 concurrente Go-programma's, inclusend handmatig gemaakte patronen, gesynthetiseerde code en 66 real-world concurrency bug kernels uit productiesystemen (CockroachDB, Kubernetes, gRPC, etcd). Elk programma wordt vijf keer uitgevoerd onder een runtime tracer om scheduler-events vast te leggen.
Doeldefinitie: Voor een gegeven programma-prefix is het doel niet een enkel label, maar een empirische distributie $\hat{p}_g$ over zes event-types: GoBlock, GoCreate, GoEnd, GoSched, GoStart, en GoUnblock. Deze distributie wordt afgeleid van de frequentie van geobserveerde volgende gebeurtenissen over herhaalde runs.
Modeltraining: De auteurs finetunen een 7B-parameter model (Qwen2.5-Coder) met behulp van twee doelstellingen:
1. Cross-Entropy (CE): Een baseline waarbij voorbeelden proportioneel aan de event-frequentie worden gedupliceerd om de distributie te benaderen.
2. KL Divergence (KL): Een distributie-bewuste doelstelling die de Kullback-Leibler divergentie minimaliseert tussen de voorspelde distributie van het model en de empirische target. De KL-term wordt specifiek toegepast op de token-positie die de event-types onderscheidt.
Evaluatie: Het model wordt geëvalueerd op een hold-out set van 66 real-world productie-bugs (GoKer) die het nooit tijdens de training heeft gezien. De metrieken omvatten top-1 accuratesse, Expected Calibration Error (ECE), en multi-step coherentie (het simuleren van executie door voorspellingen terug te voeren als input).

Belangrijkste Bijdragen

Distributie-bewuste Training: De paper demonstreert dat het behandelen van scheduler-nondeterminisme als een signaal het model in staat stelt om de "geldige toekomsten" te leren die toegestaan worden door de Go-scheduler. Een 7B-model dat gefinetuned is op minder dan 1.000 traces, bereikt 36,2% accuratesse op hold-out productie-bugs, waarmee het hetzelfde model zero-shot (28,6%) en Gemini 3.5 Flash zero-shot (34,8%) verslaat.
Verbetering van Kalibratie: Hoewel distributie-training (KL loss) een accuratesse bereikt die vergelijkbaar is met cross-entropy (35,8% vs. 36,2%), verbetert het de kalibratie van het model aanzienlijk. De Expected Calibration Error daalt van 0,205 naar 0,169, en de model-entropie correleert met de programmatische nondeterminisme, waardoor het model onzekerheid op de juiste wijze kan uiten.
Formele Leak Signature: De auteurs leiden een formele signature af voor een specifieke klasse van goroutine leaks: select-blocked goroutines. Ze tonen aan dat voor deze gevallen de waarschijnlijkheid van een GoUnblock event exact nul is ( $P(\text{GoUnblock}) = 0$ ) op alle trace-dieptes. Dit is een gevolg van de Go scheduler-semantiek (als geen enkele bereikbare goroutine aan de select-conditie kan voldoen, is unblocking onmogelijk) in plaats van een geleerd statistisch patroon.
Identificatie van Beperkingen: De studie brengt de grenzen van de aanpak expliciet in kaart. De accuratesse vlakt af rond de 35–36%, ongeacht de modelgrootte of doelstelling. Het model faalt bij het voorspellen van zeldzame event-types (GoEnd, GoSched) door class imbalance en distributie-shift. Bovendien verliest de multi-step voorspelling de scheduler-coherentie na ongeveer één stap, aangezien het model alleen getraind is op single-step transities.

Resultaten en Analyse

Accuratesse-plafond: Het performance-plafond (~36%) wordt toegeschreven aan twee factoren: class imbalance (zeldzame events zoals GoEnd en GoSched worden nooit correct voorspeld) en distributie-shift (real-world bugs oefenen event-types zoals GoCreate en GoSched vaker uit dan de hand-crafted trainingsset).
Event-specifieke Performance: Het model leert veelvoorkomende lifecycle events goed (GoStart bij 47%, GoCreate bij 44%), maar faalt bij zeldzame events. Opvallend genoeg bereikt GoCreate 44% accuratesse ondanks dat dit slechts 1,5% van de trainingsdata beslaat, wat suggereert dat het model redeneert vanuit de programmastructuur in plaats van enkel vanuit frequentie.
Multi-Step Coherentie: Wanneer het model autoregressief wordt gebruikt, produceert het geldige transities voor ongeveer één stap voordat het de Go-invarianten schendt. Dit bevestigt dat single-step training niet overdraagt naar multi-step simulatie zonder trajectory training.
Redeneren: Het inschakelen van "thinking" modi in het baseline-model (Gemini) verbeterde de accuratesse niet, wat aangeeft dat de taak steunt op structurele signalen in plaats van multi-step deductief redeneren.

Betekenis en Claims
De auteurs verklaren expliciet dat zij niet beweren een inzetbare bug-detector of een productie-klare executie-simulator te hebben ontwikkeld. De betekenis van het werk ligt in:

Formulering: Het bieden van een principieel kader voor het modelleren van concurrente executie als distributie-schatting.
Dataset en Baselines: Het vrijgeven van een dataset van concurrente traces, getrainde adapters en tooling om baselines te vestigen voor dit specifieke probleem.
Verduidelijking van Limieten: Het demonstreren dat hoewel nondeterminisme-bewuste training werkt en kalibratie verbetert, er nog steeds aanzienlijke hindernissen blijven bestaan (zeldzame events, distributie-shift, multi-step coherentie) die aangepakt moeten worden om de aanpak effectiever te maken.

De paper concludeert dat de huidige aanpak de levensvatbaarheid bewijst van distributie-bewuste training voor concurrente code, maar benadrukt dat toekomstig werk zich moet richten op trajectory training, rijkere staat-representaties (inclusief channel buffers en mutex ownership) en het herbalanceren van trainingsdata om de real-world event-distributies beter te matchen.