🤖 machine learning

TraceSynth: Generating Production-Quality Kernel Traces with Constraint-Guided Diffusion Models

TraceSynth is een door constraints gestuurd diffusiekader dat hoogwaardige synthetische kernel-executietraces genereert om beperkte echte data kosteneffectief aan te vullen voor systeemdiagnostiek, waarbij het een prestatie nabij de baseline bereikt op deterministische workloads terwijl de computationele kosten aanzienlijk worden verminderd door middel van lichtgewicht multi-channel modellering.

Oorspronkelijke auteurs: Yuvraj Sehgal, Sneh Patel, Mahsa Panahandeh, Naser Ezzati-Jivan, Francois Tetreault

Gepubliceerd 2026-07-15

📖 6 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Yuvraj Sehgal, Sneh Patel, Mahsa Panahandeh, Naser Ezzati-Jivan, Francois Tetreault

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 hoe hij een enorme, complexe machine moet repareren. Om dit te doen, moet je de robot duizenden uren aan videomateriaal laten zien van de machine die draait, uitvalt en wordt gerepareerd. Maar hier komt de adder onder het gras: het filmen van die beelden is ontzettend duur, neemt enorme hoeveelheden opslagruimte in beslag, en soms zijn de eigenaren van de machine te bezorgd over de privacy om je de gevoelige onderdelen te laten filmen. Bov�n het breekt ook zelden op precies dezelfde manier twee keer, dus je zou de vreemde, zeldzame glitches kunnen missen die juist het belangrijkst zijn om van te leren.

Dit is het probleem waar de onderzoekers van Brock University en de University of Ottawa tegenaan liepen. Ze wilden een tool bouwen genaamd TraceSynth die kon fungeren als een "filmregisseur" voor computersystemen. In plaats van de echte machine te filmen, gebruikt TraceSynth een speciaal soort AI (een diffusiemodel) om nieuwe, nep video-opnames te verbeelden en te genereren van de machine die draait. Het doel? Om de robot genoeg oefendata te geven zodat hij kan leren hoe hij dingen repareert zonder ooit de echte, dure of privacygevoelige machine te hoeven filmen.

Het "Fake News"-probleem en de "Veiligheidsnet"-methode

Je zou kunnen denken: "Als de AI gewoon dingen verzint, zal het dan niet willekeurige onzin creëren?" Dat is een terechte zorg. Als de AI een video genereert waarin een onderdeel van de machine verdwijnt of een knop wordt ingedrukt voordat de machine überhaupt is aangezet, is dat nutteloos.

Om dit op te lossen, voegde het team een stap toe genaamd constraint-guided repair (beperkingsgestuurde reparatie). Zie dit als een strikte redacteur of een veiligheidsnet. Zodra de AI een nep-trace genereert, controleert deze redacteur het tegen de regels van het universum (zoals "je kunt een bestand niet verwijderen voordat je het hebt aangemaakt"). Als de AI een fout maakt, herstelt de redacteur dit direct. Het artikel laat zien dat dit veiligheidsnet een gamechanger is, vooral wanneer de AI met korte fragmenten data werkt. Het kan de kwaliteit van de nepdata met wel 4,3% verbeteren, waardoor de "nep" traces dezelfde logische regels volgen als de echte.

Het geheime ingrediënt: Tijd is belangrijker dan details

Hier is de meest verrassende ontdekking uit hun experimenten. Je zou aannemen dat de AI om een perfecte nep-trace te maken, alles over de machine moet weten: de specifieke naam van elke thread, de exacte CPU-core, de return-codes en de procesnamen.

Het artikel voert juist een argument tegen dit idee. Ze ontdekten dat het toevoegen van al deze extra details niet veel hielp. Sterker nog, een "lichtgewicht" AI die naar slechts twee dingen keek—welke gebeurtenis plaatsvond en hoeveel tijd er tussen de gebeurtenissen zat—presteerde bijna net zo goed als de supercomplexe AI die alles wist.

