Klijent Asinkronu u Prestazzjoni
F'din il-paġna
Aġġornat fit-3 ta’ Novembru 2026 abbażi tal-paġna Rate limits ta’ xAI u r-referenza tal-API tal-Immaġni: Il-limiti tal-mudell Imagine jingħoddu bħala talbiet kull sekonda—6 fil-livell tad-dħul, 100 fl-ogħla livell—mhux “30 kull minuta”; semaforu jillimita t-talbiet konkorrenti, mhux il-produzzjoni; l-immaġni joħorġu bħala JPEG b’mod predefinit; u l-ħinijiet speċifiċi mill-verżjoni antika, li ġew mingħajr kejl ippubblikat, issa jingħataw lok għal kalkolu. Sorsi: Rate limits · Images API.
Ottimizza l-Prestazzjoni bl-Asinkronija
Meta jkollok bżonn tiġġenera jew timmodifika ħafna immaġni, sejħiet sekwenzjali jsiru ostaklu. Il-klijent asinkronu tal-API ta’ xAI jħallik tħaddem ħafna talbiet paralleli, u b’hekk tonqos b’mod sinifikanti l-ħin totali tal-ipproċessar.
Il-Klijent AsyncOpenAI
L-asinkronija ma tagħmilx ġenerazzjoni waħda aktar mgħaġġla: talba waħda għal immaġni tieħu eżattament l-istess ammont ta’ ħin. Dak li telimina huwa stennija mhux meħtieġa bejn it-talbiet—waqt li l-ewwel immaġni qed tiġi kkalkulata fuq is-server, il-programm tiegħek jista’ jitlob għaxra oħrajn minflok ma jibqa’ mblukkat. Għalhekk il-gwadann huwa żero għal immaġni waħda u drammatiku għal ħamsin.
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):
"""Tiġġenera immaġni b'mod asinkronu."""
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())
Talbiet Paralleli ma’ asyncio.gather
asyncio.gather tniedi t-talbiet kollha u mbagħad tistenna sakemm is-sett jispiċċa. Id-durata totali ssir dik tal-aktar talba bilm-mod, mhux is-somma ta’ kollha—dik hija d-differenza kollha, u tara dan b’tliet jew erba’ immaġni biss.
async def generate_batch(prompts):
"""Tiġġenera immaġni għal prompts multipli b'mod 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())
B’ħames prompts, minflok ma tistenna kull talba tispiċċa qabel ma tniedi l-oħra, il-ħames immaġni kollha jiġu kkalkulati fl-istess ħin: il-ħin totali jersaq lejn dak tal-aktar talba bil-mod.
Ikkontrolla l-Paralleliżmu
Mingħajr limitu, gather tniedi kollox f’daqqa—u ħamsin talba konkorrenti fuq mudell limitat għal 6 talbiet kull sekonda fil-livell tad-dħul jipproduċu avalanċa ta’ żbalji 429 li jiswuk aktar ħin milli eżekuzzjoni sekwenzjali. Għalhekk is-semaforu mhux prekawzjoni fakultattiva: huwa dak li jagħmel il-paralleliżmu użabbli. Ikkalibrah skont il-limitu tar-rata tal-mudell, qatt skont il-kapaċità tal-magna tiegħek.
async def generate_with_limit(prompts, max_concurrent=5):
"""Tiġġenera immaġni b'numru massimu ta' talbiet paralleli."""
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)
Il-folji uffiċjali għal grok-imagine-image u grok-imagine-image-2.0 juru 6 talbiet kull sekonda fil-livell tad-dħul, limitu li jikber mat-tim tiegħek sa 100. Nota: semaforu jillimita t-talbiet konkorrenti, mhux il-produzzjoni. B’max_concurrent=5, tibqa’ taħt 6 talbiet kull sekonda sakemm kull ġenerazzjoni tieħu aktar minn sekonda; jekk ir-risposti tiegħek jaslu aktar malajr, ibgħid is-sottomissjonijiet ukoll. Iċċekkja l-limiti tat-tim tiegħek fil-konsowl ta’ xAI qabel ma żżidhom.
Pipeline Asinkronu Sħiħ
Dan il-pipeline jgħaqqad it-tliet operazzjonijiet li jridu jmorru flimkien: iġġenera,niżżel immedjatament—l-URLs jiskadu—u iżola l-fallimenti. Fuq lott kbir, dan it-tielet punt jagħmel id-differenza bejn inċident u telf totali.
import aiohttp
import aiofiles
async def download_image(session, url, filepath):
"""Inniżżel immaġni b'mod asinkronu."""
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"):
"""Pipeline sħiħa: ġenerazzjoni + tniżżil."""
os.makedirs(output_dir, exist_ok=True)
# Pass 1: iġġenera l-immaġni kollha b'mod parallel
urls = await generate_with_limit(prompts, max_concurrent=5)
# Pass 2: niżżel l-immaġni kollha b'mod parallel
async with aiohttp.ClientSession() as session:
download_tasks = []
for i, url in enumerate(urls):
if url:
# JPEG b'mod predefinit (image/jpeg), sakemm setting tal-kwalità ma jipproduċix 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)} immaġni ġġenerati u maħżuna")
Tqabbil bejn Sinkronu u Asinkronu
Il-gwadann jiġi kkalkulat fuq il-karta. Jekk ġenerazzjoni waħda tieħu T sekondi, għoxrin immaġni mitluba waħda wara l-oħra jieħdu madwar 20 × T. B’ħames talbiet konkorrenti, imorru f’mewġ ta’ ħamsa: madwar 4 × T, gwadann qrib il-ħamsa, in-numru ta’ talbiet konkorrenti—sakemm tibqa’ taħt il-limitu tal-produzzjoni. Kejjel T fuq il-kont tiegħek stess qabel ma twiegħed skadenza: il-paġni tal-immaġni ta’ xAI ma jagħtux ħin ta’ ġenerazzjoni, u dan ivarja skont il-mudell, ir-riżoluzzjoni u t-tagħbija.
Ġestjoni tal-Iżbalji
L-imġiba predefinita ta’ gather hija brutali: eċċezzjoni f’kompitu wieħed tgħolli l-iżball u titlef ir-riżultati tal-oħrajn, inklużi dawk li diġà ħallast għalihom. return_exceptions=True ibiddel dan—kull kompitu jirritorna jew ir-riżultat tiegħu jew l-eċċezzjoni tiegħu, u inti tiddeċiedi x’tagħmel bil-fallimenti mingħajr ma ssagrifika s-suċċessi.
async def safe_generate(prompt):
"""Tiġġenera immaġni b'ġestjoni tal-iżbalji."""
try:
return await generate_image(prompt)
except Exception as e:
print(f"Żball għal '{prompt[:30]}...' : {e}")
return None
Punti Ewlenin
- Il-klijent
AsyncOpenAIjippermetti talbiet paralleli permezz ta’asyncio - Uża
asyncio.gatherbiex tniedi ġenerazzjonijiet multipli simultanjament - Illimita l-konkorrenza b’semaforu biex tirrispetta l-limiti tar-rata
- Il-gwadann jersaq lejn in-numru ta’ talbiet konkorrenti, fil-limitu tal-produzzjoni awtorizzat (6 talbiet kull sekonda fil-livell tad-dħul)
- Iġġesti l-iżbalji individwalment biex tevita li titlef il-lott kollu