BATQuant: Outlier-Resilient MXFP4 Quantization via Learnable Block-wise Optimization

Conference: ECCV2026
Paper: Official paper page · PDF
Authors: Ji-Fu Li, Manyi Zhang, Xiaobo Xia, Han Bao, Haoli Bai, Zhenhua Dong, Xianzhi Yu
Area: VLM Efficiency / Model Quantization
Keywords: Microscaling floating point, post-training quantization, outlier suppression, block-wise affine transformation, Kronecker decomposition

TL;DR

BATQuant confines learnable non-orthogonal transformations to MXFP4's 32-element quantization blocks, then uses shared factorization and local clipping to reduce deployment overhead and residual outlier effects, achieving 96.43% multimodal performance recovery on Qwen3-VL-8B-Instruct under W4A4KV16.

Background & Motivation

Reducing model weights and activations to 4 bits requires more than selecting a numerical format and rounding. MXFP4 uses E2M1 elements, with each group of 32 elements sharing a UE8M0 scaling factor. Its positive representable values are only 0.5, 1.0, 1.5, 2.0, 3.0, 4.0, and 6.0, alongside their negatives and zero. A single large value can inflate the shared scale, leaving fewer useful quantization levels for the smaller values in that block. Consequently, what matters is not whether the entire tensor looks smooth, but whether each locally scaled distribution fits the available discrete grid.

Global rotation methods such as QuaRot and SpinQuant work well for INT4, yet can spread energy from a few outlier channels into otherwise well-behaved quantization blocks. BRQ confines Hadamard rotation to individual blocks, preventing cross-block contamination, but retains the energy-preserving constraint of orthogonal transformations. When one extreme value dominates a block, positive and negative mixing can produce a bimodal distribution that underuses intermediate levels. FlatQuant relaxes orthogonality, but its global transformation still does not ensure that each hardware block's local statistics remain unaffected by other blocks.

BATQuant separates these two issues: the transformation must act locally, but its shape need not be restricted to rotation. Core idea: match the scope of a learnable affine transformation exactly to the scope of MXFP's shared scale, reshape values inside that block, and use shared parameters plus local clipping to make this flexibility trainable and deployable.

Method

Overall Architecture

The inputs are a pretrained BF16 model and a small calibration set; the output is a transformed and quantized model. Calibration learns block-wise transformations and clipping parameters layer by layer so that quantized outputs approximate the original floating-point outputs. At deployment, inverse transformations on the weight side are fused into linear layers offline, while activation-side transformations execute online in factorized form before low-bit computation.

The construction follows block-wise affine transformation, Global and Private Kronecker decomposition, block-wise learnable clipping, and equivalent Transformer integration. The decomposition parameterizes the affine transformation rather than adding another network layer after it. The diagram therefore describes construction and deployment relationships, not four independent forward-pass transformations.

%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400}}}%%
flowchart TD
    Input["BF16 model and calibration data"] --> BAT["Block-wise affine transformation<br/>Align with quantization blocks"]
    BAT --> GPK["Global and Private Kronecker decomposition<br/>Parameterize block matrices"]
    GPK --> Clip["Block-wise learnable clipping<br/>Constrain residual outliers"]
    Clip --> Integration["Equivalent Transformer integration<br/>Offline weight fusion and online transforms"]
    Integration --> Output["Quantized model and optional KV quantization"]

Key Designs

1. Block-wise affine transformation: confine outlier propagation without requiring orthogonal rotation

Consider a linear layer with activation matrix \(X\), weight matrix \(W\), and floating-point output \(Y=XW^\top\). Multiplying activations by an invertible matrix \(P\) and absorbing its inverse into the weights preserves the unquantized output. Once quantization is introduced, however, different choices of \(P\) change how values fall on discrete levels. The legible objective at the beginning of the method section is:

\[ P^\star=\operatorname*{arg\,min}_{P}\left\|Y-Q(XP)Q(P^{-1}W^\top)\right\|_F^2. \]

Here, \(Q\) denotes quantization, and the Frobenius norm measures reconstruction error across the output matrix. The objective is not simply to minimize the largest activation. It is to minimize the output distortion caused jointly by quantizing the transformed activations and weights. Shrinking activations can alter the weight distribution through the inverse transformation, so an activation histogram alone cannot establish the final benefit.

