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

Asynkroninen asiakas ja suorituskyky

Oppitunti 10 / 14 Päivitetty 3. marraskuuta 2026 Aloittelija
Tällä sivulla
  1. Suorituskyvyn optimointi asynkronisuudella
  2. AsyncOpenAI-asiakas
  3. Rinnakkaiset pyynnöt asyncio.gatherilla
  4. Rinnakkaisuuden hallinta
  5. Täydellinen asynkroninen putki
  6. Synkronisen ja asynkronisen vertailu
  7. Virheenkäsittely
  8. Keskeiset asiat

Päivitetty 3. marraskuuta 2026 xAI:n Rate limits -sivun ja Images API -viitteen perusteella: Imagine-mallin rajat lasketaan pyyntöinä sekunnissa – 6 aloitustasolla, 100 korkeimmalla tasolla – ei “30 minuutissa”; semafori rajoittaa samanaikaisia pyyntöjä, ei läpimenoa; kuvat tuotetaan oletusarvoisesti JPEG-muodossa; ja vanhan version erityiset ajoitukset, jotka eivät perustuneet julkaistuun mittaukseen, korvataan laskelmalla. Lähteet: Rate limits · Images API.

Suorituskyvyn optimointi asynkronisuudella

Kun sinun tarvitsee tuottaa tai muokata useita kuvia, peräkkäiset kutsut muodostuvat pullonkaulaksi. xAI API:n asynkroninen asiakas mahdollistaa useiden pyyntöjen suorittamisen rinnakkain, mikä lyhentää merkittävästi kokonaiskäsittelyaikaa.

AsyncOpenAI-asiakas

Asynkronisuus ei nopeuta yksittäistä generointia: yhden kuvan pyyntö vie täsmälleen saman ajan. Se kuitenkin poistaa tarpeettoman odotuksen pyyntöjen välillä – kun ensimmäinen kuva lasketaan palvelimella, ohjelmasi voi pyytää kymmentä muuta sen sijaan, että se olisi jumissa. Siksi hyöty on nolla yhden kuvan kohdalla, mutta dramaattinen viidenkymmenen kuvan kohdalla.

from openai import AsyncOpenAI
import asyncio
import os

async_client = AsyncOpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1"
)

async def generate_image(prompt):
    """Generates an image asynchronously."""
    response = await async_client.images.generate(
        model="grok-imagine-image",
        prompt=prompt,
        extra_body={"resolution": "1k"},
    )
    return response.data[0].url

async def main():
    url = await generate_image("A lighthouse on a cliff, watercolor style")
    print(url)

asyncio.run(main())

Rinnakkaiset pyynnöt asyncio.gatherilla

asyncio.gather käynnistää kaikki pyynnöt ja odottaa sitten joukon valmistumista. Kokonaiskesto vastaa hitaimman pyynnön kestoa, ei kaikkien summaa – siinä koko ero, jonka näet jo kolmella tai neljällä kuvalla.

async def generate_batch(prompts):
    """Generates images for multiple prompts in parallel."""
    tasks = [generate_image(prompt) for prompt in prompts]
    results = await asyncio.gather(*tasks)
    return results

async def main():
    prompts = [
        "Portrait of an engineer, corporate style",
        "Panoramic view of a futuristic city",
        "Isometric diagram of a data center",
        "Abstract blue and silver logo",
        "Illustration of a team in a meeting"
    ]

    urls = await generate_batch(prompts)
    for prompt, url in zip(prompts, urls):
        print(f"{prompt[:40]}... → {url}")

asyncio.run(main())

Viiden kehotteen kohdalla kaikkien viiden kuvan laskenta tapahtuu samaan aikaan sen sijaan, että odotettaisiin jokaisen pyynnön valmistumista ennen seuraavan käynnistämistä: kokonaisaika lähestyy hitaimman pyynnön kestoa.

Rinnakkaisuuden hallinta

Ilman rajoitusta gather käynnistää kaiken kerralla – ja viisikymmentä samanaikaista pyyntöä mallille, jonka raja on 6 pyyntöä sekunnissa aloitustasolla, tuottaa vyörymän 429-virheitä, jotka maksavat sinulle enemmän aikaa kuin peräkkäinen suoritus. Semafori ei siis ole valinnainen varotoimi: se on se, mikä tekee rinnakkaisuudesta käyttökelpoista. Säädä se mallin nopeusrajoituksen mukaan, äläkä koneesi kapasiteetin mukaan.

