Towards Understanding Grokking: An Effective Theory of Representation Learning
Abstract
We aim to understand grokking , a phenomenon where models generalize long after overfitting their training set.
We present both a microscopic analysis anchored by an effective theory and a macroscopic analysis of phase diagrams describing learning performance across hyperparameters.
We find that generalization originates from structured representations whose training dynamics and dependence on training set size can be predicted by our effective theory in a toy setting.
We observe empirically the presence of four learning phases: comprehension , grokking , memorization , and confusion .
We find representation learning to occur only in a “Goldilocks zone” (including comprehension and grokking) between memorization and confusion.
We find on transformers the grokking phase stays closer to the memorization phase (compared to the comprehension phase), leading to delayed generalization.
The
Goldilocks phase is reminiscent of “intelligence from starvation” in Darwinian evolution, where resource limitations drive discovery of more efficient solutions.
This study not only provides intuitive explanations of the origin of grokking, but also highlights the usefulness of physics-inspired tools, e.g., effective theories and phase diagrams, for understanding deep learning.
Introduction
Perhaps the central challenge of a scientific understanding of deep learning lies in accounting for neural network generalization.
Power et al.
[1] recently added a new puzzle to the task of understanding generalization with their discovery of grokking .
Grokking refers to the surprising phenomenon of delayed generalization where neural networks, on certain learning problems, generalize long after overfitting their training set.
It is a rare albeit striking phenomenon that violates common machine learning intuitions, raising three key puzzles:
Q
The origin of generalization : When trained on the algorithmic datasets where grokking occurs, how do models generalize at all?
Q
The critical training size : Why does the training time needed to “grok” (generalize) diverge as the training set size decreases toward a critical point?
Q3 Delayed generalization : Under what conditions does delayed generalization occur?
We provide evidence that representation learning is central to answering each of these questions.
Our answers can be summarized as follows:
A1 Generalization can be attributed to learning a good representation of the input embeddings, i.e., a representation that has the appropriate structure for the task and which can be predicted from the theory in Section 3.
See Figures 1 and 2.
A2 The critical training set size corresponds to the least amount of training data that can determine such a representation (which, in some cases, is unique up to linear transformations). [Figure]
A3 Grokking is a phase between “comprehension” and “memorization” phases and it can be remedied with proper hyperparmeter tuning, as illustrated by the phase diagrams in Figure 6.
This paper is organized as follows:
In Section 2, we introduce the problem setting and build a simplified toy model.
In Section 3, we will use an effective theory approach, a useful tool from theoretical physics, to shed some light on questions Q1 and Q2 and show the relationship between generalization and the learning of structured representations.
In Section 4, we explain Q3 by displaying phase diagrams from a grid search of hyperparameters and show how we can “de-delay” generalization by following intuition developed from the phase diagram.
We discuss related work in
Section 5, followed by conclusions in Section 6.
Problem Setting
Power et al.
[1] observe grokking on a less common task – learning “algorithmic” binary operations.
Given some binary operation ◦ , a network is tasked with learning the map ( a, b ) (cid:55)→ c where c = a ◦ b .[-
-]
They use a decoder-only transformer to predict the second to last token in a tokenized equation of the form “<lhs> <op> <rhs> <eq> <result> <eos>”.
Each token is represented as a 256-dimensional embedding vector.
The embeddings are learnable and initialized randomly.
After the transformer, a final linear layer maps the output to class logits for each token.
Toy Model We primarily study grokking in a simpler toy model, which still retains the key behaviors from the setup of [1].
Although [1] treated this as a classification task, we study both regression (mean-squared error) and classification (cross-entropy).
The basic setup is as follows: our model takes as input the symbols a, b and maps them to trainable embedding vectors E a , E b ∈ R d in .
It then sums E a , E b and sends the resulting vector through a “decoder” MLP.
The target output vector, denoted Y c ∈ R d out is a fixed random vector (regression task) or a one-hot vector (classification task).
Our model architecture can therefore be compactly described as ( a, b ) (cid:55)→
Dec( E a + E b ) , where the embeddings E ∗ and the decoder are trainable.
Despite its simplicity, this toy model can generalize to all abelian groups (discussed in Appendix A).
In sections 3-4.1, we consider only the binary operation of addition.
We consider modular addition in Section 4.2 to generalize some of our results to a transformer architecture and study general non-abelian operations in Appendix G.
Dataset In our toy setting, we are concerned with learning the addition operation.
A data sample corresponding to i + j is denoted as ( i, j ) for simplicity.
If i, j ∈ { 0 , . . . , p − 1 } , there are in total p ( p + 1) / 2 different samples since we consider i + j and j + i to be the same sample.
A dataset D is a set of non-repeating data samples.
We denote the full dataset as D 0 and split it into a training dataset D and a validation dataset D ′ , i.e., D (cid:83)
D ′ =
D 0 , D (cid:84)
D ′ = ∅ .
We define training data fraction = | D | / | D 0 | where | · | denotes the cardinality of the set.
RQI: 0.0 — Accuracy - train: 1.0, validation: 0.
[Figure]
RQI: 0.6 — Accuracy - train: 1.0, validation: 0.
[Figure]
Generalization in toy addition
[Figure]
[Figure]
validation: 0.
[Figure]
Accuracy - train: 1.0, validation: 0.
[Figure]
Why Generalization Occurs: Representations and Dynamics
We can see that generalization appears to be linked to the emergence of highly-structured embeddings in Figure 2.
In particular, Figure 2 (a, b) shows parallelograms in toy addition, and (c, d) shows a circle in toy modular addition.
We now restrict ourselves to the toy addition setup and formalize a notion of representation quality and show that it predicts the model’s performance.
We then develop a physics-inspired effective theory of learning which can accurately predict the critical training set size and training trajectories of representations.
The concept of an effective theory in physics is similar to model reduction in computational methods in that it aims to describe complex phenomena with simple yet intuitive pictures.
In our effective theory, we will model the dynamics of representation learning not as gradient descent of the true task loss but rather a simpler effective loss function ℓ eff which depends only on the representations in embedding space and not on the decoder.
3.1 Representation quality predicts generalization for the toy model
A rigorous definition for structure in the learned representation is necessary.
We propose the following definition,
Definition 1.
( i, j, m, n ) is a δ - parallelogram in the representation R ≡ [ E 0 , · · · , E p − 1 ] if
[Equation]
In the following derivations, we can take δ , which is a small threshold to tolerate numerical errors, to be zero.
Proposition 1.
When the training loss is zero, any parallelogram ( i, j, m, n ) in representation R satisfies i + j = m + n . Proof.
Suppose that this is not the case, i.e., suppose E
i + E j = E m + E n
but i + j ̸
= m + n , then
Y i + j =
Dec( E i + E j )
=
Dec( E m + E n ) =
Y m + n where the first and last equalities come from the zero training loss assumption.
However, since i + j ̸ = m + n , we have Y i + j ̸ = Y n + m (almost surely in the regression task), a contradiction.
0 training data fraction 0 .0 .0 .0 .0 .1 .
A cc
M e m o r
i z a t i o n (a) 0 .0 .0 .
0 training set fraction 0 .0 .0 .0 .0 .1 .d
A cc (b) 0 .0 .0 .0 .0 .1 .d
Acc 0 .0 .0 .0 .0 .1 .
A cc (c)
Acc .
These two accuracies as a function of training data fraction are plotted in (a)(b), and their agreement is shown in (c).
It is convenient to define the permissible parallelogram set associated with a training dataset D (“permissible” means consistent with 100% training accuracy) as
[Equation]
For simplicity, we denote P 0 ≡ P
( D 0 ) .
Given a representation R , we can check how many permissible parallelograms actually exist in R within error δ , so we define the parallelogram set corresponding to R as
[Equation]
For brevity we will write P ( R ) , suppressing the dependence on δ .
We define the representation quality index (RQI) as
[Equation]
We will use the term linear representation or linear structure to refer to a representation whose embeddings are of the form E k
= a + k b ( k = 0 , · · · , p − 1; a , b ∈ R d in ) .
A linear representation has RQI = 1 , while a random representation (sampled from, say, a normal dstribution) has RQI =with high probability.
Quantitatively, we denote the “predicted accuracy” (cid:100)
Acc as the accuracy achievable on the whole dataset given the representation R (see Appendix C for the full details).
In Figure 3, we see that the predicted (cid:100)
Acc aligns well with the true accuracy Acc , establishing good evidence that structured representation of input embeddings leads to generalization.
We use an example to illustrate the origin of generalization here.
In the setup of Figure 2 (b), suppose the decoder can achieve zero training loss and E 6 + E 8 is a training sample hence Dec( E 6 + E 8 )
=
Y 14 .
At validation time, the decoder is tasked with predicting a validation sample E 5 + E 9 .
Since (5 , 9 , 6 , 8) forms a parallelogram such that E 5 + E 9 = E 6 + E 8 , the decoder can predict the validation sample correctly because
Dec( E 5 + E 9 ) =
Dec( E 6 + E 8 ) =
Y 14 .
3.2 The dynamics of embedding vectors
Suppose that we have an ideal model M ∗ =
(Dec ∗ , R ∗ ) such that:[-
-]
• (1) M ∗ can achieve zero training loss; • (2) M ∗ has an injective decoder, i.e., Dec ∗ ( x 1 ) ̸
=
Dec ∗ ( x 2 ) for any x 1 ̸ = x 2 .
Then Proposition 2 provides a mechanism for the formation of parallelograms.
[Figure]
ili t y ( li n e a r s tr u c t u r e )
[Figure]
Proposition 2.
If a training set D contains two samples ( i, j ) and ( m, n ) with i + j = m + n , then M ∗ learns a representation R ∗ such that E i + E j = E m + E n , i.e., ( i, j, m, n ) forms a parallelogram.
Proof.
Due to the zero training loss assumption, we have Dec ∗ ( E i + E j ) =
Y i + j = Y m + n =
Dec ∗ ( E m + E n ) .
Then the injectivity of Dec ∗ implies E i + E j = E m + E n .
The dynamics of the trained embedding vectors are determined by various factors interacting in complex ways, for instance: the details of the decoder architecture, the optimizer hyperparameters, and the various kinds of implicit regularization induced by the training procedure.
We will see that the dynamics of normalized quantities, namely, the normalized embeddings at time t , defined as ˜
[Equation]
, where µ t = 1 p (cid:80) k E ( t ) k and σ t = 1 p (cid:80) k | E ( t ) k − µ t | 2 , can be qualitatively described by a simple effective loss (in the physics effective theory sense).
We will assume that the normalized embedding vectors obey a gradient flow for an effective loss function of the form
[Equation]
where | · | denotes Euclidean vector norm.
Note that the embeddings do not collapse to the trivial solution E 0 = · · · = E p − 1 = 0 unless initialized as such, because two conserved quantities exist, as proven in Appendix E:
[Equation]
We shall now use the effective dynamics to explain empirical observations such as the existence of a critical training set size for generalization.
Degeneracy of ground states (loss optima)
We define ground states as those representations satisfying ℓ eff = 0 , which requires the following linear equations to hold:
[Equation]
Since each embedding dimension obeys the same set of linear equations, we will assume, without loss of generality, that d in = 1 .
The dimension of the null space of A ( P ) , denoted as n 0 , is the number of degrees of freedom of the ground states.
Given a set of parallelograms implied by a training dataset
D , the nullity of A ( P ( D )) could be obtained by computing the singular values 0 ≤ σ 1 ≤ · · · ≤ σ p .
We always have n 0 ≥ 2 , i.e., σ 1 = σ 2 = 0 because the nullity of A ( P 0 ) , the set of linear equations given by all possible parallelograms, is Nullity( A ( P 0 ))
= 2 which can be attributed to two degrees of freedom (translation and scaling).
If n 0 = 2 , the representation is unique up to translations and scaling factors, and the embeddings have the form E k
= a + k b .
Otherwise, when n 0 > 2 , the representation is not constrained enough such that all the embeddings lie on a line.
We present theoretical predictions alongside empirical results for addition ( p = 10 ) in Figure 4.
As shown in Figure 4 (a), our effective theory predicts that the probability that the training set implies a unique linear structure (which would result in perfect generalization) depends on the training data fraction and has a phase transition around r c = 0 .
Empirical results from training different models are shown in Figure 4 (b).
The number of steps to reach RQI > 0 .
95 is seen to have a phase transition at r c = 0 . 4 , agreeing with the proposed effective theory and with the empirical findings in [1].
Time towards the linear structure We define the Hessian matrix of ℓ 0 as
[Equation]
Note that ℓ eff = 12 R T HR , R =
[ E 0 , E 1 , · · · , E p − 1 ] , so the gradient descent is linear, i.e.,
[Equation]
[Equation]
If H has eigenvalues λ i =
σ 2 i (sorted in increasing order) and eigenvectors ¯ v i , and we have the initial condition R ( t = 0)
= (cid:80) i a i ¯ v i , then we have R ( t ) =
(cid:80) i a i ¯ v i e −
λ i t .
The first two eigenvalues vanish and t h = 1 /λ 3 determines the timescale for the slowest component to decrease by a factor of e .
We call λ 3 the grokking rate .
When the step size is η , the corresponding number of steps is n h
= t
h /η
= 1 / ( λ 3 η ) .
We verify the above analysis with empirical results.
Figure 4 (c)(d) show the trajectories obtained from the effective theory and from neural network training, respectively.
The 1D neural representation in Figure 4 (d) are manually normalized to zero mean and unit variance.
The two trajectories agree qualitatively, and it takes about 3 n h steps for two trajectories to converge to the linear structure.
The quantitative differences might be due to the absence of the decoder in the effective theory, which assumes the decoder to take infinitesimal step sizes.
Dependence of grokking on data size Note that ℓ eff involves averaging over parallelograms in the training set, it is dependent on training data size, so is λ 3 .
In Figure 5 (a), we plot the dependence of λ 3 on training data fraction.
There are many datasets with the same data size, so λ 3 is a probabilistic function of data size.
Two insights on grokking can be extracted from this plot: (i) When the data fraction is below some threshold (around 0.4), λ 3 is zero with high probability, corresponding to no generalization. This again verifies our critical point in Figure 4. (ii) When data size is above the threshold, λ 3 (on average) is an increasing function of data size. This implies that grokking time t ∼ 1 /λ 3 decreases as training data size becomes larger, an important observation from [1].
To verify our effective theory, we compare the grokking steps obtained from real neural network training (defined as steps to RQI > 0 . 95 ), and those predicted by our theory t th ∼ 1 λ 3 η ( η is the embedding learning rate), shown in Figure 5 (b).
The theory agrees qualitatively with neural networks, showing the trend of decreasing grokking steps as increasing data size.
The quantitative differences might be explained as the gap between our effective loss and actual loss.
Limitations of the effective theory While our theory defines an effective loss based on the Euclidean distance between embeddings E i + E j and E n + E m , one could imagine generalizing the theory to define a broader notion of parallogram given by some other metric on the representation space.
For instance, if we have a decoder like in Figure 2 (d) then the distance between distinct representations within the same “pizza slice” is low, meaning that representations arranged not in parallelograms w.r.t.
the Euclidean metric may be parallelograms with respect to the metric defined by the decoder.
Delayed Generalization: A Phase Diagram
So far, we have (1) observed empirically that generalization on algorithmic datasets corresponds with the emergence of well-structured representations, (2) defined a notion of representation quality in a toy setting and shown that it predicts generalization, and (3) developed an effective theory to describe [Figure] kk i [Figure]
r a t e λ
[Figure] [Table] the learning dynamics of the representations in the same toy setting. We now study how optimizer hyperparameters affect high-level learning performance.
In particular, we develop phase diagrams for how learning performance depends on the representation learning rate, decoder learning rate and the decoder weight decay.
These parameters are of interest since they most explicitly regulate a kind of competition between the encoder and decoder, as we elaborate below.
4.1 Phase diagram of a toy model
Training details We update the representation and the decoder with different optimizers.
For the 1D embeddings, we use the Adam optimizer with learning rate [10 − 5 , 10 − 2 ] and zero weight decay.
For the decoder, we use an AdamW optimizer with the learning rate in [10 − 5 , 10 − 2 ] and the weight decay in [0 , 10] (regression) or [0 , 20] (classification).
For training/validation spliting, we choose 45/10 for non-modular addition ( p = 10 ) and 24/12 for the permutation group S 3 .
We hard-code addition or matrix multiplication (details in Appendix G) in the decoder for the addition group and the permutation group, respectively.
For each choice of learning rate and weight decay, we compute the number of steps to reach high (90%) training/validation accuracy.
The 2D plane is split into four phases: comprehension , grokking , memorization and confusion , defined in Table 1.
Both comprehension and grokking are able to generalize (in the “Goldilocks zone”), although the grokking phase has delayed generalization.
Memorization is also called overfitting, and confusion means failure to even memorize training data.
Figure 6 shows the phase diagrams for the addition group and the permutation group.
They display quite rich phenomena.
Competition between representation learning and decoder overfitting In the regression setup of the addition dataset, we show how the competition between representation learning and decoder learning (which depend on both learning rate and weight decay, among other things) lead to different learning phases in Figure 6 (a).
As expected, a fast decoder coupled with slow representation learning (bottom right) lead to memorization.
In the opposite extreme, although an extremely slow decoder [Figure] 1e [Figure]
1e
[Figure]
1e
[Figure]
r e p r e s e n t a t i o n l e a r n i n g r a t e c o m p r e h e n s i o n memorization grokking
[Figure]
1e
[Figure]
[Figure]
i
[Figure]
c o m p r e h e n s i o n memorization grokking
[Figure]
coupled with fast representation learning (top left) will generalize in the end, the generalization time is long due to the inefficient decoder training.
The ideal phase (comprehension) requires representation learning to be faster, but not too much, than the decoder.
Drawing from an analogy to physical systems, one can think of embedding vectors as a group of particles.
In our effective theory from Section 3.2, the dynamics of the particles are described only by their relative positions, in that sense, structure forms mainly due to inter-particle interactions (in reality, these interactions are mediated by the decoder and the loss).
The decoder plays the role of an environment exerting external forces on the embeddings.
If the magnitude of the external forces are small/large one can expect better/worse representations.
Universality of phase diagrams We fix the embedding learning rate to be 10 − 3 and sweep instead decoder weight decay in Figure 6 (b)(c)(d).
The phase diagrams correspond to addition regression (b), addition classification (c) and permutation regression (d), respectively.
Common phenomena emerge from these different tasks: (i) they all include four phases; (ii) The top right corner (a fast and capable decoder) is the memorization phase; (iii) the bottom right corner (a fast and simple decoder) is the confusion phase; (iv) grokking is sandwiched between comprehension and memorization, which seems to imply that it is an undesirable phase that stems from improperly tuned hyperparameters.
4.2 Beyond the toy model
We conjecture that many of the principles which we saw dictate the training dynamics in the toy model also apply more generally.
Below, we will see how our framework generalizes to transformer architectures for the task of addition modulo p , a minimal reproducible example of the original grokking paper [1].
We first encode p = 53 integers into 256D learnable embeddings, then pass two integers to a decoderonly transformer architecture.
For simplicity, we do not encode the operation symbols here.
The outputs from the last layer are concatenated and passed to a linear layer for classification.
Training both the encoder and the decoder with the same optimizer (i [Figure] e., with the same hyperparameters) leads to the grokking phenomenon.
Generalization appears much earlier once we lower the effective decoder capacity with weight decay (full phase diagram in Figure 7).
[Figure]
Early on, the model is able to perfectly fit the training set while having no generalization.
We study the embeddings at different training times and find that neither PCA (shown in Figure 1) nor t-SNE (not shown here) reveal any structure.
Eventually, validation accuracy starts to increase, and perfect generalization coincides with the PCA projecting the embeddings into a circle in 2D. Of course, no choice of dimensionality reduction is guaranteed to find any structure, and thus, it is challenging to show explicitly that generalization only occurs when a structure exists.
Nevertheless, the fact that, when coupled with the implicit regularization of the optimizer for sparse solutions, such a clear structure appears in a simple PCA so quickly at generalization time suggests that our analysis in the toy setting is applicable here as well.
This is also seen in the evolution of the entropy of the explained variance ratio in the PCA of the embeddings (defined as S = − (cid:80) i σ i log σ i where σ i is the fractional variance explained by the i th principal component).
As seen in Figure 7, the entropy increases up to generalization time then decreases drastically afterwards which would be consistent with the conjecture that generalization occurs when a low-dimensional structure is discovered.
The decoder then primarily relies on the information in this low-dimensional manifold and essentially “prunes” the rest of the high-dimensional embedding space.
Another interesting insight appears when we project the embeddings at initialization onto the principal axes at the end of training.
Some of the structure required for generalization exists before training hinting at a connection with the Lottery
Ticket Hypothesis.
See Appendix J for more details.
In Figure 7 (right), we show a comparable phase diagram to Figure 6 evaluated now in the transformer setting.
Note that, as opposed to the setting in [1], weight decay has only been applied to the decoder and not to the embedding layer.
Contrary to the toy model, a certain amount of weight decay proves beneficial to generalization and speeds it up significantly.
We conjecture that this difference comes from the different embedding dimensions.
With a highly over-parameterized setting, a non-zero weight decay gives a crucial incentive to reduce complexity in the decoder and help generalize in fewer steps.
This is subject to further investigation.
We also explore the effect of dropout layers in the decoder blocks of the transformer.
With a significant dropout rate, the generalization time can be brought down to under 10 3 steps and the grokking phenomenon vanishes completely.
The overall trend suggests that constraining the decoder with the same tools used to avoid overfitting reduces generalization time and can avoid the grokking phenomenon.
This is also observed in an image classification task where we were able to induce grokking.
See Appendix I for more details.
Related work
Relatively few works have analyzed the phenomenon of grokking. [2] describe the circuit that transformers use to perform modular addition, track its formation over training, and broadly suggest that grokking is related to the phenomenon of “phase changes” in neural network training. [3, 4] earlier provided speculative, informal conjectures on grokking [3, 4].
Our work is related to the following broad research directions:
Learning mathematical structures [5] trains a neural network to learn arithmetic operation from pictures of digits, but they do not observe grokking due to their abundant training data.
Beyond arithmetic relations, machine learning has been applied to learn other mathematical structures, including geometry [6], knot theory [7] and group theory [8].
Double descent Grokking is somewhat reminiscent of the phenomena of “epoch-wise” double descent [9], where generalization can improve after a period of overfitting.
[10] find that regularization can mitigate double descent, similar perhaps to how weight decay influences grokking.
Representation learning Representation learning lies at the core of machine learning [11–14].
Representation quality is usually measured by (perhaps vague) semantic meanings or performance on downstream tasks.
In our study, the simplicity of arithmetic datasets allows us to define representation quality and study evolution of representations in a quantitative way.
Physics of learning Physics-inspired tools have proved to be useful in understanding deep learning from a theoretical perspective.
These tools include effective theories [15, 16], conservation laws [17] and free energy principle [18].
In addition, statistical physics has been identified as a powerful tool in studying generalization in neural networks [19–22].
Our work connects a low-level understanding of models with their high-level performance.
In a recent work, researchers at Anthropic [23], connect a sudden decrease in loss during training with the emergence of induction heads within their models.
They analogize their work to statistical physics , since it bridges a “microscopic”, mechanistic understanding of networks with “macroscopic” facts about overall model performance.
Conclusion
We have shown how, in both toy models and general settings, that representation enables generalization when it reflects structure in the data.
We developed an effective theory of representation learning dynamics (in a toy setting) which predicts the critical dependence of learning on the training data fraction.
We then presented four learning phases (comprehension, grokking, memorization and confusion) which depend on the decoder capacity and learning speed (given by, among other things, learning rate and weight decay) in decoder-only architectures.
While we have mostly focused on a toy model, we find preliminary evidence that our results generalize to the setting of [1].
Our work can be viewed as a step towards a statistical physics of deep learning , connecting the “microphysics” of low-level network dynamics with the “thermodynamics” of high-level model behavior.
We view the application of theoretical tools from physics, such as effective theories [24], to be a rich area for further work.
The broader impact of such work, if successful, could be to make models more transparent and predictable [23, 25, 26], crucial to the task of ensuring the safety of advanced AI systems.
Appendix A Applicability of our toy setting
In the main paper, we focused on the toy setting with (1) the addition dataset and (2) the addition operation hard coded in the decoder.
Although both simplifications appear to have quite limited applicability, we argue below that the analysis of the toy setting can actually apply to all Abelian groups.
The addition dataset is the building block of all Abelian groups A cyclic group is a group that is generated by a single element.
A finite cyclic group with order n is C n = { e, g, g 2 , · · · , g n − 1 } where e is the identify element and g is the generator and g i =
g j whenever i =
j (mod n ) .
The modulo addition and { 0 , 1 , · · · , n − 1 } form a cyclic group with e = {+
+} and g can be any number q coprime to n such that ( q, n ) = 1 .
Since algorithmic datasets contain only symbolic but no arithmetic information, the datasets of modulo addition could apply to all other cyclic groups, e.g., modulo multiplication and discrete rotation groups in 2D.
Although not all Abelian groups are cyclic, a finite Abelian group G can be always decomposed into a direct product of k cyclic groups G = C n 1 × C n 2 · · · C n k .
So after training k neural networks with each handling one cyclic group separately, it is easy to construct a larger neural network that handles the whole Abelian group.
The addition operation is valid for all Abelian groups It is proved in [27] that for a permutation invariant function f ( x 1 , x 2 , · · · , x n ) , there exists ρ and ϕ such that [Equation] [Equation] or f ( x 1 , x 2 )
=
ρ ( ϕ ( x 1 ) + ϕ ( x 2 )) for n = 2 .
Notice that ϕ
( x i ) corresponds to the embedding vector
E i , ρ corresponds to the decoder.
The addition operator naturally emerges from the commutativity of the operator, not restricting the operator itself to be addition.
For example, multiplication of two numbers x [-
-]1 and x 2 can be written as x 1 x 2 = exp(ln( x 1 ) + ln( x 2 )) where ρ ( x ) =
exp( x ) and ϕ ( x ) = ln( x ) .
B An illustrative example
We use a concrete case to illustrate why parallelograms lead to generalization (see Figure 8). For the purpose of illustration, we exploit a curriculum learning setting, where a neural network is fed with a few new samples each time. We will illustrate that, as we have more samples in the training set, the ideal model M ∗ (defined in Section 3.2) will arrange the representation R ∗ in a more structured way, i.e., more parallelograms are formed, which helps generalization to unseen validation samples.
For simplicity we choose p = 6 .
• D 1 = (0 , 4) and D 2 = (1 , 3) have the same label, so (0 , 4 , 1 , 3) becomes a parallelogram
{+such that E 0 + E 
+}
{+= E 1 + E 3 → E 3 − E 
+}
= E 4 − E 1 .
{+D 
+}
{+= (1 , 5) and D 4 = (2 , 4) have the same label, so (1 , 5 , 2 , 4) becomes a parallelogram such that E 1 + E 
+}
{+= E 2 + E→ E 4 − E 
+}
=
E 5 − E 2 .
{+We can derive from the first two equations that E 5 − E 
+}
=
{+E 3 − E 
+}
→ E 0 + E 5 =
E 2 + E 3 , which implies that (0 , 5 , 2 , 3) is also a parallelogram (see Figure 8(a)).
This
means if (0 , 5) in training set, our model can predict (2 , 3) correctly.
• D 5 = (0 , 2) and D 6 = (1 , 1) have the same label, so E 0 + E 2 = 2 E 1 , i.e., 1 is the middle point of 0 and 2 (see Figure 8(b)).
Now we can derive that 2 E 4 =
E 3 + E 5 , i.e., 4 is the middle point of 3 and 5 .
If (4 , 4) is in the training data, our model can predict (3 , 5) correctly.
Finally, D 7 = (2 , 4) and D 8 = (3 , 3) have the same label, so 2 E 3 =
E 2 + E 4 ,
i
e., 3 should be placed at the middle point of 2 and 4 , ending up Figure 8(c).
This linear structure agrees with the arithmetic structure of R .
In summary, although we have p ( p + 1) / 2 = 21 different training samples for p = 6 , we only needtraining samples to uniquely determine the perfect linear structure (up to linear transformation).
The punchline is: representations lead to generalization.
C Definition of (cid:100) Acc
Given a training set D and a representation R , if ( i, j ) is a validation sample, can the neural network correctly predict its output, i.e., Dec( E i + E j )
=
Y i + j ?
Since neural network has never seen ( i, j ) in the training set, one possible mechanism of induction is through
[Equation]
The first equality Dec( E i + E j ) =
Dec( E m + E n ) holds only when E i + E j = E m + E n (i.e., ( i, j, m, n ) is a parallelogram).
The second equality Dec( E m + E n ) =
Y m+n , holds when ( m, n ) is in the training set, i.e., ( m, n ) ∈ D , under the zero training loss assumption.
Rigorously, given a training set D and a parallelogram set P (which can be calculated from R ), we collect all zero loss samples in an augmented training set D [Equation]
[Equation]
Keeping D fixed, a larger P would probably produce a larger D , i.e., if P 1 ⊆ P 2 , then D ( D, P 1 ) ⊆
D ( P, P 2 ) , which is why in Eq.
(3) our defined RQI ∝ | P | gets its name “representation quality index", because higher RQI normally means better generalization.
Finally, the expected accuracy from a dataset D and a parallelogram set P is:
[Equation]
which is the estimated accuracy (of the full dataset), and P = P ( R ) is defined on the representation after training.
On the other hand, accuracy Acc can be accessed empirically from trained neural network.
We verified Acc ≈ (cid:100)
Acc in a toy setup (addition dataset p = 10 , 1D embedding space, hard code addition), as shown in Figure 3 (c).
Figure 3 (a)(b) show Acc and (cid:100)
Acc as a function of training set ratio, with each dot corresponding to a different random seed.
The dashed red diagonal corresponds to memorization of the training set, and the vertical gap refers to generalization.
Although the agreement is good for 1D embedding vectors, we do not expect such agreement can trivially extend to high dimensional embedding vectors.
In high dimensions, our definition of RQI is too restrictive.
For example, suppose we have an embedding space with N dimensions.
Although the representation may form a linear structure in the first dimension, the representation can be arbitrary in other N − 1 dimensions, leading to RQI ≈ 0 .
However, the model may still generalize well if the decoder learns to keep only the useful dimension and drop all other N − 1 useless dimensions.
It would be interesting to investigate how to define an RQI that takes into account the role of decoder in future works.
D The gap of a realistic model M and the ideal model M ∗
Realistic models M usually form fewer number of parallelograms than ideal models M ∗ .
In this section, we analyze the properties of ideal models and calculated ideal RQI and ideal accuracy, which set upper bounds for empirical RQI and accuracy.
The upper bound relations are verified via numerical experiments in Figure 9.
Similar to Eq.
(12) where some validation samples can be derived from training samples, we demonstrate how implicit parallelograms can be ‘derived’ from explicit ones in P [-
-]0 ( D ) .
The so-called derivation follows a simple geometric argument that: if A 1 B 1 is equal and parallel to A 2 B 2 , and
A 2 B 2 is equal and parallel to A 3 B 3 , then we can deduce that A 1 B 1 is equal and parallel to A 3 B(hence ( A 1 , B 2 , A 2 , B 1 ) is a parallelogram).
Recall that a parallelogram ( i, j, m, n ) is equivalent to E i + E j = E m + E n ( ∗ ) .
So we are equivalently asking if equation ( ∗ ) can be expressed as a linear combination of equations in
A ( P 0 ( D )) .
If yes, then ( ∗ ) is dependent on A ( P 0 ( D ))
(defined in Eq.
(7)), i.e., A ( P 0 ( D )) and
A ( P 0 ( D ) (cid:83) ( i, j, m, n )) should have the same rank.
We augment P
( D ) by adding implicit parallelograms, and denote the augmented parallelogram set as
[Equation]
We need to emphasize that an assumption behind Eq.
(14) is that we have an ideal model M ∗ .
When the model is not ideal, e.g., when the injectivity of the encoder breaks down, fewer parallelograms are expected to form, i.e.,
[Equation]
The inequality is saying, whenever a parallelogram is formed in the representation after training, the reason is hidden in the training set.
This is not a strict argument, but rather a belief that today’s neural networks can only copy what datasets (explicitly or implicitly) tell it to do, without any autonomous creativity or intelligence.
For simplicity we call this belief Alexander Principle .
In very rare cases when something lucky happens (e.g., neural networks are initialized at approximate correct weights),
Alexander principle may be violated.
Alexander principle sets an upper bound for RQI :
[Equation]
[-R Q I (b) 0 .0 .0 .
-]
[-i z a t i o n (e) 0 .0 .0 .
-]
and sets an upper bound for
[Equation]
In Figure 9 (c)(f), we verify Eq.
(16) and Eq.
We choose δ = 0 .
01 to compute RQI( R , δ ).
We find the trained models are usually far from being ideal, although we already include a few useful tricks proposed in Section 4 to enhance representation learning.
It would be an interesting future direction to develop better algorithms so that the gap due to Alexander principle can be reduced or even closed.
In Figure 9 (a)(b)(d)(e), four quantities (RQI, RQI , Acc, Acc ) as functions of the training data fraction are shown, each dot corresponding to one random seed.
It is interesting to note that it is possible to have RQI = 1 only with < 40% training data, i.e., 55 × 0 .
4 = 22 samples, agreeing with our observation in Section 3.
Realistic representations Suppose an ideal model M ∗ and a realistic model M which train on the training set D give the representation R ∗ and R , respectively.
What is the relationship between R and R ∗ ?
Due to the Alexander principle we know P ( R ) ⊆
P ( D ) =
P ( R ∗ ) .
This means R ∗ has more parallelograms than R , hence R ∗ has fewer degrees of freedom than R .
We illustrate with the toy case p = 4 .
The whole dataset contains p ( p + 1) / 2 = 10 samples, i.e.,
D
= { (0 , 0) , (0 , 1) , (0 , 2) , (0 , 3) , [Equation] [Equation]
The parallelogram set contains only three elements, i.e.,
[Equation]
[Equation]
Or equivalently the equation set
[Equation]
Pictorially, we can split all possible subsets { A | A ⊆
A 0 } into different levels, each level defined by | A | (the number of elements).
A subset A 1 in the i th level points an direct arrow to another subset
A 2 in the ( i + 1) th level if A 2 ⊂ A 1 , and we say A 2 is a child of A 1 , and A 1 is a parent of A 2 .
Each subset A can determine a representation R with n ( A ) degrees of freedom.
So R should be a descendant of R ∗ , and n ( R ∗ ) ≤ n ( R ) .
Numerically, n ( A ) is equal to the dimension of the null space of A .
0 training data fraction 0 .0 .0 .0 .0 .1 .
R Q I (a) 0 .0 .0 .0 .0 .1 .
0 training {+data fraction 0 .0 .0 .0 .0 .1 . R Q I (b) 0 .0 .0 .
 RQI 0 .0 .0 .0 .0 .1 . R Q+}
I
I d e a l A l go r
i t h m
A l e x a nd e r
P r i n c i p l e (c) 0 .0 .0 .0 .0 .1 .
0 training data fraction 0 .0 .0 .0 .0 .1 .
A cc
M e m o r
i z a t
i o n (d) 0 .0 .0 .0 .0 .1 .
0 training data fraction 0 .0 .0 .0 .0 .1 .
A cc
{+M e m o r i z a t i o n (e) 0 .0 .0 .
 Acc 0 .0 .0 .0 .0 .1 . A cc+}
I d e a l A l go r
i t h m
A l e x a nd e r P r i n c i p l e (f) c)(f), RQI and Acc of the ideal algorithm sets upper bounds for those of the realistic algorithm. Suppose we have a training set
[Equation] [Equation]
21) and correspondingly P ( D ) =
P 0 , A ( P ) =
A 0 .
So an ideal model M ∗ will have the linear structure
E k
=
a + k b (see Figure 10 leftmost).
However, a realistic model M may produce any descendants of the linear structure, depending on various hyperparameters and even random seeds.
In Figure 11, we show our algorithms actually generates all possible representations.
We have two settings: (1) fast decoder ( η 1 , η 2 ) =
(10 − 3 , 10 − 2 ) (Figure 11 left), and (2) relatively slow decoder ( η 1 , η 2 ) =
(10 − 2 , 10 − 3 ) (Figure 11) right).
The relatively slow decoder produces better representations (in the sense of higher RQI) than a fast decoder, agreeing with our observation in
Section 4.
E Conservation laws of the effective theory
Recall that the effective loss function
[Equation]
22) where ℓ 0 and Z 0 are both quadratic functions of R = { E 0 , · · · , E p − 1 } , and ℓ eff = 0 remains zero under rescaling and translation E ′ i = a E i + b .
{+We will ignore the 1 / | P 
 ( D ) | factor in ℓ 0 since having it is equivalent to rescaing time, which does not affect conservation laws.+}
