Papers
Topics
Authors
Recent
Search
2000 character limit reached

Spectral Scaling Laws of Muon

Published 2 Jun 2026 in cs.LG and cs.AI | (2606.04058v2)

Abstract: Orthonormalized update rules have rapidly become a leading choice of optimizer for training LLMs, with recent open-source state-of-the-art models adopting Muon. To keep these updates tractable, Muon performs the orthonormalization with the Newton--Schulz (NS) iteration. Since NS is only approximate, directions with small singular values fail to be orthonormalized. In Muon, NS is applied to the momentum matrix at every step, yet little is known about how the singular value spectrum of these momentum matrices behaves during training, or how that behavior changes with model size. We present the first systematic study of this question. Tracking singular value quantiles of the momentum buffer across layers in models ranging from 77M to 2.8B parameters, we observe a consistent picture: after a short burn-in, the quantiles stabilize at a value determined by the layer type and model size. These stabilization values follow remarkably clean power laws in model size, with layer-dependent exponents. Layers up to mid-late depth scale very mildly with model size $M$ (around $M{-0.25}$), so the standard 5-step NS configuration used at academic scale will continue to orthonormalize them at much larger scales. Some of the late layers, however, scale much more aggressively (up to $M{-0.96}$) and will fall into the NS failure regime at frontier scale unless one uses more NS iterations or better-tuned coefficients. NS iterations are computationally expensive at scale; our laws give practitioners a principled, layer-aware recipe for choosing the minimum NS configuration that still orthonormalizes the directions that matter -- avoiding unnecessary computation without sacrificing update quality.

Summary

  • The paper demonstrates that momentum singular value quantiles stabilize and adhere to layer-dependent power laws across model scales.
  • It employs rank-p ablation studies to evaluate NS accuracy, showing that orthonormalizing the top 50% of directions largely preserves performance.
  • The work provides a principled, layer-aware recipe for NS configuration, optimizing computational efficiency in large-scale training.

Spectral Scaling Laws of Muon: Systematic Characterization and Practical Implications

Introduction

The paper "Spectral Scaling Laws of Muon" (2606.04058) presents a rigorous empirical investigation into the spectral dynamics of the Muon optimizer’s momentum matrices during large-scale LLM training. Muon, an orthonormalized-update optimizer, utilizes a Newton-Schulz (NS) iteration to orthonormalize update directions. The work systematically tracks how singular value quantiles of these matrices evolve during pre-training across model scales ranging from 77M to 2.8B parameters. The authors demonstrate that, post-burn-in, these quantiles stabilize at layer- and size-dependent values, which obey remarkably clean power laws in model size with layer-specific exponents. This spectral behavior is exploited to recommend layer-aware NS configurations for efficient large-scale training, addressing a previously opaque optimization hyperparameter choice.

Muon and Newton-Schulz Approximation Mechanisms

Muon replaces standard gradient updates in weight matrices with approximate orthonormalized updates, realized via NS iteration. For each step, Muon maintains a momentum buffer MtM_t, to which NS is applied, yielding updates of the form Θt+1ΘtηOt+1\Theta_{t+1} \leftarrow \Theta_t - \eta O_{t+1}, where Ot+1O_{t+1} is an orthonormalized update direction.

The NS iteration acts as a sequence of odd polynomials applied to the normalized momentum matrix, pushing each singular value toward unity. However, directions corresponding to sufficiently small singular values are not properly orthonormalized due to NS’s inherent limitation: the polynomial mapping f(σ)f(\sigma) fails to approximate the sign function near zero. Figure 1

Figure 1: NS map f(σ)=p5f(\sigma) = p^{\circ 5} shows strong approximation for moderate σ\sigma but fails for small singular values.

Optimally tuning NS coefficient sequences is critical, with typical configurations using five polynomials (as in NanoGPT) and more accurate compositions (up to ten steps) preferred at frontier scale (e.g., DeepSeek-V4). Each iteration incurs a substantial computational overhead, motivating analysis of which layers and quantiles require precision.

Empirical Characterization: Rank-p Updates and Quantile Dynamics

To clarify which fraction of directions must be accurately orthonormalized, the paper performs controlled ablations using rank-pp orthonormal updates. Only the top pp fraction of singular vectors are preserved in the update; performance is tracked across multiple model scales. Figure 2

