Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Paralelizmus a konkurencia

Lekcia 8 z 20 Aktualizované 28. júla 2026 Pokročilý
Na tejto strane
  1. Čakať spolu neznamená počítať spolu
  2. Spúšťanie konkurentných volaní
  3. Vzorec Map-Reduce aplikovaný na text
  4. Kedy sa viacprocesové spracovanie opäť stáva relevantným
  5. Overovanie skutočnej priepustnosti
  6. Kľúčové poznatky

Čakať spolu neznamená počítať spolu

Volanie API OpenAI je operácia viazaná na vstup/výstup (I/O): tvoj program nepočíta čísla, čaká na odpoveď zo siete. Táto povaha diktuje výber správneho nástroja. Paralelizmus v zmysle viacprocesového spracovania (multiprocessing) rozdeľuje výpočty medzi viacero jadier; stojí to celý proces na jednotku práce a spustenie sto procesov, ktoré všetky čakajú na sieť, je čistým plytvaním. Konkurencia, ktorú poskytuje asyncio, umožňuje jednému procesu obsluhovať stovky simultánnych čakaní s zanedbateľnými nákladmi. To je to, čo maximalizuje priepustnosť tvojich volaní.

Rozdiel nie je len akademický: tím, ktorý paralelizuje volania LLM pomocou poolu procesov, spotrebuje niekoľko gigabajtov pamäte pre nulový zisk v porovnaní s niekoľkými riadkami asyncio.

Spúšťanie konkurentných volaní

SDK vystavuje asynchrónneho klienta, AsyncOpenAI, ktorého volania čakajú pomocou await. Zoskupenie viacerých korutín v asyncio.gather im umožňuje všetkým napredovať súčasne, pričom celková dĺžka trvania sa blíži trvaniu najpomalšieho volania, nie ich súčtu.

import asyncio
import openai

client = openai.AsyncOpenAI()

async def single_call(prompt: str, model: str = "gpt-5.6-terra") -> str:
    """Jedno asynchrónne API volanie."""
    response = await client.responses.create(
        model=model,
        input=prompt,
    )
    return response.output_text

async def concurrent_calls(prompts: list[str]) -> list[str]:
    """Spustí všetky volania konkurentne."""
    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"Chyba pri výzve {i}: {result}")

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

Práve flag return_exceptions=True odlišuje prototyp od spracovania produkčnej kvality. Bez neho prvá výnimka preruší gather a stratíš deväťdesiatdeväť už získaných výsledkov. S ním sa chyby stanú hodnotami, ktoré preskúmaš, zaznamenáš do logu a podľa potreby zopakuješ.

Táto surová verzia má však okamžitú chybu: spustenie tisíca volaní naraz za niekoľko sekúnd prerazí tvoje limity rýchlosti (rate limits). Semafór tento problém rieši tým, že povoľuje len pevný počet simultánnych volaní, zatiaľ čo ostatné trpezlivo čakajú na svoj ťah. Dvadsať je rozumný východiskový bod, ktorý treba upraviť podľa skutočných kvót tvojej organizácie.

async def calls_with_limit(
    prompts: list[str],
    max_concurrency: int = 20,
) -> list[str]:
    """Obmedzuje počet simultánnych volaní."""
    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)

Vzorec Map-Reduce aplikovaný na text

Dvestostranový dokument nemožno zhrnúť v jednom volaní a jeho sekvenčné krájanie by trvalo minúty. Vzorec map-reduce sa tu prirodzene hodí: rozdeľ dokument na časti, každú časť konkurentne zhrň a potom požiadaj model o syntézu týchto zhrnutí. Fáza map plne využíva výhody konkurencie, zatiaľ čo fáza reduce je jedným volaním na texte, ktorý sa stal krátkym.

