Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Paralleelsus ja samaaegsus

Õppetund 8 / 20 Värskendatud 28. juuli 2026 Edasijõudnutele
Sellel lehel
  1. Üheskoos ootamine ei tähenda üheskoos arvutamist
  2. Samaaegsete väljakutsete käivitamine
  3. Kaardi-reduktseerimise mustri rakendamine tekstile
  4. Millal mitmeprotsessoriline töötlemine taas asjakohaseks muutub
  5. Tegelikku läbilaskevõimet kontrollimine
  6. Peamised punktid

Üheskoos ootamine ei tähenda üheskoos arvutamist

OpenAI API väljakutse on sisend/väljundiga (I/O) seotud toiming: su programm ei jahvata numbreid, vaid ootab võrguvastust. See olemus dikteerib õige tööriista valiku. Paralleelsus mitmeprotsessorilises tähenduses jaotab arvutustöö mitme tuuma vahel; see maksab iga tööühiku kohta ühe täieliku protsessi ja saja protsessi käivitamine, mis kõik ootavad võrku, on puhas raiskamine. Samaaegsus, mida pakub asyncio, võimaldab ühel protsessil hallata sadu samaaegseid ooteid tühise kuluga. Just see maksimeerib sinu väljakutsete läbilaskevõimet.

See eristus on enam kui akadeemiline: meeskond, mis paralleliseerib oma LLM-i väljakutseid protsessipulgaga, tarbib mitu gigabaiti mälu nullilise kasu saavutamiseks võrreldes paari rea asyncio koodiga.

Samaaegsete väljakutsete käivitamine

SDK pakub asünkroonset klienti AsyncOpenAI, mille väljakutseid oodatakse võtmesõnaga await. Mitme korutiini kogumine funktsiooni asyncio.gather abil võimaldab kõigil neil samaaegselt edeneda, kusjuures kogukestus läheneb aeglaseima väljakutse kestusele, mitte nende summale.

import asyncio
import openai

client = openai.AsyncOpenAI()

async def single_call(prompt: str, model: str = "gpt-5.6-terra") -> str:
    """Üks asünkroonne API väljakutse."""
    response = await client.responses.create(
        model=model,
        input=prompt,
    )
    return response.output_text

async def concurrent_calls(prompts: list[str]) -> list[str]:
    """Käivitab kõik väljakutsed samaaegselt."""
    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"Viga päringul {i}: {result}")

    return [r for r in results if not isinstance(r, Exception)]

Lipp return_exceptions=True on see, mis eristab prototüüpi tootmiskvaliteediga töötlemisest. Ilma selleta katkestab esimene erind gather-i ja sa kaotad üheksakümmend üheksa juba saadud tulemust. Sellega muutuvad vead väärtusteks, mida saad oma tempos kontrollida, logida ja uuesti proovida.

Sellel toorel versioonil on siiski üks kohene viga: tuhande väljakutse korraga käivitamine ületab sinu kiirusepiirangud sekunditega. Semaphor lahendab selle, lubades ainult fikseeritud arvu samaaegseid väljakutseid, ülejäänud ootavad kannatlikult oma korda. Kakskümmend on mõistlik alguspunkt, mida tuleks kohandada vastavalt sinu organisatsiooni tegelikele kvootidele.

async def calls_with_limit(
    prompts: list[str],
    max_concurrency: int = 20,
) -> list[str]:
    """Piirab samaaegsete väljakutsete arvu."""
    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)

Kaardi-reduktseerimise mustri rakendamine tekstile

Kahe sajaleheküljelist dokumenti ei saa ühe väljakutsega kokku võtta ja selle jadahaaval tükeldamine võtaks minuteid. Kaardi-reduktseerimise (map-reduce) muster sobib siia loomulikult: jaga tükkideks, võta iga tükk samaaegselt kokku ja palu mudelil seejärel koostada kokkuvõtete süntees. Kaardi faas saab samaaegsusest täielikku kasu, samas kui redutseerimise faas on üksik väljakutse tekstile, mis on muutunud lühikeseks.

