💬 NLP

GaugeQuant: Online Learning of Quantization-Optimal Bases from LLM Symmetries

GaugeQuant is an online learning method that leverages LLM symmetries and a LogSumExp loss term to dynamically learn quantization-optimal bases during training, significantly reducing perplexity under low-bit quantization without requiring calibration data or altering the language modeling objective.

Original authors: Miguel P. Bento, João F. Seabra

Published 2026-07-27

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Miguel P. Bento, João F. Seabra

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

Imagine you are trying to fit a massive, intricate library of knowledge into a tiny backpack. This is the daily struggle of modern Artificial Intelligence. The "brains" of these AI systems, called Large Language Models, are so huge that they require mountains of computer memory just to run. To make them fit into smaller devices, scientists use a trick called quantization. Think of this like compressing a high-definition movie into a low-resolution file to save space. You lose some detail, but the movie is still watchable. However, there's a catch: sometimes the movie has a few scenes that are incredibly bright or dark (called "outliers"). When you try to compress the whole file to fit those extreme scenes, the rest of the movie gets blurry and distorted.

For a long time, scientists tried to fix this after the AI was already built, like trying to edit a movie after it's been filmed. They would look at the "bright spots" and try to smooth them out using a small sample of data. But this paper introduces a new idea: what if we could teach the AI to organize its own library while it is being built, so it naturally fits into the backpack without needing a messy cleanup later? The researchers propose a method that uses the AI's own internal "flexibility" to rearrange its data before it gets squished, making the compression much cleaner.

The Paper: GaugeQuant

The paper you're reading is about a clever new technique called GaugeQuant. The authors, Miguel P. Bento and João F. Seabra, discovered that the internal structure of these AI models has a hidden superpower: symmetry.

To understand this, imagine the AI's brain is made of thousands of spinning gears. In many places, these gears can spin in perfect sync with each other without changing the final answer the AI gives. It's like if you had a team of dancers; if they all rotate 90 degrees together, the choreography looks the same from the audience's perspective. The AI doesn't care which specific "angle" the data is coming from, as long as the relationships between the gears stay the same.

The problem is that when we try to compress the AI (quantize it), we have to pick a specific angle. If we pick the wrong one, the "outliers" (the super-bright or super-dark data points) get stretched out, ruining the compression. Usually, scientists have to wait until the AI is finished training to figure out the best angle, using a separate dataset to test it.

GaugeQuant changes the game by doing this during training. The authors added a special "penalty" to the AI's homework. Imagine the AI is learning to write stories, and the teacher (the computer) says, "Great story! But if you use any words that are too extreme or weird, you lose points." This penalty is based on a mathematical formula called LogSumExp. It gently nudges the AI to rearrange its internal gears (rotating its data) so that no single number becomes an extreme outlier.

Here is the magic part: The AI has to do this rearranging without messing up its ability to write stories. The authors used a "stop-gradient" trick. Think of it as a one-way mirror. The AI learns to write better stories using its normal lessons, but it learns to organize its data for compression using a separate, invisible lesson. The two don't interfere with each other. The AI finds the "perfect angle" for its data automatically, so when it's finally compressed, everything fits snugly without losing quality.

What They Found

The researchers tested this on two famous AI models: Qwen-2.5 0.5B and LLaMA-2 7B. They simulated compressing the models to very low precision (using only 4 bits for weights and activations, which is a very tight squeeze).

The results were quite promising:

For the LLaMA-2 7B model, when they compressed both the weights and the activations to 4 bits (W4A4) with a group size of 128, the "perplexity" (a score where lower is better, meaning the AI is less confused) dropped from 8.22 to 6.73.
When they compressed just the weights to 4 bits but kept the activations full precision (W4A16), the score improved even more dramatically, dropping from 11.16 to 5.45.
For the smaller Qwen-2.5 0.5B model, the improvements were also significant, with the W4A4 score dropping from 187.8 to 61.2.

The authors note that this method requires no special calibration data (no need for a separate test set) and adds almost no extra time to the training process. It competes with methods that usually require the model to be frozen and tested extensively after training.

What It Doesn't Do (and What's Still Unknown)

It's important to know what this method doesn't solve. The authors found that if you try to compress the activations to 4 bits using just one single scale for the whole token (a very strict setting called "per-token"), the models still fail and become unusable, regardless of the rotation. The method works best when you allow for some grouping (like the group size of 128).

Also, the authors admit that their method relies on a "proxy" (a stand-in) for the actual compression error. They use the LogSumExp formula to guess where the outliers are, but it's not a perfect simulation of the real-world compression. They suggest this might sometimes smooth out data that the model actually needs to distinguish between similar things.

Finally, these results are based on simulations and training runs on two specific models (0.5B and 7B). The authors suggest that while the math looks solid, we don't yet know how this will behave on much larger models or in different real-world scenarios. They propose that this is a new tool to be used during training, which could then be combined with other "post-training" fixes for even better results, but they haven't proven it works for every possible AI architecture yet.