Figure 2: Pre-training loss curves for 77M, 160M, and 354M models under rank-pp updates, quantifying performance degradation as pp decreases.

Results reveal that orthonormalizing the top Θt+1ΘtηOt+1\Theta_{t+1} \leftarrow \Theta_t - \eta O_{t+1}0 of directions essentially retains Muon’s efficacy, whereas restricting to just Θt+1ΘtηOt+1\Theta_{t+1} \leftarrow \Theta_t - \eta O_{t+1}1 results in substantial loss inefficiency (approx. Θt+1ΘtηOt+1\Theta_{t+1} \leftarrow \Theta_t - \eta O_{t+1}2 increase in iterations required). These results are robust to initial conditions and not an artifact of early training dynamics. Figure 3

Figure 3: Persistent performance gap for Θt+1ΘtηOt+1\Theta_{t+1} \leftarrow \Theta_t - \eta O_{t+1}3 updates even after warm-starting from full Muon.

This empirical threshold reveals that the practical regime of NS accuracy must cover at least the median quantile of the momentum singular value spectrum for Muon’s benefits to be realized.

Quantile Stabilization and Spectral Distribution Evolution

Quantile tracking (Θt+1ΘtηOt+1\Theta_{t+1} \leftarrow \Theta_t - \eta O_{t+1}4) of normalized singular values across transformer block layers shows a consistent phenomenon: after burn-in, quantiles stabilize at fixed values specific to layer type and model scale. These stabilization values decrease monotonically with model size, and are highly dependent on layer depth, especially in the final blocks. Figure 4

Figure 4: Stabilization of the 50\% normalized singular value quantile across three representative layer types and model sizes.

The stabilized spectra are dominated by a single large singular value, with the bulk of directions clustered near zero, especially in late layers. Figure 5

Figure 5: Full and bulk singular value spectra for 2.8B model momentum matrices at step 1500, illustrating exponential decay and single-value dominance.

Quantile evolution under rank-Θt+1ΘtηOt+1\Theta_{t+1} \leftarrow \Theta_t - \eta O_{t+1}5 updates mirrors validation loss: Θt+1ΘtηOt+1\Theta_{t+1} \leftarrow \Theta_t - \eta O_{t+1}6 closely track Muon’s spectrum, while lower Θt+1ΘtηOt+1\Theta_{t+1} \leftarrow \Theta_t - \eta O_{t+1}7 diverges, confirming the correspondence between spectral dynamics and update quality. Figure 6

Figure 6: Quantile trajectories for the 50\% quantile under rank-Θt+1ΘtηOt+1\Theta_{t+1} \leftarrow \Theta_t - \eta O_{t+1}8 updates, supporting empirical threshold for NS accuracy.

Spectral Scaling Laws and Layer-Dependent Exponents

By averaging stabilizing quantile values post-burn-in and fitting log-log models against size, the authors establish clean power laws of the form Θt+1ΘtηOt+1\Theta_{t+1} \leftarrow \Theta_t - \eta O_{t+1}9, where Ot+1O_{t+1}0 is layer-dependent. Figure 7

Figure 7: Scaling laws for stabilization values of momentum singular value quantiles across depth and model sizes, highlighting layer variation in scaling exponents.

Exponents range from Ot+1O_{t+1}1 in mid-early/mid-late layers (mild scaling) to Ot+1O_{t+1}2 for the final MLP blocks (aggressive scaling). This variance means a uniform NS configuration is inefficient: final layers rapidly fall below NS’s effective regime as Ot+1O_{t+1}3 increases, while earlier layers remain well-served with standard NS settings. Figure 8

Figure 8: Comprehensive scaling laws across quantiles and layer types, reinforcing the necessity of layer-specific NS tuning.

Practical Implications and Frontier-Scale Extrapolation

The scaling laws enable direct extrapolation to frontier-scale training. For example, in a hypothetical 300B-parameter run, mid-late Ot+1O_{t+1}4 projection stabilization remains outside the NanoGPT NS failure regime, while the final Ot+1O_{t+1}5 projection drops below, necessitating the adoption of more accurate NS or custom-tuned coefficient sequences for the latter. This approach yields a principled, layer-aware recipe for optimizer configuration, enabling practitioners to minimize computation without sacrificing update fidelity.