async def map_reduce_summary(
    document: str,
    chunk_size: int = 3000,
) -> str:
    """Zhrnie dlhý dokument pomocou paralelného map-reduce."""

    # Fáza MAP: rozdelenie a zhrnutie paralelne
    chunks = [
        document[i:i + chunk_size]
        for i in range(0, len(document), chunk_size)
    ]

    map_prompts = [
        f"Zhrň tento úsek do 3 kľúčových bodov:\n\n{chunk}"
        for chunk in chunks
    ]

    partial_summaries = await calls_with_limit(map_prompts, max_concurrency=10)

    # Fáza REDUCE: kombinovanie zhrnutí
    summary_text = "\n\n---\n\n".join(
        r for r in partial_summaries if isinstance(r, str)
    )

    final_summary = await single_call(
        f"Syntetizuj tieto čiastočné zhrnutia do koherentného zhrnutia "
        f"5 kľúčových bodov:\n\n{summary_text}"
    )

    return final_summary

Filtrovanie if isinstance(r, str) je rovnako rozhodnutím o produkte ako technickou opatrnosťou: znamená to, že finálna syntéza vznikne aj vtedy, ak tri časti zlyhali, a to potichu. V závislosti od kontextu je to presne to, čo chceš, alebo je to neprijateľné. Rozhodni sa explicitne a v každom prípade zaznamenaj do logu počet stratených častí.

Kedy sa viacprocesové spracovanie opäť stáva relevantným

Stále existujú zriedkavé situácie, keď preberá kontrolu výpočet: náročné post-spracovanie odpovedí, extrakcia entít, bodovanie, štruktúrované parsovanie. Táto práca je viazaná na CPU a asyncio jej nič neprinesie. Elegantnou kombináciou je zreťaziť tieto dva režimy v jednom pipeline: sieťové volania v konkurencii a následne výpočty distribuované cez pool procesov pomocou run_in_executor.

import asyncio
from concurrent.futures import ProcessPoolExecutor

def heavy_post_processing(text: str) -> dict:
    """Spracovanie viazané na CPU na výsledku (NLP, parsovanie atď.)."""
    # Príklad: extrakcia entít, bodovanie atď.
    words = text.split()
    return {
        "word_count": len(words),
        "unique_words": len(set(words)),
    }

async def complete_pipeline(prompts: list[str]) -> list[dict]:
    """Pipeline: asynchrónne volania LLM + paralelné post-spracovanie CPU."""
    # Krok 1: konkurentné volania LLM
    llm_results = await calls_with_limit(prompts)

    # Krok 2: paralelné post-spracovanie (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

Over si, či výpočet skutočne ospravedlňuje použitie poolu, skôr než ho zavedieš: serializácia dát do iného procesu má svoju cenu a pri spracovaniach trvajúcich niekoľko milisekúnd táto cena prevyšuje zisk.

Overovanie skutočnej priepustnosti

Ladenie max_concurrency nie je hádanie. Príliš nízka hodnota znamená, že nechávaš priepustnosť ležať ladom; príliš vysoká spustí limity rýchlosti, ktoré ťa stoja viac času, než ušetria. Meraj na svojej skutočnej záťaži, meniac hodnotu, a sleduj priepustnosť aj počet úspechov – veľmi rýchle pipeline, ktoré zlyhá v jednom z piatich prípadov, nie je rýchle.

import time

async def benchmark_throughput(num_requests: int = 100):
    """Meria skutočnú priepustnosť tvojho pipeline."""
    prompts = [
        f"Uveď zaujímavý fakt číslo {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"Požiadavky: {num_requests}")
    print(f"Úspechy: {successes}")
    print(f"Trvanie: {duration:.1f}s")
    print(f"Priepustnosť: {successes / duration:.1f} req/s")

Kľúčové poznatky

  • Použi AsyncOpenAI a asyncio.gather pre I/O konkurenciu
  • Obmedz konkurenciu pomocou semafóru, aby si rešpektoval kvóty
  • Vzorec map-reduce paralelizuje spracovanie dlhých dokumentov
  • Vyhradź ProcessPoolExecutor pre náročné post-spracovanie na CPU