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

Spremljanje stroškov in porabe

Lekcija 16 od 22 Posodobljeno 29. julij 2026 Razvijalec
Na tej strani
  1. Spremljanje stroškov in porabe
  2. Razumevanje obračunavanja
  3. Kalkulator stroškov
  4. Sledilnik stroškov v realnem času
  5. Odjemalec z nadzorom proračuna
  6. Optimizacija stroškov
  7. Ključne ugotovitve

Spremljanje stroškov in porabe

Stroški API-ja lahko hitro uidejo nadzoru, če jih ne spremljaš. Ta lekcija te nauči, kako v proizvodnem okolju slediti, ocenjevati in nadzorovati svojo porabo. Zgodba se iz projekta v projekt ponavlja: funkcija zaživi v četrtek, čez vikend nihče ne preveri nadzorne plošče, v ponedeljek zjutraj pa račun ustreza celotnemu mesečnemu proračunu. Spodnji koraki ti pomagajo zaznati odmik stroškov v trenutku, ko se zgodi, in ne šele trideset dni kasneje.

Razumevanje obračunavanja

Stroški se izračunavajo na milijon žetonov, pri čemer so cene za vhodne in izhodne podatke različne. Ta asimetrija ima neposredne posledice za tvoje odločitve pri načrtovanju: pošiljanje dolgega dokumenta kot vhoda stane bistveno manj kot to, da model generira dolg odgovor. Vsak odziv vrne točno število žetonov za obe smeri, zato ti nikoli ni treba ocenjevati.

from openai import OpenAI
client = OpenAI()

# Vsak odziv vključuje metrike porabe
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Explain OpenAI API billing."
)

usage = response.usage
print(f"Input tokens: {usage.input_tokens}")
print(f"Output tokens: {usage.output_tokens}")
print(f"Total tokens: {usage.total_tokens}")

# Izhod stane več kot vhod!

Kalkulator stroškov

Pretvorba teh števcov v dolarje zahteva cenik. Izoliraj ga v namensko strukturo, namesto da konstante razpršiš po svoji kodi: ko se cene spremenijo ali dodaš nov model, moraš spremeniti le eno vrstico. Spodnje stopnje so okvirne in jih je treba preveriti ob vsakem pregledu proračuna.

from dataclasses import dataclass

@dataclass
class ModelRate:
    input_per_million: float
    output_per_million: float

# Približne cene v USD na milijon žetonov
# Vedno preveri trenutne cene na 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:
    """Izračuna strošek klica v USD."""
    rate = RATES.get(model)
    if not rate:
        raise ValueError(f"Unknown model: {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

# Primer
cost = calculate_cost("gpt-5.6-terra", input_tokens=1000, output_tokens=500)
print(f"Cost: ${cost:.6f}")
# Rezultat: Cost: $0.008000

Osem desetin centa na klic sliši pomirjujoče, dokler tega ne pomnožiš s petdeset tisoč dnevnimi klici proizvodnega klepetalnega bota – to je štiristo dolarjev na dan. Vedno si navadi razmišljati v mesečnih obsegih, nikoli na klic.

Sledilnik stroškov v realnem času

Izračuni na enoto so neuporabni, če niso agregirani. Ta sledilnik združuje porabo po treh oseh – po dnevih, po modelih in po številu klicev – ter primerja dnevni seštevek s proračunom, ki si ga določil. Opozorila so stopnjevana: opozorilo, ko ostane manj kot 20 % proračuna, ki mu sledi strogo opozorilo ob prekoračitvi limite. Ta vmesni korak je dragocen, ker ti da čas za posredovanje, preden se storitev izklopi.

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

class CostTracker:
    """Sledenje stroškom API-ja v realnem času."""

    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):
        """Zabeleži stroške klica."""
        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:
        """Vrne preostali proračun za danes."""
        today = date.today().isoformat()
        return self.daily_budget - self.costs_per_day[today]

    def budget_alert(self) -> bool:
        """Preveri, ali je proračun blizu limite."""
        remaining = self.remaining_budget()
        if remaining <= 0:
            print("ALERT: Daily budget exceeded!")
            return True
        elif remaining < self.daily_budget * 0.2:
            print(f"WARNING: ${remaining:.2f} remaining on daily budget")
            return True
        return False

    def report(self) -> dict:
        """Ustvari poročilo o stroških."""
        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,
        }

