Ir al contenido principal
Español— Elegir un idioma
Menú

Paralelismo y concurrencia

Lección 8 de 20 Actualizado el 28 de julio de 2026 Avanzado
En esta página
  1. Esperar juntos no es computar juntos
  2. Lanzamiento de llamadas concurrentes
  3. El patrón Map-Reduce aplicado al texto
  4. Cuándo vuelve a ser relevante el multiproceso
  5. Verificación del rendimiento real
  6. Puntos clave

Esperar juntos no es computar juntos

Una llamada a la API de OpenAI es una operación limitada por E/S: tu programa no está procesando números, está esperando una respuesta de red. Esta naturaleza dicta la herramienta adecuada. El paralelismo, en el sentido de multiproceso, distribuye el cómputo entre varios núcleos; cuesta un proceso completo por unidad de trabajo, y ejecutar cien procesos que están todos esperando a la red es un desperdicio absoluto. La concurrencia, tal como la proporciona asyncio, permite que un único proceso gestione cientos de esperas simultáneas con un coste insignificante. Esto es lo que maximiza tu rendimiento de llamadas.

La distinción es más que académica: un equipo que paraleliza sus llamadas al LLM con un pool de procesos consumirá varios gigabytes de memoria para obtener cero ventajas frente a unas pocas líneas de asyncio.

Lanzamiento de llamadas concurrentes

El SDK expone un cliente asíncrono, AsyncOpenAI, cuyas llamadas se esperan con await. Agrupar múltiples corrutinas en un asyncio.gather permite que todas progresen simultáneamente, haciendo que la duración total se aproxime a la de la llamada más lenta en lugar de a la suma de todas.

import asyncio
import openai

client = openai.AsyncOpenAI()

async def single_call(prompt: str, model: str = "gpt-5.6-terra") -> str:
    """Una única llamada asíncrona a la API."""
    response = await client.responses.create(
        model=model,
        input=prompt,
    )
    return response.output_text

async def concurrent_calls(prompts: list[str]) -> list[str]:
    """Lanza todas las llamadas de forma concurrente."""
    tasks = [single_call(prompt) for prompt in prompts]
    results = await asyncio.gather(*tasks, return_exceptions=True)

    for i, result in enumerate(results):
        if isinstance(result, Exception):
            print(f"Error en el prompt {i}: {result}")

    return [r for r in results if not isinstance(r, Exception)]

La bandera return_exceptions=True es lo que distingue un prototipo de un procesamiento de grado productivo. Sin ella, la primera excepción interrumpe el gather y pierdes los noventa y nueve resultados ya obtenidos. Con ella, los errores se convierten en valores que inspeccionas, registras y reintentas a tu propio ritmo.

Sin embargo, esta versión cruda tiene un fallo inmediato: lanzar mil llamadas de golpe superará tus límites de tasa en segundos. Un semáforo resuelve esto permitiendo solo un número fijo de llamadas simultáneas, mientras el resto espera pacientemente su turno. Veinte es un punto de partida razonable, que deberás ajustar según las cuotas reales de tu organización.

async def calls_with_limit(
    prompts: list[str],
    max_concurrency: int = 20,
) -> list[str]:
    """Limita el número de llamadas simultáneas."""
    semaphore = asyncio.Semaphore(max_concurrency)

    async def limited_call(prompt: str) -> str:
        async with semaphore:
            return await single_call(prompt)

    tasks = [limited_call(prompt) for prompt in prompts]
    return await asyncio.gather(*tasks, return_exceptions=True)

El patrón Map-Reduce aplicado al texto

Un documento de doscientas páginas no puede resumirse en una única llamada, y dividirlo secuencialmente llevaría minutos. El patrón map-reduce se aplica aquí de forma natural: divide en fragmentos, resume cada fragmento concurrentemente y luego pide al modelo una síntesis de los resúmenes. La fase de map se beneficia plenamente de la concurrencia, mientras que la fase de reduce es una única llamada sobre un texto que se ha vuelto corto.

