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

Tokenien laskeminen ja budjetointi

Oppitunti 12 / 20 Päivitetty 28. heinäkuuta 2026 Edistynyt
Tällä sivulla
  1. Tokenien ymmärtäminen
  2. Laskeminen tiktokenilla
  3. Budjetointi ennen kutsua
  4. Kustannusten arviointi ennen kulutusta
  5. Keskeiset asiat

Tokenien ymmärtäminen

Tokenit ovat suurten kielimallien (LLM) perusmittayksikkö. Jokainen API-kutsu laskutetaan tokenien perusteella, ja jokainen malli hylkää pyynnöt, jotka ylittävät sen konteksti-ikkunan. Tokenien laskemisen hallinta mahdollistaa kolme asiaa, joita arviointi ei pysty tekemään: voit ennustaa kustannukset ennen niiden syntymistä, optimoida kehotteitasi kovien lukujen eikä mututuntuman perusteella sekä kunnioittaa kontekstirajoja ilman, että huomaat ylivuodon vasta API:n heittäessä virheen.

Laskeminen tiktokenilla

tiktoken-kirjasto käyttää täsmälleen samaa tokenisointia kuin malli itse. Muodostat enkooderin kohdemallille ja lasket koodatun sekvenssin pituuden.

import tiktoken

# Enkooderi GPT-malleille
encoder = tiktoken.encoding_for_model("gpt-5.6-terra")

def count_tokens(text: str) -> int:
    """Laskee tekstin tokenien määrän."""
    return len(encoder.encode(text))

# Esimerkkejä
print(count_tokens("Hello"))           # ~1-2 tokenia
print(count_tokens("Hello world"))     # ~3-4 tokenia
print(count_tokens("Development"))     # ~2-3 tokenia (tarkeet maksavat enemmän)

Kolmas esimerkki ansaitsee pysähtymisen. Sana “Development” maksaa enemmän kuin sen merkkimäärä antaisi ymmärtää, koska tarkeelliset merkit tokenisoituvat tehottomammin. Käytännössä ranskankielinen aineisto kuluttaa enemmän tokeneita kuin vastaava englanninkielinen: jos arvioit budjettisi englanninkielisiä kehotteita käyttäen ja otat järjestelmän käyttöön ranskaksi, todellinen laskusi ylittää ennusteesi.

API-kutsu sisältää muutakin kuin raakatekstiä: jokainen viesti sisältää roolin, joskus nimen, ja API lisää rakenteellisia tokeneita. Seuraava funktio ottaa tämän ylimääräisen kuorman huomioon tarjotakseen realistisen kokonaismäärän.

def count_conversation_tokens(messages: list[dict]) -> int:
    """Laskee keskustelun tokenit (viestit + ylimääräinen kuorma)."""
    total = 0
    for message in messages:
        total += 4  # Ylimääräinen kuorma viestiä kohti (rooli jne.)
        total += count_tokens(message["content"])
        if message.get("name"):
            total += count_tokens(message["name"])
    total += 2  # Lopputokenit
    return total

conversation = [
    {"role": "system", "content": "You are a technical assistant."},
    {"role": "user", "content": "Explain microservices."},
    {"role": "assistant", "content": "Microservices are an architecture..."},
]

print(f"Total tokens: {count_conversation_tokens(conversation)}")

Kolmen viestin keskustelussa ylimääräinen kuorma on merkityksetön. Kahdensadan lyhyen viestin historiassa – mikä on tyypillistä tukikeskusteluille – se kasvaa lähes tuhanteen tokeniin, joita et ole ottanut huomioon.

Budjetointi ennen kutsua

Konteksti-ikkuna ei ole pelkkä syötebudjetti: se on jaettu budjetti lähettämäsi sisällön ja mallin tuottaman vastauksen välillä. Jos täytät ikkunan ääriään myöten kehotteellasi, vastaus typistyy. BudgetTokens-rakenne tekee tästä allokaatiosta eksplisiittisen varaamalla osan tilasta etukäteen vastaukselle.

from dataclasses import dataclass

@dataclass
class BudgetTokens:
    """Hallitsee kutsun tokenibudjettia."""
    context_limit: int       # Mallin ikkuna
    system_tokens: int = 0   # Järjestelmäkehote
    history_tokens: int = 0  # Keskusteluhistoria
    user_tokens: int = 0     # Nykyinen viesti
    output_reserve: int = 2000 # Varattu vastaukselle

    @property
    def available_tokens(self) -> int:
        used = (
            self.system_tokens
            + self.history_tokens
            + self.user_tokens
        )
        return self.context_limit - used - self.output_reserve

    @property
    def is_over(self) -> bool:
        return self.available_tokens < 0

    def report(self) -> str:
        return (
            f"Context: {self.context_limit} | "
            f"System: {self.system_tokens} | "
            f"History: {self.history_tokens} | "
            f"User: {self.user_tokens} | "
            f"Output reserve: {self.output_reserve} | "
            f"Available: {self.available_tokens}"
        )

# Esimerkki 128K tokenin konteksti-ikkunalla
budget = BudgetTokens(
    context_limit=128_000,
    system_tokens=count_tokens(system_prompt),
    history_tokens=count_conversation_tokens(history),
    user_tokens=count_tokens(user_message),
)

