Appels concurrents par lots (parallélisme borné)
Quand il te faut des réponses pour mille prompts, appeler le modèle un par un en attendant chaque réponse est terriblement lent. Les vraies applis lancent beaucoup de requêtes en même temps -> mais pas sans limite : chaque fournisseur plafonne le nombre d'appels en cours qu'il accepte, donc tu traites le travail par lots de taille fixe. Deux faits rendent la concurrence délicate, et les deux apparaissent ici.
- Les résultats reviennent dans le désordre. Un prompt court peut finir avant un long envoyé en premier. Ton code doit remettre les réponses dans l'ordre de leur position d'entrée d'origine, pas selon qui a fini en premier.
- Le débit est borné par le plafond. Avec
nprompts et un plafond dec, tu lancesceil(n / c)lots -> le chiffre autour duquel se construit tout plan de capacité.
Une version de production utiliserait asyncio et un vrai client réseau. Pour que cette première version reste facile à suivre, tu modélises la même forme avec des fonctions simples et une boucle d'ordonnancement -> pas de boucle d'événements, pas de réseau, pas de vrai modèle. Voici la vraie forme, pour référence, la même logique avec une vraie boucle d'événements :
import asyncio
async def run_batch(prompts, worker, cap=4):
sem = asyncio.Semaphore(cap) # the concurrency cap
async def one(i):
async with sem: # at most cap in flight
return i, await worker(prompts[i])
pairs = await asyncio.gather(*(one(i) for i in range(len(prompts))))
results = [None] * len(prompts)
for i, r in pairs: # reassemble by ORIGINAL index
results[i] = r["result"]
return resultsUn Semaphore impose le plafond, gather lance les appels ensemble, et tu réécris quand même chaque réponse dans sa case d'origine. Remarque une différence avec les lots que tu vas construire : avec un sémaphore, un nouvel appel démarre dès qu'un appel finit, donc il y en a toujours jusqu'à cap en cours, alors que des lots fixes attendent l'appel le plus lent de chaque lot avant de lancer le suivant. La version à sémaphore est plus rapide ; les lots sont plus simples à raisonner. Le code async peut aussi se tester (avec asyncio.run et de faux workers) ; ici tu construis la version par lots avec un simple ordonnanceur pour que la logique reste visible. Un worker(prompt) remplace l'appel au modèle et renvoie {"result": ..., "cost": ...}, où cost représente le temps que prendrait cet élément. Tu ordonnances volontairement chaque lot dans un ordre de coût différent pour prouver que l'assemblage des résultats n'en dépend pas en douce.
for start in range(0, len(prompts), cap):
window = range(start, min(start + cap, len(prompts)))
# work the window in ANY order, but write results[i] = worker(prompts[i])["result"]
...Construis run_batch(prompts, worker, cap=4). Applique worker à chaque prompt par lots de taille cap, et renvoie {"results": [...], "batches": n_batches} où results[i] est le résultat du worker pour prompts[i] (ordre d'entrée conservé) et batches vaut ceil(len(prompts) / cap). Une liste de prompts vide lance zéro lot.
Écris run_batch(prompts, worker, cap=4) qui applique un worker (simulé) à chaque prompt par lots de cap et renvoie {"results", "batches"}. results doit être dans l'ordre d'ENTRÉE même si chaque élément a un cost différent selon lequel tu peux ordonnancer ; batches vaut ceil(len(prompts) / cap). Utilise des fonctions simples et une boucle d'ordonnancement -> pas d'asyncio, pas de réseau. Un deuxième jeu d'entrées distinct doit donner des résultats différents ; une liste vide lance zéro lot.
Tu as repéré un problème dans cette leçon ? Signale-le · Pose une question sur cette leçon
Cet exercice s'ouvre bientôt
Termine la leçon précédente pour débloquer celle-ci. Tout le cours est gratuit, aucun compte n'est requis, et tu peux lire cette leçon dès maintenant.
Ce navigateur bloque les cookies pour learn.floati.life, donc les leçons que tu as terminées ici ne peuvent pas s'ouvrir dans l'ordre. Autorise les cookies pour ce site et recharge la page.