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
| Mot | Ce que ça veut dire |
|---|---|
| Requête | l’invite d’un utilisateur et la réponse qu’elle attend |
| Lot | des requêtes décodées ensemble dans une même passe |
| Place | l’emplacement d’une requête dans le lot |
| Lots statiques | un nouveau lot ne part que lorsque le précédent est fini |
| Lots continus | une place libre est reprise à l’étape suivante |
| Débit | les 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
docker exec jupyter python3 steps/share.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é : huit passes de décodage par taille
| Lot | Jetons produits | Octets de poids lus par jeton | Multiplications-additions par jeton |
|---|---|---|---|
| 1 | 8 | 12 108 | 3 427 |
| 2 | 16 | 6 054 | 3 427 |
| 4 | 32 | 3 027 | 3 427 |
| 8 | 64 | 1 513 | 3 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
docker exec jupyter python3 steps/batch.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é : trois places, six requêtes
| Requête | Arrive à l’étape | Jetons | Finit, statique | Finit, continu |
|---|---|---|---|---|
| A | 0 | 8 | 8 | 8 |
| B | 0 | 2 | 2 | 2 |
| C | 0 | 3 | 3 | 3 |
| D | 1 | 2 | 10 | 4 |
| E | 2 | 6 | 14 | 9 |
| F | 3 | 2 | 10 | 6 |
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
# 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 ?