Qu’est-ce que la quantification de modèle ? Des LLM plus petits et plus rapides

S’il existait un exemple frappant de technique contre-intuitive, ce serait la quantification des réseaux neuronaux. La quantification réduit souvent considérablement la précision des poids et autres tenseurs dans les modèles de réseaux neuronaux. Il n'est pas surprenant que la réduction de la précision des poids et d'autres paramètres, par exemple de valeurs flottantes de 32 bits à des nombres entiers de 8 bits, accélère l'exécution du modèle et lui permet de fonctionner sur des processeurs moins puissants avec beaucoup moins de mémoire. La découverte étonnante et contre-intuitive est que la quantification peut être effectuée tout en préservant largement la précision du modèle.

Pourquoi avons-nous besoin de quantification ? Les grands modèles linguistiques (LLM) actuels sont énormes. Les meilleurs modèles doivent fonctionner sur un cluster de GPU de classe serveur ; Il est révolu le temps où vous pouviez exécuter localement un modèle de pointe sur un seul GPU et obtenir des résultats rapides. La quantification permet non seulement d'exécuter un LLM sur un seul GPU, mais elle vous permet également de l'exécuter sur un CPU ou sur un périphérique Edge.

Quantification post-formation

La quantification post-formation est une technique de conversion qui peut réduire la taille du modèle tout en améliorant la latence du processeur et de l'accélérateur matériel, avec une légère dégradation de la précision du modèle.

– Documentation TensorFlow Lite

