Wrong Code, Right Structure: Learning Netlist Representations from Imperfect LLM-Generated RTL

Deze paper introduceert een kosteneffectief raamwerk dat imperfecte, door LLM's gegenereerde RTL-code gebruikt om netlistrepresentaties te leren, waardoor de schaarste aan gelabelde data voor circuitanalyse wordt overwonnen zonder in te leveren op de prestaties op realistische ontwerpen.

De kern

Stel je voor dat je een meesterklokmaker bent die probeert te leren hoe klokken werken. Om dit te leren, heb je duizenden klokken nodig om te bestuderen. Maar er is een groot probleem: echte, dure klokken zijn beschermd door auteursrecht (Intellectual Property) en niemand wil ze aan jou geven. Bovendien is het ontzettend duur en tijdrovend om elke tandwiel en veer in die klokken te labelen en te beschrijven.

Zonder genoeg voorbeelden kunnen de slimme computerprogramma's (AI) die klokken moeten begrijpen, niet goed leren. Ze blijven steken in simpele oefeningen.

De Oplossing: De "Gekke" Ontwerper

De auteurs van dit paper hebben een slimme, creatieve oplossing bedacht. Ze gebruiken een LLM (een soort super-intelligente AI die teksten schrijft) als een "gekke ontwerper".

1. De Gekke Ontwerper: Je vraagt deze AI: "Teken een tekening van een klok die 100 uur aangeeft." De AI doet haar best, maar maakt vaak fouten. Misschien draait het uurwerk de verkeerde kant op, of zijn de tandwielen een beetje scheef. De klok werkt dus niet goed (de functie is fout).
2. De Gouden Waarneming: Maar hier komt het slimme deel: Hoewel de klok niet werkt, ziet hij er nog steeds uit als een klok. De structuur, de manier waarop de tandwielen aan elkaar hangen, en de algemene vorm zijn nog steeds heel erg op een echte klok te herkennen. De AI heeft de "skeletstructuur" goed begrepen, zelfs als de "spieren" (de werking) niet kloppen.
3. De Leermeester: De onderzoekers zeggen: "Laten we die duizenden 'foutieve' tekeningen van de AI gebruiken om onze computer te leren." Ze filteren de slechtste tekeningen eruit (die die totaal niet op een klok lijken) en houden de rest over.

Hoe werkt het in de praktijk? (De Analogie)

Stel je voor dat je een kind wilt leren wat een "auto" is.

• Het oude probleem: Je hebt maar 5 echte auto's om te laten zien. Het kind leert niet genoeg.
• De nieuwe methode: Je laat een robot duizenden tekeningen van auto's maken. De robot maakt veel fouten: soms heeft de auto drie wielen, soms rijdt hij achteruit, en soms zijn de deuren aan de verkeerde kant.
• De filter: Je kijkt naar de tekeningen. Je gooit die weg waar de robot een boot heeft getekend. Maar je houdt de tekeningen waar de auto weliswaar gekleurd is met de verkeerde verf of een raam mist, maar waar je duidelijk een auto aan kunt herkennen (vier wielen, een carrosserie, een stuur).
• Het resultaat: Je kind leert van die duizenden "onvolmaakte" tekeningen wat een auto structureel is. Als het kind later een echte, perfecte auto ziet, herkent het die direct, omdat het de basisstructuur al duizenden keren heeft gezien.

Wat levert dit op?

De onderzoekers hebben dit getest op echte elektronische schakelingen (netlists).

• Ze lieten de AI code schrijven voor elektronische componenten.
• De code had vaak fouten (de schakeling werkte niet zoals bedoeld).
• Maar de bouwtekening (de netlist) zag er wel correct uit.
• Ze trainden een AI-model op deze "foutieve maar goed gebouwde" tekeningen.

Het verrassende resultaat:
Het model dat leerde van deze "slechte" AI-gegenereerde data, bleek net zo goed, of zelfs beter te zijn dan modellen die waren getraind op een paar echte, perfecte schakelingen.

Waarom is dit belangrijk?

• Geen dure data meer nodig: Je hoeft niet meer te wachten op dure, beveiligde ontwerpen van bedrijven. Je kunt zelf duizenden variaties genereren.
• Beter leren: Door de AI te laten variëren (soms een andere manier om een vermenigvuldiger te bouwen), leren de modellen de essentie van een schakeling, niet alleen de specifieke manier waarop één bedrijf het heeft gedaan.
• Toekomst: Dit opent de deur voor het analyseren van complexe, echte chips (zoals die in je telefoon) zonder dat je de geheime blauwdrukken nodig hebt.

Kortom:
Je hoeft geen perfecte kopie te hebben om iets te begrijpen. Als je genoeg "ruwe schetsen" hebt die de juiste vorm hebben, kun je zelfs beter leren dan met een paar perfecte, maar zeldzame, voorbeelden. De onderzoekers hebben bewezen dat je "foutieve code" kunt gebruiken om "slimme structuren" te leren herkennen.

Technische samenvatting

Hier is een gedetailleerde technische samenvatting van het paper "Wrong Code, Right Structure: Learning Netlist Representations from Imperfect LLM-Generated RTL" in het Nederlands.

Probleemstelling

Het leren van effectieve representaties van netlists (de gate-level weergave van digitale schakelingen) is fundamenteel beperkt door het gebrek aan gelabelde datasets. Real-world ontwerpen zijn beschermd door Intellectueel Eigendom (IP) en het handmatig annoteren ervan is extreem kostbaar. Bestaande methoden zijn daarom vaak beperkt tot kleine schakelingen met schone labels, wat de schaalbaarheid naar complexe, realistische ontwerpen belemmert.