The representation vector E i evolves according to the gradient descent
[Equation]
We will prove the following two quantities are conserved:
[Equation]
Eq.
(22) and Eq.
(23) give
[Equation]
E
[Equation]
Then
[Equation]
where the last equation uses the fact that
[Equation]
The conservation of Z 0 prohibits the representation from collapsing to zero.
Now that we have demonstrated that Z 0 is a conserved quantity, we can also show
[Equation]
The last equality holds because the two summations can be swapped and
[Equation]
F More phase diagrams of the toy setup
We study another three hyperparameters in the toy setup by showing phase diagrams similar to
Figure 6.
The toy setup is: (1) addition without modulo ( p = 10 ); (2) training/validation is split into 45/10; (3) hard code addition; (4) 1D embedding.
In the following experiments, the decoder is an
MLP with size 1-200-200-30.
The representation and the encoder are optimized with AdamW with different hyperparameters.
The learning rate of the representation is 10 − 3 .
We sweep the learning rate of the decoder in range [10 − 4 , 10 − 2 ] as the x axis, and sweep another hyperparameter as the y axis.
By default, we use full batch size 45, initialization scale s = 1 and zero weight decay of representation.
Batch size controls the amount of noise in the training dynamics.
In Figure 12, the grokking region appears at the top left of the phase diagram (small decoder learning rate and small batch size).
However, large batch size (with small learning rate) leads to comprehension, implying that smaller batch size seems harmful.
This makes sense since to get crystals (good structures) in experiments, one needs a freezer which gradually decreases temperature, rather than something perturbing the system with noise.
Initialization scale controls distances among embedding vectors at initialization.
We initialize components of embedding vectors from independent uniform distribution U [ − s/ 2 , s/ 2] where s is called the initialization scale.
Shown in Figure 13, it is beneficial to use a smaller initialization scale.
This agrees with the physical intuition that closer particles are more likely to interact and form structures.
For example, the distances among molecules in ice are much smaller than distances in gas.
Representation weight decay controls the magnitude of embedding vectors.
Shown in Figure 14, we see the representation weight decay in general does not affect model performance much. [Figure] [Figure]
a [Figure] c h s i ze c
[Figure]
m
[Figure]
h e n s
[Figure]
o n memorization grokking confusion
Addition group (regression)
[Figure]
b a t c h s i ze c
o m p r
e
h e n s i o n memorization g r
o kk i n g confusion
Addition group (classiﬁcation)
[Figure]
i n i t i a li z a t i o n s c a l e
[Figure]
G General groups G.1 Theory
We focused on Abelian groups for the most part of the paper.
This is, however, simply due to pedagogical reasons.
In this section, we show that it is straight-forward to extend definitions of parallelograms and representation quality index (RQI) to general non-Abelian groups.
We will also show that most (if not all) qualitative results for the addition group also apply to the permutation group.
Matrix representation for general groups Let us first review the definition of group representation.
A representation of a group G on a vector space V is a group homomorphism from G to GL( V ) , the general linear group on V .
That is, a representation is a map ρ : G → GL( V ) such that
[Equation]
In the case V is of finite dimension n , it is common to identify GL( V ) with n by n invertible matrices.
The punchline is that: each group element can be represented as a matrix, and the binary operation is represented as matrix multiplication.
1e1e- 1e-2 learning rate 0.
w e i g h t d ec a y (r e p r e s e n t a t i o n ) c
o m p
r
e h e n s i o n memorization g r o kk i n g
1e1e- 1e-2 learning rate 0.
w e i g h t d ec a y (r e p r e s e n t a t i o n ) c
o m p
r
e h e n s i o n m e m o r
i z a t
i o n g r o kk i n g c o n f u s i o n
A new architecture for general groups Inspired by the matrix representation, we embed each group element a as a learnable matrix E a ∈ R d × d (as opposed to a vector), and manually do matrix multiplication before sending the product to the deocder for regression or classification.
More concretly, for a ◦ b = c , our architecture takes as input two embedding matrices E a and E b and aims to predict Y c such that Y c
=
Dec( E a E b ) , where E a E b means the matrix multiplication of E a and E b .
The goal of this simplication is to disentangle learning the representation and learning the arithmetic operation (i.e, the matrix multiplication).
We will show that, even with this simplification, we are still able to reproduce the characteristic grokking behavior and other rich phenomenon.
Generalized parallelograms we define generalized parallelograms: ( a, b, c, d ) is a generalized parallelogram in the representation if || E a E b −
E c E d || 2 F ≤ δ , where δ > 0 is a threshold to tolerate numerical errors.
Before presenting the numerical results for the permutation group, we show an intuitive picture about how new parallelograms can be deduced from old ones for general groups, which is the key to generalization.
Deduction of parallelograms We first recall the case of the Abelian group (e.g., addition group).
As shown in Figure 15, when ( a, d, b, c ) and ( c, f, d, e ) are two parallelograms, we have
[Equation]
We can derive that E a + E f = E b
+ E e implying that ( a, f, b, e ) is also a parallelogram.
That is, for
Abelian groups, two parallelograms are needed to deduce a new parallelogram.
For the non-Abelian group, if we have only two parallelograms such that
[Equation]
we have E − 1 b E a = E c E − 1 d = E − 1 f E e , but this does not lead to something like E f E a = E e E b , hence useless for generalization.
However, if we have a third parallelogram such that
[Equation]
we have E − 1 b E a = E c E − 1 d = E − 1 f E e =
E g E − 1 h , equivalent to E a E h
= E b E g , thus establishing a new parallelogram ( a, h, b, g ) .
That is, for non-Abelian groups, three parallelograms are needed to deduce a new parallelogram.
G.2 Numerical Results
In this section, we conduct numerical experiments on a simple non-abelian group: the permutation group S 3 .
The group has 6 group elements, hence the full dataset contains 36 samples.
We embed each group element a into a learnable 3 × 3 embedding matrix E a .
We adopt the new architecture described in the above subsection: we hard code matrix multiplication of two input embedding matrices before feeding to the decoder.
After defining the generalized parallelogram in the last subsection, we can continue to define RQI (as in Section 3) and predict accuracy (cid:100)
Acc from representation (as in appendix
C).
We also compute the number of steps needed to reach RQI = 0 .
Representation We flatten each embedding matrix into a vector, and apply principal component analysis (PCA) to the vectors.
We show the first three principal components of these group elements in Figure 16.
On the plane of PC1 and PC3 , the six points are organized as a hexagon. [Figure] [Equation] [Figure]
[-PC 1 3 2 1 0 1 
-][Equation] [Figure] [Equation] [Figure]
[Equation] [Figure] [Equation] [Figure]
[Equation] [Figure] [Equation] [Figure]
[Equation] [Equation] [Equation] [Figure]
[Equation] [Figure] [Figure] [Figure]
[Figure]
[Figure]
[Figure]
[Figure]
2] [0, 2, 1] [1, 0, 2] [1, 2, 0] [2, 0, 1] [2, 1, 0]      3 PC1 1.
P C[0, 1, 2] [0, 2, 1] [1, 0, 2] [1, 2, 0] [2, 0, 1] [2, 1, 0] 1.5 1.0 0.5 0.0 0.5 1.0 1.5 PC2 1.
P C[0, 1, 2] [0, 2, 1] [1, 0, 2] [1, 2, 0] [2, 0, 1] [2, 1, 0]
RQI In Figure 17 (a), we show RQI
For we run 11 random
Steps to reach RQI = 0 .
In Figure 17 (b), we whow the steps to reach RQI > 0 .
95 as a function of training data fraction, and find a phase transition at r = r c = 0 .
The blue line corresponds to the best model (smallest number of steps).
Accuracy The real accuracy Acc is shown in Figure 17 (c), while the predicted accuracy (cid:100)
Acc (calculated from RQI) is shown in Figure 17 (d).
Their comparison is shown in (e): (cid:100)
Acc is a lower bound of Acc , implying that there must be some generalization mechanism beyond RQI.
Phase diagram We investigate how the model performance varies under the change of two knobs: decoder learning rate and decoder weight decay.
We calculate the number of steps to training accuracy ≥ 0 .
9 and validation accuracy ≥ 0 .
9 , respectively, shown in Figure 6 (d).
8 training data fraction 0 .0 .0 .0 .0 .1 .
R Q I (a) 0 .0 .0 .
8 training data fraction 1010s t e p s t o
R Q I > 0 . r c = 0 .(b) 0 .0 .0 .0 .1 .
0 training data fraction 0 .0 .
A cc (c) 0 .0 .0 .0 .1 .
0 training data fraction 0 .0 .
9 1 .d
A cc (d) 0 .0 .0 .0 .1 .d
Acc 0 .0 .
A cc (e) serves as a lower bound of Acc
H Effective theory for image classification
to their class-means, while class-means of different classes stay separable.
As such, the effective theory serves as a novel self-supervised learning method, as well as shed some light on neural collapse
Please see texts in Appendix H
In this section, we show our effective theory proposed in Section 3.2 can generalize beyond algorithmic datasets.
In particular, we will apply the effective theory to image classifications.
We find that: (i)
The effective theory naturally gives rise to a novel self-supervised learning method, which can provably avoid mode collapse without contrastive pairs.
(ii)
The effective theory can shed light on the neural collapse phenomenon [28], in which same-class representations collapse to their class-means.
We first describe how the effective theory applies to image classification.
The basic idea is again that, similar to algorithmic datasets, neural networks try to develop a structured representation of the inputs based on the relational information between samples (class labels in the case of image classification, sum parallelograms in the case of addition, etc.).
The effective theory has two ingredients: (i) samples with the same label are encouraged to have similar representations; (ii) the effective loss function is scale-invariant to avoid all representations collapsing to zero (global collapse).
As a result, an effective loss for image classification has the form
[Equation]
where x is an image, f ( x ) is its representation, ( x , y ) ∈ P refers to unique pairs x and y that have the same label.
Scale invariance means the loss function ℓ eff does not change under the linear scaling f ( x ) → a f ( x ) .
Relation to neural collapse It was observed in [28] that image representations in the penultimate layer of the model have some interesting features: (i) representations of same-class images collapse to their class-means; (ii) class-means of different classes develop into an equiangular tight frame.
Our effective theory is able to predict the same-class collapse, but does not necessarily put class-means into equiangular tight frames.
We conjecture that little explicit repulsion among different classes can help class-means develop into an equiangular tight frame, similar to electrons developing into lattice structures on a sphere under repulsive Coulomb forces (the Thomson problem [29]).
We would like to investigate this modification of the effective theory in the future.
Experiment on MNIST We directly apply the effective loss Eq.
(32) to the MNIST dataset.
Firstly, each image x is randomly encoded to a 2D embedding f ( x ) via the same encoder MLP whose weights are randomly initialized.
We then train these embeddings by minimizing the effective loss ℓ eff with an Adam optimizer ( 10 − 3 learning rate) for 100 steps.
We show the evolution of these embeddings in
Figure 18.
Images of the same class collapse to their class-means, and different class-means do not collapse.
This means that our effective theory can give rise to a good representation learning method which only exploits non-contrastive relational information in datasets.
Link to self-supervised learning Note that ℓ itself is vulnerable to global collapse, in the context of Siamese learning without contrastive pairs.
Various tricks (e.g., decoder with momentum, stop gradient) [13, 30] have been proposed to avoid global collapse.
However, the reasons why these tricks can avoid global collapse are unclear.
We argue ℓ fails simply because ℓ → a 2 ℓ under scaling f ( x ) → a f ( x ) so gradient descent on ℓ encourage a → 0 .
Based on this picture, our effective theory provides another possible fix: make the loss function ℓ scale-invariant (by the normalized loss ℓ eff ), so the gradient flow has no incentive to change representation scales.
In fact, we can prove that the gradient flow on ℓ eff preserve Z (variance of representations) so that global collapse is avoided provably:
[Equation]
[Equation]
33) where we use the fact that
[Equation]
[Equation]
[Figure]
We now demonstrate, for the first time, that grokking (significantly delayed generalization) is a more general phenomenon in machine learning that can occur not only on algorithmic datasets, but also on mainstream benchmark datasets.
In particular, we exhibit grokking on MNIST and demonstrate that we can control grokking by varying optimization hyperparameters, just as we did in the main text for algorithmic datasets in both the full case (transformers) and in the toy model.
To induce grokking on MNIST, we make two nonstandard decisions: (1) we reduce the size of the training set from 50k to 1k samples (by taking a random subset) and (2) we increase the scale of the weight initialization distribution (by multiplying the initial weights, sampled with Kaiming uniform initialization, by a constant > 1 ).
The choice of large initializations is justified by [31–33] which find large initializations overfit data easily but prone to poor generalization.
Relevant to this, initialization scale is found to regulate “kernel” vs “rich” learning regimes in networks [34].
With these modifications to training set size and initialization scale, we train a depth-3 [-width-
 MLP-]widthMLP with ReLU activations with the AdamW optimizer.