if budget.is_over:
    print("Budget exceeded — compaction required")

report-metodi tekee muutakin kuin auttaa vianetsinnässä. Lokita se otokseen tuotantopyyntöjä, ja näet heti, mikä komponentti kuluttaa kontekstiasi. Useimmissa sovelluksissa yllätys piilee historiassa, harvoin järjestelmäkehotteessa, jota kaikki valvovat.

Seuraavaksi sinun on toimittava, kun budjetti ylittyy. prepare_context-funktio soveltaa yksinkertaisinta ja vankkainta sääntöä: pidä uusimmat viestit ja pudota vanhimmat heti, kun budjetti loppuu. Iterointi suoritetaan käänteisessä järjestyksessä, ja viestit lisätään alkuun kronologisen järjestyksen palauttamiseksi.

def prepare_context(
    system_prompt: str,
    history: list[dict],
    message: str,
    model_limit: int = 128_000,
    output_reserve: int = 4_000,
) -> list[dict]:
    """Valmistelee kontekstin kunnioittaen tokenibudjettia."""

    system_tokens = count_tokens(system_prompt)
    message_tokens = count_tokens(message)
    history_budget = (
        model_limit - system_tokens - message_tokens - output_reserve
    )

    # Pidä uusimmat viestit budjetin rajoissa
    kept_messages = []
    used_tokens = 0

    for msg in reversed(history):
        msg_tokens = count_tokens(msg["content"]) + 4
        if used_tokens + msg_tokens > history_budget:
            break
        kept_messages.insert(0, msg)
        used_tokens += msg_tokens

    return (
        [{"role": "system", "content": system_prompt}]
        + kept_messages
        + [{"role": "user", "content": message}]
    )

Tämä typistäminen on raakaa: kaikki, mikä jää budjetin ulkopuolelle, menetetään. Kun vanhempi konteksti on todella tärkeää – esimerkiksi useiden viikkojen ajan seurattu asiakirja – korvaa pelkkä poistaminen edellisellä tunnilla käsitellyllä tiivistysstrategialla.

Kustannusten arviointi ennen kulutusta

Kalleimmat laskutusvirheet johtuvat eräajosta: suoritat ajon 10 000 dokumentille ja huomaat summan vasta seuraavana päivänä. Arviointi etukäteen, muutamassa millisekunnissa paikallisesti laskettuna, välttää tämän tilanteen.

def estimate_cost(
    input_tokens: int,
    estimated_output_tokens: int,
    model: str = "gpt-5.6-terra",
) -> dict:
    """Arvioi kutsun kustannukset ennen sen suorittamista."""
    # Hinnat miljoonaa tokenia kohti (heinäkuu 2026 – tarkista virallinen hinnoittelu)
    rates = {
        "gpt-5.6-luna": {"input": 0.20, "output": 1.20},
        "gpt-5.6-terra": {"input": 2.00, "output": 12.00},
        "gpt-5.6-sol": {"input": 5.00, "output": 30.00},
    }

    rate = rates.get(model, rates["gpt-5.6-terra"])
    input_cost = (input_tokens / 1_000_000) * rate["input"]
    output_cost = (estimated_output_tokens / 1_000_000) * rate["output"]

    return {
        "model": model,
        "input_tokens": input_tokens,
        "estimated_output_tokens": estimated_output_tokens,
        "input_cost": f"${input_cost:.6f}",
        "output_cost": f"${output_cost:.6f}",
        "total_cost": f"${input_cost + output_cost:.6f}",
    }

# Ennen suuren kehotteen lähettämistä
estimation = estimate_cost(
    input_tokens=50_000,
    estimated_output_tokens=2_000,
    model="gpt-5.6-sol",
)
print(estimation)

Hintataulukko on kovakoodattu tähän esimerkkiin, ja päivämäärä on kommentissa. Käsittele sitä konfiguraatiodatana, joka on tarkistettava säännöllisesti virallista hintalistaa vasten: vanhentuneisiin hintoihin perustuva arvio on vaarallisempi kuin ei arviota lainkaan, koska se luo väärää luottamusta.

Lopuksi, tunne kunkin mallin rajat suunnitellaksesi budjettisi. Konteksti-ikkunat vaihtelevat mallista toiseen GPT-5.6 -perheen sisällä – tarkista nykyiset arvot viralliselta OpenAI-mallien sivulta ja määritä context_limit asetuksistasi sen sijaan, että kovakoodaisit sen kutsukoodiin.

Keskeiset asiat

  • Käytä tiktokenia tokenien laskemiseen ennen jokaista kutsua ottaen huomioon viestikohtaisen ylimääräisen kuorman
  • Ranska kuluttaa enemmän tokeneita kuin englanti vastaavalle sisällölle: säädä arvioitasi
  • Varaa aina budjetti output-tokeneille konteksti-ikkunan sisällä
  • Hallitse kontekstia automaattisesti pudottamalla vanhimmat viestit
  • Arvioi kustannukset ennen kalliiden pyyntöjen lähettämistä käyttäen varmennettuja hintoja