Llamadas concurrentes por lotes (reparto acotado)
Cuando necesitas respuestas para mil prompts, llamar al modelo de uno en uno y esperar cada respuesta es desesperadamente lento. Las aplicaciones reales lanzan muchas peticiones a la vez -> pero no sin límite: cada proveedor limita cuántas llamadas en curso permite, así que procesas el trabajo en lotes de tamaño fijo. Dos hechos complican la concurrencia, y los dos aparecen aquí.
- Los resultados vuelven desordenados. Un prompt corto puede terminar antes que uno largo que enviaste primero. Tu código debe volver a montar las respuestas según su posición original en la entrada, no según quién terminó primero.
- El rendimiento está acotado por el límite. Con
nprompts y un límite dec, ejecutasceil(n / c)lotes -> el número sobre el que se construye todo plan de capacidad.
Una versión de producción usaría asyncio y un cliente de red real. Para que esta primera versión sea fácil de seguir, modelas la misma forma con funciones simples y un bucle de planificación -> sin bucle de eventos, sin red, sin modelo real. Aquí tienes la forma real, como referencia, con la misma lógica y un bucle de eventos en marcha:
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 impone el límite, gather ejecuta las llamadas juntas, y aun así escribes cada respuesta en su casilla original. Fíjate en una diferencia con los lotes que vas a construir: con un semáforo, una llamada nueva empieza en cuanto termina cualquier otra, así que siempre hay hasta cap en curso, mientras que los lotes fijos esperan a la llamada más lenta de cada lote antes de empezar el siguiente. La versión con semáforo es más rápida; los lotes son más fáciles de razonar. El código asíncrono también se puede probar (con asyncio.run y trabajadores simulados); aquí construyes la versión por lotes con un planificador simple para que la lógica quede a la vista. Un worker(prompt) sustituye a la llamada al modelo y devuelve {"result": ..., "cost": ...}, donde cost representa cuánto tardaría ese elemento. Planificas a propósito cada lote en un orden de coste distinto para demostrar que el montaje de tus resultados no depende de él en secreto.
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"]
...Construye run_batch(prompts, worker, cap=4). Aplica worker a cada prompt en lotes de tamaño cap y devuelve {"results": [...], "batches": n_batches}, donde results[i] es el resultado del trabajador para prompts[i] (conservando el orden de entrada) y batches es ceil(len(prompts) / cap). Una lista de prompts vacía ejecuta cero lotes.
Escribe run_batch(prompts, worker, cap=4), que aplique un worker (simulado) a cada prompt en lotes de cap y devuelva {"results", "batches"}. results debe estar en el orden de ENTRADA aunque cada elemento lleve un cost distinto según el que puedes planificar; batches es ceil(len(prompts) / cap). Usa funciones simples y un bucle de planificación -> sin asyncio, sin red. Un segundo conjunto de entradas distinto debe dar resultados distintos; una lista vacía ejecuta cero lotes.
¿Has visto un problema en esta lección? Avísanos · Preguntar sobre esta lección
Este ejercicio se abre pronto
Termina la lección anterior y esta se desbloquea. Todo el curso es gratis, no hace falta cuenta, y puedes leer esta lección ahora mismo.
Este navegador está bloqueando las cookies de learn.floati.life, así que las lecciones que terminaste aquí no se pueden abrir en orden. Permite las cookies de este sitio y recarga.