# Uporaba
tracker = CostTracker(daily_budget_usd=5.0)

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

cost = tracker.record(
    model="gpt-5.6-terra",
    input_tokens=response.usage.input_tokens,
    output_tokens=response.usage.output_tokens
)
print(f"Cost of this call: ${cost:.6f}")
print(json.dumps(tracker.report(), indent=2))

Odjemalec z nadzorom proračuna

Spremljanje ni vedno dovolj: ob okvari zanke, ki neprestano kliče API, potrebuješ finančno varovalko. Ta odjemalec preveri preostali proračun preden izda zahtevo in klic odkloni, če je ovojnica izčrpana. Storitev se poslabša, a na nadzorovan način brez presenečenj na računu. Knjigovodstvo stroškov poteka naknadno, ko je dejanska poraba znana.

class BudgetControlledClient:
    """Odjemalec, ki zavrne klice, če je proračun presežen."""

    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:
        """Klic API-ja z nadzorom proračuna."""
        # Preveri proračun pred klicem
        if self.tracker.remaining_budget() <= 0:
            raise RuntimeError(
                "Daily budget exhausted. "
                f"Spent: ${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
        )

        # Opozori, če je proračun nizek
        self.tracker.budget_alert()

        return response

# Uporaba
budget_client = BudgetControlledClient(daily_budget=2.0)

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

Optimizacija stroškov

1. Izbira pravega modela

Najmočnejša vzvod ostaja usmerjanje glede na kompleksnost. Naloga razvrščanja v tri kategorije ne potrebuje najdražjega modela: za to nalogo razlika v računu doseže faktor dvajset pet pri enaki kakovosti. Naj bo kompleksnost ekspliciten parameter tvoje funkcije, namesto odločitve, trdo kodirane v logiki.

# Relativni strošek na nalogo (približno, ~300 vhodnih žetonov / 20 izhodnih):
# Preprosto razvrščanje: gpt-5.6-luna ~0,0001 $ proti gpt-5.6-sol ~0,002 $
# Pravi model naredi 25-kratno razliko v stroških!

def optimized_call(prompt: str, complexity: str) -> str:
    """Izbere najbolj ekonomičen ustrezen model."""
    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. Predpomnjenje odzivov

Drugi vzvod je izogibanje dvojnemu plačevanju za isti odziv. Pogosta vprašanja (FAQ), katalog izdelkov ali standardni obrazci generirajo desetine krat na dan strogo identične pozive. Ključ predpomnilnika združuje model, vhod in parametre – vključitev vseh je bistvena, sicer bi sprememba temperature tiho vrnila stari odziv.

import hashlib

class CachedClient:
    """Odjemalec s predpomnilnikom za izogibanje odvečnim klicem."""

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

    def create(self, model: str, input: str, **kwargs) -> str:
        # Ustvari ključ predpomnilnika
        cache_key = hashlib.md5(
            f"{model}:{input}:{json.dumps(kwargs, sort_keys=True)}".encode()
        ).hexdigest()

        if cache_key in self.cache:
            print("Cache hit!")
            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. Omejevanje izhodnih žetonov

Končno, omeji izhod, kadar je njegova dolžina predvidljiva. Ker je izhod dragi del, zahteva ene same besede ob dovoljenju dveh tisoč žetonov pušča odprta vrata za zgovoren odziv, za katerega boš plačal, ga pa ne boš uporabil.

# Za predvidljive naloge vedno nastavi max_output_tokens
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Classify this text: positive, negative, or neutral.",
    max_output_tokens=10  # Pričakujemo eno samo besedo
)

Cene z dne 5. avgusta 2026 – cene se redno spreminjajo: pred vsakim izračunom proračuna preveri trenutni cenik na uradni strani s cenami OpenAI.

Ključne ugotovitve

  • Stroški so odvisni od modela IN smeri (vhod proti izhodu)
  • Implementiraj sledilnik stroškov z opozorili o proračunu
  • Uporabi pravi model za vsako nalogo: Luna za obsežne naloge, Terra privzeto
  • Predpomnjenje lahko drastično zmanjša stroške pri ponavljajočih se zahtevah
  • Nastavi max_output_tokens, kadar je dolžina odziva predvidljiva
  • Za uradno sledenje porabi preveri nadzorno ploščo OpenAI