Comhthreomhaireacht agus Comhtháthú
Ar an leathanach seo
Ní Ríomh Le Chéile atá i bhFanacht Le Chéile
Is oibríocht atá teoranta ag I/O é glaoch ar API OpenAI: níl do chlár ag brú uimhreacha, tá sé ag fanacht le freagra ón líonra. Cinneann an nádúr seo an uirlis cheart. Ciallaíonn comhthreomhaireacht, i gciall ilphróiseála, ríomhaireacht a dháileadh ar chroíleacáin iolracha; costáiltear próiseas iomlán in aghaidh gach aonaid oibre, agus is dramhaíl íomlán é céad próiseas a rith agus iad go léir ag fanacht ar an líonra. Ceadaíonn comhtháthú, mar a sholáthraíonn asyncio, do phróiseas amháin na céadta fanachta comhuaineacha a láimhseáil ar chostas neamhbhríoch. Is é seo a uasmhéadaíonn do thríthreorach glaoch.
Níl an t-idirdhealú seo acadúil amháin: íocfaidh foireann a dhéanann comhthreomhú ar a glaonna LLM le linn phróisis roinnt gigibheart cuimhne as aon tairbhe i gcomparáid le cúpla líne de asyncio.
Glaonna Comhtháthaithe a Sheoladh
Nochtann an SDK cliant neamhshioncrónach, AsyncOpenAI, a bhfuil glaonna air ag fanacht le await. Trí roinnt corútán a bhailiú in asyncio.gather, ligeann tú dóibh go léir dul chun cinn ag an am céanna, agus beidh an fad iomlán ag druidim le fad an ghlao is moille seachas a suim.
import asyncio
import openai
client = openai.AsyncOpenAI()
async def single_call(prompt: str, model: str = "gpt-5.6-terra") -> str:
"""Glaoch API neamhshioncrónach amháin."""
response = await client.responses.create(
model=model,
input=prompt,
)
return response.output_text
async def concurrent_calls(prompts: list[str]) -> list[str]:
"""Seolann sé gach glaoch go comhtháthaithe."""
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"Earráid ar leid {i}: {result}")
return [r for r in results if not isinstance(r, Exception)]
Is é an bratach return_exceptions=True a dhéanann idirdhealú idir fréamhshamhail agus próiseáil atá oiriúnach don táirgeadh. Gan é, brisfidh an chéad eisceacht an gather agus caillfidh tú na nócha-toradh is naoi a fuarthas cheana. Leis, is luachanna iad earráidí a scrúdaíonn tú, a logálann tú, agus a dhéanann tú iarracht orthu arís de réir do chuid ama féin.
Mar sin féin, tá locht láithreach ar an leagan amh seo: má sheolann tú míle glaoch ag an am, sáróidh tú do theorainneacha ráta laistigh de shoicind. Réitíonn seimeafar é seo trí líon seasta glaonna comhuaineacha a cheadú amháin, agus an chuid eile ag fanacht go foighneach ar a seal. Is tús maith é fiche, le coigeartú bunaithe ar chuótaí iarbhír d’eagraíochta.
async def calls_with_limit(
prompts: list[str],
max_concurrency: int = 20,
) -> list[str]:
"""Teorannaíonn sé líon na nglaonna comhuaineacha."""
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)
An Patrún Map-Reduce Curtha i bhFeidhm ar Théacs
Ní féidir doiciméad dhá chéad leathanach a achoimriú i nglaoch amháin, agus thógfadh sé nóiméad é a ghearradh go seicheamhach. Feileann an patrún map-reduce go nádúrtha anseo: roinn i smutání, déan achoimre ar gach smután go comhtháthaithe, agus ansin iarr ar an tsamhail sintéis a dhéanamh ar na hachoimrí. Baineann an céim map tairbhe iomlán as comhtháthú, cé gur glaoch amháin ar théacs atá tar éis éirí gairid é an céim reduce.
async def map_reduce_summary(
document: str,
chunk_size: int = 3000,
) -> str:
"""Déanann sé achoimre ar dhoiciméad fada trí mhap-reduce comhthreomhar."""
# Céim MAP: roinn agus déan achoimre go comhthreomhar
chunks = [
document[i:i + chunk_size]
for i in range(0, len(document), chunk_size)
]
map_prompts = [
f"Déan achoimre ar an bpas seo i 3 phríomhphointe:\n\n{chunk}"
for chunk in chunks
]
partial_summaries = await calls_with_limit(map_prompts, max_concurrency=10)
# Céim REDUCE: comhcheangail achoimrí
summary_text = "\n\n---\n\n".join(
r for r in partial_summaries if isinstance(r, str)
)
final_summary = await single_call(
f"Déan sintéis ar na hachoimrí páirteacha seo ina hachoimre chomhleanúnach "
f"de 5 phríomhphointe:\n\n{summary_text}"
)
return final_summary
Is cinneadh táirge chomh maith le réamhchúram teicniúil é an scagadh if isinstance(r, str): ciallaíonn sé go ndéanfar an tsintéis dheireanach fiú má theip ar thrí smután, go ciúin. Ag brath ar an gcomhthéacs, is é sin go díreach atá uait, nó tá sé dofhaighte. Socraigh go sainráite, agus logáil líon na smutání a cailleadh i ngach cás.
Nuair a Éiríonn Ilphróiseáil Ábhartha Arís
Fanann cásanna annamh ina nglacann ríomhaireacht an smacht ar ais: iar-phróiseáil throm ar fhreagairtí, eastóscadh eintiteas, scóráil, parsáil struchtúrtha. Tá an obair seo teoranta ag CPU agus ní bhaineann sí aon tairbhe as asyncio. Is é an comhcheangal galánta ná an dá réimeas a shlabhrú i bpíblíne amháin: glaonna líonra i gcomhtháthú, agus ansin ríomhaireacht dáilte ar linn phróisis trí run_in_executor.
import asyncio
from concurrent.futures import ProcessPoolExecutor
def heavy_post_processing(text: str) -> dict:
"""Próiseáil atá teoranta ag CPU ar an toradh (NLP, parsáil, srl.)."""
# Sampla: eastóscadh eintiteas, scóráil, srl.
words = text.split()
return {
"word_count": len(words),
"unique_words": len(set(words)),
}
async def complete_pipeline(prompts: list[str]) -> list[dict]:
"""Píblíne: glaonna LLM neamhshioncrónacha + iar-phróiseáil CPU chomhthreomhar."""
# Céim 1: glaonna LLM comhtháthaithe
llm_results = await calls_with_limit(prompts)
# Céim 2: iar-phróiseáil chomhthreomhar (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
Fíoraigh go bhfuil údar leis an linn ag an ríomhaireacht sula dtugann tú isteach í: tá costas ag baint le sonraí a shraithiú chuig próiseas eile, agus do chóireálacha a mhaireann cúpla milleasoicind, sáraíonn an costas sin an tairbhe.
Tríthreorach Réadach a Fhíorú
Ní tomhas buille faoi thuairim é max_concurrency a thiontú. Ró-íseal, agus fágfaidh tú tríthreorach ar an mbord; ró-ard, agus spreagfaidh tú teorainneacha ráta a chosnaíonn níos mó ama ort ná a shábhálann siad. Déan tomhas ar do lód iarbhír, ag athrú an luacha, agus féach ar an tríthreorach agus ar líon na rathanna araon – ní luas é píblíne an-tapa a theipeann uirthi uair as gach cúig huaire.
import time
async def benchmark_throughput(num_requests: int = 100):
"""Tomhaiseann sé tríthreorach réadach do phíblíne."""
prompts = [
f"Tabhair fíric shuimiúil uimhir {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"Iarratais: {num_requests}")
print(f|Ratha: {successes}")
print(f"Fad: {duration:.1f}s")
print(f"Tríthreorach: {successes / duration:.1f} iarr/s")
Príomhphointí
- Úsáid
AsyncOpenAIagusasyncio.gatherle haghaidh comhtháthaithe I/O - Teorannaigh comhtháthú le seimeafar chun cuótaí a urramú
- Déanann an patrún map-reduce comhthreomhú ar phróiseáil doiciméad fada
- Cuir
ProcessPoolExecutorin áirithe d’iar-phróiseáil atá dian ar CPU