Singular Learning Theory: Part I—Why classical parameter counting fails

Classical statistics, Bayesian volume, and singularities in overparameterized models.

published

brookmachine learningsingular learning theorysltinterpretability

By: Johannes Choo

This reflection on the final Week 8’s session conducted by Ming Liang will be in three parts, which altogether motivates the development of the Real Log Canonical Threshold (RLCT) and its practical cousin the Local Learning Coefficient (LLC). The session itself was a whirlwind tour forming useful bones on which digestion with the aid of a chatbot was needed to help me plug in holes and form an organized, motivated explanation. The structure, thesis, and section outline in what follows are entirely mine, while the prose exposition was generated with AI. I actively steered the drafting process, stepped in to redirect or rewrite sections where needed, and reviewed the final text.

Classical statistical learning theory relies on a simple proxy for model complexity: the number of parameters. Each adjustable weight is treated as an independent degree of freedom that can be tuned to fit noise in the training set. If we fit a tenth-degree polynomial to eight data points, the curve oscillates wildly between them; to keep a model from memorizing noise, we count its parameters, penalize complexity accordingly, and keep the number of degrees of freedom well below the sample size.

Modern neural networks break this picture. Large networks routinely contain far more parameters than training examples, yet they still generalize smoothly rather than memorizing data verbatim. Just as striking is the geometry of how they learn. Instead of sliding uniformly toward a single minimum, training trajectories often pass through long plateaus of little apparent change punctuated by sudden drops in loss, during which internal mechanisms form, reorganize, or simplify. Classical theory predicts the wrong complexity penalties in this regime because its assumptions fail inside neural parameter spaces.

Traditional accounts of overfitting judge a model class by its worst-case capacity—asking whether some setting of its parameters could memorize arbitrary noise in the training set, a test that any network with more weights than examples automatically fails. Rather than asking what a model could memorize in the worst case, we examine how parameter settings actually organize around good solutions, using a central quantity from Bayesian statistics and statistical physics: the marginal likelihood (or partition function), and its negative logarithm, the Bayesian free energy. By averaging fit across the entire parameter space, free energy captures not merely whether a single weight setting approximates the data well, but how much volume of configurations supports that approximation. Although free energy is a Bayesian quantity rather than a literal equation of motion for gradient descent, its trade-off between training fit and parameter volume provides both a useful physical model for why noisy training drifts toward flatter, more redundant basins and a direct way to measure the geometry around real checkpoints.

We include the explicit equations and derivations for technically curious readers comfortable with undergraduate multivariable calculus, linear algebra, and probability. At the same time, every mathematical expression is paired with a geometric explanation so that readers without those prerequisites can read past the symbolic steps and still walk away with a clear intuitive picture of how Singular Learning Theory (SLT), the Real Log Canonical Threshold (RLCT, λ), and the Local Learning Coefficient (LLC, λ^) help researchers describe and measure phenomena observed when training overparameterized models—phenomena that classical parameter counting cannot express. The progression across the three parts is as follows:

  1. In Part I, we frame neural networks as parameterized probabilistic models within the Bayesian framework, see why parameter-space volume illuminates training behavior through the partition function and free energy, examine how classical model selection approximates free energy via the Laplace approximation and the Bayesian information criterion (BIC), and see why symmetries and redundant neurons create singularities that break BIC.
  2. In Part II, we introduce Sumio Watanabe’s Singular Learning Theory and the Real Log Canonical Threshold (RLCT), which replaces parameter counting with volume scaling near zero-loss sets and explains why compact circuits capture vastly more posterior volume than memorization, leading to phase transitions during training.
  3. In Part III, we move from the global, theoretical RLCT to its empirical counterpart, the Local Learning Coefficient (LLC), showing how Stochastic Gradient Langevin Dynamics (SGLD) measures local effective complexity across training checkpoints to track circuit formation and pruning.

Parameterized models and the Bayesian framework

