🤖 machine learning

Finer is Better (with the Right Scaling)

This paper resolves the paradox where shrinking quantization block sizes degrade Large Language Model performance by demonstrating that the issue stems from heavy-tailed distributions interacting poorly with FP4 formats, and shows that targeted algorithmic interventions like 4-over-6 scaling and underflow prevention allow standard hardware-compliant formats to achieve optimal quality with finer granularity.

Original authors: Clemens Schaefer, Gil Tabak

Published 2026-05-12

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Clemens Schaefer, Gil Tabak

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 Problem: The "Too-Fine" Paradox

Imagine you are trying to pack a suitcase for a trip. You have a huge pile of clothes (data) and a limited amount of space (memory). To fit everything in, you decide to chop the clothes into smaller and smaller bundles (called blocks) so you can organize them more efficiently.

Intuitively, you'd think: "The smaller the bundles, the better I can fit everything, right?"

In the world of AI, this is called quantization. Scientists tried shrinking these bundles to make AI models smaller and faster. But they hit a weird paradox: When they made the bundles too small, the AI actually got worse at its job. It was like trying to pack a suitcase so carefully that you ended up crushing the clothes and making them useless.

Why Did This Happen?

The authors of this paper investigated why this "too-fine" paradox happened. They found two main culprits:

1. The "Zero" Glitch (The Empty Box)
Imagine you have a box that can only hold numbers. If a number is tiny, the box's ruler might round it down to zero. If you have a whole bundle of tiny numbers, the ruler might say, "Okay, everything in this bundle is zero," and throw the whole thing away.

The Fix: The paper suggests a simple rule: Never let the ruler say zero. If a number is too small, force the ruler to use the tiniest possible positive number instead. This keeps the information alive.

2. The "Rough Ruler" Problem (The Coarse Grid)
This is the bigger issue. The AI uses a specific type of "ruler" (called E4M3) to measure these bundles. This ruler has very big gaps between its markings, especially at the high end.

The Analogy: Imagine you are trying to measure a mountain range with a ruler that only has marks for 1 foot, 2 feet, 4 feet, and 6 feet.
- If you have a small hill (a small block of data), the ruler might force you to round a 5.9-foot hill up to 6 feet. That's a huge error!
- When you make the bundles smaller, you end up with more of these "tall" numbers that get forced into that big, clumsy 6-foot bucket. The smaller the bundle, the more often this bad rounding happens, and the worse the AI performs.

The Solutions: How They Fixed It

The authors tested three main ways to fix this, proving that finer blocks are better, but only if you use the right tools.

1. The "Don't Go to Zero" Rule
They simply programmed the system to never let a scaling factor become zero.

Result: This fixed the problem for very tiny numbers, but it didn't fix the problem for the "tall" numbers that were getting rounded up to 6.

2. The "4-or-6" Choice (The 4-over-6 Method)
This is the paper's "secret sauce." Instead of using one fixed ruler, the system gets to choose between two specific settings for each bundle: 4 or 6.

The Analogy: Imagine you are packing a box. Sometimes your items fit best if you use a "Medium" box (4), and sometimes they fit best in a "Large" box (6). Instead of forcing everything into a "Large" box (which crushes the small stuff), the system checks: "Which of these two boxes fits this specific bundle best?"
Result: This allowed the AI to avoid the clumsy rounding errors. When they used this method, the "paradox" disappeared. Smaller bundles suddenly became much better, just like they were supposed to be.

3. The "Brute Force" Check
To prove their point, they ran a computer search that tried every possible way to measure the bundles to find the perfect one.

Result: This proved that theoretically, smaller bundles always work better if you pick the perfect measurement. The fact that the AI was failing before wasn't because small bundles are bad; it was just because they were using a bad measuring method.

The Real-World Test: Does It Work on Real AI?

They tested this on four famous AI models (Granite, Llama, DeepSeek, and Qwen).

The Problem: Two of the models (Granite and Llama) were getting worse when the bundles got smaller, exactly as the paradox predicted.
The Fix: When they applied the "4-or-6" choice and the "Don't go to zero" rule, those models stopped getting worse. In fact, they got better as the bundles got smaller.
The Comparison: They also tried using a fancier, more expensive ruler (called UE5M3) that has more markings. This worked well too, but it requires more hardware power. Their "4-or-6" trick allowed them to use the cheaper, standard ruler and get the same great results.

The Bottom Line

The paper concludes that making AI models smaller and more efficient (using tiny blocks) is a great idea. The reason it was failing before wasn't a flaw in the idea itself, but a flaw in the "measuring tape" being used.

By using a smarter way to choose how to measure the data (specifically the "4-over-6" method), we can make AI models smaller, faster, and more accurate without needing expensive new hardware. The paradox is solved: Finer is indeed better, as long as you have the right scaling.

Technical Summary: Finer is Better (with the Right Scaling)

