🤖 machine learning

LongStraw: Long-Context RL Beyond 2M Tokens under a Fixed GPU Budget

LongStraw is een architectuurbewuste executiestack die reinforcement learning met miljoenen tokens tijdens post-training mogelijk maakt onder een vast GPU-budget door het geheugengebruik te optimaliseren via gedeelde prompt-evaluatie zonder autograd en sequentiële respons-replay, waarbij succesvol de executiecapaciteit is aangetoond op modellen zoals Qwen3.6-27B en GLM-5.2 met contextlengtes die de 2 miljoen tokens overschrijden.

Oorspronkelijke auteurs: Changhai Zhou, Kieran Liu, Yuhua Zhou, Qian Qiao, Jun Gao, Harry Zhang, Irvine Lu, Nolan Ho, Lucian Li, Andrew Lei, Cleon Cheng, Steven Chiang, Yihang Zeng, Di Zhang, Rio Yang, Kaijie Chen, Andrew Che

Gepubliceerd 2026-07-17

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Changhai Zhou, Kieran Liu, Yuhua Zhou, Qian Qiao, Jun Gao, Harry Zhang, Irvine Lu, Nolan Ho, Lucian Li, Andrew Lei, Cleon Cheng, Steven Chiang, Yihang Zeng, Di Zhang, Rio Yang, Kaijie Chen, Andrew Chen, Pony Ma, Weizhong Zhang, Cheng Jin

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 een superintelligente robot probeert te leren hoe hij een enorme, meerstaps-mysterie moet oplossen. Om dit te doen, moet de robot een bibliotheek aan aanwijzingen (de "context") lezen voordat hij zelfs maar kan beginnen met het raden van de oplossing. In de wereld van Kunstmatige Intelligentie wordt dit "long-context training" genoemd. Meestal, wanneer we deze robots trainen, voeren we ze een enorm boek vol aanwijzingen en vragen we ze vervolgens om een kort antwoord te schrijven. Het probleem is dat de hersenen van de robot (het computergeheugen) zo vol raakt met de details van het boek, dat hij geen ruimte meer overhoudt om zijn antwoord af te maken. Het is alsof je een mysterie probeert op te lossen terwijl je de hele bibliotheek in je handen houdt; uiteindelijk worden je armen te moe om te bewegen.