When a practitioner trains a neural network, they run a learning algorithm (such as gradient descent) on a dataset to arrive at one working computer program chosen from a predefined set of possible outputs of that algorithm. All candidate programs in that set share a fixed architecture and differ only in a list of d adjustable numerical weights, w=(w1,…,wd)∈W⊆ℝd. Selecting a vector of weights w selects one concrete program from this parameterized model family.

At first glance, treating a neural network as a probability distribution can seem unnatural, especially when a model appears to output deterministic numbers or discrete choices. Yet virtually every deep learning model defines, explicitly or implicitly, a probability distribution p(x|w) parameterized by its weights w. For example, a language model or image classifier with a softmax layer explicitly outputs probabilities over next tokens or class labels, while even a regression network trained with mean-squared error implicitly specifies a Gaussian distribution centered at the network’s predicted value.

That probabilistic description also highlights a difference in perspective between engineering and theory. In an applied setting, a practitioner runs a chosen training recipe on a specific dataset to obtain one final parameter vector w∗ for the task at hand—for instance, whether a fine-tuned classifier performs reliably on a support queue. A researcher studying learning more generally, however, needs a way to reason about the model family p(x|w) across arbitrary data distributions without tying every conclusion to a single run, random seed, or optimization recipe.

The Bayesian framework provides that common language. Rather than picking out a single vector w∗, we start from a prior density φ(w) assigning initial plausibility across the parameter space W, observe n training examples Dn={x1,…,xn}, and update to a posterior distribution over all candidate programs:

p(w|Dn)∝φ(w)∏i=1np(xi|w).

Taking negative logarithms turns this product into the familiar regularized objective of deep learning: −∑i=1nlog⁡p(xi|w) is the total training loss on Dn, and −log⁡φ(w) acts as a regularization term (such as L2 weight decay under a zero-mean Gaussian prior) that keeps parameter-space volume finite. Whereas standard training runs an optimizer to settle on a single minimum w∗ of that objective, conditioning on Dn retains the entire distribution across W. Because p(w|Dn) depends solely on the model family, the prior, and the dataset—abstracting away optimizer specifics—studying how it concentrates as n grows isolates the geometry of how the architecture represents a task.

Bayesian volume and training dynamics

What does retaining the full posterior p(w|Dn) reveal that looking only at a single optimum w∗ misses? Above all, it reveals parameter-space volume. Picture the parameter space W⊆ℝd as the horizontal floor of a terrain equipped with ordinary Euclidean distance and volume, and assign each point w a vertical elevation equal to its training loss. This forms what practitioners call the loss landscape, where well-fitting programs sit at the bottoms of valleys. Compare two valleys whose lowest points reach the exact same minimum loss:

  • A narrow ravine: moving even a tiny Euclidean distance from the bottom in some directions may cause the training loss to climb steeply.
  • A broad basin: one can move across a wide Euclidean region around the bottom while the training loss barely rises.

How does this loss landscape translate into the Bayesian posterior p(w|Dn)? Because lower training loss corresponds to higher data likelihood ∏i=1np(xi|w), a low-loss valley in the loss landscape becomes a high peak of probability density in the posterior. At their exact bottom points, both valleys achieve the same minimum loss—and, assuming comparable prior density φ(w), the same peak probability density.

In a continuous space W, however, a single point has zero volume, so density at one point does not determine how much posterior weight a region holds. What actually measures how strongly the posterior favors a valley is its probability mass—the integral of the probability density p(w|Dn) over Euclidean volume in that neighborhood. In the narrow ravine, the loss shoots up and the probability density drops off almost immediately away from the floor along those steep directions, leaving a thin ridge of high density with very little total mass. In the broad basin, the loss stays low—and the probability density remains high—across a large Euclidean volume, accumulating vastly more posterior probability mass.