async def map_reduce_summary(
    document: str,
    chunk_size: int = 3000,
) -> str:
    """Resume un documento largo mediante map-reduce paralelo."""

    # Fase MAP: dividir y resumir en paralelo
    chunks = [
        document[i:i + chunk_size]
        for i in range(0, len(document), chunk_size)
    ]

    map_prompts = [
        f"Resume este pasaje en 3 puntos clave:\n\n{chunk}"
        for chunk in chunks
    ]

    partial_summaries = await calls_with_limit(map_prompts, max_concurrency=10)

    # Fase REDUCE: combinar resúmenes
    summary_text = "\n\n---\n\n".join(
        r for r in partial_summaries if isinstance(r, str)
    )

    final_summary = await single_call(
        f"Sintetiza estos resúmenes parciales en un resumen coherente "
        f"de 5 puntos clave:\n\n{summary_text}"
    )

    return final_summary

El filtrado if isinstance(r, str) es tanto una decisión de producto como una precaución técnica: significa que la síntesis final se producirá incluso si tres fragmentos han fallado en silencio. Dependiendo del contexto, esto es exactamente lo que quieres, o es inaceptable. Decídelo explícitamente y, en cualquier caso, registra el número de fragmentos perdidos.

Cuándo vuelve a ser relevante el multiproceso

Siguen existiendo situaciones raras donde el cómputo retoma el control: postprocesamiento pesado sobre respuestas, extracción de entidades, puntuación, análisis estructurado. Este trabajo está limitado por la CPU y no gana nada con asyncio. La combinación elegante es encadenar los dos regímenes en una única tubería: llamadas de red en concurrencia y luego cómputo distribuido a través de un pool de procesos mediante run_in_executor.

import asyncio
from concurrent.futures import ProcessPoolExecutor

def heavy_post_processing(text: str) -> dict:
    """Procesamiento limitado por CPU sobre el resultado (NLP, análisis, etc.)."""
    # Ejemplo: extracción de entidades, puntuación, etc.
    words = text.split()
    return {
        "word_count": len(words),
        "unique_words": len(set(words)),
    }

async def complete_pipeline(prompts: list[str]) -> list[dict]:
    """Tubería: llamadas asíncronas al LLM + postprocesamiento paralelo en CPU."""
    # Paso 1: llamadas concurrentes al LLM
    llm_results = await calls_with_limit(prompts)

    # Paso 2: postprocesamiento paralelo (CPU)
    loop = asyncio.get_event_loop()
    with ProcessPoolExecutor(max_workers=4) as pool:
        tasks = [
            loop.run_in_executor(pool, heavy_post_processing, r)
            for r in llm_results
            if isinstance(r, str)
        ]
        final_results = await asyncio.gather(*tasks)

    return final_results

Verifica que el cómputo justifique realmente el pool antes de introducirlo: serializar datos hacia otro proceso tiene un coste, y para tratamientos que duran unos pocos milisegundos este coste supera la ganancia.

Verificación del rendimiento real

Ajustar max_concurrency no es cuestión de adivinar. Si es demasiado bajo, dejarás rendimiento sobre la mesa; si es demasiado alto, activarás límites de tasa que te costarán más tiempo del que ahorran. Mide con tu carga real, variando el valor, y observa tanto el rendimiento como el recuento de éxitos: una tubería muy rápida que falla una de cada cinco veces no es rápida.

import time

async def benchmark_throughput(num_requests: int = 100):
    """Mide el rendimiento real de tu tubería."""
    prompts = [
        f"Da un dato interesante número {i}."
        for i in range(num_requests)
    ]

    start = time.perf_counter()
    results = await calls_with_limit(prompts, max_concurrency=20)
    duration = time.perf_counter() - start

    successes = sum(1 for r in results if isinstance(r, str))
    print(f"Solicitudes: {num_requests}")
    print(f"Aciertos: {successes}")
    print(f"Duración: {duration:.1f}s")
    print(f"Rendimiento: {successes / duration:.1f} req/s")

Puntos clave

  • Usa AsyncOpenAI y asyncio.gather para la concurrencia de E/S
  • Limita la concurrencia con un semáforo para respetar las cuotas
  • El patrón map-reduce paraleliza el procesamiento de documentos largos
  • Reserva ProcessPoolExecutor para el postprocesamiento intensivo en CPU