Kustannusten optimointi laajassa mittakaavassa
Tällä sivulla
Kustannus suunnittelurajoitteena
Huonosti optimoitu kehote, joka maksaa 0,002 dollaria kutsua kohden, on merkityksetön kehitysvaiheessa. Miljoonan kutsun kohdalla hinta nousee 2 000 dollariin – ja se maksaa sinulle saman summan joka kuukausi, kunnes joku kirjoittaa sen uudelleen. Tämä mittakaavan muutos tekee kustannuksista suunnittelurajoitteen: et ratkaise ongelmaa neuvottelemalla sopimuksesta, vaan muuttamalla koodia.
Näkyvyys on kaiken optimoinnin edellytys. Kuukausilasku kertoo, kuinka paljon olet käyttänyt rahaa, mutta ei sitä, mihin. Siksi tämä oppitunti aloittaa instrumentoinnista ennen kuin siirtyy vähentämiskeinoihin.
Tiedä, mihin raha menee
Neljä tekijää määrittävät kutsun hinnan, eivätkä ne käyttäydy samalla tavalla. Syötetokenit, jotka koostuvat järjestelmäkehotteesta, keskusteluhistoriasta ja käyttäjän viestistä, kasvavat istunnon keston myötä. Tulostetokenit – eli generoitu vastaus – hinnoitellaan huomattavasti kalliimmiksi kuin syötetokenit. Välimuistiin tallennetut syötetokenit saavat noin 50 % alennuksen syötteen normaalihinnasta, joten niiden seuranta on välttämätöntä laskujen ymmärtämiseksi. Viimeisenä on itse malli: GPT-5.6 Luna on huomattavasti edullisempi kuin GPT-5.6 Sol, ja tämä tekijä dominoi kaikkia muita.
Seuranta tarkoittaa jokaisen API:n palauttaman usage-objektin muuntamista dollarimääräksi soveltamalla oikeaa hintaa ja eristämällä välimuistiosuus.
import openai
from dataclasses import dataclass, field
client = openai.OpenAI()
# Hinnat miljoonaa tokenia kohden (heinäkuu 2026) — cached_input on suuntaa antava (~50 % inputista),
# säädä virallisen hintataulukon mukaan
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:
"""Seuraa kustannuksia reaaliajassa."""
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 "Ei kirjattuja kutsuja."
return (
f"Kutsuja: {len(self.calls)} | "
f"Kokonaiskustannus: ${self.total_cost:.4f} | "
f"Keskimääräinen kustannus: ${self.total_cost / len(self.calls):.6f}"
)
tracker = CostTracker()
RATES-taulukko vaatii jatkuvaa huomiota: se vanhentuu heti, kun virallinen hintataulukko muuttuu. Käsittele sitä konfiguraatiodatana, joka tulee tarkistaa, äläkä ohjelmavakiona, ja tee kutsun keskimääräisestä kustannuksesta mittari, jonka tarkistat viikoittain.
Neljä vähentämiskeinoa
Ensimmäinen ja selvästi kannattavin keino on välttää kalliin mallin käyttämistä, kun tehtävä ei sitä vaadi. Monimutkaisuuteen perustuva eksplisiittinen reititys estää hiljaisen ajautumisen tilanteeseen, jossa koko liikenne päätyy kalleimmalle mallille pelkästään siksi, että se esiintyi ensimmäisessä kopioidussa esimerkissä.
async def economic_router(prompt: str, complexity: str) -> str:
"""Reitittää halvimpaan tehtävään kykenevään malliin."""
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
Toinen keino menee pidemmälle silloin, kun monimutkaisuutta ei tunneta etukäteen. Pyynnön luokittelun sijaan kaskadi kokeilee ensin halvinta mallia ja eskaloituu vain, jos vastaus epäonnistuu laaduntarkistuksessa. Tässä käytetty tarkistus on tahallaan yksinkertainen – vähimmäispituus ja tiedonpuutteen myöntämisen puuttuminen – ja tämä on kohta, jota sinun tulee hioa: kaskadi, joka eskaloituu liian usein, tulee kalliimmaksi kuin suora kutsu oikeaan malliin.
async def model_cascade(prompt: str) -> str:
"""Kokeilee ensin halvinta mallia."""
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)
# Tarkista laatu (yksinkertainen heuristiikka)
text = response.output_text
if len(text) > 50 and "i don't know" not in text.lower():
return text
return text # Viimeinen tulos, vaikka olisi epätäydellinen
Kolmas keino kohdistuu syötetokeneihin, jotka kasvavat hiljaa missä tahansa keskustelevassa sovelluksessa: kahdenkymmenennen vuoron kohdalla maksat edelliset yhdeksäntoista uudelleen jokaisella viestillä. Historian tiivistäminen säilyttämällä ensimmäinen viesti (joka sisältää kontekstin) ja viimeinen (joka sisältää kysymyksen) sekä täyttämällä jäljellä oleva budjetti tuoreimmilla vaihdoilla säilyttää olennaisen yhtenäisyyden murto-osalla kustannuksista.
def compress_history(
messages: list[dict],
max_tokens: int = 4000,
) -> list[dict]:
"""Säilyttää tuoreimmat viestit budjetin puitteissa."""
# Säilytä aina ensimmäinen (konteksti) ja viimeinen (kysymys)
if len(messages) <= 2:
return messages
first = messages[0]
last = messages[-1]
middle = messages[1:-1]
# Arvioi tokenit (likiarvo: 1 token ≈ 4 merkkiä)
fixed_tokens = (len(first["content"]) + len(last["content"])) // 4
middle_budget = max_tokens - fixed_tokens
# Säilytä tuoreimmat viestit
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]
Neljäs keino ei vaadi algoritmista hienovaraisuutta, vain kuria: Batch API tarjoaa 50 % alennuksen, ja sinun tarvitsee vain tunnistaa, mikä voi odottaa. Anna tehtävän itsensä kantaa kiireellisyytensä luontihetkestä lähtien sen sijaan, että päätelisit sen jälkikäteen – tämä on ainoa tapa estää kaikkea ajautumasta oletusarvoisesti reaaliaikaiseen jonoon.
def classify_urgency(tasks: list[dict]) -> dict:
"""Erottää tehtävät reaaliaikaisiin ja eräajoihin."""
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, # Esimerkki
}
Varoitus ennen laskua
Kaikki nämä optimoinnit voivat peruuntua yhden epäonnisen käyttöönoton seurauksena: rajoittamaton uudelleenyrityssilmukka, kolminkertainen järjestelmäkehote tai vahingossa vaihdettu malli. Kustannushälytys on turvaverkko, joka varoittaa sinua tuntien sisällä eikä vasta kuukauden lopussa. Huomaa 80 %:n välikynnys: se muuttaa raa’an hälytyksen varhaiseksi signaaliksi, joka antaa sinulle aikaa toimia ennen rajan ylittymistä.
class CostAlert:
"""Laukaisee hälytykset, kun kustannukset ylittävät kynnyksen."""
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"HÄLYTYS: päivän kustannus ${self.tracker.total_cost:.2f} "
f"ylittää kynnyksen ${self.threshold:.2f}"
)
if self.tracker.total_cost > self.threshold * 0.8:
return (
f"VAROITUS: kustannus on {self.tracker.total_cost / self.threshold:.0%} "
f"päivittäisestä kynnyksestä"
)
return None
Keskeiset asiat
- Seuraa kustannuksiasi reaaliajassa käyttämällä
response.usage-tietoja - Reititä halvimpaan tehtävään kykenevään malliin
- Käytä Batch API:a (-50 %) kaikkeen, mikä ei vaadi reaaliaikaista käsittelyä
- Vähennä syötetokeneita tiivistämällä historiaa
- Määritä kustannushälytykset välttääksesi yllätyksiä