L’entraînement et le raisonnement des grands modèles impliquent souvent le concept de précision, et il existe de nombreux types, qui sont également divisés en différents formats au même niveau de précision. De plus, il existe aussi les concepts de multi-précision et de précision mixte dans des scénarios d’utilisation pratique.
Précision courante
Précision en virgule flottante : double précision (FP64), simple précision (FP32, TF32), demi-précision (FP16, BF16), précision 8 bits (FP8), précision 4 bits (FP4, NF4)
Précision de la quantification : INT8, INT4 (également INT3/INT5/INT6)
Un nombre en virgule flottante se compose de trois parties : les bits de signe, exponentiel et de mante. Plus le bit exponentiel est grand, plus la plage de nombres pouvant être représentée est grande. Plus le chiffre mantissa est grand, plus la précision du nombre est élevée.
Le tableau résume cela ainsi
| format | Bit de symbole | Bit exponentiel | Décimale | Total des chiffres | | FP64 | 1 | 11 | 52 | 64 | | FP32 | 1 | 8 | 23 | 32 | | TF32 | 1 | 8 | 10 | 19 | | BF16 | 1 | 8 | 7 | 16 | | FP16 | 1 | 5 | 10 | 16 | | FP8 E4M3 | 1 | 4 | 3 | 8 | | FP8 E5M2 | 1 | 5 | 2 | 8 | | FP4 | 1 | 2 | 1 | 4 |
FP32 : nombre en virgule flottante 32 bits, 4 octets par donnée
TF32 : nombre en virgule flottante de 19 bits, chaque donnée fait 2 octets
FP16 : nombre en virgule flottante 16 bits, 2 octets par donnée
BF16 : nombre en virgule flottante de 16 bits, chaque donnée fait 2 octets
Int8 : entier 8 bits, chaque donnée représente 1 octet
Int4 : entiers 4 bits, chaque donnée fait 0,5 octet
Pourquoi tant de précision
À cause du coût et de la précision. Nous savons tous qu’une grande précision est certainement plus précise, mais cela entraînera aussi des coûts de calcul et de stockage plus élevés. Une précision plus faible réduit la précision des calculs mais peut améliorer l’efficacité et la performance de calcul. Ainsi, une variété de précisions différentes vous permet de choisir celle la plus adaptée à différentes situations.
La double précision est plus précise que l’expression à simple précision, mais elle prend deux fois plus de stockage et plus de temps de calcul.
Pourquoi les grands modèles doivent-ils être quantifiés ?
1. Réduire la consommation de mémoire
Les grands modèles utilisent généralement des nombres en virgule flottante de 32 bits (FP32) ou des nombres de virgule flottante de 16 bits (FP16) pour représenter les poids et les valeurs d’activation. En quantifiant, ces valeurs de haute précision peuvent être converties en représentations de moindre précision (par exemple, des entiers 8 bits, INT8), réduisant significativement l’espace de stockage du modèle. Cela est important pour le déploiement sur des appareils à ressources limitées tels que les appareils mobiles, les systèmes embarqués, etc.
2. Accélérer la vitesse de raisonnement
Les modèles quantifiés peuvent fonctionner plus efficacement sur le matériel. De nombreux matériels modernes (tels que les GPU, TPU, NPU, etc.) disposent d’un support spécialisé d’optimisation pour le calcul de basse précision, permettant des opérations de quantification plus rapides. De plus, les calculs à faible précision impliquent souvent moins d’opérations sur les bits, réduisant la complexité de calcul et accélérant ainsi l’inférence.
3. Réduire la consommation d’énergie
Le modèle quantifié réduit non seulement le besoin de ressources informatiques, mais réduit aussi la consommation d’énergie. Cela est particulièrement important pour les appareils à batterie tels que les smartphones, les appareils IoT, etc., où une faible consommation d’énergie signifie une autonomie plus longue.
4. Facilité de déploiement des dispositifs en périphérie
De nombreux grands modèles ont été initialement entraînés et déployés dans le cloud, mais avec le développement de l’informatique en périphérie, de plus en plus de scénarios applicatifs exigent que les modèles soient déployés sur des dispositifs en périphérie. Avec une puissance de calcul et des ressources de stockage limitées sur les dispositifs en périphérie, la quantification peut aider ces modèles à fonctionner plus efficacement sur les dispositifs en périphérie.
5. Réduction des besoins en bande passante
Dans le processus d’inférence distribuée ou de mises à jour de modèles, la quantification peut réduire la bande passante nécessaire au transfert de modèle. Cela est utile pour les environnements à bande passante réseau limitée, comme les appareils IoT situés dans des zones éloignées.
6. Maintenir la performance du modèle
Bien que la quantification introduise une certaine perte de précision, la performance initiale du modèle peut être largement préservée grâce à des méthodes de quantification appropriées (telles que la quantification en précision mixte, la quantification post-entraînement, l’entraînement à la perception quantitative, etc.). Ainsi, dans des applications pratiques, la quantification peut trouver un bon équilibre entre performance et efficacité.
Référence mémoire
| type | Chaque milliard de paramètres doit occuper la mémoire | | float32 | 4G | | FP16/BF16 | 2G | | int8 | 1G | | int4 | 0,5G |
FP64 (Double Précision)
La virgule flottante 64 bits, typiquement un format binaire à double précision défini par l’IEEE 754, possède :
Symbole à 1 chiffre
Index à 11 chiffres
52 décimales
Portée : ~2,23e-308... ~1,80e308 avec une précision décimale complète 15-17.
Usage:
Ce format est utilisé pour des calculs scientifiques nécessitant une grande précision.
Il n’est généralement pas utilisé pour les calculs d’apprentissage profond.
Support logiciel :
Représente le double type sur la plupart des systèmes C/C++.
Pris en charge par TensorFlow (par exemple tf.float64) / PyTorch (par exemple torch.float64 ou torch.double).
Support matériel :
Généralement pris en charge dans les processeurs x86.
La plupart des GPU, en particulier les GPU de jeu, y compris la série RTX, sont très limités en performances FP64 (généralement 1/32 des FP32 au lieu de 1/2).
Les GPU récents sans restriction supportés par FP64 incluent GP100/100/102/104 dans les Tesla P40/P4 et Quadro GP100, le GV100 dans les Tesla V100/Quadro GV100/Titan V, et le GA100 récemment annoncé en A100 (fait intéressant, la nouvelle architecture Ampere a une troisième génération) comparé aux Tensor Cores compatibles FP64 Le nouveau traitement FP64 conforme à l’IEEE est désormais inclus, offrant 2,5 fois plus de performances FP64 que V100.
FP32 (Pleine précision)
Ce format a longtemps été un cheval de bataille pour l’apprentissage profond. Un autre format IEEE 754, le virgule flottante à simple précision, possède :
Symbole à 1 chiffre
Index à 8 chiffres
23 décimales
Idéalement, l’entraînement et l’inférence devraient être effectués en FP32, mais FP32 est deux fois plus lent que FP16/BF16, donc des méthodes de précision mixte sont souvent utilisées en pratique, où les poids FP32 servent de « poids maître » exact, les poids FP16/BF16 sont utilisés pour les calculs de propagation avant et arrière afin d’améliorer la vitesse d’entraînement, et enfin les poids souverains FP32 sont mis à jour avec les gradients FP16/BF16 lors de la phase de mise à jour du gradient.
Pendant l’entraînement, le poids souverain est toujours FP32. En pratique, les poids demi-précis offrent souvent une précision similaire à FP32 lors de l’inférence – car les poids exacts FP32 ne sont nécessaires que lorsque le gradient du modèle est mis à jour. Cela signifie que nous pouvons utiliser des poids de demi-précision lors de l’inférence, ce qui permet d’obtenir le même résultat avec seulement la moitié de la mémoire GPU.
Portée : ~1,18e-38... ~3,40e38 avec une précision de 6 à 9 décimales significatives.
Usage:
Le type standard de calcul sur réseau de neurones depuis longtemps. Les poids, activations et autres valeurs dans les réseaux de neurones sont depuis longtemps passées par défaut à FP32.
Pour de nombreux calculs scientifiques, en particulier itératifs, la précision n’est pas suffisante, ce qui entraîne une accumulation d’erreurs.
Support logiciel :
Représente le type de flotteur sur la plupart des systèmes C/C++.
Pris en charge par TensorFlow (par exemple tf.float32) / PyTorch (par exemple torch.float32 ou torch.float).
Support matériel :
Généralement pris en charge dans les processeurs x86.
Généralement pris en charge par la carte graphique NVIDIA/AMD.
FP16 (Demi-précision)
De même, le format standard IEEE 754, le format à virgule flottante à demi-précision, propose :
Symbole à 1 chiffre
Index à 5 chiffres
10 décimales
Le chiffre FP16 a une plage numérique beaucoup plus basse que FP32. Par conséquent, FP16 est exposé au risque de débordement (lorsqu’il est utilisé pour représenter de très grands nombres) et de débordement (lorsqu’il est utilisé pour représenter de très petits nombres). Par exemple, quand vous faites 10k * 10k, le résultat final devrait être 100M, ce que FP16 ne peut pas représenter car le nombre maximum que FP16 peut représenter est 64k. Ainsi, on se retrouve avec NaN (Not a Number) dans les calculs de réseaux neuronaux, car les calculs sont effectués en ordre stratifié et batch, donc une fois que NaN apparaît, tous les calculs précédents sont détruits. En général, cela peut être atténué par l’échelle des pertes, mais cette approche ne fonctionne pas toujours.
Portée : ~5,96e−8 (6,10e−5) ... 65504, avec une précision de 4 chiffres décimaux significatifs.
Usage:
L’apprentissage profond a tendance à utiliser FP16 plutôt que FP32, car les calculs de plus faible précision ne semblent pas avoir d’importance pour les réseaux de neurones. La précision supplémentaire ne sert à rien, et en même temps c’est plus lent, nécessitant plus de mémoire et ralentissant la communication.
Peut être utilisé pour l’entraînement, généralement en utilisant un entraînement de précision mixte (TensorFlow/PyTorch).
Peut être utilisé pour la quantification post-entraînement afin d’accélérer l’inférence (TensorFlow Lite). D’autres formats utilisés pour la quantification post-entraînement incluent les entiers INT8 (entiers 8 bits), INT4 (4 bits), et même INT1 (valeurs binaires).
Support logiciel :
Je ne suis pas encore dans la norme C/C++ (mais il existe une proposition de flottement court). Certains systèmes C/C++ prennent en charge __fp16 types. Sinon, il peut être utilisé avec des bibliothèques spéciales.
Pris en charge par TensorFlow (par exemple tf.float16) / PyTorch (par exemple torch.float16 ou torch.half).
Support matériel :
Les processeurs x86 ne sont pas pris en charge (en tant que type unique).
Le support des anciens GPU gaming est faible (performance 32/1 pour FP64, voir le post sur les GPU pour plus de détails). Il est actuellement bien pris en charge sur les GPU modernes, comme la série NVIDIA RTX.
BFLOAT16 (Demi-précision)
Un autre format 16 bits initialement développé par Google s’appelle « Brain Floating Point Format », ou « bfloat16 » en abrégé. Le nom vient de Google Brain.
L’IEEE FP16 original a été conçu sans applications d’apprentissage profond en tête, et sa plage dynamique était trop étroite. BFLOAT16 résout ce problème en offrant la même plage dynamique que le FP32.
Par conséquent, BFLOAT16 a :
Symbole à 1 chiffre
Index à 8 chiffres
7 décimales
Le format bfloat16 est tronqué en IEEE 754 FP32, permettant une conversion rapide vers et depuis IEEE 754 FP32. Lors de la conversion au format bfloat16, les bits exponentiels sont préservés, tandis que les champs de mantissa peuvent être réduits par troncature.
Portée : ~1,18e-38... ~3,40e38 avec 3 décimales significatives.
Usage:
Maintenant, il semble remplacer FP16. Contrairement à FP16, qui nécessite souvent un traitement spécial via des techniques telles que le loss scaling, BF16 est presque un remplacement direct de FP32 lors de l’entraînement et de l’exécution de réseaux de neurones profonds.
Support logiciel :
Pas dans la norme C/C++. Peut être utilisé avec des bibliothèques spéciales.
Pris en charge par TensorFlow (par exemple tf.bfloat16) / PyTorch (par exemple torch.bfloat16).
TF32
TensorFloat-32 ou TF32 est le nouveau mode mathématique des GPU NVIDIA A100.
En utilisant les mêmes mantes 10 bits que les calculs de demi-précision (FP16), le TF32 s’avère avoir suffisamment de marge de manœuvre pour répondre aux exigences de précision des charges de travail d’IA. Et TF32 utilise le même indice 8 bits que FP32, ce qui lui permet de supporter la même plage numérique.
Techniquement, c’est un format 19 bits. Considérez-le comme un BFLOAT16 de précision prolongé, comme « BFLOAT19 » ou une précision diminuée comme FP32.
Ainsi, TF32 propose :
Symbole à 1 chiffre
Index à 8 chiffres
10 décimales
L’avantage de TF32 est qu’il a le même format que FP32. Lors du calcul du produit scalaire avec TF32, la mantisse de l’opérande d’entrée est arrondie de 23 à 10 bits. Les opérandes d’arrondi sont multipliés exactement et cumulés en FP32 normal.
Le noyau tensoriel TF32 fonctionne sur des entrées FP32 et génère des résultats en FP32 sans modification de code. Les opérations non-matricielles continuent d’utiliser FP32. Cela permet d’accélérer facilement les données d’entrée/sortie FP32 dans les cadres d’apprentissage profond et le HPC.
Portée : ~1,18e-38... ~3,40e38 avec une précision de 4 décimales significatives.
Usage:
L’un des grands avantages de TF32 est qu’il ne nécessite qu’un support du compilateur au niveau le plus profond, c’est-à-dire à l’intérieur du compilateur CUDA. Le reste du code voit simplement FP32 avec moins de précision, mais la même plage dynamique. Utiliser TF32 sert principalement à appeler la bibliothèque pour montrer si elle fonctionne correctement. La présence du TF32 permet des plug-ins rapides, tirant parti de la vitesse des cœurs tensoriels sans trop de travail.
Des formats comme FP16 et BFLOAT16 nécessitent plus d’ajustements car ils impliquent des configurations de bits différentes. Mais utiliser ces formats réduit la bande passante mémoire, permettant une exécution plus rapide.
Pour comparaison, la performance maximale de l’A100 est la suivante :
FP32 sans cœurs tensoriels : 19,5 TFLOPS
Cylindres tensoriels TF32 : 156 TFLOPS (donc utiliser TF32 au lieu de FP32 facilite l’augmentation de la vitesse).
Conducteurs tensoriels FP16/BF16 : 312 TFLOPS (par conséquent, un passage raisonnable à FP16/BF16 peut apporter plus de gains de vitesse, mais à un coût plus élevé).
Support logiciel :
Pas dans la norme C/C++.
CUDA 11 soutenu.
Support matériel :
GPU : NVIDIA A100 est le premier modèle pris en charge
FP8
Introduit par le GPU H100, il permet une multiplication et une convolution matricielles plus importantes, mais avec une précision moindre.
Les types de données FP100 pris en charge par H8 sont en réalité deux types de données différents pouvant être utilisés pour différentes parties de l’entraînement des réseaux de neurones :
E4M3 - se compose de 1 bit symbolique, 4 bits exponentiels et 3 décimales. Il peut stocker jusqu’à +/-448 et nan.
E5M2 - se compose d’un bit de signe, de 5 bits exponentiels et de 2 décimales. Il peut stocker des valeurs allant jusqu’à +/-57344, +/-inf et nan. Le compromis d’augmenter la plage dynamique est que les valeurs stockées sont moins précises.
Structure des types de données en virgule flottante. Toutes les valeurs affichées (dans FP16, BF16, FP8 E4M3 et FP8 E5M2) sont la représentation la plus proche de la valeur 0,3952.
Les deux types peuvent être utilisés lors de l’entraînement d’un réseau de neurones. En général, l’activation et les poids avant nécessitent une précision plus élevée, il est donc préférable d’utiliser le type de données E4M3 lors du passage avant. Cependant, en rétropropagation, le gradient qui traverse le réseau est généralement moins susceptible de perdre de précision mais nécessite une plage dynamique plus élevée. Il est donc préférable de les stocker en utilisant le format de données E5M2. Le H100 TensorCore prend en charge toute combinaison de ces types en entrée, nous permettant de stocker chaque tenseur avec la précision qu’il souhaite.
Référence:
La connexion hyperlientérée est visible.
La connexion hyperlientérée est visible. |
Publié le 10-03-2025 à 14:22:34
|
|
|
|
