Entropy regularization shows up in almost every policy gradient codebase, and the standard explanation is exploration: a random policy keeps trying things. This paper asks what that means for the optimization itself. A trick like entropy can only help in two ways: it makes the gradient estimate less noisy, or it changes the objective being climbed. So the authors remove the noise entirely, with exact gradients in a small gridworld, and entropy still helps. Their answer is that a more random policy smooths the landscape. Flat spots get a slope, valleys between solutions fill in, and the curvature stops swinging so wildly that only tiny learning rates are safe.

It's an analysis paper: no new algorithm, a cheap probe for gradient and curvature, and a set of qualitative experiments. The probe runs on second-order calculus, which is where most of my time went, so that part is written out in full. My notes are on arXiv v5.

Setup

  • Gridworld (exact gradients): a 5×5 grid, starting top-left, with a reward of 4.5 in the top-right corner and 5.0 in the bottom-left. The policy is a softmax, , over four actions with one-hot states, so it's effectively tabular. The dynamics are known, so the gradient is computed exactly and there's no sampling noise at all. There are two local optima: always go right () or always go down (). The objective with no entropy bonus, , is called the true objective.
  • MuJoCo (sampled gradients): Hopper, Walker2d, and HalfCheetah with a Gaussian policy whose mean is linear, , and whose standard deviation is fixed. A Gaussian's entropy depends only on , so is the entropy knob, and is the true objective. Gradients come from REINFORCE with 128 trajectories per batch and a batch-average baseline. The large batches keep the variance-reduction effect of a larger out of the comparison, and performance is always evaluated deterministically. Learning rates are tuned separately for each , with five seeds each.
  • Landscape probes: straight-line interpolation between two parameter vectors, and the random-perturbation method below, with about 1000 directions per parameter vector and 512 rollouts per evaluation.

Background: Jacobian, Hessian, eigenvalues

The probe is a second-order Taylor expansion in many dimensions. This is the calculus I needed straight before Section 2.1.

Start with one input. For at , the slope is and the bend is . Together they give the first- and second-order predictions:

For the second one is exact: . Everything below generalizes slope and bend to many inputs.

The Jacobian is a table of slopes. For outputs and inputs , it's the matrix whose row holds the slopes of :

Take a rectangle with inputs width and height , and two outputs, area and perimeter :

Its use is prediction: , with . Growing both sides of a 3×2 rectangle by 0.1 gives , so the area comes out at about 6.5 (the true value is 6.51) and the perimeter at 10.4, exactly, because is linear.

The gradient is the Jacobian of a single output, written as a column: .

The Hessian is every second derivative of a single output, an matrix with :

Mixed partials don't depend on order, so is symmetric. For the area,

and the second-order prediction is

That recovers the missing 0.01 exactly: , the corner piece of . The short version: the Jacobian is slope, the Hessian is bend.

Eigenvectors are the directions a matrix doesn't turn. A matrix takes an arrow in and gives an arrow out, usually pointing somewhere new. For a few special directions it only stretches, shrinks, or flips the arrow: , the same arrow times . For example,

The first arrow gets turned. The second comes back 3 times longer, so is an eigenvector with eigenvalue 3, and comes back unchanged, with eigenvalue 1.

Eigenvalues are the extreme bends. That happens to be the Hessian of . The bend along a unit direction is , and for a symmetric with orthonormal eigenvectors , it's a weighted average of the eigenvalues:

So every direction's bend lies between and , reaching them only along the eigenvectors. For that's 3 along , 1 along , and 2 along , an even mix of the two. Where the gradient is zero, the signs classify the point: all eigenvalues negative is a local maximum, all positive is a local minimum, mixed signs is a saddle (up in some directions, down in others), and zero eigenvalues mark flat directions.

The random-perturbation probe

Plotting the objective along one straight line (Section 2.1.1) has a known weakness: two optima that look separated by a valley on the line can be joined by a curved path of equal value. So the paper adds a local probe (Section 2.1.2) that classifies a point as a local optimum, saddle, or flat region, and tracks curvature during training.

Sample directions at random. The paper says "on the unit ball," but the unit ball is every vector with , and a direction has length exactly 1, so it's really the unit sphere, the surface of the ball. Step both ways from by some and record the change:

Each direction becomes one dot, with on the x-axis and on the y-axis (dropping the extra sub- and superscripts from here on). To read the dots, expand to second order around with steps :

The slope term flips sign with the step and the bend term doesn't, so subtracting keeps only the slope and adding keeps only the bend:

These are central finite differences along . On the scatter plot, a dot's position along the diagonal is the slope in that direction, and its position along is the bend. A histogram of (2) over many directions is the curvature spectrum, which by the eigenvalue fact above lives between and .

What the dots doPoint typeIn Hessian terms
Both negative for every Local maximumAll eigenvalues negative
Both positive for every Local minimumAll eigenvalues positive
Both negative for some , both positive for othersSaddle pointEigenvalues of both signs
Almost linear regionSlope, but little bend
Almost flat regionAlmost no slope or bend

