✗ Failed on benchmark 2026

Bregman-Projection Polyak Optimizer

Implementation & benchmark of arXiv:2608.17252 — Mirror Polyak and a Primal-Dual Lifting

Usefulness7/10
Difficulty5/10
Novelty7/10

Source paper: Mirror Polyak and a Primal-Dual Lifting arXiv:2608.17252 ⓘ · analyzed Sep 1, 2026

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

Idea description

Replace the Euclidean Polyak step in an optimizer with a mirror-descent step whose length is chosen by projecting onto the current affine lower-bound halfspace in Bregman geometry. This permits entropy geometry for simplex-valued router probabilities, log geometry for positive parameters, and other mirror maps without reducing the method to a norm-based learning-rate rule.

Formulas

$$x_{t+1}=x_t-\alpha_tg(x_t),\qquad \alpha_t=\frac{f(x_t)-f_\star}{\|g(x_t)\|_2^2}.$$
$$D_h(y,x)=h(y)-h(x)-\langle\nabla h(x),y-x\rangle.$$
$$x_{t+1}=\arg\min_{y:\,f(x_t)+\langle g_t,y-x_t\rangle\leq\widehat f_\star}D_h(y,x_t).$$
$$x_{t+1}=\nabla h^{-1}\!\left(\nabla h(x_t)-\lambda_tg_t\right),\qquad \left\langle g_t,x_t-x_{t+1}\right\rangle=\delta_t,\quad \delta_t=[f(x_t)-\widehat f_\star]_+.$$

Mathematical statement

The paper's baseline Polyak update is $$x_{t+1}=x_t-\alpha_t g(x_t),\qquad \alpha_t=\frac{f(x_t)-f_\star}{\|g(x_t)\|_2^2},$$ where $f$ is a convex objective, $g(x_t)\in\partial f(x_t)$ is a subgradient, and $f_\star=\min_x f(x)$. For a differentiable strictly convex mirror map $h$, define the Bregman divergence $$D_h(y,x)=h(y)-h(x)-\langle\nabla h(x),y-x\rangle.$$ At iterate $x_t$, let $\delta_t=f(x_t)-\widehat f_\star$ and let $g_t=
abla f(x_t)$. The affine first-order lower-bound halfspace is $H_t=\{y:f(x_t)+\langle g_t,y-x_t\rangle\leq\widehat f_\star\}$. Mirror Polyak chooses the next point as the Bregman projection $$x_{t+1}=\arg\min_{y\in H_t}D_h(y,x_t).$$ The KKT conditions reduce this to $$x_{t+1}=\nabla h^{-1}(\nabla h(x_t)-\lambda_tg_t),$$ where $\lambda_t\geq0$ satisfies $$\langle g_t,x_t-x_{t+1}\rangle=\delta_t.$$ In Euclidean geometry, $h(x)=\frac{1}{2}\|x\|_2^2$, so $x_{t+1}=x_t-\lambda_tg_t$ and $\lambda_t=\delta_t/\|g_t\|_2^2$, recovering the Polyak rule. The neural-network adaptation uses the safe stochastic gap $\delta_t=[f_t-\widehat f_\star]_+$ and optionally clips $\lambda_t$.

Implementation notes

Integrate this optimizer at the parameter-update stage for a selected tensor, initially a simplex-valued MoE router, positive gate vector, or nonnegative factor in a low-rank layer. Keep the remaining network on AdamW so the first experiment isolates the geometry. For simplex probabilities use negative entropy $h(p)=\sum_i p_i\log p_i$, whose gradient is $\nabla h(p)=\log p+1$ and whose inverse produces $p_i(\lambda)\propto p_{t,i}\exp(-\lambda g_{t,i})$. For positive parameters use $h(w)=\sum_i(w_i\log w_i-w_i)$, giving $w_i(\lambda)=w_{t,i}\exp(-\lambda g_{t,i})$. Pseudocode: compute minibatch loss $f_t$ and gradient $g_t$; set $\delta=[f_t-\widehat f_\star]_+$; if $\delta=0$, skip the update; otherwise define $x(\lambda)=\nabla h^{-1}(\nabla h(x_t)-\lambda g_t)$; solve $\phi(\lambda)=\langle g_t,x_t-x(\lambda)\rangle-\delta=0$ by expanding an upper bracket and then performing 8--12 bisection iterations; update $x_{t+1}=x(\lambda)$ and renormalize simplex tensors. Stop gradients through the root solve. Use a known loss lower bound when available; otherwise maintain an exponential minimum of recent losses and subtract a margin, $\widehat f_\star=\min_{s\leq t}f_s-m$, with $m\in\{0.01,0.05,0.1\}$. The inverse mirror map is analytic, so the only numerical operation is a scalar root solve. First test on CIFAR-10 with a two-layer MLP containing a softmax router or positive gate. Compare against SGD, AdamW, and Euclidean Polyak with matched gradient evaluations. Record training loss versus steps and FLOPs, validation accuracy, gradient spikes, root-failure frequency, clipping frequency, and router entropy. A successful result is faster loss descent or lower final loss at equal updates without exploding entropy or requiring a learning-rate sweep.

