FP4 vs FP8 vs INT4 Quantization: Performance & Accuracy

Scaling enterprise LLM serving pipelines requires balancing Inference Speed (Tokens/Second), Hardware VRAM Memory Footprint, and Model Accuracy (Perplexity).

While previous generations of GPU inference relied heavily on integer quantization (INT8 and INT4 via AWQ and GPTQ), modern GPU architectures (such as NVIDIA Hopper H100 and Blackwell B200) introduce native floating-point micro-scaling formats: FP8 (E4M3 / E5M2) and FP4 (NVFP4 / MXFP4).

In this technical guide, we evaluate the numerical dynamic range, hardware Tensor Core support, memory bandwidth efficiency, and accuracy trade-offs across FP4, FP8, and INT4.

Dynamic Range & Numerical Representation Math

Quantization formats differ in how they divide available bit budgets between sign ($S$), exponent ($E$), and mantissa ($M$) bits.

flowchart TD
    subgraph 8-Bit Floating Point FP8 E4M3
        S1[1 Sign Bit] --- E1[4 Exponent Bits] --- M1[3 Mantissa Bits]
    end
    
    subgraph 4-Bit Integer INT4
        S2[1 Sign Bit] --- I2[3 Integer Magnitude Bits]
    end
    
    subgraph Micro-scaling FP4 NVFP4
        BlockScale[Shared Block Scale Factor E8M0] --> FP4Bits[4-Bit Element: 1 Sign + 2 Exponent + 1 Mantissa]
    end

Format Specification Comparison

Micro-Scaling Mechanics: Why FP4 Outperforms INT4

Traditional INT4 quantizes weight tensors by applying a global or channel-wise scale factor $S$:

$$W_{\text{quantized}} = \text{clamp} \left( \text{round} \left( \frac{W}{S} \right), -8, 7 \right)$$

Because weight distributions in large language models contain extreme outlier activations, global linear scaling forces most weights into a narrow set of integer bins, causing significant accuracy degradation.

Micro-Scaling (MX / NVFP4) Architecture

NVFP4 divides weight matrices into tiny 16-element vector blocks. Each block shares a high-precision 8-bit scale factor ($E8M0$), allowing individual 4-bit elements ($E2M1$) to adapt dynamically to local activation spikes:

$$W_{\text{element}} = (-1)^S \times 2^{E - 1} \times \left( 1 + \frac{M}{2} \right) \times S_{\text{block}}$$

Impact: NVFP4 achieves the memory density of INT4 while retaining over 99.0% of FP8 accuracy.

Hardware Tensor Core Support Matrix

Accuracy & Throughput Benchmark: Llama 3.3 70B Serving

Evaluated across high-volume production inference serving benchmarks:

gantt
    title Relative FLOPS Throughput on NVIDIA Blackwell B200
    dateFormat X
    axisFormat %s
    section Native FP16 Baseline
    FLOPS (2,250 TFLOPS) : 0, 2250
    section FP8 (E4M3)
    FLOPS (4,500 TFLOPS) : 0, 4500
    section NVFP4 Micro-scaling
    FLOPS (9,000 TFLOPS) : 0, 9000

Summary & Deployment Recommendations

1. For Hopper H100 / H200 Workloads: Deploy FP8 (E4M3) via vLLM or TensorRT-LLM for 2x throughput with zero calibration overhead.
2. For Blackwell B200 Workloads: Deploy NVFP4 to achieve 4x FLOPS throughput over FP16 while preserving 99%+ accuracy.
3. For Legacy Consumer Hardware (RTX 3090 / 4090): Use INT4 (AWQ / GGUF Q4_K_M) for maximum VRAM memory reduction.