Lorsque l’on parle de puissance de calcul en informatique, la notion de flops revient sur le tapis. Il s’agit du « Floating-point operations per second » ou nombre d'opérations en virgule flottante par seconde en français. Mais attention, cette valeur n’est pas dissociable du nombre de bits associés, du niveau de « précision » et de la plage dynamique. De quoi s’agit-il ? On vous l'explique.

Rapide révision : bit, byte et octet

Avant d’attaquer les nombres à virgule flottante, commençons par un rappel important : les ordinateurs ne connaissent pas les virgules et leur langage se limite à deux « mots » : 0 et 1. On parle de bit – contraction de binary digit. On ne peut pas aller bien loin… sauf à les regrouper pour multiplier les possibilités.

C’est ainsi qu’on arrive à l’octet, très largement utilisé en informatique. Il s’agit d’un regroupement de 8 bits. Petite digression toujours utile : ne pas confondre le bit (notation b) avec le byte (notation B) qui vaut dans la grande majorité des cas 8 bits (même si ce n’est pas une obligation). Un octet (ou byte) peut donc représenter 2⁸ ou 256 valeurs différentes (on parle généralement de nombre allant de 0 à 255). En termes de bit cela donne 00000000, 00000001, 00000010, 00000011, 00000100… 11111110 et enfin 11111111.

On commence doucement avec les entiers…

Parlons des nombres entiers, ou integer en anglais, souvent abrégé INT en langage informatique. Il faut définir certaines limites, ne serait-ce que pour des questions d’allocation de mémoire. C’est là qu’entrent en jeu les types INT8, INT16, INT32 ou encore INT64.

Le nombre correspond à la quantité de bits disponible. INT8 est ainsi un entier sur 8 bits. Les 256 possibilités sont réparties de - 128 à 127 (on n’oublie pas de compter le 0 pour arriver au total de 256). En INT16, on va de - 32 768 à 32 767.

De manière générale, la plage pour un entier sur n bits se trouve via la formule suivante : de - 2^(n-1) à+ 2^(n-1)- 1. Pour simplifier, on place la moitié des chiffres dans les négatifs et l’autre moitié dans les positifs (en comptabilisant le 0 avec les positifs).

Une particularité intéressante de ce classement est d’avoir tous les positifs avec un 0 comme premier bit, tandis que les négatifs commencent tous par un 1 ; c’est bien pratique pour réaliser des opérations par la suite.

Pour résumer, voici une liste d'entiers sur 4 bits avec 2⁴ ou 16 possibilités : 

1. 0000 = 0
2. 0001 = 1
3. 0010 = 2
4. 0011 = 3
5. 0100 = 4
6. 0101 = 5
7. 0110 = 6
8. 0111 = 7
9. 1000 =- 8
10. 1001 =- 7
11. 1010 =- 6
12. 1011 =- 5
13. 1100 =- 4
14. 1101 =- 3
15. 1110 =- 2
16. 1111 =- 1

…qui peuvent ne pas être signés (et donc uniquement positifs)

Il existe aussi les entiers non signés (ou uINT). Dans ce cas, on supprime les nombres négatifs de la liste et on double les possibilités sur les positifs. Une variable uINT8 peut ainsi osciller entre 0 et 255 (là encore, on n’oublie pas de compter le 0 pour un total de 256). Le choix du type de variable dépend ainsi des besoins. 

D’autres noms sont également utilisés. Microsoft indique par exemple qu’en C# les entiers sur 8 bits sont des sbyte, ceux sur 16 bits des short, sur 32 bits des int et sur 64 bits des long. On a aussi les versions non signées (uINT) avec respectivement byte, ushort, uint et ulong. 

La virgule flottante à la rescousse pour les décimaux

On ne peut cependant pas toujours se contenter des nombres entiers, loin de là. Comment faire pour les nombres décimaux ? Dans cet article, on se restreindra volontairement aux décimaux au sens mathématique du terme, c’est-à-dire avec un nombre fini de chiffres après la virgule, en laissant de côté les autres réels.

En informatique, on parle de nombre avec une virgule flottante ou floating point… ce qui nous donne les fameux « FP » évoqués en titre. Pour résumer, l’écriture des décimaux n’est pas sans rappeler la notation scientifique que l’on voit au collège.