Hoewel Large Language Models (LLMs) in staat zijn om Register-Transfer-Level (RTL) code in grote hoeveelheden te genereren, is de functionaliteit van deze gegenereerde code vaak onjuist. Traditioneel wordt dit gezien als een belemmering voor gebruik in circuitanalyse, omdat functionele correctheid vaak als een vereiste wordt gezien.

Kerninzicht

De auteurs doen een cruciale observatie: zelfs wanneer LLM-gegenereerde RTL functioneel imperfect is, behouden de gegenereerde netlists structurele patronen die sterk indicatief zijn voor de beoogde functionaliteit. De structuur is gedeeltelijk losgekoppeld van de exacte functionaliteit. Dit betekent dat "ruis" in de code (functionele fouten) niet noodzakelijkerwijs de bruikbaarheid van de data voor het leren van structurele representaties ondermijnt.

Methodologie

Het paper stelt een end-to-end framework voor dat LLMs gebruikt als schaalbare, kosteneffectieve data-generators. Het proces bestaat uit drie hoofdfasen:

1. Circuit Data Augmentation (Data Augmentatie):

   • LLM-gebaseerde Generatie: Het framework accepteert ofwel functionele specificaties of bestaande RTL-code. De LLM genereert nieuwe RTL-implementaties op basis van deze specificaties. Om complexiteit te beheersen, wordt een "bottom-up" aanpak gebruikt waarbij sub-modules apart worden gegenereerd.
   • Synthese Feedback Loop: Een synthesizer (zoals Synopsys Design Compiler) en een debug-agent worden gebruikt om de gegenereerde code te valideren en te repareren, zodat alleen synthetiseerbare netlists worden gegenereerd.
   • Netlist-level Filtering (Kwaliteitscontrole): Om functioneel irrelevante ontwerpen te verwijderen, wordt een filter toegepast op basis van structurele gelijkenis. De gegenereerde netlist wordt vergeleken met een "golden" (referentie) netlist. Als de cosine-similariteit van hun grafische embedding onder een bepaalde drempel ($\tau$) ligt, wordt de data verworpen. Dit behoudt architecturale variatie maar verwijdert complete fouten.
   • RTL-level Architecture Voting: Om architecturale diversiteit te vergroten (bijv. verschillende soorten adders voor dezelfde functie), gebruikt het framework een LLM als evaluator. De LLM stemt op een batch gegenereerde ontwerpen en selecteert de meest diverse en complexe implementaties. Dit zorgt voor een trainingsset die rijk is aan verschillende architecturale keuzes.

2. Netlist Representatie Learning:

   • De gegenereerde netlists worden omgezet in grafen (knooppunten = poorten, randen = draden).
   • Er worden features geëxtraheerd (connectiviteit, functionele type, structurele eigenschappen).
   • Een Graph Neural Network (GNN) (specifiek gebaseerd op GraphSAINT voor schaalbaarheid) wordt getraind om robuuste embeddings te leren die zowel structurele als functionele informatie bevatten.

3. Downstream Taken:

   • De geleerde embeddings worden gebruikt voor taken zoals sub-circuit boundary identification (node-level classificatie) en component classificatie (graph-level classificatie).

Belangrijkste Bijdragen

1. Herwaardering van Imperfecte RTL: Het paper toont aan dat netlist-structurele eigenschappen intrinsiek robuust zijn tegen functionele fouten in de bron-RTL. Dit biedt een principieel fundament voor het gebruik van "ruisachtige" supervisie in hardware-representatielearning.
2. Kosteneffectief Framework: Het is het eerste framework dat systematisch functioneel imperfecte LLM-gegenereerde RTL gebruikt voor circuitrepresentatielearning. In vergelijking met handmatige annotatie of regelgebaseerde augmentatie (zoals logische herschrijving), verlaagt het de kosten met ordes van grootte en biedt het superieure architecturale diversiteit.
3. Schaalbaarheid naar Real-World Scenarios: Het framework is succesvol getest op schaal, van operator-niveau tot IP-niveau (hele CPU-kernen), en overwint de data-bottleneck in circuitanalyse.

Resultaten

De evaluaties werden uitgevoerd op benchmarks met toenemende complexiteit:

• Operator-niveau: Modellen getraind op de synthetische, LLM-gegenereerde dataset (met filtering) presteerden beter dan basismodellen getraind op kleine, hoogwaardige datasets. Een specifieke dataset (LLM-Aug-t2) bereikte een F1-Macro van 93,79%, wat 3,64% hoger was dan de baseline.
• Generalisatie: Het gebruik van de "Architecture Voting" mechanisme leidde tot de beste generalisatie op onbekende architecturale varianten (F1-Micro van 94,45%), wat aantoont dat de diversiteit in de trainingsdata essentieel is.
• IP-niveau Case Study (PicoRV32 & NEORV32): In een strikte test waarbij het model werd getraind op PicoRV32-data en getest op een onbekende NEORV32 SoC, behaalde het gefilterde LLM-framework een F1-score van 68,35%. Dit was aanzienlijk beter dan regelgebaseerde augmentatie (58,28%) en ruwe LLM-data (60,44%). Het framework slaagde erin de functionele grenzen van de CPU-core correct te identificeren in een onbekend ontwerp.

Betekenis

Dit werk doorbreekt de data-bottleneck in het veld van circuitrepresentatielearning. Het toont aan dat men niet afhankelijk hoeft te zijn van schaarse, perfect gelabelde datasets. Door slimme filtratie en het benutten van de architecturale diversiteit van LLMs, kunnen modellen worden getraind die generaliseren naar complexe, real-world IP-ontwerpen. Dit opent de deur voor schaalbare oplossingen in taken zoals IP-piraterijdetectie, reverse engineering en hardware security auditing.