Plus facile à lire avec un fond crème, une teinte, plus de contraste ou un texte plus grand ? Choisissez vos couleurs et votre texte, une fois pour toutes les pages.

Leçon gratuite

La quantification int8 à la main

Après cette leçon: Je peux quantifier une ligne de poids en int8 et mesurer l’erreur.

Leçon de 60 min2 commandesLab d’inférence de LLM : un petit modèle de langage sur un CPU, avec cache KV, lots et int8

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

MotCe que ça veut dire
Int8un entier rangé sur un octet
Échellele nombre par lequel on multiplie une valeur int8 pour la retrouver
Quantifierchanger des nombres réels en valeurs int8 avec une échelle
Déquantifiermultiplier à nouveau les valeurs int8 par l’échelle
Échelle par ligneune échelle pour chaque ligne d’une matrice
Valeur aberranteune 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

PoidsDivisé par l’échelle 0,00945Int8De retourErreur
0,3031,75320,302360,00236
-1,20-127-127-1,20
0,077,4170,066140,00386
0,5052,92530,500790,00079

Les cellules que les étudiants remplissent restent vides dans cet aperçu.

À vous : quantifiez une ligne

Code: python
# 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

Commande
docker exec jupyter python3 steps/quantise.py

Affiché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é

MesureRésultat
Octets en float3212 108
Octets en int8, échelles comprises3 543
Pire erreur sur un poidsde 0,00221 à 0,03771
Même caractère suivant64 places sur 64
Réponse à « the cat », des deux façonssat 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

Commande
docker exec jupyter python3 steps/outlier.py

Affiché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

MatriceUne seule échelleUne échelle par ligne
Telle qu’entraînée0,01940,00617
Une valeur mise à 400,07820,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.

À propos de ce labo et de sa source: Lab d’inférence de LLM : un petit modèle de langage sur un CPU, avec cache KV, lots et int8

Vous enseignez à une classe ? Proposez ce module à vos étudiants avec un guide de l'enseignant, des devoirs corrigés et un laboratoire pour chaque étudiant.