Conclusion

This manuscript provides the first comprehensive analysis of Muon’s momentum spectra scaling behavior. It establishes the stabilization of singular value quantiles, fits layer-dependent power laws, and thereby turns NS configuration from a heuristic into a principled, quantitative hyperparameter. The results demonstrate that mild scaling in early layers permits standard NS settings across several orders of magnitude in model size, but late layers require more precise orthonormalization for effective training at scale. Methodologically, spectral scaling laws could be extended to alternative architectures and optimizers relying on iterative matrix polynomial approximations. Future work includes designing layer-specific NS polynomials and generalizing scaling law analysis to diverse model/optimizer classes.

References

For comprehensive citations, please see the full reference list in (2606.04058).

Paper to Video (Beta)

No one has generated a video about this paper yet.

Whiteboard

No one has generated a whiteboard explanation for this paper yet.

Explain it Like I'm 14

Plain-language summary of “Spectral Scaling Laws of Muon”

Overview: what is this paper about?

This paper studies a popular training trick for LLMs called Muon. Muon changes how the model takes each training step so that updates are more “balanced” and stable. To do that, it uses a fast math procedure (Newton–Schulz, or NS) that tries to make certain update directions equally strong and independent.

But NS is only approximate: it works well for “strong” directions and can miss very “weak” ones. The authors ask: as models get bigger, do these weak directions become a problem, and if so, where in the network? They measure what really happens during training and turn it into simple rules that tell you how accurate NS needs to be in different layers of the model. This helps people save time and money by not over-spending compute where it isn’t needed.

Key questions the paper asks

  • During training, how do the “strengths” of different directions in Muon’s momentum (a running average of gradients) change over time?
  • Do these strengths settle into stable patterns, and how does that depend on model size?
  • How many of the strongest directions do we actually need to “fix” (orthonormalize) to keep Muon working well?
  • Do different layers of the model behave differently, and should we use different NS settings per layer?

How they studied it (in simple terms)

Think of each weight matrix in a neural network layer as a musical equalizer with many sliders:

  • Each slider (a “singular value”) says how loud one independent direction of change is.
  • Muon tries to make important sliders about the same height so no single direction dominates (this is “orthonormalization”).
  • Newton–Schulz (NS) is like repeatedly turning the sliders toward a target position. It’s fast, but tiny sliders may not move enough in a few steps.

What the authors did:

  • They trained GPT-2–style models of different sizes (from 77 million to 2.8 billion parameters).
  • At several points in the network (from early to final layers), they measured the “quantiles” of the slider heights. A quantile is a simple checkpoint in the distribution (for example, the 50% quantile is the median slider height).
  • They watched how these quantiles changed over training and across model sizes.
  • They also ran a test where they only kept the top p% of strongest sliders (like only using the top 50% of directions) to see how much you can safely ignore and still train well.

Helpful translations of terms:

  • Singular values: how strong each independent direction of change is (slider heights).
  • Orthonormalization: making directions independent and similarly scaled so updates are stable and fair.
  • Newton–Schulz steps: a fixed number of “polish passes” that push slider heights toward the target; more steps = more accurate but more expensive.
  • Momentum matrix: a running average of recent gradients; it’s what Muon orthonormalizes.
  • Quantiles: checkpoints that summarize the distribution (e.g., 10%, 25%, 50%, 75%, 90%).

Main findings and why they matter

  • Fast stabilization: After a short “burn-in,” the slider heights (singular value quantiles) settle into stable values for each layer. These stable values depend on the layer type and the size of the model.
  • Clean scaling laws: Those stable values follow simple power laws as models get bigger. In plain terms, if you plot “how strong the median slider is” versus “model size” on a log scale, it’s a straight line. The slope (exponent) depends on the layer.
    • Most layers (from early to mid-late) shrink gently with model size, roughly like M-0.25. This means the standard “5-step” NS is still accurate enough for them even at much larger scales.
    • Some final layers shrink much faster (up to M-0.96). For these, the same 5 steps won’t push small sliders up enough. They will fall into the “NS can’t fix this” zone in huge models unless you use more steps or better-tuned NS coefficients.
  • One big outlier, many tiny values: In each layer’s spectrum, there’s often one very large singular value and a “bulk” of much smaller ones clustered near zero. This is exactly the scenario where NS can miss many directions if you don’t give it enough steps—especially in the late layers as models grow.
  • How many directions must be fixed?: If you orthonormalize about the top half of directions (50%), training stays close to full Muon performance. If you only fix about the top 10%, performance drops a lot. This tells us which quantiles matter most when deciding how accurate NS must be.

