Stebėjimo išlaidos ir naudojimas
Šiame puslapyje
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