Quantization : comment ça fonctionne ?

Avec des nombres de paramètres qui augmentent de plus en plus, les LLM sont toujours plus volumineux, et leur consommation en mémoire GPU plus importante. Avec des modèles pouvant atteindre les dizaines de milliards de paramètres, la consommation mémoire en GPU peuvent atteindre 40 Go à 50 Go, ce qui nécessite d'avoir plusieurs GPUs à disposition sur une même machine.

Afin de réduire au maximum l'empreinte des LLM sur la consommation de la mémoire GPU, des techniques de quantization sont régulièrement utilisées. Ces techniques visent à diminuer la précision numérique des nombres flottants utilisés comme paramètres des modèles, qui sont des réseaux de neurones très profonds. Plusieurs techniques de quantization ont vu le jour ces dernières années, chacune ayant ses propres spécificités.

Dans cet article, nous allons détailler en quoi la quantization se révèle particulièrement utile pour le LLM dont le nombres de paramètres dépasse certaines fois les dizaines de milliards. Nous verrons également quels sont les principaux avantages à utiliser des méthodes de quantization dans les projets d'IA Générative.

Précision numérique des nombres

Tout l'intérêt des méthodes de quantization, c'est de pouvoir réduire la précision des paramètres qui constituent les réseaux de neurones. L'ensemble de ces paramètres sont organisés sous forme de tenseurs, qui sont des matrices multidimensionnelles constituées de nombres flottants codés sur 32 bits (précision simple) ou 64 bits (précision double).

En général, plus la précision des nombres flottants est importante dans les réseaux de neurones, plus les performances et la stabilité sont élevées. En revanche, une précision importante implique plus de ressources en termes de calcul, de stockage disque et de mémoire.

L'idée fondamentale derrière la quantization est que les réseaux de neurones ne nécessitent pas forcément de l'ensemble des 64 bits en précision double pour fournir de bons résultats. De nombreux benchmarks ont montré qu'en passant à une précision beaucoup plus faible, le gain en termes de consommation mémoire GPU surpasse largement les légères pertes sur les performances.

À lire : découvrez notre formation LLM Engineering

Par exemple, le LLM de Meta LLama2-70B (à 70 milliards de paramètres) pèse près de 138 Go avec une précision en nombre flottants FP16. En réalisation une quantization vers INT4 en nombre entiers, le poids passe à environ 41 Go, soit une division par 3 de la taille totale.

Qu'est-ce que la quantization ?

La quantization est une méthode qui vise à réduire la précision des nombres flottants utilisés dans les paramètres des réseaux de neurones profond. En effet, ces architectures représentent la base des LLM, or ils sont souvent entraînés et exécutés en utilisant des nombres flottants à haute précision, généralement sur 32 bits (FP32) ou 64 bits (FP64).

En utilisant différentes méthodes de quantization, il est donc possible d'optimiser la consommation mémoire GPU de ces réseaux de neurones en convertissant les paramètres vers des nombres encodés sur un plus faible nombre de bits, sur 16 bits (FP16), en BrainFloat 16 bits (BF16), voire même directement en nombres entiers à 8 bits (INT8).

Il existe actuellement de types de quantization qui interviennent à différentes étapes.

• Le Quantization-Aware Training (QAT) intervient au moment où le modèle est entraîné, et les paramètres sont directement convertis dans une représentation en nombres flottants à plus faible précision. Ce cas de figure permet d'obtenir une quantization la plus efficace possible en minimisant la dégradation des performances du modèle, mais est plus difficile à mettre en place car elle demande donc de réaliser soi-même la phase d'entraînement.
• Le Post-Training Quantization (PTQ) à l'inverse, intervient une fois que le modèle entraîné est chargé, notamment lorsque d'autres utilisateurs vont construire leur propre LLM. Bien que cette méthode soit plus facile à mettre en place, elle va généralement beaucoup plus impacter les performances du modèles en raison de la troncature effectuée par la quantization.

Méthodes de quantization

Il existe plusieurs méthodes de quantization, même si nous allons uniquement énumérer les plus utilisées dans le type Post-Training Quantization.

GPTQ

La méthode GPTQ est une approche de quantization qui a la particularité de réduire les nombres flottants vers des types de données basés sur les entiers (INT4 ou INT8).

