△ Mechanism confirmed, baseline not beaten 2026

Smooth Spectral Muon

Implementation & benchmark of arXiv:2608.01911 — A Continuous-Time Analysis of Smoothed Matrix-Polar Spectral Gradient Flows for Muon-Type Optimization

Usefulness7/10
Difficulty5/10
Novelty4/10

Source paper: A Continuous-Time Analysis of Smoothed Matrix-Polar Spectral Gradient Flows for Muon-Type Optimization arXiv:2608.01911 ⓘ · analyzed Aug 31, 2026

AI-generated research hypothesis, automatically tested. Not peer-reviewed.

Idea description

Replace the exact matrix-polar normalization in Muon with the smoothed feedback \(h_\epsilon(M)=M(M^\top M+\epsilon I)^{-1/2}\). This retains singular-vector-aware updates and approximately unit-normalizes dominant spectral modes, but avoids unstable behavior when the momentum matrix is rank deficient or has tiny singular values.

Formulas

$$M_k=\beta M_{k-1}+\nabla f(W_k),\qquad W_{k+1}=W_k-\eta\,\operatorname{Polar}(M_k),\qquad \operatorname{Polar}(M)=M(M^\top M)^{-1/2}.$$
$$h_\epsilon(Z)=Z(Z^\top Z+\epsilon I)^{-1/2}.$$
$$Z=U\operatorname{diag}(\sigma_i)V^\top\quad\Longrightarrow\quad h_\epsilon(Z)=U\operatorname{diag}\left(\frac{\sigma_i}{\sqrt{\sigma_i^2+\epsilon}}\right)V^\top.$$
$$\Phi_\epsilon(Z)=\operatorname{Tr}\left[(Z^\top Z+\epsilon I)^{1/2}-\sqrt{\epsilon}I\right],\qquad \nabla\Phi_\epsilon(Z)=h_\epsilon(Z).$$

Mathematical statement

The paper defines the smoothed matrix-polar feedback for a matrix \(Z\in\mathbb{R}^{m\times n}\) and \(\epsilon>0\) as \(h_\epsilon(Z)=Z(Z^\top Z+\epsilon I)^{-1/2}\). If \(Z=U\operatorname{diag}(\sigma_i)V^\top\) is an SVD, then \(h_\epsilon(Z)=U\operatorname{diag}(\sigma_i/\sqrt{\sigma_i^2+\epsilon})V^\top\), so each singular value is transformed by \(r_\epsilon(\sigma)=\sigma/\sqrt{\sigma^2+\epsilon}\): it is approximately \(1\) for \(\sigma\gg\sqrt{\epsilon}\) and approximately \(\sigma/\sqrt{\epsilon}\) near zero. The response is bounded by \(0\le r_\epsilon(\sigma)<1\), preventing arbitrarily large normalized components. The direction is the gradient of the spectral energy \(\Phi_\epsilon(Z)=\operatorname{Tr}[(Z^\top Z+\epsilon I)^{1/2}-\sqrt{\epsilon}I]\), namely \(\nabla\Phi_\epsilon(Z)=h_\epsilon(Z)\). In the optimizer, \(Z=M_k\) is the momentum matrix, \(M_k\) is the exponentially averaged gradient, \(\eta\) is the learning rate, and \(\beta\) is momentum.

Implementation notes

Integrate this into the optimizer update for every trainable two-dimensional weight matrix, especially transformer projection matrices and MLP weights; leave embeddings, biases, and layer-normalization vectors on AdamW or ordinary SGD. Maintain one momentum matrix per selected weight. At each training step, compute the gradient G, update M <- beta*M + G, and replace the exact polar update by a smoothed spectral update. A numerically robust implementation is: (1) compute the thin SVD M=U diag(s) V^T; (2) form s_scaled=s/sqrt(s*s+epsilon); (3) D=U diag(s_scaled) V^T; (4) W <- W - eta*D. For large matrices, benchmark this against Newton-Schulz polar iteration, but use the exact SVD version first as the correctness reference. Epsilon is a scalar or per-layer value; start with epsilon=c times the squared RMS singular value, where RMS_s=(mean_i s_i^2)^(1/2) and c is in {1e-4,1e-3,1e-2}, then optionally EMA-smooth RMS_s across steps. The paper-derived computation is the singular response s_scaled=s/sqrt(s^2+epsilon) and the potential Phi_epsilon; empirical choices are beta, eta, c, and whether epsilon is fixed or adaptive. Log the minimum singular value, maximum update singular value, update Frobenius norm, and Phi_epsilon(M). First test on a 12-layer small Transformer language model such as GPT-2-small or a 100M-parameter decoder on WikiText-103, comparing AdamW, exact Muon, and smoothed Muon at matched optimizer FLOPs. The initial success signal is fewer NaNs and less update-norm variance on deliberately small batches or low-rank gradient settings, followed by lower validation perplexity or faster training-loss reduction at equal steps. Also test epsilon ablations to verify that large epsilon improves stability but excessive epsilon harms convergence by making the update too linear.

