Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Tokenok számlálása és költségvetés-tervezés

12. lecke 20 közül Frissítve 2026. július 28. Haladó
Ezen az oldalon
  1. A tokenok megértése
  2. Számlálás a tiktokennel
  3. Költségvetés-tervezés a hívás előtt
  4. Költségbecslés a költés előtt
  5. Főbb megállapítások

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 tiktoken eszkö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