Does mirror descent include ordinary gradient descent?

Yes. A quadratic Euclidean mirror map recovers the usual projected gradient update under the corresponding setting.

Why can its updates be multiplicative?

Negative-entropy geometry on the simplex leads to exponential reweighting followed by normalization.

Is the Bregman divergence always symmetric?

No. Its direction is part of the update definition and should not be reversed casually.

AI Glossary / Mathematics and optimization / Advanced

Mirror descent

Definition

Mirror descent is an optimization method that generalizes gradient descent by using a chosen geometry to control how far each update moves. It balances a local linear approximation of the objective against a Bregman divergence from the current point. An appropriate geometry can make updates better suited to the problem's feasible set.

What it means

Ordinary gradient descent measures movement using squared Euclidean distance. Mirror descent allows another distance-like measure generated by a convex function, often called a mirror map or distance-generating function.

This is useful when the variables have a structure such as nonnegative weights that sum to one. A suitable mirror map can produce multiplicative rather than additive changes. The choice is mathematical, not metaphorical: it specifies how movement is penalized. Bregman divergence is not generally a metric, because symmetry and the triangle inequality need not hold.

How it works

At the current point x_k, obtain a gradient or an appropriate subgradient g_k. Choose a step size eta>0 and a differentiable, suitably convex function h. Its Bregman divergence is D_h(x,y)=h(x)−h(y)−⟨gradient h(y),x−y⟩.

The next iterate minimizes ⟨g_k,x⟩+D_h(x,x_k)/eta over the feasible set. The first term favors an improving direction in the local linear model; the second discourages an excessive move under the chosen geometry.

For h(x)=‖x‖²/2, the divergence is ‖x−y‖²/2, recovering projected gradient or subgradient descent. On a probability simplex, negative entropy h(x)=sum_i x_i log x_i produces a multiplicative update followed by normalization, starting from positive coordinates. Convergence results require conditions on the objective, mirror map, gradients, and step sizes; geometry alone is not a universal performance guarantee.

Three practical examples

1. Mixture weighting: optimize nonnegative component weights that must sum to one, using a geometry natural to probability-like vectors.

2. Online learning: update weights over a set of alternatives in response to observed losses, under a specified mirror-descent or related multiplicative-weights formulation.

3. Constrained optimization research: compare Euclidean and non-Euclidean updates when the feasible region and gradient bounds favor different geometries.

Think of it this way

Think of taking steps on a map whose scale changes with the kind of movement being measured. A step that is small under one geometry may be substantial under another, so the movement rule changes accordingly.

The analogy does not mean the algorithm changes the underlying business objective arbitrarily. It changes how local progress is balanced against movement. Nor is mirror descent automatically faster simply because its geometry is different; that depends on the problem and assumptions.

Worked example

Optimize a linear objective f(x)=0×x_1+ln(3)×x_2 on the two-component simplex x_1+x_2=1, with nonnegative coordinates. Start at x=(1/2,1/2), use negative entropy and eta=1. The gradient is g=(0,ln(3)).

The unnormalized multiplicative weights are x_i exp(−g_i). They are (1/2)×1=1/2 and (1/2)×(1/3)=1/6. Their sum is 2/3, so normalizing gives the next iterate (3/4,1/4).

The objective drops from ln(3)/2, approximately 0.5493, to ln(3)/4, approximately 0.2747. The new vector remains positive and sums to one. Repeating the same step gives unnormalized values 3/4 and 1/12, which normalize to (0.9,0.1).

After k steps, the second weight is 1/(1+3^k), approaching zero. The boundary optimum is (1,0), with objective zero, but positive initialization and finite multiplicative updates do not reach it exactly in finitely many steps here. This illustrates both the update and its limiting behavior; it is not a general convergence proof for arbitrary mirror-descent problems.

Illustrative case study

Fictional case: an analytics team combines several forecast components using nonnegative weights that total one. Its engineers compare a Euclidean projected update with an entropy-based mirror update.

They verify that each method solves the intended constrained objective and examine validation error, numerical behavior, and sensitivity to initialization. The team also checks whether weights approaching zero should remain able to recover. It selects the method based on the actual evaluation rather than assuming that multiplicative updates are inherently better. The simplex geometry informs the implementation but does not determine which forecast components are useful.

Common misconceptions and mistakes

Do not call every Bregman divergence a distance metric. Its argument order matters because it is generally asymmetric. Do not omit the one-half factor when deriving Euclidean divergence from h(x)=‖x‖²/2.

For entropy-based updates, zero coordinates and logarithms require deliberate handling. An exact zero can remain zero under a multiplicative rule. Also distinguish the original objective from the local linearized subproblem: mirror descent is not generally minimizing the original objective exactly at each iteration. Step sizes and assumptions still matter.

Business use

Mirror descent can help teams reason about optimization when variables represent allocations, distributions, or other structured quantities. It supplies a principled way to match the update geometry to that structure.

For an implementation review, specify the objective, feasible set, mirror map, initialization, and step-size policy. Confirm that the update respects the intended constraints and that numerical safeguards do not silently change the algorithm. Compare final quality and computational cost under realistic conditions rather than relying only on the elegance of the update formula.

Check your understanding

Starting from equal weights, one component has a larger gradient value in an entropy-based minimization step. Does it receive a larger or smaller multiplicative factor?

Answer: A smaller factor, because the update uses exp(−eta×gradient). The weights are then normalized together.

Related terms

Learn next

derive the Euclidean special case and the entropy-based simplex update from the same minimization rule. Then examine how initialization, boundary behavior, and gradient bounds affect the choice of geometry.

Sources

Boyd, Duchi, and Pilanci, Mirror Descent and Variable Metric Methods, standard setups and negative-entropy sections: https://web.stanford.edu/class/ee364b/lectures/mirror_descent_slides.pdf . Aalto Dictionary of Machine Learning: https://aaltodictionaryofml.github.io/ADictML_Main.pdf . Relevant update formulas were read. The Euclidean one-half factor is retained explicitly; simplex calculations are original.

Previous: Mipmap Next: Mirrorless