Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Kustannusten optimointi laajassa mittakaavassa

Oppitunti 10 / 20 Päivitetty 28. heinäkuuta 2026 Edistynyt
Tällä sivulla
  1. Kustannus suunnittelurajoitteena
  2. Tiedä, mihin raha menee
  3. Neljä vähentämiskeinoa
  4. Varoitus ennen laskua
  5. Keskeiset asiat

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ä