Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Tokenite loendamine ja eelarvestamine

Õppetund 12 / 20 Värskendatud 28. juuli 2026 Edasijõudnutele
Sellel lehel
  1. Tokenite mõistmine
  2. Loendamine tiktokeniga
  3. Eelarvestamine enne väljakutset
  4. Kulude hindamine enne kulutamist
  5. Peamised punktid

Tokenite mõistmine

Tokenid on suurte keelemudelite (LLM) põhilised mõõtühikud. Iga API väljakutse eest arvutatakse tasu tokenite kaupa ja iga mudel lükkab tagasi päringud, mis ületavad selle kontekstiakent. Tokenite loendamise oskus võimaldab sul teha kolme asja, mida ligikaudne hindamine ei suuda: ennustada kulusid enne nende tekkimist, optimeerida oma vihjeid (prompts) tuginedes kindlatele numbritele mitte sisetundele ning austada konteksti piiranguid, avastamata ületamist alles siis, kui API viskab vea.

Loendamine tiktokeniga

Teek tiktoken rakendab täpselt sama tokeniseerimist nagu mudel ise. Sa lood sihtmudeli jaoks kodeerija ja loendad seejärel kodeeritud jada pikkuse.

import tiktoken

# Kodeerija GPT mudelitele
encoder = tiktoken.encoding_for_model("gpt-5.6-terra")

def count_tokens(text: str) -> int:
    """Loendab tekstis olevate tokenite arvu."""
    return len(encoder.encode(text))

# Näited
print(count_tokens("Hello"))           # ~1-2 tokenit
print(count_tokens("Hello world"))     # ~3-4 tokenit
print(count_tokens("Development"))     # ~2-3 tokenit (rõhumärgid maksavad rohkem)

Kolmas näide väärib peatust. Sõna “Development” maksab rohkem, kui selle tähemärkide arv viitaks, sest rõhumärgiga tähed tokeniseeruvad vähem efektiivselt. Praktikas tarbib prantsuskeelne korpuse võrdväärse ingliskeelsega võrreldes rohkem tokeneid: kui hindasid oma eelarvet ingliskeelsete vihjete põhjal ja võtsid seejärel kasutusele prantsuskeelse versiooni, ületab sinu tegelik arve prognoosi.

API väljakutse ei koosne ainult toorest tekstist: iga sõnum sisaldab rolli, vahel nime ja API lisab struktuursed tokenid. Järgnev funktsioon arvestab seda üldkulu, et pakkuda realistlikku kogusummat.

def count_conversation_tokens(messages: list[dict]) -> int:
    """Loendab tokenid vestluses (sõnumid + üldkulu)."""
    total = 0
    for message in messages:
        total += 4  # Üldkulu sõnumi kohta (roll jne)
        total += count_tokens(message["content"])
        if message.get("name"):
            total += count_tokens(message["name"])
    total += 2  # Lõputokenid
    return total

conversation = [
    {"role": "system", "content": "Oled tehniline assistent."},
    {"role": "user", "content": "Selgita mikroteenuseid."},
    {"role": "assistant", "content": "Mikroteenused on arhitektuur..."},
]

print(f"Tokenite koguarv: {count_conversation_tokens(conversation)}")

Kolme sõnumiga vestluses on üldkulu tühine. Kahe saja lühikese sõnumi ajaloos – mis on tugivestluse jaoks tüüpiline – kasvab see peaaegu tuhandeks tokeniks, mida sa ei arvestanud.

Eelarvestamine enne väljakutset

Kontekstiaken ei ole sisendi eelarve: see on jagatud eelarve selle vahel, mida saadad, ja selle vahel, mida mudel genereerib. Kui täidad akna oma vihjega ääreni, lühendatakse vastust. Struktura BudgetTokens muudab selle eraldamise selgeks, reserveerides osa väljundile ette.

from dataclasses import dataclass

