Technische Samenvatting: Program-as-Weights (PAW)

1. Probleemstelling

Veel real-world programmeertaken verzetten zich tegen een precieze, op regels gebaseerde implementatie. Deze "fuzzy functies" — zoals het filteren van logregels op urgentie, het repareren van malafide JSON, of het rangschikken van zoekresultaten op basis van intentie — zijn intuïtief voor mensen, maar fragiel bij implementatie met scherpe symbolische regels (bijv. reguliere expressies) vanwege ruis, typefouten en randgevallen.

Momenteel besteden ontwikkelaars deze taken uit aan Large Language Model (LLM) API's. Hoewel dit handig is, brengt deze aanpak hoge kosten met zich mee, introduceert het latentie, ondermijnt het reproduceerbaarheid (door stille modelupdates door providers) en voorkomt het dat software zelfvoorzienend is. Het artikel stelt de behoefte aan een paradigma voor dat de flexibiliteit van LLM's behoudt voor fuzzy taken, terwijl het lokale, reproduceerbare en kosteneffectieve uitvoering mogelijk maakt.

2. Methodologie: Program-as-Weights (PAW)

De auteurs stellen Program-as-Weights (PAW) voor, een paradigma waarbij een fuzzy functie wordt gecompileerd van een natuurlijke taal-specificatie naar een compact, lokaal uitvoerbaar neuraal artefact. Het systeem ontkoppelt het "zware werk" van het begrijpen van de specificatie van het "dagelijkse werk" van het uitvoeren van de functie.

Kernarchitectuur

De PAW-pipeline bestaat uit drie hoofdonderdelen:

1. De Compiler: Een neuraal model dat een gebruikersspecificatie ($s$) mapt naar een programma ($p$).
2. Het Programma ($p$): Een hybride artefact bestaande uit:
   • Discreet Component ($p_{discrete}$): Een "pseudo-programma" in natuurlijke taal (een herformulering van de taak plus representatieve input-output voorbeelden). Dit beschermt de interpreter tegen ambiguïteit en typefouten in de oorspronkelijke specificatie.
   • Continu Component ($p_{continuous}$): Een Parameter-Efficient Fine-Tuning (PEFT) module (specifiek LoRA of prefix-tuning KV cache) die een bevroren interpreter specifiek voor de taak hertraint.
3. De Interpreter: Een klein, bevroren taalmodel (bijv. Qwen3-0.6B) dat het programma uitvoert. Het laadt de PEFT-module en het pseudo-programma, verwerkt de gebruikersinput en genereert de output autoregressief.

De Compilatie-pipeline

Het compilatieproces omvat twee stadia, die beide gebruikmaken van een 4B Qwen3-model:

1. Pseudo-Compiler ($C_p$): Een standaard, ongetraind model dat wordt aangestuurd met een taak-herschrijftemplate. Het zet de ruwe gebruikersspecificatie om in een schoon pseudo-programma met een duidelijke taakbeschrijving en few-shot voorbeelden.
2. PEFT Compiler ($C_{PEFT}$): Een getraind model (specifiek een LoRA-compiler in de huidige beste instantie) dat de specificatie en het pseudo-programma als input neemt. Het geeft de continue PEFT-gewichten (Lo-matrices) af door de verborgen toestanden van het model te mappen via een LoRA-mapper.
   • De mapper aggregeert verborgen toestanden van specifieke lagen van de compiler, poolt deze en projecteert ze in mengcoëfficiënten. Deze coëfficiënten componeren LoRA-matrices ($A, B$) over een set gedeelde leerbare bases, waarbij ongeveer 38,5 miljoen parameters per functie in de interpreter worden geïnjecteerd.

Training

Alleen de PEFT-compiler en de LoRA-mapper worden getraind. De pseudo-compiler en de interpreter blijven bevroren. Het trainingsdoel is het maximaliseren van de waarschijnlijkheid van de doeloutput gegeven de bevroren interpreter, het gegenereerde pseudo-programma en de gegenereerde LoRA-gewichten. Dit is een enkele supervised objective met behulp van de FuzzyBench dataset.

3. Belangrijkste Bijdragen

FuzzyBench Dataset

De auteurs brengen FuzzyBench uit, een dataset van 10 miljoen voorbeelden die ontworpen is om PAW-achtige methoden te trainen.

• Constructie: Gegenereerd met gpt-5.2 via een tweestaps-pipeline (generatie van specificaties gevolgd door generatie van input/output paren).
• Dekking: Opgebouwd in 29 thematische versies, met dekking van 800+ categorieën van fuzzy taken (bijv. tekstverwerking, formaatherstel, agentic tool-gebruik, veiligheidsverificatie).
• Verificatie: Bevat een geverifieerde testset waarbij twee sterke modellen het eens moeten zijn over de output om ambigue targets te filteren. Het bevat ook ruis-geperturbte versies (typefouten, grammaticafouten, ambiguïteit) voor robuustheidsevaluatie.