Problem Statement
The deployment of Large Language Models (LLMs) on datacenter and edge architectures increasingly relies on ultra-low precision formats (4-bit or fewer) to mitigate memory and bandwidth bottlenecks. Microscaling, which applies individual scaling factors to small blocks of data (e.g., size 16 or 32), is a critical technique for preserving model quality in these regimes. However, a recent paradox identified in the literature [1] contradicts the intuitive expectation that finer block sizes yield lower quantization error. Specifically, when using standard absolute maximum (abs-max) scaling with E4M3 scaling factors, reducing block sizes can paradoxically degrade model quality, resulting in higher Mean Squared Error (MSE) and increased downstream perplexity. This paper investigates the underlying mechanics of this phenomenon to determine if it is an inherent limitation of fine granularity or a solvable algorithmic issue.

Methodology
The authors conduct a two-phase investigation combining numerical analysis and full-model evaluation:

Numerical Study: The authors analyze quantization behavior across various block sizes (4, 8, 16, 32) using FP4 (OCP E2M1) for data and E4M3 for scaling factors. They sample normal distributions to isolate theoretical MSE behavior.
Scaling Strategies: The study evaluates several scaling methodologies:
- Standard Abs-Max: The baseline method where the scale is the maximum absolute value in the block, rounded to the nearest representable value in the E4M3 format.
- Prevent-Zero: A modification where the scaling factor is clamped to the smallest non-zero representable value ( $\epsilon_{SF}$ ) to prevent underflow to zero, which would otherwise collapse all values in a block to zero.
- 4-over-6: An algorithmic intervention [2] that selects the scaling factor from the two largest representable values in the FP4 range (4.0 and 6.0) to minimize MSE for a specific block, effectively adapting the quantization geometry.
- Brute-Force Search: An optimal baseline that searches all possible scaling factors to find the theoretical minimum MSE, establishing the upper bound of performance.
- Hierarchical Scaling: A two-stage process involving a per-tensor global scale followed by local block scales.
Downstream Evaluation: The proposed strategies are applied to the weight and activation quantization (specifically MLP layers) of four distinct LLMs: Granite-3.3-8B, Llama-3.1-8B, DeepSeek-LLM-7B-Base, and Qwen2.5-14B. Performance is measured via perplexity gaps against unquantized baselines.

Key Findings and Results
The study identifies that the degradation observed with smaller block sizes is not an inherent flaw of fine granularity but a consequence of heavy-tailed tensor distributions interacting poorly with the coarse upper quantization bins of the FP4 (E2M1) format.

Region A (Extremely Small Scales): Standard abs-max scaling frequently causes the scaling factor to underflow to zero, creating a spike in MSE. The Prevent-Zero adjustment completely eliminates this localized error by forcing the scale to the smallest positive value.
Region B (Moderate Scales): Even with zero-prevention, a paradoxical inversion persists where smaller blocks yield higher MSE. This occurs because the largest values in a block often align poorly with the coarse E4M3 grid, leading to excessive clipping in the largest magnitude bin (6.0). The 4-over-6 methodology resolves this by adaptively choosing between scaling factors of 4.0 and 6.0, allowing values to fit into the more uniform portion of the FP4 range and avoiding strong clipping.
Optimal Baseline: The brute-force search confirms that when the ideal scaling factor is selected, MSE strictly improves as block sizes decrease, validating that "finer is better" is theoretically sound.
Model-Specific Behavior: In downstream LLM evaluations, models like DeepSeek and Qwen behave intuitively, showing improved perplexity with smaller block sizes. Conversely, Granite and Llama exhibit the paradoxical degradation at block sizes 4 and 8 under standard scaling.
- Applying Prevent-Zero offers localized improvements but does not fully resolve the U-shaped perplexity curve for Granite and Llama.
- Applying 4-over-6 significantly reduces the perplexity gap (e.g., reducing Llama's gap from 0.725 to 0.270 at block size 4), effectively eliminating the paradox.
- Format Interchangeability: The paper demonstrates that using standard E4M3 scaling factors combined with hierarchical scaling and the 4-over-6 strategy yields results comparable to using custom, wider-exponent formats like UE5M3. While UE5M3 inherently offers a wider absolute range, the algorithmic recipe (E4M3 + 4-over-6 + Hierarchical) achieves similar quality improvements.

Significance and Claims
The authors claim to have fully resolved the "block size paradox" by demonstrating that the degradation is driven by specific interactions between tensor distributions and quantization geometry, not by the block size itself.

Algorithmic Resolution: The work establishes that standard, hardware-compliant formats (like OCP E4M3) can match the performance of custom, wider-exponent formats (like UE5M3) if the correct algorithmic recipe (specifically 4-over-6 and hierarchical scaling) is applied.
Hardware Trade-offs: The paper highlights a trade-off: while UE5M3 offers greater flexibility without needing hierarchical scaling, the 4-over-6 algorithm incurs computational overhead (requiring two quantizations and MSE calculations per block). This overhead is acceptable for offline weight quantization but may be prohibitive for dynamic activation quantization.
Future Directions: The authors note that current heuristics still fall short of the theoretical minimum MSE established by brute-force search, indicating that the design of optimal scale-selection algorithms remains a critical area for future research.

In conclusion, the paper asserts that with the right scaling strategies, the theoretical benefits of finer microscaling granularity can be realized in practice, enabling robust downstream perplexity improvements across diverse LLM architectures.