Vzporednost in sočasnost
Na tej strani
Čakanje skupaj ni računanje skupaj
Klic API-ja OpenAI je operacija, omejena z vhodom/izhodom (I/O): tvoj program ne melje števil, ampak čaka na omrežni odgovor. Ta narava narekuje pravo orodje. Vzporednost v smislu večprocesnosti (multiprocessing) porazdeli računanje med več jeder; stane celoten proces na enoto dela, in zagon sto procesov, ki vsi čakajo na omrežje, je čista zapravljenost. Sočasnost, kot jo ponuja asyncio, omogoča enemu samemu procesu, da hkrati upravlja na stotine sočasnih čakanj z zanemarljivimi stroški. To je tisto, kar maksimira tvojo prepustnost klicev.
Razlika ni le akademska: ekipa, ki paralelizira svoje klice LLM s procesnim bazenom, bo porabila več gigabajtov pomnilnika brez kakršnega koli dobička v primerjavi z nekaj vrsticami kode asyncio.
Zagon sočasnih klicev
SDK razkriva asinhroni odjemalec AsyncOpenAI, katerega klici čakajo z ukazom await. Zbiranje več korutin v asyncio.gather jim omogoča, da vse napredujejo hkrati, pri čemer se skupno trajanje približa trajanju najpočasnejšega klica in ne vsoti vseh.
import asyncio
import openai
client = openai.AsyncOpenAI()
async def single_call(prompt: str, model: str = "gpt-5.6-terra") -> str:
"""A single asynchronous API call."""
response = await client.responses.create(
model=model,
input=prompt,
)
return response.output_text
async def concurrent_calls(prompts: list[str]) -> list[str]:
"""Launches all calls concurrently."""
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 on prompt {i}: {result}")
return [r for r in results if not isinstance(r, Exception)]
Zastavica return_exceptions=True je tista, ki loči prototip od obdelave, primerne za proizvodno okolje. Brez nje prva izjema prekine gather in izgubiš devetindevetdeset že pridobljenih rezultatov. Z njo napake postanejo vrednosti, ki jih pregledaš, zabeležiš in ponovno poskusiš po svojem tempu.
Vendar ima ta surova različica takojšnjo pomanjkljivost: zagon tisoč klicev hkrati bo v nekaj sekundah presegel tvoje omejitve hitrosti (rate limits). Semaforski mehanizem to reši tako, da dovoli le določeno število sočasnih klicev, ostali pa potrpežljivo čakajo na svojo vrsto. Dvajset je razumna začetna vrednost, ki jo prilagodiš glede na dejanske kvote tvoje organizacije.
async def calls_with_limit(
prompts: list[str],
max_concurrency: int = 20,
) -> list[str]:
"""Limits the number of simultaneous calls."""
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)
Vzorec Map-Reduce, uporabljen za besedilo
Dvesto strani dolgega dokumenta ni mogoče povzeti v enem samem klicu, zaporedno rezanje pa bi trajalo minute. Vzorec map-reduce se tu naravno uporabi: razdeli na dele, vsak del povzemi sočasno, nato pa model prosi za sintezo povzetkov. Faza map v celoti izkorišča sočasnost, medtem ko je faza reduce en sam klic na besedilu, ki je postalo kratko.
async def map_reduce_summary(
document: str,
chunk_size: int = 3000,
) -> str:
"""Summarizes a long document via parallel map-reduce."""
# Phase MAP: split and summarize in parallel
chunks = [
document[i:i + chunk_size]
for i in range(0, len(document), chunk_size)
]
map_prompts = [
f"Summarize this passage in 3 key points:\n\n{chunk}"
for chunk in chunks
]
partial_summaries = await calls_with_limit(map_prompts, max_concurrency=10)
# Phase REDUCE: combine summaries
summary_text = "\n\n---\n\n".join(
r for r in partial_summaries if isinstance(r, str)
)
final_summary = await single_call(
f"Synthesize these partial summaries into a coherent summary "
f"of 5 key points:\n\n{summary_text}"
)
return final_summary
Filtriranje if isinstance(r, str) je enako odločitev o izdelku kot tehnični previdnostni ukrep: pomeni, da bo končna sinteza izdelana, tudi če so trije deli tiho odpovedali. Glede na kontekst je to točno tisto, kar želiš, ali pa je nesprejemljivo. Odloči se eksplicitno in v vsakem primeru zabeleži število izgubljenih delov.
Kdaj večprocesnost spet postane relevantna
Obstajajo redki primeri, ko računanje ponovno prevzame nadzor: obsežna naknadna obdelava odgovorov, ekstrakcija entitet, ocenjevanje, strukturirano razčlenjevanje. To delo je omejeno s procesorjem (CPU-bound) in od asyncio nima nobene koristi. Elegantna kombinacija je združitev obeh režimov v enem samem cevovodu: omrežni klici v sočasnosti, nato pa računanje, porazdeljeno med procesni bazen prek run_in_executor.
import asyncio
from concurrent.futures import ProcessPoolExecutor
def heavy_post_processing(text: str) -> dict:
"""CPU-bound processing on the result (NLP, parsing, etc.)."""
# Example: entity extraction, scoring, etc.
words = text.split()
return {
"word_count": len(words),
"unique_words": len(set(words)),
}
async def complete_pipeline(prompts: list[str]) -> list[dict]:
"""Pipeline: async LLM calls + parallel CPU post-processing."""
# Step 1: concurrent LLM calls
llm_results = await calls_with_limit(prompts)
# Step 2: parallel post-processing (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
Preden uvedeš bazen, preveri, ali računanje to res upravičuje: serializacija podatkov v drug proces ima svojo ceno in za obdelave, ki trajajo nekaj milisekund, ta cena preseže dobiček.
Preverjanje dejanske prepustnosti
Uglaševanje max_concurrency ni ugibanje. Premajhna vrednost pusti prepustnost neizkoriščeno; previsoka sproži omejitve hitrosti, ki te stanejo več časa, kot ga prihranijo. Meri na svoji dejanski obremenitvi z variiranjem vrednosti in glej tako prepustnost kot število uspehov – zelo hiter cevovod, ki odpove pri enem od petih klicev, ni hiter.
import time
async def benchmark_throughput(num_requests: int = 100):
"""Measures the real throughput of your pipeline."""
prompts = [
f"Give an interesting fact number {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"Requests: {num_requests}")
print(f"Successes: {successes}")
print(f"Duration: {duration:.1f}s")
print(f"Throughput: {successes / duration:.1f} req/s")
Ključne ugotovitve
- Za sočasnost I/O uporabi
AsyncOpenAIinasyncio.gather - Omeji sočasnost s semaforjem, da spoštuješ kvote
- Vzorec map-reduce paralelizira obdelavo dolgih dokumentov
ProcessPoolExecutorrezerviraj za naknadno obdelavo, ki zahteva veliko procesorske moči