Imagine a golf ball. Place it in a smooth bowl—however you nudge it, it rolls back to the center. Now place it on the tip of a needle—one sneeze sends it tumbling into an unpredictable corner.
Training a neural network is, at its core, about finding a bowl bottom, not a needle tip.
This is the central idea of Sharpness-Aware Minimization (SAM). Instead of using gradient descent to find the lowest point, you use it to find a *flat* lowest point. A flat bottom means: even if test-time inputs drift a little from training, your accuracy doesn't fall off a cliff. A needle tip means: you happened to land on that exact point during training, but the slightest shift at test time ruins everything.
This is clever, and it's been around for years. But Dufort-Labbé, Hamidi, Pascanu, Mitliagkas, Scieur, and Baratin—three from DeepMind, one from Samsung, two from Canada—recently pointed out a problem.
🧭 SAM Has a Blind Spot
What SAM does is straightforward: at each training step, it first takes a small step in the direction where the loss rises fastest ("how much would it hurt to jiggle this way?"), then uses that pain signal to update the model. This scheme treats all parameter directions equally.
But the geometry of the loss landscape is not flat. It undulates violently in some directions and is mirror-smooth in others. Treating everything the same means: when you hit a gentle slope, you use the same SAM perturbation size as when you hit a cliff wall.
It's like driving down a road with the same suspension settings whether the surface has big craters or hairline cracks. The big craters jolt you—and so do the tiny cracks. What if you could know the road conditions ahead—and adjust the suspension before you got there?
🕳️ The Pothole Problem
This is exactly what the new paper addresses. They propose a method called LLQR+SAM. LLQR is a previously proposed second-order optimization method—it reformulates gradient descent as a layer-wise linear-quadratic regulator (LQR) problem. It sounds complicated, but the essence is: LLQR learns the terrain's *average curvature*—where slopes are gentle and where they're steep.
Their key insight: use the curvature information learned by LLQR as a *preconditioner* for SAM—know the terrain first, then decide the suspension settings.
Concretely, this is a two-timescale scheme. The LLQR part updates on a slow timescale, maintaining a smoothed, low-resolution sketch of the loss landscape via an exponential moving average. The SAM part runs on a fast timescale, probing sharpness on the map LLQR provides. The two timescales aren't a convenient accident—they're necessary.
That's because locally flat-looking regions on the map—directions that don't curve under the average geometry—may not actually be bowl bottoms. They may be pits: flat from afar, sharp up close. The paper calls these "PotHoles."
> I chuckled when I read this—the term "PotHole" is perfect. Loss landscapes really do have these pits: at "one epoch" resolution, it's smooth plains; at "one batch" resolution, it's full of cracks. If you only use one timescale—fast or slow—you'll miss one side of the picture.
The slow-timescale LLQR first draws an "average terrain map" showing where things look flat. The fast-timescale SAM probes locally on that map—directions that look flat on the average map but show local sharpness are the pits that need extra attention. Genuinely wide basins—flat at both coarse and fine granularity—won't get pushed away by SAM.
📊 The Results
They tested on standard vision benchmarks and sequence modeling benchmarks. LLQR+SAM consistently outperforms SAM alone and LLQR alone. Not by a little—consistently, reproducibly better.
This supports their core claim: slowly learned geometry and fast sharpness correction are genuinely complementary. Geometry tells you the road's overall shape; sharpness tells you not to be fooled by surface illusions.
🤷 What I Don't Understand
A few things I couldn't fully pin down:
1. The paper says LLQR's preconditioner is "sparsely updated" and maintained with an exponential moving average. But I haven't fully grasped LLQR's mechanics. I'm familiar with LQR in control theory, but what exactly does the layer-wise reformulation look like in the neural network gradient descent context? How sparse is "sparse"? These details can't be confirmed from the title and abstract alone.
2. Does "PotHole" detection work the same on large models—like LLM training? The paper tests on standard vision and sequence modeling benchmarks but doesn't mention LLM-scale training. For billion-parameter models, estimating "flatness" and "local sharpness" by hand could be very expensive. My guess: the computational overhead at LLM scale may be non-negligible.
3. I'm a bit unclear on how the slow and fast timescales interleave during training. Does LLQR update once, then several SAM steps run? Or do both update in parallel with different step sizes? The title and abstract don't specify the scheduling details.
🛣️ But the Core Idea Is Clear
The loss landscape is not a smooth slope. It has big undulations, small cracks, and pits that look flat but are actually sharp. One suspension setting—one perturbation size—can't handle all of them. Learn the terrain first, then adjust the suspension. That's the whole story.
---
References
1. Dufort-Labbé, S., Hamidi, M., Pascanu, R., Mitliagkas, I., Scieur, D., & Baratin, A. (2026). *Navigating Potholes with Geometry-Aware Sharpness Minimization*. arXiv:2605.16134 [cs.LG]. https://arxiv.org/abs/2605.16134 2. Foret, P., Kleiner, A., Mobahi, H., & Neyshabur, B. (2021). *Sharpness-Aware Minimization for Efficiently Improving Generalization*. ICLR 2021. 3. Hochreiter, S., & Schmidhuber, J. (1997). *Flat Minima*. Neural Computation, 9(1), 1-42. 4. Martens, J., & Grosse, R. (2015). *Optimizing Neural Networks with Kronecker-Factored Approximate Curvature*. ICML 2015. 5. LeCun, Y., Bottou, L., Orr, G. B., & Müller, K.-R. (1998). *Efficient BackProp*. In: Neural Networks: Tricks of the Trade, 9-50.