BATQuant restricts \(P\) to a block-diagonal structure, with each independent submatrix operating only on the 32 channels within one quantization block. An outlier therefore cannot pass directly into another block through this transformation. Non-orthogonal flexibility also permits stretching and contraction within a block instead of requiring energy preservation. Although the paper calls the operation affine, the legible computation is a matrix transformation and does not specify an additional translation term; a bias mechanism should not be inferred from the name. The down_proj visualizations show reduced bimodality relative to Hadamard transformation, but this is an empirical observation rather than a guarantee of unimodality for every input.

2. Global and Private Kronecker decomposition: share a transformation basis without mixing data across blocks

A block-diagonal matrix is sparse, but storing a full matrix for every block remains expensive. With hidden dimension 4096 and block size 32, there are 128 blocks, requiring 131,072 parameters without decomposition. Naive Kronecker decomposition splits each block matrix into factors of size 8×8 and 4×4, but still stores both factors separately for every block, giving 10,240 parameters.

GPK instead shares one 8×8 basis across all blocks and retains only a private 4×4 matrix for each block, reducing the count to 2,112; FlatQuant uses 8,192 parameters in the same example. Global sharing refers to parameter reuse, not mixing input elements across blocks, so it does not reintroduce the cross-block energy transfer of global rotation. Factorized small matrix multiplications avoid explicitly constructing full block matrices. The associated equations are damaged in the cache, however, so this note does not reconstruct their multiplication orientation or vectorization convention.

This design also explains why the private factor cannot shrink indefinitely. The shared basis captures reusable transformation structure, whereas each private matrix adapts to its block's particular outlier locations and magnitudes. The authors test shared-factor sizes 1, 2, 4, 8, 16, and 32, with optima at 8 or 4 rather than monotonically improving with more private parameters. An overly large shared factor leaves too little local capacity; an overly small one may make optimization harder with limited calibration data.

3. Block-wise learnable clipping: handle the residual tail after distribution shaping

The transformation cannot ensure that every remaining outlier disappears, so BATQuant learns separate lower and upper clipping ratios for each quantization block. The legible prose states that sigmoid maps these ratios between 0 and 1, and that they act on the block minimum and maximum respectively. Weights receive analogous treatment. The bounds therefore adapt to the current block's range instead of imposing one tensor-wide pair of thresholds on blocks with different statistics.

Clipping accepts some distortion of extreme values to reduce their control over the shared scale and preserve more useful levels for ordinary values. Its ratios are not manually fixed: they are learned together with the affine parameters through output reconstruction. The two operations are complementary, with transformation first reshaping the distribution and clipping handling its remaining tail. Ablations likewise favor making both operations block-wise rather than only one. Because the cached clipping equations have incomplete symbols and brackets, this explanation follows the adjacent prose without restoring the damaged expressions.

4. Equivalent Transformer integration: place computation on the fusible weight side and necessary online paths

For the language model and the text component of the multimodal model, the MLP uses two transformation sets: one after LayerNorm and before up_proj and gate_proj, and another before down_proj. The visual encoder similarly transforms inputs to linear_fc1 and linear_fc2. These locations target the distributions actually entering linear layers; a single input transformation cannot simply be carried across a nonlinear activation while retaining equivalence.

Text self-attention uses four transformation sets: before qkv_proj, before o_proj, and on the per-head key and value cache paths. Figure 3 includes matching inverse transformations that preserve the computation's meaning apart from the low-precision approximation; their exact placement around RoPE should be checked against the original figure. ViT uses only the qkv_proj and o_proj transformations because it has no autoregressive KV cache. Linear layers use low-bit matrix multiplication, but LayerNorm, pre-quantization transformations, RoPE, and attention scores stay in BF16. W4A4 therefore does not mean that every operation in the graph runs at 4 bits.

A Worked Example

Take the paper's parameter-count example of a 4096-dimensional linear-layer input, partitioned into 128 independent blocks of 32 elements. Suppose one block contains a pronounced outlier; this is an explanatory scenario, not an additional experiment. A global rotation could force otherwise normal blocks to use larger scales, whereas BAT confines redistribution to the affected block.

During calibration, that block uses the shared 8×8 factor and its own 4×4 factor to construct its transformation while learning local clipping ratios. Other blocks reuse the shared factor but retain their own private matrices and clipping parameters. Optimization follows the final layer-output deviation rather than prescribing a fixed target magnitude for the outlier.

At deployment, the inverse weight transformation has already been fused. The online path transforms activations block by block, clips and quantizes them, and multiplies them by the processed weights. The 128 blocks need only 2,112 transformation parameters instead of 131,072 parameters for full block matrices. This count excludes the model's ordinary weights, scales, and clipping parameters.

Loss & Training

