Tokenien laskeminen ja budjetointi
Tällä sivulla
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