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

Kulude ja kasutuse jälgimine

Õppetund 16 / 22 Värskendatud 29. juuli 2026 Arendajatele
Sellel lehel
  1. Kulude ja kasutuse jälgimine
  2. Arvelduse mõistmine
  3. Kulukalkulaator
  4. Reaalaegne kulude jälgija
  5. Eelarvekontrolliga klient
  6. Kulude optimeerimine
  7. Peamised punktid

Kulude ja kasutuse jälgimine

API kulud võivad kiiresti kontrolli alt väljuda, kui sa neid ei jälgi. Selles õppetükis õpid, kuidas oma kulusid tootmises jälgida, hinnata ja kontrollida. Lugu kordub projektist projekti: funktsioon läheb neljapäeval live’i, keegi ei kontrolli nädalavahetusel armatuurlauda ja esmaspäeva hommikune arve võrdub kogu kuu eelarvega. Alltoodud sammud aitavad sul kulude kõrvalekaldeid tabada kohe, kui need tekivad, mitte kolmkümmend päeva hiljem.

Arvelduse mõistmine

Kulusid arvutatakse miljoni tokeni kohta, kusjuures sisendi ja väljundi hinnad erinevad. Sellel asümmeetrial on otsene mõju sinu disainivalikutele: pika dokumendi sisendina saatmine maksab oluliselt vähem kui mudeli poolt pika teksti genereerimine. Iga vastus tagastab mõlema suuna täpse loenduse, nii et sa ei pea kunagi hindama.

from openai import OpenAI
client = OpenAI()

# Iga vastus sisaldab kasutusmõõdikuid
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Selgita OpenAI API arveldust."
)

usage = response.usage
print(f"Sisendi tokenid: {usage.input_tokens}")
print(f"Väljundi tokenid: {usage.output_tokens}")
print(f"Tokenid kokku: {usage.total_tokens}")

# Väljund maksab rohkem kui sisend!

Kulukalkulaator

Nende loendurite dollaritesse teisendamine nõuab hinnakirja. Eralda see spetsiaalsesse struktuuri, selle asemel et konstante koodis laiali pillata: kui hinnad muutuvad või lisad mudeli, pead muutma vaid ühte rida. Allpool toodud määrad on soovituslikud ja need tuleks iga eelarve ülevaatuse käigus üle kontrollida.

from dataclasses import dataclass

@dataclass
class ModelRate:
    input_per_million: float
    output_per_million: float

# Ligikaudsed hinnad USD-des miljoni tokeni kohta
# Kontrolli alati jooksvaid hindu aadressil platform.openai.com/pricing
RATES = {
    "gpt-5.6-luna": ModelRate(input_per_million=0.20, output_per_million=1.20),
    "gpt-5.6-terra": ModelRate(input_per_million=2.0, output_per_million=12.0),
    "gpt-5.6-sol": ModelRate(input_per_million=5.0, output_per_million=30.0),
}

def calculate_cost(model: str, input_tokens: int,
                   output_tokens: int) -> float:
    """Arvutab päringu maksumuse USD-des."""
    rate = RATES.get(model)
    if not rate:
        raise ValueError(f"Tundmatu mudel: {model}")

    input_cost = (input_tokens / 1_000_000) * rate.input_per_million
    output_cost = (output_tokens / 1_000_000) * rate.output_per_million

    return input_cost + output_cost

# Näide
cost = calculate_cost("gpt-5.6-terra", input_tokens=1000, output_tokens=500)
print(f"Kulu: ${cost:.6f}")
# Tulemus: Kulu: $0.008000

Kaheksa kümnendikku sendist päringu kohta kõlab julgustavalt, kuni korrutad selle tootmises oleva vestlusroboti viiekümne tuhande päevase päringuga – see on nelisada dollarit päevas. Harjuta end mõtlema kuumahtudes, mitte kunagi üksiku päringu kaupa.

Reaalaegne kulude jälgija

