Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Paralelizam i konkurentnost

Lekcija 8 od 20 Ažurirano 28. srpnja 2026. Napredno
Na ovoj stranici
  1. Čekanje zajedno nije računanje zajedno
  2. Pokretanje konkurentnih poziva
  3. Uzorak Map-Reduce primijenjen na tekst
  4. Kada višeprocesnost ponovno postaje relevantna
  5. Provjera stvarne propusnosti
  6. Ključne točke

Čekanje zajedno nije računanje zajedno

Poziv OpenAI API-ju operacija je vezana uz ulaz/izlaz (I/O): tvoj program ne melje brojeve, već čeka odgovor mreže. Ta priroda diktira pravi alat. Paralelizam, u smislu višeprocesnosti, distribuira računanje na više jezgri; košta puni proces po jedinici posla, a pokretanje stotinu procesa koji svi čekaju mrežu čista je rasipnost. Konkurentnost, koju pruža asyncio, omogućuje jednom procesu da istovremeno upravlja stotinama simultanog čekanja uz zanemariv trošak. To je ono što maksimizira tvoju propusnost poziva.

Razlika je više od akademske: tim koji paralelizira svoje LLM pozive s bazenom procesa potrošit će nekoliko gigabajta memorije za nulti dobitak u usporedbi s nekoliko redaka asyncio.

Pokretanje konkurentnih poziva

SDK izlaže asinkroni klijent, AsyncOpenAI, čiji se pozivi čekaju s await. Grupiranje više korutina u asyncio.gather omogućuje im da sve napreduju istovremeno, pri čemu se ukupno trajanje približava trajanju najsporijeg poziva, a ne njihovom zbroju.

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 ono što razlikuje prototip od obrade razine produkcije. Bez nje, prva iznimka prekida gather i gubiš devedeset i devet već dobivenih rezultata. S njom, pogreške postaju vrijednosti koje inspektiraš, bilježiš i ponavljaš po vlastitom tempu.

Međutim, ova sirova verzija ima trenutni nedostatak: pokretanje tisuću poziva odjednom probit će tvoja ograničenja brzine (rate limits) u nekoliko sekundi. Semaforski mehanizam rješava to dopuštajući samo fiksan broj simultanih poziva, dok ostali strpljivo čekaju svoj red. Dvadeset je razumna početna točka, koju trebaš prilagoditi na temelju stvarnih kvota 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)

Uzorak Map-Reduce primijenjen na tekst

Dokument od dvjesto stranica ne može se sažeti u jednom pozivu, a njegovo sekvencijalno rezanje trajalo bi minutama. Uzorak map-reduce ovdje se prirodno primjenjuje: podijeli na dijelove, sažmi svaki dio konkurentno, zatim zatraži od modela sintezu tih sažetaka. Faza mapiranja u potpunosti koristi prednosti konkurentnosti, dok je faza redukcije jedan poziv na tekstu koji je postao kratak.

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) jednako je odluka o proizvodu koliko i tehnički oprez: to znači da će se konačna sinteza proizvesti čak i ako su tri dijela tiho propala. Ovisno o kontekstu, to je točno ono što želiš, ili je neprihvatljivo. Odluči eksplicitno i u svakom slučaju zabilježi broj izgubljenih dijelova.

Kada višeprocesnost ponovno postaje relevantna

Ostaju rijetke situacije u kojima računanje ponovno preuzima kontrolu: teška post-obrada odgovora, ekstrakcija entiteta, bodovanje, strukturirano parsiranje. Taj je posao vezan uz CPU i ne dobiva ništa od asyncio. Elegantna kombinacija je lančanje ta dva režima u jednom cjevovodu: mrežni pozivi u konkurentnosti, zatim računanje distribuirano kroz bazen procesa putem 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

Provjeri opravdava li računanje uvođenje bazena prije nego ga uvedeš: serializacija podataka u drugi proces ima trošak, a za obrade koje traju nekoliko milisekundi taj trošak nadmašuje dobit.

Provjera stvarne propusnosti

Ugađanje max_concurrency nije nagađanje. Premalo i ostavljaš propusnost na stolu; previše i okidaš ograničenja brzine koja te koštaju više vremena nego što štede. Mjeri na svom stvarnom opterećenju, varirajući vrijednost, i gledaj i propusnost i broj uspjeha – vrlo brz cjevovod koji faila jedan od pet puta nije brz.

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 točke

  • Koristi AsyncOpenAI i asyncio.gather za I/O konkurentnost
  • Ograniči konkurentnost semaforom kako bi poštovao kvote
  • Uzorak map-reduce paralelizira obradu dugih dokumenata
  • Rezerviraj ProcessPoolExecutor za post-obradu intenzivnu za CPU