async def map_reduce_summary(
    document: str,
    chunk_size: int = 3000,
) -> str:
    """Võtab pika dokumendi kokku paralleelse kaardi-reduktseerimise teel."""

    # Faas MAP: jaga ja võta kokku paralleelselt
    chunks = [
        document[i:i + chunk_size]
        for i in range(0, len(document), chunk_size)
    ]

    map_prompts = [
        f"Võta see lõik kokku 3 põhipunktis:\n\n{chunk}"
        for chunk in chunks
    ]

    partial_summaries = await calls_with_limit(map_prompts, max_concurrency=10)

    # Faas REDUCE: ühenda kokkuvõtted
    summary_text = "\n\n---\n\n".join(
        r for r in partial_summaries if isinstance(r, str)
    )

    final_summary = await single_call(
        f"Sünteesi need osalised kokkuvõtted ühtseks 5 põhipunkti "
        f"kokkuvõtteks:\n\n{summary_text}"
    )

    return final_summary

Filtreerimine if isinstance(r, str) on sama palju tooteotsus kui tehniline ettevaatusabinõu: see tähendab, et lõplik süntees koostatakse isegi siis, kui kolm tükki ebaõnnestusid vaikselt. Sõltuvalt kontekstist on see täpselt see, mida soovid, või on see vastuvõetamatu. Otsusta selgelt ja logi igal juhul kadunud tükkide arv.

Millal mitmeprotsessoriline töötlemine taas asjakohaseks muutub

On jäänud haruldasi olukordi, kus arvutustöö võtab taas kontrolli: rasked järeltöötlused vastustel, üksuste eraldamine, hindamine, struktureeritud parsimine. See töö on protsessoriga seotud (CPU-bound) ja asyncio sellest kasu ei too. Elegantsne kombinatsioon on aheldada need kaks režiimi ühes torustikus: võrguväljakutsed samaaegsuses, seejärel arvutustöö jaotatuna protsessipulga vahel run_in_executor kaudu.

import asyncio
from concurrent.futures import ProcessPoolExecutor

def heavy_post_processing(text: str) -> dict:
    """Protsessoriga seotud töötlemine tulemusel (NLP, parsimine jne)."""
    # Näide: üksuste eraldamine, hindamine jne.
    words = text.split()
    return {
        "word_count": len(words),
        "unique_words": len(set(words)),
    }

async def complete_pipeline(prompts: list[str]) -> list[dict]:
    """Torustik: asünkroonsed LLM väljakutsed + paralleelne protsessori järeltöötlus."""
    # Samm 1: samaaegsed LLM väljakutsed
    llm_results = await calls_with_limit(prompts)

    # Samm 2: paralleelne järeltöötlus (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

Veendu, et arvutustöö õigustab pulga kasutamist enne selle tutvustamist: andmete serialiseerimine teise protsessi on kulukas ja mõne millisekundi kestvate töötluste puhul ületab see kulu saadavat kasu.

Tegelikku läbilaskevõimet kontrollimine

max_concurrency häälestamine ei ole arvamine. Liiga madal väärtus jätab läbilaskevõime kasutamata; liiga kõrge väärtus käivitab kiirusepiirangud, mis maksavad sulle rohkem aega, kui säästavad. Mõõda oma tegeliku koormuse peal, varieerides väärtust, ja vaata nii läbilaskevõimet kui ka õnnestumiste arvu – väga kiire torustik, mis ebaõnnestub ühel juhul viiest, ei ole kiire.

import time

async def benchmark_throughput(num_requests: int = 100):
    """Mõõdab sinu torustiku tegelikku läbilaskevõimet."""
    prompts = [
        f"Anna huvitav fakt number {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"Päringuid: {num_requests}")
    print(f"Õnnestumisi: {successes}")
    print(f"Kestus: {duration:.1f}s")
    print(f"Läbilaskevõime: {successes / duration:.1f} päringut/s")

Peamised punktid

  • Kasuta I/O samaaegsuse jaoks AsyncOpenAI ja asyncio.gather
  • Piira samaaegsust semaphoriga, et austada kvootide piiranguid
  • Kaardi-reduktseerimise muster paralleliseerib pikkade dokumentide töötlemist
  • Reserveeri ProcessPoolExecutor protsessorimahukaks järeltöötluseks