FP4

FP4 est un format de nombres à virgule flottante sur 4 bits utilisé pour stocker et calculer les poids et les activations des réseaux neuronaux dans le cadre de la quantification des modèles. Le matériel et les logiciels d’IA utilisent la disposition E2M1 : un bit de signe, deux bits d’exposant et un bit de mantisse, qui ne permet de représenter que 0, ±0.5, ±1, ±1.5, ±2, ±3, ±4 et ±6. Chaque valeur occupe deux fois moins de mémoire qu’en FP8 et quatre fois moins qu’en FP16 (demi-précision), ce qui compte surtout pour les grands modèles de langage et les autres modèles d’IA générative dont la latence d’inférence est dominée par le transfert des poids depuis la mémoire. Le calcul matriciel natif FP4 est arrivé avec les GPU Blackwell de NVIDIA et la série Instinct MI350 d’AMD ; FP4 est utilisé pour l’inférence et, de plus en plus, pour l’entraînement.

Fonctionnement de FP4#

Quinze valeurs distinctes ne peuvent couvrir l’étendue des poids et activations réels ; tous les formats FP4 pratiques divisent donc un tenseur en petits blocs et stockent une échelle commune par bloc, choisie pour que la magnitude maximale du bloc soit proche du maximum E2M1 de 6. Les deux principaux formats diffèrent par la taille des blocs et la précision de l’échelle :

• MXFP4 : défini dans la spécification Microscaling (MX) de l’Open Compute Project, MXFP4 regroupe 32 valeurs avec une échelle de puissance de deux de 8 bits (E8M0). Spécification ouverte, il est pris en charge par différents fournisseurs, notamment pour la série MI350 d’AMD et les GPU Blackwell de NVIDIA.
• NVFP4 : le format de NVIDIA regroupe 16 valeurs avec une échelle FP8 (E4M3) et ajoute une seconde échelle FP32 par tenseur. Les blocs plus petits et les échelles plus précises réduisent l’erreur de quantification ; NVIDIA a signalé une perte de précision de 1 % ou moins par rapport à FP8 sur les benchmarks DeepSeek-R1-0528.

L’extrait ci-dessous arrondit un tenseur comportant quelques valeurs aberrantes aux valeurs E2M1, d’abord avec une échelle pour tout le tenseur, puis une échelle par bloc de 32 valeurs et par bloc de 16 valeurs, les tailles de bloc MXFP4 et 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}")

Avec une seule échelle pour tout le tenseur, les valeurs aberrantes étirent tellement l’échelle que la plupart des valeurs ordinaires sont arrondies à zéro, ce qui donne une erreur absolue moyenne de 0.7238. Les blocs de 32 et de 16 valeurs limitent chaque valeur aberrante à un seul bloc ; les autres blocs conservent donc une échelle précise, et l’erreur tombe à 0.0901 et 0.0747.

Inférence et entraînement en FP4#

Pour l’inférence, un moteur d’inférence comme TensorRT quantifie les poids, et souvent les activations, en FP4 après l’entraînement, effectue les multiplications matricielles en FP4 et accumule les résultats avec une précision supérieure. Les configurations NVFP4 et MXFP4 de TorchAO offrent le même workflow dans PyTorch sur les GPU pris en charge. OpenAI a publié gpt-oss-120b avec des poids de son mélange d’experts post-entraînés en MXFP4, ce qui permet à ce modèle de 117 milliards de paramètres de fonctionner sur un seul GPU de 80 Go.

L’entraînement en FP4 étend l’entraînement en précision mixte jusqu’à 4 bits et est plus difficile que l’inférence, car la plage des gradients et des activations évolue tout au long de l’entraînement. Dans son étude de préentraînement NVFP4, NVIDIA a entraîné un modèle de 12 milliards de paramètres sur 10 000 milliards de jetons en NVFP4, avec une perte d’entraînement et une précision en aval comparables à une référence FP8, en combinant des transformations de Hadamard aléatoires pour répartir les valeurs aberrantes, un arrondi stochastique pour les gradients et quelques couches conservées à une précision supérieure.

Déploiement de modèles FP4#

Les cœurs tenseurs FP4 natifs nécessitent des GPU NVIDIA Blackwell ou ultérieurs, comme les B200 et GeForce RTX 50, ou des accélérateurs AMD Instinct MI350 pour MXFP4 ; les GPU Hopper comme le H100 accélèrent FP8, mais pas FP4. La matrice de compatibilité TensorRT répertorie les précisions prises en charge par chaque GPU. Il faut vérifier la précision après la conversion et avant le déploiement du modèle, car les couches sensibles ou les petits modèles peuvent se dégrader ; l’entraînement tenant compte de la quantification permet de récupérer de la précision lorsque la quantification après entraînement ne suffit pas. L’exportation TensorRT d’Ultralytics YOLO26 construit des moteurs en FP16 avec quantize=16 ou en INT8 avec quantize=8, les options de faible précision proposées pour les modèles YOLO.

FP4 et formats apparentés#

• FP8 : FP8 (E4M3 ou E5M2) possède bien plus de valeurs distinctes et une plage plus étendue. Comme l’entraînement FP8 est largement adopté pour les grands modèles, FP8 constitue la référence habituelle pour évaluer les résultats FP4.
• BFloat16 : BF16 reste le format standard pour entraîner et servir de grands modèles en pleine qualité, avec quatre fois plus de bits que FP4.
• INT4 : INT4 répartit uniformément ses 16 niveaux, tandis que FP4 concentre davantage de niveaux près de zéro, là où se trouvent la plupart des poids et activations. INT4 reste courant pour la compression des seuls poids des modèles de langage, avec des méthodes comme GPTQ et AWQ.
• Socket FP4 d’AMD : FP4 désigne également un socket de processeur portable AMD sans rapport avec ce format, utilisé par les APU mobiles de génération Carrizo comme le FX-8800P.