Om dit op te lossen, hebben wetenschappers steeds grotere bibliotheken van computerchips (GPU's) gebouwd om alle informatie vast te houden. Maar wat als je geen supercomputer hebt? Wat als je slechts een klein, vast aantal chips hebt, zoals een standaardset van acht of tweeëndertig? Dit is de puzzel die het paper "LongStraw" aanpakt. Het vraagt: Kunnen we een robot leren om een verhaal van twee miljoen woorden te lezen en een oplossing te schrijven met slechts een kleine, vaste set computerchips, zonder meer te kopen? Het antwoord is niet "ja, we hebben de chips groter gemaakt," maar eerder "ja, we hebben veranderd hoe we het boek vasthouden."

De onderzoekers bouwden een slim systeem genaamd LongStraw. Denk aan een bibliothecaris die ongelooflijk georganiseerd is. In plaats van te proberen het hele twee-miljoen-woorden dure verhaal open op het bureau te houden terwijl de robot zijn antwoord schrijft (wat het bureau zou laten instorten), leest de bibliothecaris het hele verhaal één keer, onthoudt de essentiële "vibe" of "staat" van het verhaal, en legt dan het zware boek weg. Nu hoeft de robot alleen nog maar zijn korte antwoord te schrijven terwijl hij kijkt naar dat kleine "vibe"-briefje. Als de robot een specifiek detail moet controleren, haalt de bibliothecaris snel die ene specifieke pagina erbij, laat de robot ernaar kijken, en legt hem vervolgens onmiddellijk weer terug. Op deze manier raakt het bureau nooit overvol, ook al is het verhaal enorm.

Het paper test dit idee op twee verschillende soorten robotbreinen: één genaamd Qwen en een andere genaamd GLM. Ze probeerden deze robots een prompt (het verhaal) te laten lezen die 2.097.152 tokens lang was (wat ongeveer twee miljoen woorden of tekens is) en vervolgens een reactie te laten schrijven. Ze deden dit met een strikt budget: acht H20 GPU's voor de Qwen-robot en 32 H20 GPU's voor de GLM-robot.

Dit is wat ze vonden:

Het werkt voor het "lezen"-gedeelte: Ze slaagden erin om het volledige twee-miljoen-tokens dure verhaal te verwerken zonder dat het computergeheugen crashte. Ze bewezen dat je deze enorme taak op een vast aantal chips kunt passen door slim te zijn over wanneer je informatie vasthoudt en wanneer je het loslaat.
Het bespaart ruimte, maar kost tijd: Door het zware boek weg te leggen en alleen pagina's erbij te pakken wanneer dat nodig is, bespaarden ze een enorme hoeveelheid geheugen. Bijvoorbeeld, toen ze het aantal robot-"gissingen" (de groepsgrootte) verhoogden van 2 naar 8, veranderde het geheugengebruik nauwelijks (slechts ongeveer 0,21 GB meer), maar het duurde langer om de klus te klaren omdat ze de pagina's één voor één erbij moesten pakken in plaats van allemaal tegelijk.
Het is een "proof of concept", geen perfecte finish: Het paper is zeer eerlijk over wat het niet heeft gedaan. Hoewel het systeem de simulatie succesvol heeft uitgevoerd en aangetoond heeft dat de robot het lange verhaal kon lezen en het antwoord kon schrijven, heeft het niet volledig bewezen dat de robot de perfecte manier heeft geleerd om zijn brein bij te werken. Sommige van de wiskunde die de verschillende "hersendelen" (gradiënten) van de robot verbindt, was niet volledig gesynchroniseerd over alle chips op de manier die een perfecte trainingssessie zou vereisen. Het is alsof je laat zien dat een automotor kan draaien op een heel kleine hoeveelheid brandstof, maar nog niet hebt bewezen dat hij een hele racebaan kan rijden zonder stil te vallen.

De onderzoekers noemen hun resultaat een "execution receipt" (uitvoeringsbewijs). Het is een bonnetje dat zegt: "Ja, we hebben deze enorme taak succesvol uitgevoerd op deze specifieke hardware zonder te crashen." Ze beweerden niet een race te hebben gewonnen of de snelste auto te hebben gebouwd; ze beweerden alleen dat de auto kan rijden op dit specifieke circuit met deze specifieke hoeveelheid benzine.

Kortom, LongStraw laat zien dat je geen supercomputer nodig hebt om AI op enorme verhalen te trainen. Je hebt alleen een slimmere manier nodig om je geheugen te beheren, waarbij je een beetje extra tijd inruilt voor veel bespaarde ruimte. Het opent de deur voor kleinere teams en onderzoekers met beperkte budgetten om te experimenteren met deze gigantische AI-modellen, door te bewijzen dat je grote dingen kunt doen met een vaste, kleine toolkit als je slim genoeg bent.

Technische Samenvatting: LongStraw: Long-Context RL voorbij 2M Tokens onder een Vast GPU-budget

1. Probleemstelling

Er is een aanzienlijke kloof ontstaan tussen de contextlengtes die ondersteund worden door inferentiesystemen (die de miljoenen-token contexten naderen) en die worden gebruikt tijdens Reinforcement Learning (RL) post-training, welke vaak beperkt blijven tot 256K tokens of lager. Deze kloof is bijzonder kritiek voor AI-agenten waarvan de trajecten observaties, tool-outputs en eerdere beslissingen accumuleren over lange sequenties.

De kernuitdaging bij het uitbreiden van RL post-training (specifiek Group Relative Policy Optimization, of GRPO) naar miljoenen-token contexten onder een vast GPU-budget is geheugen. In tegenstelling tot inferentie, waarbij de forward graph kan worden weggegooid na het cachen van de staat, moet training meerdere responsen scoren en hierdoorheen backpropageren. Bestaande technieken vereisen dat de volledige prompt en alle respons-graphs simultaan in het geheugen worden behouden, wat leidt tot kwadratische aandacht-berekening (attention computation) en massale activatie-opslag. Bestaande technieken zoals FlashAttention, LoRA of Ring Attention adresseren specifieke bottlenecks, maar maken het niet inherent mogelijk voor een fixed-GPU GRPO-run om een 2M+ token context te huisvesten zonder op te schalen naar grotere clusters.

2. Methodologie: LongStraw Execution Stack

LongStraw is een architectuurbewuste execution stack ontworpen om de lange prompt te ontkoppelen van de korte respons-berekening, waarbij extra replay-tijd wordt geruild voor een verminderd GPU-geheugengebruik. Het kernontwerpprincipe is om een tensor over de prompt-grens alleen te behouden wanneer een latere respons-token er ook echt van afhankelijk is.

2.1 Het Execution Schema

Het systeem werkt in vier afzonderlijke fasen voor een gegroepeerde update:

Prompt Capture (No-Grad): De gedeelde prompt ( $P$ tokens) wordt één keer geëvalueerd met automatische differentiatie uitgeschakeld. Het systeem slaat alleen de architectuur-specifieke conditionele staat op die vereist is voor toekomstige tokens (bijv. recurrente staten, KV-pages, latente representaties) en geeft alle transiënte activaties vrij (FFN-intermediaire waarden, attention scratch, MoE routing buffers).
Pre-Step Scoring: De log-waarschijnlijkheden van de oude policy en de reference-policy worden geëvalueerd voor alle groepsleden met behulp van de bevroren prompt-staat.
Serial Response Replay: In plaats van $G$ respons-graphs simultaan te onderhouden, speelt het systeem één respons-tak tegelijk opnieuw af onder autograd. Het hergebruikt de read-only gevangen prompt-staat, berekent de loss, voert backpropagation uit en bevrijdt onmiddellijk de respons-graph.
Gradient Accumulation & Optimization: Lokale gradiënten van alle $G$ leden worden geaccumuleerd, gevolgd door een enkele optimizer-call per worker.

2.2 Architectuur-specifieke Implementaties

LongStraw past deze strategie aan voor twee verschillende modelfamilies:

Qwen3.6-27B (Hybride Recurrent/Full-Attention):
- State Retention: Houdt compacte Gated DeltaNet (GDN) recurrente staten en context-parallel (CP) gescheiden Key/Value (KV) pages voor de 16 full-attention lagen op de GPU.
- Mechanisme: Gebruikt NF4 QLoRA. De 48 GDN-lagen bieden een vaste grootte aan staat, terwijl de 16 full-attention lagen gebruikmaken van fysieke page-compactie. Het systeem voert een globale LSE/output merge uit voor de forward pass, maar erkent het ontbreken van K/V adapter gradiënt-synchronisatie.
- Hardware: Uitgevoerd op 8 H20 GPU's (CP8).
GLM-5.2 (Compressed Attention/MoE):
- State Retention: Verplaatst de lange prompt-staat (MLA latente pages en DSA indexer-key pages) naar het CPU-geheugen. Slechts één decoder-laag wordt tijdens de respons-replay naar de GPU gestreamd.
- Mechanisme: Gebruikt een "Zigzag" context-page layout over 32 ranks (CP32) en Expert Parallelism (EP32). Het maakt gebruik van whole-layer activation checkpointing om de respons-graph te begrenzen. Het systeem reconstrueert IndexShare-schema's laag voor laag.
- Hardware: Uitgevoerd op 32 H20 GPU's (TP1/CP32/EP32).

3. Belangrijkste Bijdragen

Shared-Prompt Execution Design: Een nieuw schema dat de prompt-staat één keer opslaat (losgekoppeld van autograd) en de respons-werkzaamheden serieel uitvoert, waardoor de actieve training-graph wordt gereduceerd van $P + \sum R_i$ naar $\max(R_i)$ .
Dual-Architecture Implementatie: Succesvolle instantiatie van dit ontwerp voor twee structureel verschillende modellen: een dichte hybride recurrente/attention stack (Qwen) en een gecomprimeerde attention MoE stack (GLM).
Fixed-Budget Execution Receipts: Empirisch bewijs dat GRPO execution-paden kunnen worden voltooid voor prompts die de 2M tokens overschrijden (en tot 4.25M voor Qwen) zonder het aantal GPU's te verhogen, terwijl beperkingen in gedistribueerde gradiënt-compositie expliciet worden gedocumenteerd.

4. Experimentele Resultaten

4.1 Qwen3.6-27B (8 H20s)

Contextlengte: Succesvol een context van 2.097.152 tokens uitgevoerd (2.088.960 prompt + 8.192 respons).
Geheugenefficiëntie: Het verhogen van de groepsgrootte van $G=2$ naar $G=8$ verhoogde het piek gealloceerde geheugen met slechts 0,21 GB (0,213%), wat bevestigt dat het geheugen schaalt met de grootste respons-tak, niet met de groepsgrootte.
Verlengde Capaciteit: Een stress-test bereikte 4,25M posities (4.448.256 prompt + 8.192 respons) op dezelfde 8 H20's, met een piek van ~83 GB per rank.
Beperking: De gedistribueerde update is niet volledig coherent; K/V adapter gradiënten worden niet gesynchroniseerd over de ranks, en de prompt-staat gradiënt is losgekoppeld (detached).

4.2 GLM-5.2 (32 H20s)

Contextlengte: Valideerde het end-to-end execution pad voor een 2.097.152-token prompt over alle 78 lagen.
Geheugenstrategie: De CPU-resident prompt-staat (ongeveer 5,8 GiB per rank) zorgde ervoor dat de GPU binnen het budget bleef tijdens de 78-laags backward pass.
Beperking: De DSA (Dynamic Sparse Attention) operator in het geaccepteerde receipt is lokaal aan elke CP-shard (selecteert top-2048 uit 65k tokens in plaats van de globale 2M context). Daarnaast omzeilt het pad finalize_model_grads van Megatron, waardoor CP-gerepliceerde non-expert adapter gradiënten niet worden gereduceerd vóór de optimizer-stap.

5. Betekenis en Claims

Het artikel positioneert LongStraw niet als een "wereldrecord" voor contextlengte, maar als een fixed-budget feasibility envelope (haalbaarheidsomgeving binnen een vast budget).

State Lifetime vs. Sparsity: De auteurs stellen dat de fixed-budget capaciteit wordt bepaald door de levensduur van tensoren en fysiek eigendom, en niet louter door sparsity (MoE) of geheugenefficiënte attention kernels. Door de prompt-intermediaire waarden direct na capture te laten "sterven", voorkomt het systeem de geheugenexplosie van een volledige sequentie autograd.
Fysiek Eigendom: Het werk benadrukt dat logische sharding onvoldoende is; fysieke geheugenallocatie moet overeenkomen met de sharding-strategie (bijv. het kopiëren van pages naar de juiste grootte van tensoren) om het geheugen effectief vrij te geven.
Bescheiden Claims: De auteurs stellen expliciet dat dit execution receipts zijn, geen bewijzen van trainingscorrectheid. De prompt-staat is losgekoppeld (de $\partial z_P / \partial \theta$ term ontbreekt), en de gedistribueerde gradiënt-compositie is incompleet voor beide modellen. De resultaten vestigen dat het execution pad binnen de hardwarebeperkingen past, wat onderzoekers in staat stelt om long-context RL te verkennen zonder enorme opschaling van de cluster, maar ze beweren nog niet de gedistribueerde gradiënt-pariteit of policy-verbetering aspecten te hebben opgelost.

Samenvattend demonstreert LongStraw dat met zorgvuldig beheer van de levensduur van de staat en fysiek eigendom, miljoenen-token RL post-training haalbaar is op relatief kleine, vaste GPU-clusters. Hiermee verschuift de bottleneck van ruwe geheugencapaciteit naar scheduling en state management.