Grokking in training

Why does a model that has already memorised its training data suddenly start generalising long afterwards?

A small network is trained on part of a modular arithmetic table. Within a few thousand steps it gets every training example right; held-out accuracy sits at chance. Ordinary overfitting, and the ordinary advice is to stop — nothing further is going to happen.

But training is left running far longer than anyone would sensibly leave it, and held-out accuracy, flat for a very long stretch, climbs to near-perfect. Nothing about the data changed, and the training loss was already effectively zero. A model at zero loss is supposed to be finished. What force was still acting?

Begin with what "zero training loss" rules out. It rules out further pressure from the fitting term of the objective, which has nothing left to complain about. It does not rule out pressure from anything else — and in the settings where this was first reported, by Power and colleagues in 2022, there was something else: weight decay, a penalty on the size of the weights.

So ask what that penalty is now doing. Among all weight settings that fit the training data perfectly, it prefers the smallest. If more than one exists, the model is no longer being pulled toward correctness — that is achieved — but along the surface of correct solutions, downhill in norm. So: are there two very different ways to fit this data, with different sizes?

There are, and the difference is the whole story. One way is a lookup: store each training pair separately. It is found quickly, because it decomposes into independent small corrections, and it is expensive in weight, because every example needs its own accommodation. The other way is an algorithm — for modular addition, Nanda and colleagues showed in 2023 that the network builds a trigonometric construction, representing the inputs as rotations and reading the answer off their composition. That is slow to assemble, because it only pays off once several pieces are in place, and once assembled it is very cheap in weight, because a handful of components covers every example at once.

Now the shape follows without magic. The lookup arrives first and drives loss to zero. Weight decay then presses steadily toward the cheaper solution, and the algorithmic circuit grows underneath — present but not yet dominant, so outputs are still driven by the memorised table and held-out accuracy stays flat. Once the circuit can carry the training data alone, the memorised weights are pure cost with no benefit, and decay strips them out. The output flips over, and held-out accuracy leaps.

So is the leap real? This is the sharpest claim in the account, and it is falsifiable. If generalisation is genuinely sudden, no measurement inside the network should show anything until the jump. If instead the circuit has been forming all along, a measurement that reads it directly should rise smoothly, well before the accuracy curve moves. The second is what is found: progress measures built from the emerging structure — how concentrated the representations are in a few frequency components, or how well the model does when the memorised contribution is deliberately excluded — move early and steadily. The suddenness belongs to the metric, not the learning.

That gives us the refuting observation too. Show a progress measure, chosen in advance rather than fitted after the fact, that is genuinely flat until the accuracy jump; or show grokking with the norm pressure removed entirely and no other mechanism constraining weight size. Either would break the account.

A second prediction concerns data. If the delay is a race between a fast expensive solution and a slow cheap one, how much data you have should set its terms. With very little, memorising is easy and the algorithm barely favoured, so the model may never transition; with plenty, the algorithm is found early and there is no visible delay. The long delay appears near a critical fraction in between — which is observed, and is why this reads as a threshold rather than a trend.

Two things this is not.

It is not the same as double descent, though the two are cousins and are easily confused. Double descent varies model capacity and asks where test error ends up; grokking holds capacity fixed and varies training time. The shared idea is that many settings fit the training data and something ranks them; the axes along which the ranking plays out are different.

It is also not evidence that models mysteriously "understand" late. The delay sits between two mechanical events — a fast solution being found, and a slow cheaper one displacing it — and the account works only because the two differ in cost under a penalty written down in the training script.

The honest caveat is on generality. The clean picture comes from small models on algorithmic tasks with an exactly known correct algorithm, which is precisely why the circuit could be identified at all. Grokking-like delays have since been reported in other settings and without explicit weight decay, where large initialisation scale or other implicit norm effects appear to play the same role, and competing explanations are actively argued. What is well established is the shape and the mechanism in the studied cases; that every delayed generalisation in a large model is the same thing is not established.

• What implicit regularisation gradient descent supplies on its own, when no penalty is written down.
• Whether progress measures of this kind can be defined ahead of time for tasks whose correct algorithm is unknown.

Every term the collection defines is gathered in the glossary.