Block-Scaled Precision Formats

Updated 4 July 2026

Block-scaled precision formats are low-bit numerical representations where a group of values shares a scale, enabling an extended dynamic range with reduced storage requirements.
They encompass diverse schemes like classical BFP, NVFP4, and hierarchical formats that couple payload precision with adaptive scaling for minimized quantization error.
Adaptive techniques such as ScaleSearch and Four Over Six dynamically select optimal scales, balancing precision, computational efficiency, and robust performance in training and inference.

Block-scaled precision formats are low-bit numerical representations in which a group of values shares a scale while each element stores only a reduced-precision code. In its most general form, a decoded value is $w_i = s_b \times p_i$ , where $s_b$ is block metadata and $p_i$ is the per-element payload. This design spans classical block floating point, scaled block floating point, microscaling formats such as NVFP4 and MXFP4, and hierarchical or multi-level shared-exponent schemes. Across recent work, block scaling has become a central mechanism for extending dynamic range under 3–8 bit budgets, but its behavior depends sharply on codebook geometry, scale precision, block granularity, and the interaction between quantization and downstream optimization dynamics (Khodamoradi et al., 2024, Soloveychik et al., 2022, Rouhani et al., 2023).

1. Representational structure and format families

A block-scaled format stores one scale for a small group of values and reduced-precision element codes for the values inside that group. This differs from standard floating-point, where exponent and mantissa are carried per element, and from ordinary integer quantization with coarse per-tensor or per-channel scaling, because the choice of a block scale directly couples neighboring elements. The coupling is not incidental: selecting a scale for one value changes the representable set for the rest of the block (Khodamoradi et al., 2024).

Several concrete families illustrate the design space.

Family or example	Block and scale structure	Distinguishing property
BFP / SBFP	One shared scale for $n$ mantissas	BFP uses power-of-two scale; SBFP stores scale in full precision
NVFP4	16 FP4 E2M1 values, one FP8 E4M3 block scale, one tensor-wide FP32 scale	Blackwell-native microscaling
MXFP4	32 FP4 E2M1 values, one power-of-two shared scale	Coarser scale lattice than NVFP4
HiFloat4	64 values with top-level E6M2 plus $E1_8$ and $E1_{16}$ micro-exponents	Hierarchical block scaling
MX / shared microexponents	First-level scale over $k_1 \approx 16$ , microexponents over $k_2 \approx 2$	Two-level power-of-two scaling

Within NVFP4, the FP4 E2M1 payload uses the signed set $\pm\{0, 0.5, 1, 1.5, 2, 3, 4, 6\}$ , while one FP8 E4M3 scale is stored per 16 FP4 values together with a tensor-wide FP32 scale $\alpha$ . MXFP4 uses the same FP4 E2M1 payload but typically pairs 32 values with an exponent-only power-of-two scale. HiFloat4 instead places 64 values under a three-level hierarchy: an unsigned 8-bit E6M2 top-level scale, 8 one-bit micro-exponents for 8-element groups, and 16 one-bit micro-exponents for 4-element groups. Shared-microexponent MX formats generalize this idea by combining a first-level shared scale with very small per-subblock microexponents, often at $s_b$ 0, to obtain finer local adaptation without per-element exponents (Cook et al., 1 Dec 2025, Taghian et al., 9 Apr 2026, Rouhani et al., 2023).

The common representational pattern is therefore not a single format but a family of schemes that trade off payload precision, scale precision, block granularity, and hierarchy depth. This suggests that “block-scaled precision” is best understood as an architectural principle rather than a single numeric encoding.

2. Quantization rules, scale selection, and error geometry

A generic block-scaled quantization pipeline first derives a block scale from a block maximum and then quantizes normalized elements: $s_b$ 1 Here $s_b$ 2 is the maximum representable magnitude of the element format, such as $s_b$ 3 for FP4 E2M1. In classical SBFP, the scale is $s_b$ 4 with $s_b$ 5 and $s_b$ 6, whereas BFP replaces this with the power-of-two scale $s_b$ 7 (Fasoli et al., 26 Jan 2026, Soloveychik et al., 2022).

