🤖 machine learning

Scratchpad Patching: Decoupling Compute from Patch Size in Byte-Level Language Models

Dit artikel introduceert Scratchpad Patching (SP), een techniek die de rekencapaciteit ontkoppelt van de patchgrootte in byte-niveau taalmodellen door dynamisch tijdelijke scratchpads in te voegen om patchvertraging te mitigeren, waardoor grotere patches mogelijk worden voor verlaagde KV-cache- en rekencosts zonder in te leveren op de modelkwaliteit.

Oorspronkelijke auteurs: Lin Zheng, Vasilisa Bashlovkina, Timothy Dozat, Dan Garrette, Laura Rimell, Joshua Maynez

Gepubliceerd 2026-05-12

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Lin Zheng, Vasilisa Bashlovkina, Timothy Dozat, Dan Garrette, Laura Rimell, Joshua Maynez

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 probeert een zeer lang boek te lezen, maar je hebt een strikte regel: je mag alleen naar de tekst kijken in grote stukken, alsof je een handvol pagina's tegelijk pakt. Zo werken moderne "patch-based" AI-modellen. In plaats van woord voor woord (tokens) te lezen, lezen ze byte voor byte (de ruwe computercode voor letters) in groepen die patches worden genoemd.

Het probleem met deze "pak een handvol"-aanpak is een fenomeen dat de auteurs Patch Lag noemen.

Het Probleem: Het "Verouderde" Handvol

Stel je voor dat je een alinea leest. Je pakt een stuk tekst (een patch) om te verwerken.

De Laatste Pagina: Wanneer je bij de allerlaatste pagina van dat stuk komt, heb je het volledige beeld van wat je zojuist hebt gelezen. Je kunt een perfecte voorspelling doen over wat er als volgt.
De Eerste Pagina: Maar wanneer je op de eerste pagina van datzelfde stuk zit, heb je het overige deel van het stuk nog niet echt gezien! Je bent gedwongen om te gokken op basis van het vorige stuk dat je las.

Als je stukken enorm zijn (zeg maar 16 bytes lang), gokken de eerste 15 bytes op basis van "verouderde" informatie uit het verleden. Hoe groter het stuk, hoe langer deze "lag" duurt, en hoe slechter de AI wordt in het voorspellen van de volgende letter.

Meestal moet je kiezen:

Kleine Stukken: Grote nauwkeurigheid, maar de AI moet veel werk verzetten (traag en duur).
Grote Stukken: Snel en goedkoop, maar de AI maakt meer fouten omdat het te ver vooruit gokt.

De Oplossing: Het "Schraapbord"

De auteurs introduceren een slimme truc genaamd Scratchpad Patching (SP).

Denk het zo: je pakt nog steeds die grote handvol pagina's (patches) om dingen efficiënt te houden. Maar, in je hand heb je een tijdelijk schraapbord.

Terwijl je naar de eerste paar pagina's van het stuk kijkt, maak je snel notities op je schraapbord.

De Magie: Deze notities zijn tijdelijk. Je gebruikt ze om je begrip onmiddellijk bij te werken, zodat je betere voorspellingen kunt doen voor de volgende paar pagina's.
De Haken en Ogen: Zodra je het stuk hebt afgewerkt en naar het volgende gaat, gooi je het schraapbord weg. Je bewaart het niet in je langetermijngeheugen (de "KV-cache").

Dit stelt de AI in staat om het tempo van grote stukken te hebben (omdat het alleen het eindresultaat van het stuk opslaat) maar het intelligentieniveau van kleine stukken (omdat het zijn kennis halverwege het stuk ververst).

Hoe Weet Het Wanneer Het Het Schraapbord Moet Gebruiken?

De AI gebruikt het schraapbord niet voor elke enkele letter; dat zou te traag zijn. In plaats daarvan gebruikt het een "verkeerslichtsysteem" gebaseerd op Entropie (een chique woord voor "verassing" of "onzekerheid").

Lage Verrassing: Als de tekst saai en voorspelbaar is (zoals "de kat zat op de..."), slaat de AI het schraapbord over. Het weet wat er komt.
Hoge Verrassing: Als de tekst complex of onvoorspelbaar wordt (zoals een plotselinge variabele-naam in code of een vreemd symbool), activeert de AI het schraapbord. Het zegt: "Wacht, dit is belangrijk! Laat me pauzeren en alles wat ik tot nu toe in dit stuk heb gezien opnieuw evalueren voordat ik de volgende letter gok."

De Resultaten: Het Beste van Beide Werelden

Het artikel toont aan dat deze methode werkt als een magische schakelaar:

