Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Comhthreomhaireacht agus Comhtháthú

Ceacht 8 as 20 Nuashonraithe 28 Iúil 2026 Ardleibhéal
Ar an leathanach seo
  1. Ní Ríomh Le Chéile atá i bhFanacht Le Chéile
  2. Glaonna Comhtháthaithe a Sheoladh
  3. An Patrún Map-Reduce Curtha i bhFeidhm ar Théacs
  4. Nuair a Éiríonn Ilphróiseáil Ábhartha Arís
  5. Tríthreorach Réadach a Fhíorú
  6. Príomhphointí

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 AsyncOpenAI agus asyncio.gather le 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 ProcessPoolExecutor in áirithe d’iar-phróiseáil atá dian ar CPU