Przejdź do głównej treści
Polski— Wybierz język
Menu

Klient asynchroniczny i wydajność

Lekcja 10 z 14 Zaktualizowano 3 listopada 2026 Początkujący
Na tej stronie
  1. Optymalizacja wydajności dzięki asynchroniczności
  2. Klient AsyncOpenAI
  3. Żądania równoległe z asyncio.gather
  4. Kontrola równoległości
  5. Kompletny potok asynchroniczny
  6. Porównanie synchroniczne i asynchroniczne
  7. Obsługa błędów
  8. Kluczowe wnioski

Zaktualizowano 3 listopada 2026 na podstawie strony Rate limits xAI oraz dokumentacji API Images: limity modelu Imagine liczone są jako żądania na sekundę – 6 w warstwie podstawowej, 100 w najwyższej – a nie „30 na minutę“; semafor ogranicza liczbę żądań współbieżnych, a nie przepustowość; obrazy domyślnie generowane są w formacie JPEG; konkretne czasy ze starej wersji, które nie wynikały z żadnych opublikowanych pomiarów, ustępują miejsca obliczeniom. Źródła: Rate limits · Images API.

Optymalizacja wydajności dzięki asynchroniczności

Gdy musisz wygenerować lub edytować wiele obrazów, wywołania sekwencyjne stają się wąskim gardłem. Asynchroniczny klient API xAI pozwala uruchamiać wiele żądań równolegle, co znacząco skraca całkowity czas przetwarzania.

Klient AsyncOpenAI

Asynchroniczność nie przyspiesza pojedynczej generacji: pojedyncze żądanie obrazu trwa dokładnie tyle samo czasu. Eliminuje ona jednak niepotrzebne oczekiwanie między żądaniami – podczas gdy serwer przetwarza pierwszy obraz, Twój program może zażądać dziesięciu kolejnych, zamiast pozostawać zablokowany. Dlatego zysk jest zerowy dla jednego obrazu, a dramatyczny dla pięćdziesięciu.

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):
    """Generuje obraz asynchronicznie."""
    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())

Żądania równoległe z asyncio.gather

asyncio.gather uruchamia wszystkie żądania, a następnie czeka na zakończenie całego zestawu. Całkowity czas trwania odpowiada czasowi najwolniejszego żądania, a nie sumie wszystkich – to właśnie stanowi całą różnicę, którą zauważysz już przy trzech lub czterech obrazach.

async def generate_batch(prompts):
    """Generuje obrazy dla wielu promptów równolegle."""
    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())

Przy pięciu promptach, zamiast czekać na zakończenie każdego żądania przed uruchomieniem kolejnego, wszystkie pięć obrazów jest przetwarzanych jednocześnie: całkowity czas zbliża się do czasu najwolniejszego żądania.

Kontrola równoległości

Bez limitu gather uruchamia wszystko naraz – a pięćdziesiąt współbieżnych żądań na modelu ograniczonym do 6 żądań na sekundę w warstwie podstawowej wywoła lawinę błędów 429, która kosztuje Cię więcej czasu niż wykonanie sekwencyjne. Semafor nie jest więc opcjonalnym środkiem ostrożności: to on sprawia, że równoległość staje się użyteczna. Skalibruj go do limitu przepustowości modelu, nigdy do możliwości swojej maszyny.

async def generate_with_limit(prompts, max_concurrent=5):
    """Generuje obrazy z maksymalną liczbą żądań równoległych."""
    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)

Oficjalne arkusze dla grok-imagine-image i grok-imagine-image-2.0 wskazują 6 żądań na sekundę w warstwie podstawowej; limit ten rośnie wraz z poziomem Twojego zespołu aż do 100. Uwaga: semafor ogranicza liczbę żądań współbieżnych, a nie przepustowość. Przy max_concurrent=5 pozostajesz poniżej 6 żądań na sekundę, o ile każda generacja trwa dłużej niż jedna sekunda; jeśli odpowiedzi przychodzą szybciej, również rozłóż w czasie wysyłanie żądań. Sprawdź limity swojego zespołu w konsoli xAI przed ich zwiększeniem.

Kompletny potok asynchroniczny

Ten potok łączy trzy operacje, które muszą iść w parze: generowanie, natychmiastowe pobieranie (adresy URL wygasają) oraz izolowanie błędów. Przy dużym wsadzie ten trzeci punkt decyduje o tym, czy mamy do czynienia z incydentem, czy z całkowitą utratą danych.

import aiohttp
import aiofiles

async def download_image(session, url, filepath):
    """Pobiera obraz asynchronicznie."""
    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"):
    """Kompletny potok: generowanie + pobieranie."""
    os.makedirs(output_dir, exist_ok=True)

    # Krok 1: generowanie wszystkich obrazów równolegle
    urls = await generate_with_limit(prompts, max_concurrent=5)

    # Krok 2: pobieranie wszystkich obrazów równolegle
    async with aiohttp.ClientSession() as session:
        download_tasks = []
        for i, url in enumerate(urls):
            if url:
                # Domyślnie JPEG (image/jpeg), chyba że ustawienie jakości zwróci 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)} obrazów wygenerowanych i zapisanych")

Porównanie synchroniczne i asynchroniczne

Zysk można obliczyć na papierze. Jeśli jedna generacja trwa T sekund, dwadzieścia obrazów żądanych jedno po drugim zajmie około 20 × T. Przy pięciu żądaniach współbieżnych realizowane są one falami po pięć: około 4 × T, co daje zysk bliski pięciu, czyli liczbie żądań współbieżnych – pod warunkiem, że nie przekroczysz limitu przepustowości. Zmierz T na swoim koncie przed obiecaniem terminu: strony obrazów xAI nie podają czasu generacji, a zależy on od modelu, rozdzielczości i obciążenia.

Obsługa błędów

Domyślne zachowanie gather jest brutalne: wyjątek w jednym zadaniu propaguje błąd w górę i tracisz wyniki pozostałych, w tym tych, za które już zapłacono. return_exceptions=True to zmienia – każde zadanie zwraca albo swój wynik, albo wyjątek, a Ty decydujesz, co zrobić z niepowodzeniami, nie poświęcając sukcesów.

async def safe_generate(prompt):
    """Generuje obraz z obsługą błędów."""
    try:
        return await generate_image(prompt)
    except Exception as e:
        print(f"Błąd dla '{prompt[:30]}...' : {e}")
        return None

Kluczowe wnioski

  • Klient AsyncOpenAI umożliwia żądania równoległe poprzez asyncio
  • Użyj asyncio.gather, aby uruchomić wiele generacji jednocześnie
  • Ogranicz współbieżność za pomocą semafora, aby przestrzegać limitów przepustowości
  • Zysk zbliża się do liczby żądań współbieżnych, w ramach autoryzowanego limitu przepustowości (6 żądań na sekundę w warstwie podstawowej)
  • Obsługuj błędy indywidualnie, aby uniknąć utraty całego wsadu