Although gradient-based optimizers such as SGD or Adam do not literally sample from p(w|Dn), they traverse this same Euclidean loss landscape under mini-batch gradient noise and finite step sizes, making it hard to stay balanced inside a narrow ravine and biasing trajectories toward broad, high-volume basins. The Bayesian trade-off between depth (loss at the valley floor) and volume (the Euclidean region over which loss remains low), measured by free energy, therefore captures both the intrinsic geometry of a solution and its pull on noisy optimization.

Measuring fit and curvature: KL divergence and Fisher information

To describe this landscape geometry precisely, we need one quantity to measure fit and another to measure the steepness of a valley around a minimum.

Suppose the training examples are drawn independently from an underlying data distribution q(x), and recall that each parameter vector w∈W⊆ℝd in our model family defines a predicted distribution p(x|w). We measure the average discrepancy between the data-generating distribution and the model’s predictions using the Kullback–Leibler (KL) divergence:

K(w)=DKL(q‖pw)=∫q(x)log⁡q(x)p(x|w)dx,

with integration replaced by summation when x is discrete. Intuitively, K(w) averages the prediction mismatch over all possible data points x. It is always nonnegative (K(w)≥0), and in the realizable setting—where the model family is expressive enough to represent q exactly—there exists at least one optimal parameter w0∈W matching q everywhere (p(⋅|w0)=q), at which K(w0)=0.1

In practice, we never have access to q(x) itself; we only observe the n training examples x1,…,xn. Rather than computing K(w) directly, training evaluates the empirical negative log-likelihood—the standard cross-entropy training loss averaged over the training set:

Ln(w)=−1n∑i=1nlog⁡p(xi|w).

Its expected value over fresh draws from q is K(w)+H(q), where H(q)=−∫q(x)log⁡q(x)dx is the constant entropy of q, so minimizing Ln(w) is equivalent to minimizing an empirical estimate of K(w) up to an additive constant. Moreover, rewriting the dataset likelihood as ∏i=1np(xi|w)=exp⁡(−nLn(w)) shows why poor fits disappear exponentially fast from the posterior as dataset size n grows.

Now suppose we stand at a realizable optimum w0 where K(w0)=0 and the slope ∇K(w0)=0. How steeply do the valley walls rise as we nudge w0? Expanding K(w) to second order gives a quadratic bowl approximation:

K(w)≈12(w−w0)⊤I(w0)(w−w0),

where the matrix of second derivatives ∇2K(w0) coincides at the realizable optimum w0 with the Fisher information matrix I(w0). Geometrically, a multi-dimensional quadratic bowl has a set of perpendicular principal axes, and the eigenvalues of I(w0) are simply the steepnesses (curvatures) of the bowl along each of those axes: a large eigenvalue corresponds to a steep wall where tiny weight changes sharply distort predictions, a small eigenvalue corresponds to a gentle slope, and a zero eigenvalue corresponds to a completely flat trough along which the model’s predictions do not change at all. Those steepnesses also govern local optimization behavior: when some axes are vastly steeper than others, gradient descent oscillates across steep directions while creeping slowly along shallow ones. Viewing a parameterized model family as a geometric space whose local distance and curvature are governed by the Fisher matrix I(w) is the centerpiece of information geometry, pioneered by Shun-ichi Amari—who also introduced the natural gradient (I(w)−1∇Ln(w)), rescaling updates by the inverse Fisher matrix to equalize steep and shallow axes whenever I(w) is invertible.

Local curvature also governs how reliably a solution survives noisy training steps. Near a minimum w0—where the full-batch gradient vanishes and updates are dominated by mini-batch noise—an SGD step of bounded Euclidean distance acts as a small random perturbation Δw=w−w0. When that noise is spread across directions rather than aimed solely along the steepest axis, the quadratic approximation K(w0+Δw)≈12Δw⊤I(w0)Δw yields a simple probabilistic bound: the probability that a bounded noisy step remains a good fit (keeping the increase in error below a small tolerance) is controlled by the fraction of the local Euclidean ball around w0 where the walls of I(w0) stay shallow or flat. The more directions that are flat or gentle, the smaller the chance that a bounded step knocks the model into a high-loss region.

