Floating-point formats: FP32, FP16, BF16, FP8, TF32

Summary

A floating-point format spends bits on magnitude range and local precision. More exponent bits do not preserve smaller relative updates.

Round $1.003$ to FP16 and BF16 using round-to-nearest-even. Both use sixteen bits, but FP16 has ten fraction bits and BF16 has seven. Which format retains more of this change from one?

FP16 vs. BF16: range vs. precision

For normal values, decode sign $s$ , fraction $F$ and unbiased exponent $E$ as $(- 1)^{s} (1 + F) 2^{E}$ . With $f$ fraction bits, spacing within $[2^{E}, 2^{E + 1})$ is $2^{E - f}$ .

Same storage, different rounded value

Actual rounded bit fields for 1.003

FP16: 1 sign + 5 exponent + 10 fraction

More fraction bits make nearby values finer; fewer exponent bits narrow the normal range.

Field	Bits	What those bits buy
Exponent	5	normal magnitudes ≈ 6.10 × 10⁻⁵ to 6.55 × 10⁴
Fraction	10	next value after 1 is 1 + 2⁻¹⁰ ≈ 1.00098

Failure mode: values below the narrow range become subnormal, then zero.

BF16: 1 sign + 8 exponent + 7 fraction

More exponent bits preserve FP32-like range; fewer fraction bits make nearby values coarser.

Field	Bits	What those bits buy
Exponent	8	normal magnitudes ≈ 1.18 × 10⁻³⁸ to 3.39 × 10³⁸
Fraction	7	next value after 1 is 1 + 2⁻⁷ ≈ 1.00781

Failure mode: updates can round away because adjacent values are farther apart.

Read it this way: each row has the same width. BF16 allocates more bits to the exponent, leaving fewer fraction bits. Its broader range does not preserve the 0.003 change near one.

Check: Why can BF16 have broader range yet round away the 0.003 change retained by FP16?

Reference drawing

Same storage, different rounded value

Spend bits on range or resolution; distinguish rounding, overflow, and scaled-integer saturation

Derivation

FP16: 1 sign + 5 exponent + 10 fraction

More fraction bits make nearby values finer; fewer exponent bits narrow the normal range.

Field	Bits	What those bits buy
Exponent	5	normal magnitudes ≈ 6.10 × 10⁻⁵ to 6.55 × 10⁴
Fraction	10	next value after 1 is 1 + 2⁻¹⁰ ≈ 1.00098

Failure mode: values below the narrow range become subnormal, then zero.

BF16: 1 sign + 8 exponent + 7 fraction

More exponent bits preserve FP32-like range; fewer fraction bits make nearby values coarser.

Field	Bits	What those bits buy
Exponent	8	normal magnitudes ≈ 1.18 × 10⁻³⁸ to 3.39 × 10³⁸
Fraction	7	next value after 1 is 1 + 2⁻⁷ ≈ 1.00781

Failure mode: updates can round away because adjacent values are farther apart.

Read it this way: each row has the same width. BF16 allocates more bits to the exponent, leaving fewer fraction bits. Its broader range does not preserve the 0.003 change near one.

Check: Why can BF16 have broader range yet round away the 0.003 change retained by FP16?

Read it this way: Both sixteen-bit formats trade exponent range against fraction resolution. Near one, BF16 spacing is eight times wider: 1.003 rounds to one, while FP16 keeps about 1.00293. At 70000, FP16 overflows but BF16 remains finite and inexact. Accumulation precision is separate. Scaled INT8 instead maps values to bounded integer codes; finer scale improves local resolution but narrows range. Saturation is not rounding noise. Does wider range preserve smaller updates?

References: NVIDIA's IEEE 754 overview, Google Cloud's BF16 documentation, and the BFLOAT16 study.

In $[1, 2)$ , FP16 spacing is $2^{- 10} = 0.0009765625$ . BF16 spacing is $2^{- 7} = 0.0078125$ , eight times wider.

Format	Rounded $1.003$	Absolute error
FP16	$1.0029296875$	$0.0000703125$
BF16	$1$	$0.003$

These are rounding errors in a fixture, not measurements of model quality.

Change the numerical requirement

1. Prioritize range

New task: store $70000$ with the same rounding rule.

Picture and change: inspect the exponent range rather than only spacing near one.

Check: FP16 overflows because its largest finite value is $65504$ . BF16 rounds to finite $70144$ , not exact $70000$ .

Use when: activations exceed FP16 range and BF16 rounding is acceptable for the application.

2. Store scaled integers

New task: store $x = 0.26$ as signed INT8 with scale $a = 0.1$ and zero point zero.

Picture and change: compute $q = clamp (round (x / a), - 128, 127)$ , then reconstruct $\overset{x}{^} = a q$ . This is scaled integer quantization, not an exponent/fraction format.

