FLOPs (Floating-Point Operations)

FLOP signifie Floating-Point Operation (opération en virgule flottante) : une addition, soustraction, multiplication ou division sur un nombre décimal. C’est l’unité de base pour mesurer le volume de calcul en IA. On parle de FLOPs (au pluriel) pour le nombre total d’opérations nécessaires à un entraînement, et de FLOPS (avec un S majuscule, pour « per Second ») pour la puissance de calcul d’un processeur. L’entraînement de GPT-3 a nécessité environ 3,14 × 10²³ FLOPs. Un GPU NVIDIA H100 délivre environ 989 TFLOPS en FP8.

Définition: Opération mathématique sur un nombre à virgule flottante (addition, soustraction, multiplication, division)
FLOPs (pluriel): Nombre total d’opérations (mesure un budget de compute)
FLOPS (per Second): Opérations par seconde (mesure la puissance d’un processeur)
Formule clé pour l’IA: C ≈ 6 × N × D (FLOPs = 6 × paramètres × tokens d’entraînement)
Échelles courantes: GFLOPS (10⁹), TFLOPS (10¹²), PFLOPS (10¹⁵), EFLOPS (10¹⁸), ZFLOPS (10²¹)
Seuil réglementaire: 10²⁵ FLOPs (AI Act, modèles GPAI à risque systémique), 10²⁶ FLOPs (Executive Order US)

Comprendre les FLOPs en deux minutes

Imaginez que chaque calcul élémentaire que fait un GPU (multiplier deux nombres, les additionner) est un FLOP. Un LLM comme GPT-3 nécessite environ 314 000 000 000 000 000 000 000 de ces opérations pour être entraîné. C’est pour cela qu’on utilise la notation scientifique : 3,14 × 10²³ FLOPs.

Le GPU est le processeur spécialisé qui exécute ces opérations. Sa puissance se mesure en FLOPS (opérations par seconde). Un NVIDIA H100, le GPU de référence pour l’entraînement IA, peut effectuer environ 989 000 000 000 000 opérations par seconde en précision FP8. C’est 989 TFLOPS (tera-FLOPS).

La distinction entre les deux usages du terme est source de confusion fréquente. Retenez : FLOPs (pluriel) = un volume total de calcul. FLOPS (per Second) = un débit de calcul.

La formule C = 6 × N × D

C’est la formule centrale pour estimer le compute d’entraînement d’un Transformer :

C ≈ 6 × N × D

Où :

C = compute total en FLOPs
N = nombre de paramètres du modèle
D = nombre de tokens d’entraînement
6 = facteur qui reflète le coût du forward pass (~2 FLOPs/paramètre/token) + backward pass (~4 FLOPs/paramètre/token)

Exemples concrets :

Modèle	Paramètres (N)	Tokens (D)	Compute estimé (C ≈ 6ND)
GPT-3	175B	300B	~3,14 × 10²³ FLOPs
Chinchilla	70B	1,4T	~5,88 × 10²³ FLOPs
Llama 3 8B	8B	15T	~7,2 × 10²³ FLOPs
Llama 3.1 405B	405B	~15T	~3,8 × 10²⁵ FLOPs
Mistral 7B (estimation)	7B	~8T	~3,4 × 10²³ FLOPs

Un même budget compute, des modèles très différents GPT-3 et Chinchilla ont utilisé un budget compute comparable (~3-6 × 10²³ FLOPs), mais GPT-3 a alloué ce budget à 175B paramètres sur 300B tokens, tandis que Chinchilla l’a alloué à 70B paramètres sur 1,4T tokens. Le résultat : Chinchilla surpasse GPT-3 sur la quasi-totalité des benchmarks. C’est la démonstration concrète que le budget FLOPs ne fait pas tout : c’est son allocation entre N et D qui détermine la performance (voir scaling laws).

Précision numérique et FLOPS des GPU

Les GPU modernes ne font pas tous les calculs avec la même précision. Plus la précision est faible (moins de bits par nombre), plus le GPU peut faire d’opérations par seconde. C’est un compromis qualité/vitesse fondamental en IA.

Précision	Bits	Usage IA	TFLOPS H100 SXM	TFLOPS A100 SXM
FP64 (double)	64	Calcul scientifique, HPC	~67 (Tensor Core)	~19,5
FP32 (simple)	32	Entraînement classique	~495 (TF32 Tensor)	~156
FP16 / BF16	16	Entraînement et inférence standard	~989	~312
FP8	8	Entraînement accéléré (Transformer Engine H100+)	~3 958	N/A (pas de support natif)
INT8	8	Inférence quantifiée	~3 958	~624