The critical observation in recent FP4 work is that the dominant error source is often not merely “low bitwidth” but the geometry of the codebook under shared scaling. In NVFP4, the E2M1 step size is non-uniform: $s_b$ 8 between $s_b$ 9 and $p_i$ 0, $p_i$ 1 between $p_i$ 2 and $p_i$ 3, and $p_i$ 4 between $p_i$ 5 and $p_i$ 6. Under the default max-based rule, the block maximum is mapped to $p_i$ 7, which leaves no representable value near scaled magnitude $p_i$ 8. As a result, values near the block maximum incur disproportionately large error; simulations in the NVFP4 analysis show especially strong degradation when values around scaled magnitude $p_i$ 9 are quantized, with smaller spikes near $n$ 0 and $n$ 1 at the step changes (Cook et al., 1 Dec 2025).

Max-based scale selection is therefore not generally MSE-optimal. ScaleSearch makes this explicit for microscaling BFP: starting from the default NVFP4 scale

$n$ 2

it searches nearby FP8 codes $n$ 3 and selects the one minimizing

$n$ 4

Because NVFP4 uses FP8 scales with mantissa bits rather than only powers of two, nearby representable scales form a dense local search space, and the method reports a 27% reduction in quantization error for NVFP4 (Gupta et al., 12 May 2026).

A second misconception is that smaller blocks are always superior. A recent microscaling study shows the opposite can happen when scales are quantized: once block size becomes too small, narrow per-block distributions force very small scales into poorly represented FP8 bins or even the zero-scale bin. The resulting max-element mismatch and scale underflow can outweigh the benefit of finer granularity. That work identifies this “perplexity inversion” in LLMs and proposes unsigned FP8 E5M3 scales as a remedy, since UE5M3 extends the minimum nonzero scale from $n$ 5 to $n$ 6 without changing mantissa precision (Fasoli et al., 26 Jan 2026).

3. Adaptive block scaling and mixed block representations

One major response to the geometric limitations of max-based FP4 scaling is adaptive scale selection. The Four Over Six method modifies NVFP4 by evaluating two candidate block scales,

$n$ 7

then quantizing and dequantizing both candidates and choosing the lower-error block under an objective such as MSE. Its central insight is that mapping a block maximum to $n$ 8 rather than $n$ 9 can make representable values near the top of the block more uniform, even though the FP4 codebook itself is unchanged. The method retains tensor-core compatibility because only the chosen block scale and payload change; the storage format remains FP4 plus FP8 scale metadata (Cook et al., 1 Dec 2025).

A more general strategy is to adapt not only the scale but also the local micro-format. MixFP4 extends NVFP4 by choosing between two stored FP4 payload formats per block: exponent-heavy E2M1 and mantissa-heavier E1M2. It keeps the same FP32-per-tensor and FP8-per-block hierarchy, chooses the lower-MSE candidate, and encodes the format choice in the otherwise unused sign bit of the FP8 E4M3 block scale. Both payloads are decoded into a unified internal E2M2 representation, which avoids separate compute pipelines. Reported tensor-core datapath overhead is 3.1% area and 1.5% power (Zou et al., 29 May 2026).

Adaptive block-scaled data types push the same principle further by mixing FP and INT codebooks. IF4 selects, per 16-value block, between FP4 E2M1 and scaled INT4 under a common UE4M3 block scale. Its “6/7 method” rescales INT4 so that FP4 and INT4 modes share the same physical range $E1_8$ 0, which preserves global dynamic range while allowing the block to choose the more suitable quantizer. On $E1_8$ 1, the reported MSE is $E1_8$ 2 for IF4, compared with $E1_8$ 3 for NVFP4, $E1_8$ 4 for NVFP4 with 4/6, $E1_8$ 5 for NVINT4, and $E1_8$ 6 for MXFP4 (Cook et al., 30 Mar 2026).

