Paralelismo e Concorrência
Nesta página
Esperar em Conjunto Não é Computar em Conjunto
Uma chamada à API da OpenAI é uma operação limitada por E/S (I/O-bound): o seu programa não está a processar números, está à espera de uma resposta de rede. Esta natureza dita a ferramenta correta. O paralelismo, no sentido de multiprocessamento, distribui o cálculo por vários núcleos; custa um processo completo por unidade de trabalho, e executar cem processos que estão todos à espera da rede é um desperdício puro. A concorrência, fornecida pelo asyncio, permite que um único processo gestione centenas de esperas simultâneas com um custo negligenciável. É isto que maximiza a sua taxa de transferência de chamadas.
A distinção é mais do que académica: uma equipa que paralelize as suas chamadas de LLM com um pool de processos consumirá vários gigabytes de memória para zero ganho, comparado com algumas linhas de asyncio.
Lançamento de Chamadas Concorrentes
O SDK expõe um cliente assíncrono, AsyncOpenAI, cujas chamadas aguardam com await. Agrupar múltiplas corrotinas num asyncio.gather permite que todas progridam simultaneamente, com a duração total a aproximar-se da chamada mais lenta, em vez da soma de todas.
import asyncio
import openai
client = openai.AsyncOpenAI()
async def single_call(prompt: str, model: str = "gpt-5.6-terra") -> str:
"""Uma única chamada assíncrona à API."""
response = await client.responses.create(
model=model,
input=prompt,
)
return response.output_text
async def concurrent_calls(prompts: list[str]) -> list[str]:
"""Lança todas as chamadas concorrentemente."""
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"Erro no prompt {i}: {result}")
return [r for r in results if not isinstance(r, Exception)]
A flag return_exceptions=True é o que distingue um protótipo de um processamento de nível de produção. Sem ela, a primeira exceção interrompe o gather e perde os noventa e nove resultados já obtidos. Com ela, os erros tornam-se valores que inspeciona, regista e volta a tentar ao seu próprio ritmo.
No entanto, esta versão crua tem uma falha imediata: lançar mil chamadas de uma vez fará estourar os seus limites de taxa em segundos. Um semáforo resolve isto, permitindo apenas um número fixo de chamadas simultâneas, ficando o resto à espera pacientemente pela sua vez. Vinte é um ponto de partida razoável, a ajustar com base nas quotas reais da sua organização.
async def calls_with_limit(
prompts: list[str],
max_concurrency: int = 20,
) -> list[str]:
"""Limita o número de chamadas 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)
O Padrão Map-Reduce Aplicado a Texto
Um documento de duzentas páginas não pode ser resumido numa única chamada, e fatiá-lo sequencialmente levaria minutos. O padrão map-reduce aplica-se naturalmente aqui: divida em blocos, resuma cada bloco concorrentemente e peça depois ao modelo uma síntese dos resumos. A fase de map beneficia totalmente da concorrência, enquanto a fase de reduce é uma única chamada sobre texto que se tornou curto.
async def map_reduce_summary(
document: str,
chunk_size: int = 3000,
) -> str:
"""Resume um documento longo via map-reduce paralelo."""
# Fase MAP: dividir e resumir em paralelo
chunks = [
document[i:i + chunk_size]
for i in range(0, len(document), chunk_size)
]
map_prompts = [
f"Resuma esta passagem em 3 pontos-chave:\n\n{chunk}"
for chunk in chunks
]
partial_summaries = await calls_with_limit(map_prompts, max_concurrency=10)
# Fase REDUCE: combinar resumos
summary_text = "\n\n---\n\n".join(
r for r in partial_summaries if isinstance(r, str)
)
final_summary = await single_call(
f"Sintetize estes resumos parciais num resumo coerente "
f"de 5 pontos-chave:\n\n{summary_text}"
)
return final_summary
A filtragem if isinstance(r, str) é tanto uma decisão de produto como uma precaução técnica: significa que a síntese final será produzida mesmo que três blocos tenham falhado silenciosamente. Dependendo do contexto, é exatamente o que deseja, ou é inaceitável. Decida explicitamente e registe, em qualquer caso, o número de blocos perdidos.
Quando o Multiprocessamento Volta a Ser Relevante
Restam situações raras onde o cálculo retoma o controlo: pós-processamento pesado nas respostas, extração de entidades, pontuação, análise estruturada. Este trabalho é limitado pela CPU e não ganha nada com o asyncio. A combinação elegante é encadear os dois regimes num único pipeline: chamadas de rede em concorrência, depois cálculo distribuído por um pool de processos via run_in_executor.
import asyncio
from concurrent.futures import ProcessPoolExecutor
def heavy_post_processing(text: str) -> dict:
"""Processamento limitado pela CPU no resultado (NLP, análise, etc.)."""
# Exemplo: extração de entidades, pontuação, etc.
words = text.split()
return {
"word_count": len(words),
"unique_words": len(set(words)),
}
async def complete_pipeline(prompts: list[str]) -> list[dict]:
"""Pipeline: chamadas assíncronas de LLM + pós-processamento paralelo na CPU."""
# Passo 1: chamadas concorrentes de LLM
llm_results = await calls_with_limit(prompts)
# Passo 2: pós-processamento 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
Verifique se o cálculo justifica verdadeiramente o pool antes de o introduzir: serializar dados para outro processo tem um custo e, para tratamentos que duram alguns milissegundos, este custo excede o ganho.
Verificação da Taxa de Transferência Real
Ajustar o max_concurrency não é um palpite. Muito baixo e deixa taxa de transferência na mesa; muito alto e dispara limites de taxa que lhe custam mais tempo do que poupam. Meça na sua carga real, variando o valor, e observe tanto a taxa de transferência como a contagem de sucessos — um pipeline muito rápido que falha uma em cada cinco vezes não é rápido.
import time
async def benchmark_throughput(num_requests: int = 100):
"""Mede a taxa de transferência real do seu pipeline."""
prompts = [
f"Dê um facto interessante 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"Pedidos: {num_requests}")
print(f"Sucessos: {successes}")
print(f"Duração: {duration:.1f}s")
print(f"Taxa de transferência: {successes / duration:.1f} req/s")
Pontos-chave
- Utilize
AsyncOpenAIeasyncio.gatherpara concorrência de E/S - Limite a concorrência com um semáforo para respeitar as quotas
- O padrão map-reduce paraleliza o processamento de documentos longos
- Reserve
ProcessPoolExecutorpara pós-processamento intensivo na CPU