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

Mesurer la latence et le débit d’un LLM

Après cette leçon: Je peux calculer le temps jusqu’au premier jeton et les jetons par seconde à partir des instants de chaque jeton.

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

Deux nombres faciles à embellir

Mesurer la latence d’un LLM, c’est chronométrer combien de temps un utilisateur attend le premier jeton et à quelle vitesse arrivent les suivants. Les deux nombres habituels sont le temps jusqu’au premier jeton et les jetons par seconde.

Ces deux nombres sont faciles à faire paraître meilleurs qu’ils ne sont. Le moment où démarre le chronomètre et les jetons que l’on compte les changent plus que n’importe quelle accélération.

À la fin de cette leçon

Remarque

Je peux calculer le temps jusqu’au premier jeton et les jetons par seconde à partir des instants de chaque jeton.

Mots-clés

MotCe que ça veut dire
Latencele temps que quelqu’un attend
Temps jusqu’au premier jetonl’attente entre l’envoi d’une requête et le premier jeton
Jetons par secondeles jetons de sortie divisés par les secondes qu’ils ont prises
Écart entre jetonsle temps entre deux jetons d’une réponse
Mise en chauffeune première exécution qui charge des choses et qui est plus lente
Médianela valeur du milieu une fois les valeurs triées

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

Lancer le chronomètre à l’arrivée de la requête

Le temps jusqu’au premier jeton est ce que l’utilisateur ressent comme « est-ce que ça marche ? ». Il va de l’arrivée de la requête jusqu’au premier jeton. Il comprend l’attente dans une file, puis la passe de prefill, puis la première étape de décodage.

Un serveur qui lance son chronomètre au début du travail cache la file. Sur un serveur chargé, la file peut faire l’essentiel de l’attente.

Calculer les nombres d’une requête

Commande
docker exec jupyter python3 steps/latency.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é : une requête sur une horloge simulée

MesureValeurHonnête ?
Temps jusqu’au premier jeton, depuis l’arrivée345 msOui
Temps jusqu’au premier jeton, depuis le début du travail225 msNon : cache 120 ms de file
Vitesse de décodage, après le premier jeton40,0 jetons par secondeOui, pour le décodage
Toute la requête, jetons de sortie seuls31,8 jetons par secondeOui, pour l’utilisateur
Invite comptée comme sortie286,6 jetons par secondeNon

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

Compter seulement les jetons écrits par le modèle

La vitesse de décodage, ce sont les jetons de sortie après le premier, divisés par le temps entre le premier et le dernier jeton. Ici, 49 jetons en 1,225 seconde, soit 40,0 par seconde.

La vitesse de toute la requête divise les 50 jetons de sortie par le temps depuis l’arrivée : 31,8 par seconde. Les deux sont honnêtes et répondent à des questions différentes. Dites laquelle vous donnez.

Une erreur fréquente

Attention

Beaucoup comptent les jetons de l’invite dans les jetons par seconde, puisque le modèle les a bien traités. Ici, cela a changé 31,8 en 286,6. Les jetons de l’invite sont lus en une passe rapide. Donnez les jetons de sortie par seconde, avec la longueur de l’invite à côté.

Une vraie horloge demande chauffe et répétitions

Un vrai chronomètre donne un nombre différent à chaque exécution. La première est souvent lente, car le code et les données se chargent. Une exécution peut aussi être gênée par un autre programme.

Faites donc une exécution de chauffe et jetez-la. Répétez plusieurs fois et donnez la médiane, qu’une exécution bizarre ne peut pas tirer. Nommez la machine et les réglages, car une autre machine donne d’autres nombres.

À vous : moyenne contre médiane

Code: python
# Huit mesures de la même requête, en millisecondes. La première était à froid.
mesures = [41.0, 12.5, 12.1, 13.0, 12.4, 30.2, 12.6, 12.3]
total = 0
for une in mesures:
    total = total + une
print("moyenne de toutes les mesures :", round(total / len(mesures), 2))
chaudes = sorted(mesures[1:])
print("milieu des mesures à chaud :", chaudes[len(chaudes) // 2])
# Remplacez 30.2 par 300. Quel nombre bouge, et lequel reste ?

Chronométrer pour de vrai le petit modèle

Dans le labo, ouvrez JupyterLab et le notebook start.ipynb, puis lancez la cellule sous Real timings. Elle chronomètre le prefill, une étape de décodage et trois tailles de lot avec une vraie horloge. Elle chauffe d’abord, répète sept fois et affiche la valeur du milieu.

Vos nombres seront différents de ceux de votre voisin et d’une exécution à l’autre. C’est pour cela que les scripts du dossier steps comptent le travail.

À 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.