Dust: Pretraining van Transformers zonder Backpropagation

Samenvatting (TL;DR)

Wij presenteren de eerste nulde-orde methode die concurrerend is met backpropagation bij het pretrainen van transformer-taalmodellen. Dust perturbeert activaties (node-perturbatie) onafhankelijk voor elk token, waardoor elk token een virtueel populatielid wordt en één forward pass ze allemaal parallel evalueert.

Dust benadert backpropagation nauwkeurig bij een grote populatie (oftewel aanzienlijk meer rekenkracht) en overtreft deze in meerdere scenario's zelfs. Dit suggereert dat we in een regime met rijke rekenbronnen backpropagation zouden kunnen overtreffen.

Dust is orders van grootte efficiënter dan weight-space Evolution Strategies (ES). Vanaf 1 miljoen tokens is Dust, gebaseerd op onze extrapolaties, ongeveer $10^3$ tot $10^4$ keer efficiënter dan een transformer-implementatie van EGGROLL, een state-of-the-art ES-methode.

Er wordt algemeen aangenomen dat nulde-orde methoden niet schalen naar grote netwerken. Opvallend is dat we ontdekken dat grotere modellen juist populatie-efficiënter zijn: een model met 243 miljoen parameters presteert bij de meeste populatiegroottes beter dan een model dat $120\times$ kleiner is.

De gradiat-schattingen van Dust komen beter overeen met die van backpropagation naarmate de populatie groeit, en blijven goed uitgelijnd bij elke schaal die we testen, tot 1 miljard tokens, wat bemoedigend is voor verdere schaling.

---

1. Inleiding

Deep learning is gebouwd rond backpropagation, het enige credit assignment-algoritme dat in staat is om moderne neurale netwerken te trainen, inclusief transformer-gebaseerde taalmodellen. Backpropagation vereist differentieerbaarheid en produceert eerstegraads gradiënten; de architecturen, optimizers en hardware van deep learning zijn mee-evolueerd rond deze beperking.

Naarmate de beschikbare rekenkracht in de wereld toeneemt, zouden we echter de voorkeur kunnen geven aan meer generieke en brute-force leeralgoritmen gebaseerd op zoeken, in plaats van op inductieve biases zoals differentieerbaarheid, backpropagation en benaderingen van hogere-orde gradiënten. De "bitter lesson" (Sutton, 2019) is dat algemene methoden die schalen met rekenkracht uiteindelijk winnen, waarbij AlphaGo Zero (Silver et al., 2017) het meest duidelijke voorbeeld is. Het bootstrappen van AlphaGo op menselijke data hielp het netwerk aanvankelijk sneller te leren, maar met veel computationele kracht haalde het puur self-play netwerk het in.

Tương tự kunnen differentieerbaarheid en backpropagation goede inductieve biases zijn in een regime met weinig rekenkracht, waar ze het leren efficiënt maken, maar in een regime met veel rekenkracht beperken ze de ruimte van architecturen die werken. Zelfs binnen een architectuur slagen gradiënt-gebaseerde methoden er niet in om het verlieslandschap optimaal te verkennen (Liu et al., 2020). Dit zou ook kunnen verklaren waarom huidige neurale netwerken enorme hoeveelheden data nodig hebben om te generaliseren. Een flexibeler credit assignment-algoritme gebaseerd op zoeken is waarschijnlijk een belangrijke stap naar veel betere generalisatie.

In dit artikel streven we ernaar backpropagation te vervangen door een leeralgoritme dat veel meer gebaseerd is op brute-force berekeningen en veel minder op analytische structuur. We noemen dit Dust. Dust is een nulde-orde optimalisatiealgoritme dat activaties perturbeert, elke perturbatie beloont op basis van hoeveel deze het verlies verlaagt, en de belonings-gewogen perturbaties over een populatie middelt om de gradiënt te schatten. Traditionele ES-methoden die gewichten perturberen (Salimans et al., 2017), zoals EGGROLL (Sarkar et al., 2025), schalen met de populatie, maar het schalen van de populatie is kostbaar omdat elk lid gematerialiseerd en geëvalueerd moet worden.

