Parallelism och samtidighet
På denna sida
Att vänta tillsammans är inte att beräkna tillsammans
Ett API-anrop till OpenAI är en I/O-bunden operation: ditt program knådar inte siffror, det väntar på ett nätverkssvar. Denna egenskap styr valet av rätt verktyg. Parallelism, i bemärkelsen multiprocessering, fördelar beräkningar över flera kärnor; det kostar en hel process per arbetsenhet, och att köra hundra processer som alla väntar på nätverket är rent slöseri. Samtidighet, som tillhandahålls av asyncio, låter en enda process hantera hundratals samtidiga väntelägen till försumbar kostnad. Det är detta som maximerar din genomströmning av anrop.
Skillnaden är mer än akademisk: ett team som paralleliserar sina LLM-anrop med en processpool kommer att förbruka flera gigabyte minne utan någon vinst jämfört med några rader asyncio.
Starta samtidiga anrop
SDK:t exponerar en asynkron klient, AsyncOpenAI, vars anrop avvaktas med await. Genom att samla flera korutiner i en asyncio.gather låter du dem alla fortskrida samtidigt, där den totala varaktigheten närmar sig det långsammaste anropet snarare än summan av alla.
import asyncio
import openai
client = openai.AsyncOpenAI()
async def single_call(prompt: str, model: str = "gpt-5.6-terra") -> str:
"""Ett enda asynkront API-anrop."""
response = await client.responses.create(
model=model,
input=prompt,
)
return response.output_text
async def concurrent_calls(prompts: list[str]) -> list[str]:
"""Startar alla anrop samtidigt."""
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"Fel vid prompt {i}: {result}")
return [r for r in results if not isinstance(r, Exception)]
Flaggan return_exceptions=True är vad som skiljer en prototyp från produktionsklassad bearbetning. Utan den avbryter det första felet gather och du förlorar de nittionio resultat som redan hämtats. Med den blir fel värden som du inspekterar, loggar och försöker igen i din egen takt.
Denna råa version har dock en omedelbar brist: att starta tusen anrop på en gång kommer att spränga dina hastighetsbegränsningar (rate limits) på några sekunder. En semafor löser detta genom att endast tillåta ett fast antal samtidiga anrop, medan resten väntar tålmodigt på sin tur. Tjugo är en rimlig startpunkt, att justeras baserat på din organisations faktiska kvoter.
async def calls_with_limit(
prompts: list[str],
max_concurrency: int = 20,
) -> list[str]:
"""Begränsar antalet samtidiga anrop."""
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)
Map-reduce-mönstret applicerat på text
Ett dokument på tvåhundra sidor kan inte sammanfattas i ett enda anrop, och att skiva upp det sekventiellt skulle ta minuter. Map-reduce-mönstret passar naturligt här: dela upp i bitar, sammanfatta varje bit samtidigt, och be sedan modellen om en syntes av sammanfattningarna. Map-fasen drar full nytta av samtidighet, medan reduce-fasen är ett enda anrop på text som har blivit kort.
async def map_reduce_summary(
document: str,
chunk_size: int = 3000,
) -> str:
"""Sammanfattar ett långt dokument via parallell map-reduce."""
# Fas MAP: dela upp och sammanfatta parallellt
chunks = [
document[i:i + chunk_size]
for i in range(0, len(document), chunk_size)
]
map_prompts = [
f"Sammanfatta detta stycke i 3 nyckelpunkter:\n\n{chunk}"
for chunk in chunks
]
partial_summaries = await calls_with_limit(map_prompts, max_concurrency=10)
# Fas REDUCE: kombinera sammanfattningar
summary_text = "\n\n---\n\n".join(
r for r in partial_summaries if isinstance(r, str)
)
final_summary = await single_call(
f"Syntetisera dessa delsammanfattningar till en sammanhängande sammanfattning "
f"av 5 nyckelpunkter:\n\n{summary_text}"
)
return final_summary
Filtreringen if isinstance(r, str) är lika mycket ett produktbeslut som en teknisk försiktighetsåtgärd: det innebär att den slutgiltiga syntesen kommer att produceras även om tre bitar misslyckades, tyst och stilla. Beroende på kontexten är detta exakt vad du vill ha, eller så är det oacceptabelt. Beslut explicit, och logga antalet förlorade bitar under alla omständigheter.
När multiprocessering blir relevant igen
Det finns fortfarande sällsynta situationer där beräkningen återtar kontrollen: tung efterbearbetning av svar, entitetsutvinning, poängsättning, strukturerad parsning. Detta arbete är CPU-bundet och vinner inget på asyncio. Den eleganta kombinationen är att kedja de två regimerna i en enda pipeline: nätverksanrop med samtidighet, följt av beräkning fördelad över en processpool via run_in_executor.
import asyncio
from concurrent.futures import ProcessPoolExecutor
def heavy_post_processing(text: str) -> dict:
"""CPU-bunden bearbetning på resultatet (NLP, parsning, etc.)."""
# Exempel: entitetsutvinning, poängsättning, etc.
words = text.split()
return {
"word_count": len(words),
"unique_words": len(set(words)),
}
async def complete_pipeline(prompts: list[str]) -> list[dict]:
"""Pipeline: asynkrona LLM-anrop + parallell CPU-efterbearbetning."""
# Steg 1: samtidiga LLM-anrop
llm_results = await calls_with_limit(prompts)
# Steg 2: parallell efterbearbetning (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
Verifiera att beräkningen verkligen motiverar poolen innan du introducerar den: att serialisera data till en annan process har en kostnad, och för behandlingar som varar några millisekunder överstiger denna kostnad vinsten.
Verifiera verklig genomströmning
Att finjustera max_concurrency är inte gissningslek. För lågt, och du lämnar genomströmning på bordet; för högt, och du utlöser hastighetsbegränsningar som kostar dig mer tid än de sparar. Mät på din faktiska belastning, variera värdet, och titta på både genomströmning och antal lyckade anrop – en mycket snabb pipeline som misslyckas var femte gång är inte snabb.
import time
async def benchmark_throughput(num_requests: int = 100):
"""Mäter den verkliga genomströmningen i din pipeline."""
prompts = [
f"Ge ett intressant faktum 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"Förfrågningar: {num_requests}")
print(f"Lyckade: {successes}")
print(f"Varaktighet: {duration:.1f}s")
print(f"Genomströmning: {successes / duration:.1f} req/s")
Viktiga punkter
- Använd
AsyncOpenAIochasyncio.gatherför I/O-samtidighet - Begränsa samtidighet med en semafor för att respektera kvoter
- Map-reduce-mönstret paralleliserar bearbetning av långa dokument
- Reservera
ProcessPoolExecutorför CPU-intensiv efterbearbetning