Počítanie tokenov a rozpočtovanie
Na tejto strane
Pochopenie tokenov
Tokeny sú základnou jednotkou merania pre veľké jazykové modely (LLM). Každé volanie API sa fakturuje v tokenoch a každý model odmietne požiadavky, ktoré prekročia jeho kontextové okno. Zvládnutie počítania tokenov ti umožní tri veci, ktoré aproximácia nedokáže: predpovedať náklady skôr, než ich vzniknú, optimalizovať tvoje prompty na základe tvrdých čísel namiesto pocitu a rešpektovať limity kontextu bez toho, aby si zistil pretečenie až v momente, keď API vyhodí chybu.
Počítanie pomocou tiktoken
Knižnica tiktoken aplikuje presne rovnakú tokenizáciu ako model. Vytvoríš inštanciu enkodéra pre cieľový model a následne spočítaš dĺžku zakódovanej sekvencie.
import tiktoken
# Enkodér pre modely GPT
encoder = tiktoken.encoding_for_model("gpt-5.6-terra")
def count_tokens(text: str) -> int:
"""Spočíta počet tokenov v texte."""
return len(encoder.encode(text))
# Príklady
print(count_tokens("Hello")) # ~1-2 tokeny
print(count_tokens("Hello world")) # ~3-4 tokeny
print(count_tokens("Development")) # ~2-3 tokeny (akcenty stoja viac)
Tretí príklad si zaslúži zastavenie. Slovo „Development“ stojí viac, než by naznačovala jeho dĺžka v znakoch, pretože znaky s diakritikou sa tokenizujú menej efektívne. V praxi francúzsky korpus spotrebuje viac tokenov než ekvivalentný anglický: ak by si odhadoval svoj rozpočet pomocou anglických promptov a následne nasadil systém vo francúzštine, tvoja skutočná faktúra prekročí tvoj odhad.
Volanie API nesie viac než len surový text: každá správa obsahuje rolu, niekedy meno a API pridáva štrukturálne tokeny. Nasledujúca funkcia zahŕňa túto réžiu, aby poskytla realistický súčet.
def count_conversation_tokens(messages: list[dict]) -> int:
"""Spočíta tokeny v konverzácii (správy + réžia)."""
total = 0
for message in messages:
total += 4 # Réžia na správu (rola atď.)
total += count_tokens(message["content"])
if message.get("name"):
total += count_tokens(message["name"])
total += 2 # Koncové tokeny
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 konverzácii s tromi správami je táto réžia zanedbateľná. Pri histórii dvoch stoviek krátkych správ – čo je typické pre podporu chatom – sa to vyšplhá na takmer tisíc tokenov, s ktorými si nepočítal.
Rozpočtovanie pred volaním
Kontextové okno nie je rozpočet len pre vstup: je to zdieľaný rozpočet medzi tým, čo pošleš, a tým, čo model vygeneruje. Ak naplníš okno po okraj svojím promptom, odpoveď bude orezaná. Štruktúra BudgetTokens robí toto pridelenie explicitným tým, že vopred vyhradí časť pre výstup.
from dataclasses import dataclass
@dataclass
class BudgetTokens:
"""Spravuje tokenový rozpočet pre volanie."""
context_limit: int # Okno modelu
system_tokens: int = 0 # Systémový prompt
history_tokens: int = 0 # História konverzácie
user_tokens: int = 0 # Aktuálna správa
output_reserve: int = 2000 # Vyhradené pre odpoveď
@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}"
)
# Príklad s kontextovým oknom 128K tokenov
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")
Metóda report robí viac, než len pomáha pri ladení. Ak ju zaznamenáš do logu pri vzorke produkčných požiadaviek, okamžite uvidíš, ktorá zložka spotrebúva tvoj kontext. Vo väčšine aplikácií prichádza prekvapenie z histórie, zriedka zo systémového promptu, ktorý každý monitoruje.
Ďalej musíš konať, keď sa rozpočet prekročí. Funkcia prepare_context aplikuje najjednoduchšie a najrobustnejšie pravidlo: ponechaj najnovšie správy a zahodź tie najstaršie hneď, ako sa rozpočet vyčerpá. Iterácia prebieha obrátene, pričom sa vkladá na začiatok, aby sa obnovilo chronologické poradie.
def prepare_context(
system_prompt: str,
history: list[dict],
message: str,
model_limit: int = 128_000,
output_reserve: int = 4_000,
) -> list[dict]:
"""Pripraví kontext pri rešpektovaní tokenového rozpočtu."""
system_tokens = count_tokens(system_prompt)
message_tokens = count_tokens(message)
history_budget = (
model_limit - system_tokens - message_tokens - output_reserve
)
# Ponechaj najnovšie správy v rámci rozpočtu
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}]
)
Toto orezávanie je brutálne: všetko, čo vypadne mimo rozpočet, je stratené. Keď na staršom kontexte skutočne záleží – napríklad pri sledovaní spisu klienta počas niekoľkých týždňov – nahraď čisté mazanie stratégiou kompaktácie, ktorú sme prebrali v predchádzajúcej lekcii.
Odhad nákladov pred minutím
Najdrahšie chyby vo fakturácii pochádzajú z dávkového spracovania: spustíš prechod cez 10 000 dokumentov a sumu zistíš až nasledujúci deň. Predbežný odhad, ktorý zaberie len niekoľko milisekúnd lokálneho výpočtu, tomuto scenáru predíde.
def estimate_cost(
input_tokens: int,
estimated_output_tokens: int,
model: str = "gpt-5.6-terra",
) -> dict:
"""Odhadne náklady na volanie pred jeho vykonaním."""
# Sadzby za milión tokenov (júl 2026 – over si oficiálne ceny)
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 odoslaním veľkého promptu
estimation = estimate_cost(
input_tokens=50_000,
estimated_output_tokens=2_000,
model="gpt-5.6-sol",
)
print(estimation)
Tabuľka sadzieb je v tomto príklade natvrdo zakódovaná s dátumom v komentári. Ber ju ako konfiguračné údaje, ktoré musíš pravidelne overovať proti oficiálnemu cenníku: odhad vypočítaný na zastaraných cenách je nebezpečnejší než žiadny odhad, pretože vyvoláva falošnú dôveru.
Nakoniec, poznaj limity každého modelu, aby si mohol plánovať svoj rozpočet. Kontextové okná sa líšia model od modelu v rámci rodiny GPT-5.6 – aktuálne hodnoty nájdeš na oficiálnej stránke modelov OpenAI a context_limit konfiguruj zo svojich nastavení, namiesto toho, aby si ho natvrdo kódoval priamo do volacieho kódu.
Kľúčové poznatky
- Používaj
tiktokenna počítanie tokenov pred každým volaním, pričom zohľadni réžiu na každú správu - Francúzština spotrebuje viac tokenov než angličtina pre rovnaký obsah: uprav svoje odhady
- Vždy vyhraď rozpočet pre výstupné tokeny v rámci kontextového okna
- Spravuj kontext automaticky zahadzovaním najstarších správ
- Odhaduj náklady pred odoslaním drahých požiadaviek pomocou overených sadzieb