Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Klient för asynkron kommunikation och prestanda

Lektion 10 av 14 Uppdaterad 3 november 2026 Nybörjare
På denna sida
  1. Optimera prestanda med asynkron körning
  2. Klienten AsyncOpenAI
  3. Parallella förfrågningar med asyncio.gather
  4. Kontrollera parallellism
  5. Komplett asynkron pipeline
  6. Jämförelse: Synkront kontra asynkront
  7. Felhantering
  8. Viktiga punkter

Uppdaterat den 3 november 2026 baserat på xAI:s sida om Rate limits och referensen för Images API: Gränser för Imagine-modellen räknas som förfrågningar per sekund—6 på instegsnivån, 100 på den högsta nivån—inte “30 per minut”; en semafor begränsar samtidiga förfrågningar, inte genomströmning; bilder levereras som JPEG som standard; och de specifika tiderna från den gamla versionen, som inte baserades på någon publicerad mätning, ersätts nu av en beräkning. Källor: Rate limits · Images API.

Optimera prestanda med asynkron körning

När du behöver generera eller redigera många bilder blir sekventiella anrop en flaskhals. xAI API:s asynkrona klient låter dig köra flera förfrågningar parallellt, vilket minskar den totala bearbetningstiden avsevärt.

Klienten AsyncOpenAI

Asynkron körning gör inte en enskild generering snabbare: en enda bildförfrågan tar exakt lika lång tid. Vad den eliminerar är onödigt väntande mellan förfrågningar—medan den första bilden beräknas på servern kan ditt program begära tio andra istället för att stå blockerat. Därför är vinsten noll för en bild men dramatisk för femtio.

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):
    """Genererar en bild asynkront."""
    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())

Parallella förfrågningar med asyncio.gather

asyncio.gather startar alla förfrågningar och väntar sedan på att hela uppsättningen ska bli klar. Den totala durationen blir densamma som för den långsammaste förfrågan, inte summan av alla—det är hela skillnaden, och du ser den redan med tre eller fyra bilder.

async def generate_batch(prompts):
    """Genererar bilder för flera prompts parallellt."""
    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())

Med fem prompts, istället för att vänta på att varje förfrågan ska avslutas innan nästa startar, beräknas alla fem bilder samtidigt: den totala tiden närmar sig tiden för den långsammaste förfrågan.

Kontrollera parallellism

Utan en gräns startar gather allt på en gång—och femtio samtidiga förfrågningar på en modell som är begränsad till 6 förfrågningar per sekund på instegsnivån skapar en lavin av 429-fel som kostar dig mer tid än sekventiell körning. Semaforen är därför inte en valfri försiktighetsåtgärd: det är den som gör parallellism användbar. Kalibrera den efter modellens hastighetsbegränsning, aldrig efter din maskins kapacitet.

async def generate_with_limit(prompts, max_concurrent=5):
    """Genererar bilder med ett maximalt antal parallella förfrågningar."""
    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)

De officiella tabellerna för grok-imagine-image och grok-imagine-image-2.0 anger 6 förfrågningar per sekund på instegsnivån, en gräns som växer med ditt teams nivå upp till 100. Observera: en semafor begränsar samtidiga förfrågningar, inte genomströmning. Med max_concurrent=5 håller du dig under 6 förfrågningar per sekund så länge varje generering tar mer än en sekund; om dina svar anländer snabbare måste du också glesa ut inskickandet. Kontrollera ditt teams gränser i xAI-konsolen innan du ökar antalet.

Komplett asynkron pipeline

Denna pipeline kedjar ihop de tre operationer som måste hänga ihop: generera, ladda ner omedelbart—URL:er löper ut—isolera fel. Vid stora batchar är denna tredje punkt skillnaden mellan en incident och en total förlust.

import aiohttp
import aiofiles

async def download_image(session, url, filepath):
    """Laddar ner en bild asynkront."""
    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"):
    """Komplett pipeline: generering + nedladdning."""
    os.makedirs(output_dir, exist_ok=True)

    # Steg 1: generera alla bilder parallellt
    urls = await generate_with_limit(prompts, max_concurrent=5)

    # Steg 2: ladda ner alla bilder parallellt
    async with aiohttp.ClientSession() as session:
        download_tasks = []
        for i, url in enumerate(urls):
            if url:
                # JPEG som standard (image/jpeg), om inte kvalitetsinställningen ger 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)} bilder genererade och sparade")

Jämförelse: Synkront kontra asynkront

Vinsten går att beräkna på papper. Om en generering tar T sekunder tar tjugo bilder som begärs en efter en cirka 20 × T. Med fem samtidiga förfrågningar går de i vågor om fem: cirka 4 × T, en vinst nära fem, vilket är antalet samtidiga förfrågningar—förutsatt att du håller dig under genomströmningsgränsen. Mät T på ditt eget konto innan du lovar en deadline: xAI:s bildsidor anger ingen genereringstid, och den varierar med modell, upplösning och belastning.

Felhantering

gather:s standardbeteende är brutalt: ett undantag i en uppgift bubblar upp felet och du förlorar resultaten från de andra, inklusive de du redan betalat för. return_exceptions=True ändrar detta—varje uppgift returnerar antingen sitt resultat eller sitt undantag, och du bestämmer vad du ska göra med misslyckanden utan att offra framgångarna.

async def safe_generate(prompt):
    """Genererar en bild med felhantering."""
    try:
        return await generate_image(prompt)
    except Exception as e:
        print(f"Fel för '{prompt[:30]}...' : {e}")
        return None

Viktiga punkter

  • Klienten AsyncOpenAI möjliggör parallella förfrågningar via asyncio
  • Använd asyncio.gather för att starta flera genereringar samtidigt
  • Begränsa samtidigheten med en semafor för att respektera hastighetsbegränsningar
  • Vinsten närmar sig antalet samtidiga förfrågningar, inom den tillåtna genomströmningsgränsen (6 förfrågningar per sekund på instegsnivån)
  • Hantera fel individuellt för att undvika att förlora hela batchen