Wij elimineren beide kosten met het concept van een virtuele populatie, waarbij we vermijden elk lid te materialiseren door de gewichtsruimte volledig te omzeilen en in plaats daarvan activaties te perturberen, zoals in node perturbation (Werfel et al., 2003; Widrow and Lehr, 1990). We doen dit onafhankelijk voor elk token, zodat elk token een lid is en één forward pass ze allemaal parallel evalueert.

Activaties zijn een interessantere ruimte om in te zoeken dan gewichten. Mechanistic interpretability heeft aangetoond dat redeneren, of dit nu verbaal uitgedrukt kan worden of niet, zich in de activaties bevindt (Gurnee et al., 2026; Lindsey et al., 2025), wat betekent dat deze aanpak training zou kunnen veranderen in een zoektocht naar latent redeneren (Vegesna and Dahal, 2025). We koppelen de perturbatie in de activatieruimte vervolgens aan een zeer generieke credit assignment-regel die verschillende beloningen op tokenniveau toekent aan verschillende laagtypen in een transformer-blok. Deze twee biases, samen met enkele implementatiedetails en efficiëntiemaatregelen (zoals het vermijden van interferentie tussen geperturbeerde modules), vormen het volledige algoritme.

Onze bijdragen zijn als volgt:

  • We presenteren de eerste nulde-orde methode die concurrerend is met backpropagation bij het pretrainen van transformer-taalmodellen. Bij grote populaties overtreft Dust backpropagation in meerdere scenario's, wat suggereert dat we in een compute-rich regime backpropagation kunnen passeren.
  • Dust is orders van grootte efficiënter dan weight-space ES. Vanaf 1 miljoen tokens is Dust, op basis van onze extrapolaties, $10^3$ tot $10^4$ keer efficiënter dan een transformer-implementatie van EGGROLL.
  • In tegenstelling tot de conventionele wijsheid zijn grotere modellen vaak populatie-efficiënter, niet minder. Dit geeft een nieuw perspectief op overparameterisatie als een grotere zoekruimte met potentieel betere geometrie.
  • De gradiënt-schattingen van Dust komen beter overeen met die van backpropagation naarmate de populatie groeit, en deze uitlijning houdt stand bij elke schaal die we testen, tot 1 miljard tokens.

Het doel van dit artikel is om de fundamenten te leggen voor een zoek-gebaseerd credit assignment-algoritme dat concurrerend is met backpropagation op de moeilijkste taak die we konden bedenken: het pretrainen van transformers. We proberen het op dit moment niet rekentechnisch efficiënt genoeg te maken om backpropagation direct te vervangen. Ook trainen we geen nieuwe soorten neurale netwerken die hiermee toegankelijk worden (zoals netwerken met een extern programma in de loop). Beiden zijn overgelaten aan toekomstig werk.

---

2. Methode

Dust werkt als volgt: we voegen Gaussische ruis toe aan de output van elke lineaire laag, onafhankelijk voor elk token, voeren een forward pass uit, en belonen de ruis van elk token op basis van de verandering in het verlies bij dat token. De belonings-gewogen ruis, gemiddeld over de trekkingen (draws), is de geschatte fout bij de output van de laag, en het buitenproduct hiervan met de input van de laag is de gewichtsgradiënt. Interne attention-mechanismen krijgen een variant hiervan: zij worden beloond via de geschatte fout bij de attention-output over huidige en toekomstige tokens, in plaats van direct via het verlies van de tokens.

De kernintuïtie is dat terwijl weight-space ES één populatielid per forward pass evalueert, wij er één per token evalueren, in parallel, en een lid wordt gematerialiseerd door ruis toe te voegen aan een hidden state, wat goedkoop is. Op een moderne transformer evalueert één enkele forward pass dus een populatie die minstens drie ordes van grootte groter is dan bij weight-space ES.