With finitely many directions, these are probabilities rather than certainties.

The paper's toy, checked by hand. The running example is . It's never positive and equals 0 on the whole curve , so its maxima form a curve, a manifold, and there's a saddle at the origin. The gradient is , which vanishes at both. The Hessian is

and at the two points the paper probes,

At the origin the eigenvalues are : up along , down along , a saddle. At the maximum they're and . The zero eigenvalue's eigenvector is , which is exactly the tangent to at that point, so the flat direction runs along the manifold of maxima while the steep one, , cuts across it. That's what Figures 1 and 2 show: at the maximum the dots sit in the bottom-left with some reaching zero and the curvatures are zero or negative, while at the saddle the curvatures come in both signs.

Policy optimization and the entropy bonus

is expected return, the book's , in the notation of Nachum et al.'s path consistency learning paper, which shares two authors with this one. Splitting the expectation into the start state and everything after it turns it into the value of the start state, averaged over where you start:

Here is a whole trajectory, since is taken by the entropy temperature, and the sum starting at with is an indexing quirk, so read it as the usual discounted return. The gradient is the policy gradient theorem, written with integrals so it covers continuous states and actions:

With sums instead of integrals, that's the book's , which keeps the same form in the episodic and continuing cases.

Entropy is the expected negative log-probability of the policy's own actions: large when the policy spreads out, 0 when it always picks one action. The paper adds it to the reward at every step, weighted by a temperature :

which gives

Entropy regularization comes in two flavors that look alike:

  • Bonus in the loss (A3C, PPO): add at each sampled state, with the return built from plain rewards. Entropy only counts at the current state.
  • Bonus in the reward (maximum-entropy RL, SAC, this paper): is a soft value that includes all future entropy, so the agent is also paid for heading toward states where it can stay random. SAC calls the temperature .

In expectation, A3C's update has the same shape as (3), and the only real difference is which . The term sits inside only for tidiness, since it doesn't depend on .

The paper's framing comes from one observation. In Q-learning, exploration is a separate module like ε-greedy, but a policy gradient method explores with the very policy it's optimizing, so any change to the policy is a change to the objective. A trick like entropy can therefore affect learning in only two ways: it reduces noise in the gradient estimate, or it changes the landscape. Changing also changes , which states get visited, but the gradient never differentiates through directly; the policy gradient theorem folds that effect into .

Gridworld: hard even with the exact gradient

With exact gradients, about 25% of random initializations still end at the worse corner. Sampling noise can't be the cause, so the landscape is.

Figure 4 shows why. At , every sampled direction lands at the origin, with a negligible gradient and slightly negative bend (4a, black): a plateau with nothing to follow. On the straight line from to , the true objective has two plateaus with a sharp valley between them (4b, black). The valley matters not because you're in it but because it sits between you and the better solution. Gradient ascent only moves uphill and can't see what's on the other side.

Adding entropy and decaying it during training drops the rate of bad solutions to zero (Figure S5), and Figure 4 shows two changes. With , the dots at spread along (4a, blue and orange), so every direction now has an uphill side and it's no longer a flat solution. Along the interpolation, entropy alone shrinks the valley (blue), and entropy plus a more random policy nearly erases it (orange).

"A more random policy" is the Mix knob. The evaluated policy is , so every action keeps at least probability; with four actions and Mix = 0.8, that's 20% each. rewards randomness, while Mix forces it.

One thing tripped me up in 4a: orange isn't better than blue there, just tighter, and the caption groups the two together. With Mix = 0.8, controls only 20% of the policy, so any step in moves the objective less. Orange's real advantage is in 4b.

MuJoCo: more randomness, smoother objective

Here plays the role that and Mix played in the gridworld.

Faster learning. Higher learns faster in all three tasks, and in Hopper and Walker2d the final reward is 2 to 8 times that of (Figure 5). It isn't a clean ranking, though. beats in Hopper and HalfCheetah, and in HalfCheetah isn't the worst. The authors only claim the rough trend.

Why faster: steadier curvature. The clue is the learning rate. In Hopper and Walker2d the best constant rate grows with , ten times larger at than at . The safe step size depends on the bend, and a constant rate has to survive the sharpest bend along the way, like driving at one fixed speed on a road with a single hairpin turn. Rescaling the parameters can't fully explain it, since the reward also climbs faster at higher . Figure 6 measures the bend in the best improvement direction during training: for it swings down to around and back, and for it stays in a narrow band. HalfCheetah's swings barely change with , which fits its weak response.

More randomness allowing bigger steps felt backwards to me at first. It makes sense once you see that a random policy's objective averages reward over many nearby actions. Averaging blurs the landscape, so cliffs like "the robot falls or it doesn't" become slopes. The randomness that makes big steps risky is a different kind: noise in the gradient estimate, which the large batches hold down.