Ühikuarvutused on kasutud, kui neid ei koondata. See jälgija koondab kulutused kolme telje lõikes – päeva, mudeli ja päringute arvu järgi – ning võrdleb päeva kogusummat sinu määratud eelarvega. Hoiatused on astmelised: hoiatus, kui eelarvest on jäänud vähem kui 20%, millele järgneb range hoiatus piiri ületamisel. See vaheaste on väärtuslik, sest annab sulle aega sekkuda enne teenuse katkestamist.

import json
from datetime import datetime, date
from collections import defaultdict

class CostTracker:
    """Reaalaegne API kulude jälgimine."""

    def __init__(self, daily_budget_usd: float = 10.0):
        self.daily_budget = daily_budget_usd
        self.costs_per_day: dict[str, float] = defaultdict(float)
        self.costs_per_model: dict[str, float] = defaultdict(float)
        self.calls_per_day: dict[str, int] = defaultdict(int)
        self.total_tokens = 0

    def record(self, model: str, input_tokens: int,
               output_tokens: int):
        """Salvestab päringu kulud."""
        cost = calculate_cost(model, input_tokens, output_tokens)
        today = date.today().isoformat()

        self.costs_per_day[today] += cost
        self.costs_per_model[model] += cost
        self.calls_per_day[today] += 1
        self.total_tokens += input_tokens + output_tokens

        return cost

    def remaining_budget(self) -> float:
        """Tagastab tänaseks päevaks järelejäänud eelarve."""
        today = date.today().isoformat()
        return self.daily_budget - self.costs_per_day[today]

    def budget_alert(self) -> bool:
        """Kontrollib, kas eelarve on piirile lähedal."""
        remaining = self.remaining_budget()
        if remaining <= 0:
            print("HOIATUS: Päevane eelarve ületatud!")
            return True
        elif remaining < self.daily_budget * 0.2:
            print(f"HOIATUS: Päevases eelarves on jäänud ${remaining:.2f}")
            return True
        return False

    def report(self) -> dict:
        """Genereerib kuluaruande."""
        return {
            "total_cost_usd": sum(self.costs_per_day.values()),
            "cost_today_usd": self.costs_per_day.get(
                date.today().isoformat(), 0
            ),
            "remaining_budget_usd": self.remaining_budget(),
            "costs_per_model": dict(self.costs_per_model),
            "total_tokens": self.total_tokens,
        }

# Kasutamine
tracker = CostTracker(daily_budget_usd=5.0)

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Tere!"
)

cost = tracker.record(
    model="gpt-5.6-terra",
    input_tokens=response.usage.input_tokens,
    output_tokens=response.usage.output_tokens
)
print(f"Selle päringu kulu: ${cost:.6f}")
print(json.dumps(tracker.report(), indent=2))

Eelarvekontrolliga klient

Jälgimisest ei piisa alati: tõrkega tsükli ees, mis kutsub API-d pidevalt, vajad finantsilist kaitselülitit. See klient kontrollib järelejäänud eelarvet enne päringu tegemist ja keeldub kategooriliselt päringust, kui limiit on ammendunud. Teenus degradeerub, kuid kontrollitud viisil ilma üllatusarveteta. Kuluarvestus toimub hiljem, kui tegelik kasutus on teada.

class BudgetControlledClient:
    "Klient, mis keeldub päringutest, kui eelarve on ületatud."

    def __init__(self, daily_budget: float = 10.0):
        self.client = OpenAI()
        self.tracker = CostTracker(daily_budget_usd=daily_budget)

    def create(self, model: str, input: str, **kwargs) -> object:
        """API päring eelarvekontrolliga."""
        # Kontrolli eelarvet enne päringut
        if self.tracker.remaining_budget() <= 0:
            raise RuntimeError(
                "Päevane eelarve ammendatud. "
                f"Kulutatud: ${self.tracker.report()['cost_today_usd']:.2f}"
            )

        response = self.client.responses.create(
            model=model,
            input=input,
            **kwargs
        )

        cost = self.tracker.record(
            model=model,
            input_tokens=response.usage.input_tokens,
            output_tokens=response.usage.output_tokens
        )

        # Hoiata, kui eelarve on madal
        self.tracker.budget_alert()

        return response