The method optimizes transformations and clipping parameters through layer-wise reconstruction between floating-point and quantized outputs, rather than repeating full-model pretraining. Equation (5) is corrupted in the cache, preventing verification of its complete summation and normalization. No replacement is presented as the original training loss; the linear-layer objective above only explains the underlying transformation-selection principle.

The optimizer is AdamW with an initial learning rate of 2e-3, cosine annealing, 5 epochs, and batch size 4. GPK defaults to shared-factor size 8 and private-factor size 4. For Qwen3-8B, calibration data are self-generated by the BF16 model using Numina-Math-1.5, with 128 randomly sampled text sequences of length 2048. Qwen3-VL-8B-Instruct instead uses 128 image-text pairs from GQA.

W4A4KV16 means 4-bit weights, 4-bit activations, and a 16-bit KV cache. The paper also tests W4A8KV16, W4A8KV8, and W4A8KV4; MXFP8 uses E4M3. Unless specified otherwise, reported methods incorporate GPTQ weight quantization. BATQuant's main results therefore should not be interpreted as gains obtained using only naive rounding. The appendix algorithm, pseudocode, and additional implementation details referenced by the paper are absent from the current cache.

Key Experimental Results

Main Results

The following rows are taken from Table 2 for Qwen3-VL-8B-Instruct. Recovery is the paper's reported performance recovery relative to BF16, aggregated across tasks with different score scales. It is neither a single accuracy nor a ratio obtained by summing raw scores. The main text does not provide its complete calculation formula, so the reported values are retained without reconstructing it.

Configuration	Method	MME	OCRBench	DocVQA	RealWorldQA	VLMBlind	Recovery (%)
BF16	Original model	2377	906	95.81	70.98	73.98	100.00
W4A4KV16	RTN	2243	838	92.70	65.23	66.47	93.07
W4A4KV16	SpinQuant	1994	801	91.79	65.36	60.23	88.32
W4A4KV16	BRQ	2147	805	92.94	66.14	62.14	90.74
W4A4KV16	FlatQuant	2231	873	94.10	65.62	68.86	94.79
W4A4KV16	SmoothQuant	2264	862	93.93	68.89	66.26	95.01
W4A4KV16	GPTQ	2286	849	93.98	66.93	67.29	94.64
W4A4KV16	BATQuant	2360	864	94.31	67.32	69.70	96.43
W4A8KV16	BATQuant	2386	893	95.55	70.20	73.14	99.29
W4A8KV8	BATQuant	2368	890	95.47	69.93	72.82	98.89
W4A8KV4	BATQuant	2332	885	95.07	68.63	70.92	97.51

Under W4A4KV16, recovery exceeds FlatQuant by 1.64 percentage points, but the strongest baseline in the table is actually SmoothQuant, making that gap 1.42 percentage points. The prose calling FlatQuant the strongest baseline conflicts with the table. BATQuant also does not lead every individual metric: its OCRBench score is below FlatQuant and its RealWorldQA score is below SmoothQuant.

The next table reproduces selected Qwen3-8B reasoning results from Table 3. Every quantized row uses W4A4KV16. Avg. is the mean of the five task scores, whereas Recovery is the separate relative-recovery metric reported in the source; they are not interchangeable.

Method	GSM8K	MATH-500	AIME24	AIME25	GPQA-D	Avg.	Recovery (%)
BF16	95.15	96.87	71.46	63.12	58.13	76.95	100.00
SpinQuant	93.40	91.67	38.57	35.63	45.66	60.99	76.35
BRQ	92.27	91.73	37.29	34.58	48.03	60.78	76.25
FlatQuant	93.40	94.33	58.96	43.54	50.51	68.15	86.78
SmoothQuant	94.69	95.33	60.71	47.29	52.42	70.09	89.60
GPTQ	94.24	95.73	57.50	52.08	52.12	70.33	90.10
BATQuant	94.77	95.60	62.08	52.92	54.19	71.91	92.45

Relative to GPTQ, BATQuant improves Avg. by 1.58 points and Recovery by 2.35 percentage points, while remaining below BF16. The paper's claim of severe baseline collapse on GSM8K and MATH-500 is overstated; the table shows more pronounced losses on harder tasks such as AIME24 and AIME25.

Ablation Study

These results come from Table 4 under W4A4KV16. Global means using the global counterpart, not removing the corresponding module. Non-reasoning Avg. aggregates ARC-C, ARC-E, HellaSwag, PIQA, and Winogrande.