Kwaliteit zonder de Kosten: Zelfs bij het gebruik van zeer grote stukken (16 bytes) presteert de AI met schraapborden bijna net zo goed als wanneer het byte voor byte zou lezen.
Geheugenvoordeel: Omdat het schraapbord direct wordt weggegooid, hoeft de AI geen extra geheugen op te slaan. Het houdt de "KV-cache" (het kortetermijngeheugen van de AI) 16 keer kleiner dan een standaard byte-voor-byte-model.
Flexibele Snelheid: Je kunt de "schraapbordschakelaar" na het trainen van het model omhoog of omlaag zetten. Als je wilt dat het supersnel is, zet je de schraapborden uit. Als je wilt dat het slimmer is, zet je ze aan. Je hoeft het model niet opnieuw te trainen om dit te doen.

Samenvattende Analogie

Stel je voor dat je een kok bent die een enorme stoofpot kookt.

Oude Manier (Standaard Patching): Je proeft de stoofpot slechts één keer elke 10 minuten. Als je op minuut 1 een pittig ingrediënt toevoegt, proef je het pas weer op minuut 10. Tegen die tijd kan de smaak misschien al verkeerd zijn.
Nieuwe Manier (Scratchpad Patching): Je neemt nog steeds elke 10 minuten een volledige "officiële" proef om het recept te loggen. Maar ertussenin doop je een lepel in zodra de geur drastisch verandert (hoge entropie) om je kruiden direct aan te passen. Je gooit de lepel weg na het proeven, zodat je geen miljoen lepels hoeft te wassen (geheugen), maar je stoofpot smaakt perfect.

Het artikel bewijst dat door deze tijdelijke "proefmomenten" (schraapborden) toe te voegen, je een enorme pot stoofpot (lange tekst verwerken) snel, goedkoop en met perfecte smaak kunt koken.

Technische Samenvatting: Scratchpad Patching (SP)

Probleemstelling

Moderne taalmodellen vertrouwen doorgaans op tokenisatie om tekst te segmenteren in subwoordeenheden, een proces dat broosheid, gevoeligheid voor promptopmaak en schaalproblemen introduceert. Tokenizer-vrije benaderingen die direct op bytes werken, bieden een oplossing, maar lijden onder prohibitieve rekenkosten vanwege lange sequentielengtes. Om dit te mitigeren, aggregeren patch-gebaseerde byte-level modellen aaneengesloten bytes in grotere "patches", die als enkele eenheden worden verwerkt om de sequentielengte en de footprint van de KV-cache te verminderen.

De auteurs identificeren echter een fundamenteel compromis in standaard patch-gebaseerde architecturen: patch-lag. In deze modellen werkt de hoofdtrunk (de primaire rekenmotor) zijn representatie alleen bij op de grenzen van patches. Bijgevolg moet het model voor elke byte binnen een patch die niet de laatste is, vertrouwen op een "verouderde" representatie van de vorige patch om causaliteit te behouden. Naarmate patchgroottes toenemen om de efficiëntie te verbeteren, wordt deze lag groter, waardoor meer voorspellingen moeten vertrouwen op verouderde context, wat de modelkwaliteit aanzienlijk verslechtert. Dit creëert een strakke koppeling waarbij grotere patches betere efficiëntie opleveren maar slechtere kwaliteit.

Methodologie: Scratchpad Patching (SP)

Het artikel introduceert Scratchpad Patching (SP), een mechanisme dat is ontworpen om rekenallocatie te ontkoppelen van patchgrootte, waardoor patch-lag wordt aangepakt zonder de persistente KV-cache-footprint te vergroten.

Kernmechanisme

In plaats van slechts aan het einde van een patch één representatie vast te leggen, voegt SP transiënte scratchpad-toestanden in op geselecteerde interne byte-posities binnen een patch.

Transiënte toestanden: Wanneer een scratchpad wordt geactiveerd, aggregeert het model alle tot nu toe geziene bytes binnen de huidige patch, voert deze aggregatie door de hoofdtrunk en genereert een frisse representatie.
Behoud van causaliteit: Deze frisse representatie is direct beschikbaar voor daaropvolgende byte-voorspellingen binnen dezelfde patch, en vervangt de verouderde representatie van de vorige patch.
KV-cache-efficiëntie: Cruciaal worden deze scratchpad-toestanden niet gepersisteerd in de KV-cache. Ze worden tijdens inferentie on-the-fly berekend en direct verworpen. Alleen de uiteindelijke "vastgelegde" patch-representatie wordt opgeslagen. Hierdoor kan het model meerdere verfijningstappen uitvoeren binnen een patch zonder de geheugenvoetafdruk tijdens inferentie of de effectieve sequentielengte die door de trunk wordt gezien, te vergroten.

Activeringsstrategie

Om de rekenkosten van updates bij elke byte te vermijden (wat de voordelen van patching teniet zou doen), hanteert SP een selectief activeringsmechanisme:

