Floating-point inspector

The scale is a power of two: X is the largest power of two not above the block’s absolute maximum, divided by the largest power of two the element type can hold (2^8 for E4M3, 2^15 for E5M2, 2^2 for E2M3 and E2M1, 2^4 for E3M2, 2^0 for INT8). Each element is V/X rounded to the element type, ties to even, with values beyond its range clamped to ±max.

Worked example (MXFP4): a block whose largest value is 10. ⌊log₂ 10⌋ = 3 and E2M1’s largest power of two is 2^2, so X = 2^(3−2) = 2 (E8M0 code 128). Then 10/2 = 5 lies exactly between the E2M1 values 4 and 6 and rounds to the even code, 4: the stored 10 comes back as 8. A value of 2.5 becomes 1.25, which rounds to 1 and decodes as 2.

The specification leaves some cases to the implementation; here an all-zero block gets the smallest scale (2^−127), a block containing NaN or ±Infinity gets the NaN scale (so all of its values read as NaN), and the shared exponent is clamped to E8M0’s range — as the reference implementation does.

NVFP4 uses smaller blocks (16) and a more precise block scale: an FP8 E4M3 number, not just a power of two. Because E4M3 only reaches 448, a second, per-tensor FP32 scale first moves the whole tensor into range. With amax the tensor’s largest magnitude, the global encode scale is 6 · 448 / amax (6 and 448 are the largest E2M1 and E4M3 values) and its inverse is stored as FP32. Each block’s decode scale amax_b / 6 is multiplied by the global encode scale and rounded to E4M3; the elements are the inputs times the block’s effective encode scale, rounded to E2M1.

Worked example: two blocks, one with largest value 6 and one with 1.5. The tensor amax is 6, so the global decode scale is 1/448. The first block’s scale is e4m3(1 · 448) = 448; the second’s is e4m3(0.25 · 448) = 112. In the second block 1.5 is stored as 1.5 · 4 = 6, and 0.3 as 1.2 → 1, which decodes as 1 · 112 / 448 = 0.25.

NF4 (from QLoRA) scales each block of 64 values by its absolute maximum, then stores each value as the index of the nearest of 16 fixed levels placed at quantiles of a normal distribution, from −1 to 1 with an exact zero. FP32 block constants cost 32/64 = 0.5 bits per value. Double quantization quantizes those constants too: their mean is subtracted (and kept as one FP32 number), then they are stored as 8-bit floats in groups of 256 with an FP32 scale per group — 8/64 + 32/(64·256) ≈ 0.127 bits per value instead of 0.5. The QLoRA paper specifies "8-bit floats"; this tool uses FP8 E4M3, while bitsandbytes uses its own 8-bit dynamic map, so its second-level error differs slightly.

The integer layout used by GPTQ- and AWQ-style weight quantization: groups of 128 values share an FP16 scale, amax / 7, and each value is the nearest integer from −8 to 7 (ties to even) — 4
16/128 = 4.125 bits per value. This is the symmetric variant; GPTQ and AWQ often also store a 4-bit zero point per group, which shifts the steps but not their uniform spacing.

Real activations and weights contain a few values far larger than the rest. The One outlier panel replaces one element of your vector (at, counting from 0) by outlier × the vector’s RMS and quantizes it in the four 4-bit formats. For each it shows the RMS error of the other values of the outlier’s block before and after (bars: blue before, red after), the same over the whole vector, and the outlier’s own error. Every block takes its scale from its largest value, so the outlier stretches its own block’s scale and its neighbours collapse onto the few codes near zero: NVFP4’s 16-value blocks limit the damage to 15 neighbours, INT4’s 128-value groups spread it over 127 with uniform steps, and MXFP4’s power-of-two scale cannot represent the outlier itself closely (it lands on the nearest E2M1 step, up to about 20% off).