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

Ġestjoni tal-Iżbalji u Dħul fil-Produzzjoni

Lezzjoni 12 / 12 Aġġornat 3 ta’ Novembru 2026 Livell Medju
F'din il-paġna
  1. Ipprepara l-Applikazzjoni Tiegħek għall-Produzzjoni
  2. Żewġ Familji ta’ Żbalji, Żewġ Mumenti
  3. Ipprova mill-Ġdid b’Mod Intelliġenti
  4. Kju biex Iżżomm il-Pass
  5. Ivverifika ċ-Ċavetta Tiegħek Qabel Ma Tiddependi Fuqha
  6. Ara X’Qed Jiġri fil-Produzzjoni
  7. Punti Ewlenin
  8. Ittestja l-Għarfien Tiegħek

Aġġornat fit-2 ta’ Novembru, 2026 ibbażat fuq id-dokumentazzjoni tal-vidjow ta’ xAI u l-kodiċi xai-sdk 1.21.0: client.video.generate (mhux client.videos), ir-riżultat f’url, il-fallimenti rrappurtati minn VideoGenerationError b’kodiċi (invalid_argument, service_unavailable…), il-limitu tar-rata rċevut bħala grpc.RpcError bil-kodiċi RESOURCE_EXHAUSTED — il-klassi RateLimitError u l-istatus expired ma jeżistux. Suppliment tat-3 ta’ Novembru, 2026: il-limitu tar-rata jgħodd it-talbiet kull sekonda (10 fil-livell tad-dħul), mhux “60 RPM”, u l-ispiża attwali kull ġenerazzjoni tinqara minn usage.cost_in_usd_ticks. Sorsi: Ġenerazzjoni tal-Vidjow · Limiti tar-Rata.

Ipprepara l-Applikazzjoni Tiegħek għall-Produzzjoni

Skript li jiġġenera vidjow fuq il-magna tiegħek u servizz li jipproduċi mijiet kuljum għal utenti reali m’għandhom kważi xejn komuni. Dan tal-aħħar irid jimmaniġġja rifjuti ta’ moderazzjoni, qbiż tal-kwoti, inċidenti tas-server, u URLs li jiskadu mingħajr qatt ma jitlif silenzjożament ġenerazzjoni mħallsa. Din il-lezzjoni tkopri l-mekkaniżmi li jagħmlu d-differenza: klassifikazzjoni tal-iżbalji, strateġija ta’ riprovazzjoni, arkitettura tal-kju, u osservabbiltà.

Żewġ Familji ta’ Żbalji, Żewġ Mumenti

L-ewwel familja tidher immedjatament, fil-mument tas-sejħa POST. Dawn huma żbalji stretti tat-talba, u l-kodiċi HTTP huwa biżżejjed biex tiddeċiedi x’tagħmel.

Kodiċi HTTPKawżaSoluzzjoni
400Parametri mhux validi (pereżempju, vuċi mhux magħrufa f’reference_audios)Irranġa t-talba
401Ċavetta tal-API mhux valida jew skadutaIvverifika l-awtentikazzjoni
429Limitu tar-rata qabeż (talbiet kull sekonda, skont il-livell)Implimenta backoff
500Żball tas-serverIpprova mill-ġdid b’backoff esponenzjali

It-tieni familja timmanifesta ruħha ħafna iktar tard, waqt il-polling, wara li t-talba tkun ġiet aċċettata u l-ġenerazzjoni tkun bdiet.

StatusKawża ProbabbliAzzjoni
failed + invalid_argument jew permission_deniedIt-talba jew il-kontenut ġie rifjutatImmodifika l-prompt jew is-sors
failed + service_unavailable jew internal_errorIs-servizz imħammal, inċidentIpprova mill-ġdid iktar tard

Din id-distinzjoni mhix akkademika: 400 irid jirritorna minnufih lis-sejjaħ għax il-kodiċi huwa l-ħati, filwaqt li status failed iseħħ wara diversi minuti ta’ stennija u jrid jiġi ttrattat fil-kuntest tax-xogħol, mhux fit-talba HTTP li ttriggerjah.

Ipprova mill-Ġdid b’Mod Intelliġenti