These methods all replace a fixed “map the maximum to the maximum code” rule with an optimization over candidate scales or codebooks. A plausible implication is that block-scaled FP formats are increasingly being treated as adaptive local approximation schemes rather than static storage formats.

4. Quantization algorithms, calibration methods, and execution paths

Block-scaled formats require quantization procedures that explicitly respect shared-scale dependencies. Error Diffusion is a post-training quantization method built around this constraint. It formulates quantization at the level of layer outputs, models the network as a composite function, and diffuses residual quantization error forward while quantizing layer weights. For block-scaled layouts, it updates blocks rather than independent elements because quantizing one element can alter the shared block scale and therefore the reconstruction of neighboring elements. The method is hyperparameter-free, does not use backpropagation or Hessian information, and is implemented in the TensorCast PyTorch library to emulate custom block-scaled formats (Khodamoradi et al., 2024).

At serving time, mixed-format execution can be layered on top of block-scaled representations. MicroMix uses MX formats on Blackwell GPUs and assigns channels to MXFP4, MXFP6, or MXFP8 according to quantization thresholds derived from an INT8-style error bound. All formats use a shared E8M0 scale per 32-element block, and the Blackwell $E1_8$ 7 path fuses dequantization with matrix multiplication, accumulates in FP32, and emits BF16 outputs. The resulting kernel is reported to be at least 20% faster than TensorRT-FP8 on both RTX 5070Ti laptop and RTX 5090 systems (Liu et al., 4 Aug 2025).

Block-scaled formats have also been specialized for attention kernels. ScaleSearchAttention quantizes $E1_8$ 8, $E1_8$ 9, $E1_{16}$ 0, and the partial-probability matrix $E1_{16}$ 1 blockwise in NVFP4, applies ScaleSearch to each micro-block, and combines the search with Hadamard incoherence processing, a magnitude-reduction reparameterization, and attention-sink-aware mixed precision. For Llama 3.1 70B, the paper reports a Wikitext-2 perplexity reduction from $E1_{16}$ 2 under naive FP4 attention to $E1_{16}$ 3, close to the full-precision $E1_{16}$ 4 baseline (Gupta et al., 12 May 2026).

These algorithms underline a broader point: in block-scaled systems, “quantization” is no longer a one-shot cast. It typically includes scale calibration, block-aware error evaluation, metadata layout, and a hardware-specific execution path that determines whether the representation remains practical.

5. Training and inference behavior

Training with block-scaled formats is not merely a lower-precision analogue of BF16 or FP16 training. A large MX-format study reports sharp, stochastic-looking loss spikes across nearly one thousand LLMs trained from scratch, with compute budgets from $E1_{16}$ 5 to $E1_{16}$ 6 FLOPs. The proposed mechanism is multiplicative gradient bias caused by quantizing layer-norm affine parameters and a small fraction of activations inside shared-scale blocks. In proxy experiments, instability can often be averted by keeping activations and layer normalization in BF16 or by quantizing only the forward pass (Su et al., 25 Jun 2025).

The NVFP4 analysis reaches a related conclusion from a different angle. When all GEMM operands are quantized to NVFP4 to preserve the fast Blackwell tensor-core path, baseline training diverges across all tested architectures, including transformers with QK Norm and hybrid attention models. Replacing max-based scaling with 4/6 adaptive block scaling stabilizes training and keeps the loss curve significantly closer to BF16 (Cook et al., 1 Dec 2025).

Inference behavior is equally structured rather than uniform across a network. A layer-wise and block-wise sensitivity analysis of NVFP4 and MXFP4 on Qwen2.5 models finds that MLP up-projection and down-projection are consistently the most sensitive components, gate projections are moderately sensitive, and attention projections are substantially less sensitive. It also finds that sensitivity does not universally concentrate in the last transformer blocks: early blocks can be highly sensitive, particularly under MXFP4. Across all scales studied, NVFP4 is generally more robust than MXFP4 (Cim et al., 5 Mar 2026).

