Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Kulude optimeerimine suurel skaalal

Õppetund 10 / 20 Värskendatud 28. juuli 2026 Edasijõudnutele
Sellel lehel
  1. Kulu kui inseneripiirang
  2. Teadmine, kuhu raha läheb
  3. Neli vähendamishooba
  4. Hoiatus enne arvet
  5. Peamised punktid

Kulu kui inseneripiirang

Halvasti optimeeritud vihje, mis maksab taotluse kohta 0,002 dollarit, on arendusetapis tühine. Miljoni taotluse korral tähendab see 2000 dollarit – ja see maksab sulle sama summa iga kuu, kuni keegi selle ümber kirjutab. See mastaabi muutus teeb kulust inseneripiirangu: sa ei lahenda seda lepingut läbi rääkides, vaid koodi muutes.

Nähtavus on iga optimeerimise eeldus. Kuuarve ütleb, kui palju sa kulutasid, mitte kus. Seetõttu algab see õppetund instrumendistamise ehk mõõtmise seadistamisega enne kulude vähendamise hoobade käsitlemist.

Teadmine, kuhu raha läheb

Taotluse hinda määravad neli elementi ja need ei käitu ühtmoodi. Sisendtokenid, mis koondavad süsteemiviha, vestlusajaloo ja kasutaja sõnumi, kasvavad sessiooni kestusega. Väljundtokenid – genereeritud vastus – on hinnastatud oluliselt kõrgemalt kui sisend. Vahemällu salvestatud sisendtokenitele antakse sisendhinnast umbes 50% soodustust, mistõttu on nende jälgimine arve mõistmiseks hädavajalik. Lõpuks mudel ise: GPT-5.6 Luna on palju odavam kui GPT-5.6 Sol ja see tegur domineerib kõigi teiste ees.

Jälgimine tähendab iga API tagastatud usage objekti dollari summaks teisendamist, õige hinna rakendamist ja vahemällu salvestatud osa eraldamist.

import openai
from dataclasses import dataclass, field

client = openai.OpenAI()

# Hinnad miljoni tokeni kohta (juuli 2026) — cached_input on soovituslik (~50% sisendist),
# kohanda ametliku hinnakirja alusel
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:
    """Jälgib kulusid reaalajas."""
    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 "Ühtegi taotlust ei ole salvestatud."
        return (
            f"Taotlusi: {len(self.calls)} | "
            f"Kogukulu: ${self.total_cost:.4f} | "
            f"Keskmine kulu: ${self.total_cost / len(self.calls):.6f}"
        )

tracker = CostTracker()

Tabelit RATES tuleb pidevalt silmas pidada: see aegub kohe, kui ametlik hinnakiri muutub. Kohtle seda konfiguratsiooniandmena, mida tuleb kontrollida, mitte programmi konstandina, ja tee keskmisest taotluse hinnast näitaja, mida igal nädalal üle vaatad.

Neli vähendamishooba

Esimene ja kaugelt kõige kasumlikum hoob on vältida kallite mudelite eest maksmist, kui ülesanne seda ei nõua. Selge suunamine keerukuse põhjal hoiab ära vaikimisi nihke, kus kogu liiklus lõpetab kõige kallimal mudelil lihtsalt sellepärast, et see ilmus esimesse kopeeritud näitesse.

async def economic_router(prompt: str, complexity: str) -> str:
    """Suunab odavaimale sobivale mudelile."""
    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

Teine hoob läheb kaugemale, kui keerukust pole ette teada. Taotluse klassifitseerimise asemel proovib kaskaad kõigepealt odavaimat mudelit ja eskaleerub ainult siis, kui vastus ei läbi kvaliteedikontrolli. Siin kasutatav kontroll on tahtlikult lihtne – miinimumpikkus ja teadmatuse tunnistuse puudumine – ja just seda punkti pead täiustama: kaskaad, mis eskaleerub liiga sageli, muutub kallimaks kui otsene pöördumine õige mudeli poole.

async def model_cascade(prompt: str) -> str:
    """Proovib kõigepealt odavaimat mudelit."""
    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)

        # Kontrolli kvaliteeti (lihtne heuristika)
        text = response.output_text
        if len(text) > 50 and "i don't know" not in text.lower():
            return text

    return text  # Viimane tulemus isegi kui ebatäiuslik

Kolmas hoob sihib sisendtokeneid, mis kasvavad vaikselt igas vestlusrakenduses: kahekümnendaks pöördeks maksad iga sõnumiga tagasi eelmiste üheksateistkümne eest. Ajaloo tihendamine, hoides alles esimese sõnumi (mis sisaldab konteksti) ja viimase (mis sisaldab küsimust), ning täites ülejäänud mahu kõige värskemate vahetustega, säilitab olulise sidususe murdosa hinnaga.

def compress_history(
    messages: list[dict],
    max_tokens: int = 4000,
) -> list[dict]:
    """Hoiab alles kõige värskemad sõnumid eelarve piires."""
    # Hoia alati alles esimene (kontekst) ja viimane (küsimus)
    if len(messages) <= 2:
        return messages

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

    # Hinda tokeneid (ligikaudne: 1 token ≈ 4 tähemärki)
    fixed_tokens = (len(first["content"]) + len(last["content"])) // 4
    middle_budget = max_tokens - fixed_tokens

    # Hoia alles kõige värskemad sõnumid
    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]

Neljas hoob ei nõua algoritmilist peenust, vaid distsipliini: Batch API pakub 50% soodustust ja sa pead lihtsalt tuvastama, mis võib oodata. Lase ülesandel endal kanda kiireloomulisust juba selle loomise hetkest, mitte ei tuletada seda hiljem – see on ainus viis vältida olukorda, kus kõik vaikimisi reaalaja järjekorda satuvad.

def classify_urgency(tasks: list[dict]) -> dict:
    """Eraldab ülesanded reaalaja ja partii töötlemise vahel."""
    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,  # Näide
    }

Hoiatus enne arvet

Kõik need optimeerimised võib tühistada üks ebaõnnestunud juurutus: piiramatu korduskatsete tsükkel, kolmekordistunud süsteemiviha, kogemata muudetud mudel. Kuluhäire on ohutusvõrk, mis hoiatab sind tundide, mitte kuu lõpu seisuga. Pane tähele vahepealset lävendit 80% juures: see muudab brutaalse alarmi varajaseks signaaliks, andes sulle aega tegutseda enne limiidi ületamist.

class CostAlert:
    """Käivitab hoiatused, kui kulud ületavad lävendi."""

    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"HOIATUS: päevakulu ${self.tracker.total_cost:.2f} "
                f"ületab lävendi ${self.threshold:.2f}"
            )
        if self.tracker.total_cost > self.threshold * 0.8:
            return (
                f"HOIATUS: kulu on {self.tracker.total_cost / self.threshold:.0%} "
                f"päevasest lävendist"
            )
        return None

Peamised punktid

  • Jälgi kulusid reaalajas, kasutades response.usage
  • Suunata taotlus odavaimale ülesandega toime tulevale mudelile
  • Kasuta Batch API-d (-50%) kõige jaoks, mis ei nõua reaalajas töötlemist
  • Vähenda sisendtokeneid ajaloo tihendamisega
  • Seadista kuluhoiatused, et vältida üllatusi