De bevinding: Een simpel model dat slechts 2 kanalen aan data gebruikte (gebeurtenis en tijd), behield 97–99% van de prestaties van het volledige 6-kanaals model, maar tegen ongeveer de helft van de rekenkosten.
De les: Over-engineer de generator niet. Weten wat de volgorde en de timing van gebeurtenissen is, is veel belangrijker dan het kennen van de specifieke namen van elk onderdeel.

Het magische getal: 4096

Hoewel de AI niet meer details nodig had, had de AI wél dringend meer tijd nodig. De onderzoekers testten hoeveel "context" (hoeveel gebeurtenissen op een rij) de AI tegelijkertijd kon bekijken.

Wanneer de AI naar slechts 256 gebeurtenissen keek, was de nepdata vrij slecht.
Toen ze het zicht vergrootten naar 4096 gebeurtenissen, schoot de kwaliteit omhoog.

Deze sprong in contextlengte resulteerde in een relatieve verbetering van 104% in kwaliteit. Het is het verschil tussen proberen een film te begrijpen door naar één enkel frame te kijken versus het kijken van een hele scène. Voor de meest voorspelbare, wiskundig zware workloads (zoals een benchmark genaamd scimark2) was de nepdata die met dit lange overzicht werd gegenereerd zo goed dat het een F1-Macro score van 87,2% behaalde, wat slechts 2,6 procentpunt verwijderd is van het gebruik van echte data.

Wanneer werkt dit? (En wanneer niet?)

Het artikel is heel duidelijk over waar deze magie wel werkt en waar niet.

Het werkt geweldig voor: Deterministische, rekenintensieve taken. Dit zijn zaken als een robotarm die een auto in een fabriek schildert; de stappen zijn voorspelbaar en herhaalbaar. Voor deze taken is de nepdata een bijna perfect substituut voor echte data.
Het worstelt met: Chaotische, I/O-intensieve workloads. Dit zijn zaken als een drukke luchthaven waar vliegtuigen aankomen en vertrekken op basis van onvoorspelbaar weer en verkeer. Het artikel vond dat voor deze rommelige, asynchrone taken (zoals stream of iozone), de nepdata nog steeds aanzienlijke tekortkomingen vertoonde, waarbij de prestaties met 25–36% daalden vergeleken met echte data. De AI kon de complexe, willekeurige interacties die buiten het systeem plaatsvinden simpelweg niet raden.

Het eindoordeel

TraceSynth is geen toverstaf die elk probleem oplost, maar wel een krachtig nieuw instrument voor specifieke situaties. De auteurs suggereren dat industrieën die AI willen trainen om hun systemen te monitoren, nu het volgende kunnen doen:

Geld en privacy besparen door deze gegenereerde traces te gebruiken in plaats van het verzamelen van enorme hoeveelheden echte, gevoelige data.
Focus op tijd, niet op details, door simpelere modellen te gebruiken die naar lange sequenties van gebeurtenissen kijken in plaats van te proberen elk kenmerk te onthouden.
Een veiligheidsnet gebruiken (de constraint repair) om ervoor te zorgen dat de nepdata logisch correct is.

Het artikel waarschuwt echter dat we bij zeer chaotische systemen nog niet alleen op deze nepdata moeten vertrouwen. Het is een fantastische manier om systemen te "stress-testen" en de gaten op te vullen voor voorspelbare workloads, maar voor de rommelige, echte wereldse chaos van zware input/output, moeten we nog steeds voorzichtig zijn. De onderzoekers kijken nu of ze dit op hun eigen industriële netwerken kunnen testen om te zien of het standhoudt in de praktijk, maar voor nu suggereren de resultaten dat we onze robots kunnen leren met behulp van verhalen die we zelf hebben verzonnen.

Technische Samenvatting: TraceSynth

Probleemstelling