Compte tenu de la maturité de TensorFlow Lite par rapport, disons, au modèle Gen AI du jour (probablement Codestral de Mistral AI, qui a été publié le jour où j'ai écrit ceci), il vaut la peine d'examiner comment TensorFlow Lite implémente la quantification. Tout d'abord, TensorFlow Lite implémente trois options de quantification :

Technique	Avantages	Matériel
Quantification de la plage dynamique	4x plus petit, 2x à 3x accélération	CPU
Quantification entière complète	4x plus petit, 3x+ accélération	CPU, Edge TPU, microcontrôleurs
Quantification Float16	2x plus petit, accélération GPU	Processeur, GPU

Dans l'arbre de décision qui accompagne ce tableau, les documenteurs de TensorFlow Lite décrivent les considérations à prendre en compte pour le choix d'une technique de quantification. Cela vaut la peine de lire la logique. En un mot, la meilleure méthode de post-quantification pour votre cas d'utilisation dépendra de la prise en charge matérielle de vos opérations sur les nombres entiers ou en virgule flottante et de votre capacité à fournir un ensemble de données représentatif pour l'étalonnage.

Quantification de la plage dynamique

Ils expliquent ensuite pourquoi la quantification de la plage dynamique est le point de départ habituel : elle permet une utilisation réduite de la mémoire et un calcul plus rapide sans nécessiter de fournir un ensemble de données représentatif pour l'étalonnage. La quantification de la plage dynamique quantifie statiquement seulement les poids de la virgule flottante à l'entier à conversion time, qui fournit 8 bits de précision. De plus, les opérateurs de « plage dynamique » quantifient dynamiquement les activations en fonction de leur plage jusqu'à 8 bits et effectuent des calculs avec des poids et des activations sur 8 bits. Les sorties sont toujours stockées sous forme de valeurs à virgule flottante.

Quantification entière complète

La quantification d'entiers complets peut accélérer les choses encore plus que la quantification de plage dynamique, mais vous devez fournir un ensemble de données représentatif pour l'étalonnage (généralement quelques centaines d'échantillons) et exécuter quelques cycles d'inférence afin de pouvoir capturer la plage de toutes les valeurs à virgule flottante. tenseurs dans le modèle. Ceux-ci incluent non seulement les pondérations et les biais du modèle, mais également les entrées du modèle, les activations (sorties des couches intermédiaires) et les sorties du modèle. La quantification entière complète est essentiellement obligatoire sur les appareils utilisant uniquement des entiers, tels que les microcontrôleurs 8 bits, et sur les accélérateurs utilisant uniquement des entiers, tels que le Coral Edge TPU.

Flotteur16 quantification

La quantification Float16 réduit la taille du modèle jusqu'à la moitié, puisque tous les poids deviennent la moitié de leur taille d'origine et entraîne une perte de précision minimale. Il prend également en charge certains « délégués » (c'est-à-dire les accélérateurs intégrés à l'appareil tels qu'un GPU) qui peuvent fonctionner directement sur les données float16. Par contre, la quantification float16 ne réduit pas autant la latence que la quantification mathématique en virgule fixe. De plus, un modèle quantifié float16 « déquantifiera » les valeurs de poids en float32 lorsqu'il est exécuté sur un processeur, ce qui est une excellente raison d'utiliser un délégué GPU à la place, ainsi que l'augmentation de la vitesse liée à l'utilisation du GPU.

Quantification et précision du modèle

Comme on peut s'y attendre, la précision peut être un problème lorsque vous quantifiez un modèle. Vous pouvez évaluer la précision d'un modèle quantifié par rapport au modèle d'origine et décider si le modèle quantifié est suffisamment précis pour vos besoins. Par exemple, TensorFlow Lite propose trois exécutables pour vérifier l'exactitude des modèles quantifiés. Vous pouvez également envisager MQBench, une référence et un cadre pour évaluer les algorithmes de quantification dans le cadre de déploiements matériels réels qui utilisent PyTorch.

Si la dégradation de la précision due à la quantification post-entraînement est trop importante, une alternative consiste à utiliser un entraînement prenant en compte la quantification.

Formation prenant en compte la quantification

L'entraînement sensible à la quantification (QAT) modélise les effets de la quantification pendant l'entraînement ou le réglage fin, et produit un modèle avec des poids float32 qui peuvent ensuite être quantifiés en poids entiers et en activations. Le modèle quantifié résultant est généralement plus précis qu'un modèle produit par quantification post-entraînement (PTQ) sans prendre en compte la quantification lors de l'entraînement.

Un moyen rapide de comprendre comment et pourquoi QAT fonctionne est de regarder quand les plages d'activation sont calculées. Pour la quantification dynamique post-entraînement, la plage de chaque activation est calculée à la volée au moment de l'exécution. Pour la quantification statique post-formation (appelée quantification entière complète ci-dessus), la plage de chaque activation est calculée à l'avance au moment de la quantification, en utilisant des observateurs pour enregistrer les valeurs des activations. Pour un entraînement prenant en compte la quantification, la plage de chaque activation est calculée au moment de l'entraînement, suivant la même idée que la quantification statique après l'entraînement. Le problème est que dans QAT, des opérateurs de « fausse quantification » sont utilisés à la place des observateurs, non seulement pour enregistrer les valeurs, mais également pour simuler l’erreur induite par la quantification, afin que le modèle puisse s’y adapter.

LLM 1 bit

Le point final évident de la tendance à la quantification est un réduction par l'absurde: quantification 1 bit. Étonnamment, les modèles quantifiés 1 bit (présentés dans l'article BitNet) fonctionnent réellement, et les modèles 1,58 bits (nous expliquerons cette fraction de bit dans un instant) sont encore meilleurs. Les deux types de modèles ont été développés par un groupe de Microsoft Research et de l’Académie chinoise des sciences.

Tout d’abord, des modèles quantifiés sur 1 bit. De peur que vous ne vous trompiez d'idée, non, les modèles de transformateur BitNet 1 bit ne réduisent pas tous les tenseurs du modèle à 1 bit bon gré mal gré. Les poids, et uniquement les poids, sont binarisés à -1 ou 1, après centralisation à une moyenne nulle, puis les poids binarisés sont mis à l'échelle pour réduire l'erreur introduite par la binarisation.

Les activations sont quantifiées à b-précision en bits (le papier original utilisait une précision de 8 bits) après quelques mises à l'échelle et découpage. Le modèle est modifié pour utiliser des couches BitLinear au lieu des couches nn.Linear, et une fonction LayerNorm est appliquée à l'entrée de chaque couche BitLinear. En d’autres termes, beaucoup de travail est en cours pour rendre les modèles quantifiés 1 bit compétitifs en termes de précision par rapport aux modèles originaux, tout en étant beaucoup plus petits et plus rapides.

Maintenant, à propos de ce nombre de 1,58 bits. Le papier L'ère des LLM 1 bit : Tous les grands modèles de langage sont en 1,58 bits introduit une variante LLM 1 bit, appelée BitNet b1.58, dans laquelle chaque poids du LLM est ternaire {-1, 0, 1}. Les auteurs disent que cela fait 1,58 bits, mais ils ne montrent pas leur calcul.

Selon le document, BitNet b1.58 « correspond au Transformer LLM de pleine précision (c'est-à-dire FP16 ou BF16) avec la même taille de modèle et les mêmes jetons de formation en termes de perplexité et de performances de tâche finale, tout en étant nettement plus rentable. en termes de latence, de mémoire, de débit et de consommation d’énergie. Les auteurs poursuivent en disant que « cela permet un nouveau paradigme de calcul et ouvre la porte à la conception de matériel spécifique optimisé pour les LLM 1 bit ».

L'architecture de BitNet b1.58 commence par BitNet, mais utilise une fonction de quantification différente pour accéder à la représentation de poids ternaire et utilise la mise à l'échelle d'activation sur la plage (−Qb, Qb) par jeton au lieu de la plage (0, Qb). Pour être plus compatible avec les modèles de type LLaMA, BitNet b1.58 ajoute RMSNorm, SwiGLU et l'intégration rotative.

Les auteurs ont comparé BitNet b1.58 à un LLM FP16 LLaMA reproduit dans différentes tailles, formé à partir de zéro sur l'ensemble de données RedPajama pour 100 milliards de jetons. Leur conclusion était que « BitNet b1.58 commence à correspondre à la pleine précision LLaMA LLM à une taille de modèle 3B en termes de perplexité, tout en étant 2,71 fois plus rapide et en utilisant 3,55 fois moins de mémoire GPU. En particulier, BitNet b1.58 avec une taille de modèle de 3,9B est 2,4 fois plus rapide, consomme 3,32 fois moins de mémoire, mais fonctionne nettement mieux que LLaMA LLM 3B.

Des LLM plus petits et plus rapides

Comme nous l'avons vu, la quantification peut aider à résoudre certains des problèmes les plus importants liés aux grands modèles de langage : les LLM sont trop volumineux et trop lents pour fonctionner sur du matériel normal, nécessitant à la place des clusters de GPU dans le cloud. Diverses techniques de quantification aident à des degrés divers, mais les modèles « à un bit » passionnants et inattendus (c'est-à-dire à la fois les quantifications binaires de 1 bit et les quantifications ternaires de 1,58 bits) commencent à sortir de l'impasse de la taille croissante des modèles.