Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Štetje žetonov in načrtovanje proračuna

Lekcija 12 od 20 Posodobljeno 28. julij 2026 Napredni
Na tej strani
  1. Razumevanje žetonov
  2. Štetje s knjižnico tiktoken
  3. Načrtovanje proračuna pred klicem
  4. Ocena stroškov pred porabo
  5. Ključne ugotovitve

Razumevanje žetonov

Žetoni so osnovna merilna enota za velike jezikovne modele (LLM). Vsak klic API-ja se zaračuna v žetonih in vsak model zavrne zahteve, ki presegajo njegovo okno konteksta. Obvladovanje štetja žetonov ti omogoča tri stvari, ki jih približevanje ne more: napovedati stroške, preden jih nastane, optimizirati pozive na podlagi trdnih števil namesto občutka in spoštovati omejitve konteksta, ne da bi preliv odkril šele, ko API vrže napako.

Štetje s knjižnico tiktoken

Knjižnica tiktoken uporablja popolnoma enako tokenizacijo kot model. Ustvariš kodirnik za ciljni model in nato prešteješ dolžino kodiranega zaporedja.

import tiktoken

# Kodirnik za modele GPT
encoder = tiktoken.encoding_for_model("gpt-5.6-terra")

def count_tokens(text: str) -> int:
    """Prešteje število žetonov v besedilu."""
    return len(encoder.encode(text))

# Primeri
print(count_tokens("Hello"))           # ~1-2 žetona
print(count_tokens("Hello world"))     # ~3-4 žetoni
print(count_tokens("Development"))     # ~2-3 žetoni (naglasi stanejo več)

Tretji primer si zasluži premislek. Beseda “Development” stane več, kot bi nakazovala njena dolžina v znakih, ker se znaki z naglasi tokenizirajo manj učinkovito. V praksi francoski korpus porabi več žetonov kot enakovreden angleški: če si proračun ocenil z uporabo angleških pozivov in nato uvedel sistem v francoščini, bo tvoj dejanski račun presegel napoved.

Klic API-ja nosi več kot surovo besedilo: vsako sporočilo vključuje vlogo, včasih ime, API pa doda še strukturne žetone. Naslednja funkcija vključuje ta dodatni obseg, da zagotovi realno skupno vsoto.

def count_conversation_tokens(messages: list[dict]) -> int:
    """Prešteje žetone v pogovoru (sporočila + dodatni obseg)."""
    total = 0
    for message in messages:
        total += 4  # Dodatni obseg na sporočilo (vloga itd.)
        total += count_tokens(message["content"])
        if message.get("name"):
            total += count_tokens(message["name"])
    total += 2  # Končna žetona
    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)}")

Pri pogovoru s tremi sporočili je dodatni obseg zanemarljiv. Pri zgodovini dveh sto kratkih sporočil – kar je tipično za klepetalno podporo – se to sešteje v skoraj tisoč žetonov, ki jih nisi upošteval.

Načrtovanje proračuna pred klicem

Okno konteksta ni proračun samo za vhod: to je skupni proračun med tem, kar pošlješ, in tem, kar model ustvari. Če okno do roba napolniš s svojim pozivom, bo odgovor odrezan. Struktura BudgetTokens to razporeditev naredi eksplicitno tako, da vnaprej rezervira del za izhod.

from dataclasses import dataclass

@dataclass
class BudgetTokens:
    """Upravlja žetonski proračun za klic."""
    context_limit: int       # Okno modela
    system_tokens: int = 0   # Sistemski poziv
    history_tokens: int = 0  # Zgodovina pogovora
    user_tokens: int = 0     # Trenutno sporočilo
    output_reserve: int = 2000 # Rezervirano za odgovor

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

# Primer z oknom konteksta 128K žetonov
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")

Metoda report ne služi le za odpravljanje napak. Zabeleži jo pri vzorcu zahtev v proizvodnem okolju in takoj boš videl, katera komponenta porablja tvoj kontekst. Pri večini aplikacij presenečenje pride iz zgodovine, redko iz sistemskega poziva, ki ga vsi spremljajo.

Nato moraš ukrepati, ko je proračun presežen. Funkcija prepare_context uporablja najpreprostejše in najbolj robustno pravilo: obdrži najnovejša sporočila in zavrzi najstarejša, takoj ko je proračun izčrpan. Iteracija teče v obratni smeri, vstavljanje pa na začetek, da se obnovi kronološki vrstni red.

def prepare_context(
    system_prompt: str,
    history: list[dict],
    message: str,
    model_limit: int = 128_000,
    output_reserve: int = 4_000,
) -> list[dict]:
    """Pripravi kontekst ob spoštovanju žetonskega proračuna."""

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

    # Obdrži najnovejša sporočila znotraj proračuna
    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}]
    )

To obrezovanje je brutalno: vse, kar pade zunaj proračuna, je izgubljeno. Ko starejši kontekst resnično šteje – na primer datoteka stranke, ki jo spremljaš več tednov – nadomesti čisto brisanje s strategijo stiskanja, obravnavano v prejšnji lekciji.

Ocena stroškov pred porabo

Najdražje napake pri obračunu prihajajo iz serijske obdelave: zaženeš prehod skozi 10.000 dokumentov in znesek odkriješ šele naslednji dan. Predhodna ocena, ki traja le nekaj milisekund lokalnega računanja, temu scenariju prepreči nastanek.

def estimate_cost(
    input_tokens: int,
    estimated_output_tokens: int,
    model: str = "gpt-5.6-terra",
) -> dict:
    """Ocení strošek klica pred njegovo izvedbo."""
    # Cene na milijon žetonov (julij 2026 – preveri uradne cene)
    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}",
    }

# Pred pošiljanjem velikega poziva
estimation = estimate_cost(
    input_tokens=50_000,
    estimated_output_tokens=2_000,
    model="gpt-5.6-sol",
)
print(estimation)

Tabela cen je v tem primeru trdno kodirana, datum pa je v komentarju. Obravnavaj jo kot konfiguracijske podatke, ki jih moraš redno preverjati glede na uradni cenik: ocena, izračunana na podlagi zastarelih cen, je bolj nevarna kot nobena ocena, saj vzbuja lažno zaupanje.

Nazadnje, poznavaj omejitve vsakega modela, da lahko načrtuješ svoj proračun. Okna konteksta se razlikujejo od modela do modela znotraj družine GPT-5.6 – za trenutne vrednosti se posvetuj z uradno stranjo modelov OpenAI in context_limit konfiguriraj iz svojih nastavitev, namesto da bi ga trdno kodiral v kodo za klicanje.

Ključne ugotovitve

  • Uporabi tiktoken za štetje žetonov pred vsakim klicem, pri čemer upoštevaj dodatni obseg na sporočilo
  • Francoščina porabi več žetonov kot angleščina za enako vsebino: prilagodi svoje ocene
  • Vedno rezerviraj proračun za izhodne žetone znotraj okna konteksta
  • Samodejno upravljaj kontekst z odstranjevanjem najstarejših sporočil
  • Pred pošiljanjem dragih zahtev oceni stroške z uporabo preverjenih cen