Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Stebėjimo išlaidos ir naudojimas

Paskaita 16 iš 22 Atnaujinta 2026 m. liepos 29 d. Kūrėjas
Šiame puslapyje
  1. Stebėjimo išlaidos ir naudojimas
  2. Sąskaitų faktūrų supratimas
  3. Išlaidų skaičiuoklė
  4. Realaus laiko išlaidų stebėtojas
  5. Klientas su biudžeto valdymu
  6. Išlaidų optimizavimas
  7. Svarbiausi punktai

Stebėjimo išlaidos ir naudojimas

API išlaidos gali greitai išaugti nekontroliuojamai, jei jų nestebi. Šioje pamokoje sužinosi, kaip sekti, įvertinti ir valdyti savo išlaidas gamybos aplinkoje. Istorija kartojasi nuo projekto iki projekto: funkcija paleidžiama ketvirtadienį, per savaitgalį niekas nepatikrina skydelio, o pirmadienio ryte sąskaita atitinka visą mėnesio biudžetą. Toliau pateikti veiksmai padės pastebėti išlaidų nukrypimus tą pačią akimirką, kai jie įvyksta, o ne po trisdešimties dienų.

Sąskaitų faktūrų supratimas

Išlaidos apskaičiuojamos už milijoną tokenų, taikant skirtingas kainas įvesties ir išvesties duomenims. Ši asimetrija tiesiogiai veikia tavo dizaino sprendimus: ilgo dokumento siuntimas kaip įvestis kainuoja žymiai mažiau nei modelio generuojamas ilgas atsakymas. Kiekvienas atsakymas grąžina tikslius abiejų krypčių skaičius, todėl tau niekada nereikia jų įvertinti apytiksliai.

from openai import OpenAI
client = OpenAI()

# Kiekvienas atsakymas apima naudojimo metrikas
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}")

# Išvestis kainuoja daugiau nei įvestis!

Išlaidų skaičiuoklė

Norint šiuos skaitiklius paversti doleriais, reikia kainoraščio. Izoliuok jį atskiroje struktūroje, užuot išbarstęs konstantas po visą kodą: kai kainos pasikeis arba pridėsi naują modelį, tau reikės pakeisti tik vieną eilutę. Toliau pateikti tarifai yra orientaciniai ir turėtų būti patikrinti per kiekvieną biudžeto peržiūrą.

from dataclasses import dataclass

@dataclass
class ModelRate:
    input_per_million: float
    output_per_million: float

# Apytikslės kainos USD už milijoną tokenų
# Visada tikrink dabartines kainas 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:
    """Apskaičiuoja užklausos kainą 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

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

Aštuoni dešimtieji cento už vieną užklausą skamba raminančiai, kol tai padaugini iš penkiasdešimties tūkstančių kasdienių gamybos pokalbių roboto užklausų – tai keturi šimtai dolerių per dieną. Visada įprask galvoti mėnesinių apimčių kategorijomis, o ne vienos užklausos.

Realaus laiko išlaidų stebėtojas

Vienetiniai skaičiavimai yra nenaudingi, jei jie nėra agreguoti. Šis stebėtojas kaupia išlaidas trimis ašimis: pagal dieną, pagal modelį ir pagal užklausų skaičių, bei lygina dienos sumą su tavo nustatytu biudžetu. Įspėjimai yra laipsniški: perspėjimas, kai lieka mažiau nei 20 % biudžeto, o vėliau – griežtas įspėjimas viršijus limitą. Šis tarpinis žingsnis yra vertingas, nes suteikia laiko imtis veiksmų prieš nutraukiant paslaugą.

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

class CostTracker:
    """Realaus laiko API išlaidų stebėjimas."""

    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):
        """Įrašo užklausos išlaidas."""
        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:
        """Grąžina likusį šiandienos biudžetą."""
        today = date.today().isoformat()
        return self.daily_budget - self.costs_per_day[today]

    def budget_alert(self) -> bool:
        """Tikrina, ar biudžetas artimas limitui."""
        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:
        """Generuoja išlaidų ataskaitą."""
        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,
        }

# Naudojimas
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))

Klientas su biudžeto valdymu

Stebėjimo ne visada pakanka: susidūrus su klaidinga kilpa, be perstojo kviečiančia API, tau reikia finansinio grandinės pertraukiklio. Šis klientas patikrina likusį biudžetą prieš siųsdamas užklausą ir kategoriškai atsisako vykdyti kvietimą, jei limitas yra išnaudotas. Paslauga degraduoja, tačiau tai vyksta kontroliuojamu būdu be netikėtų sąskaitų. Išlaidų apskaita atliekama vėliau, kai jau žinomas faktinis naudojimas.

class BudgetControlledClient:
    """Klientas, atsisakantis kvietimų, jei viršijamas biudžetas."""

    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 kvietimas su biudžeto valdymu."""
        # Patikrink biudžetą prieš kvietimą
        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
        )

        # Įspėk, jei biudžetas mažas
        self.tracker.budget_alert()

        return response