Check: $q = 3$ reconstructs $0.3$ , with error $0.04$ . Scale $0.01$ reconstructs $0.26$ exactly but narrows the representable range. For 1024 raw values, INT8 uses 1024 bytes versus BF16’s 2048 bytes, excluding metadata.

Use when: storage or bandwidth motivates quantization and calibration can establish a suitable scale.

Saturation is not rounding noise

At scale $0.1$ , $x = 20$ exceeds INT8’s largest code. Clamping reconstructs $12.7$ instead. Finer rounding within the existing range cannot recover the clipped value.

Try the next exponent interval

What is BF16 spacing within $[2, 4)$ ?

Check your answer

It is $2^{1 - 7} = 0.015625$ . Increasing the exponent doubles spacing while the fraction width stays fixed.

The standard layouts

The table gives approximate finite endpoints and normal minima. FP8 rows use the E4M3 finite-endpoint and E5M2 conventions described in FP8 Formats for Deep Learning.

Format	Stored bits	Exponent / fraction	Largest finite magnitude	Smallest positive normal
FP32	32	8 / 23	$3.4 \times 1 0^{38}$	$1.18 \times 1 0^{- 38}$
FP16	16	5 / 10	$65504$	$2^{- 14}$
BF16	16	8 / 7	$3.39 \times 1 0^{38}$	$2^{- 126}$
TF32 multiply input precision	FP32 storage	8 / 10	Approximately FP32 range	Approximately FP32 normal range
FP8 E4M3	8	4 / 3	$448$	$2^{- 6}$
FP8 E5M2	8	5 / 2	$57344$	$2^{- 14}$
Signed INT8	8	Neither	Codes $- 128$ through $127$	Scale-dependent step
FP64	64	11 / 52	$1.8 \times 1 0^{308}$	$2.23 \times 1 0^{- 308}$

FP16’s smallest positive subnormal is $2^{- 24}$ , below its normal minimum. Actual operations may flush subnormals to zero; representable values and hardware behavior are separate questions.

TF32: a hybrid for matmul accumulation

TF32 is an internal multiply-input precision, not a packed nineteen-bit tensor dtype. Its reduced fraction precision and FP32 accumulation describe separate stages. Check the actual operation, library version and enabled precision policy; defaults and speedups are not universal.

FP8: the new training format

OFP8 E4M3 has more fraction precision and a smaller finite range than E5M2. E4M3’s finite-endpoint convention has no infinity encoding; E5M2 includes infinities. Other FP8 variants have different endpoint conventions. Scaling, tensor placement and accumulation precision are part of a training recipe, not implied by the bit count.

INT8: the inference format

Affine quantization adds a zero point $z$ : $q = clamp (round (x / a) + z, q_{m i n}, q_{m a x})$ . Reconstruction is $a (q - z)$ . Per-tensor, per-channel and grouped scales trade metadata and kernel support against quantization error.

INT4 / NF4 / GPTQ: aggressive inference quantization

INT4 stores sixteen codes; its reconstruction depends on scales and zero points. NF4 uses nonuniform levels motivated by a normal-weight distribution. GPTQ and AWQ are distinct quantization methods, not scalar floating-point formats. Evaluate the actual model, calibration distribution, kernels and downstream quality.

Choosing precision by operation

Task	Format
Training	Select parameter, activation, reduction and optimizer-state precision separately
FP16 backward	Consider loss scaling; unscale before clipping and optimizer updates
BF16 backward	Broader range often avoids loss scaling, but coarse updates can still disappear
Inference	Check weight, activation and KV-cache quantization independently
Memory-limited deployment	Include scales, metadata, workspace and kernel support, not only raw weight bits

Common pitfalls

Loss scaling does not repair low-precision master-weight rounding or incorrect arithmetic. Reduced-precision optimizer states need a validated recipe; FP32 is not a universal theorem or the only workable choice. Throughput comparisons must state format, sparsity, operation and workload.

Mixed precision training. Practical training in FP16/BF16.
Quantization. Inference quantization in depth.
GPU memory hierarchy. Why bandwidth matters.

Summary

FP16 vs. BF16: range vs. precision

FP16: 1 sign + 5 exponent + 10 fraction

BF16: 1 sign + 8 exponent + 7 fraction

FP16: 1 sign + 5 exponent + 10 fraction

BF16: 1 sign + 8 exponent + 7 fraction

Change the numerical requirement

1. Prioritize range

2. Store scaled integers

Saturation is not rounding noise

Try the next exponent interval

The standard layouts

TF32: a hybrid for matmul accumulation

FP8: the new training format

INT8: the inference format

INT4 / NF4 / GPTQ: aggressive inference quantization

Choosing precision by operation

Common pitfalls

Related