Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Tokenu skaitīšana un budžeta plānošana

Nodarbība 12 no 20 Atjaunota 2026. gada 28. jūlijs Augstākais
Šajā lapā
  1. Tokenu izpratne
  2. Skaitīšana ar tiktoken
  3. Budžeta plānošana pirms izsaukuma
  4. Izmaksu novērtēšana pirms tērēšanas
  5. Galvenās atziņas

Tokenu izpratne

Tokeni ir LLM pamata mērvienība. Katrs API izsaukums tiek tarifēts tokenu daudzumā, un katrs modelis noraida pieprasījumus, kas pārsniedz tā konteksta logu. Apgūstot tokeno skaitīšanu, tu vari paveikt trīs lietas, ko aptuvenie aprēķini nespēj: prognozēt izmaksas pirms to rašanās, optimizēt savus uzvednes (promptus), balstoties uz precīziem skaitļiem, nevis nojautām, un ievērot konteksta limitus, nepiedzīvojot pārplūdi tikai brīdī, kad API izmet kļūdu.

Skaitīšana ar tiktoken

Bibliotēka tiktoken pielieto tieši tādu pašu tokenizāciju kā modelis. Tu izveido kodētāju (encoder) konkrētajam modelim un pēc tam nosaki kodētās virknes garumu.

import tiktoken

# Kodētājs GPT modeļiem
encoder = tiktoken.encoding_for_model("gpt-5.6-terra")

def count_tokens(text: str) -> int:
    """Saskaita tokeno skaitu tekstā."""
    return len(encoder.encode(text))

# Piemēri
print(count_tokens("Hello"))           # ~1-2 tokeni
print(count_tokens("Hello world"))     # ~3-4 tokeni
print(count_tokens("Development"))     # ~2-3 tokeni (akcenti maksā vairāk)

Trešais piemērs ir pelnījis īpašu uzmanību. Vārds “Development” maksā vairāk, nekā liecinātu tā rakstzīmju garums, jo rakstzīmes ar diakritiskajām zīmēm tiek tokenizētas mazāk efektīvi. Praksē franču valodas korpuss patērē vairāk tokeno nekā līdzvērtīgs angļu valodas teksts: ja tu esi aprēķinājis savu budžetu, izmantojot uzvednes angļu valodā, un pēc tam izvietoji sistēmu franču valodā, tavs faktiskais rēķins pārsniegs prognozi.

API izsaukums satur ne tikai izejtekstu: katrs ziņojums ietver lomu, dažreiz vārdu, un API pievieno strukturālos tokenus. Tālāk redzamā funkcija iekļauj šo papildu slodzi, lai nodrošinātu reālistisku kopsummu.

def count_conversation_tokens(messages: list[dict]) -> int:
    """Saskaita tokenus sarunā (ziņojumi + papildu slodze)."""
    total = 0
    for message in messages:
        total += 4  # Papildu slodze uz ziņojumu (loma u.c.)
        total += count_tokens(message["content"])
        if message.get("name"):
            total += count_tokens(message["name"])
    total += 2  # Beigu tokeni
    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)}")

Trīs ziņojumu sarunā šī papildu slodze ir niecīga. Taču divu simtu īsu ziņojumu vēsturē, kas ir tipiski atbalsta čatam, tā sasniedz gandrīz tūkstoti tokeno, kurus tu neesi ņēmis vērā.

Budžeta plānošana pirms izsaukuma

Konteksta logs nav tikai ievades budžets: tas ir kopīgs budžets tam, ko tu nosūti, un tam, ko modelis ģenerē. Ja tu piepildi logu līdz malām ar savu uzvedni, atbilde tiks apgriezta. Struktūra BudgetTokens padara šo sadali skaidru, iepriekš rezervējot daļu atbildei.

from dataclasses import dataclass