Verification

Mechanism confirmed, baseline not beaten

Stage 1 · Toy mechanism gate: Passed ✓

Stage 2 · Mechanism transferred to benchmark: Confirmed ✓

Stage 2 · Practical benchmark result: Significantly worse ✗

Methodology: 8 paired seeds, permutation test (p<0.05) against a learning-rate-tuned baseline. How verification works

Stage 1 — Mechanism check agent confidence 9/10

Built and numerically verified Smooth Spectral Muon with a thin-SVD implementation, spectral potential, finite-difference gradient check, and toy low-rank matrix regression. The predicted transition and asymptotic scaling matched essentially exactly: transition at sigma/sqrt(epsilon)=1, small-mode ratio 0.999999995, large-mode asymptotic 1.000000016, bounded response below 1, and matrix spectral error 0. The smoothed optimizer retained Muon-like loss while providing finite update variability, but did not beat SGD, so this confirms the mechanism rather than an overall training win.

Agent confidence
9/10
Baseline
Toy SGD final loss 2.8356e-05, best loss 3.7964e-06, update-norm CV 0.4468; exact Muon final loss 1.8187e-04, best loss 1.2352e-04, update-norm CV 3.0e-16.
Idea
Smooth Muon with c=1e-3 final loss 1.6260e-04, best loss 1.2357e-04, update-norm CV 0.0193; finite-difference gradient error 2.95e-11; predicted response transition observed exactly at ratio 1.0 with response 0.70710678.

Limitations: Only a small NumPy low-rank matrix-regression toy was tested. No Transformer, language modeling, WikiText, AdamW, CUDA benchmark, matched-FLOP study, NaN stress test, or multi-seed statistical evaluation was performed.

How to run: python3 smooth_spectral_muon.py

Stage 2 — Benchmark vs. tuned baseline (arXiv:2608.01911)

Significantly WORSE than the tuned baseline (+212.3%, p=0.0081, wins 0 / 8 paired seeds).

Benchmark
Tabular regression (Friedman)
Model
mlp_tiny
Paired seeds
8
Baseline mean
7.0048
Idea mean
21.8775
Effect (Δ)
14.8727 (+212.3%; negative = idea better)
Wins
0 / 8 paired seeds
p-value
0.0081 (permutation test, 20 000 shuffles)
Smallest detectable effect
±16.2%
Mechanism
Confirmed ✓
Practical effect
Hurts
Baseline tuning
swept over 6 configs
Limitations:

Only the mandated tabular optimizer track was tested; no vision, sequence, dynamics, transformer, large-scale language-model, exact-Muon, matched-FLOP, NaN-stress, or epsilon-ablation benchmark was run.

How to run: python3 stage2_bench.py

Verdict computed by deterministic test code from paired-seed statistics — not by the language model.

Stage 2 — Benchmark latest Failed ✗

Agent confidence: 10/10

Smooth Spectral Muon was implemented as a custom optimizer loop and evaluated on the registered built-in tabular Friedman#1 track with the shared mlp_tiny architecture. The trained-model mechanism signature was confirmed quantitatively, but tuned Adam was significantly better: Smooth Muon mean test MSE 21.8775 versus Adam 7.0048, paired delta +14.8727, permutation p=0.0081. Therefore the benchmark verdict is idea worse (significant), and the system did not work.

Baseline
Adam; best lr=0.006, beta1=0.85, weight_decay=0; full 8-seed mean test MSE 7.004796803, std 0.373929317
Idea
Smooth Muon; best lr=0.006, beta=0.9, c=0.001; full 8-seed mean test MSE 21.877507687, std 1.497784459; paired delta +14.872710884; p=0.0081

Benchmark result

Significantly WORSE than the tuned baseline (+212.3%, p=0.0081, wins 0 / 8 paired seeds).

Benchmark
Tabular regression (Friedman)
Model
mlp_tiny
Paired seeds
8
Baseline mean
7.0048
Idea mean
21.8775
Effect (Δ)
14.8727 (+212.3%; negative = idea better)
Wins
0 / 8 paired seeds
p-value
0.0081 (permutation test, 20 000 shuffles)
Smallest detectable effect
±16.2%
Mechanism
Confirmed ✓
Practical effect
Hurts
Baseline tuning
swept over 6 configs
Limitations:

Only the mandated tabular optimizer track was tested; no vision, sequence, dynamics, transformer, large-scale language-model, exact-Muon, matched-FLOP, NaN-stress, or epsilon-ablation benchmark was run.

How to run: python3 stage2_bench.py

Artifacts

Implementation overview ⬇ Download all as ZIP 6 files · code, reports and structured results