# Kasutamine
budget_client = BudgetControlledClient(daily_budget=2.0)

try:
    response = budget_client.create("gpt-5.6-terra", "Tere!")
    print(response.output_text)
except RuntimeError as e:
    print(f"Blokeeritud: {e}")

Kulude optimeerimine

1. Õige mudeli valik

Võimsaim hoob on suunamine keerukuse järgi. Kolme kategooria klassifitseerimisülesanne ei vaja kõige kallimat mudelit: selle ülesande puhul ulatub arve erinevus sama kvaliteedi korral 25-kordseks. Tee keerukusest oma funktsiooni selge parameeter, mitte loogikasse kodeeritud otsus.

# Suhteline kulu ülesande kohta (ligikaudne, ~300 sisendi tokenit / 20 väljundit):
# Lihtne klassifitseerimine: gpt-5.6-luna ~$0.0001 vs gpt-5.6-sol ~$0.002
# Õige mudel teeb kuludes 25-kordse vahe!

def optimized_call(prompt: str, complexity: str) -> str:
    """Valib kõige ökonoomsema sobiva mudeli."""
    model = {
        "simple": "gpt-5.6-luna",
        "standard": "gpt-5.6-terra",
        "complex": "gpt-5.6-sol",
    }.get(complexity, "gpt-5.6-terra")

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

2. Vastuste vahemällu salvestamine

Teine hoob on vältida sama vastuse eest kaks korda maksmist. KKK, tootekataloog või standardvorm genereerivad kümneid kordi päevas täpselt identseid vihjeid. Vahemäluvõti ühendab mudeli, sisendi ja parameetrid – kõigi kaasamine on hädavajalik, vastasel juhul tagastaks temperatuuri muutmine vaikselt vana vastuse.

import hashlib

class CachedClient:
    "Klient vahemäluga, et vältida tarbetuid päringuid."

    def __init__(self):
        self.client = OpenAI()
        self.cache: dict[str, str] = {}

    def create(self, model: str, input: str, **kwargs) -> str:
        # Loo vahemäluvõti
        cache_key = hashlib.md5(
            f"{model}:{input}:{json.dumps(kwargs, sort_keys=True)}".encode()
        ).hexdigest()

        if cache_key in self.cache:
            print("Vahemälu tabamus!")
            return self.cache[cache_key]

        response = self.client.responses.create(
            model=model, input=input, **kwargs
        )

        self.cache[cache_key] = response.output_text
        return response.output_text

3. Väljundi tokenite piiramine

Lõpuks, piira väljundit alati, kui selle pikkus on ennustatav. Kuna väljund on kallis osa, jätab ühe sõna küsimine kahe tuhande tokeni lubamisega ukse lahti sõnaohtrale vastusele, mille eest sa maksad, kuid mida ei kasuta.

# Määra ennustatavate ülesannete puhul alati max_output_tokens
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Klassifitseeri see tekst: positiivne, negatiivne või neutraalne.",
    max_output_tokens=10  # Oodatakse ühte sõna
)

Hinnad seisuga 5. august 2026 – hinnad muutuvad regulaarselt: enne mis tahes eelarve arvutamist kontrolli jooksvat hinnakirja ametlikul OpenAI hinnalehel.

Peamised punktid

  • Kulud sõltuvad mudelist JA suunast (sisend vs väljund)
  • Rakenda kulude jälgija eelarvehoiatustega
  • Kasuta iga ülesande jaoks õiget mudelit: Luna mahukate ülesannete jaoks, Terra vaikimisi
  • Vahemällu salvestamine võib korduvate päringute kulusid drastiliselt vähendada
  • Määra max_output_tokens, kui vastuse pikkus on ennustatav
  • Kontrolli ametlikku tarbimise jälgimist OpenAI armatuurlaualt