@dataclass
class BudgetTokens:
    """Pārvalda tokeno budžetu izsaukumam."""
    context_limit: int       # Modeļa logs
    system_tokens: int = 0   # Sistēmas uzvedne
    history_tokens: int = 0  # Sarunas vēsture
    user_tokens: int = 0     # Pašreizējais ziņojums
    output_reserve: int = 2000 # Rezervēts atbildei

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

# Piemērs ar 128K tokeno konteksta logu
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")

Metode report kalpo ne tikai atkļūdošanai. Reģistrējot to ražošanas pieprasījumu izlasē, tu uzreiz redzēsi, kura komponente patērē tavu kontekstu. Lielākajā daļā lietojumprogrammu pārsteigums slēpjas vēsturē, reti sistēmas uzvednē, ko visi uzrauga.

Tālāk tev jārīkojas, kad budžets ir pārsniegts. Funkcija prepare_context pielieto vienkāršāko un visdrošāko likumu: saglabā jaunākos ziņojumus un dzēs vecākos, tiklīdz budžets ir izsmelts. Iterācija notiek apgrieztā secībā, ievietojot elementus sākumā, lai atjaunotu hronoloģisko kārtību.

def prepare_context(
    system_prompt: str,
    history: list[dict],
    message: str,
    model_limit: int = 128_000,
    output_reserve: int = 4_000,
) -> list[dict]:
    """Sagatavo kontekstu, ievērojot tokeno budžetu."""

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

    # Saglabā jaunākos ziņojumus budžeta robežās
    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}]
    )

Šī apgriešana ir brutāla: viss, kas neatbilst budžetam, tiek zaudēts. Ja vecāks konteksts ir patiešām svarīgs – piemēram, klienta fails, kas izsekots vairāku nedēļu garumā – aizstāj tīru dzēšanu ar kompaktizācijas stratēģiju, ko aplūkojām iepriekšējā nodarbībā.

Izmaksu novērtēšana pirms tērēšanas

Visdārgākās rēķinu kļūdas rodas masveida apstrādē: tu palaid cauri 10 000 dokumentiem un nākamajā dienā uzzini summu. Iepriekšēja novērtēšana, veicot dažas milisekundes ilgu lokālu aprēķinu, izvairās no šāda scenārija.

def estimate_cost(
    input_tokens: int,
    estimated_output_tokens: int,
    model: str = "gpt-5.6-terra",
) -> dict:
    """Novērtē izsaukuma izmaksas pirms tā izpildes."""
    # Likmes par miljonu tokeno (2026. gada jūlijs — pārbaudi oficiālās cenas)
    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}",
    }

# Pirms lielas uzvednes nosūtīšanas
estimation = estimate_cost(
    input_tokens=50_000,
    estimated_output_tokens=2_000,
    model="gpt-5.6-sol",
)
print(estimation)

Šajā piemērā likmju tabula ir iekodēta, ar datumu komentārā. Uztver to kā konfigurācijas datus, kas regulāri jāpārbauda pret oficiālo cenu sarakstu: novērtējums, kas aprēķināts, izmantojot novecojušas cenas, ir bīstamāks par novērtējuma neesamību, jo tas rada maldīgu pārliecību.

Visbeidzot, iepazīsties ar katra modeļa limitiem, lai plānotu savu budžetu. Konteksta logi GPT-5.6 saimē atšķiras no modeļa uz modeli – aktuālās vērtības meklē oficiālajā OpenAI modeļu lapā un konfigurē context_limit no saviem iestatījumiem, nevis iekodējot to izsaukuma kodā.

Galvenās atziņas

  • Izmanto tiktoken, lai saskaitītu tokenus pirms katra izsaukuma, ņemot vērā papildu slodzi uz katru ziņojumu
  • Franču valoda patērē vairāk tokeno nekā angļu valoda līdzvērtīgam saturam: pielāgo savas aplēses
  • Vienmēr rezervē budžetu izvades tokeniem konteksta loga ietvaros
  • Pārvaldi kontekstu automātiski, dzēšot vecākos ziņojumus
  • Novērtē izmaksas pirms dārgu pieprasījumu nosūtīšanas, izmantojot pārbaudītas likmes