Classical model selection and the Laplace approximation

With training fit and local curvature in place, we step back from tracking and updating a single parameter instance w through gradient steps to evaluating the model family as a whole. Rather than modifying one weight vector, Bayesian model selection integrates out w across parameter space against the regularizing prior φ(w) (such as Gaussian weight decay), which keeps total parameter volume finite. Averaging the dataset likelihood under φ(w) gives the marginal likelihood, known in statistical physics as the partition function Zn:

Zn=∫W∏i=1np(xi|w)φ(w)dw=∫Wexp⁡(−nLn(w))φ(w)dw.

Although Zn integrates over all of W, local curvature around w0 still governs its value as n grows: because exp⁡(−nLn(w)) suppresses high-loss regions exponentially fast, almost the entire integral concentrates inside the low-loss valley around w0. Taking the negative logarithm of Zn gives the Bayesian free energy:

Fn=−log⁡Zn=−log⁡∫Wexp⁡(−nLn(w))φ(w)dw.

Because of the minus sign, a larger partition function Zn—meaning a better combination of low training loss and generous supporting volume—corresponds to a smaller free energy Fn. Returning to our earlier terrain comparison, suppose we evaluate two landscapes (or two local regions with comparable prior weight) whose bottoms reach the exact same minimum training loss: the broad basin keeps exp⁡(−nLn(w)) large across a much wider Euclidean neighborhood than the narrow ravine, giving it a larger integral Zn and therefore a lower free energy Fn.

Consider what happens to Fn as dataset size n→∞ in a regular statistical model—one whose loss landscape around the optimal parameter w0 is a single smooth bowl curving upward in every direction, with no flat troughs or ridges (formally, w0 sits as an isolated point in the interior of W with φ(w0)>0, and every principal axis of I(w0) has strictly positive curvature so I(w0) is positive definite). As n grows, the empirical minimizer w^n (the weight setting minimizing training loss Ln on the dataset) moves within distance n−1/2 of w0, and the factor exp⁡(−nLn(w)) concentrates almost all of the integral inside a small Gaussian peak around w^n. Because the loss rises quadratically like (Δw)2 around the bottom of the bowl, keeping n(Δw)2 bounded as n grows forces the width of that peak to shrink by 1/n along every one of the d independent parameter axes. Shrinking a d-dimensional box by 1/n along each axis shrinks its total volume by (n−1/2)d=n−d/2.

Approximating the integral by treating the log-integrand as a quadratic bowl around its peak—the Laplace approximation—turns that shrinking volume into an asymptotic formula for the free energy:

Fn=nLn(w0)+d2log⁡n+12log⁡det⁡I(w0)+𝒪p(1).

Multiplying the leading terms by 2 (with Ln evaluated at the empirical minimizer w^n) gives the classical Bayesian information criterion (BIC). Reading each term geometrically shows why classical parameter counting works here:

  1. Training fit (nLn(w0)): Because this term grows linearly with dataset size n, even a slight improvement in fitting the data eventually outweighs complexity penalties once enough samples are collected.
  2. Dimensional volume penalty (d2log⁡n): This comes directly from −log⁡(n−d/2). Each of the d independent parameters shrinks the surviving volume by 1/n, adding 12log⁡n to the free energy regardless of what the parameter represents.
  3. Local curvature (12log⁡det⁡I(w0)): The determinant det⁡I(w0) is the product of the bowl’s steepnesses across all d principal axes. Steeper bowls have smaller volume and pay a slightly higher constant penalty.
  4. Lower-order remainder (𝒪p(1)): This collects terms that stay bounded as n grows, including the prior density −log⁡φ(w0), the Gaussian normalization constant −d2log⁡(2π), and the bounded fluctuation nLn(w^n)−nLn(w0) between the empirical minimum and w0.

For classical regular models such as linear or logistic regression, this expansion matches both model selection and optimization geometry: there is an isolated bowl, every parameter constrains predictions, and the posterior contracts uniformly around w0.

