🤖 machine learning

HyperQuant: A Rate-Distortion-Optimal Quantization Pipeline for Large Language and Diffusion Models

HyperQuant is a unified post-training quantization pipeline that combines Randomized Hadamard Transform, optimal lattice quantization, Rice coding, and bias correction to achieve rate-distortion-optimal compression for both weights and KV caches in large language and diffusion models, outperforming existing methods across various bit-rates while maintaining near-lossless quality.

Original authors: Yuval Domb, Hadar Sackstein, Tomer Solberg

Published 2026-06-23

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Yuval Domb, Hadar Sackstein, Tomer Solberg

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 have a massive, incredibly detailed library of books (a Large Language Model or a video generator). These books contain billions of words and images, taking up so much space that they barely fit on your computer's hard drive. When you ask the computer to read a sentence or generate a video, it has to constantly shuffle these heavy books back and forth, which is slow and exhausting for the machine.

HyperQuant is a new, clever system designed to shrink these books down to a fraction of their size without losing the story, making them faster to read and easier to store.

Here is how it works, broken down into simple steps using everyday analogies:

1. The "Shuffling" Trick (Randomized Hadamard Transform)

Imagine you have a messy pile of papers where some pages are huge and heavy, while others are tiny scraps. If you try to pack them into a box, the big pages stick out and waste space.
HyperQuant starts by shuffling the pages. It mixes the data so that instead of having a few giant outliers and many tiny bits, everything becomes a smooth, even distribution (like a perfect bell curve). This makes the data much easier to pack efficiently, just like shuffling a deck of cards makes it easier to deal evenly.

2. The "Perfect Packing" (Lattice Quantization)

Once the data is shuffled, HyperQuant needs to turn the continuous numbers into discrete "dots" that can be stored.

Old Way: Imagine trying to pack spheres into a box using a simple grid (like a checkerboard). There's a lot of wasted empty space between the spheres.
HyperQuant's Way: It uses mathematical "lattices" (like the E8 or D4 shapes). Think of these as the most efficient way to stack oranges in a crate. They fit the spheres together so tightly that there is almost no wasted space. This allows the system to store the same amount of information using far fewer bits.

3. The "Zipper" (Entropy Coding & Rice Codes)

Even with perfect packing, you still have a long list of numbers to write down.

Old Way: You write down every number with the same amount of space, even if some numbers appear very often and others rarely.
HyperQuant's Way: It uses a variable-length code (Rice coding). Think of this like a secret language where common words get very short codes (like "u" for "you"), and rare words get longer codes. Because the system knows which numbers appear most often, it compresses the data even further, saving space without losing any meaning.

4. The "Noise Canceling" (Bias Correction for KV Cache)

When a model remembers previous words (the "KV cache"), it needs to be very precise. If you round off numbers too roughly, the model might get confused and start hallucinating nonsense.
HyperQuant uses a trick called "subtractive dither." Imagine you are trying to measure a liquid, but your cup is slightly wobbly. Instead of just guessing, you add a tiny, random amount of water, measure it, and then subtract that exact random amount later. This cancels out the error perfectly, ensuring the final result is unbiased and accurate, even when the data is compressed heavily.

5. The "Magic Box" (Hardware Integration)

