Kulude optimeerimine suurel skaalal
Sellel lehel
Kulu kui inseneripiirang
Halvasti optimeeritud vihje, mis maksab taotluse kohta 0,002 dollarit, on arendusetapis tühine. Miljoni taotluse korral tähendab see 2000 dollarit – ja see maksab sulle sama summa iga kuu, kuni keegi selle ümber kirjutab. See mastaabi muutus teeb kulust inseneripiirangu: sa ei lahenda seda lepingut läbi rääkides, vaid koodi muutes.
Nähtavus on iga optimeerimise eeldus. Kuuarve ütleb, kui palju sa kulutasid, mitte kus. Seetõttu algab see õppetund instrumendistamise ehk mõõtmise seadistamisega enne kulude vähendamise hoobade käsitlemist.
Teadmine, kuhu raha läheb
Taotluse hinda määravad neli elementi ja need ei käitu ühtmoodi. Sisendtokenid, mis koondavad süsteemiviha, vestlusajaloo ja kasutaja sõnumi, kasvavad sessiooni kestusega. Väljundtokenid – genereeritud vastus – on hinnastatud oluliselt kõrgemalt kui sisend. Vahemällu salvestatud sisendtokenitele antakse sisendhinnast umbes 50% soodustust, mistõttu on nende jälgimine arve mõistmiseks hädavajalik. Lõpuks mudel ise: GPT-5.6 Luna on palju odavam kui GPT-5.6 Sol ja see tegur domineerib kõigi teiste ees.
Jälgimine tähendab iga API tagastatud usage objekti dollari summaks teisendamist, õige hinna rakendamist ja vahemällu salvestatud osa eraldamist.
import openai
from dataclasses import dataclass, field
client = openai.OpenAI()
# Hinnad miljoni tokeni kohta (juuli 2026) — cached_input on soovituslik (~50% sisendist),
# kohanda ametliku hinnakirja alusel
RATES = {
"gpt-5.6-luna": {"input": 0.20, "output": 1.20, "cached_input": 0.02},
"gpt-5.6-terra": {"input": 2.00, "output": 12.00, "cached_input": 0.20},
"gpt-5.6-sol": {"input": 5.00, "output": 30.00, "cached_input": 0.50},
}
@dataclass
class CostTracker:
"""Jälgib kulusid reaalajas."""
calls: list[dict] = field(default_factory=list)
def record(self, model: str, usage: dict) -> float:
input_tokens = usage.input_tokens
cached_tokens = getattr(
usage.input_tokens_details, "cached_tokens", 0
)
output_tokens = usage.output_tokens
uncached_input_tokens = input_tokens - cached_tokens
rate = RATES.get(model, RATES["gpt-5.6-terra"])
cost = (
(uncached_input_tokens / 1_000_000) * rate["input"]
+ (cached_tokens / 1_000_000) * rate["cached_input"]
+ (output_tokens / 1_000_000) * rate["output"]
)
self.calls.append({
"model": model,
"input_tokens": input_tokens,
"cached_tokens": cached_tokens,
"output_tokens": output_tokens,
"cost": cost,
})
return cost
@property
def total_cost(self) -> float:
return sum(a["cost"] for a in self.calls)
def report(self) -> str:
if not self.calls:
return "Ühtegi taotlust ei ole salvestatud."
return (
f"Taotlusi: {len(self.calls)} | "
f"Kogukulu: ${self.total_cost:.4f} | "
f"Keskmine kulu: ${self.total_cost / len(self.calls):.6f}"
)
tracker = CostTracker()
Tabelit RATES tuleb pidevalt silmas pidada: see aegub kohe, kui ametlik hinnakiri muutub. Kohtle seda konfiguratsiooniandmena, mida tuleb kontrollida, mitte programmi konstandina, ja tee keskmisest taotluse hinnast näitaja, mida igal nädalal üle vaatad.
Neli vähendamishooba
Esimene ja kaugelt kõige kasumlikum hoob on vältida kallite mudelite eest maksmist, kui ülesanne seda ei nõua. Selge suunamine keerukuse põhjal hoiab ära vaikimisi nihke, kus kogu liiklus lõpetab kõige kallimal mudelil lihtsalt sellepärast, et see ilmus esimesse kopeeritud näitesse.
async def economic_router(prompt: str, complexity: str) -> str:
"""Suunab odavaimale sobivale mudelile."""
if complexity == "simple":
model = "gpt-5.6-luna"
elif complexity == "medium":
model = "gpt-5.6-terra"
else:
model = "gpt-5.6-sol"
response = client.responses.create(model=model, input=prompt)
tracker.record(model, response.usage)
return response.output_text
Teine hoob läheb kaugemale, kui keerukust pole ette teada. Taotluse klassifitseerimise asemel proovib kaskaad kõigepealt odavaimat mudelit ja eskaleerub ainult siis, kui vastus ei läbi kvaliteedikontrolli. Siin kasutatav kontroll on tahtlikult lihtne – miinimumpikkus ja teadmatuse tunnistuse puudumine – ja just seda punkti pead täiustama: kaskaad, mis eskaleerub liiga sageli, muutub kallimaks kui otsene pöördumine õige mudeli poole.
async def model_cascade(prompt: str) -> str:
"""Proovib kõigepealt odavaimat mudelit."""
models = ["gpt-5.6-luna", "gpt-5.6-terra", "gpt-5.6-sol"]
for model in models:
response = client.responses.create(
model=model,
input=prompt,
max_output_tokens=500,
)
tracker.record(model, response.usage)
# Kontrolli kvaliteeti (lihtne heuristika)
text = response.output_text
if len(text) > 50 and "i don't know" not in text.lower():
return text
return text # Viimane tulemus isegi kui ebatäiuslik
Kolmas hoob sihib sisendtokeneid, mis kasvavad vaikselt igas vestlusrakenduses: kahekümnendaks pöördeks maksad iga sõnumiga tagasi eelmiste üheksateistkümne eest. Ajaloo tihendamine, hoides alles esimese sõnumi (mis sisaldab konteksti) ja viimase (mis sisaldab küsimust), ning täites ülejäänud mahu kõige värskemate vahetustega, säilitab olulise sidususe murdosa hinnaga.
def compress_history(
messages: list[dict],
max_tokens: int = 4000,
) -> list[dict]:
"""Hoiab alles kõige värskemad sõnumid eelarve piires."""
# Hoia alati alles esimene (kontekst) ja viimane (küsimus)
if len(messages) <= 2:
return messages
first = messages[0]
last = messages[-1]
middle = messages[1:-1]
# Hinda tokeneid (ligikaudne: 1 token ≈ 4 tähemärki)
fixed_tokens = (len(first["content"]) + len(last["content"])) // 4
middle_budget = max_tokens - fixed_tokens
# Hoia alles kõige värskemad sõnumid
result = []
tokens_used = 0
for msg in reversed(middle):
msg_tokens = len(msg["content"]) // 4
if tokens_used + msg_tokens > middle_budget:
break
result.insert(0, msg)
tokens_used += msg_tokens
return [first] + result + [last]
Neljas hoob ei nõua algoritmilist peenust, vaid distsipliini: Batch API pakub 50% soodustust ja sa pead lihtsalt tuvastama, mis võib oodata. Lase ülesandel endal kanda kiireloomulisust juba selle loomise hetkest, mitte ei tuletada seda hiljem – see on ainus viis vältida olukorda, kus kõik vaikimisi reaalaja järjekorda satuvad.
def classify_urgency(tasks: list[dict]) -> dict:
"""Eraldab ülesanded reaalaja ja partii töötlemise vahel."""
real_time = []
batch = []
for task in tasks:
if task.get("urgency") == "immediate":
real_time.append(task)
else:
batch.append(task)
return {
"real_time": real_time,
"batch": batch,
"estimated_savings": len(batch) * 0.001, # Näide
}
Hoiatus enne arvet
Kõik need optimeerimised võib tühistada üks ebaõnnestunud juurutus: piiramatu korduskatsete tsükkel, kolmekordistunud süsteemiviha, kogemata muudetud mudel. Kuluhäire on ohutusvõrk, mis hoiatab sind tundide, mitte kuu lõpu seisuga. Pane tähele vahepealset lävendit 80% juures: see muudab brutaalse alarmi varajaseks signaaliks, andes sulle aega tegutseda enne limiidi ületamist.
class CostAlert:
"""Käivitab hoiatused, kui kulud ületavad lävendi."""
def __init__(self, daily_threshold: float = 50.0):
self.threshold = daily_threshold
self.tracker = CostTracker()
def check(self) -> str | None:
if self.tracker.total_cost > self.threshold:
return (
f"HOIATUS: päevakulu ${self.tracker.total_cost:.2f} "
f"ületab lävendi ${self.threshold:.2f}"
)
if self.tracker.total_cost > self.threshold * 0.8:
return (
f"HOIATUS: kulu on {self.tracker.total_cost / self.threshold:.0%} "
f"päevasest lävendist"
)
return None
Peamised punktid
- Jälgi kulusid reaalajas, kasutades
response.usage - Suunata taotlus odavaimale ülesandega toime tulevale mudelile
- Kasuta Batch API-d (-50%) kõige jaoks, mis ei nõua reaalajas töötlemist
- Vähenda sisendtokeneid ajaloo tihendamisega
- Seadista kuluhoiatused, et vältida üllatusi