Quantization : faire tourner des modèles ML géants sur du hardware minuscule

  MINI-COURS #34      ⏱️ 30-40 minutes de lecture

Dans un précédent deep dive consacré à la compression de modèles, nous avons passé en revue différentes façons de compresser un modèle ML une fois qu'il est entraîné.

Dans ce deep dive là, nous avons vu plusieurs techniques qui permettent de réduire l'empreinte mémoire des modèles ML et de les rendre plus accessibles et plus déployables.

L'une de ces techniques était la quantization. Nous l'avions abordée avec un certain niveau de détail, mais pas avec toute la précision que ce sujet mérite vraiment pour un ingénieur ML.

Dans ce dossier, on plonge donc dans les détails techniques de la quantization : ce que c'est, comment ça marche, et pourquoi c'est l'une des techniques les plus puissantes pour exploiter de gros modèles sur des machines ordinaires.

👉 En tant qu'ingénieur ML, savoir manier les techniques qui font économiser de l'argent à ton employeur est sincèrement apprécié. Maîtriser la quantization, la compression de modèles, l'optimisation, etc., te place clairement sur la voie pour devenir un atout indispensable dans ton équipe.

En règle générale, les paramètres d'un réseau de neurones (les poids des couches) sont représentés avec des nombres à virgule flottante sur 32 bits.

Le raisonnement est le suivant : comme les paramètres d'un modèle ML ne sont contraints à aucune plage de valeurs précise, assigner un type de données capable de couvrir une large plage est une décision prudente. Ça évite l'instabilité numérique et maintient une haute précision pendant l'entraînement comme à l'inférence.

Évidemment, le gros inconvénient de cette approche, c'est qu'utiliser le plus grand type de données signifie aussi que le modèle consomme plus de mémoire.

Imagine qu'on puisse représenter ces mêmes paramètres avec des formats plus compacts : 16 bits, 8 bits, 4 bits, voire 1 bit, tout en préservant l'essentiel de l'information.

Plutôt cool, non ?

Ça réduirait drastiquement la quantité de mémoire nécessaire pour stocker les paramètres du modèle, sans compromettre significativement sa précision.

C'est exactement ce que permettent les techniques de quantization.

Dans ce dossier, on va comprendre en détail pourquoi la quantization est nécessaire et à quel moment il vaut mieux quantizer le modèle, puis explorer les différents types de données et les méthodes de quantization modernes.

Formellement, la quantization est le processus qui consiste à convertir des valeurs depuis une représentation riche en information (généralement un ensemble continu) vers une représentation plus compacte (généralement un ensemble discret).

Un bon exemple de quantization, c'est l'échantillonnage d'un signal analogique : chaque valeur d'un signal continu se voit assigner une valeur tirée d'un ensemble discret prédéfini.

Dans le contexte des réseaux de neurones, la quantization consiste à convertir la précision des nombres (principalement les paramètres) utilisés dans notre modèle, en passant d'une haute précision (comme un float 32 bits) à une précision plus basse (comme un entier 4 bits).

La raison est assez évidente.

Ça économise de la mémoire, ce qui, à son tour, économise de l'argent.

Pour te donner un ordre de grandeur, prends un modèle ML avec plus d'un million de paramètres, chacun représenté par un float 32 bits.

Si on peut les représenter avec des nombres sur 8 bits, on obtient une baisse significative de l'usage mémoire (environ 75 %), tout en conservant la capacité de représenter une large plage de valeurs.

De plus, les modèles quantizés nécessitent moins de ressources de calcul et sont plus rapides. Résultat : ils font économiser de l'argent et améliorent l'expérience utilisateur.

Enfin, tout le monde n'a pas accès à de gros clusters de GPU pour faire tourner d'énormes modèles ML. Avec la quantization, les chercheurs et passionnés sans cluster GPU personnel peuvent expérimenter facilement avec de gros modèles modernes. Autrement dit, on peut exécuter efficacement des calculs directement sur les appareils des utilisateurs.

Bien sûr, la quantization introduit un compromis entre efficacité (taille du modèle) et précision (accuracy). En réduisant la précision numérique, les prédictions du modèle deviennent plus approximatives que celles du modèle original en pleine précision.

L'entraînement en précision mixte (mixed precision training) est une technique similaire qui repose elle aussi sur l'usage de plusieurs types de données.

Quantization et précision mixte servent toutes deux à optimiser l'efficacité computationnelle des modèles ML, mais elles s'attaquent à des aspects différents, avec des approches d'implémentation et des compromis distincts.

Avant de passer aux techniques de quantization, il est donc important de bien comprendre ce qui les sépare.

Quantization

Comme on l'a vu plus haut, la quantization consiste à réduire la précision des poids et des activations, en passant de formats haute précision (comme le float 32 bits) à des formats basse précision (comme les entiers 16 ou 8 bits).

Son objectif premier est de rendre les modèles plus petits et plus rapides à l'inférence, ce qui est particulièrement utile pour déployer des modèles sur des appareils aux ressources limitées.

Entraînement en précision mixte

L'entraînement en précision mixte, lui, vise à accélérer le processus d'entraînement en utilisant à la fois de l'arithmétique haute précision (float 32 bits) et basse précision (float 16 bits) au sein du même modèle.

On a déjà couvert ce sujet dans ce shot data ci-dessous :

…mais faisons un rapide rappel de son fonctionnement.

Les bibliothèques de deep learning classiques sont très conservatrices dans l'attribution des types de données.

Par défaut, le type assigné est souvent du 64 bits ou du 32 bits, alors qu'il y aurait par exemple de la marge pour du 16 bits. C'est ce qu'illustre le code ci-dessous :

Résultat : on n'est pas du tout optimal dans l'allocation mémoire.

Bien sûr, ce choix vise à garantir une meilleure précision dans la représentation de l'information.

Mais cette précision a toujours un coût : une consommation mémoire supplémentaire, pas toujours souhaitable selon les situations.

On observe d'ailleurs que beaucoup d'opérations sur les tenseurs, en particulier la multiplication matricielle, sont bien plus rapides avec des types de données de plus faible précision, comme le montre l'exemple ci-dessous :

Par ailleurs, comme le float16 ne fait que la moitié de la taille du float32, son usage réduit la mémoire nécessaire pour entraîner le réseau.

Ça permet aussi d'entraîner de plus gros modèles, ou de travailler sur des mini-batches plus grands (ce qui accélère encore davantage l'entraînement), etc.

L'entraînement en précision mixte est une technique fiable et largement adoptée dans l'industrie pour atteindre cet objectif.

Comme son nom l'indique, l'idée est d'employer du float16 basse précision (partout où c'est faisable, comme dans les convolutions et les multiplications matricielles) en complément du float32. D'où le nom de « précision mixte ».

Voici une liste de quelques modèles que j'ai trouvés et qui ont été entraînés en précision mixte :

On voit clairement que la précision mixte est bien plus utilisée qu'on ne le croit, même si on en entend rarement parler.

Si tu veux entrer dans le détail technique et l'implémentation, jette un œil à cette newsletter :

Pour bien marquer la différence une dernière fois :

💡 En continuant, tu vas découvrir :