Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Izmaksu un lietojuma uzraudzība

Nodarbība 16 no 22 Atjaunota 2026. gada 29. jūlijs Programmētājs
Šajā lapā
  1. Izmaksu un lietojuma uzraudzība
  2. Rēķinu izpratne
  3. Izmaksu kalkulators
  4. Reāllaika izmaksu izsekotājs
  5. Klients ar budžeta kontroli
  6. Izmaksu optimizēšana
  7. Galvenās atziņas

Izmaksu un lietojuma uzraudzība

API izmaksas var strauji iziet no kontroles, ja tās neuzraugi. Šajā nodarbībā tu iemācīsies izsekot, prognozēt un kontrolēt savus tēriņus darbvidē. Stāsts atkārtojas projektā pēc projekta: funkcija tiek palaista ceturtdienā, neviens brīvdienās nepārbauda informācijas paneli, un pirmdienas rīta rēķins atbilst visa mēneša budžetam. Tālāk minētie soļi palīdzēs tev pamanīt izmaksu novirzes brīdī, kad tās notiek, nevis trīsdesmit dienas vēlāk.

Rēķinu izpratne

Izmaksas tiek aprēķinātas par miljonu tokeniem, un ievades (input) un izvades (output) cenās pastāv atšķirības. Šī asimetrija tieši ietekmē tavus dizaina lēmumus: garu dokumentu nosūtīšana kā ievade izmaksā ievērojami mazāk nekā modeļa ģenerēts garš teksts. Katra atbilde satur precīzu abu virzienu skaitu, tāpēc tev nekad nav jāmin.

from openai import OpenAI
client = OpenAI()

# Katra atbilde ietver lietojuma 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}")

# Izvade maksā vairāk nekā ievade!

Izmaksu kalkulators

Lai pārvērstu šos skaitītājus dolāros, nepieciešama cenu tabula. Izolē to atsevišķā struktūrā, nevis izkliedē konstantes visā kodā: ja cenas mainās vai pievieno jaunu modeli, tev jāmaina tikai viena rindiņa. Zemāk norādītās likmes ir orientējošas, un tās jāpārbauda katras budžeta pārskatīšanas laikā.

from dataclasses import dataclass

@dataclass
class ModelRate:
    input_per_million: float
    output_per_million: float

# Aptuvenās cenas USD par miljonu tokeniem
# Vienmēr pārbaudi aktuālās cenas vietnē 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:
    """Aprēķina zvana izmaksas 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

# Piemērs
cost = calculate_cost("gpt-5.6-terra", input_tokens=1000, output_tokens=500)
print(f"Cost: ${cost:.6f}")
# Rezultāts: Cost: $0.008000

Astoņas desmitdaļas centa par vienu zvanu šķiet nomierinoši, līdz to sareizini ar piecdesmit tūkstošiem ikdienas zvanu, ko veic darbvides čatbots, — tas ir četrsimt dolāru dienā. Vienmēr pierod domāt mēneša apjomos, nevis par vienu zvanu.

Reāllaika izmaksu izsekotājs

Vienību aprēķini ir bezjēdzīgi, ja tie netiek apkopoti. Šis izsekotājs apkopo izdevumus pa trim asīm — pa dienām, pa modeļiem un pa zvanu skaitu — un salīdzina dienas kopsummu ar tavu noteikto budžetu. Brīdinājumi ir pakāpeniski: brīdinājums, kad atlicis mazāk par 20 % no budžeta, kam seko stingrs brīdinājums, pārsniedzot limitu. Šis starpposms ir vērtīgs, jo tas dod tev laiku iejaukties, pirms pakalpojums tiek pārtraukts.

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

class CostTracker:
    """Reāllaika API izmaksu izsekošana."""

    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):
        """Reģistrē zvana izmaksas."""
        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:
        """Atgriež atlikušo budžetu šodienai."""
        today = date.today().isoformat()
        return self.daily_budget - self.costs_per_day[today]

    def budget_alert(self) -> bool:
        """Pārbauda, vai budžets ir tuvu limitam."""
        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:
        """Ģenerē izmaksu pārskatu."""
        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,
        }

# Lietošana
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))

Klients ar budžeta kontroli

Uzraudzība ne vienmēr ir pietiekama: saskaroties ar kļūdainu cilpu, kas nepārtraukti izsauc API, tev ir nepieciešams finanšu „drošinātājs”. Šis klients pārbauda atlikušo budžetu pirms pieprasījuma nosūtīšanas un kategoriski atsaka zvanu, ja aploksne ir izsmelta. Pakalpojums pasliktinās, bet kontrolētā veidā bez negaidītiem rēķiniem. Izmaksu uzskaite notiek pēc tam, kad faktiskais lietojums ir zināms.

class BudgetControlledClient:
    "Klients, kas atsaka zvanus, ja budžets ir pārsniegts."

    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 zvans ar budžeta kontroli."""
        # Pārbaudi budžetu pirms zvana
        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
        )

        # Brīdini, ja budžets ir zems
        self.tracker.budget_alert()

        return response