Verification

Failed on benchmark

Stage 1 · Toy mechanism gate: Passed ✓

Stage 2 · Mechanism transferred to benchmark: Not reproduced ✗

Stage 2 · Practical benchmark result: Inconclusive

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 an entropy-geometry Bregman-Projection Polyak optimizer for simplex variables with stable analytic mirror mapping and scalar bisection root solving. The mechanism manifested: small-gap lambda/delta matched 1/Var_p(g)=2.782415 within 4e-8 relative error, simultaneous gradient/gap scaling matched the predicted lambda->lambda/a law exactly, fixed-gap local scaling matched 1/a^2 within 1.5e-7, and root feasibility switched at the predicted reachable gap 0.86. In the toy optimization both methods converged to essentially zero loss; Euclidean Polyak was slightly better at step 10, so no practical optimization win was observed.

Agent confidence
9/10
Baseline
Euclidean Polyak with simplex projection: loss 1.9971e-08 at step 10 and 4.9111e-32 at step 120.
Idea
Entropy Bregman Polyak: loss 2.3863e-08 at step 10 and 2.7926e-33 at step 120; root halfspace residual <=1.1e-18. Core predictions: asymptotic lambda/delta observed 2.782415034 vs predicted 2.782415136; scaling ratios 1.0; feasibility succeeded through delta/reachable=0.999999 and failed at 1.001.

Limitations: Only deterministic NumPy simplex optimization was tested, not a neural network, stochastic gradients, AdamW integration, CIFAR-10, wall-clock speed, clipping frequency, router entropy over training, or GPU behavior. The optimization comparison used the exact known optimum and a tiny 8-dimensional quadratic, so it establishes the mechanism rather than a general training advantage.

How to run: python3 experiment.py

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

No significant difference vs. the tuned baseline (+15.8%, p=0.4921, wins 4 / 8 paired seeds).

Benchmark
Tabular regression (Friedman)
Model
mlp_tiny
Paired seeds
8
Baseline mean
12.7702
Idea mean
14.7852
Effect (Δ)
2.015 (+15.8%; negative = idea better)
Wins
4 / 8 paired seeds
p-value
0.4921 (permutation test, 20 000 shuffles)
Smallest detectable effect
±39.1%
Mechanism
Not confirmed ✗
Practical effect
Inconclusive
Baseline tuning
swept over 3 configs
Limitations:

Only the tabular Friedman#1 track and mlp_tiny were tested; CIFAR vision, sequence, and dynamics tracks were not tested. The local implementation used a positive gated MLP rather than a simplex router, and the root safeguard capped difficult positive-geometry steps, so the result does not establish behavior for simplex-valued MoE routing.

How to run: python3 bench_experiment.py

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

Stage 2 — Benchmark latest Failed ✗

Agent confidence: 9/10

Implemented the Bregman-Projection Polyak intervention as a positive-parameter log-geometry update on a gated MLP and evaluated it on the structurally matched tabular Friedman#1 track. Across 8 paired seeds, tuned Adam achieved MSE 12.7702 versus 14.7852 for the idea, with delta +2.0150 and permutation p=0.4921, so there was no significant win. The mechanism signature was not confirmed because root residuals and failures were nontrivial and observed versus predicted scaling disagreed.

Baseline
Adam, lr sweep {0.001, 0.003, 0.01}, best lr=0.01; full 8-seed test MSE mean 12.7702126503, std 1.1689042660
Idea
Positive log-mirror Polyak, same lr sweep, best lr=0.001; full 8-seed test MSE mean 14.7852387428
Paired delta
idea - baseline = +2.0150260925 MSE; 4/8 idea wins; permutation p=0.4921
Signature
observed lambda/delta mean 0.2710435168 versus predicted inverse weighted gradient-square mean 1e12; max root residual 0.1692199707; root failure rate 0.1453125; confirmed=false

Benchmark result

No significant difference vs. the tuned baseline (+15.8%, p=0.4921, wins 4 / 8 paired seeds).

Benchmark
Tabular regression (Friedman)
Model
mlp_tiny
Paired seeds
8
Baseline mean
12.7702
Idea mean
14.7852
Effect (Δ)
2.015 (+15.8%; negative = idea better)
Wins
4 / 8 paired seeds
p-value
0.4921 (permutation test, 20 000 shuffles)
Smallest detectable effect
±39.1%
Mechanism
Not confirmed ✗
Practical effect
Inconclusive
Baseline tuning
swept over 3 configs
Limitations:

Only the tabular Friedman#1 track and mlp_tiny were tested; CIFAR vision, sequence, and dynamics tracks were not tested. The local implementation used a positive gated MLP rather than a simplex router, and the root safeguard capped difficult positive-geometry steps, so the result does not establish behavior for simplex-valued MoE routing.

How to run: python3 bench_experiment.py

Artifacts

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