Transformation scope	Clipping scope	Qwen3-8B non-reasoning Avg.	Qwen3-VL-8B Recovery (%)
Block-wise	Global	68.51	96.18
Global	Block-wise	68.24	95.59
Block-wise	Block-wise	68.70	96.43

With block-wise clipping retained, replacing the global transformation with its block-wise counterpart improves the two aggregates by 0.46 points and 0.84 percentage points. With the block-wise transformation retained, replacing global clipping with block-wise clipping adds 0.19 points and 0.25 percentage points. These results test module granularity, not the presence versus absence of transformations. The table does not report a row with both components global.

Key Findings

• The transformation-block sweep fixes MXFP quantization blocks at 32, and both models perform best when transformation blocks also contain 32 elements. Smaller transformations cannot coordinate the entire quantization block; larger ones mix multiple blocks. Exact coordinates from Figure 7 were not fully extracted, so only the prose-supported GPK capacity trend is retained.
• Efficiency evidence spans different levels: representative GEMM throughput is approximately 4.7 times BF16, whereas end-to-end Qwen3-8B speedup reaches 1.82 times at batch size 64, prefill 256, and decode 16. At batch size 1, the speedup is only 0.94 times, so not every workload benefits.
• Memory measurements use prefill 256 and decode 32. At batch size 1, BF16, BATQuant, and MR-GPTQ consume 15.30, 5.85, and 5.89 GB respectively; at batch size 64 they consume 17.65, 10.56, and 12.95 GB. The different decode lengths mean the memory and latency experiments must not be presented as one identical configuration.

Highlights & Insights

• Matching preprocessing granularity to shared-scale granularity is the central lesson. Better global outlier statistics do not guarantee lower error in every hardware block, a useful consideration for other grouped low-precision formats.
• GPK separates parameter sharing from data mixing. Reusing a transformation basis reduces storage without allowing inputs to interact across blocks, preserving the method's original locality constraint.
• Output reconstruction connects distribution shaping to model usefulness. Suppressing outliers or producing attractive histograms can sacrifice weight-side precision, making joint output error a better target than an isolated statistic.

Limitations & Future Work

• The main paper has no standalone limitations section; the following points are primarily reading-based assessments of the experimental scope. Evaluation centers on Qwen3-8B and Qwen3-VL-8B-Instruct, which does not establish equivalent benefits for other model families, scales, or MoE architectures.
• GPK's best capacity depends on limited calibration data and optimization settings. The authors discuss convergence difficulties with too many private parameters, but the available main text does not include broad calibration-set sensitivity studies or repeated-run error bars.
• Online transformations still incur overhead, and the small-batch end-to-end results already show a slowdown. Deployment claims need measurements with long contexts, larger KV caches, other hardware, and end-to-end multimodal workloads rather than extrapolation from GEMM throughput alone.
• Reproducibility is limited by the available material: appendices are absent, several equations are corrupted, and the efficiency section does not specify the hardware model or complete kernel configuration. Baseline rankings and degradation claims also differ between prose and tables, so individual results should take precedence.

Related Work & Insights

• Compared with QuaRot / SpinQuant: These primarily distribute outliers through global orthogonal rotation. BATQuant changes both transformation scope and constraints, so its gains cannot simply be described as learning a better rotation.
• Compared with BRQ / MR-GPTQ: Block rotation and format adaptation already establish the importance of local handling for MXFP. BATQuant adds non-orthogonal distribution shaping and block-wise learnable clipping, at the cost of calibration and online transformations.
• Compared with FlatQuant: Both use learnable transformations and Kronecker ideas. The main distinctions are strict alignment with quantization blocks and the organization of a globally shared basis plus private block parameters, not the first use of affine transformation.
• Compared with GPTQ: The methods are complementary rather than mutually exclusive. BATQuant constructs a representation better suited to quantization, while GPTQ performs weight quantization. The main results combine them by default, so reproductions should hold the weight quantizer fixed when comparing transformations.

Rating

• Novelty: 4/5. A concrete combination of hardware-block alignment, non-orthogonal shaping, and shared factorization, built on established block-rotation and affine-quantization approaches.
• Experimental Thoroughness: 4/5. Covers multimodal, non-reasoning, reasoning, module granularity, and deployment efficiency, but model families and scales remain limited.
• Writing Quality: 3/5. The mechanism is coherent, but claims about the strongest baseline and some degradation patterns do not fully match the tables; missing cached material also limits verification.
• Value: 4/5. Offers a practical direction for MXFP4 accuracy and deployment, particularly by showing why INT4 rotation recipes should not be transferred blindly to microscaling formats.