FP8

FP8 est un format de nombres à virgule flottante sur 8 bits qui permet d’entraîner et d’exécuter des réseaux neuronaux avec deux fois moins de mémoire et de transferts de données que les formats sur 16 bits. Comme tout type à virgule flottante, chaque valeur comporte un bit de signe, des bits d’exposant qui déterminent sa plage et des bits de mantisse qui déterminent sa précision ; avec seulement huit bits au total, il implique toutefois d’importants compromis sur les deux plans. Des ingénieurs de NVIDIA, Arm et Intel ont défini les deux variantes standard, E4M3 et E5M2, dans l’article de septembre 2022 Formats FP8 pour l’apprentissage profond, et ont validé l’entraînement de modèles de langage pouvant compter jusqu’à 175 milliards de paramètres avec ces formats. Sur les GPU dotés de Tensor Cores FP8, comme le Hopper H100 de NVIDIA lancé en 2022, les multiplications matricielles FP8 atteignent deux fois le débit du FP16 ou du BF16.

E4M3 et E5M2#

Les deux variantes répartissent différemment les sept bits autres que celui du signe :

• E4M3 : quatre bits d’exposant et trois bits de mantisse. Il renonce aux infinis et ne conserve qu’un seul motif NaN pour atteindre une valeur maximale de 448 ; il convient aux poids et aux activations de la passe avant.
• E5M2 : cinq bits d’exposant et deux bits de mantisse, conformément aux conventions IEEE 754 pour les valeurs spéciales. Il atteint 57 344 avec des incréments plus grossiers et convient aux gradients, dont les amplitudes couvrent une plage plus large.

Les deux formats ramènent à zéro les petites valeurs et tronquent les grandes ; les tenseurs FP8 sont donc généralement associés à un facteur d’échelle qui ramène leurs valeurs dans la plage représentable. La conversion de valeurs de l’ordre des gradients, avec et sans facteur d’échelle, illustre pourquoi :

import torch

torch.manual_seed(0)
grads = torch.randn(10_000) * 1e-4  # gradient-sized values, far below 1
e4m3, e5m2 = torch.float8_e4m3fn, torch.float8_e5m2
print(f"E4M3 max {torch.finfo(e4m3).max:g}, E5M2 max {torch.finfo(e5m2).max:g}")

# Per-tensor scaling maps the largest magnitude onto the E4M3 maximum before casting
scale = torch.finfo(e4m3).max / grads.abs().max()
results = {
    "E4M3 direct": grads.to(e4m3).float(),
    "E5M2 direct": grads.to(e5m2).float(),
    "E4M3 scaled": (grads * scale).to(e4m3).float() / scale,
}

for name, restored in results.items():
    zeros = (restored == 0).float().mean()
    error = ((restored - grads).abs() / grads.abs()).median()
    print(f"{name}: {zeros:.0%} rounded to zero, median relative error {error:.1%}")

Une conversion directe en E4M3 arrondit 100% des valeurs à zéro ; la plage plus étendue d’E5M2 en conserve la plupart, avec une erreur relative médiane de 6.4% et 7% de valeurs perdues, tandis qu’une mise à l’échelle préalable permet à E4M3 de conserver toutes les valeurs avec une erreur médiane de 2.2%. PyTorch fournit également float8_e4m3fnuz et float8_e5m2fnuz, les variantes utilisées par les accélérateurs MI300 d’AMD, qui suppriment le zéro négatif et décalent le biais de l’exposant, ce qui plafonne E4M3 à 240. Un modèle FP8 n’est donc pas automatiquement portable entre les fournisseurs.

Stratégies de mise à l’échelle#

Un facteur d’échelle unique pour tout un tenseur ne fonctionne pas lorsque quelques valeurs aberrantes déterminent le maximum et rapprochent toutes les autres valeurs de zéro, ce qui est fréquent dans les activations de transformer. Les méthodes de mise à l’échelle diffèrent selon leur granularité :

• Mise à l’échelle différée par tenseur : Transformer Engine de NVIDIA détermine l’échelle de chaque tenseur à partir des valeurs maximales observées lors des étapes d’entraînement récentes, sans nécessiter de passe supplémentaire sur les données.
• Mise à l’échelle par blocs : DeepSeek-V3 a mis à l’échelle les activations par tuiles de 1 × 128 valeurs et les poids par blocs de 128 × 128 ; son équipe a rapporté la première validation de l’entraînement FP8 sur un modèle de taille extrême, comptant 671 milliards de paramètres.
• MXFP8 : le format de mise à l’échelle microscopique de l’Open Compute Project partage une échelle en puissance de deux entre chaque groupe de 32 valeurs, et les GPU Blackwell de NVIDIA le prennent en charge matériellement.

Les multiplications matricielles accumulent leurs résultats avec une précision supérieure, et les couches sensibles ou peu coûteuses, telles que la normalisation, le softmax et les poids maîtres de l’optimiseur, restent en BF16 ou en FP32. FP8 n’est donc qu’un élément d’une méthode de calcul à précision mixte.

FP8 pour l’entraînement et l’inférence#

Pour l’entraînement, Transformer Engine de NVIDIA et TorchAO remplacent les couches linéaires par des versions FP8 tout en conservant les poids maîtres avec une précision supérieure. Pour l’inférence, les moteurs de service stockent les poids du modèle et le cache KV des grands modèles de langage en FP8, ce qui divise par deux leur mémoire par rapport aux formats sur 16 bits et permet de traiter davantage de requêtes simultanées. TensorRT crée également des moteurs FP8 pour les GPU dotés de Tensor Cores FP8. Ce format ne présente d’intérêt que si le matériel le prend en charge : l’A100 de NVIDIA exécute le FP16, le BF16 et l’INT8 sur ses Tensor Cores, mais ne dispose d’aucune unité FP8, contrairement aux GPU Ada Lovelace, Hopper et Blackwell ainsi qu’à la gamme MI300 d’AMD.

FP8 se situe entre les formats voisins :

• FP16 ou précision demi-mot : deux fois plus de bits, avec 10 bits de mantisse et une plage suffisante pour la plupart des inférences sans échelle par tenseur.
• FP4 : encore deux fois moins de bits, avec une mise à l’échelle fine par blocs pour préserver la précision.
• INT8 : l’autre format sur 8 bits, avec 256 niveaux uniformément espacés plutôt que l’espacement exponentiel du FP8 ; il nécessite donc des échelles calibrées, mais fonctionne sur beaucoup plus de matériel, notamment la plupart des CPU et des NPU.

Ultralytics YOLO26 adopte la voie INT8 pour l’inférence sur 8 bits : l’export avec quantize=8 en mode export vers des formats tels que TensorRT et OpenVINO lance une quantification du modèle post-entraînement qui calibre les échelles à partir d’images du jeu de données data, tandis qu’un modèle affiné avec quantize=8 par apprentissage tenant compte de la quantification s’exporte vers TensorRT avec les plages qu’il a apprises, sans nécessiter de calibration.