Izmaksu un lietojuma uzraudzība
Šajā lapā
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