Un rappel (désolé si cela ravive de mauvais souvenirs à certains…) de Wikipédia : « La notation scientifique est une façon de représenter les nombres décimaux. Elle consiste à exprimer le nombre sous la forme ± a x 10^n, où ± est appelé signe, a est un nombre décimal de l'intervalle [1 ; 10[ appelé mantisse (ou significande) et n est un entier relatif appelé exposant ». Bref, un nombre à virgule compris entre 1 et 10, avec des puissances de 10. Par exemple, 127,5 devient 1,275 x 10^2, 0,01275 devient 1,275 x 10⁻². Même mantisse, mais exposant différent.

En informatique, c'est… pas pareil, mais l’idée reste la même. On utilise la virgule flottante, toujours désignée par trois éléments : un signe, une mantisse et un exposant. Seule différence avec l’écriture scientifique : la mantisse est une suite de chiffres et l’exposant permet de replacer la virgule. 125,3 devient 1 253 x10^- 1 en virgule flottante, contre 1,253 x10^2 en notation scientifique.

Premier point important : on ne peut pas transformer de cette manière un nombre avec des chiffres infinis après la virgule. C’est d’ailleurs pour cela que nous nous sommes limités aux décimaux, sans prendre l’ensemble des réels pour nous simplifier un peu le programme.

Maintenant que l’on sait ce que signifie FP, que veulent dire les chiffres venant juste après ? Simplement la longueur en bits sur laquelle le nombre sera écrit : 16, 32 ou 64 par exemple. Le premier des xx bits sera dédié au signe : 0 pour les positifs, 1 pour les négatifs (même chose que pour les entiers).

La norme IEEE 754 pose les bases

Les choses se corsent un peu ensuite, mais tout est bien encadré par la norme IEEE 754. La première version date de 1985, sous l’impulsion de William Kahan, puis elle a été révisée en 2008 et 2019, rappelle Paul Zimmermann d’Inria.

Voici le résumé de Wikipedia : « La norme définit les formats de représentation des nombres à virgule flottante (signe, mantisse, exposant, nombres dénormalisés) et valeurs spéciales (infinis et NaN), en même temps qu’un ensemble d’opérations sur les nombres flottants. Il décrit aussi cinq modes d'arrondi et cinq exceptions (comprenant les conditions dans lesquelles une exception se produit, et ce qui se passe dans ce cas) ». Ne paniquez pas, on vous explique.

Commençons par donner quelques définitions :

• Demi précision (FP16) : virgule flottante sur 16 bits avec 1 bit de signe, 5 bits d'exposant et 10 bits de mantisse.
• Simple précision (FP32) : virgule flottante sur 32 bits, avec 1 bit de signe, 8 bits d'exposant et 23 bits de mantisse.
• Double précision (FP64) : virgule flottante sur 64 bits, avec 1 bit de signe, 11 bits d'exposant et 52 bits de mantisse.

Préparez l’aspirine : mantisse, exposant et (dé)normalisé en FP32

Attardons-nous quelques instants sur le FP32 pour comprendre le schéma de fonctionnement. Dans ce cas, l’exposant est sur 8 bits, soit 256 possibilités. Dans la pratique, l’exposant est « biaisé », c’est-à-dire décalé de - 127 ; il peut donc prendre des valeurs entre - 127 à+ 128.- 127 est ainsi codé comme 0 dans l’exposant (00000000), tandis que 128 est codé 255 (11111111). Simple ? Pas si vite…

Il existe des exceptions :- 127 (et donc un exposant 00000000 en binaire) est réservé pour le « 0 » (32 zéro à la suite) et les nombres « dénormalisés » (subnormal en anglais). L’IEEE 754 est ainsi construit : lorsque l’exposant est à- 127 les règles de calculs sont un peu différentes (nous le verrons avec la mantisse). Pour le reste, pas de piège ; lorsque l’exposant vaut autre chose que - 127 on parle de nombres « normalisés ». Enfin, 128 (11111111) est aussi réservé, mais pour l’infini et les « NaN » (Not a Number).