Look closely, however, at the product of steepnesses inside 12log⁡det⁡I(w0). It requires every single eigenvalue of I(w0) to be strictly greater than zero. If even one direction in parameter space is completely flat at w0—curvature zero—then the product det⁡I(w0) vanishes, a Gaussian bowl fails to confine probability along that flat axis, and the BIC expansion breaks down.

Symmetries, redundancy, and singularities in neural networks

In neural networks, flat directions are not rare edge cases; they are built directly into the architecture through symmetries and overparameterization.

First, consider continuous rescaling symmetries. Take a single hidden ReLU neuron computing v⋅ReLU⁡(w⋅x) for an input vector x, incoming weights w, and outgoing weight v, where ReLU⁡(z)=max⁡(0,z) sets negative numbers to zero and passes positive numbers through unchanged. Because positive scaling passes straight through ReLU⁡, multiplying the incoming weights w by any positive number c>0 and dividing the outgoing weight v by c cancels out identically:

(vc)ReLU⁡((cw)⋅x)=v⋅ReLU⁡(w⋅x).

Doubling w and halving v, for instance, produces the exact same output for every input x. Varying c traces a continuous curve (cw,v/c) in parameter space along which the predicted distribution p(x|w) and K(w) never change. Along that curve, the valley has zero steepness, giving I(w0) a zero eigenvalue.2

Second, consider redundant units. Suppose the true data distribution can be represented exactly by a single hidden neuron, and we fit a two-neuron network instead. The second neuron can be switched off in two distinct ways without disturbing K(w)=0:

  • setting its outgoing weight to zero (v2=0), which leaves its incoming weights w2 free to take any values; or
  • setting its incoming weights to zero (w2=0), which silences the unit for every input and leaves its outgoing weight v2 free to take any values.

Where w2=0 and v2=0 meet, two flat zero-loss sheets cross along a crease, much like two perpendicular walls meeting at a corner.

When the set of optimal weights W0={w∈W:K(w)=0} is no longer a collection of isolated points sitting in round bowls—forming instead continuous curves, flat sheets, and intersecting creases where I(w) has zero eigenvalues—we call the model a singular statistical model. Amari and collaborators showed that these intersecting redundant-neuron singularities also degenerate the Fisher metric along training trajectories, trapping gradient descent on the long plateaus followed by sudden drops in loss observed when training neural networks.

Beyond slowing optimization, singularities also break the Laplace approximation for free energy because flat and intersecting valleys leave vastly more room for weights to vary without hurting training fit. Where quadratic curvature disappears, valley walls flatten out into gentler higher-order slopes such as quartics (K(w)∝Δw4) or cross-terms like w22v22. In a quartic direction, the region of acceptable parameters shrinks at rate n−1/4 rather than n−1/2 (since keeping nΔw4 bounded allows Δw up to order n−1/4 rather than n−1/2); along an exact symmetry curve, it does not shrink with n at all. Posterior volume therefore contracts far more slowly than n−d/2, and raw parameter count d dramatically overstates the model’s effective complexity.

In Part II, we replace raw parameter counting with a geometric measure of how fast near-optimal volume shrinks—the Real Log Canonical Threshold (λ)—and see how it governs competition between basins inside a single network.

Footnotes

  1. If the model is slightly misspecified so that minw⁡K(w)=K(w0)>0, the local volume and free-energy theory still holds by replacing K(w) with the excess divergence K(w)−K(w0) under appropriate regularity conditions around the optimal set. ↩

  2. Watanabe’s formal proofs assume that K(w) is real-analytic, which excludes piecewise-linear activations such as ReLU at their nondifferentiable boundaries. However, networks with smooth activations (such as tanh⁡ or GELU) as well as deep linear networks satisfy analyticity and exhibit the exact same continuous rescaling symmetries and intersecting degeneracies, and empirical SLT extends smoothly to ReLU architectures in practice. ↩