async def generate_with_limit(prompts, max_concurrent=5):
    """Generates images with a maximum number of parallel requests."""
    semaphore = asyncio.Semaphore(max_concurrent)

    async def limited_generate(prompt):
        async with semaphore:
            return await generate_image(prompt)

    tasks = [limited_generate(prompt) for prompt in prompts]
    return await asyncio.gather(*tasks)

grok-imagine-image- ja grok-imagine-image-2.0-mallien viralliset taulukot ilmoittavat 6 pyyntöä sekunnissa aloitustasolla; raja kasvaa tiimisi tason myötä aina 100:aan saakka. Huomaa: semafori rajoittaa samanaikaisia pyyntöjä, ei läpimenoa. Arvolla max_concurrent=5 pysyt alle 6 pyynnön sekunnissa, jos jokainen generointi kestää yli sekunnin; jos vastaukset saapuvat nopeammin, harvenna myös lähetyksiä. Tarkista tiimisi rajat xAI-konsolista ennen niiden kasvattamista.

Täydellinen asynkroninen putki

Tämä putki ketjuttaa kolme toimintoa, jotka kuuluvat yhteen: generointi, välitön lataus (URL-osoitteet vanhentuvat) ja virheiden eristäminen. Suuressa erässä tämä kolmas kohta tekee eron häiriön ja täydellisen menetyksen välillä.

import aiohttp
import aiofiles

async def download_image(session, url, filepath):
    """Downloads an image asynchronously."""
    async with session.get(url) as resp:
        if resp.status == 200:
            async with aiofiles.open(filepath, "wb") as f:
                await f.write(await resp.read())
            return filepath
    return None

async def pipeline(prompts, output_dir="output"):
    """Complete pipeline: generation + download."""
    os.makedirs(output_dir, exist_ok=True)

    # Step 1: generate all images in parallel
    urls = await generate_with_limit(prompts, max_concurrent=5)

    # Step 2: download all images in parallel
    async with aiohttp.ClientSession() as session:
        download_tasks = []
        for i, url in enumerate(urls):
            if url:
                # JPEG by default (image/jpeg), unless quality setting produces PNG
                filepath = os.path.join(output_dir, f"image_{i:03d}.jpg")
                download_tasks.append(download_image(session, url, filepath))

        saved_files = await asyncio.gather(*download_tasks)

    count = sum(1 for f in saved_files if f)
    print(f"{count}/{len(prompts)} images generated and saved")

Synkronisen ja asynkronisen vertailu

Hyöty on laskettavissa paperilla. Jos yhden generoinnin kesto on T sekuntia, kaksikymmentä peräkkäin pyydettyä kuvaa vievät noin 20 × T. Viidellä samanaikaisella pyynnöllä ne etenevät viiden aaltoina: noin 4 × T, eli hyöty on lähellä viittä, eli samanaikaisten pyyntöjen määrää – edellyttäen, että pysyt läpimenorajan sisällä. Mittaa T omalla tililläsi ennen deadline-lupausten antamista: xAI:n kuvasivut eivät ilmoita generointiaikaa, ja se vaihtelee mallin, resoluution ja kuorman mukaan.

Virheenkäsittely

gatherin oletuskäyttäytyminen on brutaali: yhden tehtävän poikkeus kuplittaa virheen ylöspäin, ja menetät muiden tulokset, mukaan lukien ne, joista on jo maksettu. return_exceptions=True muuttaa tätä – jokainen tehtävä palauttaa joko tuloksensa tai poikkeuksensa, ja sinä päätät, mitä epäonnistumisille tehdään uhraamatta onnistumisia.

async def safe_generate(prompt):
    """Generates an image with error handling."""
    try:
        return await generate_image(prompt)
    except Exception as e:
        print(f"Error for '{prompt[:30]}...' : {e}")
        return None

Keskeiset asiat

  • AsyncOpenAI-asiakas mahdollistaa rinnakkaiset pyynnöt asyncion kautta
  • Käytä asyncio.gatheria käynnistääksesi useita generointeja samanaikaisesti
  • Rajoita rinnakkaisuutta semaforilla nopeusrajoitusten noudattamiseksi
  • Hyöty lähestyy samanaikaisten pyyntöjen määrää sallitun läpimenorajan puitteissa (6 pyyntöä sekunnissa aloitustasolla)
  • Käsittele virheet yksittäin välttääksesi koko erän menettämisen