Pour la mantisse, on réalise des divisions de puissance de deux successives. Raccourcissons un peu les choses en prenant comme exemple une mantisse de 4 bits seulement. Si elle est à 1111 on aurait le résultat suivant : 1/2¹+ 1/2²+ 1/2³+ 1/2⁴ (soit 0,9375). Avec 1001 comme matisse on aurait alors 1/2¹+ 0/2²+ 0/2³+ 1/2⁴ (0,5625). Vous voyez le principe ? Cette technique permet de rapidement descendre dans les petits nombres.

Ne pensez pas en avoir terminé, on en rajoute une couche : si le nombre est normalisé, on ajoute 1 à la mantisse, sinon on ne touche pas la mantisse (lorsque l’exposant vaut 00000000).

Une mantisse à 100…0 (sur 23 bits) vaut donc 0,5 : 1/2 + 0/2²+ 0/2⁴…+ 0/2²³. On en déduit facilement que la plus petite valeur de la mantisse est atteinte avec 000…001, soit 0/2 + 0/2²+…+ 0/2²²+ 1/2²³ ou encore 0,00000011920928955078125. On a notre nombre à virgule flottante ? Pas encore, il faut encore multiplier le résultat par 2^(exposant).

À gauche le principe de fonctionnement du FP32 simple précision, à droite le FP64 double précision

Deux exemples. Avec un nombre normalisé pour commencer : 0 00000010 00000000000000000000001. L’exposant  (00000010) vaut 2, que l’on rapporte à- 125 (via le biais, puisqu’il faut enlever 127 pour rappel). La mantisse est égale à 1 + 1/2²³ (on ajoute 1 car le nombre est normalisé). On obtient 2⁻¹²⁵ x (1 + 1/2²³). On vous épargne les calculs : 2,3509889819e-38 si on s’arrête à 10 chiffres après la virgule.

Avec un nombre dénormalisé maintenant : 0 00000000 00000000000000000000001. L’exposant vaut 0 et la mantisse reste la même (on n’ajoute pas 1). L’exposant des nombres dénormalisés est de - 126 (et pas - 127), il vaut donc 1/2¹²⁶ x 1/2²³, soit 1/2¹⁴⁹ ou encore 1,40129846432e-45.

Un « convertisseur » de nombre décimal en FP32 (simple précision) est disponible par ici. Il permet d’afficher l’erreur due à la conversion, le résultat en binaire, la partie mantisse et exposant, s’il s’agit ou non d’un nombre normalisé, etc. Vous pouvez entrer les 32 bits à la main ou un nombre décimal, il marche dans les deux sens.

Le plus petit nombre (supérieur à 0) en FP32, il s’agit fort logiquement de 0000…001.

On ne peut pas représenter tous les décimaux, il y a des approximations

Ce nombre est le plus petit positif (strictement supérieur à 0 évidemment) que l’on peut représenter en simple précision. Le suivant vaut 2,80259692865e-45, l’écart est donc de 1,4e-45 environ. Vous l’aurez compris, on ne peut pas représenter tous les nombres décimaux en virgule flottante.

Un exemple flagrant : 0,1 ne peut pas être écrit en simple précision. La valeur la plus proche est 0,100000001490116119384765625. Les approximations peuvent donner lieu à des situations cocasses si les systèmes ne disposent pas de systèmes de correction. Essayez par exemple de calculer 0,1 + 0,2 dans la console JavaScript de votre navigateur (F12), le résultat n’est pas 0,3 ! Pour contourner le problème, on utilise un moteur de calcul exact, comme nous l’avions expliqué dans le test de la calculatrice Numworks.

• Numworks : on a testé la « calculatrice réinventée », tient-elle ses promesses ?

Microsoft explique qu’en simple précision (float ou FP32), les nombres possibles vont d’environ ±1.5 x 10⁻⁴⁵ à ±3.4 x 10³⁸ avec une précision de 6 à 9 chiffres, tandis que la plage varie entre ±5.0 × 10⁻³²⁴ et ±1.7 × 10³⁰⁸ en double précision (double ou FP64), avec en plus une précision améliorée entre 15 et 17 chiffres.