In short, GaugeQuant suggests that by teaching an AI to tidy up its own data while it learns, we can pack it into a much smaller backpack without spilling the contents. It's a playful, efficient way to handle the messy reality of compressing giant AI brains.

Technical Summary: GaugeQuant

Problem Statement
Large Language Models (LLMs) require massive computational resources, necessitating quantization to reduce memory footprints for inference. While Post-Training Quantization (PTQ) is computationally inexpensive, it often degrades model performance due to "outliers" in the distribution of weights and activations. These outliers stretch the quantization range, leaving fewer bits to represent frequent values. Existing PTQ methods, such as SpinQuant, attempt to mitigate this by learning optimal orthogonal rotations to suppress outliers, but they operate on frozen models using static calibration datasets. This paper addresses the need for an in-training mechanism that learns a quantization-optimal basis without requiring calibration data or freezing the model, thereby avoiding the performance degradation associated with standard PTQ.

Methodology
GaugeQuant leverages the continuous symmetries inherent in Transformer architectures. The authors observe that specific linear transformations (rotations) at the boundaries of attention and MLP layers leave the full-precision output invariant. However, uniform quantization is non-linear and does not commute with these rotations, meaning the choice of basis significantly impacts quantization error.

The core methodology involves introducing a differentiable proxy for quantization error directly into the training loss function:

Symmetry Exploitation: The method identifies $SO(d)$ symmetries at the Value-Output (V-O) boundary of attention heads and the MLP boundary. For the MLP, where the non-linearity prevents full absorption of rotations, a block-diagonal rotation structure is employed.
Differentiable Proxy: Instead of simulating non-differentiable quantization, the authors minimize the $L_\infty$ norm of the rotated activations, which dictates the quantization step size. This is approximated using a smooth, differentiable LogSumExp function:
$L_{rot}(R) = \frac{1}{\beta} \log \left( \sum_i \exp(\beta |z_i|) \right), \quad z = \text{sg}(H) \cdot R$
Here, $H$ represents boundary activations, $R$ is the rotation matrix, and $\text{sg}(\cdot)$ is a stop-gradient operator.
Loss Separation: The total loss is defined as $L_{total} = L_{CE} + \lambda L_{rot}$ . The stop-gradient operator ensures that the language modeling objective ( $L_{CE}$ ) updates only the model weights, while the rotation parameters ( $R$ ) are updated exclusively by the LogSumExp term. This keeps the two objectives orthogonal.
Optimization: To maintain orthogonality during gradient descent, the rotation matrices are parametrized via the Cayley transform of a skew-symmetric matrix, ensuring the parameters remain on the $SO(d)$ manifold.

Key Contributions

In-Training Basis Learning: Unlike prior works that optimize rotations post-training, GaugeQuant learns the quantization-optimal basis dynamically during the training process.
No Calibration Data: The method requires no static calibration datasets, as the outlier suppression is driven by the training loss itself.
Negligible Overhead: The approach adds minimal computational cost to training and inference (limited to the runtime application of block-diagonal rotations for MLPs).
Symmetry Breaking: It explicitly breaks the gauge symmetry of the transformer via a specific loss term to select a unique basis that minimizes activation outliers.

Results
The authors evaluated GaugeQuant on Qwen-2.5 0.5B and LLaMA-2 7B models using the WikiText-2 dataset.

W4A16 (4-bit weights, 16-bit activations): On LLaMA-2 7B, perplexity dropped from 11.16 (baseline) to 5.45, a 51% reduction in quantization-induced degradation.
W4A4 g128 (4-bit weights and activations, group size 128): On LLaMA-2 7B, perplexity improved from 8.22 to 6.73. On Qwen-2.5 0.5B, perplexity dropped from 187.8 to 61.2.
Comparison: The method competes with post-training approaches like SpinQuant but achieves these results without a frozen model or calibration set. A control group fine-tuned without the gauge loss showed no improvement, confirming the gains are due to the learned rotations.
Limitations: The method fails under strict per-token W4A4 quantization, where models collapse regardless of rotation, indicating that group quantization remains necessary for viable 4-bit inference.

Significance and Claims
The paper claims that GaugeQuant demonstrates that continuous symmetries in transformer architectures can be exploited online during training rather than solely post-hoc. The authors position the method as complementary to existing PTQ techniques; a model trained with GaugeQuant could subsequently be refined with post-training methods like SpinQuant.

The significance lies in the ability to produce "quantization-friendly" models directly from the training process, eliminating the need for separate calibration steps. The authors note that the gauge framework is generalizable beyond quantization to any hardware constraint that breaks rotational symmetry (e.g., structured sparsity or mixed-precision formats). However, the paper modestly acknowledges limitations, including the reliance on block-diagonal rotations for MLPs (which limits outlier redistribution across block boundaries) and the potential for the LogSumExp proxy to indiscriminately suppress large activations, possibly affecting the encoding of fine-grained distinctions. Experiments are currently limited to 0.5B and 7B parameter models.

The Paper: GaugeQuant

What They Found

What It Doesn't Do (and What's Still Unknown)

Technical Summary: GaugeQuant

More like this