Le H100 délivre 4× plus de TFLOPS en FP8 qu’en FP16. C’est pourquoi le Transformer Engine du H100, qui gère dynamiquement la précision entre FP8 et FP16, a été un changement de paradigme pour l’entraînement des LLM : il permet de profiter du débit FP8 sans sacrifier significativement la qualité du modèle.

Pourquoi les TFLOPS GPU ne sont qu’un indicateur partiel Les TFLOPS théoriques mesurent la puissance de calcul brute. En pratique, l’utilisation effective (Model FLOPS Utilization, MFU) est souvent de 30 à 50 % des TFLOPS théoriques. Le reste est perdu en transferts mémoire, synchronisation entre GPU, communications réseau et overhead logiciel. Un GPU H100 à 989 TFLOPS FP16 délivre typiquement 300-500 TFLOPS effectifs en entraînement réel de LLM.

FLOPs d’entraînement vs FLOPs d’inférence

L’entraînement et l’inférence consomment des FLOPs de façon très différente.

Entraînement : on parle du budget total de FLOPs nécessaire pour entraîner le modèle du début à la fin. C’est un coût fixe, payé une seule fois. La formule C = 6ND s’applique. Le facteur 6 vient du forward pass (2 FLOPs/param/token) + backward pass avec calcul des gradients (4 FLOPs/param/token).

Inférence : on parle du coût par requête. Générer un token coûte environ 1 à 2 FLOPs par paramètre actif (forward pass uniquement, pas de backward). Pour un modèle dense de 70B paramètres, chaque token généré coûte ~70-140 milliards de FLOPs. Pour un modèle MoE de 675B total / 41B actifs (Mistral Large 3), chaque token coûte ~41-82 milliards de FLOPs, soit bien moins que ne le suggère sa taille totale.

C’est cette asymétrie qui explique le « Chinchilla Trap » : un modèle compute-optimal pour l’entraînement est souvent trop gros (et donc trop cher) pour l’inférence à grande échelle.

Les échelles de FLOPs en IA

Préfixe	Valeur	Contexte IA
GFLOPS (Giga)	10⁹	Un seul forward pass d’un petit modèle
TFLOPS (Tera)	10¹²	Puissance d’un GPU (ex : H100 = 989 TFLOPS en FP16)
PFLOPS (Peta)	10¹⁵	Puissance d’un petit cluster de GPU
EFLOPS (Exa)	10¹⁸	Puissance d’un grand datacenter IA
ZFLOPS (Zetta)	10²¹	Budget d’entraînement d’un petit LLM
10²³-10²⁴	N/A	Budget d’entraînement d’un LLM standard (GPT-3, Chinchilla)
10²⁵-10²⁶	N/A	Budget d’entraînement d’un modèle frontier (Llama 3.1 405B, GPT-4)

Le paysage GPU en mars 2026

Le compute IA est dominé par les GPU NVIDIA. Voici les principales générations pertinentes pour l’entraînement et l’inférence des LLM.

GPU	Architecture	VRAM	FP16 TFLOPS	FP8 TFLOPS	Prix estimé
A100 SXM	Ampere (2020)	80 Go HBM2e	~312	N/A	~$10 000-15 000
H100 SXM	Hopper (2023)	80 Go HBM3	~989	~3 958	~$25 000-30 000
H200 SXM	Hopper+ (2024)	141 Go HBM3e	~989	~3 958	~$30 000-35 000
B200	Blackwell (2025)	192 Go HBM3e	~2 250	~9 000	~$30 000-40 000

Le B200 (Blackwell) représente environ 2,3× les TFLOPS du H100. Le prochain GPU prévu, Vera Rubin (R200), devrait offrir encore ~2,4× les performances du B200, soit environ 6× le H100. Cette progression alimente la baisse continue du coût par FLOP, qui se traduit directement en baisse du coût d’entraînement et d’inférence des modèles d’IA.

FLOPs et réglementation

Les FLOPs d’entraînement sont devenus un critère réglementaire pour identifier les modèles d’IA les plus puissants (et potentiellement les plus risqués) :

AI Act européen : les modèles d’IA à usage général (GPAI) entraînés avec plus de 10²⁵ FLOPs sont présumés présenter un « risque systémique », déclenchant des obligations renforcées (évaluations de risques, tests adversariaux, reporting d’incidents). Ce seuil correspond approximativement aux modèles frontier comme Llama 3.1 405B.