On peut facilement calculer la plage dynamique de la demi précision (FP16) qui varie entre 0,000000059604645 (±5,96 x 10⁻⁸) et 65 504 « seulement ». La précision tombe à 4 ou 5 chiffres au mieux.

Bien sûr, les opérations sont bien plus longues et complexes en double qu’en simple précision, tout en occupant deux fois plus de place. Ceci explique les grosses différences de performances annoncées dans les supercalculateurs et autres GPU.

0,1 ne peut être écrit en FP32, il faut passer par une approximation qui s’en approche à environ 1,5 x 10⁻⁹.

TF32, bfloat16, fp24 : des déclinaisons de 16 à 24 bits

On retrouve aussi les minifloats sur 8 bits (ou FP8) et des TF32 (Tensor Float) chez NVIDIA. Voici un comparatif des exposants et mantisse, sur lequel on ajoute une version modifiée des nombres à virgule flottante sur 16 bits, les bfloat16 :

• Demi précision (16 bits, FP16) : 1 bit de signe, 5 bits d'exposant et 10 bits de mantisse.
• Simple précision (32 bits, FP32) : 1 bit de signe, 8 bits d'exposant et 23 bits de mantisse.
• bfloat (16 bits) : 1 bit de signe, 8 bits d'exposant et 7 bits de mantisse.
• TF32 (19 bits) : 1 bit de signe, 8 bits d'exposant et 10 bits de mantisse.
• fp24 (24 bits) : 1 bit de signe, 8 bits d'exposant et 15 bits de mantisse.

Les nombres TF32 reprennent la même taille d’exposant que les FP32 (simple précision), mais avec une mantisse identique à celle des FP16. Un TF32 est sur 19 bits, ce qui le place entre les nombres à simple et double précision.

Selon NVIDIA, « il a été démontré que [les TF32] ont une marge plus que suffisante pour les exigences de précision des charges de travail d'IA. Et TF32 adopte le même exposant sur 8 bits que FP32 afin qu'il puisse prendre en charge la même plage numérique ». Un nombre TF32 peut varier sur une plage aussi grande que FP32, mais avec une précision équivalente à FP16, c’est-à-dire de l’ordre de quatre chiffres.

De leur côté, les bfloat16 (brain floating point) ont aussi un exposant sur 8 bits (et donc une plage dynamique équivalente aux FP32 et TF32), mais avec une mantisse de 7 bits seulement. Les bfloat16 ont encore moins de précision que les TF32 (et par conséquent que les FP32). Selon Google, « bfloat16 est un format personnalisé à virgule flottante 16 bits pour le machine learning ».

AMD a lancé de son côté le fp24, sur 24 bits comme son nom le laisse penser. Il s’agit d’une autre déclinaison avec la même plage dynamique que les FP32, mais une partie mantisse sur 15 bits. La précision se situe au-dessus des TF32, mais en dessous des FP32.

Il existe bien d’autres manières de coder des nombres en virgule flottante, mais le principe de base reste le même. On peut par exemple citer la double précision étendue, souvent avec 80 bits : 1 pour le signe, 15 pour l’exposant et 64 pour la mantisse. On change de registre avec une plage dynamique allant de  3,65 × 10⁻⁴⁹⁵¹ à 1,18 × 10⁴⁹³² et une précision de 18 à 19 chiffres.

Vous avez besoin d’une plus grande précision ? Voici quadruple et octuple

Et si vous avez besoin d’aller encore plus loin, la quadruple précision sur 128 bits (binary128) vous tend les bras. On reste sur un exposant à 15 bits, mais la mantisse explose pour atteindre 112 bits (le dernier bit est toujours pour le signe). La précision monte jusqu’à 33 à 36 chiffres.

La norme IEEE 754 parle aussi d’un binary256 qui, vous l’aurez compris est sur 256 bits. Avec l’octuple précision, l’exposant pousse jusqu’à 19 bits, la mantisse à pas moins de 236 bits, pour une précision à 71 chiffres. « Ce format est rarement (voire jamais) utilisé et très peu d’environnements le supportent », précise Wikipédia.

L’Institute of Electrical and Electronics Engineers prépare déjà la suite de la norme 754, dont la révision devrait avoir lieu aux alentours de 2029.