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

Ottimizzazzjoni tal-Ispejjeż fuq Skala Kbira

Lezzjoni 10 / 20 Aġġornat 28 ta’ Lulju 2026 Avvanzat
F'din il-paġna
  1. L-Ispejjeż bħala Vincolu tal-Inġinerija
  2. Fejn Qed Imur il-Flus
  3. Erba’ Levi għat-Tnaqqis
  4. Li Tirċievi Twissija Qabel il-Kont
  5. Punti Ewlenin

L-Ispejjeż bħala Vincolu tal-Inġinerija

Prompt mhux ottimizzat li jiswa $0.002 għal kull sejħa huwa negliġibbli waqt l-iżvilupp. F’miljun sejħa, jiswak $2,000—u se jkompli jiswa daqshekk kull xahar sakemm xi ħadd ma jiktebuh mill-ġdid. Din il-bidla fl-iskala tbiddel l-ispiża f’vincolu tal-inġinerija: ma ssolvihx billi tinnegozja kuntratt, issolvih billi tbiddel il-kodiċi.

Il-viżibbiltà hija l-prerekwiżit għal kwalunkwe ottimizzazzjoni. Kont finali ta’ kull xahar jgħidlek kemm nefqt, mhux fejn. Għalhekk din il-lezzjoni tibda bl-istrumentazzjoni qabel ma tkopri l-levi għat-tnaqqis.

Fejn Qed Imur il-Flus

Erba’ elementi jiddeterminaw l-ispiża ta’ sejħa, u dawn ma jaġixxux bl-istess mod. It-tokens tal-input, li jiġbru flimkien il-prompt tas-sistema, l-istorja tal-konversazzjoni u l-messaġġ tal-utent, jikbru mat-tul tas-sessjoni. It-tokens tal-output—ir-risposta ġġenerata—jiġu ffrattati b’mod sinifikanti ogħla mill-input. It-tokens tal-input fil-cache jirċievu skont ta’ madwar 50% mir-rata tal-input, u għalhekk it-traċċar tagħhom huwa essenzjali biex tifhem kwalunkwe kont. Fl-aħħar nett, il-mudell innifsu: GPT-5.6 Luna huwa ferm irħas minn GPT-5.6 Sol, u dan il-fattur jiddomina lill-oħrajn kollha.

It-traċċar ifisser li tikkonverti kull oġġett usage irritornat mill-API f’ammont ta’ dollaru, tapplika r-rata korretta, u tiżola l-parti fil-cache.

import openai
from dataclasses import dataclass, field

client = openai.OpenAI()

# Rates per million tokens (July 2026) — cached_input is indicative (~50% of input),
# adjust according to the official pricing grid
RATES = {
    "gpt-5.6-luna": {"input": 0.20, "output": 1.20, "cached_input": 0.02},
    "gpt-5.6-terra": {"input": 2.00, "output": 12.00, "cached_input": 0.20},
    "gpt-5.6-sol": {"input": 5.00, "output": 30.00, "cached_input": 0.50},
}

@dataclass
class CostTracker:
    """Tracks costs in real time."""
    calls: list[dict] = field(default_factory=list)

    def record(self, model: str, usage: dict) -> float:
        input_tokens = usage.input_tokens
        cached_tokens = getattr(
            usage.input_tokens_details, "cached_tokens", 0
        )
        output_tokens = usage.output_tokens
        uncached_input_tokens = input_tokens - cached_tokens

        rate = RATES.get(model, RATES["gpt-5.6-terra"])
        cost = (
            (uncached_input_tokens / 1_000_000) * rate["input"]
            + (cached_tokens / 1_000_000) * rate["cached_input"]
            + (output_tokens / 1_000_000) * rate["output"]
        )

        self.calls.append({
            "model": model,
            "input_tokens": input_tokens,
            "cached_tokens": cached_tokens,
            "output_tokens": output_tokens,
            "cost": cost,
        })
        return cost

    @property
    def total_cost(self) -> float:
        return sum(a["cost"] for a in self.calls)

    def report(self) -> str:
        if not self.calls:
            return "No calls recorded."
        return (
            f"Calls: {len(self.calls)} | "
            f"Total cost: ${self.total_cost:.4f} | "
            f"Average cost: ${self.total_cost / len(self.calls):.6f}"
        )

tracker = CostTracker()

It-tabella RATES teħtieġ attenzjoni kostanti: issir antika malli tinbidel il-grilja uffiċjali tal-prezzijiet. Itrattaha bħala data ta’ konfigurazzjoni li trid tiċċekkja, mhux bħala kostanti tal-programm, u agħmel l-ispiża medja għal kull sejħa metrika li tirrevedi kull ġimgħa.

Erba’ Levi għat-Tnaqqis

L-ewwel leva, u sa issa l-aktar profittabbli, hija li tevita li tħallas għal mudell high-end meta l-kompitu ma jeħtiġihx. Ir-rottaġġ espliċitu bbażat fuq il-kumplessità jipprevjeni d-deriva awtomatika fejn it-traffiku kollu jispiċċa fuq l-aktar mudell għali sempliċiment għax deher fl-ewwel eżempju kkupjat.

async def economic_router(prompt: str, complexity: str) -> str:
    """Routes to the cheapest capable model."""
    if complexity == "simple":
        model = "gpt-5.6-luna"
    elif complexity == "medium":
        model = "gpt-5.6-terra"
    else:
        model = "gpt-5.6-sol"

    response = client.responses.create(model=model, input=prompt)
    tracker.record(model, response.usage)
    return response.output_text

