Technische Samenvatting: DeltaLog

Probleem: De State-Update Belasting bij Lineaire Aandacht Decoding

Lineaire aandachtmodellen (bijv. GDN, KDA, RWKV6) bieden een overtuigend alternatief voor softmax-aandacht door de kwadratische prefix-berekening en de met de context groeiende Key-Value (KV) cache te vervangen door fixed-size recurrente state-updates. In deze modellen is de state $S_t$ een dichte matrix van omvang $d_k \times d_v$, onafhankelijk van de sequentielengte.

Echter, bestaande decoding-implementaties lijden aan een significante inefficiëntie die de state-update belasting wordt genoemd. Hoewel de logische update bij een enkel token compact is (vertegenwoordigd door vectoren van omvang $O(d_k + d_v)$), materialiseren standaard "eager" implementaties deze update onmiddellijk in de volledige dichte state en schrijven ze de volledige $[B, H, d_k, d_v]$ tensor terug naar High-Bandwidth Memory (HBM) na elke gegenereerde token.

• Mismatch in Geheugentrafiek: Voor een batchgrootte $B$ en $H$ koppen is de werkelijke toegevoegde informatie $O(BH(d_k + d_v))$, maar het fysieke verkeer betreft het lezen en schrijven van $O(BH d_k d_v)$ elementen.
• Geheugen-gebonden Bottleneck: Deze "eager" materialisatie creëert een aritmetische intensiteit van ongeveer 0,5–1,0 FLOPs/byte, wat ver onder de machine-balans van moderne GPU's ligt (bijv. ~208 FLOPs/byte voor een H200). Bij consequent gevolg wordt het onderhoud van de recurrente state een primaire bron van geheugentrafiek, wat de decode-latentie domineert, vooral naarmate de batchgroottes en state-omvang toenemen. Metingen tonen aan dat dit tot 44,6% van de decode-latentie kan consumeren in scenario's met grote batches.

Methodologie: Uitgestelde Materialisatie via DeltaLog

Het artikel stelt DeltaLog voor, een decoding-schema dat de logische recursie ontkoppelt van de fysieke materialisatie van de state. DeltaLog verandert de modelgewichten of de wiskundige recursie niet; het verandert enkel het fysieke schema van de state-updates.

Kernmechanisme: Base + Log

DeltaLog representeert de actieve recurrente state als twee componenten:

1. Dense Base State ($\bar{S}$): Een dichte matrix die de geaccumuleerde historie opslaat tot het laatste "merge"-punt.
2. Bounded Update Log: Een buffer die recente, compacte update-factoren ($a_t, b_t$) en hun bijbehorende log-decay metadata ($\Lambda$) opslaat.

De decoding-cyclus werkt in twee fasen:

• Append Fase (Common Case): Voor $M-1$ stappen schrijft het systeem de volledige dichte state niet terug. In plaats daarvan voegt het de compacte update-factoren en de huidige log-decay snapshot toe aan de log-buffer. De dichte base $\bar{S}$ blijft ongewijzigd.
• Merge Fase (Periodiek): Elke $M$ stappen materialiseert het systeem de geaccumuleerde logische state (base + gereplayde log-entries) terug in de dichte base $\bar{S}$, reset de log en wist de uitgestelde updates.

Trafiekmodel

Door de dichte write-back uit te stellen, vervangt DeltaLog frequente volledige state-writes door:

• Lichtgewicht appends van compacte factoren ($O(d_k + d_v)$).
• Geamortiseerde dichte writes die slechts één keer per $M$ stappen voorkomen.
• Het replayen van log-entries tijdens de merge-stap.

Het optimale merge-interval $M$ balanceert de kosten van verhoogde replay-trafiek tegen de besparingen door verminderde dichte writes.

Kernel Implementatie

Om dit efficiënt op GPU's te implementeren, maakt de auteur gebruik van een tiled kernel decompositie:

