Išlaidų optimizavimas dideliu mastu
Šiame puslapyje
Išlaidos kaip inžinerinis apribojimas
Prastai optimizuotas užklausos šablonas, kainuojantis 0,002 USD už kvietimą, kūrimo metu atrodo nereikšmingas. Tačiau atlikus milijoną kvietimų, kaina siekia 2 000 USD – ir ji tau bus taikoma kas mėnesį, kol kas nors jo neperrašys. Šis mastelio pokytis paverčia išlaidas inžineriniu apribojimu: jų neišspręsi derėdamasis dėl sutarties, tai išspręsi pakeisdamas kodą.
Matomumas yra bet kokio optimizavimo priešaidė. Mėnesio sąskaita parodo, kiek išleidai, bet ne kur. Štai kodėl ši pamoka prasideda nuo instrumentavimo, prieš nagrinėjant mažinimo svertus.
Žinojimas, kur dingsta pinigai
Kvietimo kainą lemia keturi elementai, ir jie elgiasi skirtingai. Įvesties tokenai, apimantys sistemos užklausos šabloną, pokalbio istoriją ir naudotojo žinutę, didėja sesijos trukmei ilgėjant. Išvesties tokenai – sugeneruotas atsakymas – kainuoja žymiai brangiau nei įvestis. Talpykloje saugomi įvesties tokenai gauna maždaug 50 % nuolaidą nuo įvesties tarifo, todėl jų stebėjimas yra būtinas norint suprasti bet kurią sąskaitą. Galiausiai pats modelis: GPT-5.6 Luna yra daug pigesnis nei GPT-5.6 Sol, ir šis veiksnys dominuoja visus kitus.
Stebėjimas reiškia kiekvieno API grąžinamo usage objekto konvertavimą į dolerių sumą, taikant tinkamą tarifą ir išskiriant talpykloje esančią dalį.
import openai
from dataclasses import dataclass, field
client = openai.OpenAI()
# Tarifai už milijoną tokenų (2026 m. liepa) — cached_input yra orientacinis (~50 % nuo input),
# koreguokite pagal oficialų kainoraštį
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:
"""Stebi išlaidas realiuoju laiku."""
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 "Nėra užregistruotų kvietimų."
return (
f"Kvietimai: {len(self.calls)} | "
f"Bendra kaina: ${self.total_cost:.4f} | "
f"Vidutinė kaina: ${self.total_cost / len(self.calls):.6f}"
)
tracker = CostTracker()
Lentelė RATES reikalauja nuolatinio dėmesio: ji pasensta vos tik pasikeitus oficialiam kainoraščiui. Traktuok ją kaip konfigūracijos duomenis, kuriuos reikia tikrinti, o ne kaip programos konstantą, ir vidutinę vieno kvietimo kainą paversk metrika, kurią peržiūri kas savaitę.
Keturi mažinimo svertai
Pirmasis ir toli gražu pelningiausias svertas – vengti mokėti už aukščiausios klasės modelį, kai užduotis jo nereikalauja. Aiškus maršrutizavimas pagal sudėtingumą neleidžia vykti numatytajam nukrypimui, kai visas srautas atsiduria brangiausiame modelyje vien todėl, kad jis buvo pirmajame nukopijuotame pavyzdyje.
async def economic_router(prompt: str, complexity: str) -> str:
"""Nukreipia į pigiausią tinkamą modelį."""
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
Antrasis svertas eina dar toliau, kai sudėtingumas iš anksto nežinomas. Užuot klasifikavęs užklausą, kaskadas pirmiausia bando pigiausią modelį ir pereina prie kito tik tada, jei atsakymas neatlaiko kokybės patikros. Čia naudojama patikra yra tyčia primityvi – minimalus ilgis ir ignoravimo pripažinimo nebuvimas – ir būtent šią vietą tau reikės tobulinti: kaskadas, kuris per dažnai pereina prie aukštesnio lygio, tampa brangesnis nei tiesioginis kvietimas į tinkamą modelį.
async def model_cascade(prompt: str) -> str:
"""Pirmiausia bando pigiausią modelį."""
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)
# Tikrina kokybę (paprasta heuristika)
text = response.output_text
if len(text) > 50 and "i don't know" not in text.lower():
return text
return text # Paskutinis rezultatas, net jei netobulas
Trečiasis svertas taikomas įvesties tokenams, kurie bet kurioje pokalbių programoje tyčia auga: dvidešimtuoju posūkiu tu jau mokai už ankstesnius devyniolika su kiekviena žinute. Istorijos glaudinimas paliekant pirmąją žinutę (kuri turi kontekstą) ir paskutinę (kuri turi klausimą), o likusį biudžetą užpildant naujausiais mainais, išlaiko esminį nuoseklumą už dalį kainos.
def compress_history(
messages: list[dict],
max_tokens: int = 4000,
) -> list[dict]:
"""Palieka naujausias žinutes neviršijant biudžeto."""
# Visada paliekama pirmoji (kontekstas) ir paskutinė (klausimas)
if len(messages) <= 2:
return messages
first = messages[0]
last = messages[-1]
middle = messages[1:-1]
# Įvertinami tokenai (apytiksliai: 1 tokenas ≈ 4 simboliai)
fixed_tokens = (len(first["content"]) + len(last["content"])) // 4
middle_budget = max_tokens - fixed_tokens
# Paliekamos naujausios žinutės
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]
Ketvirtajam svertui nereikia algoritminio meistriškumo, tik disciplinos: „Batch API“ siūlo 50 % sumažinimą, tau tereikia nustatyti, kas gali palaukti. Leisk pačiai užduočiai nešti skubos požymį nuo jos sukūrimo momento, o ne bandyk to nustatyti vėliau – tai vienintelis būdas išvengti situacijos, kai viskas pagal nutylėjimą patenka į realiojo laiko eilę.
def classify_urgency(tasks: list[dict]) -> dict:
"""Atskiria užduotis į realiojo laiko ir paketines."""
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, # Pavyzdys
}
Įspėjimas prieš gaunant sąskaitą
Visus šiuos optimizavimus gali sugriauti vienas nesėkmingas diegimas: neribotas bandymų ciklas, patrigubintas sistemos užklausos šablonas, klaidingai pakeistas modelis. Išlaidų įspėjimas yra saugos tinklas, kuris įspėja tave per valandas, o ne mėnesio pabaigoje. Atkreipk dėmesį į tarpinę 80 % ribą: ji paverčia šiurkštų signalizavimą ankstyvu įspėjimu, suteikdama laiko imtis veiksmų prieš viršijant limitą.
class CostAlert:
"""Suaktyvina įspėjimus, kai išlaidos viršija ribą."""
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"ĮSPĖJIMAS: dienos išlaidos ${self.tracker.total_cost:.2f} "
f"viršija ribą ${self.threshold:.2f}"
)
if self.tracker.total_cost > self.threshold * 0.8:
return (
f"DĖMESIO: išlaidos siekia {self.tracker.total_cost / self.threshold:.0%} "
f"nuo dienos ribos"
)
return None
Svarbiausi punktai
- Stebėk išlaidas realiuoju laiku naudodamas
response.usage - Nukreipk užklausas į pigiausią užduotį atlikti pajėgų modelį
- Naudok „Batch API“ (-50 %) viskam, kas nereikalauja realiojo laiko apdorojimo
- Sumažink įvesties tokenus glaudindamas istoriją
- Nustatyk išlaidų įspėjimus, kad išvengtum netikėtumų