# Naudojimas
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}")

Išlaidų optimizavimas

1. Tinkamo modelio pasirinkimas

Svarčiausias svertas išlieka maršrutizavimas pagal sudėtingumą. Trijų kategorijų klasifikavimo užduočiai nereikia brangiausio modelio: šiai užduočiai sąskaitos skirtumas siekia dvidešimt penkis kartus esant tokiai pačiai kokybei. Paversk sudėtingumą aiškiu savo funkcijos parametru, o ne logikoje įtvirtintu sprendimu.

# Santykinė kaina vienai užduočiai (apytikslė, ~300 įvesties tokenų / 20 išvesties):
# Paprasta klasifikacija: gpt-5.6-luna ~0,0001 $ vs gpt-5.6-sol ~0,002 $
# Tinkamas modelis lemia 25 kartų išlaidų skirtumą!

def optimized_call(prompt: str, complexity: str) -> str:
    """Pasirenka ekonomiškiausią tinkamą 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. Atsakymų kaupimas į podėlį

Antras svertas – vengti mokėti du kartus už tą patį atsakymą. DUK, produktų katalogas ar standartinė forma dešimtis kartų per dieną generuoja visiškai identiškas užklausas. Podėlio raktas sujungia modelį, įvestį ir parametrus – įtraukti visus juos yra būtina, kitaip temperatūros pakeitimas tyliai grąžintų seną atsakymą.

import hashlib

class CachedClient:
    """Klientas su podėliu, vengiantis perteklinių kvietimų."""

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

    def create(self, model: str, input: str, **kwargs) -> str:
        # Sukurk podėlio raktą
        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. Išvesties tokenų ribojimas

Galiausiai, visada nustatyk išvesties limitą, kai jos ilgis yra nuspėjamas. Kadangi išvestis yra brangioji dalis, prašant vieno žodžio, bet leidžiant du tūkstančius tokenų, paliekamos durys išsamiam atsakymui, kurį sumokėsi, bet nenaudosi.

# Visada nustatyk max_output_tokens nuspėjamosioms užduotims
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Classify this text: positive, negative, or neutral.",
    max_output_tokens=10  # Tikimasi vieno žodžio
)

Tarifai galioja nuo 2026 m. rugpjūčio 5 d. – kainos keičiasi reguliariai: prieš atlikdami bet kokius biudžeto skaičiavimus, patikrinkite dabartinį kainoraštį oficialiame „OpenAI“ kainų puslapyje.

Svarbiausi punktai

  • Išlaidos priklauso nuo modelio IR krypties (įvestis prieš išvestį)
  • Įdiek išlaidų stebėtoją su biudžeto įspėjimais
  • Naudok tinkamą modelį kiekvienai užduočiai: „Luna“ didelėms apimtims, „Terra“ pagal nutylėjimą
  • Podėlis gali drastiškai sumažinti išlaidas pasikartojančioms užklausoms
  • Nustatyk max_output_tokens, kai atsakymo ilgis yra nuspėjamas
  • Tikrink „OpenAI“ skydelį oficialiam vartojimo stebėjimui