Štetje žetonov in načrtovanje proračuna
Na tej strani
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
tiktokenza š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