Il-bażi komuni hija l-backoff esponenzjali b’xi jitter. Li tirdoppja d-dewmien jagħti lil inċident tranżitorju ż-żmien biex isolvi ruħu, u l-jitter jipprevjeni lill-proċessi kollha tiegħek milli jippruvaw mill-ġdid fl-istess mument wara pik — fenomenu li jħawwel mikro-interruzzjoni f’falliment fit-tul.

import asyncio
import random

async def call_with_retry(func, max_retries=3, base_delay=2):
    """Jesegwixxi funzjoni b'riprovazzjoni u backoff esponenzjali."""
    for attempt in range(max_retries + 1):
        try:
            return await func()
        except Exception as e:
            if attempt == max_retries:
                raise

            # Backoff esponenzjali b'jitter
            delay = base_delay * (2 ** attempt) + random.uniform(0, 1)
            print(f"Tentattiv {attempt + 1} falla: {e}. Qed nipprova mill-ġdid f'{delay:.1f}s")
            await asyncio.sleep(delay)

Dan l-iskema ġenerika mhix biżżejjed, madankollu, għax mhux l-iżbalji kollha jistħoqqilhom l-istess paċenzja. Qbiż tal-kwota jsolvi billi tistenna minuta sħiħa; rifjut ta’ moderazzjoni qatt ma se jsolvi, u li tipprova mill-ġdid ifisser li tħallas diversi drabi għall-istess falliment. Il-funzjoni li ġejja tiddistingwi l-każijiet.

import asyncio
from datetime import timedelta

import grpc
from xai_sdk.video import VideoGenerationError

# Kodiċijiet ta' falliment li riprovazzjoni ma tissewwihomx
REQUIRES_FIX = {"invalid_argument", "permission_denied", "failed_precondition"}


async def generate_with_retry(client, params, max_retries=3):
    """Ġenerazzjoni tal-vidjow b'riprovazzjoni mmirata (client: xai_sdk.AsyncClient)."""
    for attempt in range(max_retries + 1):
        is_last = attempt == max_retries
        try:
            return await client.video.generate(**params)
        except VideoGenerationError as e:
            if e.code.lower() in REQUIRES_FIX or is_last:
                raise  # it-talba jew il-kontenut ġie rifjutat: irranġa qabel ma terġa' tniedi
            await asyncio.sleep(5 * (attempt + 1))  # is-servizz imħammal, inċident
        except grpc.RpcError as e:
            if e.code() != grpc.StatusCode.RESOURCE_EXHAUSTED or is_last:
                raise
            await asyncio.sleep(2 ** attempt)  # limitu tar-rata: backoff
        except TimeoutError:
            if is_last:
                raise
            # Ħalli aktar żmien għat-tentattiv li jmiss
            params["timeout"] = params.get("timeout", timedelta(minutes=10)) + timedelta(minutes=2)

Kju biex Iżżomm il-Pass

Hekk kif is-servizz tiegħek jibda jirċievi talbiet minn utenti multipli, trid tissepara r-riċeviment tat-talbiet mill-eżekuzzjoni, u fuq kollox tillimita l-konkorrenza biex tibqa’ taħt il-limitu tar-rata tal-livell tiegħek. Kju mqabbel ma’ semaforu jissodisfa ż-żewġ ħtiġijiet: ix-xogħlijiet jistgħu jistakkaw liberament, iżda għaxra biss b’massimu jesegwixxu fl-istess ħin.

import asyncio
from collections import deque

class VideoGenerationQueue:
    def __init__(self, client, max_concurrent=10):
        self.client = client
        self.queue = deque()
        self.semaphore = asyncio.Semaphore(max_concurrent)
        self.results = {}

    async def add(self, job_id, params):
        """Iżid ġenerazzjoni fil-kju."""
        self.queue.append((job_id, params))

    async def process(self):
        """Jipproċessa l-ġenerazzjonijiet pendenti kollha."""
        tasks = []
        while self.queue:
            job_id, params = self.queue.popleft()
            task = asyncio.create_task(
                self._execute(job_id, params)
            )
            tasks.append(task)
        await asyncio.gather(*tasks, return_exceptions=True)

    async def _execute(self, job_id, params):
        """Jesegwixxi ġenerazzjoni b'kontroll tal-konkorrenza."""
        async with self.semaphore:
            try:
                result = await generate_with_retry(
                    self.client, params
                )
                self.results[job_id] = {
                    "status": "done",
                    "url": result.url
                }
            except Exception as e:
                self.results[job_id] = {
                    "status": "failed",
                    "error": str(e)
                }

