À mesure que les grands modèles de langage (LLM) et les architectures complexes de vision par ordinateur deviennent la norme dans les environnements de production, le coût de l'inférence et la demande de faible latence ont explosé. Le traitement des requêtes individuelles est souvent la méthode la moins efficace pour exploiter le matériel moderne. C'est là que l'inférence par lots intervient. En regroupant plusieurs requêtes indépendantes en une seule opération de tenseur, les développeurs peuvent considérablement augmenter l'utilisation du matériel et réduire le coût par inférence. Cependant, implémenter efficacement le lot nécessite d'équilibrer le débit et la latence perçue par l'utilisateur.
Pourquoi l'inférence par lots est importante
Les GPU modernes sont conçus pour traiter des opérations matricielles parallèles. Lorsque vous traitez un seul jeton ou une seule image, le GPU reste largement sous-utilisé, en attendant que les données passent de la mémoire aux unités de calcul. On appelle cela le régime limité par la mémoire. En regroupant plusieurs entrées, vous transformez la charge de travail en un régime limité par le calcul, où les unités arithmétiques et logiques (UAL) du GPU sont saturées. Cela peut entraîner une amélioration du débit de 10 à 100 fois par rapport au traitement séquentiel.
Lot statique vs. lot dynamique
Il existe deux approches principales pour gérer les lots dans un environnement de service de production :
- Lot statique : Le serveur attend un nombre fixe de requêtes (la taille du lot) ou une période de délai d'expiration maximale avant de traiter. C'est simple à implémenter, mais peut introduire une latence significative pour les utilisateurs qui n'ont pas à attendre que le lot soit complètement rempli.
- Lot dynamique : Le serveur accepte de nouvelles requêtes pendant qu'un lot est en cours de formation et les traite dès que le lot est prêt ou qu'un seuil est atteint. Cela offre une meilleure latence, mais nécessite une gestion de file d'attente plus sophistiquée et potentiellement une logique de planification complexe pour gérer les longueurs de séquence variables.
Exemple d'implémentation avec Python
Ci-dessous se trouve un exemple conceptuel de la manière dont vous pourriez implémenter une boucle de lot simple en Python en utilisant NumPy pour simuler des opérations de tenseur. Dans un scénario réel, vous remplaceriez l'opération `np.dot` par un passage avant à travers un modèle PyTorch ou TensorFlow.
import numpy as np
import time
from concurrent.futures import ThreadPoolExecutor
def process_batch(inputs, batch_size):
"""
Traite une liste d'entrées par lots.
"""
results = []
for i in range(0, len(inputs), batch_size):
batch = inputs[i:i + batch_size]
# Simuler un appel de modèle de calcul lourd
# En production, ce serait model(batch_tensor)
output = np.dot(batch, np.eye(10))
results.extend(output.tolist())
return results
def infer_with_batching(input_data, batch_size=32, timeout=0.1):
"""
Simulation simple de la logique de lot dynamique.
"""
start_time = time.time()
# Dans un système réel, vous utiliseriez une file d'attente et un thread de travail
# qui vérifie les nouveaux éléments jusqu'à ce que batch_size soit atteint ou que le délai expire.
if len(input_data) < batch_size:
# Rembourrer ou attendre si nécessaire
pass
return process_batch(input_data, batch_size)
# Exemple d'utilisation
raw_inputs = [np.random.rand(10) for _ in range(100)]
results = infer_with_batching(raw_inputs, batch_size=16)
Gestion des longueurs de séquence variables
L'un des plus grands défis de l'inférence par lots en TALN est que les séquences d'entrée ont des longueurs différentes. Rembourrer naïvement toutes les séquences à la longueur maximale du lot entraîne un calcul gaspillé sur les jetons de bourrage. Pour atténuer cela :
- Masques d'attention : Utilisez des masques d'attention pour indiquer au modèle d'ignorer les jetons de bourrage, en veillant à ce qu'ils n'affectent pas les logits de sortie.
- Lot trié : Triez les requêtes entrantes par longueur. Regrouper des longueurs similaires minimise le bourrage requis au sein d'un lot spécifique.
- Bourrage dynamique : Ne bourrez que jusqu'à la longueur maximale du lot actuel, et non la longueur maximale globale.
Conclusion
L'inférence par lots n'est pas seulement une optimisation des performances ; c'est une décision architecturale fondamentale pour une infrastructure IA évolutive. En ajustant soigneusement les tailles de lot, en implémentant une planification dynamique et en gérant les longueurs de séquence variables, vous pouvez réduire considérablement les coûts opérationnels tout en maintenant des profils de latence acceptables. À mesure que les modèles continuent de croître en taille, l'efficacité obtenue grâce à un lot intelligent ne fera que devenir plus critique pour maintenir les services IA réactifs et abordables.