Paralelismus a souběžnost
Na této stránce
Čekat společně neznamená počítat společně
Volání API OpenAI je operace vázaná na vstup/výstup (I/O): tvůj program nedrtí čísla, ale čeká na odpověď ze sítě. Tato povaha diktuje výběr správného nástroje. Paralelismus ve smyslu víceprocesového zpracování (multiprocessing) rozděluje výpočty mezi více jader; stojí to jeden celý proces na jednotku práce a spuštění sta procesů, které všechny čekají na síť, je čistý plýtvání. Souběžnost, kterou poskytuje asyncio, umožňuje jednomu procesu obsluhovat stovky simultánních čekání s zanedbatelnými náklady. To je to, co maximalizuje propustnost tvých volání.
Rozdíl není jen akademický: tým, který paralelizuje svá volání LLM pomocí fondu procesů, spotřebuje několik gigabajtů paměti pro nulový zisk ve srovnání s několika řádky kódu využívajícího asyncio.
Spouštění souběžných volání
SDK poskytuje asynchronního klienta, AsyncOpenAI, jehož volání čekáš pomocí await. Shromáždění více korutin v asyncio.gather jim umožní všem postupovat současně, přičemž celková doba trvání se blíží době nejpomalejšího volání, nikoli jejich součtu.
import asyncio
import openai
client = openai.AsyncOpenAI()
async def single_call(prompt: str, model: str = "gpt-5.6-terra") -> str:
"""Jedno asynchronní volání API."""
response = await client.responses.create(
model=model,
input=prompt,
)
return response.output_text
async def concurrent_calls(prompts: list[str]) -> list[str]:
"""Spustí všechna volání souběžně."""
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"Chyba u promptu {i}: {result}")
return [r for r in results if not isinstance(r, Exception)]
Příznak return_exceptions=True je tím, co odlišuje prototyp od zpracování produkční kvality. Bez něj první výjimka přeruší gather a ty přijdeš o devadesát devět již získaných výsledků. S ním se chyby stanou hodnotami, které zkontroluješ, zaznamenáš do logu a podle potřeby zopakuješ.
Tato syrová verze má však okamžitou vadu: spuštění tisíce volání najednou během vteřin prorazí tvé limity rychlosti (rate limits). Semafor to řeší tím, že povolí pouze pevný počet simultánních volání, zatímco ostatní trpělivě čekají na svou řadu. Dvacet je rozumný výchozí bod, který je třeba upravit na základě skutečných kvót tvé organizace.
async def calls_with_limit(
prompts: list[str],
max_concurrency: int = 20,
) -> list[str]:
"""Omezí počet simultánních volání."""
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)
Vzor Map-Reduce aplikovaný na text
Dokument o dvou stech stranách nelze shrnout v jediném volání a jeho sekvenční krájení by trvalo minuty. Vzor map-reduce se zde přirozeně hodí: rozděl dokument na úseky, každý úsek souběžně shrň a poté požádej model o syntézu těchto shrnutí. Fáze map plně těží ze souběžnosti, zatímco fáze reduce je jediným voláním na text, který se stal krátkým.
async def map_reduce_summary(
document: str,
chunk_size: int = 3000,
) -> str:
"""Shrne dlouhý dokument pomocí paralelního map-reduce."""
# Fáze MAP: rozdělení a shrnutí paralelně
chunks = [
document[i:i + chunk_size]
for i in range(0, len(document), chunk_size)
]
map_prompts = [
f"Shrň tento úsek do 3 klíčových bodů:\n\n{chunk}"
for chunk in chunks
]
partial_summaries = await calls_with_limit(map_prompts, max_concurrency=10)
# Fáze REDUCE: kombinování shrnutí
summary_text = "\n\n---\n\n".join(
r for r in partial_summaries if isinstance(r, str)
)
final_summary = await single_call(
f"Syntetizuj tato částečná shrnutí do uceleného shrnutí "
f"o 5 klíčových bodech:\n\n{summary_text}"
)
return final_summary
Filtrování if isinstance(r, str) je stejně tak produktovým rozhodnutím jako technickou opatrností: znamená to, že finální syntéza bude vytvořena, i když tři úseky selžou, a to tiše. V závislosti na kontextu je to přesně to, co chceš, nebo je to nepřijatelné. Rozhodni se explicitně a v každém případě zaznamenej do logu počet ztracených úseků.
Kdy se víceprocesové zpracování znovu stává relevantním
Stále existují vzácné situace, kdy převezme kontrolu výpočet: náročné post-zpracování odpovědí, extrakce entit, bodování, strukturované parsování. Tato práce je vázaná na CPU a asyncio jí nic nepřinese. Elegantní kombinací je řetězení obou režimů v jediném pipeline: síťová volání ve souběžnosti, následovaná výpočty distribuovanými přes fond procesů pomocí run_in_executor.
import asyncio
from concurrent.futures import ProcessPoolExecutor
def heavy_post_processing(text: str) -> dict:
"""Zpracování náročné na CPU na výsledku (NLP, parsování atd.)."""
# Příklad: extrakce entit, bodování atd.
words = text.split()
return {
"word_count": len(words),
"unique_words": len(set(words)),
}
async def complete_pipeline(prompts: list[str]) -> list[dict]:
"""Pipeline: asynchronní volání LLM + paralelní post-zpracování na CPU."""
# Krok 1: souběžná volání LLM
llm_results = await calls_with_limit(prompts)
# Krok 2: paralelní post-zpracování (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
Ověř, zda výpočet skutečně ospravedlňuje použití fondu, než jej zavedeš: serializace dat do jiného procesu má svou cenu a pro zpracování trvající několik milisekund tato cena převyšuje zisk.
Ověření skutečné propustnosti
Ladění max_concurrency není hádání. Příliš nízká hodnota znamená, že necháváš propustnost ležet ladem; příliš vysoká spustí limity rychlosti, které tě stojí více času, než ušetří. Měř na své skutečné zátěži, měň hodnotu a sleduj jak propustnost, tak počet úspěchů – velmi rychlé pipeline, které selže u jednoho z pěti případů, není rychlé.
import time
async def benchmark_throughput(num_requests: int = 100):
"""Měří skutečnou propustnost tvého pipeline."""
prompts = [
f"Uveď zajímavý fakt číslo {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"Požadavky: {num_requests}")
print(f"Úspěchy: {successes}")
print(f"Doba trvání: {duration:.1f}s")
print(f"Propustnost: {successes / duration:.1f} req/s")
Klíčové poznatky
- Pro souběžnost I/O použij
AsyncOpenAIaasyncio.gather - Omez souběžnost pomocí semaforu, abys dodržel kvóty
- Vzor map-reduce paralelizuje zpracování dlouhých dokumentů
ProcessPoolExecutorsi rezervuj pro post-zpracování náročné na CPU