🤖 machine learning

ADMM-Q: An Improved Hessian-based Weight Quantizer for Post-Training Quantization of Large Language Models

ADMM-Q is a novel, modular post-training weight quantization algorithm based on a combinatorial variant of the Alternating Direction Method of Multipliers that significantly improves the utility of Large Language Models at aggressive sub-4-bit quantization levels by minimizing layer-wise reconstruction error while enforcing quantization constraints.

Original authors: Ryan Lucas, Mehdi Makni, Xiang Meng, Adam Deng, Rahul Mazumder

Published 2026-05-13

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Ryan Lucas, Mehdi Makni, Xiang Meng, Adam Deng, Rahul Mazumder

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 Big Picture: Shrinking Giant Brains

Imagine Large Language Models (LLMs) like Qwen or LLaMA as massive, highly detailed libraries. These libraries contain billions of books (parameters) that allow the AI to write, reason, and chat. However, because these libraries are so huge, they are hard to carry around (high memory usage) and take a long time to read through (slow computation).

Quantization is the process of shrinking these libraries. Instead of keeping every book written in high-definition, full-color ink (32-bit or 16-bit precision), we try to rewrite them using fewer colors or simpler symbols (4-bit or even 2-bit). The goal is to make the library small enough to fit in a backpack without losing the story.

The Problem: The "Greedy" Shrinkers

Existing methods for shrinking these models, like GPTQ (the current industry standard), work like a greedy editor.

How they work: They look at the first sentence, shrink it, and move on. Then they look at the second sentence, shrink it, and move on.
The flaw: When the editor shrinks the first sentence, they might make a small mistake. Because they move on immediately, they never look back to fix that mistake. By the time they reach the end of the book, all those tiny mistakes have piled up, making the story confusing or nonsensical. This is especially bad when trying to shrink the books very aggressively (down to 2 or 3 bits).

The Solution: ADMM-Q (The "Team Huddle" Approach)

The authors propose a new method called ADMM-Q. Instead of a greedy editor working alone, imagine a team of editors holding a round-table meeting for every chapter.

The Team Huddle (Joint Optimization):
Instead of fixing one sentence at a time, the team looks at the entire chapter at once. They ask, "If we change this word here, how does it affect that word there?" They adjust all the words simultaneously to find the best possible combination that keeps the story clear, even when using very few colors.
The "Smooth" vs. "Blocky" Dance (ADMM):
The math behind this is called ADMM (Alternating Direction Method of Multipliers). Think of it as a dance between two steps:
- Step A (The Smooth Slide): The team makes small, continuous adjustments to the words to improve the story flow.
- Step B (The Snap-to-Grid): Suddenly, they have to snap those words to specific, allowed values (like snapping a Lego brick into place).
- They keep alternating between sliding and snapping. Over time, this process forces the words to settle into the best possible "Lego positions" without breaking the story.
The "Outlier" Problem (Diagonal Scaling):
In these models, some words are "loud" (outliers) and some are "quiet." If you try to shrink them all at once, the loud words dominate the conversation, and the quiet ones get lost.
- ADMM-Q's fix: They use a technique called Diagonal Scaling. Imagine giving the quiet words a microphone and turning down the volume on the loud words just for the editing session. This ensures every word gets a fair chance to be optimized, leading to a much clearer final story.
The Final Polish (Local Search):
Once the team finishes their huddle, they do a quick "spot check." They look for pairs of words that might have been swapped by accident and see if swapping them back improves the story. This is a fast, final polish to catch any last-minute errors.

Why It Matters: The Results

The paper tested this new method on several models (Qwen and LLaMA) and found that:

Better Stories: When they shrank the models down to very small sizes (like 3-bit or 2-bit), the old "greedy" methods (GPTQ) produced gibberish or very confused answers. ADMM-Q kept the models smart and coherent.
- Example: On a test called "WikiText-2," the old method had a score of 12.85 (higher is worse), while ADMM-Q dropped it to 10.06. That's a huge improvement in clarity.
Works with Other Tools: ADMM-Q isn't a replacement for everything; it's a drop-in replacement for the "shrinker" part. It works perfectly alongside other tricks people use, like rotating the data or scaling it.
Same Speed: Once the model is shrunk, it runs just as fast as the old methods. The extra time ADMM-Q takes is only during the "offline" shrinking process (like editing a book before publishing), not while you are actually using the AI.