2.1 Activation-Space Perturbation

De bottleneck van evolutionaire strategieën is de populatiegrootte. Elk lid heeft zijn eigen geperturbeerde kopie van de gewichten en een eigen forward pass nodig. EGGROLL (Sarkar et al., 2025) maakt kopieën goedkoper met low-rank perturbaties, maar elk lid is nog steeds één sequentie-element van de batch, waardoor de populatie wordt begrensd door het aantal forward passes dat men kan betalen.

Wij perturberen activaties, onafhankelijk per token. Op dat token gedraagt het netwerk zich alsof er een low-rank perturbatie is toegepast op de gewichten van de laag die de activaties produceerde, zonder dat de perturbatie ooit in de gewichten zelf wordt gematerialiseerd. We noemen dit een virtuele populatie. Een sequentie in een transformer heeft enkele duizenden tokens, dus één forward pass evalueert enkele duizenden leden per sequentie in plaats van één. Elk gewicht in het model wordt op deze manier getraind, behalve de $2L$ residual mixing scalars, die worden getraind via gewone weight-space ES.

Het toevoegen van ruis aan activaties in plaats van gewichten staat bekend als node perturbation (Widrow and Lehr, 1990), en het gebruikelijke argument hiervoor is dimensionaliteit (Ren et al., 2023; Werfel et al., 2003). De output van een laag heeft $d{\mathrm{out}}$ entries en de gewichten hebben $d{\mathrm{out}} \times d{\mathrm{in}}$, dus activatieruis bevindt zich in een veel kleinere ruimte. Naïef gezien geldt het dimensionaliteitsargument niet voor transformers met grote activaties over veel tokens. De ruis op één sequentie is een $T \times d{\mathrm{out}}$ tensor, die minstens zoveel entries heeft als de gewichtsmatrix zodra $T \ge d_{\mathrm{in}}$. Echter, met per-token onafhankelijke perturbaties en beloningen, creëert het perturberen van activaties een nieuwe, efficiënte populatie langs de token-as die orthogonaal staat aan de batch-as waar EGGROLL op vertrouwt.

2.2 Credit Assignment

Voor een lineaire laag $yt = W xt$ voegen we jitter toe aan de output bij alle tokens, $yt \to yt + \sigma at$ met $at \sim \mathcal{N}(0, I)$ en $\sigma$ als ruisschaal, en voeren we de forward pass uit. Bij elk token $s$ berekenen we de gecentreerde verliesreductie $cs = \tilde{\ell}s - \ells$, waarbij $\ells$ het geperturbeerde verlies is en $\tilde{\ell}_s$ het gemiddelde geperturbeerde verlies bij dat token over de trekkingen die samen in dezelfde gebatchte forward pass zijn geëvalueerd. De beloning van de jitter bij token $t$ is de verliesreductie bij $t$ en, met een vervalfactor $\gamma$, de verliesreducties bij de tokens daarna, die de jitter ook bereikt via attention:

$$rt = \sum{s \ge t} \gamma^{\,s-t} c_s \quad (1)$$

Bij $\gamma = 0$ wordt een jitter alleen beloond door zijn eigen token. In Sectie 2.3 wordt besloten welke lagen toekomstige tokens zien. Eén onafhankelijke jitter van alle tokens is een draw, en een populatie bestaat uit $K$ draws. Gemiddeld over de draws is de belonings-gewogen ruis:

$$\hat gt = -\frac{1}{K\sigma}\sum{i=1}^{K} rt^{(i)} at^{(i)} \quad (2)$$

Dit is de geschatte fout bij de output van de laag, en het buitenproduct hiervan met de input van de laag (die de forward pass al heeft berekend), gesommeerd over de tokens, is de gewichtsgradiënt:

