Also known as: grok, delayed generalization
Grokking is the training-dynamics phenomenon where a model first memorizes the training set, then much later — often suddenly — learns to generalize to held-out data.
Grokking is the training-dynamics phenomenon where a neural network first memorizes its training set — perfect training accuracy, near-zero training loss — and then, much later in training, suddenly learns to generalize to held-out data. The validation accuracy can stay at chance for thousands of optimizer steps after training accuracy is perfect, then jump abruptly to 100%. The phenomenon was named by Power et al. (2022) at OpenAI and is one of the cleanest empirical demonstrations that training does not do one thing at one time.
The 2022 paper trained small transformers on modular arithmetic — given
What actually happened:
The transition is fast relative to the long flat region preceding it. Training the model 100× longer than it took to memorize was necessary to see generalization emerge.
Mechanistic-interpretability work on grokking (Nanda et al., among others) suggests that two solutions are competing during training:
The memorization solution wins early because it’s locally easier to reach. Weight decay slowly penalizes the high-norm memorization solution, pushing weights toward the lower-norm generalization solution. Once the optimizer crosses into a basin that supports the algorithmic solution, generalization emerges sharply.
This story explains why grokking depends on weight decay (without it, the memorization solution is stable forever) and why the transition is sudden (the algorithmic solution is structurally different, not a smooth interpolation).
Two reasons. First, grokking is one of the cleanest pieces of evidence that overparameterized neural networks have internal phase transitions during training — they’re not just slowly improving; they’re occasionally restructuring. This puts strong pressure on the simple intuition that “loss going down = capability going up.” Second, related phenomena show up at scale: emergent capabilities in large language models (where a benchmark sits near chance until some scale, then jumps), reasoning skills that appear suddenly during fine-tuning, and the general observation that training past apparent convergence sometimes still pays off. Whether scaled-up grokking is “really” grokking is debated, but the conceptual lesson — that training can do qualitatively distinct things sequentially — has held up.
Grokking is delayed, sudden generalization — the model memorizes first, then snaps into a generalizing solution thousands of steps later. It’s the cleanest empirical evidence that training has phases, and that loss-curve intuitions can mislead you about what the model has actually learned.
Power, Burda, Edwards, Babuschkin, and Misra at OpenAI introduced grokking in a 2022 paper studying small transformers learning modular arithmetic. They showed that on tasks like 'compute (a + b) mod p,' the model would memorize training examples in a few thousand steps, then sit at near-random validation accuracy for tens of thousands more steps, then abruptly hit 100% validation accuracy.
No — that's the surprising part. The transition is sharp, not gradual. Validation accuracy can stay at chance for 10,000+ steps after training accuracy is perfect, then jump to 100% in a few hundred steps. The training loss is already zero and barely moves; it's some other internal change driving the generalization.
It's debated. The original setup is a tiny transformer on a synthetic algebraic task, which is far from production training. But the broader insight — that memorization and generalization can be temporally separated, and that long training past 'apparent convergence' can produce qualitative jumps — does seem to show up in scaled training, particularly on reasoning benchmarks where capabilities emerge non-monotonically.
