Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Vzporednost in sočasnost

Lekcija 8 od 20 Posodobljeno 28. julij 2026 Napredni
Na tej strani
  1. Čakanje skupaj ni računanje skupaj
  2. Zagon sočasnih klicev
  3. Vzorec Map-Reduce, uporabljen za besedilo
  4. Kdaj večprocesnost spet postane relevantna
  5. Preverjanje dejanske prepustnosti
  6. Ključne ugotovitve

Čakanje skupaj ni računanje skupaj

Klic API-ja OpenAI je operacija, omejena z vhodom/izhodom (I/O): tvoj program ne melje števil, ampak čaka na omrežni odgovor. Ta narava narekuje pravo orodje. Vzporednost v smislu večprocesnosti (multiprocessing) porazdeli računanje med več jeder; stane celoten proces na enoto dela, in zagon sto procesov, ki vsi čakajo na omrežje, je čista zapravljenost. Sočasnost, kot jo ponuja asyncio, omogoča enemu samemu procesu, da hkrati upravlja na stotine sočasnih čakanj z zanemarljivimi stroški. To je tisto, kar maksimira tvojo prepustnost klicev.

Razlika ni le akademska: ekipa, ki paralelizira svoje klice LLM s procesnim bazenom, bo porabila več gigabajtov pomnilnika brez kakršnega koli dobička v primerjavi z nekaj vrsticami kode asyncio.

Zagon sočasnih klicev

SDK razkriva asinhroni odjemalec AsyncOpenAI, katerega klici čakajo z ukazom await. Zbiranje več korutin v asyncio.gather jim omogoča, da vse napredujejo hkrati, pri čemer se skupno trajanje približa trajanju najpočasnejšega klica in ne vsoti vseh.

import asyncio
import openai

client = openai.AsyncOpenAI()

async def single_call(prompt: str, model: str = "gpt-5.6-terra") -> str:
    """A single asynchronous API call."""
    response = await client.responses.create(
        model=model,
        input=prompt,
    )
    return response.output_text

async def concurrent_calls(prompts: list[str]) -> list[str]:
    """Launches all calls concurrently."""
    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"Error on prompt {i}: {result}")

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

Zastavica return_exceptions=True je tista, ki loči prototip od obdelave, primerne za proizvodno okolje. Brez nje prva izjema prekine gather in izgubiš devetindevetdeset že pridobljenih rezultatov. Z njo napake postanejo vrednosti, ki jih pregledaš, zabeležiš in ponovno poskusiš po svojem tempu.

Vendar ima ta surova različica takojšnjo pomanjkljivost: zagon tisoč klicev hkrati bo v nekaj sekundah presegel tvoje omejitve hitrosti (rate limits). Semaforski mehanizem to reši tako, da dovoli le določeno število sočasnih klicev, ostali pa potrpežljivo čakajo na svojo vrsto. Dvajset je razumna začetna vrednost, ki jo prilagodiš glede na dejanske kvote tvoje organizacije.

async def calls_with_limit(
    prompts: list[str],
    max_concurrency: int = 20,
) -> list[str]:
    """Limits the number of simultaneous calls."""
    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, uporabljen za besedilo

Dvesto strani dolgega dokumenta ni mogoče povzeti v enem samem klicu, zaporedno rezanje pa bi trajalo minute. Vzorec map-reduce se tu naravno uporabi: razdeli na dele, vsak del povzemi sočasno, nato pa model prosi za sintezo povzetkov. Faza map v celoti izkorišča sočasnost, medtem ko je faza reduce en sam klic na besedilu, ki je postalo kratko.

async def map_reduce_summary(
    document: str,
    chunk_size: int = 3000,
) -> str:
    """Summarizes a long document via parallel map-reduce."""

    # Phase MAP: split and summarize in parallel
    chunks = [
        document[i:i + chunk_size]
        for i in range(0, len(document), chunk_size)
    ]

    map_prompts = [
        f"Summarize this passage in 3 key points:\n\n{chunk}"
        for chunk in chunks
    ]

    partial_summaries = await calls_with_limit(map_prompts, max_concurrency=10)

    # Phase REDUCE: combine summaries
    summary_text = "\n\n---\n\n".join(
        r for r in partial_summaries if isinstance(r, str)
    )

    final_summary = await single_call(
        f"Synthesize these partial summaries into a coherent summary "
        f"of 5 key points:\n\n{summary_text}"
    )

    return final_summary

Filtriranje if isinstance(r, str) je enako odločitev o izdelku kot tehnični previdnostni ukrep: pomeni, da bo končna sinteza izdelana, tudi če so trije deli tiho odpovedali. Glede na kontekst je to točno tisto, kar želiš, ali pa je nesprejemljivo. Odloči se eksplicitno in v vsakem primeru zabeleži število izgubljenih delov.

Kdaj večprocesnost spet postane relevantna

Obstajajo redki primeri, ko računanje ponovno prevzame nadzor: obsežna naknadna obdelava odgovorov, ekstrakcija entitet, ocenjevanje, strukturirano razčlenjevanje. To delo je omejeno s procesorjem (CPU-bound) in od asyncio nima nobene koristi. Elegantna kombinacija je združitev obeh režimov v enem samem cevovodu: omrežni klici v sočasnosti, nato pa računanje, porazdeljeno med procesni bazen prek run_in_executor.

import asyncio
from concurrent.futures import ProcessPoolExecutor

def heavy_post_processing(text: str) -> dict:
    """CPU-bound processing on the result (NLP, parsing, etc.)."""
    # Example: entity extraction, scoring, etc.
    words = text.split()
    return {
        "word_count": len(words),
        "unique_words": len(set(words)),
    }

async def complete_pipeline(prompts: list[str]) -> list[dict]:
    """Pipeline: async LLM calls + parallel CPU post-processing."""
    # Step 1: concurrent LLM calls
    llm_results = await calls_with_limit(prompts)

    # Step 2: parallel post-processing (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

Preden uvedeš bazen, preveri, ali računanje to res upravičuje: serializacija podatkov v drug proces ima svojo ceno in za obdelave, ki trajajo nekaj milisekund, ta cena preseže dobiček.

Preverjanje dejanske prepustnosti

Uglaševanje max_concurrency ni ugibanje. Premajhna vrednost pusti prepustnost neizkoriščeno; previsoka sproži omejitve hitrosti, ki te stanejo več časa, kot ga prihranijo. Meri na svoji dejanski obremenitvi z variiranjem vrednosti in glej tako prepustnost kot število uspehov – zelo hiter cevovod, ki odpove pri enem od petih klicev, ni hiter.

import time

async def benchmark_throughput(num_requests: int = 100):
    """Measures the real throughput of your pipeline."""
    prompts = [
        f"Give an interesting fact 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"Requests: {num_requests}")
    print(f"Successes: {successes}")
    print(f"Duration: {duration:.1f}s")
    print(f"Throughput: {successes / duration:.1f} req/s")

Ključne ugotovitve

  • Za sočasnost I/O uporabi AsyncOpenAI in asyncio.gather
  • Omeji sočasnost s semaforjem, da spoštuješ kvote
  • Vzorec map-reduce paralelizira obdelavo dolgih dokumentov
  • ProcessPoolExecutor rezerviraj za naknadno obdelavo, ki zahteva veliko procesorske moči