Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Optimizacija stroškov v velikem obsegu

Lekcija 10 od 20 Posodobljeno 28. julij 2026 Napredni
Na tej strani
  1. Stroški kot inženirska omejitev
  2. Vedeti, kam gre denar
  3. Štirje vzvodi za zmanjšanje
  4. Opozorilo pred računom
  5. Ključne ugotovitve

Stroški kot inženirska omejitev

Slabo optimiziran poziv, ki stane 0,002 $ na klic, je med razvojem zanemarljiv. Pri milijonu klicev to znaša 2.000 $ – in ta znesek boš plačeval vsak mesec, dokler ga nekdo ne bo prepisal. Ta premik v obsegu spremeni strošek v inženirsko omejitev: ne rešiš ga s pogajanji o pogodbi, temveč s spremembo kode.

Vidljivost je predpogoj za vsako optimizacijo. Mesečni račun ti pove, koliko si porabil, ne pa kje. Zato se ta lekcija začne z instrumentacijo, šele nato pa obravnava vzvode za zmanjšanje stroškov.

Vedeti, kam gre denar

Štirje elementi določajo strošek klica in se ne obnašajo enako. Vhodni žetoni, ki združujejo sistemski poziv, zgodovino pogovora in uporabnikovo sporočilo, rastejo s trajanjem seje. Izhodni žetoni – ustvarjeni odgovor – so zaračunani bistveno dražje od vhodnih. Predpomnjeni vhodni žetoni prejmejo približno 50-odstotni popust glede na vhodno ceno, zato je njihovo sledenje ključno za razumevanje katerega koli računa. Nazadnje, sam model: GPT-5.6 Luna je veliko cenejši od GPT-5.6 Sol in ta dejavnik prevlada nad vsemi drugimi.

Sledenje pomeni pretvorbo vsakega predmeta usage, ki ga vrne API, v dolarje, uporabo pravilne stopnje in izolacijo predpomnjenega dela.

import openai
from dataclasses import dataclass, field

client = openai.OpenAI()

# Stopnje na milijon žetonov (julij 2026) — cached_input je okvirna (~50 % vhodne),
# prilagodi glede na uradni cenik
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:
    """Sledi stroškom v realnem času."""
    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 "Ni zabeleženih klicev."
        return (
            f"Klici: {len(self.calls)} | "
            f"Skupni strošek: ${self.total_cost:.4f} | "
            f"Povprečni strošek: ${self.total_cost / len(self.calls):.6f}"
        )

tracker = CostTracker()

Tabela RATES zahteva stalno pozornost: zastara takoj, ko se spremeni uradni cenik. Obravnavaj jo kot konfiguracijske podatke, ki jih je treba preverjati, ne kot programske konstante, in povprečni strošek na klic naj bo metrika, ki jo pregleduješ tedensko.

Štirje vzvodi za zmanjšanje

Prvi in daleč najbolj donosen vzvod je izogibanje plačevanju vrhunskega modela, ko naloga tega ne zahteva. Izrecno usmerjanje glede na kompleksnost prepreči privzeto drsenje, pri katerem ves promet konča na najdražjem modelu zgolj zato, ker se je pojavil v prvem kopiranem primeru.

async def economic_router(prompt: str, complexity: str) -> str:
    """Usmeri na najcenejši zmogljiv 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

Drugi vzvod gre še dlje, ko kompleksnost ni vnaprej znana. Namesto razvrščanja zahteve kaskada najprej preizkusi najcenejši model in eskalira le, če odgovor ne opravi preverjanja kakovosti. Preverjanje, uporabljeno tukaj, je namerno osnovno – minimalna dolžina in odsotnost priznanja nevednosti – in to je točka, ki jo boš moral izpopolniti: kaskada, ki prepogosto eskalira, postane dražja od neposrednega klica pravemu modelu.

async def model_cascade(prompt: str) -> str:
    """Najprej preizkusi najcenejši model."""
    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)

        # Preveri kakovost (preprosta hevristika)
        text = response.output_text
        if len(text) > 50 and "i don't know" not in text.lower():
            return text

    return text  # Zadnji rezultat, tudi če ni popoln

Tretji vzvod cilja na vhodne žetone, ki tiho rastejo v vsaki pogovorni aplikaciji: do dvajsetega obrata z vsakim sporočilom znova plačuješ za prejšnjih devetnajst. Stiskanje zgodovine tako, da obdržiš prvo sporočilo (ki vsebuje kontekst) in zadnje (ki vsebuje vprašanje), preostali proračun pa zapolniš z najnovejšimi izmenjavami, ohrani bistveno koherenco le za delček stroška.

def compress_history(
    messages: list[dict],
    max_tokens: int = 4000,
) -> list[dict]:
    """Ohrani najnovejša sporočila znotraj proračuna."""
    # Vedno obdrži prvo (kontekst) in zadnje (vprašanje)
    if len(messages) <= 2:
        return messages

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

    # Oceni žetone (približek: 1 žeton ≈ 4 znake)
    fixed_tokens = (len(first["content"]) + len(last["content"])) // 4
    middle_budget = max_tokens - fixed_tokens

    # Obdrži najnovejša sporočila
    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]

Četrti vzvod ne zahteva algoritmične finesse, le disciplino: Batch API ponuja 50-odstotno zmanjšanje, identificirati moraš le, kaj lahko počaka. Naj naloga sama nosi nujnost že od svoje ustvaritve, namesto da bi jo sklepal naknadno – to je edini način, da preprečiš, da bi vse privzeto končalo v čakalni vrsti za realni čas.

def classify_urgency(tasks: list[dict]) -> dict:
    """Loči naloge na tiste za realni čas in paketne."""
    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,  # Primer
    }

Opozorilo pred računom

Vse te optimizacije lahko uniči en sam nesrečen uvajanje: neomejena zanka za ponovne poskuse, potrojeno sistemsko pozivanje, pomota pri spremembi modela. Opozorilo o stroških je varnostna mreža, ki te opozori v nekaj urah, ne šele ob koncu meseca. Upoštevaj vmesni prag pri 80 %: brutalni alarm spremeni v zgodnji signal, ki ti da čas za ukrepanje, preden presežeš omejitev.

class CostAlert:
    """Sproži opozorila, ko stroški presežejo prag."""

    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"OPOZORILO: dnevni strošek ${self.tracker.total_cost:.2f} "
                f"presega prag ${self.threshold:.2f}"
            )
        if self.tracker.total_cost > self.threshold * 0.8:
            return (
                f"OPOZORILO: strošek pri {self.tracker.total_cost / self.threshold:.0%} "
                f"dnevnega praga"
            )
        return None

Ključne ugotovitve

  • Sledi svojim stroškom v realnem času z uporabo response.usage
  • Usmerjaj na najcenejši model, ki zmore opravilo
  • Uporabi Batch API (-50 %) za vse, kar ne zahteva obdelave v realnem času
  • Zmanjšaj vhodne žetone s stiskanjem zgodovine
  • Nastavi opozorila o stroških, da se izogneš presenečenjem