Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Paralēlisms un vienlaicīgums

Nodarbība 8 no 20 Atjaunota 2026. gada 28. jūlijs Augstākais
Šajā lapā
  1. Gaidīšana kopā nav aprēķināšana kopā
  2. Vienlaicīgu izsaukumu palaišana
  3. Map-Reduce modelis, kas piemērots tekstam
  4. Kad daudzu procesu izmantošana atkal kļūst aktuāla
  5. Reālās caurlaidspējas pārbaude
  6. Galvenās atziņas

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 AsyncOpenAI un asyncio.gather I/O vienlaicīgumam
  • Ierobežo vienlaicīgumu ar semaforu, lai ievērotu kvotas
  • Map-reduce modelis paralēlizē garu dokumentu apstrādi
  • Atstāj ProcessPoolExecutor procesoram intensīvai pēcapstrādei