Moderne productiesystemen vertrouwen steeds vaker op machine learning (ML) voor operationele intelligentie, zoals het voorspellen van bottlenecks en het verminderen van de gemiddelde tijd tot herstel (MTTR). Deze modellen vereisen hoogwaardige kernel-niveau executietraces om fijnmazige interne staten (scheduler-beslissingen, geheugenallocaties, I/O-operaties) vast te leggen, in plaats van alleen geaggregeerde metrieken. Het verzamelen van productietraces wordt echter belemmerd door drie primaire beperkingen:

Runtime Overhead: Continue instrumentatie (bijv. via LTTng) introduceert aanzienlijke prestatieboetes (typisch 1,5–1,6×), wat onpraktisch maakt voor latency-gevoelige services.
Privacy en Compliance: Traces bevatten vaak gevoelige gegevens (bestandspaden, netwerkendpoints) die dataretentiebeleid schenden, wat het aggregeren van grootschalige datasets voor gecentraliseerde training verhindert.
Data-schaarsheid: Echte traces leggen zelden "long-tail" foutmodi of diverse executiepatronen vast die nodig zijn voor robuuste modeltraining.

Bestaande benaderingen voor synthetische generatie (bijv. Markov-ketens, regelgebaseerde generatoren of GANs) slagen er niet in om de langetermijn temporele afhankelijkheden, multi-attribuut correlaties of de structurele validiteit te vangen die vereist zijn voor kernel-traces.

Methodologie: TraceSynth

De auteurs stellen TraceSynth voor, een framework gebaseerd op Denoising Diffusion Probabilistic Models (DDPMs) om synthetische kernel-traces te genereren die beperkte echte data aanvullen. Het framework werkt via vier stadia:

1. Data Preprocessing

Ruwe kernel-traces (gedecodeerd uit LTTng) worden getransformeerd naar een gestructureerde, multi-channel representatie. Elk event wordt gecodeerd over zes kanalen:

Event: Event-type identifier.
dt: Inter-event tijddelta (log-genormaliseerd).
cpu: CPU-core identifier.
tid: Thread identifier (gehasht).
comm: Process command name.
ret: System call return waarde.

Traces worden gesegmenteerd in overlappende fixed-length vensters ( $L \in \{256, 1024, 4096\}$ ) om trainingssamples te creëren.

2. Diffusion Model Architectuur

TraceSynth maakt gebruik van een Transformer-gebaseerd denoising diffusion model.

Input: Multi-channel sequenties waarbij discrete kanalen worden geëmbed via geleerde tabellen en het continue tijd-delta kanaal wordt geprojecteerd via een MLP.
Forward Process: Het model corrumpeert de latente representatie progressief met Gaussische ruis over $T=1000$ stappen.
Reverse Process: Een Transformer encoder voorspelt de geïnjecteerde ruis. Het trainingsdoel combineert een standaard diffusion loss met een aanvullende reconstructie loss om semantische consistentie over kanalen te waarborgen.

3. Constraint-Guided Repair

Om het probleem aan te pakken waarbij generatieve modellen lokaal plausibele maar globaal ongeldige sequenties produceren, introduceert TraceSynth een post-hoc repair mechanisme.

Constraint Learning: In plaats van hard-coded regels, mijnt het systeem invarianten direct uit echte traces, inclusocief event transitie grafieken, temporele grenzen, CPU affinity regels en attribuut validiteitssets.
Repair: Gedetecteerde schendingen (bijv. ongeldige event transities of buiten bereik liggende timestamps) worden gecorrigeerd door te samplen uit de geleerde toegestane sets, geconditioneerd op het event type. Dit ontkoppelt generatie van validatie.

4. Evaluatiestrategie

De kwaliteit van synthetische data wordt geëvalueerd via een downstream next-event prediction taak (het voorspellen van het volgende event type gegeven 128 voorafgaande events). De studie vergelijkt modellen getraind op:

Alleen echte data.
Een 50/50 mix van echte en onherstelde (unrepaired) synthetische data.
Een 50/50 mix van echte en door constraints herstelde (constraint-repaired) synthetische data.