It-tieni leva tmur aktar ‘il quddiem meta l-kumplessità ma tkunx magħrufa minn qabel. Minflok ma tikklassifika t-talba, il-kaskata tipprova l-aktar mudell irħas l-ewwel u titla’ biss jekk ir-risposta tonqos minn kontroll tal-kwalità. Iċ-ċekk użat hawnhekk huwa deliberatament rudimentali—tul minimu u n-nuqqas ta’ ammissjoni ta’ injoranza—u dan huwa l-punt li trid tirfina: kaskata li titla’ wisq spiss issir aktar għolja minn sejħa diretta għall-mudell it-tajjeb.

async def model_cascade(prompt: str) -> str:
    """Tries the cheapest model first."""
    models = ["gpt-5.6-luna", "gpt-5.6-terra", "gpt-5.6-sol"]

    for model in models:
        response = client.responses.create(
            model=model,
            input=prompt,
            max_output_tokens=500,
        )
        tracker.record(model, response.usage)

        # Check quality (simple heuristic)
        text = response.output_text
        if len(text) > 50 and "i don't know" not in text.lower():
            return text

    return text  # Last result even if imperfect

It-tielet leva timmira lejn it-tokens tal-input, li jikbru b’mod silenzjuż f’kwalunkwe applikazzjoni konversazzjonali: sal-għoxrin dawra, tkun qed tħallas għad-dsatax-il preċedenti ma’ kull messaġġ. Il-kompressjoni tal-istorja billi żżomm l-ewwel messaġġ (li fih il-kuntest) u l-aħħar wieħed (li fih il-mistoqsija), imbagħad timla l-bqija tal-baġit bl-iskambji l-aktar riċenti, tippreżerva l-koerenza essenzjali bi frazzjoni tal-ispiża.

def compress_history(
    messages: list[dict],
    max_tokens: int = 4000,
) -> list[dict]:
    """Keeps the most recent messages within budget."""
    # Always keep the first (context) and last (question)
    if len(messages) <= 2:
        return messages

    first = messages[0]
    last = messages[-1]
    middle = messages[1:-1]

    # Estimate tokens (approximation: 1 token ≈ 4 characters)
    fixed_tokens = (len(first["content"]) + len(last["content"])) // 4
    middle_budget = max_tokens - fixed_tokens

    # Keep the most recent messages
    result = []
    tokens_used = 0
    for msg in reversed(middle):
        msg_tokens = len(msg["content"]) // 4
        if tokens_used + msg_tokens > middle_budget:
            break
        result.insert(0, msg)
        tokens_used += msg_tokens

    return [first] + result + [last]

Ir-raba’ leva ma teħtieġ l-ebda finesse algoritmika, biss dixxiplina: il-Batch API toffri tnaqqis ta’ 50%, u trid biss tidentifika x’jista’ jistenna. Ħalli l-kompitu nnifsu jġorr l-urġenza mill-ħolqien tiegħu, minflok ma tiddeduċiha wara—din hija l-unika mod biex tipprevjeni li kollox jidderiva awtomatikament lejn il-kjuw f’ħin reali.

def classify_urgency(tasks: list[dict]) -> dict:
    """Separates tasks into real-time vs batch."""
    real_time = []
    batch = []

    for task in tasks:
        if task.get("urgency") == "immediate":
            real_time.append(task)
        else:
            batch.append(task)

    return {
        "real_time": real_time,
        "batch": batch,
        "estimated_savings": len(batch) * 0.001,  # Example
    }

Li Tirċievi Twissija Qabel il-Kont

L-ottimizzazzjonijiet kollha jistgħu jiġu mħassra b’dispjegament wieħed mix-xorti ħażina: loop ta’ retry mingħajr limitu, prompt tas-sistema mtripplikat, mudell mibdel bi żball. Allerta tal-ispejjeż hija x-xibka ta’ sigurtà li twissik fi żmien sigħat minflok fl-aħħar tax-xahar. Innota l-limitu intermedjarju f’80%: dan ibiddel allarma brutali f’sinjal bikri, u jagħtik il-ħin biex taġixxi qabel ma taqbeż il-limitu.

class CostAlert:
    """Triggers alerts when costs exceed a threshold."""

    def __init__(self, daily_threshold: float = 50.0):
        self.threshold = daily_threshold
        self.tracker = CostTracker()

    def check(self) -> str | None:
        if self.tracker.total_cost > self.threshold:
            return (
                f"ALERT: daily cost ${self.tracker.total_cost:.2f} "
                f"exceeds threshold of ${self.threshold:.2f}"
            )
        if self.tracker.total_cost > self.threshold * 0.8:
            return (
                f"WARNING: cost at {self.tracker.total_cost / self.threshold:.0%} "
                f"of daily threshold"
            )
        return None

Punti Ewlenin

  • Ittraċċa l-ispejjeż tiegħek f’ħin reali bl-użu ta’ response.usage
  • Agħmel rotta lejn l-aktar mudell irħas kapaċi għall-kompitu
  • Uża l-Batch API (-50%) għal kull ma ma jeħtiġx ipproċessar f’ħin reali
  • Naqqas it-tokens tal-input billi tikkompressa l-istorja
  • Ippara allerti tal-ispejjeż biex tevita sorpriżi