Temario Lección 187 de 250 · Patrones de producción: reintentos, asincronía, streaming y memoria
Patrones de producción: reintentos, asincronía, streaming y memoria

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 n prompts y un límite de c, ejecutas ceil(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 results

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

Tu turno

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.