• Value-Tile Parallelisme: De state wordt gepartitioneerd langs de value-dimensie ($d_v$). Elke werkunit handelt een slice van de dichte base af en de bijbehorende shard van de value-zijde log.
• Shared Metadata: Key-zijde factoren en log-decay metadata worden gedeeld over value-tiles om redundante berekeningen te voorkomen.
• Gefaseerde Executie: De kernel is gesplitst in een gedeelde "ReplayPrep" fase (het berekenen van coëfficiënten één keer per slot-head) en parallelle "AppendDecode" fasen voor value-tiles.

De methode wordt geïnstantieerd voor drie operatoren met verschillende decay-granulariteiten en update-semantics:

• GDN (Gated DeltaNet): Head-wise scalaire decay; gebruikt Delta-regel correctie.
• KDA (Kimi Delta Attention): Per-key decay; gebruikt Delta-regel correctie.
• RWKV6: Per-key decay; gebruikt raw-value updates (geen Delta-regel correctie).

Belangrijkste Bijdragen

1. Identificatie van de State-Update Belasting: Het artikel karakteriseert de per-token overhead veroorzaakt door "eager" dichte materialisatie in grote-batch lineaire aandacht-serving, en identificeert dit als een geheugenbandbreedte-bottleneck die onderscheidend is van de logische recursie-kosten.
2. DeltaLog Executie Strategie: Een strategie voor uitgestelde materialisatie die de state representeert als een dichte base aangevuld met een begrensde log van compacte updates, waardoor de meeste stappen lichtgewicht appends kunnen uitvoeren in plaats van volledige dichte rewrites.
3. Systeem Implementatie en Evaluatie: Een volledige implementatie voor GDN, KDA en RWKV6, geïntegreerd in een vLLM-gebaseerde serving stack, die aantoont dat de optimalisatie exacte rekenkundige equivalentie behoudt (binnen floating-point tolerantie) terwijl de prestaties verbeteren.

Resultaten

Experimenten werden uitgevoerd op NVIDIA H200 en RTX 4090 GPU's over diverse batchgroottes en contextlengtes.

• Kernel-niveau Prestaties:
  • DeltaLog versnelt de recurrente-state update kernel met 1,19× tot 1,86× vergeleken met de hoog-geoptimaliseerde Fast Linear Attention (FLA) baseline.
  • Het vermindert de geprofileerde recurrente-state write-verkeer met tot wel 7,83×.
  • GDN profiteert het meest vanwege de compacte scalaire decay metadata, terwijl RWKV6 en KDA significante winsten laten zien ondanks zwaardere per-key metadata.
• End-to-End Serving Prestaties:
  • Geïntegreerd in een prototype serving stack, bereikt DeltaLog 1,05× tot 1,20× end-to-end versnellingen ten opzichte van dichte recurrente baselines op modellen zoals Qwen3.6-35B en Kimi-Linear-48B.
  • De winsten zijn kleiner dan de verbeteringen op kernel-niveau vanwege de wet van Amdahl, aangezien de recurrente update slechts één component is van de volledige decode-stap (die ook MLP, normalisatie en scheduling bevat).
• Numerieke Correctheid:
  • De methode behoudt numerieke equivalentie met eager decoding, waarbij de maximale relatieve fouten van de output ruim binnen de standaard repository-toleranties liggen (bijv. < 0,005 voor alle geteste operatoren).

Betekenis

Het artikel betoogt dat recurrente-state materialisatie een kritieke, vaak over het hoofd geziene bottleneck is bij lineaire aandacht decoding, met name bij serving met grote batches. Door de fysieke planning van state-updates te optimaliseren in plaats van de algoritmische recursie zelf, demonstreert DeltaLog dat significante efficiëntiewinsten kunnen worden behaald zonder modelarchitecturen te wijzigen.

Het werk benadrukt dat hoewel lineaire aandacht de context-lengte afhankelijkheid van KV-caches wegneemt, het een nieuwe vaste-state onderhoudskost introduceert die sterk geheugen-gebonden is. DeltaLog biedt een praktische oplossing voor deze "state-update belasting", en laat zien dat het uitstellen van dichte writes een levensvatbare strategie is om de inference throughput voor recurrente lineaire aandachtmodellen te verbeteren. De auteurs merken op dat de voordelen het meest prominent zijn in regimes waar de recurrente-state write-back een dominant deel van de geheugentrafiek vormt (grote batches, grote state-omvang).