Sparse Delta Memory: Scaling the State of Linear RNNs through Sparsity
Abstract: Linear attention models allow a fixed state size and a fixed amount of compute per token. However, due to their limited state size, linear attention models fall behind in long-context recall compared to softmax-attention-based transformer architectures. Increasing the state size of linear attention improves recall performance but at the cost of higher FLOPs. In this work, we introduce Sparse Delta Memory (SDM), an architecture that scales the hidden state of gated linear RNNs to orders of magnitude higher capacity using a sparse addressing scheme. SDM extends the Gated DeltaNet architecture by replacing the dense key-value outer product with sparse reads and writes to a large explicit memory. We show that, under an isoFLOP constraint and with an identical number of parameters, a higher state memory capacity significantly improves performance on in-context learning and long-context retrieval tasks. Moreover, by learning the initial state of the SDM memory and therefore using it as a parametric memory, we show that the model further improves on a wide range of common-knowledge and reasoning tasks.
Paper Prompts
Sign up for free to create and run prompts on this paper using GPT-5.
Top Community Prompts
Explain it Like I'm 14
Overview
This paper is about helping AI models remember and use information from very long pieces of text (like entire books or big codebases) without slowing down or running out of memory. The authors introduce a new way to give certain models a much bigger “memory” while keeping the amount of work they do per word the same. They call it Sparse Delta Memory (SDM).
What questions were they asking?
- Can we make models that process text one token at a time (like certain RNNs) remember much more, so they can handle very long contexts?
- Can we do that without increasing the compute (work) needed for each token, and without adding extra parameters compared to strong baselines?
- Will a bigger memory improve tasks like recalling facts from far back in the text and learning patterns on the fly (“in-context learning”)?
- Does giving the model a learnable “starting memory” help it store useful knowledge from training?
How did they do it?
To make this accessible, here are the key ideas using simple analogies.
Transformers vs. RNNs: the memory problem
- Transformers keep a running “notebook” of every past token (called a KV cache). It’s great for remembering, but the notebook grows linearly with text length, so it gets slow and expensive for very long inputs.
- RNNs keep a fixed-size “summary card” instead. That’s fast and memory-efficient, but the card is small, so they forget details over long stretches.
The question: Can we give RNN-like models a much bigger “summary” without making each step more expensive?
The idea of Sparse Delta Memory (SDM)
- Think of SDM as a very large storage room with many lockers (memory slots).
- At each step (each token), instead of opening and updating every locker (which would be slow), SDM:
- Picks only a few lockers to read.
- Picks only a few lockers to write to.
- Leaves all other lockers untouched that step.
- “Sparse” means it touches only a small number of lockers per step, even though there are many lockers in total. That keeps the per-token cost low.
How does SDM pick which lockers?
- SDM uses a clever addressing trick called Product-Key Memory (PKM).
- Imagine the lockers are arranged in a big grid. The model scores rows and columns separately, then combines those scores to quickly find the best few lockers (top-k) to read or write—without checking every single locker.
- This lets SDM scale up to millions of lockers but only access, say, 64 of them at a time.
What gets written and why “delta”?
- When SDM writes to a locker, it first asks: “What’s already there?” It reads the old content and only writes the difference (the delta) needed to make the content more accurate. This prevents the memory from getting messy and keeps it stable.
- It also uses a “forget gate” (like a dimmer) that slowly fades old information unless it’s refreshed. This controls how long memories last.
Keeping the compute the same (isoFLOP)
- FLOPs are a way to measure how much work the model does per token.
- The authors made sure SDM uses about the same FLOPs and the same number of parameters as a strong baseline model (Gated DeltaNet, or GDN).
- The key is that SDM’s per-token work depends on how many lockers it reads/writes (a small constant), not on how many lockers exist in total. So they can make the memory huge without increasing per-token cost.
A learned “starting memory”
- SDM can start with a learned initial memory (like pre-filled lockers) that stores useful knowledge from training.
- This doesn’t cost extra compute during use, but can boost performance because the model begins with some “built-in” know-how.
What did they find?
Here are the main results, in plain terms:
- Bigger memory, same cost per token: SDM gives RNN-like models a memory that is thousands of times larger while keeping per-token compute essentially the same as GDN.
- Better at long-context recall: On benchmarks that test remembering information across very long texts (like RULER), SDM beats GDN by a wide margin at both medium (~1.4B) and large (~8B) model sizes. It sometimes matches or even exceeds full attention on certain tasks, despite using fixed memory.
- Better (or competitive) on normal tasks too: On typical reasoning and knowledge tests (short-context), SDM performs better than GDN and is competitive with, sometimes better than, full attention baselines at larger scale.
- Lower perplexity on code at long lengths: For coding data, SDM’s predictions improve as the context gets longer (up to 1 million tokens), more than GDN or Mamba2.
- Learned starting memory helps: Letting SDM learn its initial memory improves results further, especially on general knowledge and reasoning. But even without that, SDM’s larger memory capacity is the main driver of long-context gains.
- Scales predictably: As they trained bigger models with more compute, SDM’s loss decreased in a smooth, predictable way and consistently stayed ahead of GDN under the same compute budget.
Why this matters: It shows you can have the “best of both worlds”—RNN-like constant-speed processing with a large, effective memory similar to what makes transformers strong on long inputs.
What could this change?
- Longer, smarter agents: SDM could power AI assistants that hold coherent, detailed memories over very long sessions, helping with tasks like coding in large projects, doing research over long documents, or assisting over extended conversations.
- Better long-video or robotics memory: The same idea can help models remember long sequences in other areas, like video or sensor streams in robotics.
- More efficient long-context systems: Because per-token compute stays constant, SDM could make long-context applications more practical and affordable.
A note on limitations
- Today, SDM’s specialized GPU kernels are less optimized than dense baselines, so training can be slower in wall-clock time even if the FLOPs match. The authors expect engineering improvements will reduce this gap.
- Full attention still has advantages on some tasks, especially those that benefit from seeing and comparing all prior tokens directly.
In short
Sparse Delta Memory turns a small, fixed RNN state into a huge, efficient, and carefully accessed memory. By reading and writing only a few slots each step—but having many slots available—SDM remembers much more without doing more work per token. This leads to better long-context recall and strong overall performance, pointing to more capable long-term AI systems.
Knowledge Gaps
Knowledge gaps, limitations, and open questions
The paper proposes Sparse Delta Memory (SDM) and provides empirical evidence up to 8B parameters, but leaves several important aspects unresolved. Future work could address the following concrete gaps:
- Fair parameter accounting and scaling laws
- The reported parameter counts explicitly exclude the SDM memory state while allowing a learned initial memory , potentially confounding “iso-parameter” claims. Quantify the effective parameter increase from and re-assess scaling under Chinchilla-optimal token budgets and strict parameter-matched baselines.
- Establish whether SDM’s advantages persist when the parameter budget includes and when training tokens are allocated per Chinchilla scaling laws.
- Theoretical capacity and retention guarantees
- Provide formal analysis connecting recall/ICL performance to memory size , read/write budgets , value dimension , and forget/input gates under the delta rule. Bound retrieval error, interference, and expected retention time as a function of these hyperparameters.
- Characterize conditions where SDM provably reduces to or strictly improves upon GDN with respect to stability and capacity.
- Differentiability and learning dynamics of sparse selection
- Clarify how gradients flow through the non-differentiable
top-kPKM routing during writes/reads (e.g., straight-through vs. no gradient to unselected slots). Analyze bias introduced by hard selection and compare to continuous relaxations (e.g., Gumbel-Softmax, differentiable kNN). - Measure convergence stability and variance across seeds as a function of selection hardness and sparse-key normalization.
- Clarify how gradients flow through the non-differentiable
- Slot collisions, utilization, and interference
- Quantify slot collision rates and long-term slot “churn,” including lifetime and turnover of stored items. Evaluate whether regularizers (e.g., entropy, coverage, anti-collision losses) improve load balancing and reduce interference.
- Investigate whether some slots become “dead” or “hot,” and whether targeted rekeying, hashing, or routing constraints can mitigate imbalance.
- Read/write budget scheduling and adaptivity
- The paper shows static and observes adaptive behavior post hoc; test learnable or token-conditional controllers that dynamically trade selectivity vs. dispersion.
- Explore per-layer/per-head heterogeneous budgets and their impact on depth-wise information routing.
- Head count and state–depth trade-offs
- Systematically ablate the number of SDM heads beyond the chosen state-to-parameter ratio, examining cross-head specialization, robustness, and whether multi-head SDM yields better compositional recall than single-head configurations at fixed FLOPs.
- Study how memory per layer (and its O() scaling) should be distributed across depth for optimal capacity vs. interference.
- Learned initial memory : benefits, risks, and mechanics
- Isolate and quantify how much of the short-context and reasoning gains stem from vs. online updates across diverse tasks and datasets (beyond code/text). Explain task-specific regressions (e.g., BoolQ drop at 8B) potentially attributable to interference.
- Develop methods for editing, updating, or selectively erasing (for data deletion or model updates) without catastrophic forgetting or re-pretraining.
- Assess privacy risks and compliance implications of storing pretraining knowledge in , and propose scrubbing/attribution tools.
- Robustness and OOD generalization
- Evaluate SDM under distribution shift, adversarial prompts that induce key collisions, noisy contexts, and extremely long horizons (≫1M tokens). Measure failure modes when contexts exceed effective capacity and characterize degradation curves.
- Test stability under extreme decay/gating regimes and across precision formats (FP8/FP16) for the memory table.
- Breadth of comparisons and tasks
- Extend iso-FLOP comparisons to additional long-context baselines (e.g., RetNet, RWKV, Hyena, S4/S5, xLSTM variants) and memory-augmented approaches (RMT, KERPLE, external kNN).
- Evaluate on agentic, codebase-scale, and long-form QA tasks; and on modalities the paper claims SDM could benefit (e.g., long video/world models), none of which are tested here.
- Training curriculum and long-context strategy
- Compare pretrain-on-short then finetune-on-long vs. pretrain-on-long from scratch for SDM. Determine the minimal long-context finetuning needed and whether curriculum over context length improves stability or capacity utilization.
- Analyze sensitivity to optimizer/learning-rate schedules, gate initializations (, ), and value/key dimensions.
- Hybrid architecture interactions
- The model uses SWA with window size 128 and a 3:1 short:long ratio; ablate window sizes, ratios, and local-attention alternatives. Quantify interaction effects and competition between local attention and SDM, and identify optimal hybrids.
- Practical systems and hardware efficiency
- SDM underutilizes compute (low MFU) due to HBM-bound random memory access; provide detailed wall-clock profiling (per-layer, per-operation) at larger to validate the claim that PKM top-k is <1% of FLOPs and to identify bottlenecks.
- Explore kernel/placement strategies (e.g., prefetching, fused gather/scatter, tiling, caching, NUMA-aware layouts), quantization of the memory table, and cross-device sharding. Report training/inference latency vs. FullAttn in multi-batch and multi-query decoding regimes.
- Memory persistence and sessioning
- Define and evaluate policies for memory persistence across documents/sessions, resets, and multi-turn chat. Study session-level memory growth, interference between sessions, and mechanisms for isolation or selective carryover.
- Retrieval integration
- Examine combining SDM with external retrieval (RAG, document memory) and hierarchical memory schemes (short-term vs. long-term slots). Determine whether SDM indexing can coordinate with external indices to reduce collisions and improve recall.
- Interpretability and controllability
- Develop tools to probe and visualize what is stored in slots (both and online updates), identify which slots support a given prediction, and enable targeted memory editing or auditing.
- Numerical and normalization choices
- Evaluate alternatives to RMSNorm on reads, effects of different normalizations/gates on stability, and the impact of per-slot vs. global decay schedules. Test sensitivity to softmax temperature for read/write distributions.
- Failure cases on RULER
- Analyze why SDM still lags FullAttn on multikey-2/3 and other hard RULER settings; determine whether limitations stem from budgets, collisions, or decay, and design targeted fixes (e.g., separate indices for multi-key associations).
- Data and tokenization scope
- Test multilingual, code-heavy, and specialized domains with different tokenizers, measuring whether PKM-based indexing is sensitive to token distribution shifts.
These gaps, if addressed, would clarify SDM’s theoretical foundations, practical efficiency, robustness, and generality, and would guide principled choices of memory size, indexing, gating, and hybridization in future work.
Practical Applications
Immediate Applications
Below are deployable use cases that can be implemented with the paper’s released approach and current hardware/software stacks, benefiting from SDM’s fixed per-token compute, large learned/persistent state, and superior long-context recall.
- Software engineering: repository-scale code assistants
- What: IDE copilots that reason across entire monorepos, long issue threads, and multi-file refactoring sessions without blowing up KV cache.
- Tools/workflows: Replace some global attention or linear RNN layers with SDM layers in existing code LLMs; fine-tune on 128k–1M token sequences; persist learned initial memory M0 per domain (e.g., organization-specific code conventions).
- Sector: Software
- Assumptions/dependencies: Efficient SDM kernels (top-k PKM, sparse reads/writes) on GPUs; training data with long code contexts; guardrails against memorizing sensitive code in M0.
- Enterprise knowledge assistants with session-scale memory
- What: Assistants that track long, multi-hour to multi-day conversations, meeting series, and evolving project contexts without linear growth in KV cache.
- Tools/workflows: Hybrid SWA+SDM architecture; session memory persisted across turns; “R/W key” budget tuning (R, W) per latency/SLA.
- Sector: Enterprise software, Productivity
- Assumptions/dependencies: Product integration with conversation platforms; privacy controls around persistent memory; throughput acceptable given SDM is ~6× faster than full attention at decode but ~10% slower than dense linear-RNN baselines.
- RAG-lite and cache-lean inference
- What: Reduce frequency of external retrieval by caching in-context facts/indices inside SDM memory over long sequences.
- Tools/workflows: Orchestrator that first attempts SDM recall, falls back to vector DB only when confidence is low; per-domain learned M0 to preload common knowledge.
- Sector: Enterprise search, Customer support
- Assumptions/dependencies: Calibrated confidence estimation; safe handling of potentially stale cached info.
- Log and telemetry analysis over long horizons
- What: Analyze millions of tokens of logs/telemetry with constant per-token compute (e.g., root-cause analysis across rolling windows).
- Tools/workflows: Streaming inference with SDM heads tuned for large N and modest R/W; chunk-wise parallel training for long contexts.
- Sector: DevOps, Security
- Assumptions/dependencies: Efficient streaming pipelines; memory residency in HBM is acceptable; alerting UX for long-horizon anomalies.
- Legal and compliance document review at scale
- What: Summarize, compare, and track references across large contracts, filings, and case histories without prohibitive KV cache.
- Tools/workflows: SDM-based reviewers that maintain cross-document entities and clause links in-state over 100k+ tokens.
- Sector: Legal, Finance (compliance)
- Assumptions/dependencies: Domain fine-tuning and evaluation; governance for persistent memory; explainability tooling.
- Healthcare longitudinal summarization (non-diagnostic assistants)
- What: Create longitudinal patient narratives spanning long clinical notes and labs; maintain problem lists and med histories in-state.
- Tools/workflows: SDM heads tuned for recall; learned M0 seeded with non-PHI medical ontology embeddings.
- Sector: Healthcare IT
- Assumptions/dependencies: Strict PHI handling; on-prem deployment; clinical validation; avoid using M0 to memorize PHI.
- Education: persistent tutoring across a semester
- What: Tutors that remember a learner’s goals, misconceptions, and progress across long sequences of interactions.
- Tools/workflows: Domain-adapted M0 per subject; SDM memory checkpointed per learner; long-context fine-tuning.
- Sector: Education
- Assumptions/dependencies: Privacy and parental consent; bias/feedback monitoring; device/server deployment model.
- Long-form code/data artifact generation
- What: Generate or refactor books, specs, notebooks, and pipelines that exceed typical context windows.
- Tools/workflows: SDM layers for long-horizon planning and revision passes; value gating schedules to control write “pressure.”
- Sector: Software, Publishing, Data science
- Assumptions/dependencies: UI to navigate very long drafts; evaluation for coherence across 100k+ tokens.
- Meeting and research assistants with sustained context
- What: Track agendas, decisions, citations, and open questions across multi-session projects and literature reviews.
- Tools/workflows: M0 initialized with domain taxonomy; SDM read distributions tuned for broader reads (higher R) to improve recall breadth.
- Sector: Productivity, Academia
- Assumptions/dependencies: Data retention policies; ability to export/import SDM memory snapshots.
- Code and data perplexity reduction for analytics pipelines
- What: Lower perplexity on long code/data sequences, improving autocompletion and schema inference with stable latency.
- Tools/workflows: Replace dense linear-RNN layers with SDM in code LLM backends powering BI/SQL assistance.
- Sector: Analytics, Data platforms
- Assumptions/dependencies: Kernel maturity; acceptance of small inference slow-down vs dense RNN in exchange for large quality gains.
- On-device or edge assistants with predictable latency
- What: Fixed per-token FLOPs enable stable latency on constrained hardware for long conversations or transcripts.
- Tools/workflows: Quantized SDM variants; smaller H to control state size; N tuned to device HBM/LPDDR constraints.
- Sector: Mobile, IoT
- Assumptions/dependencies: Memory bandwidth constraints; sparse kernels in mobile runtimes; privacy policies for persistent memory.
- Open-source research baselines for long-context modeling
- What: Academia can benchmark long-context tasks without the compute explosion of full attention.
- Tools/workflows: Use the released SDM code; reproduce isoFLOP comparisons; expand to new datasets (RULER-like for other domains).
- Sector: Academia
- Assumptions/dependencies: Community kernel contributions to raise MFU; standardized evaluation suites.
- Cost optimization for long-context serving
- What: Reduce GPU memory needs relative to full attention KV caches on long prompts, improving consolidation and utilization.
- Tools/workflows: SDM serving tiers for “long-session” users; autoscaling policies tuned for constant per-token cost.
- Sector: Cloud AI platforms
- Assumptions/dependencies: Throughput vs quality trade-offs; monitoring for memory fragmentation and read/write hot-spotting.
Long-Term Applications
These opportunities likely require further advances in sparse kernels, memory hierarchies, multimodal training, or governance.
- Persistent, privacy-preserving personal assistants
- What: Month-scale memory of user preferences, projects, and context with fixed per-token cost and controllable write gates.
- Tools/products: Per-user SDM memory graphs; selective “forget” policies; client-side M0 with encrypted sync.
- Sectors: Consumer software, Productivity
- Assumptions/dependencies: Robust privacy and consent frameworks; explainable memory inspection; efficient on-device kernels.
- Multimodal long-video understanding and world models
- What: Track events and dependencies across hours of video for summarization, surveillance, and simulation.
- Tools/products: Vision-language SDM layers that write sparse states keyed by spatiotemporal indices; hierarchical SDM over shots/scenes.
- Sectors: Media, Robotics, Sports analytics
- Assumptions/dependencies: Multimodal pretraining at scale; video tokenizers; memory bandwidth and hierarchical memory design.
- Long-horizon robotic planning and control
- What: Maintain sparse, durable state across long trajectories; integrate with world models needing extended temporal memory.
- Tools/products: SDM as the recurrent core in model-based RL pipelines; read/write policies aligned with control objectives.
- Sector: Robotics
- Assumptions/dependencies: Real-time constraints; safety and reliability certification; sim-to-real transfer.
- Financial temporal reasoning across filings and streams
- What: Jointly reason over multi-year filings, earnings calls, and transaction streams with constant per-token inference.
- Tools/products: SDM-based analyst copilots; audit trail memory with selective “legal hold.”
- Sector: Finance
- Assumptions/dependencies: Regulatory compliance (SEC, MiFID II); thorough calibration and auditability of persistent memory.
- Regulatory and legislative drafting assistants
- What: Track cross-references and precedents across vast legal corpora while drafting amendments and impact analyses.
- Tools/products: SDM memory conditioned on jurisdictional ontologies; versioned memory snapshots for traceability.
- Sector: Public policy, Legal
- Assumptions/dependencies: Gold-standard evaluations; explainability for cited memory reads; bias and fairness assessments.
- Hierarchical, distributed SDM memory at billion-slot scale
- What: Scale N to 108–109 effective slots using multi-level product-key routing and device sharding.
- Tools/products: Memory servers with top-k routing; hot/cold tiers; cross-device read/write consistency.
- Sector: Cloud AI infrastructure
- Assumptions/dependencies: New kernels and network primitives; routing correctness under contention; failure handling.
- Continual and domain-adaptive M0 with safe updates
- What: Periodically update the learned initial state to encode fresh domain knowledge without catastrophic interference.
- Tools/products: Offline “M0 refresh” pipeline; safety scanners; diff-based memory updates with rollback.
- Sectors: All knowledge-heavy verticals
- Assumptions/dependencies: Methods to disentangle in-context vs parametric memory; compliance with data retention laws.
- Retrieval-synthesis hybrids with tighter integration
- What: Use SDM to cache retrieved evidence and synthesize over very long chains of retrieved segments.
- Tools/products: Retrieval controller that shapes SDM write/read distributions; evidence aging via forget gates.
- Sectors: Search, Research
- Assumptions/dependencies: Controller training; avoiding error accumulation; evaluation on multi-hop, 100k+ token pipelines.
- Long-horizon scientific assistants
- What: Maintain hypotheses, experiments, and literature tracking across extended projects (weeks to months).
- Tools/products: SDM-based lab notebooks; hypothesis memory readouts; chain-of-thought held in sparse state for re-use.
- Sector: Academia, Pharma R&D
- Assumptions/dependencies: Domain corpora; IP/governance for memory persistence; model accountability.
- Safety, auditing, and governance of persistent LLM memory
- What: Standards and tools to inspect, edit, and prove properties of SDM state (e.g., deletion requests, bias audits).
- Tools/products: Memory introspection APIs; per-slot provenance; red-team suites for long-memory systems.
- Sector: Policy, Trust & Safety
- Assumptions/dependencies: Formalization of “right to be forgotten” in model memory; verifiable deletion.
- Energy-efficient long-context inference at the edge
- What: Stable, bounded compute for long transcripts on edge accelerators to reduce energy per token.
- Tools/products: Hardware co-design for PKM top-k and sparse updates; LPDDR-aware memory layouts.
- Sectors: Energy, Edge AI
- Assumptions/dependencies: Vendor support for sparse primitives; quantization-aware training for SDM.
- Program synthesis and verification over massive contexts
- What: Maintain invariants and proofs across long proofs/traces in formal verification and large-scale codebases.
- Tools/products: SDM-integrated verifiers that keep lemmas and dependencies in fast, sparse memory.
- Sector: Software verification, Safety-critical systems
- Assumptions/dependencies: Benchmarks and proof corpora; interfaces to theorem provers.
Cross-cutting feasibility notes
- Performance/throughput: The paper reports SDM decode ~10% slower than dense linear-RNN baselines but ~6× faster than full attention; training ~1.5× slower than dense linear RNN due to current kernels. Kernel optimization and memory locality will improve viability for latency-sensitive use.
- Memory bandwidth: SDM state lives in HBM (vs SRAM), making bandwidth a bottleneck; hierarchical and fused kernels are likely needed for large-scale deployments.
- Tuning and safety: Read/write sparsity budgets (R, W), head count H, and forget/input gates critically shape behavior; safety reviews are needed when using learned M0 (risk of storing sensitive or stale info).
- Integration: Hybrid designs (local SWA + global SDM) and isoFLOP swaps ease adoption. The code link provided in the paper accelerates prototyping.
- Data/regulation: Domain deployments (healthcare, legal, finance) require fine-tuning on compliant corpora, auditability of persistent memory, and deletion/retention controls.
Glossary
- Associative Memory: A memory formulation where keys and values are written as associations and later retrieved via similarity to a query. "Linear Attention as an Associative Memory."
- Chinchilla scaling laws: Empirical compute–data tradeoff rules for training LLMs optimally. "We do not rely on optimal token budget following the Chinchilla scaling laws \citep{hoffmann2022trainingcomputeoptimallargelanguage}"
- Chunk-wise parallelism: Training technique that processes sequences in chunks to enable efficient parallel updates. "We detail how SDM is trained efficiently using chunk-wise parallelism (via the WY representation from GDN/FLA)"
- Delta rule: An update rule that subtracts the retrieved value before writing a new association to reduce interference. "DeltaNet \citep{schlag2021lineartransformersselfretrievalcompressive} improves upon vanilla linear attention by introducing the delta rule: before writing a new association into the memory, the model first retrieves and subtracts the existing value associated with the key"
- Fast-Weight Product Key Memory: A sparse, online memory mechanism that uses product-key indexing for fast updates. "The work most closely related to ours is the recent Fast-Weight Product Key Memory~\citep{zhao2026fastweightproductkeymemory}"
- FLOPs: A measure of computational cost counting floating-point operations. "Increasing the state size of linear attention improves recall performance but at the cost of higher FLOPs."
- Forget gate: A scalar gate controlling decay of past associations in memory. "Gated DeltaNet (GDN) further adds a decay (forget) gate to control how quickly old associations are forgotten."
- Gated attention output: A mechanism that modulates attention outputs via element-wise gating. "and gated attention output \citep{qiu2025gatedattentionlargelanguage}."
- Gated DeltaNet (GDN): A linear attention variant with delta updates and gating to prevent interference and control forgetting. "Gated DeltaNet (GDN) further adds a decay (forget) gate "
- Gated MLP: An MLP layer whose outputs are modulated by learned gates. "Each block uses a gated MLP \citep{liu2021payattentionmlps}"
- Grouped-Query Attention (GQA): An attention variant that shares key–value sets across groups of queries. "All full-attention layers use grouped-query attention (GQA) with group size 2 ()"
- HBM: High Bandwidth Memory on GPUs with lower bandwidth than on-chip SRAM. "HBM, which has a 10 lower bandwidth than SRAM."
- In-context learning: The ability to learn and adapt from information presented within the current input sequence. "a higher state memory capacity significantly improves performance on in-context learning and long-context retrieval tasks."
- Input gate: A scalar gate controlling the strength of memory updates. "where is a learned input gate modulating the memory update strength."
- isoFLOP: A constraint where models are compared using identical FLOP budgets to isolate architectural effects. "under an isoFLOP constraint"
- Linear Attention: Attention mechanism that uses kernel feature maps to enable constant-time/state reads and writes. "Linear attention models allow a fixed state size and a fixed amount of compute per token."
- Linear RNNs: Recurrent architectures with linear state updates enabling constant memory/compute per token. "Overall, we show that SDM, thanks to its large state, can keep the constant-space and memory advantages of Linear RNNs"
- Long-context retrieval: The task of retrieving information from very long sequences. "improves performance on in-context learning and long-context retrieval tasks."
- Mamba2: A modern linear RNN/state-space model optimized for long sequences. "modern linear RNNs like Mamba2~\citep{mamba2}"
- MFU (Model FLOPs Utilization): The fraction of peak FLOPs a kernel achieves in practice. "the current SDM kernel MFU (Model FLOPs Utilization) is around an order of magnitude lower than the highly optimized GDN kernel"
- Multi-Head Attention (MHA): Attention mechanism using multiple parallel heads to capture diverse patterns. "All models use a hybrid architecture with Multi-Head Attention (MHA) layers using Sliding Window Attention (SWA)"
- Negative Log-Likelihood (NLL): A standard loss/metric measuring model fit to data; lower is better. "Validation text NLL"
- Perplexity: A sequence-modeling metric derived from NLL; lower indicates better predictions. "SDM achieves consistently lower perplexity on code data compared to Mamba2 and GDN"
- Product-Key Memories (PKM): A large, sparse memory indexing scheme combining two key spaces via an outer-sum. "Product-Key Memories (PKM)~\citep{lample2019largememorylayersproduct} propose an indexing scheme that allows indexing to arbitrary indices among possible memory slots"
- RMS-Norm: A normalization method using root-mean-square statistics instead of mean/variance. "The retrieved memory is normalized through RMS-Norm"
- Recurrent Neural Networks (RNNs): Sequence models that maintain a hidden state updated at each time step. "Recurrent Neural Networks (RNNs), including State Space Models \citep{gu2024mambalineartimesequencemodeling}"
- RoPE: Rotary Positional Embeddings used to encode positions in attention. "Position encoding uses RoPE \citep{su2023roformerenhancedtransformerrotary}"
- RULER: A benchmark for evaluating long-context retrieval and reasoning. "long-context recall tasks from the RULER~\citep{hsieh2024rulerwhatsrealcontext} benchmark"
- SiLU activation: The Sigmoid Linear Unit nonlinear activation function. "with SiLU activation \citep{elfwing2017sigmoidweightedlinearunitsneural}"
- Sliding Window Attention (SWA): Attention restricted to a fixed local window for efficiency. "Multi-Head Attention (MHA) layers using Sliding Window Attention (SWA)"
- Softmax attention: Standard attention using softmax-normalized dot-product similarities. "In the standard transformer architectures equipped with a vanilla softmax attention"
- Sparse addressing scheme: An approach that selects a small subset of memory slots for read/write operations. "using a sparse addressing scheme."
- Sparse reads and writes: Memory operations that update or retrieve from only selected slots. "replacing the dense key-value outer product with sparse reads and writes to a large explicit memory."
- SRAM: On-chip static RAM with higher bandwidth than HBM. "HBM, which has a 10 lower bandwidth than SRAM."
- State Space Models: Sequence models that view hidden states as outputs of linear dynamical systems. "Recurrent Neural Networks (RNNs), including State Space Models \citep{gu2024mambalineartimesequencemodeling}"
- Test-Time-Training: Methods that adapt model parameters during inference to improve performance. "sparsifying the existing Test-Time-Training methods~\citep{sun2025learninglearntesttime, zhang2025testtimetrainingright}"
- Tokens-per-parameter (TPP): A budgeting ratio specifying training tokens relative to model parameters. "we adopt a 160 tokens-per-parameter (160TPP) compute budget."
- Top-k: Selecting the k highest-scoring items from a set. "We simply get the of the flattened scores ."
- WY representation: A factorized representation enabling efficient parallel computation of certain updates. "chunk-wise parallelism (via the WY representation from GDN/FLA)"
Collections
Sign up for free to add this paper to one or more collections.

