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

Traitement par lots et lots continus

Après cette leçon: Je peux ordonnancer des requêtes par lots statiques et par lots continus, et comparer les deux.

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

Un modèle, beaucoup d’utilisateurs à la fois

Le traitement par lots continu est la façon dont un serveur de modèle de langage répond à beaucoup d’utilisateurs à la fois. Il décode leurs requêtes ensemble et fait entrer une nouvelle requête dès qu’une autre se termine.

Un serveur qui répond à un seul utilisateur à la fois gaspille la plupart de ses lectures de mémoire. Les lots sont la première raison pour laquelle un modèle partagé reste abordable.

À la fin de cette leçon

Remarque

Je peux ordonnancer des requêtes par lots statiques et par lots continus, et comparer les deux.

Mots-clés

MotCe que ça veut dire
Requêtel’invite d’un utilisateur et la réponse qu’elle attend
Lotdes requêtes décodées ensemble dans une même passe
Placel’emplacement d’une requête dans le lot
Lots statiquesun nouveau lot ne part que lorsque le précédent est fini
Lots continusune place libre est reprise à l’étape suivante
Débitles jetons produits par seconde par tout le serveur

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

Un lot partage une lecture des poids

Une passe de décodage lit chaque poids pour produire un jeton. Si huit requêtes sont décodées dans la même passe, les poids sont lus une fois et servent huit fois.

Chaque requête garde ses propres calculs et son propre cache KV. Seule la lecture des poids est partagée, et sur un grand modèle, c’est elle la partie lente.

Compter les lectures pour quatre tailles de lot

Commande
docker exec jupyter python3 steps/share.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é : huit passes de décodage par taille

LotJetons produitsOctets de poids lus par jetonMultiplications-additions par jeton
1812 1083 427
2166 0543 427
4323 0273 427
8641 5133 427

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

Ce que montre un CPU

Remarque

Ce modèle pèse 12 Ko : ses poids tiennent dans le cache rapide du CPU et les lire coûte peu. Ses vraies mesures, dans la cellule Real timings du notebook, gagnent bien moins que la taille du lot. Un grand modèle sur un GPU gagne beaucoup plus, car là, ce sont les lectures qui sont lentes.

Les lots statiques attendent le plus lent

Les requêtes demandent des réponses de longueurs différentes. Avec des lots statiques, un lot démarre ensemble et le serveur ne prend aucune nouvelle requête tant que toutes n’ont pas fini.

Une requête de 2 jetons finit tôt, et sa place reste vide pendant qu’une longue continue. Les nouvelles requêtes attendent dehors tout ce temps.

Ordonnancer six requêtes des deux façons

Commande
docker exec jupyter python3 steps/batch.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é : trois places, six requêtes

RequêteArrive à l’étapeJetonsFinit, statiqueFinit, continu
A0888
B0222
C0333
D12104
E26149
F32106

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

Les lots continus reprennent une place aussitôt

Avec des lots continus, le serveur cherche une place libre avant chaque étape. Quand B a fini à l’étape 2, D a pris sa place à l’étape suivante au lieu d’attendre A.

Le lot n’est jamais vidé puis rempli d’un bloc. Chaque requête entre et sort pour son compte : les requêtes courtes n’attendent plus derrière les longues.

Une erreur fréquente

Attention

Beaucoup pensent que les lots font revenir chaque réponse plus tôt. Ils augmentent les jetons par seconde de tout le serveur. Une requête seule peut attendre une place, et un lot plus gros peut ralentir un peu chaque étape. Mesurez le débit et l’attente de chaque utilisateur.

À vous : la mémoire décide des places

Code: python
# Combien de requêtes tiennent à côté des poids ? Chacune a son propre cache KV.
memoire_go = 24
poids_go = 14
cache_go_par_requete = 1
places = (memoire_go - poids_go) // cache_go_par_requete
print("requêtes servies en même temps :", places)
# Quantifiez les poids à 7 Go. Combien en tient-il maintenant ?

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