Executive Order 14110 (US) : les modèles entraînés avec plus de 10²⁶ FLOPs (ou utilisant des clusters de plus de 10²⁰ opérations au total en biologie) sont soumis à des obligations de reporting auprès du gouvernement américain.

Ces seuils, bien que discutés (les FLOPs ne capturent pas l’efficacité architecturale ni la qualité des données), constituent le premier cadre réglementaire basé sur une mesure objective du compute. La base de données Epoch AI recense les FLOPs d’entraînement de plus de 3 200 modèles et constitue la référence pour le suivi de ces métriques.

Model FLOPS Utilization (MFU) : l’efficacité réelle

La MFU mesure le pourcentage des TFLOPS théoriques du GPU effectivement utilisés pendant l’entraînement. C’est un indicateur clé de l’efficacité du code d’entraînement et de l’infrastructure.

Un entraînement avec une MFU de 50 % sur des H100 à 989 TFLOPS FP16 utilise effectivement ~495 TFLOPS par GPU. Les causes de perte incluent les transferts mémoire (le GPU attend les données), les communications entre GPU (synchronisation des gradients en entraînement distribué), l’overhead logiciel (framework, orchestration), et la recomputation des activations (technique qui économise la mémoire au prix de FLOPs supplémentaires).

Les équipes qui optimisent leur MFU (meilleures stratégies de parallélisme, FlashAttention, compilation optimisée) obtiennent des entraînements significativement plus rapides et moins coûteux pour le même budget matériel. DeepSeek, par exemple, a atteint des performances frontier avec un budget limité en partie grâce à une utilisation très efficace de son cluster GPU.

Le coût par FLOP : une chute continue

Le coût d’un FLOP est en baisse constante, porté par les améliorations matérielles (nouvelles générations de GPU), logicielles (frameworks optimisés, FlashAttention, compilation) et architecturales (MoE, attention clairsemée).

Pour donner un ordre de grandeur : en 2020, entraîner un modèle de la taille de GPT-3 sur un cluster de GPU A100 coûtait plusieurs millions de dollars. En 2025, DeepSeek V3 a atteint des performances comparables à GPT-4 pour environ 5,6 millions de dollars, grâce à une architecture MoE efficace et une utilisation optimisée de son cluster. Les prévisions pour 2026-2027 anticipent une nouvelle division par 2-3 du coût par FLOP avec la généralisation des GPU Blackwell (B200) et l’arrivée de Vera Rubin (R200).

Cette baisse a des conséquences directes sur l’accessibilité de l’IA. Les modèles qui étaient l’apanage de Google, OpenAI et Meta il y a trois ans sont désormais entraînables par des startups ou des laboratoires de recherche académique. Le concept d’« AI 2027 » estime que la production mondiale de compute IA (mesurée en équivalents H100) devrait atteindre 100 millions d’unités en 2027, contre environ 5 millions en 2024.

FLOPs et qualité : une relation complexe

Plus de FLOPs ne signifie pas automatiquement un meilleur modèle. La qualité dépend de l’allocation du compute (voir compute-optimal), de la qualité des données, de l’architecture et du post-training.

Deux exemples illustratifs :

Chinchilla vs Gopher. Budget compute similaire (~5-6 × 10²³ FLOPs). Chinchilla (70B paramètres, 1,4T tokens) surpasse Gopher (280B paramètres, 300B tokens) parce que le compute est mieux réparti entre taille et données.

DeepSeek V3 vs modèles comparables. DeepSeek a entraîné un modèle frontier avec un budget estimé 10 à 100 fois inférieur aux modèles propriétaires comparables, grâce à l’efficacité architecturale (MoE, MLA) et logicielle. Le nombre brut de FLOPs est un indicateur de l’investissement en calcul, pas directement de la qualité du résultat.

C’est pourquoi les régulateurs utilisent les FLOPs comme proxy imparfait : c’est la mesure la plus objective et standardisée disponible, même si elle ne capture pas la totalité de la « puissance » d’un modèle. Un modèle entraîné avec 10²⁴ FLOPs en 2026 est probablement meilleur qu’un modèle entraîné avec 10²⁴ FLOPs en 2022, grâce aux progrès en architecture et en données.

FLOPs en pratique : ce que vous devez savoir

Si vous ne retenez que trois choses sur les FLOPs :

