Attention Drift: What Autoregressive Speculative Decoding Models Learn
Abstract: Speculative decoding accelerates LLM inference by drafting future tokens with a small model, but drafter models degrade sharply under template perturbation and long-context inputs. We identify a previously-unreported phenomenon we call \textbf{attention drift}: as the drafter generates successive tokens within a speculation chain, attention progressively moves from the prompt onto its own recently-generated tokens. We observe this across both \emph{EAGLE3} drafters and \emph{MTP heads}, suggesting drift is a property of drafter designs. We trace this to the un-normalized residual path between chain steps: the drafter's hidden state magnitude grows monotonically with chain depth, which exhibits dynamics consistent with additional pre-norm transformer layers stacked on the target rather than as a standalone autoregressive predictor. In order to limit the growth, we propose two architectural changes: Post-norm on the drafter hidden states and per-hidden-state RMSNorm after capturing target hidden states. Our interventions improve acceptance length over the current leading model, pre-norm EAGLE3, by up to $2\times$ under template perturbation, $1.18\times$ on long-context tasks, and $1.10\times$ on seven standard benchmarks spanning multi-turn chat, math, and coding. Our changes also allow shorter train-time-test depths to generalize over longer drafting sequences.
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
What is this paper about?
This paper looks at a speed-up trick for LLMs called “speculative decoding.” In simple terms, a small “drafter” model guesses several words ahead, and a big “verifier” model quickly checks those guesses. The goal is to answer faster without losing accuracy.
The authors discovered a problem they call “attention drift”: as the drafter keeps guessing more words in a row, it starts paying more attention to its own recent guesses and less to the original prompt. They show why this happens and propose simple fixes that make the drafter more reliable and faster across many situations.
What questions were the researchers trying to answer?
- Why do drafter models sometimes work well in one setup but fall apart when the prompt format changes or the input is very long?
- What exactly is “attention drift,” and what causes it inside the model?
- Can we change the drafter’s design to prevent this drift and make it more robust and faster?
How did they study it? (Plain-language explanation)
Think of the system like a team:
- The “drafter” is a fast friend who tries to guess the next several words.
- The “verifier” is a careful expert who checks those guesses in one go and accepts as many as match its own choices.
The team repeats this: the drafter guesses a few words, the verifier checks, and so on. A key score is “acceptance length” (how many drafted words get accepted each round). The higher this number, the faster the overall system.
What the researchers did:
- They looked “inside” the drafter to see where its attention goes as it writes more words. In many LLMs, there’s a special “anchor” position near the start—an “attention sink”—that helps keep focus. They saw that, over a chain of guesses, the drafter’s attention slide from this anchor toward the words it just wrote. That’s attention drift.
- They measured the “size” (magnitude) of the drafter’s internal signals after each guess. They found those signals grow bigger and bigger with each drafted step—like a microphone getting louder every time you pass it through an amplifier. This growth pushes the drafter to focus more on its own recent outputs than on the original prompt.
- They tried architecture tweaks. One key idea is about “normalization,” which is like turning the volume back to a steady level after each step:
- Pre-norm (the usual way): normalize before each layer. This leaves a pathway where the “volume” can still build up across drafting steps.
- Post-norm (their change): normalize after each step, keeping the “volume” steady so it doesn’t swell.
- They also normalized the verifier’s internal signals before feeding them into the drafter, so all inputs start at similar “volume levels.”
- They ran many tests across different models, prompt formats, and long-context settings, and compared acceptance length and stability.
Analogy:
- Without fixes: each drafting step adds “more sound” to the signal, so the drafter hears itself louder and louder and tunes into its own recent guesses.
- With post-norm: after each step, you reset the “volume,” keeping focus balanced between the original prompt and the latest guesses.
What did they find, and why does it matter?
Main findings:
- Attention drift is real and common: as the drafter writes more, it pays less attention to the prompt and more to its own latest words.
- Root cause: the drafter’s internal signals grow larger at every step because of how layers are organized (an unnormalized “residual” path). This makes the drafter behave like it’s stacking extra layers on top of the big model instead of acting like a steady, independent predictor. That’s why it breaks more easily when prompts or contexts change.
- Simple fixes work:
- Add post-norm to the drafter (normalize after each step) so signal size stays steady.
- Normalize the verifier’s internal signals before combining them (so inputs are balanced).
- These changes reduce attention drift and make the drafter more robust.
- Better performance:
- Under messy or changed prompt templates: up to about 2× more drafted tokens accepted per round (so, faster).
- With long inputs: around 18% improvement.
- Across standard tests (chat, math, coding): about 10% improvement on average.
- It also generalizes better: drafters trained on short guessing chains keep working well on longer chains.
- Extra insight: Removing the “attention sink” alone (using “gated attention”) stops the visible drift pattern, but doesn’t stop the harmful signal growth. That means “drift” and “signal growth” are separate problems. Post-norm specifically targets the growth problem—this is what improves reliability and speed.
Why it matters:
- Faster: More accepted guesses per round means fewer checks and quicker responses.
- More reliable: Works better when the prompt formatting changes or when the context is really long—two situations common in real apps.
- Cheaper to train: Because it generalizes to longer chains than it saw during training, you can train with shorter chains and still get good results later.
What’s the big picture impact?
- For developers and companies: A small architectural change (post-norm + input normalization) can make speculative decoding more stable and faster, cutting costs and headaches when prompts or templates vary.
- For research: Naming “attention drift” gives a clear target to diagnose and fix. It also shows that keeping internal signal sizes steady is key for models that feed their own outputs back in multiple steps.
- For users: You get quicker, more consistent model replies—especially when conversations are long or formats differ.
In short: The paper uncovers why some speed-up tricks fail in the real world and offers a simple, effective fix that makes fast drafting both faster and sturdier.
Knowledge Gaps
Knowledge gaps, limitations, and open questions
Below is a concise list of unresolved issues that the paper surfaces or leaves unexplored; each item is framed to enable concrete follow‑up work.
- Causal attribution of drift vs. magnitude growth remains incomplete. While correlations are shown, the paper does not run training-time interventions that fix hidden-state scale without architectural changes (e.g., magnitude regularizers, residual rescaling, LayerScale) to isolate whether scale alone causes drift.
- Head- and layer-level responsibility for drift is not identified. The analysis aggregates attention; it does not determine which attention heads (e.g., induction, sink-related) or layers dominate drift, nor whether targeted per-head Q/K/V scaling or per-layer residual scaling could resolve it.
- Fusion of target hidden states is underexplored. Only a simple FC over low/mid/high layers (with added RMSNorms) is tested; alternatives like learned per-layer weights, attention-based fusion, gating between layers, or excluding high layers to avoid pre-norm magnitude imbalance are not ablated.
- Training-window construction may contribute to drift but is not studied. The paper hypothesizes that fixed TTT windows that drop early tokens (including sinks) encourage drift; it does not test curricula that retain sink/system tokens, vary window policies, or use depth-adaptive windows.
- Mechanism of drift in MTP heads is unresolved. MTP uses post-norm yet exhibits sharp-then-stabilize drift; the paper doesn’t disentangle whether this arises from joint training, LM-head sharing, loss design, or architecture. No fixes are evaluated on MTP.
- Generality across drafter families is unknown. Only EAGLE-3 and MTP are examined; Medusa/Hydra-style multi-head drafters, diffusion-based (e.g., D-Flash), and non-autoregressive or tree-based drafters are not analyzed for drift or tested with the proposed fixes.
- Scaling behavior at larger model sizes is unverified. Experiments cap at ≤120B; whether drift, magnitude growth, and the efficacy of post-norm persist or change at larger scales remains open.
- End-to-end system speedups are not reported. Gains are presented in acceptance length, but real latency/throughput under vLLM/SGLang (with drafter compute, KV-cache, batching, and verification overhead) are not quantified.
- Impact on final task quality is not measured. The paper optimizes/report acceptance length, but it does not evaluate downstream answer correctness or faithfulness under speculative decoding with the modified drafter.
- Robustness to quantization and deployment noise is not validated. Noise-injection experiments use synthetic Gaussian perturbations; effects with realistic INT8/FP8 activation/KV quantization, AWQ/GPTQ weight quantization, and KV-eviction are not tested.
- Long-context evaluation is limited. Tests rely on SWA windows and moderate lengths; interaction with alternative long-context methods (e.g., RoPE scaling, NTK/PI/ALiBi, ring-attention) and very long contexts (e.g., ≥32k–128k) is not assessed.
- Template sensitivity coverage is narrow. Only a few perturbations and English prompts are tested; behavior across multiple languages, diverse chat formats, code vs. prose prompts, and varied template markers remains unmeasured.
- Decoding hyperparameter sensitivity is underexplored. Acceptance and robustness are tested at a couple of temperatures; the effects of top‑p, top‑k, typical‑p, repetition penalties, and verifier temperature on drift and acceptance are not mapped.
- Training stability of post-norm for deeper drafters is unknown. The paper modifies a shallow drafter; whether post-norm maintains stability for deeper drafter stacks (or interacts with optimizer choice, LR schedules) is not evaluated.
- Entropy collapse with post-norm + gated attention is not understood. The combined variant collapses attention entropy without a clear diagnosis; methods to prevent over-regularization (e.g., entropy penalties, head-wise gates, temperature tuning) are not explored.
- Relationship between magnitude control and drift needs training-time tests. Inference-time magnitude pinning reduces drift but harms acceptance; the paper does not train with magnitude constraints (e.g., norm matching losses, spectral/gradient norm control) to see if drift can be reduced without performance loss.
- Per-head Q/K norm dynamics across steps are not analyzed. The link between step-wise scale growth and Q/K similarity changes is argued qualitatively; quantitative tracking of per-head Q/K RMS, dot-product distributions, and softmax temperatures is missing.
- Sink-suppression mechanisms in verifiers are only spot-checked. Beyond GPT-oss and Qwen3-Next, the interplay between different sink-suppression designs (gating, softmax biases, learned null keys) and drafter drift is not systematically studied.
- Tokenization and special-token effects are not isolated. The paper observes template tokens acting as pseudo-sinks but does not ablate different tokenizers or vary special-token inventories to quantify their role in drift.
- Alternative normalizations are not compared. Only RMSNorm placement is varied; ScaleNorm, LayerNorm, RMSNorm with learned scaling, residual/post-activation scaling (e.g., μ-Param/DeepNet), or norm-aware attention (per-head scaling) are not benchmarked.
- Depth-invariance objectives are not explored. No losses explicitly enforce that the drafter’s mapping is invariant across speculation depth (e.g., consistency losses across steps, step-agnostic parameterization, or distillation to a depth-invariant predictor).
- Curriculum on train-time-test (TTT) depth is not studied. The paper shows post-norm generalizes beyond TTT; it does not evaluate curricula that vary/maximize TTT or stochastic depth across steps to improve pre-norm robustness.
- Interaction with alternative verification schemes is unknown. Results assume standard rejection sampling; behavior under dynamic draft trees, adaptive k, or multi-branch verifiers (e.g., Hydra/EAGLE-2) is not evaluated.
- Prompt-domain and task-dependence of drift are not quantified. Drift is aggregated over tasks; whether math, coding, multi-turn chat, or reasoning prompts induce different drift patterns is not analyzed.
- Theoretical grounding is limited. The “layer-stacking” interpretation for pre-norm drafters is argued empirically; a formal analysis of residual dynamics across chain steps (e.g., fixed-point or stability analysis) is not provided.
- Safety/security implications are not considered. Whether drift or magnitude dynamics interact with prompt injection, jailbreaks, or safety filter prompts during speculative decoding is unexplored.
- Reproducibility details for MTP are incomplete. The MTP training procedure for Qwen3.5 is not public, limiting causal analysis and replication of MTP drift results; standardized MTP setups are needed to test proposed fixes.
Practical Applications
Overview
This paper identifies “attention drift” in autoregressive speculative decoding drafters (e.g., EAGLE-3, MTP heads) and proposes simple architectural fixes—post-normalization between drafting steps and per-hidden-state RMSNorm before fusing target hidden states—that stabilize hidden-state magnitudes, reduce drift, and improve acceptance length and robustness. Reported gains include up to 2× acceptance length under template perturbations, ~1.18× on long-context tasks, and ~1.10× across standard benchmarks, with improved noise tolerance and better generalization beyond the training horizon (shorter train-time-test depths).
The following lists translate these findings into actionable applications, highlighting sectors, tools/products/workflows, and feasibility assumptions.
Immediate Applications
- Faster, more robust LLM serving via post-norm drafters
- Sector(s): software, cloud/ML platforms, enterprise IT, consumer AI apps
- What: Replace pre-norm EAGLE-3 drafters with post-norm drafters (plus RMSNorm on captured target states) in engines like vLLM/SGLang to increase acceptance length and reduce latency/cost.
- Tools/Products/Workflows:
- “PostNorm Drafter” plugin/module for vLLM/SGLang
- Deployment recipes for Llama/Qwen/GPT-OSS class models
- Assumptions/Dependencies:
- Access to target model’s internal hidden states (required by EAGLE-style drafting)
- Ability to retrain drafter heads on SFT-like data
- Improvements validated on models ≤120B; larger models unverified
- Reduced drafter training cost via shorter train-time-test depth (TTT)
- Sector(s): software, ML R&D, MLOps
- What: Train drafters at smaller depth (e.g., TTT=2–4) and rely on post-norm’s depth generalization at inference (deeper speculation), cutting training time while keeping acceptance length high.
- Tools/Products/Workflows:
- “TTT auto-scheduler” that selects minimal training depth based on observed generalization
- Assumptions/Dependencies:
- Same data and loss as EAGLE; applies to post-norm variant
- Robustness to prompt template changes in production
- Sector(s): customer support, content moderation, multi-agent systems, platform SDKs
- What: Swap to post-norm drafters to mitigate large acceptance drops when chat templates/system prompts are altered (intentional or accidental).
- Tools/Products/Workflows:
- Prompt-template A/B testing harness tied to acceptance-length monitoring
- “Template-robust mode” in serving stack
- Assumptions/Dependencies:
- Templates may vary across deployments; benefits are largest when templates change frequently
- Better long-context performance with sliding-window attention (SWA)
- Sector(s): legal, healthcare, finance, code intelligence, enterprise search
- What: Combine post-norm drafters with SWA at 256–1024 token windows to restore most performance on long inputs (multi-turn, documents, codebases) at low compute cost.
- Tools/Products/Workflows:
- “SWA optimizer” that picks window sizes (e.g., ~1024 tokens) per workload
- Assumptions/Dependencies:
- Long-context tasks present; SWA supported by the serving stack
- Carrying BoS helps pre-norm but is optional for post-norm; carrying long system prompts may harm pre-norm
- Drafter robustness QA and continuous monitoring
- Sector(s): MLOps, platform reliability, compliance
- What: Use “attention drift” and hidden-state RMS as health signals in CI/CD to prevent regressions when updating models, templates, or quantization settings.
- Tools/Products/Workflows:
- “Drift dashboard” exposing sink/self-token attention, per-step acceptance, RMS growth
- Regression tests that perturb templates and context length
- Assumptions/Dependencies:
- Access to attention and hidden-state metrics at inference/debug time
- More reliable low-precision and edge inference
- Sector(s): mobile, embedded/edge AI, energy/green computing
- What: Deploy post-norm drafters for higher tolerance to hidden-state noise and quantization artifacts, stabilizing acceptance length under low-precision serving.
- Tools/Products/Workflows:
- Quantization-aware drafter configs
- On-device speculative decoding that keeps verifier passes minimal
- Assumptions/Dependencies:
- Quantization introduces small perturbations; post-norm improves tolerance but is not a substitute for full quantization-aware training
- Prescriptive guidance for gated attention use
- Sector(s): ML engineering, model architecture teams
- What: If using gated attention to suppress sinks, avoid combining with post-norm by default (can collapse attention entropy); prefer post-norm alone for robustness.
- Tools/Products/Workflows:
- Architecture checklists and linting in model repos
- Assumptions/Dependencies:
- Gating behaviors vary across model families; requires validation per target
- Prompt/system-context configuration best practices
- Sector(s): platform SDKs, enterprise chatbot teams, educational tech
- What: For post-norm drafters, vary system prompt length with minimal acceptance loss; for pre-norm, keep prompts short and stable; when using SWA, windows ~1024 tokens suffice for most gains.
- Tools/Products/Workflows:
- Prompt policy templates and automatic length tuning
- Assumptions/Dependencies:
- Performance depends on training-time prompt distributions of the base model
- Task domains benefiting immediately from acceptance-length gains
- Sector(s):
- Healthcare: EHR summarization, clinical note drafting (long-context)
- Finance: report analysis, compliance scanning
- Education: grading assistants, feedback generation
- Software: code completion, repo Q&A
- What: Integrate post-norm drafters to reduce end-to-end latency/cost per response while preserving output correctness (lossless speculative decoding).
- Tools/Products/Workflows:
- Sector-specific pipelines (e.g., document summarizers, repo assistants) with speculative decoding defaults
- Assumptions/Dependencies:
- Speculative decoding configured to be lossless; verifier still governs final outputs
Long-Term Applications
- Generalized drafter designs across architectures
- Sector(s): ML research, platform vendors
- What: Extend post-norm/RMSNorm principles to MTP heads, Hydra, diffusion-based drafters; co-train drafters with verifiers for better stability.
- Tools/Products/Workflows:
- Unified “drafter zoo” with pluggable norm strategies and training pipelines
- Assumptions/Dependencies:
- Requires research into training dynamics and access to pretraining workflows
- Standard APIs to expose/internalize hidden states for drafting
- Sector(s): cloud platforms, inference providers, governance
- What: Standardize interfaces for safe access to internal representations to enable robust drafting across closed/open models.
- Tools/Products/Workflows:
- Inference APIs that allow selective hidden-state export or on-device fusion
- Assumptions/Dependencies:
- Vendor cooperation; security/privacy reviews for exposing internals
- Adaptive runtime controllers for speculation depth and SWA
- Sector(s): MLOps, AIOps
- What: Dynamically tune speculation depth, SWA window, and temperature based on live drift/magnitude signals to maximize acceptance length and minimize compute.
- Tools/Products/Workflows:
- “Speculation controller” service with feedback loops
- Assumptions/Dependencies:
- Lightweight telemetry from serving path; robust control policies
- Security and safety monitoring via drift signatures
- Sector(s): trust & safety, security, policy/compliance
- What: Use unusual drift/magnitude patterns as indicators of prompt injection or template-based attacks; gate responses or trigger fallback modes.
- Tools/Products/Workflows:
- Drift-based anomaly detectors integrated with safety layers
- Assumptions/Dependencies:
- Requires datasets linking drift shifts to adversarial behaviors
- Energy-aware scheduling and carbon accounting
- Sector(s): data center ops, sustainability
- What: Combine post-norm drafters with fewer verifier passes to reduce energy per token; integrate with carbon dashboards and scheduling.
- Tools/Products/Workflows:
- Energy-per-acceptance-length meters; green scheduling policies
- Assumptions/Dependencies:
- Accurate energy instrumentation; acceptance gains translate to energy savings in practice
- Hardware and kernel co-design for post-norm/RMSNorm
- Sector(s): semiconductor, systems software
- What: Optimize kernels for per-step RMSNorm and post-norm placement; fuse operations for throughput; explore quantization schemes resilient to magnitude stability.
- Tools/Products/Workflows:
- Custom CUDA/Triton kernels; accelerator features for norm ops
- Assumptions/Dependencies:
- Vendor toolchain support; workload scale to justify engineering
- On-device assistants and robotics with predictable latency
- Sector(s): mobile, automotive, robotics
- What: Use robust speculative decoding to guarantee stable, low-latency token generation under changing prompts and contexts in interactive settings.
- Tools/Products/Workflows:
- On-device inference stacks with post-norm drafters and SWA
- Assumptions/Dependencies:
- Memory/compute budgets; availability of compact verifiers
- Long-context RAG and streaming applications
- Sector(s): enterprise search, media, research tools
- What: Pair post-norm drafters with retrieval and streaming pipelines to handle dynamic, lengthy contexts (e.g., transcripts, code streams) with high acceptance.
- Tools/Products/Workflows:
- “SWA + RAG” orchestrators; streaming summarization modules
- Assumptions/Dependencies:
- Retrieval quality; coherent chunking to keep useful tokens in the SWA window
- Benchmarks and standards for drafter robustness
- Sector(s): academia, standards bodies
- What: Establish shared benchmarks focusing on template perturbations, long-context regimes, and noise tolerance with acceptance-length metrics and drift diagnostics.
- Tools/Products/Workflows:
- Public robustness suites; leaderboards with drift/magnitude metrics
- Assumptions/Dependencies:
- Community adoption; coverage across model families and sizes
- Scaling to very large models (>120B) and multi-tenant serving
- Sector(s): hyperscalers, enterprise clouds
- What: Validate and adapt post-norm methods for very large verifiers and multi-tenant workloads; exploit larger acceptance gains for fleet-level cost reduction.
- Tools/Products/Workflows:
- Fleet simulators for acceptance-length vs. cost/latency tradeoffs
- Assumptions/Dependencies:
- Access to large-scale models; engineering to amortize overheads
Notes on feasibility across all applications:
- The approach assumes lossless verification remains in place; correctness still depends on the verifier.
- Gains depend on model family and access to hidden states; closed models without internal access may need alternative drafter designs (e.g., MTP co-training).
- Combining gated attention with post-norm can over-regularize attention; evaluate carefully.
- Training data and prompt distributions shape robustness; some benefits may vary with domain fine-tuning.
Glossary
- Acceptance length: Average number of drafted tokens accepted per verification round in speculative decoding. "A key efficiency metric is the acceptance length (), defined as the average number of drafted tokens accepted per verification round."
- Attention drift: Progressive shift of a drafter’s attention from prompt tokens (often a sink) to its own recently generated tokens as speculation proceeds. "We identify a previously-unreported phenomenon we call attention drift:"
- Attention entropy: The entropy of the attention distribution; used to analyze whether attention becomes more or less concentrated. "We also examine whether attention entropy () explains drafter failures."
- Attention sink: A token, usually near sequence start, that attracts disproportionately high attention and stabilizes long-context behavior. "An attention sink \citep{streamingllm} is a token (typically near the start of a sequence) that absorbs disproportionately large attention during inference."
- Autoregressive: A generation setup where each token is predicted based on previously generated tokens. "In the drafting phase, the drafter auto-regressively generates a sequence of candidate future tokens, where is the speculation depth."
- Beginning-of-sequence (BoS) token: A special token marking the start of a sequence, often acting as a sink or anchor. "Is template sensitivity an artifact of attention sinks? To test this, we compared post-norm against a Gated Attention model, which eliminates the attention sink and, thus, the sensitivity to the beginning-of-sequence (BoS) token."
- Cross-entropy loss: Training objective comparing predicted token distributions to targets, measuring prediction error. "The drafter is trained with a token-level cross-entropy loss against the frozen target's predicted distribution,"
- Drafter: A lightweight model that proposes future tokens to be verified by a larger target model in speculative decoding. "the drafter's hidden state magnitude grows monotonically with chain depth,"
- EAGLE-3: A pre-norm, auto-regressive drafter architecture widely used for speculative decoding. "EAGLE-3, our focus, is the dominant auto-regressive drafter design in production engines such as vLLM \cite{vllm} and SGLang \cite{sglang}."
- Fully-connected projection (fc): A learned linear projection used to fuse target hidden states before feeding the drafter. "feed the target's fused internal hidden states through a fully-connected projection (fc in \Cref{fig:postnorm-arch}) into a single pre-norm transformer decoder layer"
- Gated attention: An attention mechanism augmented with learned gates to modulate head contributions, often reducing sink reliance. "Qwen3-Next uses gated attention, applying a per-head sigmoid gate to the SDPA output so that heads can multiplicatively suppress their contribution."
- Hidden-state magnitude: The scale (e.g., RMS) of hidden vectors; its growth across chain depth is linked to drift and instability. "The drafter-generated hidden states grow monotonically with speculation depth."
- LM head: The output projection mapping hidden states to token logits in a LLM. "MTP Heads are auxiliary prediction heads jointly trained with the target model during pretraining, sharing the target's LM head and predicting multiple positions ahead."
- Mixture-of-Experts (MoE): An architecture using multiple expert subnetworks with sparse routing to scale model capacity. "GPT-OSS 20B (sparse MoE thinking)."
- Multi-Token Prediction (MTP) head: An auxiliary head that predicts multiple future tokens jointly or stepwise, often sharing the LM head with the target. "MTP Heads are auxiliary prediction heads jointly trained with the target model during pretraining, sharing the target's LM head and predicting multiple positions ahead."
- Post-norm (post-normalization): Applying normalization after residual additions to stabilize scale across steps. "we introduce a simple architectural modification based on post-normalization (\Cref{fig:into-prepost}) combined with a normalization before hidden-state fusion, that prevents hidden-state magnitude growth and stabilizes the drafting process."
- Pre-norm (pre-normalization): Applying normalization before attention/MLP within each block; common in modern LLMs but can cause scale drift across residual paths. "a single pre-norm transformer decoder layer~\cite{vaswani2017attention} that serves as the drafter"
- Prenorm dilution: The phenomenon where magnitudes accumulate across layers in pre-norm transformers, making later-layer states dominate. "As such, each layer's magnitudes accumulate monotonically through depth (prenorm dilution \cite{attentionresiduals}),"
- Quantization: Reducing numerical precision of model parameters or activations to speed up inference, potentially perturbing hidden states. "such as those induced by verifier quantization or mild distribution shift."
- Rejection sampling: A verification procedure that accepts drafted tokens only if they match samples from the target model’s distribution. "applies rejection sampling against its own token distribution; the longest valid prefix is accepted."
- Residual connection (unnormalized residual path): The skip connection adding inputs to block outputs; unnormalized across drafting steps can cause magnitude growth. "the unnormalized residual connection between speculation steps causes hidden-state magnitudes to grow monotonically with chain depth,"
- RMSNorm: A normalization layer using root-mean-square statistics to normalize activations. "per-hidden-state RMSNorm after capturing target hidden states."
- Scaled Dot-Product Attention (SDPA): The standard attention mechanism computing scaled dot-products between queries and keys. "Qwen3-Next uses gated attention, applying a per-head sigmoid gate to the SDPA output"
- Sliding Window Attention (SWA): Limiting attention to a fixed-size recent window to handle long contexts efficiently. "LLMs have developed various techniques to handle this, one being sliding window attention (SWA), where the model's effective context is a fixed window over the most recent tokens."
- Softmax bias logit: A learnable bias term added to the softmax denominator for each head to modulate attention mass (e.g., “attend to nothing”). "GPT-oss instead introduces a per-head learnable bias logit in the softmax denominator, giving each head an explicit "attend to nothing" option that absorbs excess attention mass."
- Speculative decoding: An inference acceleration technique where a small model drafts tokens that are later verified by a larger model. "Speculative decoding accelerates LLM inference by drafting future tokens with a small model."
- Speculation depth: The number of tokens drafted ahead before verification. "the drafter auto-regressively generates a sequence of candidate future tokens, where is the speculation depth."
- Train-time-test depth (TTT): The maximum drafting depth used during training, affecting generalization to longer chains. "with a fixed number of speculation steps (the train-time-test depth, TTT)."
- Verification phase: The stage where the target model checks drafted tokens in a single pass and accepts the longest matching prefix. "In the verification phase, the target model evaluates the drafted sequence in a single forward pass and applies rejection sampling against its own token distribution;"
Collections
Sign up for free to add this paper to one or more collections.