$$\widehat{G}W = \sumt \hat gt\, xt^\top \quad (3)$$

Backpropagation vormt hetzelfde buitenproduct met dezelfde input. Het enige verschil is dat backpropagation de outputfout krijgt via de ketenregel (chain rule) en wij deze krijgen via de populatie. Voor een embedding-laag is $xt$ one-hot, dus het buitenproduct is een scatter-add van $\hat gt$ in de rij van het token.

Bij een onbeperkte populatie is de bovenstaande schatting de volledige methode, en elke perturbatie zou in één forward pass kunnen passen. De belonings-gewogen ruis van elke draw is de gradiënt plus een fout zonder voorkeursrichting. Over draws tellen de gradiënten lineair op, terwijl de fouten optellen als de wortel, waardoor hun ratio afneemt naarmate de populatie groeit en de interferentie in de limiet verdwijnt.

2.3 Interferentie en Tuning

Bij een haalbare populatiegrootte is de belangrijkste kostenpost interferentie: we jitteren veel lagen bij veel tokens in dezelfde forward pass, waardoor de verandering in verlies die de ruis van één token beloont, ook het effect van elke andere perturbatie in die pass oppikt. We verminderen deze interferentie op drie manieren:

  1. Gescheiden passes per laagtype: Verschillende laagtypen worden gejitterd in aparte forward passes, elk met hun eigen ruisschaal, en elk blok krijgt zijn eigen passes. Deze passes zijn goedkoper dan volledige forwards omdat de "schone" forward is gecached en een draw voor blok $l$ alleen blokken $l$ en verder opnieuw uitvoert.
  2. Gescheiden attention-internals: De interne onderdelen van de attention (query, key, value, gate, value embedding) worden apart gejitterd. Token-verliezen registreren hun jitters nauwelijks, dus ze worden beloond via de attention-output, zoals hieronder beschreven.
  3. Directe jittering van de head: De language modeling head wordt direct op de gecachede logits gejitterd, waarbij alleen de cross-entropy wordt herberekend voor een deel van de vocabulaire per draw. Dit kost een fractie van een forward pass en stelt de head in staat een veel grotere populatie te gebruiken.

Voor de attention-internals berekenen we alleen de attention-output van hun blok opnieuw met de jitter, vanuit de gecachede schone activaties. We scoren de jitters met de uitlijning met de geschatte attention-output gradiënten:

$$cs = -\langle \hat gs, \Delta o_s \rangle \quad (4)$$

waarbij $\Delta os$ de verandering is die de jitter veroorzaakt in de attention-output bij token $s$, en $\hat gs$ de geschatte fout van die output is uit Vergelijking 2. De beloning volgt Vergelijking 1 met deze scores, berekend per head, in plaats van de verliesreducties.

De hyperparameters (ruisschaal per laagtype, credit-verval van attention-internals en het aandeel van de populatie per laag) kunnen op twee manieren worden getuned: via een grid search die traint op een klein tokenbudget, of via een grid search die de cosinus maximaliseert tussen onze schatting en de backprop-gradiënt op een enkele batch. De tuning is grotendeels een eenmalige kostenpost, aangezien de instellingen generaliseren over tokenbudgetten en populatiegroottes. Een uitzondering is dat bij de grootste populaties bij 10M en 20M tokens een trager credit-verval en een verschuiving van draws naar de attention-zijde voordelig zijn. Zoals verwacht hebben alle lagen geen credits nodig van toekomstige tokens, behalve de keys, values, gates en value embeddings, die worden gelezen door latere tokens die naar hen refereren en een $\gamma$ dicht bij één krijgen.

---

3. Pretraining zonder Backward Pass

3.1 Setup

