🤖 AI

Differentiate the Evaluator, Not the Program: An Efficient Runtime Representation for Neuro-Symbolic Learning

Dit artikel introduceert de Native Differentiable Virtual Machine (NDVM), een runtime-representatie die uitvoerbare programma's efficiënt differentieert door de symbolische structuur te scheiden van de gebatchte numerieke staat, waardoor de knelpunten van traditionele programma-en-parameter co-zoekprocessen worden overwonnen en neuro-symbolische wetenschappelijke ontdekking met wel 24x wordt versneld.

Oorspronkelijke auteurs: Lucas Sheneman

Gepubliceerd 2026-07-07

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Lucas Sheneman

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

Het Grote Probleem: De "Custom Car" Bottleneck

Stel je voor dat je een autofabrikant bent die probe op zoek is naar het perfecte autoontwerp. Je hebt een AI die elke dag duizenden nieuwe blauwdrukken voor auto's bedenkt. Sommige zijn vrachtwagens, sommige zijn sportwagens, sommige hebben drie wielen en sommige hebben geen deuren.

Voor elke nieuwe blauwdruk moet je testen hoe goed deze rijdt op een specifiek circuit. Om dit te doen, moet je meestal:

Een aangepaste fabriek bouwen voor die ene specifieke auto-blauwdruk.
De test uitvoeren om te zien hoe snel hij rijdt.
De motorinstellingen aanpassen (de continue parameters) om hem sneller te maken.
De fabriek weer afbreken omdat de volgende blauwdruk totaal anders is.

Het paper stelt dat deze aanpak een verspilling van tijd is. Een nieuwe fabriek bouwen (een nieuwe computergrafiek compileren) voor elke auto gaat zo langzaam dat je nauwelijks tijd hebt om de auto's daadwerkelijk te besturen. De bottleneck is niet het rijden; het is het bouwen van de fabriek.

De Oude Manier vs. De Nieuwe Manier

De Oude Manier (Staging):
Huidige methoden behandelen elke nieuwe auto-blauwdruk als een uniek project. Ze stoppen het proces om een gespecialiseerd, hogesnelheidstestcircuit te bouwen voor die specifieke auto. Als de AI 1.000 verschillende auto's voorstelt, bouw je 1.000 verschillende circuits. Dit is traag omdat je al je tijd besteedt aan het bouwen van circuits, in plaats van aan het rijden.

De Oude Manier (Interpreter):
Een andere methode gebruikt een generiek "universeel testcircuit" (een interpreter) waar je elke auto kunt besturen. Echter, dit circuit is gebouwd met zware, logge apparatuur. Elke keer als de auto een hobbel raakt of een bocht maakt, moet het circuit stoppen, een handleiding raadplegen en zichzelf opnieuw configureren. Het is zo traag dat de auto nauwelijks vooruit komt.

De Nieuwe Manier (NDVM): "Differentiate the Evaluator, Not the Program"
De auteurs hebben een Native Differentiable Virtual Machine (NDVM) gebouwd. Zie dit als een uiterst efficiënte, universele rijsimulator.

In plaats van voor elke auto een nieuw circuit te bouwen, of een logge handmatige track te gebruiken, hebben ze één ongelooflijk snel circuit gebouwd dat elke auto-blauwdruk direct kan verwerken.

Hoe het werkt: De "Structurele/Numerieke Splitsing"

De geheime ingrediënt van NDVM is hoe het de vorm van de auto scheidt van de snelheid van de motor.

De Structuur (De Blauwdruk): De vorm van de auto (is het een vrachtwagen? heeft het 3 wielen?) wordt behandeld als eenvoudige, lichtgewicht data. Het is als een lijst met instructies geschreven op een stuk papier. Het systeem leest dit papier heel snel zonder iets nieuws te bouwen.
De Getallen (De Motor): De werkelijke snelheid, brandstof en bandenspanning zijn de "getallen" die aangepast moeten worden. In NDVM worden deze getallen compact samengepakt in een dichte, hogesnelheids-transportband (een batched buffer).