The Catch (Limitations)

It takes longer to edit: Because ADMM-Q does a complex "team huddle" for every layer, it takes more computer time to shrink the model initially compared to the simple greedy methods. However, the authors say this one-time wait is worth it for the much better quality.
It needs a sample: Like all these methods, it needs a small sample of text (calibration data) to understand what the model is trying to say before it starts shrinking.

Summary

ADMM-Q is a smarter way to compress AI models. Instead of rushing through the compression step-by-step and making mistakes along the way, it takes a holistic, mathematical approach to adjust all parts of the model together. The result is a much smaller AI that still remembers how to think clearly, even when squeezed into a very tight space.

Technical Summary: ADMM-Q for Post-Training Quantization of LLMs

Problem Statement

Large Language Models (LLMs) face significant deployment challenges due to their computational and memory requirements. Quantization, specifically Post-Training Quantization (PTQ), is a primary strategy for compressing these models by reducing weight precision (e.g., from 16-bit to 4-bit or lower) without retraining.

Current standard weight quantization methods, such as Round-to-Nearest (RTN) and Greedy Per-Column Quantization (GPTQ), exhibit limitations, particularly at aggressive bit-widths (sub-4-bit):

RTN independently rounds weights, ignoring inter-weight dependencies and the structure of the reconstruction error landscape.
GPTQ incorporates Hessian information to compensate for errors but processes weights greedily in a column-by-column fashion. This sequential approach is sensitive to processing order and accumulates errors across columns.

The core challenge is formulating layer-wise quantization as a constrained optimization problem that minimizes reconstruction error while respecting discrete quantization constraints, a problem that becomes increasingly difficult as bit-widths decrease.

Methodology: ADMM-Q

The authors propose ADMM-Q, a novel weight quantization algorithm based on the Alternating Direction Method of Multipliers (ADMM). Unlike GPTQ's greedy column-wise approach, ADMM-Q treats layer-wise quantization as a joint optimization problem.

1. Problem Formulation

The algorithm formulates the quantization of a layer with pre-trained weights $\hat{W}$ and input activations $X$ as a Hessian-weighted constrained optimization problem:
$\min_{W} \frac{1}{2} \text{Tr}\left((W - \hat{W})^\top H (W - \hat{W})\right) \quad \text{s.t.} \quad W \in \mathcal{Q}$
where $H = X^\top X + \lambda I$ is the Hessian matrix, and $\mathcal{Q}$ is the set of quantized weight matrices.

2. Key Algorithmic Components

To solve this non-convex problem efficiently at the scale of LLMs, ADMM-Q incorporates several enhancements:

Diagonal Scaling for Numerical Stability: LLM activations often contain "channel outliers" (dimensions with disproportionately large magnitudes), leading to a poorly conditioned Hessian. ADMM-Q applies a diagonal scaling matrix $\Sigma = \text{Diag}(H)^{-1/2}$ to normalize the problem, ensuring all channels contribute comparably to the updates. This is critical; ablation studies show that removing this scaling degrades performance significantly (e.g., increasing perplexity from 10.06 to 14.68 in W3A16 on Qwen3-8B).
ADMM Splitting: The algorithm introduces an auxiliary variable $D$ $D$ to decouple the continuous Hessian-weighted objective from the discrete quantization constraint. It alternates between:
1. W-update: A continuous update minimizing the Hessian-weighted distance, solved efficiently via eigendecomposition of $H$ .
2. D-update: A discrete projection onto the quantization grid (equivalent to RTN but accounting for scaling).
3. Dual Update: Adjusting the Lagrange multiplier to enforce consistency.
Grid Refresh: Unlike GPTQ, which fixes the quantization grid during optimization, ADMM-Q dynamically refits the grid parameters (scale and zero-point) based on the current continuous iterate. This allows the projection to remain aligned with the moving target, avoiding the staleness of a fixed grid.
Local Search Refinement: To address suboptimal discrete solutions caused by correlated rounding, a post-processing step performs an efficient pair-swap local search. This step evaluates discrete moves (swapping values between rows) that directly reduce the reconstruction error, leveraging GPU parallelization for speed.
Convergence Guarantees: The authors extend existing ADMM convergence proofs (previously established for sparsity constraints) to the quantization setting, proving that the continuous and discrete iterates converge to the same limit point under a specific penalty schedule ( $\rho_t = \rho_0 \cdot \gamma^t$ ).