Cette méthode se distingue par sa capacité à préserver les gradients pendant la back-propagation. En effet, GPTQ va effectuer cette conversion dans chaque matrice de paramètres du réseau de neurone, c'est-à-dire à chaque couche.

Ainsi, un algorithme spécifique basé sur la factorisation de Cholesky a été développé pour trouver les paramètres quantizés de chaque couche, car GPTQ cherche à minimiser les erreurs commises entre chaque couches successives.

Cette approche dispose principalement de plusieurs avantages.

• Scalabilité : des réseaux de neurones très profonds peuvent être optimisés en réduisant fortement la précision des nombres flottants avec une dégradation très limitée au niveau des performances.
• Performance : avec cette méthode, il est dorénavant possible d'exécuter des inférences sur des modèles à plusieurs dizaines de milliards de paramètres sur un seul GPU, car la plupart sont limités à 24 Go ou 32 Go de mémoire. Automatiquement, cela impacte également la vitesse d'inférence qui est beaucoup plus rapide.

NF4 : 4-bit Normal Float

La méthode NF (NormalFloat) est une technique basée sur le Quantization Quantile pour représenter les nombres flottants sur 4 bits. En effet, là où la plupart des méthodes de Quantization vont surtout chercher à transformer les nombres vers des bases d'entiers, NF4 offre un niveau de flexibilité en donnant la possibilité de choisir la précision des poids.

Cela permet donc aux développeurs de choisir eux-mêmes le compromis entre réduction de la consommation mémoire GPU, et limitation de la dégradation des performances.

En pratique, la méthode NF4 est également couplée avec la Double Quantization, générant ainsi des nombres flottants FP32 ou FP8. Ces phases de traitement permettent ainsi de diviser en moyenne par 3 la consommation mémoire GPU sans grosse contrepartie sur les performances.

Cette méthode de Quantization est particulièrement utilisée pour le fine-tuning de LLM, notamment QLoRA et implémenté en Python avec le package bitsandbytes, qui est également bien intégré dans LangChain.

Avantages et inconvénients

Comme nous venons de le voir, un des principaux avantages de la quantization est de réduire l'empreinte mémoire GPU des LLM pour les déployer sur des serveurs à ressources limitées, ou même sur des périphériques comme des smartphones.

Cette réduction de la consommation mémoire s'accompagne également d'une baisse de la consommation d'énergie, ce qui est non négligeable lorsque l'on sait que les LLM sont très énergivores et que les calculs sur GPU requièrent une grande consommation d'électricité (alimentation et refroidissement).

Enfin, les temps d'inférence sont réduits, puisque la précision des paramètres des réseaux de neurones est également réduite. Ainsi, il y a moins de calculs qui sont réalisés du fait qu'il y a moins de bits dans les tenseurs, accélérant ainsi les temps de réponses apportées aux utilisateurs.

À découvrir : notre formation LLM Engineering

Cependant, la quantization apporte également quelques inconvénients. Le principal inconvénient qui peut survenir est la baisse de performance des LLM, en particulier lorsqu'ils sont utilisés pour des tâches où il doit être très spécialisés.

Un des autres inconvénients provient de la quantization elle-même : elle nécessite une nouvelle étape dans le développement des LLM, ce qui rajoute une complexité opérationnelle car il faut intégrer cette étape dans les projets, tout en s'assurant que les équipes disposent bien de compétences spécialisées sur ce sujet.

Conclusion

Comme nous venons de le voir, la quantization est une étape particulièrement utile pour réduire la taille des LLM, et donc leur empreinte sur la mémoire GPU lorsqu'ils doivent être chargés pour de l'inférence. Cela offre des perspectives intéressantes pour déployer des LLM sur des serveurs qui ne disposent pas de beaucoup de ressources GPU, ou encore pour embarquer des LLM dans des smartphones.

Toute la difficulté de la quantization réside dans le compromis à définir entre réduction de la consommation mémoire et perte de performance. Néanmoins, elle semble tout de même être aujourd'hui une étape incontournable dans l'utilisation des LLM, encore plus lorsque les modèles approchent désormais la centaine de milliards de paramètres.