Innota li kull xogħol iżżomm ir-riżultat tiegħu f’results, suċċess jew falliment: ġenerazzjoni li tisparixxi mingħajr traċċa hija inċident li ħadd ma jista’ jiddijanjożtika.

Ir-rifless tal-arkitettura t-tieni jikkonċerna l-ħażna. Peress li l-URLs tal-vidjow huma temporanji, it-tniżżil irid ikun awtomatiku u immedjat, b’semmijiet b’timestamp li jiggarantixxu li ma jkun hemm l-ebda kolliżjoni bejn żewġ ġenerazzjonijiet simultanji.

import httpx
from pathlib import Path
from datetime import datetime

async def save_video(video_url, output_dir="./videos"):
    """Inizzel u jissalva vidjow iġġenerat."""
    Path(output_dir).mkdir(parents=True, exist_ok=True)
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    file_path = f"{output_dir}/video_{timestamp}.mp4"

    async with httpx.AsyncClient() as client:
        resp = await client.get(video_url)
        resp.raise_for_status()
        Path(file_path).write_bytes(resp.content)

    return file_path

Ivverifika ċ-Ċavetta Tiegħek Qabel Ma Tiddependi Fuqha

L-endpoint GET /v1/api-key jgħarfek dwar l-istat taċ-ċavetta tiegħek. Li ssejjaħlu fil-bidu tas-servizz jevita li tiskopri ċavetta mblukkata wara għoxrin talba falluta, waqt li l-utenti tiegħek jistennew.

resp = httpx.get(
    "https://api.x.ai/v1/api-key",
    headers={"Authorization": f"Bearer {api_key}"}
).json()

if resp.get("api_key_blocked") or resp.get("api_key_disabled") or resp.get("team_blocked"):
    raise RuntimeError("Ċavetta tal-API jew tim imblukkat, jew ċavetta diżattivata")

Ara X’Qed Jiġri fil-Produzzjoni

Ħames indikaturi biżżejjed biex timmaniġġja servizz ta’ ġenerazzjoni tal-vidjow. Ir-rata ta’ suċċess, jiġifieri s-sehem ta’ ġenerazzjonijiet li jispiċċaw f’done, ikejjel is-saħħa ġenerali. Il-ħin medju tal-ġenerazzjoni, imkejjel bejn is-sottomissjoni u l-istatus done, iservi biex tikkalibra l-timeouts tiegħek u tinforma lill-utenti tiegħek. Ir-rata tal-iżbalji maqsuma skont it-tip — failed skont il-kodiċi tal-iżball, timeout, limitu tar-rata — tgħidlek fejn trid tiffoka l-isforz: żieda fit-timeouts mingħajr żieda f’failed tissuġġerixxi ġenerazzjonijiet iktar bil-mod mid-deadline tal-istennija tiegħek, pereżempju, mhux fallimenti. L-ispiża kumulattiva, miksuba billi tgħodd il-qasam usage.cost_in_usd_ticks minn kull riżultat (dollaru wieħed huwa ugwali għal 10 biljun tick), jew alternattivament billi timmultiplika d-durati ġġenerati bil-prezz tas-sekonda tal-mudell, trid tiġi mmonitorjata kuljum. Fl-aħħar nett, l-użu tal-kwota, f’talbiet kull sekonda relattivament għal-limitu tal-livell tiegħek (10 fil-livell tad-dħul għal mudelli tal-vidjow), jantiċipa s-saturazzjoni qabel ma tittrasforma f’429s.

Dawn il-metriki jinbnew b’mod naturali minn reġistru strutturat, fejn kull ġenerazzjoni tħalli linja użabbli mill-għodda tal-analiżi tiegħek.

import logging
import json

logger = logging.getLogger("video-generation")

def log_generation(request_id, status, duration_s, cost, time_ms):
    logger.info(json.dumps({
        "event": "video_generation",
        "request_id": request_id,
        "status": status,
        "duration_seconds": duration_s,
        "cost_usd": cost,
        "processing_time_ms": time_ms
    }))

