Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Rinnakkaisuus ja samanaikaisuus

Oppitunti 8 / 20 Päivitetty 28. heinäkuuta 2026 Edistynyt
Tällä sivulla
  1. Yhdessä odottaminen ei ole yhdessä laskemista
  2. Samanaikaisten kutsujen käynnistäminen
  3. Map-reduce-malli sovellettuna tekstiin
  4. Milloin moniajo tulee taas ajankohtaiseksi
  5. Todellisen läpimenon varmistaminen
  6. Keskeiset asiat

Yhdessä odottaminen ei ole yhdessä laskemista

OpenAI API -kutsu on I/O-sidonnainen operaatio: ohjelmasi ei jauha lukuja, vaan odottaa verkkovastausta. Tämä luonne määrää oikean työkalun valinnan. Rinnakkaisuus (parallelism) moniajon mielessä jakaa laskentaa useiden ytimien kesken; se vaatii kokonaisen prosessin jokaista työyksikköä kohden, ja sadan prosessin pyörittäminen, jotka kaikki odottavat verkkoa, on puhdasta hukkaa. Samanaikaisuus (concurrency), jota asyncio tarjoaa, mahdollistaa sen, että yksi prosessi hoitaa satoja samanaikaisia odotuksia mitättömällä kustannuksella. Tämä on se, mikä maksimoi kutsujesi läpimenon.

Ero on muutakin kuin akateemista: tiimi, joka rinnakkaistaa LLM-kutsunsa prosessipoolilla, kuluttaa useita gigatavuja muistia saavuttaakseen nollahyödyn verrattuna muutamaan riviin asyncio-koodia.

Samanaikaisten kutsujen käynnistäminen

SDK tarjoaa asynkronisen asiakkaan, AsyncOpenAI, jonka kutsuja odotetaan avainsanalla await. Useiden korutiinien kokoaminen asyncio.gather-funktiolla antaa niiden edetä kaikki samanaikaisesti, jolloin kokonaiskesto lähestyy hitaimman kutsun kestoa niiden summan sijaan.

import asyncio
import openai

client = openai.AsyncOpenAI()

async def single_call(prompt: str, model: str = "gpt-5.6-terra") -> str:
    """Yksi asynkroninen API-kutsu."""
    response = await client.responses.create(
        model=model,
        input=prompt,
    )
    return response.output_text

async def concurrent_calls(prompts: list[str]) -> list[str]:
    """Käynnistää kaikki kutsut samanaikaisesti."""
    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"Virhe kehotteessa {i}: {result}")

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

Lippu return_exceptions=True on se, mikä erottaa prototyypin tuotantokelpoisesta käsittelystä. Ilman sitä ensimmäinen poikkeus keskeyttää gather-funktion, ja menetät jo saadut yhdeksänkymmentäyhdeksän tulosta. Sen kanssa virheet muuttuvat arvoiksi, joita tarkastat, kirjaat ja yrität uudelleen omaan tahtiisi.

Tällä raakaversiolla on kuitenkin välitön vika: tuhannen kutsun käynnistäminen kerralla rikkoo nopeusrajasi sekunneissa. Semafori ratkaisee tämän sallimalla vain kiinteän määrän samanaikaisia kutsuja, kun taas loput odottavat kärsivällisesti vuoroaan. Kaksikymmentä on kohtuullinen lähtökohta, jota tulee säätää organisaatiosi todellisten kiintiöiden perusteella.

async def calls_with_limit(
    prompts: list[str],
    max_concurrency: int = 20,
) -> list[str]:
    """Rajoittaa samanaikaisten kutsujen määrää."""
    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-malli sovellettuna tekstiin

Kaksisataasivuista dokumenttia ei voi tiivistää yhdellä kutsulla, ja sen pilkkominen peräkkäin veisi minuutteja. Map-reduce-malli sopii tähän luontevasti: jaa osiin, tiivistä jokainen osa samanaikaisesti ja pyydä sitten mallia syntetisoimaan tiivistelmät. Map-vaihe hyötyy täysin samanaikaisuudesta, kun taas reduce-vaihe on yksittäinen kutsu tekstille, joka on lyhentynyt.