@dataclass
class BudgetTokens:
    """Haldab väljakutse tokenite eelarvet."""
    context_limit: int       # Mudeli aken
    system_tokens: int = 0   # Süsteemne vihje
    history_tokens: int = 0  # Vestluse ajalugu
    user_tokens: int = 0     # Praegune sõnum
    output_reserve: int = 2000 # Reserveeritud vastusele

    @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"Kontekst: {self.context_limit} | "
            f"Süsteem: {self.system_tokens} | "
            f"Ajalugu: {self.history_tokens} | "
            f"Kasutaja: {self.user_tokens} | "
            f"Väljundi reserv: {self.output_reserve} | "
            f"Saadaval: {self.available_tokens}"
        )

# Näide 128K tokenite kontekstiaknaga
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("Eelarve ületatud — vajalik tihendamine")

Meetod report ei aita ainult silumisel. Logi seda tootmispäringute valimis ja näed kohe, milline komponent sinu konteksti tarbib. Enamikes rakendustes tuleb üllatus ajaloost, harva süsteemsest vihjest, mida kõik jälgivad.

Järgmiseks pead tegutsema, kui eelarve on ületatud. Funktsioon prepare_context rakendab kõige lihtsamat ja kindlamat reeglit: hoia alles kõige uuemad sõnumid ja kõrvalda vanimad niipea, kui eelarve on ammendunud. Iteratsioon kulgeb tagurpidi, sisestades päisesse, et taastada kronoloogiline järjekord.

def prepare_context(
    system_prompt: str,
    history: list[dict],
    message: str,
    model_limit: int = 128_000,
    output_reserve: int = 4_000,
) -> list[dict]:
    """Valmistab konteksti ette, austades tokenite eelarvet."""

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

    # Hoia alles kõige uuemad sõnumid eelarve piires
    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}]
    )

See kärpimine on brutaalne: kõik, mis jääb eelarvest välja, läheb kaduma. Kui vanem kontekst on tõesti oluline – näiteks kliendifail, mida on jälgitud mitme nädala jooksul – asenda puhas kustutamine eelmises tunnis käsitletud tihendamise strateegiaga.

Kulude hindamine enne kulutamist

Kallimad arveldusvead tulenevad partii töötlemisest: käivitad 10 000 dokumendi läbitöötamise ja avastad summa alles järgmisel päeval. Esmalt hindamine, mis võtab kohalikus arvutuses vaid mõni millisekund, väldib seda stsenaariumi.

def estimate_cost(
    input_tokens: int,
    estimated_output_tokens: int,
    model: str = "gpt-5.6-terra",
) -> dict:
    """Hindab väljakutse kulu enne selle teostamist."""
    # Hinnad miljoni tokeni kohta (juuli 2026 – kontrolli ametlikku hinnakirja)
    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}",
    }

# Enne suure vihje saatmist
estimation = estimate_cost(
    input_tokens=50_000,
    estimated_output_tokens=2_000,
    model="gpt-5.6-sol",
)
print(estimation)

Hinnatabel on selles näites kodeeritud koos kuupäevaga kommentaaris. Kohtle seda konfiguratsiooniandmetena, mida tuleb regulaarselt ametliku hinnakirjaga võrrelda: aegunud hindadel põhinev hinnang on ohtlikum kui hinnangu puudumine, sest see tekitab vale kindlustunde.

Lõpuks tunne iga mudeli piiranguid, et oma eelarvet planeerida. Kontekstiaknad varieeruvad GPT-5.6 perekonna mudelite lõikes – praeguste väärtuste jaoks konsulteeri ametliku OpenAI mudelite lehega ja seadista context_limit oma seadetest, mitte ära kodeeri seda kutsekoodi sisse.

Peamised punktid

  • Kasuta tiktoken tokenite loendamiseks enne iga väljakutset, arvestades sõnumipõhist üldkulu
  • Prantsuse keel tarbib võrdväärse sisu puhul rohkem tokeneid kui inglise keel: kohanda oma hinnanguid
  • Reserveeri kontekstiaknas alati eelarve väljundtokenitele
  • Halda konteksti automaatselt, kõrvaldades vanimad sõnumid
  • Hinda kulusid enne kallite päringute saatmist, kasutades kontrollitud hindu