Paralelizam i konkurentnost
Na ovoj stranici
Čekanje zajedno nije računanje zajedno
Poziv OpenAI API-ju operacija je vezana uz ulaz/izlaz (I/O): tvoj program ne melje brojeve, već čeka odgovor mreže. Ta priroda diktira pravi alat. Paralelizam, u smislu višeprocesnosti, distribuira računanje na više jezgri; košta puni proces po jedinici posla, a pokretanje stotinu procesa koji svi čekaju mrežu čista je rasipnost. Konkurentnost, koju pruža asyncio, omogućuje jednom procesu da istovremeno upravlja stotinama simultanog čekanja uz zanemariv trošak. To je ono što maksimizira tvoju propusnost poziva.
Razlika je više od akademske: tim koji paralelizira svoje LLM pozive s bazenom procesa potrošit će nekoliko gigabajta memorije za nulti dobitak u usporedbi s nekoliko redaka asyncio.
Pokretanje konkurentnih poziva
SDK izlaže asinkroni klijent, AsyncOpenAI, čiji se pozivi čekaju s await. Grupiranje više korutina u asyncio.gather omogućuje im da sve napreduju istovremeno, pri čemu se ukupno trajanje približava trajanju najsporijeg poziva, a ne njihovom zbroju.
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 ono što razlikuje prototip od obrade razine produkcije. Bez nje, prva iznimka prekida gather i gubiš devedeset i devet već dobivenih rezultata. S njom, pogreške postaju vrijednosti koje inspektiraš, bilježiš i ponavljaš po vlastitom tempu.
Međutim, ova sirova verzija ima trenutni nedostatak: pokretanje tisuću poziva odjednom probit će tvoja ograničenja brzine (rate limits) u nekoliko sekundi. Semaforski mehanizam rješava to dopuštajući samo fiksan broj simultanih poziva, dok ostali strpljivo čekaju svoj red. Dvadeset je razumna početna točka, koju trebaš prilagoditi na temelju stvarnih kvota 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)
Uzorak Map-Reduce primijenjen na tekst
Dokument od dvjesto stranica ne može se sažeti u jednom pozivu, a njegovo sekvencijalno rezanje trajalo bi minutama. Uzorak map-reduce ovdje se prirodno primjenjuje: podijeli na dijelove, sažmi svaki dio konkurentno, zatim zatraži od modela sintezu tih sažetaka. Faza mapiranja u potpunosti koristi prednosti konkurentnosti, dok je faza redukcije jedan poziv na tekstu koji je postao kratak.
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) jednako je odluka o proizvodu koliko i tehnički oprez: to znači da će se konačna sinteza proizvesti čak i ako su tri dijela tiho propala. Ovisno o kontekstu, to je točno ono što želiš, ili je neprihvatljivo. Odluči eksplicitno i u svakom slučaju zabilježi broj izgubljenih dijelova.
Kada višeprocesnost ponovno postaje relevantna
Ostaju rijetke situacije u kojima računanje ponovno preuzima kontrolu: teška post-obrada odgovora, ekstrakcija entiteta, bodovanje, strukturirano parsiranje. Taj je posao vezan uz CPU i ne dobiva ništa od asyncio. Elegantna kombinacija je lančanje ta dva režima u jednom cjevovodu: mrežni pozivi u konkurentnosti, zatim računanje distribuirano kroz bazen procesa putem 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
Provjeri opravdava li računanje uvođenje bazena prije nego ga uvedeš: serializacija podataka u drugi proces ima trošak, a za obrade koje traju nekoliko milisekundi taj trošak nadmašuje dobit.
Provjera stvarne propusnosti
Ugađanje max_concurrency nije nagađanje. Premalo i ostavljaš propusnost na stolu; previše i okidaš ograničenja brzine koja te koštaju više vremena nego što štede. Mjeri na svom stvarnom opterećenju, varirajući vrijednost, i gledaj i propusnost i broj uspjeha – vrlo brz cjevovod koji faila jedan od pet puta nije brz.
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 točke
- Koristi
AsyncOpenAIiasyncio.gatherza I/O konkurentnost - Ograniči konkurentnost semaforom kako bi poštovao kvote
- Uzorak map-reduce paralelizira obradu dugih dokumenata
- Rezerviraj
ProcessPoolExecutorza post-obradu intenzivnu za CPU