# Lietošana
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}")

Izmaksu optimizēšana

1. Pareizā modeļa izvēle

Visspēcīgākais svira joprojām ir maršrutēšana pēc sarežģītības. Trīs kategoriju klasifikācijas uzdevumam nav vajadzīgs dārgākais modelis: šim uzdevumam rēķina starpība sasniedz divdesmit piecas reizes pie identiskas kvalitātes. Padari sarežģītību par savu funkciju skaidru parametru, nevis lēmumu, kas iekodēts loģikā.

# Relatīvās izmaksas par uzdevumu (aptuveni, ~300 ievades tokeni / 20 izvade):
# Vienkārša klasifikācija: gpt-5.6-luna ~$0.0001 pret gpt-5.6-sol ~$0.002
# Pareizais modelis rada 25 reižu atšķirību izmaksās!

def optimized_call(prompt: str, complexity: str) -> str:
    """Izvēlas visekonomiskāko piemēroto modeli."""
    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. Atbilžu kešošana

Otrā svira ir izvairīšanās no maksāšanas divreiz par vienu un to pašu atbildi. BUJ, produktu katalogs vai standarta veidlapa ģenerē stingri identiskus uzvedumus desmitiem reižu dienā. Keša atslēga apvieno modeli, ievadi un parametrus — ir būtiski iekļaut tos visus, pretējā gadījumā temperatūras izmaiņas klusi atgrieztu veco atbildi.

import hashlib

class CachedClient:
    "Klients ar kešu, lai izvairītos no liekiem zvaniem."

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

    def create(self, model: str, input: str, **kwargs) -> str:
        # Izveido keša atslēgu
        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. Izvades tokenu ierobežošana

Visbeidzot, ierobežo izvadi, kad tās garums ir paredzams. Tā kā izvade ir dārgākā daļa, viena vārda pieprasīšana, atļaujot divus tūkstošus tokenus, atstāj durvis vaļā verbosai atbildei, par kuru samaksāsi, bet kuru neizmantosi.

# Vienmēr iestati max_output_tokens paredzamiem uzdevumiem
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Classify this text: positive, negative, or neutral.",
    max_output_tokens=10  # Sagaidāms viens vārds
)

Likmes uz 2026. gada 5. augustu — cenas regulāri mainās: pirms jebkādiem budžeta aprēķiniem pārbaudi aktuālo tabulu oficiālajā OpenAI cenu lapā.

Galvenās atziņas

  • Izmaksas ir atkarīgas no modeļa UN virziena (ievade pret izvadi)
  • Ievies izmaksu izsekotāju ar budžeta brīdinājumiem
  • Izmanto pareizo modeli katram uzdevumam: Luna apjomam, Terra pēc noklusējuma
  • Kešošana var drastiski samazināt izmaksas atkārtotiem pieprasījumiem
  • Iestati max_output_tokens, ja atbildes garums ir paredzams
  • Pārbaudi OpenAI informācijas paneli oficiālai patēriņa uzraudzībai