Tokenok számlálása és költségvetés-tervezés
Ezen az oldalon
A tokenok megértése
A tokenek az LLM-ek alapvető mérőegységei. Minden API-hívást tokenekben számláznak, és minden modell elutasítja azokat a kéréseket, amelyek túllépik a kontextusablakát. A tokenek pontos számlálásának elsajátítása három olyan dolgot tesz lehetővé, amit a becslés nem: előre jelzi a költségeket, mielőtt felmerülnének, optimalizálja a promptjaidat kemény számok alapján a hasraütés helyett, és betartatja a kontextuskorlátokat anélkül, hogy csak akkor derülne ki a túlcsordulás, amikor az API hibát dob.
Számlálás a tiktokennel
A tiktoken könyvtár pontosan ugyanazt a tokenizálást alkalmazza, mint a modell. Létrehozol egy enkódert a célmodellhez, majd megszámolod az enkódolt szekvencia hosszát.
import tiktoken
# Enkóder GPT modellekhez
encoder = tiktoken.encoding_for_model("gpt-5.6-terra")
def count_tokens(text: str) -> int:
"""Megszámolja a tokenek számát egy szövegben."""
return len(encoder.encode(text))
# Példák
print(count_tokens("Hello")) # ~1-2 token
print(count_tokens("Hello world")) # ~3-4 token
print(count_tokens("Development")) # ~2-3 token (az ékezetek többe kerülnek)
A harmadik példa megállásra késztet. A „Development“ szó többe kerül, mint amit a karakterszáma sugallna, mert az ékezetes karakterek kevésbé hatékonyan tokenizálódnak. A gyakorlatban egy francia szövegkorpusz több tokent fogyaszt, mint egy ezzel egyenértékű angol: ha angol promptok alapján becsülted meg a költségvetésedet, majd franciára váltottál élesben, a végső számlád magasabb lesz a tervezettnél.
Egy API-hívás többet tartalmaz, mint a nyers szöveget: minden üzenet tartalmaz egy szerepet (role), néha egy nevet, és az API strukturális tokeneket is hozzáad. Az alábbi függvény figyelembe veszi ezt a többletet, hogy realisztikus összesítést adjon.
def count_conversation_tokens(messages: list[dict]) -> int:
"""Megszámolja a tokeneket egy beszélgetésben (üzenetek + többlet)."""
total = 0
for message in messages:
total += 4 # Többlet üzenetenként (szerep, stb.)
total += count_tokens(message["content"])
if message.get("name"):
total += count_tokens(message["name"])
total += 2 # Záró tokenek
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)}")
Egy három üzenetből álló beszélgetésnél a többlet elhanyagolható. Kétszáz rövid üzenetből álló előzmény esetén – ami egy ügyfélszolgálati chatre jellemző – ez közel ezer olyan tokent jelent, amivel nem számoltál.
Költségvetés-tervezés a hívás előtt
A kontextusablak nem csupán egy bemeneti keret: ez egy megosztott keret arra, amit elküldesz, és amire a modell válaszol. Ha a promptoddal telezsúfolod az ablakot, a válasz csonkolódni fog. A BudgetTokens struktúra ezt az allokációt teszi explicit módon láthatóvá azáltal, hogy előre fenntart egy részt a kimenet számára.
from dataclasses import dataclass
@dataclass
class BudgetTokens:
"""Kezeli a hívás token-költségvetését."""
context_limit: int # Modell ablak
system_tokens: int = 0 # Rendszer-prompt
history_tokens: int = 0 # Beszélgetés előzményei
user_tokens: int = 0 # Jelenlegi üzenet
output_reserve: int = 2000 # Fenntartva a válaszhoz
@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}"
)
# Példa egy 128K tokenes kontextusablakkal
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")
A report metódus többet nyújt, mint segít a hibakeresésben. Naplózd ezt éles kérések egy mintáján, és azonnal látni fogod, melyik komponens emészti fel a kontextust. A legtöbb alkalmazásban a meglepetést az előzmények okozzák, ritkán a rendszer-prompt, amit mindenki figyel.
Ezután cselekedned kell, amikor túlléped a költségvetést. A prepare_context függvény a legegyszerűbb és legrobusztusabb szabályt alkalmazza: tartsd meg a legfrissebb üzeneteket, és dobd el a legrégebbieket, amint a keret kimerül. Az iteráció fordított sorrendben fut, és az elejére szúr be, hogy visszaállítsa az időrendi sorrendet.
def prepare_context(
system_prompt: str,
history: list[dict],
message: str,
model_limit: int = 128_000,
output_reserve: int = 4_000,
) -> list[dict]:
"""Előkészíti a kontextust a token-költségvetés betartásával."""
system_tokens = count_tokens(system_prompt)
message_tokens = count_tokens(message)
history_budget = (
model_limit - system_tokens - message_tokens - output_reserve
)
# A legfrissebb üzenetek megtartása a kereten belül
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}]
)
Ez a csonkolás brutális: minden, ami kiesik a keretből, elvész. Amikor a régebbi kontextus valóban számít – például egy ügyfélfájl követése több héten át –, a puszta törlés helyett alkalmazd az előző leckében tárgyalt tömörítési stratégiát.
Költségbecslés a költés előtt
A legdrágább számlázási hibák a kötegelt feldolgozásból (batch processing) adódnak: lefuttatsz egy folyamatot 10 000 dokumentumon, és csak másnap derül ki az összeg. Az előzetes becslés, ami helyi számítással néhány milliszekundumot vesz igénybe, elkerüli ezt a forgatókönyvet.
def estimate_cost(
input_tokens: int,
estimated_output_tokens: int,
model: str = "gpt-5.6-terra",
) -> dict:
"""Becsli a hívás költségét a végrehajtás előtt."""
# Díjak milliónyi tokenenként (2026. július – ellenőrizd a hivatalos árakat)
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}",
}
# Mielőtt elküldenél egy nagy promptot
estimation = estimate_cost(
input_tokens=50_000,
estimated_output_tokens=2_000,
model="gpt-5.6-sol",
)
print(estimation)
A díjtáblázat ebben a példában keménykódolt, a dátum pedig megjegyzésben szerepel. Kezeld ezt konfigurációs adatként, amit rendszeresen ellenőrizni kell a hivatalos árlistával szemben: egy elavult árakon alapuló becslés veszélyesebb, mint a becslés hiánya, mert hamis biztonságérzetet kelt.
Végül ismerd meg az egyes modellek korlátait a költségvetésed tervezéséhez. A kontextusablakok modellenként változnak a GPT-5.6 családon belül – consultáld a hivatalos OpenAI modellek oldalt az aktuális értékekért, és a beállításaidból konfiguráld a context_limit értékét, ne pedig keménykódold azt a hívó kódban.
Főbb megállapítások
- Használd a
tiktokeneszközt a tokenek megszámolására minden hívás előtt, figyelembe véve az üzenetenkénti többletet - A francia nyelv több tokent fogyaszt, mint az angol azonos tartalom esetén: igazítsd ehhez a becsléseidet
- Mindig tarts fenn keretet a kimeneti tokenek számára a kontextusablakon belül
- Kezeld automatikusan a kontextust a legrégebbi üzenetek eldobásával
- Becsüld meg a költségeket drága kérések elküldése előtt, hitelesített díjak alapján