Entropie-gebaseerde activering: Een scratchpad-update wordt geactiveerd op bytepositie $n$ als de entropie van de volgende-byte-voorspelling van de encoder een vooraf gedefinieerde drempel ( $\tau_{SP}$ ) overschrijdt.
Content-adaptiviteit: Deze strategie wijst selectief rekenkracht toe aan "informatiedichte" gebieden waar het model onzeker is, en slaat voorspelbare gebieden over.
Aanpassing achteraf: Omdat de trigger gebaseerd is op een drempel die wordt toegepast op de output van de encoder, kan de frequentie van scratchpad-updates tijdens inferentie worden aangepast zonder hertraining, wat flexibele compromissen tussen rekenkracht en kwaliteit mogelijk maakt.

Architectuur

SP is agnostisch ten opzichte van de onderliggende patchifier (de methode die wordt gebruikt om patchgrenzen te definiëren). Het integreert in de standaard vijf-componenten patch-gebaseerde architectuur (Encoder, Patchifier, Main Trunk, Unpatchifier, Decoder) door de informatiestroom binnen de patch te wijzigen. Tijdens training worden scratchpad-toestanden uitgerold en geconcateneerd met de trunk-input, met een gespecialiseerd causaal attentiemasker dat voorkomt dat scratchpads naar toekomstige toestanden of andere scratchpads kijken, zodat ze uitsluitend vorige bytes binnen de huidige patch aggregeren.

Belangrijkste Bijdragen

Ontkoppeling van rekenkracht en patchgrootte: SP introduceert een algemeen mechanisme dat modellen toestaat grotere patches te gebruiken (voor efficiëntie) zonder te lijden onder de kwaliteitsverslechtering die doorgaans geassocieerd wordt met verhoogde patch-lag.
Aanpak van patch-lag: De auteurs karakteriseren patch-lag als een structureel falingspatroon van patch-gebaseerde modellen en tonen aan dat SP deze lag effectief reduceert door de context binnen de patch te verversen.
Efficiënte inferentie: SP bereikt deze verbeteringen terwijl het dezelfde vastgelegde patch-sequentielengte en KV-cache-footprint behoudt als standaard patch-gebaseerde modellen.
Flexibele rekencontrole: De methode maakt achteraf aanpassing van rekenkracht tijdens inferentie mogelijk via entropiedrempels, wat een "single-knob"-bediening biedt voor compromissen tussen efficiëntie en nauwkeurigheid.

Experimentele Resultaten

De auteurs evalueerden SP over vier patchifier-families (Vaste grootte, SpaceByte, Entropie-gebaseerd en H-Net) op datasets voor natuurlijke taal, code en wiskunde.

Kwaliteit-Efficiëntie Frontier: SP verschuift consequent de Pareto-frontier van kwaliteit (gemeten in Bits-Per-Byte, BPB) versus efficiëntie (sequentiereductie).
Hoge patchgroottes: Bij agressieve patchgroottes (bijvoorbeeld 16 bytes per patch) bereiken met SP verrijkte modellen de prestaties van byte-level baselines of benaderen deze nauwkeurig. Zo behaalde een Fixed-size (p=16) model met SP een gemiddelde NLU-nauwkeurigheid van 54,2, wat bijna overeenkomt met de byte-level baseline (54,1), terwijl het gebruikte 16× kleinere KV-cache en 3–4× minder inferentie-rekenkracht.
Codegeneratie: SP verbeterde de pass@1-rates op MBPP- en HumanEval-benchmarks aanzienlijk, met name voor grote patchgroottes waar standaardmodellen moeite hadden.
Rekenallocatie: Bij vergelijkingen op basis van gelijke FLOPs presteerden SP-modellen over het algemeen gelijk aan of beter dan non-SP-baselines, wat suggereert dat de winst voortkomt uit beter gerichte rekenallocatie en niet simpelweg uit het toevoegen van meer rekenkracht.
Meertalige robuustheid: SP verbeterde de prestaties van patch-gebaseerde modellen over 200 talen (FLORES-200) en verkleinde de kloof met pure byte-level modellen.

Betekenis en Claims

Het artikel beweert dat Scratchpad Patching een praktische stap voorwaarts is naar flexibelere end-to-end taalmodellen. Door modellen toe te staan te beslissen waar ze rekenkracht toewijzen op basis van informatiedichtheid in plaats van starre segmentatie te erven van een tokenizer of patchifier, biedt SP een superieur compromis tussen persistente sequentielengte, rekenkosten en taakprestaties.

De auteurs benadrukken dat SP een generieke techniek is die toepasbaar is op veel bestaande patch-gebaseerde architecturen. Zij merken op dat met SP de prestatiekloof tussen verschillende patchificatiestrategieën (bijvoorbeeld vaste grootte versus geleerde grenzen) kleiner wordt, wat suggereert dat rekenallocatie een kritieker bottleneck kan zijn dan de specifieke methode voor het definiëren van patchgrenzen.

Het werk is bescheiden in zijn beperkingen: het richt zich op single-stage patching en reduceert niet direct de FLOPs tijdens training ten opzichte van standaard baselines (hoewel het de inferentie-efficiëntie verbetert). De auteurs suggereren dat toekomstig werk hiërarchische architecturen en rijkere update-regels kan verkennen.