We trainen GPT-stijl transformers op FineWeb met een 4096-token BPE tokenizer, een batch van 16k tokens (8 sequenties van 2048 tokens), één epoch, en SGD met momentum bij een constante leercurve. Het basismodel heeft 8 lagen en een breedte van 512. Elke methode krijgt hetzelfde protocol en drie seeds per cel, en wordt apart getuned per tokenbudget en populatie. Dust en backprop delen één momentum- en leercurve-grid; we implementeren EGGROLL met dezelfde transformer-architectuur (genoemd EGGROLL-Transformer).

We tellen de populatie in draws voor Dust en in forward passes van de batch voor EGGROLL. Een draw is één jitter van activaties over alle tokens van geselecteerde lagen. Een draw is iets goedkoper dan een forward pass omdat de schone forward is gecached.

3.2 Belangrijkste Resultaten

Uit experimenten met een tokenbudget van 100k tot 20M en populaties van 64 tot 16k blijkt dat Dust bij 100k en 1M tokens onder de testloss van backpropagation eindigt, respectievelijk vanaf enkele honderden draws en vanaf duizend draws. Bij 10M en 20M tokens krimpt het gat met backpropagation naarmate de populatie groeit. Bij 20M tokens daalt de curve nog steeds bij 16k draws, en een power law fit plaatst de limiet op 4.431, wat onder de 4.633 van backpropagation ligt.

Weight-space ES is veel minder efficiënt. Zelfs met een 256 keer grotere populatie bereikt EGGROLL bij 16k draws Dust bij 64 draws niet. EGGROLL blijft 0.4 tot 0.6 boven Dust bij 1M, 10M en 20M tokens. Extrapolaties suggereren dat EGGROLL een $10^4$ keer grotere populatie nodig heeft om Dust's kleinste populatie te matchen.

3.3 Dust onder Adam

We hebben de 1M token test herhaald met Adam. Terwijl EGGROLL nauwelijks profiteert van Adam, verbeteren zowel Dust als backpropagation aanzienlijk. Dust nadert backpropagation bij een grote populatie, en het interval van zijn limiet ligt zelfs onder dat van backpropagation. Dit toont aan dat de schattingen van Dust werken met moderne optimizers, ondanks dat deze oorspronkelijk voor backprop-gradiënten zijn geoptimaliseerd.

---

4. Zoeken in Hoogdimensionale Ruimte

4.1 Overparameterisatie

De conventionele visie is dat nulde-orde methoden geen grote netwerken kunnen trainen, omdat de variantie van de gradiëntschatting groeit met het aantal geperturbeerde dimensies. We hebben dit getest met vier modelgroottes: 2M, 7M, 38M en 243M parameters bij een vast budget van 10M tokens.

Hieruit volgen twee opvallende observaties:

  1. Grotere modellen zijn vaak populatie-efficiënter, niet minder. Bij elke populatie vanaf 256 daalt het verlies van 2M naar 7M naar 38M parameters, en het model van 243M is slechts marginaal slechter. Een model dat $120\times$ groter is, presteert ongeveer hetzelfde als het kleinste model bij de kleinste populatie, en beter bij alle andere populaties.
  2. Grotere modellen blijven verbeteren met de populatie, waar kleine modellen stagneren. Kleine modellen verzadigen sneller, terwijl grote modellen blijven winnen bij grote populaties.

De juiste manier om naar modelgrootte te kijken is dus als de grootte en geometrie van de zoekruimte. Een groter model heeft een grotere ruimte om in te zoeken, wat het in staat stelt een grote populatie effectief te gebruiken, en potentieel een beter geconditioneerd verlieslandschap.

4.2 Emergentie van Backprop-achtige Gradiënten

We hebben de cosinus gemeten tussen de schatting van Dust en de backprop-gradiënt op dezelfde batch, voor checkpoints van 10M tot 1B tokens. De cosinus stijgt met de populatie voor elk laagtype. Een twee-parameter wet $\cos(K) = \frac{c_{\max}}{\sqrt{1 + c/K}}$ past goed bij elke laag.

