Le quart des octets
La quantification int8 range chaque poids d’un modèle de langage comme un entier de -127 à 127, sur un octet. Une échelle le retransforme en nombre réel.
Le décodage lit chaque poids à chaque passe : un quart des octets, c’est un quart de la lecture. La question est ce que cela coûte en précision.
À la fin de cette leçon
Remarque
Je peux quantifier une ligne de poids en int8 et mesurer l’erreur.
Mots-clés
| Mot | Ce que ça veut dire |
|---|---|
| Int8 | un entier rangé sur un octet |
| Échelle | le nombre par lequel on multiplie une valeur int8 pour la retrouver |
| Quantifier | changer des nombres réels en valeurs int8 avec une échelle |
| Déquantifier | multiplier à nouveau les valeurs int8 par l’échelle |
| Échelle par ligne | une échelle pour chaque ligne d’une matrice |
| Valeur aberrante | une valeur bien plus grande que les autres |
Les cellules que les étudiants remplissent restent vides dans cet aperçu.
Une échelle place chaque ligne sur int8
Cherchez la plus grande valeur absolue de la ligne. Divisez-la par 127 : c’est l’échelle. Divisez chaque nombre par l’échelle et arrondissez : c’est sa valeur int8.
Pour retrouver un nombre, multipliez sa valeur int8 par l’échelle. La plus grande valeur revient exactement. Toutes les autres reviennent un peu décalées, d’au plus une demi-échelle.
Exemple travaillé : une ligne de quatre poids
| Poids | Divisé par l’échelle 0,00945 | Int8 | De retour | Erreur |
|---|---|---|---|---|
| 0,30 | 31,75 | 32 | 0,30236 | 0,00236 |
| -1,20 | -127 | -127 | -1,2 | 0 |
| 0,07 | 7,41 | 7 | 0,06614 | 0,00386 |
| 0,50 | 52,92 | 53 | 0,50079 | 0,00079 |
Les cellules que les étudiants remplissent restent vides dans cet aperçu.
À vous : quantifiez une ligne
# Une ligne de poids, quantifiée en int8 avec sa propre échelle.
ligne = [0.30, -1.20, 0.07, 0.50]
plus_grand = 0
for x in ligne:
plus_grand = max(plus_grand, abs(x))
echelle = plus_grand / 127
entiers = []
for x in ligne:
entiers.append(round(x / echelle))
print("échelle :", round(echelle, 5))
print("valeurs int8 :", entiers)
retour = []
for n in entiers:
retour.append(round(n * echelle, 5))
print("de retour :", retour)
# Remplacez 0.07 par 0.004. Que lui arrive-t-il ?
Quantifier tout le modèle et comparer
Le labo quantifie chacune des cinq matrices de poids du modèle, avec une échelle par ligne. Il affiche la pire erreur de chaque matrice et les octets avant et après, échelles comprises.
Puis il pose la vraie question : le modèle choisit-il toujours le même caractère suivant ? Il vérifie chaque place des 64 premiers caractères de son texte, puis écrit une réponse des deux façons.
Quantifier le modèle en int8
docker exec jupyter python3 steps/quantise.pyAffichée ici, non exécutée. Appuyez sur Démarrer le labo pour la saisir dans le terminal de votre propre labo.
Ce que le Run a affiché
| Mesure | Résultat |
|---|---|
| Octets en float32 | 12 108 |
| Octets en int8, échelles comprises | 3 543 |
| Pire erreur sur un poids | de 0,00221 à 0,03771 |
| Même caractère suivant | 64 places sur 64 |
| Réponse à « the cat », des deux façons | sat on the mat. the dog |
Les cellules que les étudiants remplissent restent vides dans cet aperçu.
Une grande valeur gâche une échelle partagée
Avec une seule échelle pour toute une matrice, sa plus grande valeur fixe le pas entre deux niveaux. Si un poids est bien plus grand que les autres, le pas s’élargit et les petits poids perdent leur détail.
Une échelle par ligne limite les dégâts à cette seule ligne. Le labo met un poids à 40 et mesure l’erreur moyenne des deux façons.
Une seule échelle contre une échelle par ligne
docker exec jupyter python3 steps/outlier.pyAffichée ici, non exécutée. Appuyez sur Démarrer le labo pour la saisir dans le terminal de votre propre labo.
Exemple travaillé : erreur moyenne de la dernière matrice
| Matrice | Une seule échelle | Une échelle par ligne |
|---|---|---|
| Telle qu’entraînée | 0,0194 | 0,00617 |
| Une valeur mise à 40 | 0,0782 | 0,00702 |
Les cellules que les étudiants remplissent restent vides dans cet aperçu.
Une erreur fréquente
Attention
Beaucoup pensent que l’int8 accélère un modèle parce que les calculs sur des entiers sont plus rapides. Pour le décodage, le gain vient surtout de la lecture d’un quart des octets. Une machine qui reconvertit l’int8 en float32 pour chaque calcul lit quand même moins, donc elle accélère aussi.