Hierarchical block scaling offers another stabilization route. HiFloat4 performs all linear and expert GEMMs in FP4 on Ascend NPUs using a 64-element block with E6M2 top-level scale and E1 micro-exponents at finer granularities. In 50B-token pre-training runs, relative loss error against BF16 is reported as 1.19% for OpenPangu-1B, 0.85% for Llama3-8B, and 0.88% for Qwen3-MoE-30B, compared with 1.79%, 1.44%, and 1.55% respectively for MXFP4 under the study’s stabilization recipe (Taghian et al., 9 Apr 2026).

Taken together, these results show that the principal failure modes of block-scaled training and inference are format-specific. Some arise from codebook geometry near block maxima, others from scale under-representation in narrow blocks, and others from the interaction between shared scaling and optimization-sensitive tensors such as layernorm parameters.

6. Theory, block size, hardware co-design, and alternatives

A rigorous theoretical treatment predates the recent FP4 systems work. For Gaussian inputs, the BFP/SBFP analysis derives high-dimensional bounds for inner-product error and introduces a relative block-format accuracy measure. Under fixed 4-bit BFP mantissa precision, the reported optimal block size is $E1_{16}$ 7. The same framework shows why SBFP varies smoothly with block size while BFP exhibits jumps when the quantized power-of-two scale crosses exponent thresholds (Soloveychik et al., 2022).

Recent workload-specific studies complicate any universal block-size prescription. In an MRI mixed-precision FFT using MX formats, larger block sizes produced better numerical behavior, and mantissa precision rather than exponent range emerged as the primary limiter under MX scaling. In that study, moving from $E1_{16}$ 8 to $E1_{16}$ 9 or $k_1 \approx 16$ 0 improved PSNR, SSIM, and NMSE for representative formats such as MXFP8-E4M3 (Deveshwar et al., 3 Dec 2025). In contrast, NVFP4 edge-inference ablations identify $k_1 \approx 16$ 1 as a practical accuracy-storage knee, with

$k_1 \approx 16$ 2

which gives $k_1 \approx 16$ 3 bits per input at $k_1 \approx 16$ 4 and $k_1 \approx 16$ 5. That same study reports up to $k_1 \approx 16$ 6 energy reduction over traditional LUTs with ECC plus voltage scaling, and up to $k_1 \approx 16$ 7 area reduction (Sen et al., 3 Jun 2026). This suggests that block-size optimality is workload- and hardware-dependent rather than format-intrinsic.

Hardware co-design has therefore become central. Shared-microexponent MX formats show that a first-level power-of-two scale combined with tiny $k_1 \approx 16$ 8 microexponents can materially improve QSNR at low overhead, with MX9, MX6, and MX4 occupying favorable points on an accuracy-efficiency frontier (Rouhani et al., 2023). At the same time, some work now argues for bypassing block scaling entirely. The AetherFloat family proposes Base-4 explicit-mantissa formats with sufficiently wide per-element dynamic range to eliminate runtime AMAX logic. Its AF8 design is presented as “Block-Scale-Free,” with reported reductions of 33.17% in MAC area, 21.99% in total power, and 11.73% in critical path delay, though the format is explicitly described as QAT-first rather than PTQ-friendly (Morisaki, 26 Feb 2026).

The broader design lesson is therefore not that block-scaled precision formats are converging toward one canonical representation. Rather, recent work shows a widening design space: full-precision block scales versus power-of-two scales, static versus adaptive block scaling, mixed FP/INT or mixed micro-format blocks, hierarchical micro-exponents, and even proposals that remove block scaling by redesigning the per-element format. For ultra-low-bit arithmetic, scale selection has become a first-class optimization problem, not merely a metadata choice.