De Analogie:
Stel je een chef-kok (de evaluator) voor die elk recept (het programma) kan koken dat je hem geeft.

Oude Manier: Voor elk nieuw recept stopt de chef, bouwt hij een nieuwe keuken vanaf nul, kookt de maaltijd en breekt de keuken daarna weer af.
NDVM: De chef heeft één super-snelle, permanente keuken. Wanneer je hem een nieuw recept geeft, leest hij alleen de lijst met ingrediënten (de structuur) en begint hij direct met het koken van het eten (de getallen) op een hogesnelheidsassemblagelijn. Hij bouwt geen nieuwe keuken; hij verandert alleen het menu.

Waarom dit een Game-Changer is

Het paper mat precies waar de tijd naartoe ging in de oude systemen en vond een schokkende waarheid: 90% van de tijd werd besteed aan het beheren van de "keuken" (de interpreter), en slechts 1% aan het daadwerkelijk "koken" (het doen van de wiskunde).

Door het beheer van de keuken te scheiden van het koken, bereikte NDVM enorme snelheidsverbeteringen:

Batching (De Assemblagelijn): NDVM kan 256 verschillende motorinstellingen tegelijkertijd testen op exact dezelfde auto-blauwdruk. Omdat de "wandeling door de keuken" gedeeld wordt, daalt de kosten per instelling met ongeveer 60 keer.
Snelheid: In tests was NDVM tot wel 10.000 keer sneller dan het oude, logge systeem voor complexe taken.
Ontdekking: In een test waarbij een AI probeerde het beste wetenschappelijke model te vinden, vond NDVM goede oplossingen 24 keer sneller dan de oude manier. Het stelde de AI in staat om in dezelfde tijdheid een veel dieper "bos" aan mogelijkheden te verkennen.

Wat het NIET is

Het paper is zeer duidelijk over wat deze technologie niet is:

Het is geen toverstaf die elk computerprogramma sneller maakt. Als je één specifiek programma hebt dat je miljoenen keren uitvoert, is de oude "bouw een aangepaste fabriek"-methode nog steeds beter.
Het is geen manier om ruwe randen in de wiskunde glad te strijken. Het houdt de logica exact en discreet (een auto is ofwel een vrachtwagen of een sedan, niet een "bijna" vrachtwagen).
Het is momenteel een CPU-gebaseerd systeem (zoals een standaard computerprocessor), nog geen gespecialiseerd grafische kaart (GPU) systeem, hoewel de auteurs van plan zijn dit later te bouwen.

De Kernboodschap

Het paper introduceert een nieuwe manier om computerprogramma's uit te voeren die aangepast en getest moeten worden. In plaats van elk nieuw programma te behandelen als een uniek constructieproject, behandelt het het programma als eenvoudige data en draait het door één hoog-geoptimaliseerde motor. Hierdoor kunnen wetenschappers en AI-systemen duizenden verschillende ideeën testen in de tijd die het vroeger kostte om er slechts een paar te testen, wat de ontdekking van nieuwe wetenschappelijke modellen veel sneller maakt.

Technische Samenvatting: Differentieer de Evaluator, niet het Programma

1. Probleemstelling

Het artikel behandelt een centrale bottleneck in programma- en parameter-co-zoekopdrachten (program-and-parameter co-search), een workflow waarbij een buitenste lus (bijv. evolutionaire zoektocht of Large Language Models) duizenden structureel verschillende kandidaat-wetenschappelijke modellen voorstelt, en een binnenste lus hun continue parameters kalibreert aan de hand van data.

Huidige implementatiestrategieën dwingen een afweging af:

