Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Skaičiavimas ir biudžeto planavimas pagal tokenus

Paskaita 12 iš 20 Atnaujinta 2026 m. liepos 28 d. Pažengusiems
Šiame puslapyje
  1. Kas yra tokenai
  2. Skaičiavimas naudojant „tiktoken“
  3. Biudžeto planavimas prieš kviečiant API
  4. Išlaidų įvertinimas prieš išleidžiant pinigus
  5. Svarbiausi punktai

Kas yra tokenai

Tokenai yra pagrindinis didžiųjų kalbos modelių (LLM) matavimo vienetas. Kiekvienas API užklausos kvietimas apmokestinamas tokenais, o kiekvienas modelis atmeta užklausas, viršijančias jo konteksto langą. Įvaldęs tokenų skaičiavimą, gali atlikti tris dalykus, kurių neįmanoma pasiekti naudojant apytikslius įverčius: numatyti išlaidas prieš jas patiriant, optimizuoti savo prompts remiantis tiksliais skaičiais, o ne intuicija, ir laikytis konteksto ribų, neiššaukiant klaidos tik tada, kai API jau grąžina perpildymo pranešimą.

Skaičiavimas naudojant „tiktoken“

Biblioteka tiktoken taiko tą pačią tokenizaciją kaip ir pats modelis. Sukuri koduoklį (encoder) targetiniam modeliui ir tada suskaičiuoji užkoduotos sekos ilgį.

import tiktoken

# Koduoklis GPT modeliams
encoder = tiktoken.encoding_for_model("gpt-5.6-terra")

def count_tokens(text: str) -> int:
    """Suskaičiuoja tokenų skaičių tekste."""
    return len(encoder.encode(text))

# Pavyzdžiai
print(count_tokens("Hello"))           # ~1-2 tokenai
print(count_tokens("Hello world"))     # ~3-4 tokenai
print(count_tokens("Development"))     # ~2-3 tokenai (akcentuoti simboliai kainuoja daugiau)

Trečiasis pavyzdys vertas dėmesio. Žodis „Development“ kainuoja daugiau, nei rodo jo simbolių ilgis, nes akcentuoti simboliai tokenizuojami mažiau efektyviai. Praktiškai prancūziškas tekstas suvartoja daugiau tokenų nei ekvivalentiškas angliškas: jei biudžetą įvertinai naudodamas angliškus prompts, o vėliau diegėi sistemą prancūzų kalba, tavo galutinė sąskaita viršys prognozę.

API užklausa susideda ne tik iš gryno teksto: kiekvienoje žinutėje yra vaidmuo (role), kartais vardas, be to, API priduria struktūrinius tokenus. Ši funkcija įtraukia šią papildomą apkrovą, kad pateiktų realistišką bendrą sumą.

def count_conversation_tokens(messages: list[dict]) -> int:
    """Suskaičiuoja tokenus pokalbyje (žinutės + papildoma apkrova)."""
    total = 0
    for message in messages:
        total += 4  # Papildoma apkrova vienai žinutei (vaidmuo ir kt.)
        total += count_tokens(message["content"])
        if message.get("name"):
            total += count_tokens(message["name"])
    total += 2  # Pabaigos tokenai
    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)}")

Trijų žinučių pokalbyje ši papildoma apkrova yra nereikšminga. Tačiau dviejų šimtų trumpų žinučių istorijoje – kas yra tipiška palaikymo pokalbiui – ji gali sudaryti beveik tūkstantį tokenų, kurių neįskaitei.

Biudžeto planavimas prieš kviečiant API

Konteksto langas nėra tik įvesties biudžetas: tai bendras biudžetas tam, ką siunči, ir tam, ką modelis sugeneruoja. Jei konteksto langą užpildysi savo promptu iki kraštų, atsakymas bus nukirptas. Struktūra BudgetTokens daro šį paskirstymą aiškų, iš anksto rezervuodama dalį vietos atsakymui.

from dataclasses import dataclass