3. Modularity and Integration

ADMM-Q is designed as a drop-in replacement for RTN or GPTQ within existing PTQ pipelines. It is fully composable with:

Scaling transformations (e.g., SmoothQuant, AWQ).
Rotation transformations (e.g., SpinQuant, QuaRot).
Clipping heuristics (e.g., MSE-based grid search).

Experimental Results

The authors evaluated ADMM-Q across three settings: weight-only quantization, weight-and-activation quantization with SpinQuant, and weight-and-activation quantization with SmoothQuant.

1. Weight-Only Quantization (Qwen3 Family)

Across Qwen3 models (1.7B to 32B), ADMM-Q consistently outperformed GPTQ and AWQ in perplexity and zero-shot accuracy, with gains increasing at lower bit-widths:

W3A16 (Qwen3-8B): WikiText-2 perplexity improved from 12.85 (GPTQ) to 10.06 (ADMM-Q).
W2A16 (Qwen3-8B): WikiText-2 perplexity improved from 32.88 (GPTQ) to 17.69 (ADMM-Q).
Layer-wise Analysis: ADMM-Q reduced reconstruction error across all decoder layers, achieving up to 10% of GPTQ's error in early layers.

2. Weight-and-Activation Quantization

SpinQuant (WbA4KV4): On LLaMA-3 and Qwen3 models, replacing GPTQ with ADMM-Q yielded consistent improvements. For example, on LLaMA-3 8B at W2A4KV4, perplexity dropped from 50.27 (GPTQ) to 15.65 (ADMM-Q).
SmoothQuant (WbA8): On Qwen3-8B, ADMM-Q improved W3A8 perplexity from 16.00 to 12.21.

3. Inference Performance

When integrated into the vLLM inference stack, ADMM-Q produced weight matrices in the same format as GPTQ. Consequently, it achieved identical inference throughput and memory benefits. For instance, on Qwen3-32B with SpinQuant W8A8, both methods achieved a ~1.52× speedup over the dense baseline.

4. Computational Cost

The offline quantization process for ADMM-Q is more computationally intensive than GPTQ due to the iterative optimization. However, the authors note that quantization is a one-time step, and the runtime remains practical (e.g., under two hours for a 32B model on a single GPU). The peak GPU memory usage is slightly higher (approx. 6%) than GPTQ.

Significance and Claims

The paper claims that ADMM-Q represents a principled shift from greedy, sequential quantization to joint, constrained optimization for LLMs. Its primary contributions are:

Algorithmic Innovation: It successfully adapts ADMM to the hard combinatorial problem of weight quantization, introducing necessary stabilizations (diagonal scaling) and refinements (grid refresh, local search) for LLM scales.
Performance Gains: It demonstrates substantial improvements in model utility (perplexity and accuracy), particularly in aggressive low-bit regimes (W3 and W2) where previous methods struggle.
Versatility: It serves as a modular, drop-in component that enhances existing pipelines (including those using rotations and scaling) without altering the final inference format or speed.

The authors acknowledge limitations, noting that ADMM-Q incurs higher offline quantization costs and relies on the representativeness of the calibration set. Furthermore, the current evaluation is limited to dense autoregressive decoder-only LLMs, and adaptation to mixture-of-experts or diffusion models would require further work.