Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Klijent Asinkronu u Prestazzjoni

Lezzjoni 10 / 14 Aġġornat 3 ta’ Novembru 2026 Bidbieni
F'din il-paġna
  1. Ottimizza l-Prestazzjoni bl-Asinkronija
  2. Il-Klijent AsyncOpenAI
  3. Talbiet Paralleli ma’ asyncio.gather
  4. Ikkontrolla l-Paralleliżmu
  5. Pipeline Asinkronu Sħiħ
  6. Tqabbil bejn Sinkronu u Asinkronu
  7. Ġestjoni tal-Iżbalji
  8. Punti Ewlenin

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 AsyncOpenAI jippermetti talbiet paralleli permezz ta’ asyncio
  • Uża asyncio.gather biex 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