Qabel ma tiftaħ is-servizz tiegħek għall-pubbliku, irrevedi kollox mill-bidu. Ir-riprovazzjoni b’backoff esponenzjali u jitter trid tkun fis-seħħ, u l-konkorrenza limitata minn semaforu biex tibqa’ taħt il-limitu tar-rata. It-tniżżil tal-vidjow irid jinxtegħel awtomatikament hekk kif ikunu lesti, mingħajr ma jiddependu fuq azzjoni umana. Kull ġenerazzjoni trid tħalli linja fir-reġistru li ġġorr l-request_id, l-istatus u l-ispiża tagħha, inkella r-rata tal-iżbalji u l-ħin medju tal-ġenerazzjoni jibqgħu mhux verifikabbli. Iċċekkja l-istat taċ-ċavetta tal-API fil-bidu minflok fl-ewwel falliment. U stabbilixxi baġit b’allerti ta’ qbiż: bi $0.05 kull sekonda, ċiklu ta’ riprovazzjoni mingħajr limitu jikkonsma iktar malajr milli taħseb.

Prezzijiet ivverifikati fit-3 ta’ Novembru, 2026 — il-prezzijiet jevolvu regolarment: qabel kwalunkwe kalkolu tal-baġit, ivverifika l-grilja attwali fuq il-paġna uffiċjali tal-mudelli u l-prezzijiet ta’ xAI.

Punti Ewlenin

  • L-iżbalji jinqasmu f’sinkroniċi (talba) u asinkroniċi (ġenerazzjoni)
  • Mhux l-iżbalji kollha jistħoqqilhom riprovazzjoni: il-moderazzjoni hija definittiva
  • Uża semaforu biex tillimita l-ġenerazzjonijiet konkorrenti
  • URLs temporanji jeħtieġu tniżżil immedjat u sistematiku
  • Segwi metriki ta’ spiża, suċċess u ħin tal-ġenerazzjoni biex timmaniġġja s-servizz tiegħek

Ittestja l-Għarfien Tiegħek

Vidjow ġenerattiv fil-produzzjoni: ivvalida l-fluss sħiħ tax-xogħol.

1. X'inhuma l-partikolaritajiet ta' prompt tal-vidjow?

Tweġiba: Iddeskrivi l-azzjoni u l-moviment, mhux biss ix-xena: suġġett, spostament, ambjent, inquadrament — id-dimensjoni temporali hija dak li jiddistingwi l-prompt tal-vidjow mill-prompt tal-immaġni.

2. X'jippermetti l-immaġni-għal-vidjow?

Tweġiba: Tanima immaġni eżistenti, jew iġġib persuni u prodotti mogħtija f’xena ġdida bl-użu ta’ immaġnijiet ta’ referenza — u, fuq grok-imagine-video-1.5, issakkar l-ewwel, l-aħħar, jew immaġnijiet ewlenin: l-identità viżiva tiegħek issir punt tat-tluq, mhux każwalità.

3. Immuntar u estensjoni: liema użi?

Tweġiba: /videos/edits jimmodifika vidjow iġġenerat, /videos/extensions itawlu — u t-tnejn jingħaqdu biex jinbnew sekwenzi twal permezz ta’ iterazzjonijiet.

4. Għaliex il-fluss tax-xogħol huwa asinkroniku?

Tweġiba: Il-ġenerazzjoni tal-vidjow tieħu ż-żmien: tibgħat xogħol, tikkontrolla l-istatus tiegħu, imbagħad tirrikupra r-riżultat — l-SDK ta’ xAI tawtomatizza dan il-polling.

5. X'għandek tippjana għall-produzzjoni?

Tweġiba: Ġestjoni tal-iżbalji u xogħlijiet falluti, tniżżil immedjat tal-outputs, u traċċar tal-ispiża (riżoluzzjoni, durata, iterazzjonijiet) — il-vidjow huwa l-modalità l-aktar għalja: irid ikun ibbaġitjat.

Prompt temporali, referenza viżiva, asinkronija mħaddma: il-vidjow ġenerattiv isir pipeline — mhux lotterija.