Nuttige gradiënten ontstaan puur door de grote populatie, zonder dat de ketenregel is ingebouwd. Voor het checkpoint van 100M tokens zijn de RMSE's van de fits zeer laag (0.0032–0.0367). Ter vergelijking: de schattingen van EGGROLL blijven bij 128k draws onder een cosinus van 0.05 voor bijna alle laagtypen.

Belangrijk is dat de cosinussen stabiel blijven terwijl het aantal tokens groeit. Dit betekent dat bij een voldoende grote populatie de vereiste populatiegrootte mogelijk niet langer hoeft mee te groeien met het aantal tokens. Bovendien is het feit dat Dust's gradiënten backprop benaderen maar er niet exact mee samenvallen een goede eigenschap; dit leidt tot een ander optimalisatietraject dat in onze experimenten zelfs beter kan zijn dan dat van backpropagation.

---

5. Conclusie

Sinds Rumelhart et al. (1986) is backpropagation het dominante algoritme voor het trainen van neurale netwerken. Naarmate rekenkracht overvloediger wordt, geloven we dat betere alternatieven mogelijk zijn. We hebben Dust geïntroduceerd, een algoritme dat bestaande ES-algoritmen drastisch verbetert en backpropagation nauw benadert bij het pretrainen van transformers, en deze zelfs overtreft bij grote hoeveelheden berekeningen.

Er blijven interessante open vragen:

  • Kan Dust betere richtingen vinden dan de eerstegraads gradiënt van backpropagation door impliciet het verlieslandschap te verkennen en hogere-orde kromming op te pikken?
  • Omdat Dust geen end-to-end differentieerbaarheid vereist, opent het de zoekruimte voor nieuwe architecturen (zoals recurrente of geloopte berekeningen) waar backpropagation moeite mee heeft.
  • De reken-efficiëntie moet met ordes van grootte verbeteren voordat Dust een praktisch alternatief wordt voor backpropagation bij huidige computerniveaus.

---

6. Gerelateerd Werk

Vroeg werk aan nulde-orde pretraining van taalmodellen (Allaire et al., 2025) onderzocht de moeilijkheid van het trainen van transformers met gewichtsperturbaties. Hun latere methode, KronZO (Allaire et al., 2026), gebruikt compacte perturbaties met Kronecker-structuur. EGGROLL (Sarkar et al., 2025) maakt grote populaties van gewichtsperturbaties efficiënt via low-rank structuren. Dust zoekt daarentegen in de activaties en gebruikt beloningen per token om meer informatie uit elke forward pass te halen.

Voor fine-tuning heeft MeZO (Malladi et al., 2023) aangetoond dat taalmodellen kunnen worden aangepast met alleen forward passes. Evolution Strategies at Scale (Qiu et al., 2026) demonstreert fine-tuning van alle parameters met ES in modellen met miljarden parameters. Neural Thickets (Gan and Isola, 2026) vindt taalspecialisten door gepretrainde gewichten willekeurig te perturberen. Onze experimenten richten zich echter op het leren van de representaties zelf via pretraining vanaf nul.

Onze activatieperturbaties bouwen voort op node perturbation (Werfel et al., 2003). GEMINI (Le Cun et al., 1988) injecteerde ruis in de eerste hidden layer en herstelde gradiëntschattingen via matrixinversie. Zoop (Hu et al., 2025) gebruikt outputperturbaties voor fine-tuning. Scaling Forward Gradient with Local Losses (Ren et al., 2023) combineert activatieperturbaties en lokale verliezen.

Een andere lijn van onderzoek vervangt de globale backward pass door lokale leer-dynamiek, zoals Sakana AI's PC-ALM (Seely and Gould, 2026), die gebruikmaakt van predictive coding en Lagrange-multiplicatoren. Dust schat krediet via forward perturbaties tijdens transformer pretraining, waarbij beloningen per token worden gecombineerd met lokale doelen voor attention-outputs.