Rinnakkaisuus ja samanaikaisuus
Tällä sivulla
Yhdessä odottaminen ei ole yhdessä laskemista
OpenAI API -kutsu on I/O-sidonnainen operaatio: ohjelmasi ei jauha lukuja, vaan odottaa verkkovastausta. Tämä luonne määrää oikean työkalun valinnan. Rinnakkaisuus (parallelism) moniajon mielessä jakaa laskentaa useiden ytimien kesken; se vaatii kokonaisen prosessin jokaista työyksikköä kohden, ja sadan prosessin pyörittäminen, jotka kaikki odottavat verkkoa, on puhdasta hukkaa. Samanaikaisuus (concurrency), jota asyncio tarjoaa, mahdollistaa sen, että yksi prosessi hoitaa satoja samanaikaisia odotuksia mitättömällä kustannuksella. Tämä on se, mikä maksimoi kutsujesi läpimenon.
Ero on muutakin kuin akateemista: tiimi, joka rinnakkaistaa LLM-kutsunsa prosessipoolilla, kuluttaa useita gigatavuja muistia saavuttaakseen nollahyödyn verrattuna muutamaan riviin asyncio-koodia.
Samanaikaisten kutsujen käynnistäminen
SDK tarjoaa asynkronisen asiakkaan, AsyncOpenAI, jonka kutsuja odotetaan avainsanalla await. Useiden korutiinien kokoaminen asyncio.gather-funktiolla antaa niiden edetä kaikki samanaikaisesti, jolloin kokonaiskesto lähestyy hitaimman kutsun kestoa niiden summan sijaan.
import asyncio
import openai
client = openai.AsyncOpenAI()
async def single_call(prompt: str, model: str = "gpt-5.6-terra") -> str:
"""Yksi asynkroninen API-kutsu."""
response = await client.responses.create(
model=model,
input=prompt,
)
return response.output_text
async def concurrent_calls(prompts: list[str]) -> list[str]:
"""Käynnistää kaikki kutsut samanaikaisesti."""
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"Virhe kehotteessa {i}: {result}")
return [r for r in results if not isinstance(r, Exception)]
Lippu return_exceptions=True on se, mikä erottaa prototyypin tuotantokelpoisesta käsittelystä. Ilman sitä ensimmäinen poikkeus keskeyttää gather-funktion, ja menetät jo saadut yhdeksänkymmentäyhdeksän tulosta. Sen kanssa virheet muuttuvat arvoiksi, joita tarkastat, kirjaat ja yrität uudelleen omaan tahtiisi.
Tällä raakaversiolla on kuitenkin välitön vika: tuhannen kutsun käynnistäminen kerralla rikkoo nopeusrajasi sekunneissa. Semafori ratkaisee tämän sallimalla vain kiinteän määrän samanaikaisia kutsuja, kun taas loput odottavat kärsivällisesti vuoroaan. Kaksikymmentä on kohtuullinen lähtökohta, jota tulee säätää organisaatiosi todellisten kiintiöiden perusteella.
async def calls_with_limit(
prompts: list[str],
max_concurrency: int = 20,
) -> list[str]:
"""Rajoittaa samanaikaisten kutsujen määrää."""
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-malli sovellettuna tekstiin
Kaksisataasivuista dokumenttia ei voi tiivistää yhdellä kutsulla, ja sen pilkkominen peräkkäin veisi minuutteja. Map-reduce-malli sopii tähän luontevasti: jaa osiin, tiivistä jokainen osa samanaikaisesti ja pyydä sitten mallia syntetisoimaan tiivistelmät. Map-vaihe hyötyy täysin samanaikaisuudesta, kun taas reduce-vaihe on yksittäinen kutsu tekstille, joka on lyhentynyt.
async def map_reduce_summary(
document: str,
chunk_size: int = 3000,
) -> str:
"""Tiivistää pitkän dokumentin rinnakkaisen map-reduce-menetelmän avulla."""
# Vaihe MAP: jakaminen ja tiivistäminen rinnakkain
chunks = [
document[i:i + chunk_size]
for i in range(0, len(document), chunk_size)
]
map_prompts = [
f"Tiivistä tämä kohta 3 keskeiseen pointtiin:\n\n{chunk}"
for chunk in chunks
]
partial_summaries = await calls_with_limit(map_prompts, max_concurrency=10)
# Vaihe REDUCE: tiivistelmien yhdistäminen
summary_text = "\n\n---\n\n".join(
r for r in partial_summaries if isinstance(r, str)
)
final_summary = await single_call(
f"Syntetisoi nämä osatiivistelmät johdonmukaiseksi tiivistelmäksi, "
f"jossa on 5 keskeistä pointtia:\n\n{summary_text}"
)
return final_summary
Suodatus if isinstance(r, str) on yhtä lailla tuotepäätös kuin tekninen varotoimi: se tarkoittaa, että lopullinen synteesi tuotetaan vaikka kolme osaa epäonnistuisi hiljaisesti. Kontekstista riippuen tämä on täsmälleen sitä, mitä haluat, tai se on hyväksymätöntä. Päätä asiasta eksplisiittisesti ja kirjaa kadonneiden osien määrä joka tapauksessa.
Milloin moniajo tulee taas ajankohtaiseksi
On edelleen harvinaisia tilanteita, joissa laskenta ottaa vallan takaisin: raskas jälkikäsittely vastauksille, entiteettien poiminta, pisteytys, jäsennetty analyysi. Tämä työ on CPU-sidonnaista eikä hyödy asyncio:sta. Eleganti yhdistelmä on ketjuttaa nämä kaksi tilaa yhdessä putkistossa: verkkokutsut samanaikaisesti, sitten laskenta jaettuna prosessipooliin run_in_executor-funktiolla.
import asyncio
from concurrent.futures import ProcessPoolExecutor
def heavy_post_processing(text: str) -> dict:
"""CPU-sidonnainen käsittely tulokselle (NLP, jäsennys jne.)."""
# Esimerkki: entiteettien poiminta, pisteytys jne.
words = text.split()
return {
"word_count": len(words),
"unique_words": len(set(words)),
}
async def complete_pipeline(prompts: list[str]) -> list[dict]:
"""Putkisto: asynkroniset LLM-kutsut + rinnakkainen CPU-jälkikäsittely."""
# Vaihe 1: samanaikaiset LLM-kutsut
llm_results = await calls_with_limit(prompts)
# Vaihe 2: rinnakkainen jälkikäsittely (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
Varmista, että laskenta todella oikeuttaa poolin käyttöönoton ennen sen lisäämistä: datan sarjalistaminen toiseen prosessiin maksaa, ja muutaman millisekunnin kestävissä käsittelyissä tämä kustannus ylittää hyödyn.
Todellisen läpimenon varmistaminen
max_concurrency-arvon säätäminen ei ole arvailua. Liian matala arvo jättää läpimenoa hyödyntämättä; liian korkea arvo laukaisee nopeusrajat, jotka maksavat enemmän aikaa kuin säästävät. Mittaa todellisella kuormallasi vaihtelevilla arvoilla ja tarkastele sekä läpimenoa että onnistumisten määrää – erittäin nopea putkisto, joka epäonnistuu joka viidennellä kerralla, ei ole nopea.
import time
async def benchmark_throughput(num_requests: int = 100):
"""Mittaa putkistosi todellisen läpimenon."""
prompts = [
f"Anna mielenkiintoinen fakta numero {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"Pyyntöjä: {num_requests}")
print(f"Onnistumisia: {successes}")
print(f"Kesto: {duration:.1f}s")
print(f"Läpimeno: {successes / duration:.1f} pyyntöä/s")
Keskeiset asiat
- Käytä
AsyncOpenAI:ta jaasyncio.gather:ia I/O-samanaikaisuuteen - Rajoita samanaikaisuutta semaforilla kiintiöiden noudattamiseksi
- Map-reduce-malli rinnakkaistaa pitkien dokumenttien käsittelyn
- Varaa
ProcessPoolExecutorCPU-raskaille jälkikäsittelyille