@dataclass
class BudgetTokens:
    """Valdo tokenų biudžetą vienam kvietimui."""
    context_limit: int       # Modelio langas
    system_tokens: int = 0   # Sistemos promptas
    history_tokens: int = 0  # Pokalbio istorija
    user_tokens: int = 0     # Dabartinė žinutė
    output_reserve: int = 2000 # Rezervas atsakymui

    @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}"
        )

# Pavyzdys su 128K tokenų konteksto langu
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")

Metodas report naudingas ne tik derinimui. Įrašyk jį į žurnalą (log) atrankinei produkcijos užklausų imčiai ir iškart pamatysi, kuris komponentas suvartoja tavo kontekstą. Daugelyje programų netikėtumas kyla iš istorijos, o retai iš sistemos prompto, kurį visi stebi.

Toliau reikia imtis veiksmų, kai biudžetas viršijamas. Funkcija prepare_context taiko paprasčiausią ir patikimiausią taisyklę: palikti naujausias žinutes ir šalinti seniausias, kai tik biudžetas išsenka. Iteracija vyksta atvirkštine tvarka, įterpiant žinutes į sąrašo pradžią, kad būtų atkurta chronologinė tvarka.

def prepare_context(
    system_prompt: str,
    history: list[dict],
    message: str,
    model_limit: int = 128_000,
    output_reserve: int = 4_000,
) -> list[dict]:
    """Paruošia kontekstą, laikantis tokenų biudžeto."""

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

    # Palikti naujausias žinutes, tilpstančias į biudžetą
    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}]
    )

Šis trumpinimas yra brutalus: viskas, kas nepatenka į biudžetą, prarandama. Kai senesnis kontekstas yra tikrai svarbus – pavyzdžiui, kliento byla, stebima kelias savaites – vietoj paprasto ištrynimo taikyk kompaktinimo strategiją, aptartą ankstesnėje pamokoje.

Išlaidų įvertinimas prieš išleidžiant pinigus

Brangiausias sąskaitų klaidas sukelia paketinis apdorojimas: paleidi 10 000 dokumentų apdorojimą ir sumą sužinai tik kitą dieną. Išankstinis įvertinimas, trunkantis kelias milisekundes vietiniame kompiuteryje, leidžia išvengti tokios situacijos.

def estimate_cost(
    input_tokens: int,
    estimated_output_tokens: int,
    model: str = "gpt-5.6-terra",
) -> dict:
    """Įvertina kvietimo kainą prieš jį vykdant."""
    # Kainos už milijoną tokenų (2026 m. liepa – tikrink oficialias kainas)
    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}",
    }

# Prieš siunčiant didelį promptą
estimation = estimate_cost(
    input_tokens=50_000,
    estimated_output_tokens=2_000,
    model="gpt-5.6-sol",
)
print(estimation)

Šiame pavyzdyje kainų lentelė yra įkoduota („hardcoded“), o data nurodyta komentare. Laikyk ją konfigūracijos duomenimis ir reguliariai tikrink pagal oficialų kainoraštį: įvertis, apskaičiuotas pagal pasenusias kainas, yra pavojingesnis nei jokio įverčio nebuvimas, nes jis sukelia klaidingą pasitikėjimą.

Galiausiai, žinok kiekvieno modelio ribas, kad galėtum planuoti savo biudžetą. Konteksto langai skiriasi net ir tos pačios GPT-5.6 šeimos modeliams – dabartines reikšmes rasi oficialioje OpenAI modelių svetainėje, o context_limit reikšmę konfigūruok per savo nustatymus, o ne įkoduok tiesiai į kvietimo kodą.

Svarbiausi punktai

  • Naudok tiktoken tokenams skaičiuoti prieš kiekvieną kvietimą, atsižvelgdamas į papildomą apkrovą vienai žinutei
  • Prancūzų kalba suvartoja daugiau tokenų nei anglų kalba tam pačiam turiniui: koreguok savo įverčius
  • Visada rezervuok biudžetą išvesties tokenams konteksto lange
  • Automatiškai valdyk kontekstą šalindamas seniausias žinutes
  • Įvertink išlaidas prieš siųsdamas brangias užklausas, naudodamas patikrintus kainoraščius