We use MSE loss with one-hot targets, rather than cross-entropy.
With this setup, we find that the network quickly fits the train set, and then much later in training validation accuracy improves, as shown in Figure 19a.
This closely follows the stereotypical grokking learning, first observed in algorithmic datasets.
With this setup, we also compute a phase diagram over the model weight decay and the last layer learning rate.
See Figure 19b.
While in MLPs it is less clear what parts of the network to consider the “encoder” vs the “decoder”, for our purposes here we consider the last layer to be the “decoder” and vary its learning rate relative to the rest of the network.
The resulting phase diagram has some similarity to Figure 7.
We observe a “confusion”phase in the bottom right (high learning rate and high weight decay), a “comprehension” phase bordering it, a “grokking” phase as one decreases weight decay and decoder learning rate, and a “memorization“ phase at low weight decay and low learning rate.
Instead of an accuracy threshold of 95%, we use a threshold of 60% here for validation accuracy for runs to count as comprehension or grokking.
This phase diagram demonstrates that with sufficient regularization, we can again “de-grok” learning.
We also investigate the effect of training set size on time to generalization on MNIST.
We find a result similar to what Power et al.
[1] observed, namely that generalization time increases rapidly once one drops below a certain amount of training data.
See Figure 20.
J Lottery Ticket Hypothesis Connection
In Figure 21, we show the projection of the learned embeddings after generalization to their first two principal components.
Compared to the projection at initialization, structure clearly emerges in
[Figure]
[Figure]
embedding space when the neural network is able to generalize ( > 99% validation accuracy).
What is intriguing is that the projection of the embeddings at initialization to the principal components of the embeddings at generalization seem to already contain much of that structure.
In this sense, the structured representation necessary for generalization already existed (partially) at initialization.
The training procedure essentially prunes other unnecessary dimensions and forms the required parallelograms for generalization.
This is a nonstandard interpretation of the lottery ticket hypothesis where the winning tickets are not weights or subnetworks but instead particular axes or linear combinations of the weights (the learned embeddings).
In Figure 22, we show the original training curves (dashed lines).
In solid lines, we recompute accuracy with models which use embeddings that are projected onto the n principal components of the embeddings at the end of training (and back).
Clearly, the first few principal components contain enough information to reach 99% accuracy.
The first few PCs explain the most variance by definition, however, we note that this is not necessarily the main reason for why they can generalize so well.
In fact, embeddings reconstructed from the PCA at the end of training (solid lines) perform better than current highest variance axes (dotted line).
This behavior is consistent across seeds.
[Figure]
[Figure]
K Derivation of the effective loss
In this section, we will further motivate the use of our effective loss to study the dynamics of representation learning by deriving it from the gradient flow dynamics on the actual MSE loss in linear regression.
The loss landscape of a neural network is in general nonlinear, but the linear case may shed some light on how the effective loss can be derived from actual loss.
For a sample r (which is the sum of two embeddings E i and E j ), the prediction of the linear network is D ( r ) =
Ar + b .
The loss function is ( y is its corresponding label):
[Equation]
where the first and the second term are prediction error and regularization, respectively.
Both the model ( A , b ) and the input r are updated via gradient flow, with learning rate η A and η x , respectively:
[Equation]
Inserting ℓ into the above equations, we obtain the gradient flow:
[Equation]
For the d b /dt equation, after ignoring the Ar term and set the initial condition b (0) = 0 , we obtain analytically b ( t ) =
(1 − e − 2 η A t ) y .
Inserting this into the first and third equations, we have
[Equation]
internal
[Equation]
external force
[Equation]
For the second equation on the evolution of d r /dt , we can artificially decompose the right hand side into two terms, based on whether they depend on the label y .
In this way, we call the first term "internal interaction" since it does not depend on y , while the second term "external force".
Note this distinction seems a bit artificial from a mathematical perspective, but it can be conceptually helpful from a physics perspective.
We will show below the internal interaction term is important for representations to form.
Because we are interested in how two samples interact, we now consider another sample at r ′ , and the evolution becomes
[Equation]
Subtracting d r /dt by d r ′ /dt and setting r ′ = − r , the above equations further simply to
[Equation]
The second equation implies that the pair of samples interact via a quadratic potential U ( r ) = 12 r T A T Ar , leading to a linear attractive force f ( r ) ∝ r .
We now consider the adiabatic limit where η A → 0 .
The adiabatic limit Using the standard initialization (e.g., Xavier initialization) of neural networks, we have A T
A
≈ I .
As a result, the quadratic potential becomes U ( r ) = 12 r T r , which is timeindependent because η A → 0 .
We are now in the position to analyze the addition problem.
For two samples x (1) =
E i + E j and x (2) =
E m + E n with the same label ( i + j = m + n ), they contribute to an interaction term
[Equation]
Averaging over all possible quadruples in the training dataset D , the total energy of the system is
[Equation]
where P
( D ) =
{ ( i, j, m, n ) | i + j = m + n, ( i, j ) ∈ D, ( m, n ) ∈ D } .
To make it scale-invariant, we define the normalized Hamiltonian Eq.
(42) as
[Equation]
which is the effective loss we used in Section 3.2.