Staging (Tracing/Partiële Evaluatie): Elk kandidaat-programma wordt gecompileerd naar een afzonderlijke differentieerbare graaf. Hoewel dit snel is voor een vast programma, offert het de "programma-als-data"-eigenschap op die vereist is voor een vloeiende zoektocht, aangezien de zoeklus niet kan muteren of kandidaten kan weggooien zonder opnieuw te compileren.
Interpreter-gebaseerde Benaderingen: Programma's blijven runtime-data, maar bestaande implementaties (bijv. eager tensor-frameworks zoals PyTorch) representeren elke runtime-waarde (tags, symbolen, heap-adressen, getallen) als een kleine getagde tensor. Dit brengt een enorme "representatiebelasting" met zich mee, waarbij de kosten voor het alloceren en doorlopen van deze tensors de werkelijke numerieke berekening domineren.

De kernhypothese is dat voor differentieerbare interpreters de dominante bottleneck representatie en controleflow-traversering is, en niet de rekenkunde. Bij consequentie wordt parameterkalibratie de beperkende factor in co-zoekopdrachten in plaats van modelgeneratie.

2. Methodologie: De Native Differentiable Virtual Machine (NDVM)

De auteurs stellen NDVM voor, een runtime-representatie die de symbolische structuur scheidt van de differentieerbare numerieke staat. De ontwerpfilosofie wordt samengevat door de slogan: "Differentiate the evaluator, not the program." (Differentieer de evaluator, niet het programma).

Kernprincipes van het Ontwerp

Structurele/Numerieke Splitsing:
- Discrete Structuur: Tags, symbolen, heap-adressen, closures en omgevingen worden gerepresenteerd als native scalaire waarden (bijv. integers). Zij worden nooit gedifferentieerd en alloceren geen tensoropslag.
- Numerieke Payloads: Alleen differentieerbare getallen leven in dichte, gebatchte buffers (Structure-of-Arrays). Een enkele structurele waarde kan wijzen naar een batch van $B$ numerieke payloads.
Exact Gerealiseerd Trace: Controleflow wordt niet gesmoothd of versoepeld. De evaluator voert het programma uit als data en legt een exacte trace vast van het gevolgde pad. Reverse-mode differentiatie wordt alleen toegepast op de numerieke primitieven op deze gerealiseerde trace.
Batch-Native Executie: Eén enkele evaluator-wand opereert simultaan over een populatie van parametervectoren. De structurele wand wordt gedeeld (scalar), terwijl alleen de numerieke payloads worden uitgebreid naar de batch-dimensie.
Native Tape: Reverse-mode differentiatie wordt vastgelegd als een compacte native tape die alleen numerieke operaties bevat. Structurele operaties (symboolopzoeking, tag-tests, branch dispatch) genereren geen tape-nodes.

Implementatiedetails

Runtime: Geïmplementeerd als een native C++ runtime met een direct-threaded evaluator, correcte tail calls en een write-once arena heap.
Differentiatie: Gebruikt een PyTorch autograd.Function grens om de native runtime als een differentieerbare tensoroperatie te exposeren, waardoor externe optimizers (bijv. Adam) de kalibratie kunnen aansturen.
Divergentie-afhandeling: Ondersteunt divergent controleflow over de batch via lane masking, wat ervoor zorgt dat gradiënten worden afgeschermd voor de lanes die specifieke paden hebben genomen.

3. Belangrijkste Bijdragen

