Paralēlisms un vienlaicīgums
Šajā lapā
Gaidīšana kopā nav aprēķināšana kopā
OpenAI API izsaukums ir ievades/izvades (I/O) ierobežota operācija: tava programma neveic skaitļošanas darbības, tā gaida tīkla atbildi. Šī daba diktē pareizā rīka izvēli. Paralēlisms daudzu procesu (multiprocessing) izpratnē sadala aprēķinus starp vairākiem kodoliem; tas prasa pilnu procesu katram darba vienībai, un simts procesu palaišana, kas visi gaida tīklu, ir tīrs izšķērdējums. Vienlaicīgums, ko nodrošina asyncio, ļauj vienam procesam apstrādāt simtiem vienlaicīgu gaidīšanu ar niecīgām izmaksām. Tieši tas maksimizē tavu izsaukumu caurlaidspēju.
Šī atšķirība ir vairāk nekā akadēmiska: komanda, kas paralēlizē savus LLM izsaukumus, izmantojot procesu kopu, patērēs vairākus gigabaitus atmiņas, negūstot nekādu labumu, salīdzinot ar dažām asyncio rindiņām.
Vienlaicīgu izsaukumu palaišana
SDK piedāvā asinhronu klientu AsyncOpenAI, kura izsaukumus gaida ar await. Vairāku korutīnu apkopošana, izmantojot asyncio.gather, ļauj tām visām virzīties uz priekšu vienlaicīgi, kopējam ilgumam tuvojoties lēnākā izsaukuma ilgumam, nevis to summai.
import asyncio
import openai
client = openai.AsyncOpenAI()
async def single_call(prompt: str, model: str = "gpt-5.6-terra") -> str:
"""Viens asinhrons API izsaukums."""
response = await client.responses.create(
model=model,
input=prompt,
)
return response.output_text
async def concurrent_calls(prompts: list[str]) -> list[str]:
"""Palaiž visus izsaukumus vienlaicīgi."""
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"Kļūda pie pieprasījuma {i}: {result}")
return [r for r in results if not isinstance(r, Exception)]
Karogs return_exceptions=True ir tas, kas atšķir prototipu no ražošanas līmeņa apstrādes. Bez tā pirmais izņēmums pārtrauc gather un tu zaudē deviņdesmit deviņus rezultātus, kas jau iegūti. Ar to kļūdas kļūst par vērtībām, kuras tu pārbaudi, reģistrē un atkārto savā tempā.
Tomēr šai „neapstrādātajai” versijai ir tūlītējs trūkums: tūkstoša izsaukumu palaišana vienlaikus pārkāps tavus ātruma ierobežojumus (rate limits) dažu sekunžu laikā. Semafors to atrisina, atļaujot tikai noteiktu skaitu vienlaicīgu izsaukumu, kamēr pārējie pacietīgi gaida savu kārtu. Divdesmit ir saprātīgs sākumpunkts, kas jāpielāgo, balstoties uz tavas organizācijas faktiskajām kvotām.
async def calls_with_limit(
prompts: list[str],
max_concurrency: int = 20,
) -> list[str]:
"""Ierobežo vienlaicīgo izsaukumu skaitu."""
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 modelis, kas piemērots tekstam
Divu simtu lappušu dokumentu nevar apkopot vienā izsaukumā, un tā secīga sagriešana prasītu minūtes. Map-reduce modelis šeit iederas dabiski: sadali fragmentos, apkopo katru fragmentu vienlaicīgi, pēc tam lūdz modelim izveidot šo apkopojumu sintēzi. Map fāze pilnībā izmanto vienlaicīguma priekšrocības, savukārt reduce fāze ir viens izsaukums tekstam, kas kļuvis īss.
async def map_reduce_summary(
document: str,
chunk_size: int = 3000,
) -> str:
"""Apkopo garu dokumentu, izmantojot paralēlu map-reduce."""
# Fāze MAP: sadalīšana un apkopošana paralēli
chunks = [
document[i:i + chunk_size]
for i in range(0, len(document), chunk_size)
]
map_prompts = [
f"Apkopo šo fragmentu 3 galvenajos punktos:\n\n{chunk}"
for chunk in chunks
]
partial_summaries = await calls_with_limit(map_prompts, max_concurrency=10)
# Fāze REDUCE: apkopojumu apvienošana
summary_text = "\n\n---\n\n".join(
r for r in partial_summaries if isinstance(r, str)
)
final_summary = await single_call(
f"Sintezē šos daļējos apkopojumus vienotā kopsavilkumā "
f"ar 5 galvenajiem punktiem:\n\n{summary_text}"
)
return final_summary
Filtrēšana if isinstance(r, str) ir tikpat daudz produkta lēmums cik tehniska piesardzība: tas nozīmē, ka galīgā sintēze tiks izveidota pat tad, ja trīs fragmenti būs neizdevušies, un to izdarīs klusi. Atkarībā no konteksta tas ir tieši tas, ko vēlies, vai arī tas ir nepieņemami. Izlem to apzināti un jebkurā gadījumā reģistrē zaudēto fragmentu skaitu.
Kad daudzu procesu izmantošana atkal kļūst aktuāla
Joprojām pastāv retas situācijas, kad aprēķini atgūst kontroli: smaga atbilžu pēcapstrāde, entīciju ekstrakcija, vērtēšana, strukturēta parsēšana. Šis darbs ir procesora (CPU) ierobežots un negūst nekādu labumu no asyncio. Eleganta kombinācija ir savienot abus režīmus vienā cauruļvadā: tīkla izsaukumi vienlaicīgumā, pēc tam aprēķini, kas sadalīti starp procesu kopu, izmantojot run_in_executor.
import asyncio
from concurrent.futures import ProcessPoolExecutor
def heavy_post_processing(text: str) -> dict:
"""Procesoram intensīva apstrāde uz rezultāta (NLP, parsēšana u.c.)."""
# Piemērs: entīciju ekstrakcija, vērtēšana u.c.
words = text.split()
return {
"word_count": len(words),
"unique_words": len(set(words)),
}
async def complete_pipeline(prompts: list[str]) -> list[dict]:
"""Cauruļvads: asinhroni LLM izsaukumi + paralēla CPU pēcapstrāde."""
# 1. solis: vienlaicīgi LLM izsaukumi
llm_results = await calls_with_limit(prompts)
# 2. solis: paralēla pēcapstrāde (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
Pirms tā ieviešanas pārliecinies, ka aprēķini tiešām attaisno kopas izmantošanu: datu sērijveida pārsūtīšana uz citu procesu rada izmaksas, un apstrādei, kas ilgst dažas milisekundes, šīs izmaksas pārsniedz ieguvumu.
Reālās caurlaidspējas pārbaude
max_concurrency pielāgošana nav minējumu spēle. Ja tas ir par zemu, tu atstāj caurlaidspēju neizmantotu; ja par augstu, tu aktivizē ātruma ierobežojumus, kas tev izmaksā vairāk laika, nekā ietaupa. Veic mērījumus uz savas faktiskās slodzes, mainot vērtību, un aplūko gan caurlaidspēju, gan veiksmīgo izsaukumu skaitu – ļoti ātrs cauruļvads, kas neizdodas vienā no pieciem gadījumiem, nav ātrs.
import time
async def benchmark_throughput(num_requests: int = 100):
"""Mēra tavas cauruļvada reālo caurlaidspēju."""
prompts = [
f"Sniedz interesantu faktu numur {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"Pieprasījumi: {num_requests}")
print(f"Veiksmīgi: {successes}")
print(f"Ilgums: {duration:.1f}s")
print(f"Caurlaidspēja: {successes / duration:.1f} piepr./s")
Galvenās atziņas
- Izmanto
AsyncOpenAIunasyncio.gatherI/O vienlaicīgumam - Ierobežo vienlaicīgumu ar semaforu, lai ievērotu kvotas
- Map-reduce modelis paralēlizē garu dokumentu apstrādi
- Atstāj
ProcessPoolExecutorprocesoram intensīvai pēcapstrādei