Parallelisme og samtidighed
På denne side
At vente sammen er ikke det samme som at regne sammen
Et API-kald til OpenAI er en I/O-bundet operation: Dit program knuser ikke tal, det venter på et netsvar. Denne natur dikterer det rigtige værktøj. Parallelisme, i betydningen multiprocessering, fordeler beregninger på tværs af flere kerner; det koster en hel proces per arbejdsenhed, og at køre hundrede processer, der alle venter på netværket, er ren spild. Samtidighed, som leveret af asyncio, tillader en enkelt proces at håndtere hundredevis af samtidige venteperioder til en ubetydelig omkostning. Det er dette, der maksimerer din kald-gennemstrømning.
Distinktionen er mere end akademisk: Et team, der paralleliserer sine LLM-kald med en proces-pulje, vil forbruge flere gigabyte hukommelse for nul gevinst sammenlignet med et par linjer asyncio.
Opstart af samtidige kald
SDK’et eksponerer en asynkron klient, AsyncOpenAI, hvis kald afventes med await. Ved at samle flere korutiner i en asyncio.gather kan de alle skride frem samtidigt, hvor den samlede varighed nærmer sig den langsomste kalds varighed snarere end summen af dem alle.
import asyncio
import openai
client = openai.AsyncOpenAI()
async def single_call(prompt: str, model: str = "gpt-5.6-terra") -> str:
"""Et enkelt asynkront API-kald."""
response = await client.responses.create(
model=model,
input=prompt,
)
return response.output_text
async def concurrent_calls(prompts: list[str]) -> list[str]:
"""Opstarter alle kald 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"Fejl ved prompt {i}: {result}")
return [r for r in results if not isinstance(r, Exception)]
Flaget return_exceptions=True er det, der adskiller en prototype fra produktionsegnet behandling. Uden det vil den første undtagelse afbryde gather, og du mister de nioghalvfems resultater, der allerede er opnået. Med det bliver fejl til værdier, som du inspicerer, logger og genprøver i dit eget tempo.
Denne rå version har dog en øjeblikkelig fejl: At opstarte tusind kald på én gang vil sprænge dine hastighedsgrænser på få sekunder. En semafor løser dette ved kun at tillade et fast antal samtidige kald, mens resten venter tålmodigt på deres tur. Tyve er et rimeligt udgangspunkt, som skal justeres baseret på din organisations faktiske kvoter.
async def calls_with_limit(
prompts: list[str],
max_concurrency: int = 20,
) -> list[str]:
"""Begrænser antallet af samtidige kald."""
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ønsteret anvendt på tekst
Et dokument på to hundrede sider kan ikke opsummeres i et enkelt kald, og at skære det op sekventielt ville tage minutter. Map-reduce-mønsteret passer naturligt her: Opdel i bidder, opsummer hver bid samtidigt, og bed derefter modellen om en syntese af opsummeringerne. Map-fasen drager fuld fordel af samtidighed, mens reduce-fasen er et enkelt kald på tekst, der er blevet kort.
async def map_reduce_summary(
document: str,
chunk_size: int = 3000,
) -> str:
"""Opsummerer et langt dokument via parallel map-reduce."""
# Fase MAP: opdel og opsummer parallelt
chunks = [
document[i:i + chunk_size]
for i in range(0, len(document), chunk_size)
]
map_prompts = [
f"Opsummer dette afsnit i 3 nøglepunkter:\n\n{chunk}"
for chunk in chunks
]
partial_summaries = await calls_with_limit(map_prompts, max_concurrency=10)
# Fase REDUCE: kombinér opsummeringer
summary_text = "\n\n---\n\n".join(
r for r in partial_summaries if isinstance(r, str)
)
final_summary = await single_call(
f"Syntetisér disse delvise opsummeringer til en sammenhængende opsummering "
f"af 5 nøglepunkter:\n\n{summary_text}"
)
return final_summary
Filtreringen if isinstance(r, str) er lige så meget en produktbeslutning som en teknisk forholdsregel: Det betyder, at den endelige syntese vil blive produceret, selv hvis tre bidder fejlede, stille og roligt. Afhængigt af konteksten er det præcis, hvad du ønsker, eller også er det uacceptabelt. Beslut det eksplicit, og log antallet af tabte bidder under alle omstændigheder.
Hvornår multiprocessering igen bliver relevant
Der findes stadig sjældne situationer, hvor beregningen tager kontrol tilbage: Tung efterbehandling af svar, entitetsudtrækning, scoring, struktureret parsing. Dette arbejde er CPU-bundet og får ingen gevinst af asyncio. Den elegante kombination er at kæde de to regimer i en enkelt pipeline: Netværkskald i samtidighed, derefter beregning fordelt på tværs af en proces-pulje via run_in_executor.
import asyncio
from concurrent.futures import ProcessPoolExecutor
def heavy_post_processing(text: str) -> dict:
"""CPU-bundet behandling af resultatet (NLP, parsing osv.)."""
# Eksempel: entitetsudtrækning, scoring osv.
words = text.split()
return {
"word_count": len(words),
"unique_words": len(set(words)),
}
async def complete_pipeline(prompts: list[str]) -> list[dict]:
"""Pipeline: Asynkrone LLM-kald + parallel CPU-efterbehandling."""
# Trin 1: Samtidige LLM-kald
llm_results = await calls_with_limit(prompts)
# Trin 2: Parallel efterbehandling (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
Verificér, at beregningen retfærdiggør puljen, før du introducerer den: Serialisering af data til en anden proces har en omkostning, og for behandlinger, der varer få millisekunder, overstiger denne omkostning gevinsten.
Verificering af reel gennemstrømning
Justering af max_concurrency er ikke gætværk. For lavt, og du efterlader gennemstrømning på bordet; for højt, og du udløser hastighedsgrænser, der koster dig mere tid, end de sparer. Mål på din faktiske belastning, varier værdien, og se på både gennemstrømning og antal succeser – en meget hurtig pipeline, der fejler én ud af fem gange, er ikke hurtig.
import time
async def benchmark_throughput(num_requests: int = 100):
"""Måler den reelle gennemstrømning af din pipeline."""
prompts = [
f"Giv et interessant 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"Forespørgsler: {num_requests}")
print(f"Succeser: {successes}")
print(f"Varighed: {duration:.1f}s")
print(f"Gennemstrømning: {successes / duration:.1f} req/s")
Vigtige pointer
- Brug
AsyncOpenAIogasyncio.gathertil I/O-samtidighed - Begræns samtidighed med en semafor for at overholde kvoter
- Map-reduce-mønsteret paralleliserer behandling af lange dokumenter
- Reserver
ProcessPoolExecutortil CPU-intensiv efterbehandling