Izmaksu optimizēšana mērogā
Šajā lapā
Izmaksas kā inženiertehniskais ierobežojums
Slikti optimizēts uzvednis, kas maksā 0,002 USD par pieprasījumu, izstrādes posmā šķiet niecīgs. Veicot miljonu pieprasījumu, tas izmaksā 2000 USD — un tas tev izmaksās tikpat katru mēnesi, līdz kāds to pārraksta. Šī mēroga maiņa pārvērš izmaksas par inženiertehnisku ierobežojumu: tu to neatrisini, vedot sarunas par līgumu, bet gan mainot kodu.
Redzamība ir priekšnoteikums jebkurai optimizācijai. Mēneša rēķins parāda, cik daudz tu esi iztērējis, bet ne kur tieši. Tāpēc šī nodarbība sākas ar instrumentēšanu, pirms tiek apskatīti samazināšanas sviras.
Zinot, kur dodas nauda
Pieprasījuma izmaksas nosaka četri elementi, un tie uzvedas atšķirīgi. Ievades tokeni, kas apvieno sistēmas uzvedni, sarunu vēsturi un lietotāja ziņojumu, pieaug, ilgstošai sesijai. Izvades tokeni — ģenerētā atbilde — tiek tarifēti ievērojami dārgāk nekā ievade. Kešotie ievades tokeni saņem aptuveni 50 % atlaidi no ievades tarifa, tāpēc to izsekošana ir būtiska, lai saprastu jebkuru rēķinu. Visbeidzot, pats modelis: GPT-5.6 Luna ir daudz lētāks nekā GPT-5.6 Sol, un šis faktors dominē pār visiem pārējiem.
Izsekošana nozīmē katru API atgriezto usage objektu pārvērst dolāru summā, piemērojot pareizo tarifu un izolējot kešoto daļu.
import openai
from dataclasses import dataclass, field
client = openai.OpenAI()
# Tarifi par miljonu tokeniem (2026. gada jūlijs) — cached_input ir orientējošs (~50% no input),
# pielāgojiet atbilstoši oficiālajam cenu sarakstam
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:
"""Izmaksu izsekošana reāllaikā."""
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 "Nav reģistrētu pieprasījumu."
return (
f"Pieprasījumi: {len(self.calls)} | "
f"Kopējās izmaksas: ${self.total_cost:.4f} | "
f"Vidējās izmaksas: ${self.total_cost / len(self.calls):.6f}"
)
tracker = CostTracker()
Tabulai RATES nepieciešama pastāvīga uzmanība: tā kļūst novecojusi tiklīdz mainās oficiālais cenu saraksts. Uztveri to kā konfigurācijas datus, kas jāpārbauda, nevis kā programmas konstanti, un padari vidējās izmaksas par pieprasījumu par metrikas rādītāju, ko pārskati ik nedēļu.
Četras sviras samazināšanai
Pirmā un tālu ienesīgākā svira ir izvairīšanās no maksāšanas par augstas klases modeli, ja uzdevums to neprasa. Eksplicīta maršrutēšana, balstoties uz sarežģītību, novērš noklusējuma novirzi, kurā visa plūsma nonāk pie dārgākā modeļa vienkārši tāpēc, ka tas parādījās pirmajā nokopētajā piemērā.
async def economic_router(prompt: str, complexity: str) -> str:
"""Maršrutē uz lētāko modeli, kas spēj veikt uzdevumu."""
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
Otrā svira iet tālāk, ja sarežģītība nav zināma iepriekš. Tā vietā, lai klasificētu pieprasījumu, kaskāde vispirms izmēģina lētāko modeli un paaugstina līmeni tikai tad, ja atbilde neiztur kvalitātes pārbaudi. Šeit izmantotā pārbaude ir apzināti primitīva — minimālais garums un ignorēšanas atzīšanas trūkums — un tieši šeit tev būs jāveic uzlabojumi: kaskāde, kas pārāk bieži paaugstina līmeni, kļūst dārgāka nekā tiešs pieprasījums pareizajam modelim.
async def model_cascade(prompt: str) -> str:
"""Vispirms izmēģina lētāko modeli."""
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)
# Kvalitātes pārbaude (vienkārša heuristika)
text = response.output_text
if len(text) > 50 and "i don't know" not in text.lower():
return text
return text # Pēdējais rezultāts pat tad, ja nepilnīgs
Trešā svira ir vērsta uz ievades tokeniem, kas klusējot pieaug jebkurā sarunu lietotnē: līdz divdesmitajam gājienam tu ar katru ziņojumu atmaksā par iepriekšējiem deviņpadsmit. Vēstures kompresija, saglabājot pirmo ziņojumu (kas satur kontekstu) un pēdējo (kas satur jautājumu), un atlikušo budžetu aizpildot ar jaunākajām apmaiņām, saglabā būtisku sakarību par daļu no izmaksām.
def compress_history(
messages: list[dict],
max_tokens: int = 4000,
) -> list[dict]:
"""Saglabā jaunākos ziņojumus budžeta robežās."""
# Vienmēr saglabā pirmo (konteksts) un pēdējo (jautājums)
if len(messages) <= 2:
return messages
first = messages[0]
last = messages[-1]
middle = messages[1:-1]
# Tokenu novērtējums (aptuveni: 1 tokens ≈ 4 rakstzīmes)
fixed_tokens = (len(first["content"]) + len(last["content"])) // 4
middle_budget = max_tokens - fixed_tokens
# Saglabā jaunākos ziņojumus
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]
Ceturtā svira neprasa algoritmisku smalkumu, tikai disciplīnu: Batch API piedāvā 50 % samazinājumu, un tev tikai jāidentificē, kas var pagaidīt. Ļauj uzdevumam pašam nest steidzamību no tā radīšanas brīža, nevis secināt to pēc tam — tas ir vienīgais veids, kā novērst visu nokļūšanu realitātes laika rindā.
def classify_urgency(tasks: list[dict]) -> dict:
"""Atdala uzdevumus realitātes laika un batch apstrādei."""
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, # Piemērs
}
Brīdinājumu saņemšana pirms rēķina
Visas šīs optimizācijas var tikt iznīcinātas ar vienu neveiksmīgu izvietošanu: neierobežota atkārtojumu cilpa, trīskāršots sistēmas uzvednis, kļūdaini nomainīts modelis. Izmaksu brīdinājums ir drošības tīkls, kas tevi brīdina stundu laikā, nevis mēneša beigās. Ņem vērā starpposma slieksni pie 80 %: tas pārvērš brutālu trauksmi agrīnā signālā, dodot laiku rīkoties pirms limita pārsniegšanas.
class CostAlert:
"""Iedarbina brīdinājumus, kad izmaksas pārsniedz slieksni."""
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"TRAUKSME: dienas izmaksas ${self.tracker.total_cost:.2f} "
f"pārsniedz slieksni ${self.threshold:.2f}"
)
if self.tracker.total_cost > self.threshold * 0.8:
return (
f"BRĪDINĀJUMS: izmaksas sasniegušas {self.tracker.total_cost / self.threshold:.0%} "
f"no dienas sliekšņa"
)
return None
Galvenās atziņas
- Izseko savas izmaksas reāllaikā, izmantojot
response.usage - Maršrutē uz lētāko modeli, kas spēj veikt uzdevumu
- Izmanto Batch API (-50 %) visam, kam nav nepieciešama realitātes laika apstrāde
- Samazini ievades tokenus, kompresējot vēsturi
- Iestatī izmaksu brīdinājumus, lai izvairītos no pārsteigumiem