Klient asynchroniczny i wydajność
Na tej stronie
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
AsyncOpenAIumożliwia żądania równoległe poprzezasyncio - 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