Why it matters:

  • NS steps are expensive at huge scale. Knowing exactly which layers need extra accuracy (and which don’t) avoids wasting compute while keeping update quality high.
  • These simple laws give a recipe: per layer, estimate where the median (or top-half) slider height will be at your target model size, and choose the smallest NS configuration that still fixes those directions.

What this means going forward

  • Layer-aware settings: Don’t use the same NS setup everywhere. Most layers can keep the cheaper 5-step setting even in very large models; some final layers should use a more accurate (e.g., 10-step) setting.
  • Practical savings: This avoids unnecessary computation and prevents silent failures in layers where small directions matter most.
  • Bigger picture: Just like LLM loss follows scaling laws, the inner “shape” of optimizer updates (Muon's momentum spectrum) also follows clean scaling laws. That opens the door to smarter, scale-aware optimizer design.
  • Future possibilities: Tune NS polynomials specifically for each layer’s observed spectrum, or study similar laws in other optimizers and architectures (like Mixture-of-Experts).

In short: The paper turns a fuzzy engineering choice—how many NS steps to use in Muon—into a clear, data-driven rule per layer and model size. This helps train bigger models more efficiently without sacrificing stability or quality.

Knowledge Gaps

Knowledge gaps, limitations, and open questions

Below is a concise list of unresolved issues, limitations, and actionable open questions that follow from the paper’s scope, assumptions, and methodology:

  • External validity to other architectures and regimes
    • Do the stabilization and power-law exponents hold for non–GPT-2 architectures (e.g., encoder-decoder Transformers, Mixture-of-Experts, vision models, speech, multimodal) and during fine-tuning/RLHF rather than pretraining?
    • How do depth/width trade-offs (at fixed parameter count) affect the exponents and stabilization behavior?
  • Scale limits and extrapolation risk
    • The laws are fit on 77M–2.8B models and extrapolated to 300B; are there breakpoints or regime changes beyond 2.8B? Obtain empirical validation at intermediate scales (e.g., 7B–70B–100B) to test extrapolation stability.
  • Dataset and objective dependence
    • Results are on FineWeb with next-token prediction; do exponents change with different corpora (code-heavy, multilingual, curated text), data quality/mix, or alternative objectives (causal vs masked LM, instruction tuning)?
    • How sensitive are the spectra to token-to-parameter ratios different from Chinchilla-optimal (undertraining/overtraining)?
  • Optimizer and hyperparameter sensitivity
    • How do the exponents vary with Muon hyperparameters (momentum coefficient μ, weight decay, learning-rate schedule, gradient clipping, update frequency of NS)?
    • What is the effect of batch size, microbatching, and optimizer precision (mixed precision vs full precision) on the momentum spectra?
    • Do alternative Muon variants (e.g., NorMuon, block-periodic orthonormalization) or error-feedback schemes (as in Dion) change the spectral laws?
  • NS configuration and adaptivity
    • The paper infers NS “failure” by comparing quantiles to polynomial maps; it does not measure the actual per-step orthonormalization error. Can we directly measure the fraction of directions insufficiently orthonormalized under different NS configurations during training?
    • Can we design and validate adaptive, layer-wise NS schedules (iterations/coefficients adjusted online) that track moving spectral targets with compute-aware triggers?
    • How close to optimal are the proposed 5- vs 10-step configurations when compute is the constraint? Provide a Pareto frontier (compute vs loss) for layer-specific NS strategies at scale.
  • Rank-p dynamics and self-consistency
    • Rank-p analyses were limited to 77M–354M and require full SVD; the paper notes potential underestimation when NS orthonormalizes <50% of directions. Can we fit separate scaling laws under rank-p updates at larger scales using sketching/streaming SVDs to quantify this deviation?
    • Establish the minimum fraction of directions that must be orthonormalized per layer to preserve downstream performance (not only validation loss), and whether this fraction itself scales with model size or dataset.
  • Temporal dynamics and stability
    • Stabilization is estimated over steps 1300–1500; do quantiles remain stable across the full training horizon (including LR decay), or do they drift as optimization enters late phases?
    • What is the relationship between transient dynamics (burn-in shapes) and training stability events (e.g., loss spikes)? Do impending NS failures correlate with instabilities?
  • Spectral structure and mechanistic understanding
    • Each spectrum has a dominant outlier singular value with an exponential-like bulk near zero. What generates this outlier mechanistically (e.g., shared gradient mode, data anisotropy, curvature alignment), and how does its magnitude scale?
    • Why do all tracked quantiles per layer share a common exponent? Develop a theoretical model (e.g., stochastic optimization with anisotropic noise/curvature) that predicts exponent values and their layer dependence.
  • Shape and aspect-ratio effects
    • Different weight matrices have different aspect ratios; how do matrix shape and head-splitting (per-head vs concatenated projections) affect the spectra and exponents?
  • Normalization choices and NS preconditioning
    • The analysis uses Frobenius normalization before NS. How would results change with spectral-norm normalization or alternative normalizations used in other Muon implementations?
    • Quantify how pre-normalization noise/scale interacts with NS polynomial behavior near zero and the practical failure threshold.
  • Layer coverage and granularity
    • Only four relative-depth checkpoints and six matrices per selected layer were tracked. Do exponents vary within nearby layers, across attention heads, or across blocks with architectural quirks (e.g., rotary embeddings, RMSNorm variants)?
  • Distributed training and sharding effects
    • Real-world deployments shard matrices and may apply NS per shard with periodic sync. How do sharding strategies, communication frequency, and local NS accuracy affect the global spectra and the fitted laws?
  • Robustness and statistical uncertainty
    • Provide variance estimates across random seeds and runs; report confidence intervals and goodness-of-fit diagnostics for the power-law fits to verify statistical robustness.
  • Compute and systems impact
    • The paper motivates layer-wise NS to save compute but does not quantify wall-clock, memory, or energy savings. Deliver end-to-end benchmarks (throughput vs final loss) comparing uniform vs layer-aware NS at scale.
  • Downstream generalization
    • Validation loss is the main metric. Do NS-induced differences in which directions are orthonormalized affect downstream competencies (zero-shot, reasoning, code, long-context), robustness, or calibration differently across layers?
  • Practical scheduling and tool support
    • Provide a concrete procedure and tooling to infer per-layer NS settings online from observed spectra, including safe margins for uncertainty and drift, and guidelines for switching thresholds during training.
  • Interaction with non-matrix parameters
    • Non-matrix parameters (embeddings, LM head, biases) were optimized with AdamW. Does their optimization interact with the momentum spectra of matrix parameters in ways that affect the scaling laws or NS needs?
  • Precision and numerical issues
    • Mixed-precision training and kernel implementations can change effective polynomial maps (due to rounding/accumulation). How sensitive are failure thresholds and exponents to numeric precision and kernel choices?
  • Extensions to other iterative matrix-function optimizers
    • The paper suggests exploring Shampoo/SOAP/COSMOS. What spectral quantities and scaling behaviors are the right analogs for those methods, and do they admit similar layer-dependent power laws?
  • Safety margins for frontier scale
    • What safety factor (in terms of quantile buffer above the NS failure threshold) is needed to avoid rare but catastrophic under-orthonormalization events at frontier scale with distributional shift or curriculum changes?

Practical Applications

Overview

Below are practical, real-world applications that follow from the paper’s findings on layer-wise spectral scaling laws for Muon’s Newton–Schulz (NS) orthonormalization. Each item states where it applies, what tools/workflows/products could emerge, and key assumptions or dependencies.

Immediate Applications

  • Layer-aware NS scheduling to cut compute cost without degrading updates
    • Sectors: Software/AI, cloud training providers, foundation-model labs
    • Tools/products/workflows: A Muon “NS scheduler” that assigns 5-step NS to most layers and 10-step (or better coefficients) only to late layers with aggressive scaling; plug-ins for PyTorch/JAX optimizers; YAML/JSON configs keyed by layer depth
    • Assumptions/dependencies: GPT-2–style models and Muon; per-layer exponents from the paper or quick calibration runs; availability of implementations that support per-layer NS configs
  • Scaling-law–driven hyperparameter transfer for NS (zero-shot config from model size)
    • Sectors: MLOps/AutoML, AI model developers
    • Tools/products/workflows: A “size→NS-config” function that maps target parameter count to the minimum NS step count per layer to orthonormalize ≥50% of directions; integrated into training scripts
    • Assumptions/dependencies: The provided power-law exponents hold for similar architectures/data; NS failure thresholds known for the chosen coefficient set
  • Per-layer spectral monitoring and alerting in training pipelines
    • Sectors: MLOps/observability, cloud training platforms
    • Tools/products/workflows: Lightweight randomized SVD or sketching to log normalized singular-value quantiles (e.g., 0.5, 0.75, 0.9) per layer; dashboards and alerts when quantiles enter NS failure bands
    • Assumptions/dependencies: Efficient quantile estimation (randomized SVD/sketching); small overhead tolerated during training
  • Cost/energy reduction and throughput planning using spectral laws
    • Sectors: Cloud/infra, finance (R&D budgeting), sustainability
    • Tools/products/workflows: Budget calculators that estimate GPU-hours and energy with layer-aware NS; procurement guidance that caps NS steps except where laws predict failure
    • Assumptions/dependencies: Reasonable generalization of exponents to the target stack; accurate energy/GPU utilization models
  • Fast feasibility testing via rank-p proxy experiments
    • Sectors: Academia and industry research
    • Tools/products/workflows: Short “rank-p orthonormal update” ablations (e.g., p=0.5) to sanity-check that orthonormalizing the top ~50% directions preserves performance for a given task/model
    • Assumptions/dependencies: Access to SVD or efficient low-rank approximations for small-scale pilots; proxy-to-full-run correlation holds as observed
  • Distributed/sharded training optimization (focus NS where it matters)
    • Sectors: HPC, distributed training frameworks
    • Tools/products/workflows: Combine Dion/MuonBP-style sharding with layer-aware NS steps; apply heavier NS/comms only on late layers; schedule-aware pipeline stages
    • Assumptions/dependencies: Compatibility with existing distributed optimizers; comms/compute trade-off validated in your cluster
  • Fine-tuning and lab-scale training recipes
    • Sectors: Open-source LLM fine-tuning, education
    • Tools/products/workflows: Practical defaults: 5-step NS for all but last few blocks; 10-step NS for final attention/MLP projections; minimal code changes to modded-NanoGPT/Muon
    • Assumptions/dependencies: Late-layer spectra at small scales resemble those in the paper; quick monitoring to confirm thresholds
  • Sector-wide downstream benefits via cheaper/better training
    • Sectors: Healthcare, education, finance, legal, customer support
    • Tools/products/workflows: Lower pretraining cost yields lower TCO and faster refresh cycles for domain LLMs; quicker turnaround for model variants (e.g., clinical, financial, educational assistants)
    • Assumptions/dependencies: Orthonormalization savings translate to significant end-to-end cost/time reductions in your stack

Long-Term Applications

  • Per-layer learned NS polynomials tuned to empirical spectra
    • Sectors: Optimizer R&D, software/AI
    • Tools/products/workflows: Coefficient search or meta-learning to design odd-polynomial compositions that target each layer’s stabilized spectrum; “NS compiler” that outputs optimal per-layer coefficients
    • Assumptions/dependencies: Reliable online/offline spectrum estimates; robustness across training phases and datasets
  • Dynamic NS curricula over training time
    • Sectors: Training systems, AutoML
    • Tools/products/workflows: Schedules that increase/decrease NS steps as quantiles stabilize; early cheaper NS during burn-in, then focus only on late layers; closed-loop controllers using telemetry
    • Assumptions/dependencies: Stability of the observed burn-in→stabilization behavior across architectures and data regimes
  • Architecture/optimizer co-design to reduce orthonormalization burden
    • Sectors: Model architecture research, software/AI
    • Tools/products/workflows: Design final blocks with forms that yield less aggressive spectral shrinkage (e.g., alternative projection layouts, normalization schemes); hybrid optimizers (e.g., Muon+Shampoo/SOAP on specific layers)
    • Assumptions/dependencies: Measurable link between architectural changes and momentum spectra; no loss in model quality
  • Generalization to other modalities and optimizers
    • Sectors: Vision, speech, robotics; optimizer ecosystem
    • Tools/products/workflows: Spectral scaling studies and NS (or analogous) tuning for ViTs, speech encoders, diffusion backbones, robot policies; analogous laws for Shampoo/COSMOS variants
    • Assumptions/dependencies: Similar stabilization and scaling behavior in non-text tasks and other optimizers
  • Hardware–software co-design for fast orthonormalization
    • Sectors: Semiconductors, accelerator vendors, hyperscalers
    • Tools/products/workflows: Kernel/hardware primitives optimized for repeated odd-polynomial matrix maps and batched Gram-matrix multiplications; on-die accelerators for polar-decomposition-like updates
    • Assumptions/dependencies: Sufficient demand and predictable polynomial structures; standardization of NS kernels across frameworks
  • Standards and policy for optimizer transparency and sustainability
    • Sectors: Policy, public funding agencies, ESG reporting
    • Tools/products/workflows: Guidelines requiring reporting of per-layer optimizer compute and energy; best-practice checklists to use layer-aware NS where applicable; procurement language for public AI projects
    • Assumptions/dependencies: Community acceptance; accessible measurement and verification tools
  • Automated “AutoMuon” services in the cloud
    • Sectors: Cloud platforms, MLOps SaaS
    • Tools/products/workflows: Managed services that infer per-layer NS configs from model specs; continuous adaptation during training based on spectral telemetry; integration with job schedulers
    • Assumptions/dependencies: Secure and low-overhead telemetry; broad compatibility with user models and distributed setups
  • Domain-specific training pipelines with lower TCO
    • Sectors: Healthcare, finance, education, energy, robotics
    • Tools/products/workflows: Turnkey pipelines that embed layer-aware NS for vertical models (e.g., clinical summarization, financial analytics), enabling more frequent retraining/adaptation within fixed budgets
    • Assumptions/dependencies: Validation that savings persist for domain data and regulatory constraints; governance for optimizer changes

Notes on Feasibility, Assumptions, and Dependencies

  • Scope of evidence: The laws are fit on GPT-2–style LMs trained with Muon. Exponents and thresholds may shift for other architectures (e.g., MoE, encoder–decoder), modalities, or datasets.
  • NS failure thresholds: Depend on the specific polynomial coefficients and composition depth; teams must map their chosen NS configuration’s “failure band” to the observed quantiles.
  • Measurement overhead: Tracking singular-value quantiles adds compute; use randomized SVD/sketching to keep overhead low.
  • Distributed constraints: Sharded models introduce communication/computation trade-offs; integration with Dion/MuonBP-like methods may be needed.
  • Target fraction: Results suggest orthonormalizing roughly the top 50% of directions preserves most of Muon’s benefit; more aggressive pruning (e.g., 10–25%) degrades token efficiency.
  • Stability over training: Quantiles stabilize after burn-in in the reported setups; dynamic schedules should verify this behavior online before reducing NS effort.

Glossary

  • AdamW: A variant of Adam optimizer with decoupled weight decay commonly used for training deep networks. "AdamW \citep{adamw_2019,adam_2015} has long been the standard optimizer for training LLMs"
  • Chinchilla-optimal: A scaling rule prescribing token budgets that are compute-optimal for a given model size. "each for a Chinchilla-optimal number of tokens"
  • compute efficiency: The amount of model improvement per unit of computational cost. "Muon achieves twice the compute efficiency of AdamW."
  • compute-optimal token-to-parameter ratios: Ratios of training tokens to parameters that minimize compute for a target performance. "refined these relationships into compute-optimal token-to-parameter ratios"
  • error feedback: A technique that accumulates and reinjects approximation residuals to compensate for low-rank or compressed updates. "Dion uses \emph{error feedback}, accumulating the residual of the low-rank approximation back into the momentum buffer,"
  • exponents (layer-dependent): Power-law exponents that characterize how a quantity scales with model size and differ across layers. "with layer-dependent exponents."
  • Frobenius-normalized: Scaled by the Frobenius norm so singular values lie in [0,1]. "the Frobenius-normalized momentum matrix"
  • frontier scale: The largest, cutting-edge model scales where training is most expensive and challenging. "will fall into the NS failure regime at frontier scale"
  • learning rate grafting: A heuristic that transfers learning rate behavior across methods or components. "requires heuristics such as learning rate grafting~\citep{agarwal2020disentangling}"
  • learning-rate transfer: The property that good learning rates transfer across scales or settings. "leveraging Muon's known learning-rate transfer property."
  • log-log linear relationship: A straight-line relationship when both axes are on logarithmic scales, indicating a power law. "a remarkably clean log-log linear relationship"
  • matrix-preconditioned optimizers: Optimizers that transform gradients via matrix-based conditioners to accelerate convergence. "A parallel line of work explores matrix-preconditioned optimizers for deep learning"
  • Mixture-of-Experts models: Architectures that route inputs to specialized subnetworks (experts). "Mixture-of-Experts models"
  • momentum buffer: The state that accumulates past gradients to form momentum for updates. "At each step Muon maintains a momentum buffer MtM_t"
  • momentum matrix: The matrix-shaped momentum state associated with a weight matrix, used to compute updates. "NS is applied to the momentum matrix at every step"
  • Newton--Schulz (NS) iteration: An iterative polynomial method used to approximate matrix functions like orthonormalization. "Muon performs the orthonormalization with the Newton--Schulz (NS) iteration."
  • NS failure regime: The range of small singular values where NS cannot adequately orthonormalize directions. "will fall into the NS failure regime at frontier scale"
  • odd polynomial: A polynomial containing only odd powers, used in NS to map singular values toward 1. "which repeatedly applies an odd polynomial to push each singular value toward $1$."
  • orthonormal factor: The orthogonal component U VT in a matrix’s polar decomposition. "recovering the orthonormal factor in the polar decomposition of AA."
  • orthonormalization: Transforming a matrix so its columns (or rows) are orthonormal. "Exact orthonormalization is expensive for large matrices"
  • orthonormalized-update optimizers: Optimizers that modify raw updates to be (approximately) orthonormal before applying them. "orthonormalized-update optimizers such as Muon"
  • outlier singular value: A singular value much larger than the rest of the spectrum. "each spectrum is dominated by a single outlier singular value"
  • polar decomposition: Factorization of a matrix into an orthonormal factor and a positive semidefinite factor. "recovering the orthonormal factor in the polar decomposition of AA."
  • power laws: Relationships where a quantity scales as a power of another, often seen as straight lines in log-log plots. "follow remarkably clean power laws in model size"
  • preconditioner: A matrix or transformation applied to gradients/updates to improve optimization dynamics. "by adaptively updating the preconditioner."
  • rank-pp orthonormal updates: Updates that keep only the top p fraction of singular directions when forming the orthonormalized step. "we introduce rank-pp orthonormal updates"
  • scaling laws: Empirical power-law relations describing how metrics change with model size, data, or compute. "Scaling laws were pioneered by \citet{kaplan2020scaling}"
  • sharded: Partitioned across devices to distribute memory and computation. "when weight matrices are sharded across devices."
  • sign function: A function mapping positive inputs to +1 (and zero to 0 here), used as the target of NS on singular values. "approximate the sign function on (0,1](0,1]"
  • spectral norm: The largest singular value of a matrix, used to define a notion of steepest descent. "steepest descent under the spectral norm"
  • SVD (singular value decomposition): Factorization A = U S VT that expresses a matrix via its singular vectors and singular values. "Recall that for any matrix with SVD A=USVA = U S V^\top"
  • stabilization values: Post–burn-in steady values that tracked statistics (e.g., quantiles) converge to during training. "These stabilization values follow remarkably clean power laws in model size"
  • singular value quantiles: Specific percentiles of a matrix’s singular value spectrum used to track its distribution. "Tracking singular value quantiles of the momentum buffer across layers"

Open Problems

We haven't generated a list of open problems mentioned in this paper yet.

Collections

Sign up for free to add this paper to one or more collections.

Tweets

Sign up for free to view the 2 tweets with 52 likes about this paper.