← Latest papers
🤖 machine learning

Egalitarian Gradient Descent: A Simple Approach to Accelerated Grokking

This paper introduces Egalitarian Gradient Descent (EGD), a simple modification that normalizes gradients to ensure uniform evolution speed across all principal directions, thereby theoretically and empirically demonstrating that it significantly accelerates or completely eliminates the "grokking" phenomenon where generalization performance suddenly improves after prolonged stagnation.

Original authors: Ali Saheb Pasand, Elvis Dohmatob

Published 2026-05-18
📖 5 min read🧠 Deep dive

Original authors: Ali Saheb Pasand, Elvis Dohmatob

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Problem: The "Grokking" Mystery

Imagine you are teaching a robot to solve a math puzzle.

  1. Phase 1 (Memorization): The robot quickly memorizes the answers to the specific practice problems you give it. It gets 100% on the practice test.
  2. Phase 2 (The Stagnation): You ask it to take a new test with different numbers. Suddenly, the robot fails. It keeps failing for a very long time, even though you keep training it. It seems stuck.
  3. Phase 3 (The "Grok"): Then, out of nowhere, the robot suddenly "gets it." Its performance on the new test jumps from 0% to nearly 100% in a single moment.

This phenomenon is called Grokking. The paper calls the long period of failure in Phase 2 a "plateau." The goal of this research is to make the robot skip the long, boring plateau and get to the "Aha!" moment much faster.

The Diagnosis: Why Does the Robot Get Stuck?

The authors discovered that the robot gets stuck because it is trying to learn different parts of the puzzle at different speeds.

Imagine the robot has a team of workers (called "principal directions" or "singular directions") trying to fix a broken machine.

  • Worker A is very strong and fast. They fix their part of the machine instantly.
  • Worker B is very weak and slow. They take forever to fix their part.

In standard training (called "Vanilla Gradient Descent"), the boss (the algorithm) tells everyone to work at the same pace. Because Worker A is so fast, they finish their job and just stand around waiting. Because Worker B is so slow, the whole team is held up. The robot can't "grok" (generalize) until the slowest worker finally catches up.

The paper shows that this happens because the "gradient" (the instruction on how to fix the error) is ill-conditioned. It's like trying to push a heavy box where one side is on ice (slippery/fast) and the other is on mud (sticky/slow). The box spins or stalls instead of moving forward smoothly.

The Solution: Egalitarian Gradient Descent (EGD)

The authors propose a new method called Egalitarian Gradient Descent (EGD).

The Analogy:
Instead of letting the fast worker finish early and wait, the boss (EGD) steps in and says:

"No one moves faster than the slowest person. We are all going to move at the exact same speed."

EGD does this by mathematically normalizing the instructions. It takes the fast instructions and slows them down, and it takes the slow instructions and speeds them up, so that every "worker" in the robot's brain progresses at the exact same rate.

  • The Result: The robot stops waiting for the slow parts. All parts of the solution evolve together. The "stagnation" disappears, and the robot reaches the "Aha!" moment almost immediately.

How It Works (The Magic Trick)

To do this, the method looks at the "shape" of the instructions the robot is receiving. It uses a mathematical tool called SVD (Singular Value Decomposition) to find the fast directions and the slow directions.

Then, it performs a "whitening" operation (similar to how a photo editor might balance the colors so no single color is too bright or too dark). It ensures that the "volume" of the update is the same for every direction.

  • Simple Version: The paper also suggests a "Column Normalization" trick. This is a simplified version where you just divide the instructions by their size. It's not as perfect as the full method, but it still works much better than doing nothing.

Comparison to Other Methods

The paper compares EGD to a previous method called Grokfast.

  • Grokfast is like a filter that tries to boost the "quiet" (slow) voices in the room so they can be heard over the "loud" (fast) voices. It works, but it requires remembering a lot of past conversations (memory) and tuning many knobs (hyperparameters).
  • EGD is like a manager who simply tells everyone to speak at the same volume. It doesn't need to remember the past, it doesn't need extra memory, and it doesn't need complex settings. It just works.

What the Experiments Showed

The authors tested this on classic "hard" puzzles where grokking is common, such as:

  • Modular Arithmetic: Adding or multiplying numbers and taking the remainder (e.g., "What is 7 + 5 mod 10?").
  • Sparse Parity: A logic puzzle involving flipping bits based on a secret rule.

The Results:

  • Standard Training: The robot trained for thousands of steps, stayed stuck at 0% accuracy for a long time, and then suddenly jumped to 100%.
  • EGD Training: The robot jumped to 100% accuracy after just a few steps. The long plateau was completely removed.

They also tested this on more realistic tasks (like recognizing handwritten digits or images) and found that EGD still made the robot learn faster and more stably, without needing extra computer memory.

The Bottom Line

The paper claims that "Grokking" (the sudden jump in intelligence) is often just a side effect of the robot's learning process being unbalanced. By forcing all parts of the learning process to move at the same speed (Egalitarian Gradient Descent), we can eliminate the long, frustrating waiting period and get the model to understand the task almost instantly.

Drowning in papers in your field?

Get daily digests of the most novel papers matching your research keywords — with technical summaries, in your language.

Try Digest →