Finally, HyperQuant is designed to work directly with modern computer chips (like NVIDIA's H100 and Blackwell GPUs). It doesn't just compress the data; it formats it so the chip can read it instantly without needing to unpack it first.

The Result: It found that using 8-bit integers (standard whole numbers) actually works better than 8-bit floating points (decimal numbers) for this specific type of compressed data. It's like realizing that for this specific puzzle, whole numbers fit the slots better than decimals.

The Big Wins

The paper claims that HyperQuant achieves the following:

Massive Compression: It shrinks the model's "memory" (weights) by about 4 times and the "working memory" (KV cache) by about 3.8 times.
No Quality Loss: Despite shrinking the data so much, the model still understands and generates text or video almost as well as the original, uncompressed version.
Video Success: It successfully compressed a 19-billion-parameter video generation model (LTX-2) without any visible glitches in the video.
Beating the Competition: It outperforms previous top methods (like HIGGS, TurboQuant, and OCTOPUS) in almost every test, especially when trying to squeeze the data down to very small sizes (like 1.7 bits per number).

In short, HyperQuant is a new "packing algorithm" that shuffles, stacks, and zips up AI models so they fit in your pocket without breaking the story.

Technical Summary: HyperQuant

Problem Statement

Large Language Models (LLMs) and diffusion transformers face a critical bottleneck during autoregressive inference: memory bandwidth. As context lengths grow, the Key-Value (KV) cache and model weights dominate memory usage, forcing the system to stream massive datasets for thin matrix-vector products. This keeps arithmetic intensity well below hardware compute-to-bandwidth ratios. While Post-Training Quantization (PTQ) offers a solution by framing inference as a rate-distortion compression problem, existing state-of-the-art methods suffer from inefficiencies:

Weight Quantization: Methods like HIGGS utilize Randomized Hadamard Transforms (RHT) and finite Lloyd codebooks but transmit indices at a fixed bit-rate. Information theory dictates that entropy-coded quantizers should require fewer bits for the same distortion, yet HIGGS leaves "rate on the table" due to fixed-rate indices.
KV Cache Quantization: Approaches like TurboQuant and OCTOPUS rely on scalar or low-dimensional marginal quantization with fixed-rate overheads. They often lack strict per-vector unbiasedness, leading to systematic shifts in attention scores, and fail to fully exploit multi-dimensional vector quantization gains.

Methodology: The HyperQuant Pipeline

HyperQuant proposes a unified, data-free, post-training pipeline that applies a rate-distortion-optimal triplet—per-tile RHT, lattice quantization, and entropy coding—to both weights and KV caches. The pipeline consists of four core components:

1. Per-Tile Randomized Hadamard Transform (RHT)

Before quantization, inputs (weights or KV vectors) are partitioned into tiles (e.g., size 128) and transformed via $RHT_n(x) = H_n D x$ , where $H_n$ is the Walsh-Hadamard matrix and $D$ is a random sign diagonal.

Effect: This "mixes" the data, making the per-coordinate distribution approximately Gaussian ( $N(0, \sigma^2)$ ).
Benefit: It redistributes quantization error from outlier coordinates into an isotropic spread, making the data amenable to optimal lattice quantization. The transform is orthogonal, preserving $\ell_2$ error properties.

2. Lattice Quantization

Instead of finite codebooks, HyperQuant quantizes the rotated tiles to low-dimensional optimal lattices: E8 (8-D), D4 (4-D), A2 (2-D), or scalar Z.

Granular Gain: These lattices offer lower normalized second moments ( $G(\Lambda)$ ) than scalar quantization, reducing distortion for a fixed rate. E8 is the highest-dimensional lattice admitting a constant-time ( $O(1)$ ) closed-form decoder.
Integer Realization: The lattices are mapped to integer embeddings (e.g., $E^8_{int} \subset \mathbb{Z}^8$ ) to fit within 8-bit storage constraints, with scaling factors ( $\alpha$ ) calibrated to prevent overflow.

3. Bit-Stripping and Rice Coding

To achieve near-entropy-optimal rates, HyperQuant employs a two-stage encoding process:

Bit-Stripping: Lattice membership constraints (e.g., parity checks for E8) deterministically fix certain bits of the integer code vector. These bits are stripped losslessly before encoding, reducing the entropy of the remaining symbols.
Rice Coding: The remaining symbols are encoded using Rice codes (a variable-length code optimal for geometric distributions). Unlike fixed-rate schemes, this allows the codebook to be effectively unbounded, handling Gaussian tails without stretching outer cells. The realized rate lands within $\sim0.01$ bits per scalar (bps) of any target.

4. Bias Correction for KV Cache

To prevent deterministic bias in the KV cache from corrupting attention semantics, HyperQuant integrates:

Random Rotation: A per-layer rotation (either a full Haar-uniform QJL matrix or a cheap $\pm 1$ sign diagonal) to reduce anisotropy.
Subtractive Dither: A fresh uniform noise vector $U \sim \text{Uniform}(V(\Lambda))$ is added before quantization and subtracted after. The authors prove (Appendix A) that this yields strict per-vector inner-product unbiasedness, a property superior to the distribution-average unbiasedness of standard QJL sketches.

Key Contributions

Unified Rate-Distortion Optimal Pipeline: HyperQuant is the first data-free pipeline to combine RHT, optimal lattices, and entropy coding for both weights and KV caches, achieving rates within $\sim0.01$ bps of theoretical targets.
Superior Weight Quantization: By replacing finite codebooks with unbounded lattices and variable-length coding, HyperQuant outperforms HIGGS at every operating point (3–5 bps). The paper decomposes this gain into:
- Entropy Slack: Recovering bits wasted by fixed-rate indices (dominant at low rates).
- Unbounded Codebook Advantage: The structural benefit of infinite codebooks over finite ones (dominant at high rates).
Two-Regime KV Quantization: The authors characterize KV quantization into a "high-quality" regime ( $\ge 2.5$ bps) where bias correction variants converge, and a "high-compression" regime ( $1.7\text{--}2.5$ bps) where QJL rotation provides significant gains ( $\sim0.5$ PPL improvement).
Hardware Integration: The pipeline is designed for modern Tensor Cores (Hopper/Blackwell), integrating with fp8, int8, nvfp4, and mxfp4 paths. Notably, the authors find that int8 outperforms fp8 on post-RHT lattice data due to the light-tailed, near-Gaussian distribution of the transformed weights.
Generalization: The method successfully transfers to non-LLM architectures, demonstrated on the 19B-parameter LTX-2 video DiT with no perceptible artifacts.

Experimental Results

Evaluated on Llama-3.1-8B-Instruct (WikiText-2) and LTX-2-19B:

Weight Quantization: At 4 bps, HyperQuant (E8 lattice) achieves a perplexity (PPL) of 7.434, compared to HIGGS-p2's 7.618. At 3 bps, the gap widens significantly (HyperQuant: 8.744 vs. HIGGS: 9.527).
KV Cache Quantization:
- At 3 bps, HyperQuant achieves a PPL of 7.41 (vs. bf16 baseline 7.16), an 81% memory reduction.
- At 2 bps, HyperQuant achieves a PPL of 7.93 (+0.77% over baseline), significantly outperforming OCTOPUS (+34.7% PPL) and TurboQuant.
- At 1.7 bps, HyperQuant reaches a compression ratio of 7.1× with a PPL increase of 26.9%, whereas OCTOPUS tops out near 3.0× compression.
End-to-End Performance: On an H100, HyperQuant compresses linear weights 3.9× and the KV cache 3.79×. While the variable-length decoding introduces latency (no wall-clock speedup on current hardware), the resident memory reduction is substantial (14.96 GiB $\to$ 5.29 GiB for the full model).
Video Model: On LTX-2-19B, 4 bps quantization yields a PSNR of 22.74 dB and LPIPS of 0.20, with no visible artifacts, outperforming fp8-based quantization.

Significance and Claims

The paper claims that HyperQuant establishes a new state-of-the-art for data-free post-training quantization by rigorously applying information-theoretic principles (entropy coding and lattice theory) to transformer inference.

Theoretical Breakthrough: It demonstrates that the gap between current SOTA (HIGGS) and optimal performance is largely due to the inefficiency of fixed-rate indices and finite codebooks. By switching to variable-length coding over unbounded lattices, HyperQuant recovers this "slack."
Practical Deployment: The method requires no calibration dataset and no fine-tuning, making it immediately deployable. It provides a "menu" of operating points, allowing practitioners to trade off memory and quality (e.g., 3 bps for KV cache offers massive memory savings with minimal PPL degradation).
Hardware Awareness: The work challenges the assumption that fp8 is always superior for outliers; by Gaussianizing the data via RHT, it shows that int8 is often a better match for the resulting distribution, offering better quality at the same bit-width.

The authors conclude that while HyperQuant currently trades throughput for memory efficiency on current hardware, the pipeline provides the necessary foundation for future kernel optimizations (e.g., fused decode+MMA) that could unlock wall-clock speedups.