async def map_reduce_summary(
    document: str,
    chunk_size: int = 3000,
) -> str:
    """Tiivistää pitkän dokumentin rinnakkaisen map-reduce-menetelmän avulla."""

    # Vaihe MAP: jakaminen ja tiivistäminen rinnakkain
    chunks = [
        document[i:i + chunk_size]
        for i in range(0, len(document), chunk_size)
    ]

    map_prompts = [
        f"Tiivistä tämä kohta 3 keskeiseen pointtiin:\n\n{chunk}"
        for chunk in chunks
    ]

    partial_summaries = await calls_with_limit(map_prompts, max_concurrency=10)

    # Vaihe REDUCE: tiivistelmien yhdistäminen
    summary_text = "\n\n---\n\n".join(
        r for r in partial_summaries if isinstance(r, str)
    )

    final_summary = await single_call(
        f"Syntetisoi nämä osatiivistelmät johdonmukaiseksi tiivistelmäksi, "
        f"jossa on 5 keskeistä pointtia:\n\n{summary_text}"
    )

    return final_summary

Suodatus if isinstance(r, str) on yhtä lailla tuotepäätös kuin tekninen varotoimi: se tarkoittaa, että lopullinen synteesi tuotetaan vaikka kolme osaa epäonnistuisi hiljaisesti. Kontekstista riippuen tämä on täsmälleen sitä, mitä haluat, tai se on hyväksymätöntä. Päätä asiasta eksplisiittisesti ja kirjaa kadonneiden osien määrä joka tapauksessa.

Milloin moniajo tulee taas ajankohtaiseksi

On edelleen harvinaisia tilanteita, joissa laskenta ottaa vallan takaisin: raskas jälkikäsittely vastauksille, entiteettien poiminta, pisteytys, jäsennetty analyysi. Tämä työ on CPU-sidonnaista eikä hyödy asyncio:sta. Eleganti yhdistelmä on ketjuttaa nämä kaksi tilaa yhdessä putkistossa: verkkokutsut samanaikaisesti, sitten laskenta jaettuna prosessipooliin run_in_executor-funktiolla.

import asyncio
from concurrent.futures import ProcessPoolExecutor

def heavy_post_processing(text: str) -> dict:
    """CPU-sidonnainen käsittely tulokselle (NLP, jäsennys jne.)."""
    # Esimerkki: entiteettien poiminta, pisteytys jne.
    words = text.split()
    return {
        "word_count": len(words),
        "unique_words": len(set(words)),
    }

async def complete_pipeline(prompts: list[str]) -> list[dict]:
    """Putkisto: asynkroniset LLM-kutsut + rinnakkainen CPU-jälkikäsittely."""
    # Vaihe 1: samanaikaiset LLM-kutsut
    llm_results = await calls_with_limit(prompts)

    # Vaihe 2: rinnakkainen jälkikäsittely (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

Varmista, että laskenta todella oikeuttaa poolin käyttöönoton ennen sen lisäämistä: datan sarjalistaminen toiseen prosessiin maksaa, ja muutaman millisekunnin kestävissä käsittelyissä tämä kustannus ylittää hyödyn.

Todellisen läpimenon varmistaminen

max_concurrency-arvon säätäminen ei ole arvailua. Liian matala arvo jättää läpimenoa hyödyntämättä; liian korkea arvo laukaisee nopeusrajat, jotka maksavat enemmän aikaa kuin säästävät. Mittaa todellisella kuormallasi vaihtelevilla arvoilla ja tarkastele sekä läpimenoa että onnistumisten määrää – erittäin nopea putkisto, joka epäonnistuu joka viidennellä kerralla, ei ole nopea.

import time

async def benchmark_throughput(num_requests: int = 100):
    """Mittaa putkistosi todellisen läpimenon."""
    prompts = [
        f"Anna mielenkiintoinen fakta numero {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"Pyyntöjä: {num_requests}")
    print(f"Onnistumisia: {successes}")
    print(f"Kesto: {duration:.1f}s")
    print(f"Läpimeno: {successes / duration:.1f} pyyntöä/s")

Keskeiset asiat

  • Käytä AsyncOpenAI:ta ja asyncio.gather:ia I/O-samanaikaisuuteen
  • Rajoita samanaikaisuutta semaforilla kiintiöiden noudattamiseksi
  • Map-reduce-malli rinnakkaistaa pitkien dokumenttien käsittelyn
  • Varaa ProcessPoolExecutor CPU-raskaille jälkikäsittelyille