Parallelisme en concurrentie
Op deze pagina
Samen wachten is niet samen rekenen
Een API-aanroep naar OpenAI is een I/O-gebonden bewerking: uw programma rekent geen getallen uit, maar wacht op een netwerkrespons. Deze aard bepaalt welk gereedschap u moet kiezen. Parallelisme, in de zin van multiprocessen, verdeelt berekeningen over meerdere kernen; het kost een volledig proces per werkseenheid, en honderd processen draaien die allemaal op het netwerk wachten, is pure verspilling. Concurrentie, zoals geboden door asyncio, stelt één proces in staat om honderden gelijktijdige wachttijden tegen verwaarloosbare kosten af te handelen. Dit maximaliseert uw doorvoer van aanroepen.
Het onderscheid is meer dan academisch: een team dat zijn LLM-aanroepen paralleliseert met een process-pool, verbruikt enkele gigabytes geheugen voor nul winst in vergelijking met een paar regels asyncio.
Gelijktijdige aanroepen starten
De SDK biedt een asynchrone client, AsyncOpenAI, waarvan de aanroepen worden afgewacht met await. Door meerdere coroutines te verzamelen in een asyncio.gather, kunnen ze allemaal gelijktijdig vorderen, waarbij de totale duur de langzaamste aanroep benadert in plaats van hun som.
import asyncio
import openai
client = openai.AsyncOpenAI()
async def single_call(prompt: str, model: str = "gpt-5.6-terra") -> str:
"""Een enkele asynchrone API-aanroep."""
response = await client.responses.create(
model=model,
input=prompt,
)
return response.output_text
async def concurrent_calls(prompts: list[str]) -> list[str]:
"""Start alle aanroepen gelijktijdig."""
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"Fout bij prompt {i}: {result}")
return [r for r in results if not isinstance(r, Exception)]
De vlag return_exceptions=True is wat een prototype onderscheidt van verwerkingscode voor productieomgevingen. Zonder deze vlag onderbreekt de eerste uitzondering de gather en verliest u de negenennegentig reeds verkregen resultaten. Met deze vlag worden fouten waarden die u inspecteert, logt en op uw eigen tempo opnieuw probeert.
Deze ruwe versie heeft echter een onmiddellijk gebrek: duizend aanroepen tegelijk starten, zal uw tarieflimieten binnen seconden overschrijden. Een semafoor lost dit op door slechts een vast aantal gelijktijdige aanroepen toe te staan, terwijl de rest geduldig wacht op zijn beurt. Twintig is een redelijk startpunt, dat u kunt aanpassen op basis van de daadwerkelijke quota van uw organisatie.
async def calls_with_limit(
prompts: list[str],
max_concurrency: int = 20,
) -> list[str]:
"""Beperkt het aantal gelijktijdige aanroepen."""
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)
Het map-reduce-patroon toegepast op tekst
Een document van tweehonderd pagina’s kan niet in één enkele aanroep worden samengevat, en het sequentieel in stukken snijden zou minuten duren. Het map-reduce-patroon past hier natuurlijk: splits in brokken, vat elke brok gelijktijdig samen, en vraag het model vervolgens om een synthese van de samenvattingen. De map-fase profiteert volledig van concurrentie, terwijl de reduce-fase een enkele aanroep is op tekst die kort is geworden.
async def map_reduce_summary(
document: str,
chunk_size: int = 3000,
) -> str:
"""Vat een lang document samen via parallelle map-reduce."""
# Fase MAP: splits en vat samen parallel
chunks = [
document[i:i + chunk_size]
for i in range(0, len(document), chunk_size)
]
map_prompts = [
f"Vat deze passage samen in 3 kernpunten:\n\n{chunk}"
for chunk in chunks
]
partial_summaries = await calls_with_limit(map_prompts, max_concurrency=10)
# Fase REDUCE: combineer samenvattingen
summary_text = "\n\n---\n\n".join(
r for r in partial_summaries if isinstance(r, str)
)
final_summary = await single_call(
f"Synthetiseer deze deelsamenvattingen tot een coherente samenvatting "
f"van 5 kernpunten:\n\n{summary_text}"
)
return final_summary
Het filteren met if isinstance(r, str) is net zozeer een productbeslissing als een technische voorzorgsmaatregel: het betekent dat de uiteindelijke synthese wordt geproduceerd, zelfs als drie brokken stilzwijgend zijn mislukt. Afhankelijk van de context is dit precies wat u wilt, of is het onaanvaardbaar. Beslis hier expliciet over en log in elk geval het aantal verloren brokken.
Wanneer multiprocessen weer relevant worden
Er blijven zeldzame situaties waarin berekening weer de controle overneemt: zware nabewerking van responsen, entity-extractie, scoring, gestructureerd parseren. Dit werk is CPU-gebonden en heeft niets aan asyncio. De elegante combinatie is om de twee regimes in één enkele pipeline te ketenen: netwerkaanroepen via concurrentie, gevolgd door berekening verdeeld over een process-pool via run_in_executor.
import asyncio
from concurrent.futures import ProcessPoolExecutor
def heavy_post_processing(text: str) -> dict:
"""CPU-gebonden verwerking van het resultaat (NLP, parseren, enz.)."""
# Voorbeeld: entity-extractie, scoring, enz.
words = text.split()
return {
"word_count": len(words),
"unique_words": len(set(words)),
}
async def complete_pipeline(prompts: list[str]) -> list[dict]:
"""Pipeline: asynchrone LLM-aanroepen + parallelle CPU-nabewerking."""
# Stap 1: gelijktijdige LLM-aanroepen
llm_results = await calls_with_limit(prompts)
# Stap 2: parallelle nabewerking (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
Verifieer dat de berekening de pool rechtvaardigt voordat u deze introduceert: het serialiseren van gegevens naar een ander proces heeft een kostprijs, en voor behandelingen die enkele milliseconden duren, overstijgt deze kostprijs de winst.
De echte doorvoer verifiëren
Het afstemmen van max_concurrency is geen giswerk. Te laag, en u laat doorvoer liggen; te hoog, en u activeert tarieflimieten die u meer tijd kosten dan ze besparen. Meet op uw daadwerkelijke belasting, varieer de waarde, en kijk zowel naar de doorvoer als naar het aantal successen: een zeer snelle pipeline die één op de vijf keer faalt, is niet snel.
import time
async def benchmark_throughput(num_requests: int = 100):
"""Meet de echte doorvoer van uw pipeline."""
prompts = [
f"Geef een interessant feit nummer {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"Aanroepen: {num_requests}")
print(f"Successen: {successes}")
print(f"Duur: {duration:.1f}s")
print(f"Doorvoer: {successes / duration:.1f} req/s")
Belangrijkste punten
- Gebruik
AsyncOpenAIenasyncio.gathervoor I/O-concurrentie - Beperk concurrentie met een semafoor om quota te respecteren
- Het map-reduce-patroon parallelleert de verwerking van lange documenten
- Reserveer
ProcessPoolExecutorvoor CPU-intensieve nabewerking