FP4

FP4 é um formato de ponto flutuante de 4 bits usado para armazenar e calcular os pesos e as ativações de redes neurais na quantização de modelos. O hardware e o software de IA usam o formato E2M1: um bit de sinal, dois bits de expoente e um bit de mantissa, que só consegue representar 0, ±0.5, ±1, ±1.5, ±2, ±3, ±4 e ±6. Cada valor ocupa metade da memória de FP8 e um quarto da de FP16 (precisão de meia palavra), o que é mais importante para modelos de linguagem grandes e outros modelos de IA generativa, cuja latência de inferência é dominada pela transferência dos pesos da memória. A aritmética matricial FP4 nativa chegou com as GPUs Blackwell da NVIDIA e a série Instinct MI350 da AMD, e FP4 é usado tanto para inferência quanto, cada vez mais, para treinamento.

Como funciona FP4#

Quinze valores distintos não conseguem cobrir a faixa de pesos e ativações reais, por isso todo formato FP4 prático divide um tensor em pequenos blocos e armazena uma escala compartilhada por bloco, escolhida para que a maior magnitude do bloco seja mapeada perto do máximo E2M1 de 6. Os dois formatos principais diferem no tamanho do bloco e na precisão da escala:

• MXFP4: Definido na especificação de Microrreferenciamento (MX) do Open Compute Project, o MXFP4 agrupa 32 valores sob uma escala de potência de dois de 8 bits (E8M0). Como especificação aberta, é compatível com vários fornecedores, incluindo a série MI350 da AMD e as GPUs Blackwell da NVIDIA.
• NVFP4: O formato da NVIDIA agrupa 16 valores sob uma escala FP8 (E4M3) e adiciona uma segunda escala FP32 por tensor. Os blocos menores e as escalas mais precisas reduzem o erro de quantização, e a NVIDIA relatou perda de precisão de 1% ou menos em relação ao FP8 nos benchmarks do DeepSeek-R1-0528.

O trecho abaixo arredonda um tensor com alguns valores atípicos para valores E2M1 usando uma escala para todo o tensor, depois uma escala por 32 valores e por 16 valores, os tamanhos de bloco do MXFP4 e do NVFP4:

import torch

# The eight non-negative values FP4 E2M1 can represent; the sign bit mirrors them
grid = torch.tensor([0.0, 0.5, 1.0, 1.5, 2.0, 3.0, 4.0, 6.0])

torch.manual_seed(0)
x = torch.randn(4096)
x[::512] *= 20  # a few large outliers, as real weight and activation tensors have

# One shared scale for the whole tensor, then MXFP4-sized and NVFP4-sized blocks
for block in [4096, 32, 16]:
    blocks = x.reshape(-1, block)
    scale = blocks.abs().amax(dim=1, keepdim=True) / 6.0  # map each block's largest value to 6
    nearest = ((blocks.abs() / scale).unsqueeze(-1) - grid).abs().argmin(dim=-1)
    dequantized = grid[nearest] * blocks.sign() * scale
    error = (dequantized.flatten() - x).abs().mean()
    print(f"Block size {block:>4}: mean absolute error {error:.4f}")

Com uma escala para todo o tensor, os valores atípicos ampliam tanto a escala que a maioria dos valores comuns é arredondada para zero, resultando em erro absoluto médio de 0,7238. Blocos de 32 e 16 valores confinam cada valor atípico a um único bloco, de modo que todos os outros blocos mantêm uma escala precisa e o erro cai para 0,0901 e 0,0747.

Inferência e Treinamento FP4#

Para inferência, um motor de inferência, como o TensorRT, quantiza os pesos e, muitas vezes, as ativações em FP4 após o treinamento, executa as multiplicações de matrizes em FP4 e acumula os resultados com precisão mais alta. As configurações NVFP4 e MXFP4 do TorchAO levam o mesmo fluxo de trabalho ao PyTorch em GPUs compatíveis. A OpenAI lançou o gpt-oss-120b com seus pesos de mistura de especialistas pós-treinados em MXFP4, o que permite executar o modelo de 117 bilhões de parâmetros em uma única GPU de 80 GB.

O treinamento em FP4 estende o treinamento de precisão mista até 4 bits e é mais difícil do que a inferência, pois os gradientes e as ativações mudam de faixa durante o treinamento. O estudo de pré-treinamento NVFP4 da NVIDIA treinou em NVFP4 um modelo de 12 bilhões de parâmetros com 10 trilhões de tokens, obtendo perda de treinamento e precisão em tarefas posteriores comparáveis às de uma referência FP8, ao combinar transformadas aleatórias de Hadamard para distribuir os valores atípicos, arredondamento estocástico para os gradientes e algumas camadas mantidas em precisão mais alta.

Implantação de Modelos FP4#

Os núcleos tensoriais FP4 nativos exigem GPUs NVIDIA Blackwell ou posteriores, como a B200 e a série GeForce RTX 50, ou aceleradores AMD Instinct MI350 para MXFP4; GPUs Hopper, como a H100, aceleram FP8, mas não FP4. A matriz de compatibilidade do TensorRT lista as precisões compatíveis com cada GPU. A precisão deve ser verificada após a conversão e antes da implantação do modelo, pois camadas sensíveis ou modelos pequenos podem sofrer degradação, e o treinamento com reconhecimento de quantização recupera a precisão quando a quantização pós-treinamento não é suficiente. A exportação para TensorRT do Ultralytics YOLO26 compila mecanismos em FP16 com quantize=16 ou em INT8 com quantize=8, as opções de baixa precisão disponíveis para os modelos YOLO.

FP4 vs. Formatos Relacionados#

• FP8: FP8 (E4M3 ou E5M2) tem muito mais valores distintos e uma faixa mais ampla; como o treinamento FP8 é amplamente adotado para modelos grandes, FP8 é a referência habitual para comparar resultados FP4.
• BFloat16: BF16 continua sendo o formato padrão para treinar e servir modelos grandes com qualidade total, com quatro vezes mais bits que FP4.
• INT4: INT4 distribui seus 16 níveis uniformemente, enquanto FP4 concentra mais níveis perto de zero, onde se encontram a maioria dos pesos e das ativações. INT4 continua sendo comum para compressão apenas de pesos de modelos de linguagem, com métodos como GPTQ e AWQ.
• Soquete FP4 da AMD: FP4 também é o nome de um soquete de processador para laptops da AMD sem relação com esse formato, o encapsulamento usado por APUs móveis da geração Carrizo, como a FX-8800P.