Programme Leçon 187 sur 250 · Schémas de production : nouvelles tentatives, async, streaming et mémoire
Schémas de production : nouvelles tentatives, async, streaming et mémoire

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 n prompts et un plafond de c, tu lances ceil(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 results

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

À ton tour

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