Better final solutions: fewer traps. Final Hopper solutions at have about 3 times as many downward-bending directions as at . At one poor solution (Figure 7a), 84% of directions bend down under , so it looks like a hilltop, while under almost every curvature is within noise, closer to a slope. Fewer downward bends don't prove a way up exists, so they check one: the straight line to a good solution, trained with from the same initialization, climbs steadily under the objective (7b). Under the true objective it's flat near the poor solution and then jumps. This holds for some pairs in Hopper and Walker2d (Figures S14 to S16), not all (S17), and not in HalfCheetah, where the local landscape barely changes with (S18).

Exploration or smoothing?

In policy gradient methods these are two descriptions of the same randomness. Exploration describes behavior: the agent tries more things. Smoothing describes the math: averaging over those tries makes the objective easier to climb. The exact-gradient gridworld removes the data-gathering side entirely, since nothing is sampled, and entropy still helps, so smoothing is doing real work.

Later theory agrees. Mei et al. (2020) show that with exact gradients, softmax policy gradient converges at an rate, while the entropy-regularized version converges linearly to its regularized optimum. Smoothing isn't the whole story either. In sampled settings, especially with sparse rewards, you can't learn from a reward you never reach, and HalfCheetah doesn't fit the smoothing story at all. I read the paper as adding a second lens, not replacing the first.

A nice side idea from the related work: Ilyas et al. (2018) found that ascent on PPO's surrogate objective doesn't always mean ascent on the true objective. This paper's lens suggests why that can still work: a surrogate, like an entropy-smoothed objective, can connect regions that the true objective separates with a dip.

Connection to Sutton & Barto, Chapter 13

I read this alongside the policy gradient chapter, and the two fit together well:

  • Same theorem, different notation. is , is , and is . The book's form also covers the continuing case, where becomes the steady-state distribution, the differential value, and becomes .
  • The book fixes noise; this paper points at geometry. The book's remedies for slow policy gradients are variance reduction: the baseline in REINFORCE with baseline, then actor-critic. This paper says that's half the problem, since even the exact gradient stalls on plateaus and can't cross valleys. The authors call for optimization techniques "orthogonal to variance reduction."
  • The is the discounted state weighting. The book's REINFORCE box multiplies each update by . The paper's main text calls the stationary distribution, but the exact gradient in Appendix S.2 (eq. 23) weights states by , the discounted version, which is exactly what the does.
  • Mix is an ε-soft policy. Chapter 5's ε-soft policies give every action at least probability. Mix does the same with .
  • The price of approaching determinism. Section 13.1 sells softmax policies because, unlike ε-greedy, they can approach a deterministic policy. This paper shows the cost: a near-deterministic softmax sits on a plateau where pushing its preferences further barely changes the policy, so the gradient vanishes. For exactly these plateaus, the authors point to the natural gradient and methods like TRPO and PPO.

My take

The framing and the exact-gradient gridworld are the strongest parts: they cleanly separate noise from geometry, and the probe is cheap, needing only forward evaluations that parallelize trivially. Past that, the evidence is thinner than the abstract suggests:

  • The probe is central differences. Equations (1) and (2) are central finite differences along random directions, and the novelty is in summarizing many directions as a scatter plot and two histograms. Expanding around , as above, is also shorter than the appendix's derivation from a global quadratic, which drops and misplaces a few 's in its eqs. (4) and (5).
  • Random directions understate the extremes. In , each weight averages in dimensions, so random directions land near the average eigenvalue. The claim that the sampled extremes are close to and gets less true as grows, and a few sharp or uphill directions can go unseen, which the authors' own Figure S3 shows.
  • Figure 4a has a confound. Because Mix = 0.8 leaves controlling 20% of the policy, orange's tighter cluster is partly mechanical, and blue versus orange isn't a fair comparison there. The clean signals are black versus everything in 4a and the depth of the valley in 4b.
  • Entropy also moves the optimum. In Figure S5, a constant of 0.5 or more makes every run count as suboptimal, presumably because the regularized optimum stays too random to beat the deterministic 4.5. Decaying is what makes it work, so entropy acts as a continuation method: optimize a smoothed objective, then sharpen it. The discussion says as much.
  • The learning curves are weak evidence. Five seeds, shading of half a standard deviation, learning rates tuned per , and no clean ordering among the higher values. The authors concede the statistical power is limited.
  • Scope. A tabular gridworld and linear Gaussian policies with at most a few hundred parameters, no neural networks, high- policies that lean on action clipping (their Appendix S.4), and HalfCheetah showing no effect. Environment dependence is a finding, but it also bounds the claim.
  • Small errors. "Stationary distribution" for what is really discounted state weighting (the appendix gets it right), "unit ball" for unit sphere, 84% in the text versus 85% in the caption for the same statistic, and appendix eqs. (21) and (22) label the gradient vector and write a matrix inverse as a division.

How I'd cite it: evidence that, in small tabular and linear-policy settings, a more random policy helps policy gradient partly by reshaping the objective (flat spots get a slope, curvature swings calm down, some local optima connect) rather than only through exploration, plus a cheap random-perturbation probe for gradient and curvature. It isn't evidence about deep policies, and it doesn't replace the exploration story.