Belangrijkste Bijdragen

Probleemkarakterisering: Definieerde de specifieke uitdagingen van data-schaarsheid voor ML-gebaseerde diagnostiek in industriële omgevingen (met specifieke verwijzing naar de beperkingen van Ciena).
TraceSynth Framework: Stelde een multi-channel diffusion model voor dat in staat is tot 4096-lengte sequenties te synthetiseren over zes trace attributen, gekoppeld aan een constraint-learning module voor het behoud van invarianten.
Empirische Evaluatie: Demonstreerde dat synthetische augmentatie effectief de trainingsdatagrootte kan verdubbelen voor deterministische workloads met minimale prestatievermindering.
Praktische Richtlijieden: Bood inzichten in de kosten-kwaliteit trade-offs, waarbij werd aangetoond dat lichtgewicht modellen vaak volstaan voor industriële use-cases.

Experimentele Resultaten

De evaluatie maakte gebruik van zes benchmarks uit de Phoronix Test Suite (bijv. scimark2, ffmpeg, iozone) die compute-intensieve, I/O-intensieve en gemengde workloads vertegenwoordigen.

Workload Afhankelijkheid: Prestaties zijn sterk afhankelijk van het type workload.
- Deterministisch/Compute-heavy: Voor scimark2 bereikte synthetische augmentatie bij contextlengte $L=4096$ een 87,2% Macro-F1, slechts 2,6 procentpunten onder de real-only baseline (89,8%).
- I/O-Heavy: Workloads zoals stream en iozone vertoonden significante degradatie (25–36% daling), wat aangeeft dat synthetische traces moeite hebben met asynchrone I/O en complexe kernel interacties.
Context Lengte: Het vergroten van de context lengte is de dominante factor in kwaliteit. Het bewegen van $L=256$ naar $L=4096$ leverde een +104% relatieve verbetering op in Macro-F1.
Constraint-Guided Repair: Repair verbeterde de datakwaliteit consistent, met name bij kortere context lengtes (tot +4,3% verbetering voor scimark2 bij $L=256$ ). Bij $L=4096$ nam het marginale voordeel af omdat het model meer invarianten impliciet leerde.
Model Complexiteit (Ablatie): Verrassend genoeg behielden lichtgewicht 2-kanaals modellen (Event + Time) 97–99% van de prestaties van volledige 6-kanaals modellen, terwijl de computationele kosten werden verminderd. Feature-rijke modellen boden verwaarloosbare winst, behalve voor zeer gestructureerde workloads.

Betekenis en Claims

Het artikel claimt dat TraceSynth een kosteneffectieve oplossing biedt voor het aanvullen van kernel traces in productie observability pipelines. De betekenis ligt in:

Haalbaarheid: Het bewijs dat diffusion modellen in staat zijn om structureel geldige, productie-waardige traces te genereren voor deterministische workloads, waardoor de afhankelijkheid van kostbare real-world dataverzameling wordt verminderd.
Veiligheid: Het constraint-guided repair mechanisme fungeert als een "veiligheidsnet", dat garandeert dat gegenereerde traces de systeem invarianten respecteren, wat ze veiliger maakt voor downstream training en stress-testing.
Efficiëntie: De bevinding dat eenvoudige 2-kanaals modellen vaak voldoende zijn, daagt de aanname uit dat complexe multi-attribuut modellering altijd noodzakelijk is, wat lagere trainingskosten en lagere inference latency mogelijk maakt.
Praktische Toepassing: Het framework stelt organisaties in staat om trace-gedreven infrastructuur te testen tegen edge cases en faciliteert privacy-bewuste ontwikkeling door het delen van synthetische, statistisch vergelijkbare data in plaats van gevoelige productielogs.

De auteurs hanteren een bescheiden standpunt en erkennen dat hoewel de aanpak goed werkt voor gestructureerde workloads, zeer asynchrone I/O systemen een uitdaging blijven en verdere validatie vereisen op propriëtaire productietraces.