Pour estimer un budget d’entraînement : C = 6 × N × D. Divisez par les TFLOPS effectifs de votre cluster pour obtenir une durée.
Pour comparer des GPU : regardez les TFLOPS dans la précision que vous utiliserez (FP16/BF16 pour l’entraînement standard, FP8 si votre framework le supporte, INT4/INT8 pour l’inférence quantifiée).
Pour anticiper la réglementation : si votre entraînement dépasse 10²⁵ FLOPs (AI Act) ou 10²⁶ FLOPs (Executive Order US), des obligations spécifiques s’appliquent.

Verdict

Les FLOPs sont la monnaie de l’IA. Ils quantifient le coût de construction d’un modèle (FLOPs d’entraînement), la puissance de l’infrastructure (FLOPS des GPU), et le coût d’exploitation (FLOPs par requête en inférence). Comprendre cette métrique est indispensable pour évaluer les modèles, dimensionner l’infrastructure, et anticiper les obligations réglementaires.

La formule C = 6ND est l’outil de base : elle vous permet d’estimer le budget compute de n’importe quel entraînement de Transformer. Combinée aux scaling laws, elle prédit la performance résultante. Et les seuils réglementaires (10²⁵ FLOPs pour l’AI Act, 10²⁶ pour l’Executive Order US) en font aussi un critère de conformité.

La bonne nouvelle : le coût par FLOP baisse continuellement. Chaque nouvelle génération de GPU (A100 → H100 → B200 → Rubin) double à triple les TFLOPS disponibles, ce qui rend les entraînements et les inférences de plus en plus accessibles. Le modèle que vous n’auriez pas pu vous permettre il y a deux ans est peut-être à votre portée aujourd’hui.

FAQ

Quelle est la différence entre FLOPs et FLOPS ?

FLOPs (au pluriel) désigne un nombre total d’opérations en virgule flottante. C’est un volume de calcul, comme dire « cet entraînement a nécessité 10²⁴ FLOPs ». FLOPS (avec un S pour « per Second ») désigne un débit de calcul, la puissance d’un processeur. Un GPU H100 délivre 989 TFLOPS en FP16, soit 989 trillions d’opérations par seconde. En écriture scientifique, FLOP/s (avec un slash) est parfois utilisé pour lever l’ambiguïté.

Comment calculer les FLOPs d’entraînement d’un LLM ?

Utilisez la formule C ≈ 6 × N × D, où N est le nombre de paramètres et D le nombre de tokens d’entraînement. Le facteur 6 vient du forward pass (2 FLOPs/param/token) plus le backward pass (4 FLOPs/param/token). Exemple : un modèle de 7B paramètres entraîné sur 8T tokens nécessite environ 6 × 7 × 10⁹ × 8 × 10¹² = 3,4 × 10²³ FLOPs. Cette formule donne une estimation de premier ordre ; le chiffre réel varie selon l’architecture et les optimisations.

Combien de TFLOPS délivre un GPU NVIDIA H100 ?

Cela dépend de la précision numérique. En FP16/BF16 : environ 989 TFLOPS. En FP8 (avec Transformer Engine) : environ 3 958 TFLOPS. En FP64 (calcul scientifique) : environ 67 TFLOPS. Les TFLOPS théoriques ne sont jamais atteints en pratique : l’utilisation effective (MFU) en entraînement de LLM est typiquement de 30 à 50 % des TFLOPS théoriques.

Pourquoi les FLOPs sont-ils utilisés comme seuil réglementaire ?

Parce que les FLOPs d’entraînement sont une mesure objective et vérifiable de la « puissance » d’un modèle. L’AI Act européen utilise un seuil de 10²⁵ FLOPs pour identifier les modèles GPAI à risque systémique. L’Executive Order américain utilise 10²⁶ FLOPs pour les obligations de reporting. Ces seuils ont des limites (ils ne capturent pas l’efficacité architecturale ni la qualité des données), mais ils constituent le meilleur proxy disponible pour une mesure standardisée du compute.

Comment convertir des FLOPs en durée d’entraînement ?

Divisez le budget FLOPs total par la puissance effective de votre cluster. Exemple : 10²⁴ FLOPs sur un cluster de 1 000 GPU H100 à 50 % de MFU (soit ~495 TFLOPS effectifs par GPU = 495 × 10¹² × 1 000 = 4,95 × 10¹⁷ FLOPS totaux). Durée = 10²⁴ / 4,95 × 10¹⁷ ≈ 2 × 10⁶ secondes ≈ 23 jours. En pratique, ajoutez 20-40 % pour les interruptions, la synchronisation et le checkpointing.