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

asyncio.gather eräprosessointia varten

Oppitunti 5 / 12 Päivitetty 30. heinäkuuta 2026 Edistynyt
Tällä sivulla
  1. Rinnakkaisten pyyntöjen orkestrointi
  2. Perussyntaksi
  3. Täydellinen malli: Erä semaforilla
  4. Virheiden käsittely erässä
  5. Jakaminen osieriin (Chunking)
  6. Edistymisen seuranta
  7. Keskeiset asiat

Rinnakkaisten pyyntöjen orkestrointi

asyncio.gather on ydinfunktio useiden korutiinien suorittamiseen rinnakkain ja kaikkien tulosten keräämiseen. Yhdistettynä semaforiin sen avulla voit käsitellä pyyntöeriä tehokkaasti noudattaen samalla API-rajoituksia.

Perussyntaksi

import asyncio

requests = ["Question 1", "Question 2", "Question 3"]
tasks = [process_request(r) for r in requests]
responses = await asyncio.gather(*tasks)

asyncio.gather ottaa vastaan vaihtelevan määrän korutiineja (minkä vuoksi käytetään *tasks-purkua listalle) ja palauttaa tulosten listan samassa järjestyksessä kuin tehtävät lähetettiin. Tämä on tärkeä seikka: vaikka kysymys 3 valmistuisi ennen kysymystä 1, responses[0] sisältää aina kysymyksen 1 tuloksen.

Täydellinen malli: Erä semaforilla

Tässä on malli, jota tulet käyttämään useimmiten tuotantoympäristössä:

import os
from asyncio import Semaphore
from openai import AsyncOpenAI
import httpx

client = AsyncOpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(3600.0)
)

async def process_batch(prompts: list[str], max_concurrent: int = 5) -> list[str]:
    sem = Semaphore(max_concurrent)

    async def single_request(prompt: str) -> str:
        async with sem:
            response = await client.chat.completions.create(
                model="grok-4.5",
                messages=[{"role": "user", "content": prompt}]
            )
            return response.choices[0].message.content

    tasks = [single_request(p) for p in prompts]
    return await asyncio.gather(*tasks)

Tämä malli kapseloi semaforin eräfunktion sisälle. Sinun tarvitsee vain kutsua process_batch(prompts) ja hakea vastauslista.

Virheiden käsittely erässä

Oletusarvoisesti, jos yksittäinen korutiini nostaa poikkeuksen, asyncio.gather peruuttaa kaiken ja välittää virheen eteenpäin. Parametri return_exceptions=True muuttaa tätä käyttäytymistä:

async def safe_batch(prompts: list[str]) -> list[str | Exception]:
    sem = Semaphore(5)

    async def single_request(prompt: str) -> str:
        async with sem:
            response = await client.chat.completions.create(
                model="grok-4.5",
                messages=[{"role": "user", "content": prompt}]
            )
            return response.choices[0].message.content

    tasks = [single_request(p) for p in prompts]
    results = await asyncio.gather(*tasks, return_exceptions=True)
    return results

# Käyttö
results = await safe_batch(mes_prompts)
for i, result in enumerate(results):
    if isinstance(result, Exception):
        print(f"Error on prompt {i}: {result}")
    else:
        print(f"Result {i}: {result[:100]}...")

Kun käytät parametria return_exceptions=True, virheet tallennetaan arvoina tulosten listaan. Tämän jälkeen voit tunnistaa epäonnistuneet pyynnöt ja yrittää niitä uudelleen.

Jakaminen osieriin (Chunking)

Hyvin suurissa määrissä on parempi jakaa pyynnöt osieriin kuin käynnistää tuhansia tehtäviä samanaikaisesti:

async def chunked_batch(
    prompts: list[str],
    chunk_size: int = 50,
    max_concurrent: int = 5
) -> list[str]:
    all_results = []

    for i in range(0, len(prompts), chunk_size):
        chunk = prompts[i:i + chunk_size]
        print(f"Processing batch {i//chunk_size + 1} ({len(chunk)} prompts)")
        results = await process_batch(chunk, max_concurrent)
        all_results.extend(results)

    return all_results

Osieriin jakamisella on useita etuja: voit näyttää edistymisen, tallentaa välituloksia ja rajoittaa muistin käyttöä. Jos yksi osierä epäonnistuu, et menetä aiempien osierien tuloksia.

Edistymisen seuranta

Suurissa erissä edistymisindikaattori on hyödyllinen:

import asyncio
from asyncio import Semaphore

async def batch_with_progress(prompts: list[str], max_concurrent: int = 5) -> list[str]:
    sem = Semaphore(max_concurrent)
    completed = 0
    total = len(prompts)

    async def single_request(prompt: str) -> str:
        nonlocal completed
        async with sem:
            response = await client.chat.completions.create(
                model="grok-4.5",
                messages=[{"role": "user", "content": prompt}]
            )
            completed += 1
            print(f"\r{completed}/{total} completed", end="", flush=True)
            return response.choices[0].message.content

    tasks = [single_request(p) for p in prompts]
    results = await asyncio.gather(*tasks)
    print()  # uusi rivi edistymisen jälkeen
    return results

Keskeiset asiat

  • asyncio.gather(*tasks) suorittaa korutiinit rinnakkain ja palauttaa tulokset alkuperäisessä järjestyksessä
  • return_exceptions=True estää yksittäisen virheen kaatamasta koko erää
  • Osieriin jakaminen mahdollistaa hyvin suurten määrien käsittelyn muistia kuormittamatta
  • Yhdistä gather aina semaforiin nopeusrajoitusten noudattamiseksi
  • Lisää edistymisen seuranta pitkäkestoisiin prosesseihin