Het PAW-systeem

• Text-to-LoRA Instantie: De auteurs demonstreren dat het genereren van LoRA-adapters vanuit tekstspecificaties beter presteert dan prefix-tuning en directe prompting.
• Modaliteit-generalisme: De abstractie strekt zich uit tot beeld-geconditioneerde taken door enkel de compiler te vervangen door een vision-language model (Qwen3-VL), terwijl dezelfde tekst-gebaseerde interpreter behouden blijft.
• Developer Interface: Een praktische API (paw.compile, paw.function) waarmee ontwikkelaars specificaties kunnen compileren naar serialiseerbare gewichtsbestanden (GGUF-formaat) die volledig offline draaien.

4. Experimentele Resultaten

Prestaties op FuzzyBench

• Nauwkeurigheid: Een 0.6B-parameter interpreter die PAW-programma's uitvoert, bereikt 73,78% exact match op FuzzyBench.
• Vergelijking: Dit presteert beter dan directe prompting van Qwen3-32B (68,70%) en overtreft aanzienlijk de prestaties van de 0.6B base model met directe prompting (9,84%).
• Efficiëntie: Het PAW-systeem gebruikt ongeveer 1/50ste van de inferentiegeheugen van het 32B model (~1,2 GB vs. ~60 GB).
• Latentie: Op een MacBook M3 draait het gekwantiseerde systeem met 30 tokens/seconde.

Robuustheid

• PAW vertoont een hoge robuustheid tegen ruisige specificaties (typefouten, grammaticafouten). Het discrete pseudo-programma fungeert als een denoiser; wanneer de ruwe ruisige specificatie direct naar de interpreter wordt gevoed (zonder het pseudo-programma), daalt de prestatie aanzienlijk (4,5 punten bij zware typefouten), terwijl de volledige PAW-pipeline slechts licht degradeert.

Ablatie-studies

• Noodzaak van de Compiler: PAW presteert 15,4 procentpunt beter dan full fine-tuning van de 0.6B base en 21,7 punten beter dan vaste LoRA's, wat bevestigt dat de winst komt uit de door de compiler gegenereerde, specificatie-bewuste LoRA.
• Architectuur: Het eenvoudigste LoRA-mapper ontwerp (mean-pooling verborgen toestanden in één vector, een ondiepe MLP, gedeelde bases) bleek superieur aan complexere, "expressievere" varianten.
• Kwantisatie: Het kwantiseren van de base naar Q6_K en de LoRA-adapter naar Q4_0 resulteert in een verwaarloosbaar nauwkeurigheidsverlies vergeleken met bf16, met een totale opslagvoetafdruk van ~507 MB.

Casestudies

Het artikel valideert het paradigma op vijf use cases:

1. Event-gestuurde log-monitoring: Lokale classificatie van de urgentie van logs.
2. Intent-gebaseerde sitenavigatie: Classificatie van gebruikersintentie zonder API-calls.
3. Semantische zoekherrangschikking: Herrangschikken van keyword zoekresultaten op basis van intentie.
4. Agent preprocessing: Een tool-calling pipeline die 93% scoort op TOOLCALL-15.
5. Creatieve generatie: Een meertalig woord-raadspel (Alien-Taboo) bediend door een 0.6B interpreter.

5. Betekenis en Claims

Het artikel presenteert PAW als een concrete stap naar een "small-model future" waarbij foundation modellen fungeren als tool builders in plaats van per input probleemoplossers.

• Paradigmaverschuiving: In plaats van voor elke query een massaal model aan te roepen, vindt het zware werk (het begrijpen van de fuzzy specificatie) één keer plaats tijdens de compilatie. Het resulterende artefact is een klein, herbruikbaar, versiebeheerbaar en distribueerbaar "neuraal binair bestand".
• Lokale Executie: PAW maakt het mogelijk om complexe fuzzy logica volledig offline uit te voeren op consumentenhardware (bijv. MacBooks, browsers via WebAssembly), wat de problemen van kosten, privacy en reproduceerbaarheid die gepaard gaan met cloud LLM API's aanpakt.
• Modulariteit: De "één runtime, vele programma's" architectuur stelt een enkele kleine interpreter in staat om onbegrensd veel fuzzy functies te dienen door de PEFT-adapters te wisselen (hot-swapping).

De auteurs blijven bescheiden over beperkingen, waarbij zij opmerken dat het systeem momenteel single-step fuzzy functies afhandelt (multi-step reasoning is toekomstig werk), vertrouwt op synthetische trainingsdata, en de compiler moet hertrainen als de interpreter-architectuur verandert. Ze betogen echter dat voor de klasse van taken die zich verzetten tegen symbolische implementatie maar geen enorme context of redenering vereisen, PAW een levensvatbaar, efficiënt en lokaal alternatief biedt voor API-gebaseerde LLM's.