Runtime-Representatie Thesis: Het artikel introduceert een structurele/numerieke splitsing voor differentieerbare symbolische berekeningen, wat exacte reverse-mode gradiënten op willekeurige runtime-programma's mogelijk maakt zonder per-programma staging.
Locked Phase-0 Kostenmodel: Door de profilering van een echte differentieerbare Scheme-interpreter (DMCI) op een PyTorch-backend, demonstreren de auteurs dat 85–90% van de forward execution tijd wordt besteed aan value boxing en evaluator-traversering, terwijl rauwe rekenkunde slechts ~1% of minder account. Deze kosten zijn batch-onafhankelijk.
Native Runtime Implementatie: Een volledig gerealiseerde CPU-runtime die exacte forward en gradient equivalentie bereikt ten opzichte van de baseline-backend over een diverse suite (scalars, recursie, closures, en een 80-staps Kalman filter).
Generaliteit: De representatie wordt gevalideerd op twee verschillende clients: de DMCI (een tree-walking evaluator) en een aparte stack-bytecode VM, wat bewijst dat de aanpak niet specifief is voor één enkele interpreter-architectuur.
Gedecodeerde Snelheidsanalyse: De auteurs isoleren de winst van de representatie (structurele/numerieke splitsing) versus de executie-engine (native versus Python).
- De representatie alleen (in eager Python) levert een 4–5× versnelling op.
- Native executie voegt daar een verdere 8× tot 2133× versnelling aan toe, afhankelijk van de programmadepte.

4. Resultaten

Het artikel rapporteert gemeten resultaten op een enkele CPU-kern (AMD Ryzen Threadripper PRO) met float32 precisie.

Batch Amortisatie: Door de structurele wand te delen over een batch van parametervectoren, vermindert NDVM de per-lane kalibratiekosten met ongeveer 60× bij de overgang van batchgrootte $B=1$ naar $B=256$ .
Multicore Schaalbaarheid: Omdat kandidaat-evaluaties geen gedeelde mutable state hebben, bereikt een multicore scheduler bijna lineaire schaling (~15× op 16 cores).
End-to-End Co-Search:
- Kalibratie-throughput: In een Kalman filter maximum-likelihood fit voert NDVM ~8100× meer kalibraties per CPU-uur uit dan de baseline (139.000 versus 17).
- Ontdekkingsfront: In een symbolische regressie taak met door LLM voorgestelde programma's, bereikt NDVM hoogwaardige oplossingen ~24× sneller in wandkloktijd.
- Recurrente Taken: Voor diepe geïtereerde maps bereikt de verschuiving van het front circa ~340×, waarbij NDVM succesvolle fits vindt die de baseline-backend binnen hetzelfde budget niet kan bereiken.
Vergelijking met Staging: Gestaged benaderingen (bijv. JAX) presteren pas beter dan NDVM na honderden tot tienduizenden gradiëntstappen per kandidaat. In co-search, waar kandidaten na een handvol stappen worden gemuteerd of weggegooid, is de "pay-nothing-to-stage" natuur van NDVM superieur.

5. Betekenis en Claims

Het artikel claimt dat efficiënte runtime-differentiatie parameterkalibratie snel genoeg kan maken om gelijke tred te houden met AI-gegenereerde modelvoorstellen.

Verschuiving in Bottleneck: NDVM verwijdert parameterkalibratie als de bottleneck in co-search, waardoor de model-voorstelstap (bijv. LLM-generatie) de nieuwe limiterende factor wordt.
Exactheid versus Relaxatie: In tegenstelling tot differentieerbare interpreters die controleflow versoepelen om het differentieerbaar te maken, behoudt NDVM exacte, discrete controle en differentieert enkel de numerieke payloads. Dit ondersteunt willekeurige runtime-programma's in een volledige taal zonder de noodzaak om relaxatieparameters af te stemmen.
Systeemfundament: Het werk biedt een praktisch systeemfundament voor wetenschappelijke ontdekkingsworkflows die gezamenlijk zoeken over zowel mechanistische structuur als kwantitatieve parametrisering.

Beperkingen en Omvang:

De huidige implementatie is gebaseerd op de CPU; een volledige GPU-interpreter is toekomstig werk.
De subset van de taal sluit mutatie uit (write-once heap), exceptions en dynamische shapes.
De correctheid van de gradiënten is empirisch gevalideerd tegen een baseline en eindige verschillen; een formeel machine-gecontroleerd bewijs is toekomstig werk.
De voordelen zijn specifief voor workloads waarbij de interpreter-traversering de rekenkunde domineert en waarbij kandidaten niet langdurig worden hergebruikt tijdens optimalisatie-runs.