Technische Samenvatting: De Neuronale Compiler

1. Probleemstelling

Wetenschappelijk machine learning (SciML) staat voor een fundamentele spanning tussen bekende natuurwetten en onbekende componenten. Onderzoekers beschikken vaak over de symbolische vorm van een vergelijking (bijvoorbeeld de structuur van de beweging van een slinger of een PDE voor warmtediffusie), maar moeten specifieke parameters of correctietermen uit data leren. Huidige benaderingen voor het integreren van deze kennis zijn onbevredigend:

• Verwerpen van Structuur: Pure neurale netwerken (MLP's, Neural ODE's) leren de volledige mapping uit data en negeren bekende fysica. Dit vereist overmatige parameters, faalt bij extrapolatie en produceert niet-interpreteerbare gewichten.
• Zachte Beperkingen: Physics-Informed Neural Networks (PINN's) coderen fysica als een regularisatieverlies. Hoewel elegant, staat deze "zachte" beperking het model toe natuurwetten te schenden als dit het dataverlies verlaagt, wat vaak leidt tot slechte parameterherwinning en catastrofale extrapolatiefalen.
• Handmatige Coding: Het direct schrijven van vergelijkingen als PyTorch nn.Module-instanties zorgt voor exacte berekening, maar vereist handmatige herimplementatie voor elke nieuwe vergelijking, is foutgevoelig en mist systematische compositie (het koppelen van vergelijkingen vereist nieuwe code voor elke combinatie).

2. Methodologie: De Neuronale Compiler

De auteurs stellen De Neuronale Compiler voor, een systeem dat programma's geschreven in een taal voor eerste-orde rekenkundige expressies (met Scheme-syntaxis) vertaalt naar bevroren, differentieerbare PyTorch-modules (nn.Module).

Brontaal

De invoertaal ondersteunt 51 primitieve operaties verdeeld over vier categorieën:

• Scalair Rekenen: Standaard wiskunde, goniometrie, exponentiële functies en logica.
• Vectoroperaties: Constructie, indexering, inproduct/kruisproduct, normen.
• Matrixoperaties: Constructie, vermenigvuldiging, inversie, determinanten.
• Besturingsflow: let-bindingen, tail-recursive loops (geoptimaliseerd tot iteratief) en algemene recursie.

Compilatiepijplijn

De compiler transformeert broncode via vier fasen in minder dan 150 µs:

1. Parse: Converteert S-expressies naar een Abstract Syntax Tree (AST).
2. ANF Transform: Converteert de AST naar A-Normal Form, waarbij samengestelde expressies worden afgevlakt tot let-bindingen om een één-op-één-correspondentie te creëren tussen bindingen en computationele knooppunten.
3. Tail-Call Optimalisatie: Transformeert tail-recursive functies naar iteratieve loops voor efficiëntie.
4. Grafiekconstructie: Genereert een DirectModule, een PyTorch-module die knooppunten in topologische volgorde evalueert met behulp van een instructie-dispatchmechanisme. Deze module is bevroren (geen trainbare parameters binnen de gecompileerde logica zelf), maar ondersteunt trainbare parameters die worden blootgelegd als symbolische constanten.

Hybride Architectuurpatronen

Het systeem ondersteunt drie integratiepatronen:

1. Bekende Structuur, Onbekende Parameters: De volledige vergelijking wordt gecompileerd, met specifieke constanten blootgelegd als nn.Parameter voor gradient-based learning.
2. Bekende Term + Geraande Correctie: Een gecompileerde module behandelt de bekende fysicaterm, terwijl een trainbare MLP een residuale correctie leert.
3. Compositieve Pijplijn: Meerdere gecompileerde modules worden aan elkaar gekoppeld om complexe pijplijnen te vormen.

3. Theoretische Garantiën

Het artikel levert formele bewijzen voor de eigenschappen van de compiler:

• Compilatiecorrectheid (Stelling 2): De gecompileerde module produceert output numeriek identiek aan het bronprogramma (floating-point precisie) op zijn veilige domein.
• Exactheid van Gradienten (Stelling 3): Autograd door de gecompileerde module levert de ware afgeleide van het programma op.
• Exactheid van Gecompileerde Componenten (Stelling 5): In hybride modellen draagt de gecompileerde component nul benaderingsfout bij op zijn veilige domein, zelfs buiten de trainingsverdeling. Alle fouten ontstaan uitsluitend uit de geleerde componenten.
• Compositiefoutgrenzen (Propositie 6): Kettingen van gecompileerde modules behouden nul fout op willekeurige diepte. In tegenstelling hiermee accumuleren neurale benaderingen fouten multiplicatief op basis van downstream Lipschitz-constanten.

4. Experimentele Resultaten

Het systeem werd geëvalueerd over zes domeinen tegenover vier baselines: Handmatige PyTorch, PINN's, Neural ODE's en pure MLP's.

Belangrijkste Bevindingen

• Numerieke Identiteit: Gecompileerde modellen produceerden resultaten numeriek identiek aan handmatige PyTorch-implementaties in alle experimenten (MSE-verschillen op machineprecisie), wat nul compiler-overhead bevestigt.
• Parameterherwinning:
  • Feynman-vergelijkingen: Gecompileerde modellen (1–3 parameters) herstelden fysische constanten met <1% fout op 13/15 vergelijkingen. PINN's (8.500+ parameters) toonden 7–93% fout.
  • Warmtevergelijking (PDE): Het gecompileerde model herstelde thermische diffusiviteit met 0,00% fout. De PINN toonde 92,7% fout.
  • Lotka-Volterra & Slinger: Gecompileerde modellen herstelden snelheidsconstanten en fysische parameters met <1,1% fout, terwijl PINN's faalden om deze nauwkeurig te herstellen en catastrofale extrapolatiefalen vertoonden.
• Extrapolatie: Hard-beperkte gecompileerde modellen generaliseerden perfect naar 5× extrapolatiebereiken. Zacht-beperkte PINN's en pure MLP's faalden om dynamiek te behouden of divergeerden aanzienlijk.
• Compositieve Generalisatie: Kettingen van gecompileerde modules behielden nul fout op dieptes tot 6. Neurale ketten acumuleerden fouten tot $5,9 \times 10^9$ bij 4× extrapolatie door foutversterking.
• Vectormechanica: De compiler verwerkte 3D-vectoroperaties (normen, schaling) succesvol met hoge nauwkeurigheid, waarbij de gravitatieconstante werd hersteld met 0,02% fout.

Computatiekosten

• Compilatie is een eenmalige kost (<150 µs).
• Trainings overhead voor hybride modellen is 2,5–3,8× trager dan pure MLP's door instructie-dispatch, maar dit wordt gecompenseerd door enorme winsten in nauwkeurigheid en parameter-efficiëntie (bijvoorbeeld 4.000× minder parameters voor de slingervergelijking).

5. Betekenis en Beweringen

Het artikel positioneert de Neuronale Compiler niet als een methode om de numerieke nauwkeurigheid van een enkele vergelijking te verbeteren (aangezien handmatige coding hetzelfde bereikt), maar als een hulpmiddel voor systematische compositie en programmatische modelgeneratie.

• Harde versus Zachte Beperkingen: De primaire bijdrage is het aantonen dat harde beperkingen (exacte compilatie) zachte beperkingen (PINN's) ver overtreffen in parameterherwinning en extrapolatie, met name voor transcendentale en PDE-problemen.
• Compositie: De compiler stelt wetenschappers in staat vergelijkingen te koppelen door tekststrings te wijzigen in plaats van nieuwe code te schrijven. Dit maakt het creëren van bibliotheken van fysica-modules mogelijk die opnieuw kunnen worden gecombineerd zonder herimplementatie.
• LLM-interface: Omdat de invoer een tekststring is, dient de compiler als een natuurlijke doelwit voor Large Language Models (LLM's). De auteurs stellen een toekomst voor waarin LLM's natuurlijke taal-fysicabeschrijvingen vertalen naar compileerbare programma's, waardoor "zelf-architecturerende" wetenschappelijke modellen mogelijk worden die nieuwe exacte-berekeningscapaciteiten ontwikkelen via compilatie.

De auteurs concluderen dat de compiler de kloof overbrugt tussen symbolische kennis en differentieerbaar leren, en een rigoureuze, exacte en compositieve alternatief biedt voor huidige neurale benaderingen in wetenschappelijk machine learning.