Przejdź do głównej treści
Polski— Wybierz język
Menu

Liczenie tokenów i zarządzanie budżetem

Lekcja 12 z 20 Zaktualizowano 28 lipca 2026 Zaawansowany
Na tej stronie
  1. Zrozumienie tokenów
  2. Liczenie za pomocą tiktoken
  3. Budżetowanie przed wywołaniem
  4. Szacowanie kosztów przed wydaniem pieniędzy
  5. Kluczowe wnioski

Zrozumienie tokenów

Tokeny to podstawowa jednostka miary dla modeli LLM. Każde wywołanie API jest rozliczane w tokenach, a każdy model odrzuca żądania przekraczające jego okno kontekstowe. Opanowanie liczenia tokenów pozwala Ci zrobić trzy rzeczy, których nie umożliwiają przybliżenia: przewidzieć koszty przed ich poniesieniem, zoptymalizować prompty w oparciu o twarde liczby, a nie przeczucia, oraz respektować limity kontekstu, nie odkrywając przepełnienia dopiero wtedy, gdy API zgłosi błąd.

Liczenie za pomocą tiktoken

Biblioteka tiktoken stosuje dokładnie tę samą tokenizację co model. Tworzysz instancję enkodera dla docelowego modelu, a następnie zliczasz długość zakodowanej sekwencji.

import tiktoken

# Enkoder dla modeli GPT
encoder = tiktoken.encoding_for_model("gpt-5.6-terra")

def count_tokens(text: str) -> int:
    """Zlicza liczbę tokenów w tekście."""
    return len(encoder.encode(text))

# Przykłady
print(count_tokens("Hello"))           # ~1-2 tokeny
print(count_tokens("Hello world"))     # ~3-4 tokeny
print(count_tokens("Development"))     # ~2-3 tokeny (akcenty kosztują więcej)

Trzeci przykład zasługuje na chwilę zastanowienia. Słowo „Development“ kosztuje więcej, niż sugerowałaby jego długość znakowa, ponieważ znaki z akcentami tokenizują się mniej efektywnie. W praktyce korpus w języku francuskim zużywa więcej tokenów niż odpowiadający mu korpus angielski: jeśli oszacujesz swój budżet, używając promptów w języku angielskim, a następnie wdrożysz rozwiązanie w języku francuskim, Twój rzeczywisty rachunek przekroczy prognozę.

Wywołanie API niesie ze sobą więcej niż surowy tekst: każda wiadomość zawiera rolę, czasem nazwę, a API dodaje tokeny strukturalne. Poniższa funkcja uwzględnia ten narzut, aby zapewnić realistyczną sumę całkowitą.

def count_conversation_tokens(messages: list[dict]) -> int:
    """Zlicza tokeny w konwersacji (wiadomości + narzut)."""
    total = 0
    for message in messages:
        total += 4  # Narzut na wiadomość (rola itp.)
        total += count_tokens(message["content"])
        if message.get("name"):
            total += count_tokens(message["name"])
    total += 2  # Tokeny końcowe
    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)}")

W przypadku konwersacji składającej się z trzech wiadomości narzut jest pomijalny. Przy historii dwustu krótkich wiadomości – typowej dla czatu wsparcia – narzut ten sumuje się do nearly tysiąca tokenów, których nie uwzględniłeś.

Budżetowanie przed wywołaniem

Okno kontekstowe to nie budżet wejściowy: to budżet współdzielony między tym, co wysyłasz, a tym, co model generuje. Jeśli wypełnisz okno po brzegi swoim promptem, odpowiedź zostanie ucięta. Struktura BudgetTokens czyni ten podział explicite, rezerwując z góry część na wyjście.

from dataclasses import dataclass

@dataclass
class BudgetTokens:
    """Zarządza budżetem tokenów dla wywołania."""
    context_limit: int       # Okno modelu
    system_tokens: int = 0   # Prompt systemowy
    history_tokens: int = 0  # Historia konwersacji
    user_tokens: int = 0     # Bieżąca wiadomość
    output_reserve: int = 2000 # Rezerwa na odpowiedź

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

# Przykład z oknem kontekstowym 128K tokenów
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 robi więcej niż tylko pomaga w debugowaniu. Zaloguj ją na próbce żądań produkcyjnych, a natychmiast zobaczysz, który komponent zużywa Twój kontekst. W większości aplikacji niespodzianką okazuje się historia, rzadko prompt systemowy, który wszyscy monitorują.

Następnie musisz podjąć działanie, gdy budżet zostanie przekroczony. Funkcja prepare_context stosuje najprostszą i najbardziej odporną regułę: zachowuje najnowsze wiadomości i odrzuca najstarsze, gdy tylko budżet się wyczerpie. Iteracja przebiega od końca, wstawiając elementy na początek, aby przywrócić porządek chronologiczny.

def prepare_context(
    system_prompt: str,
    history: list[dict],
    message: str,
    model_limit: int = 128_000,
    output_reserve: int = 4_000,
) -> list[dict]:
    """Przygotowuje kontekst z poszanowaniem budżetu tokenów."""

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

    # Zachowaj najnowsze wiadomości mieszczące się w budżecie
    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 obcięcie jest brutalne: wszystko, co wykracza poza budżet, przepada. Gdy starszy kontekst naprawdę ma znaczenie – np. plik klienta śledzony przez kilka tygodni – zastąp czyste usuwanie strategią kompresji omówioną w poprzedniej lekcji.

Szacowanie kosztów przed wydaniem pieniędzy

Najdroższe błędy rozliczeniowe wynikają z przetwarzania wsadowego: uruchamiasz proces na 10 000 dokumentów i odkrywasz kwotę następnego dnia. Wstępne oszacowanie, zajmujące kilka milisekund obliczeń lokalnych, pozwala uniknąć takiego scenariusza.

def estimate_cost(
    input_tokens: int,
    estimated_output_tokens: int,
    model: str = "gpt-5.6-terra",
) -> dict:
    """Szacuje koszt wywołania przed jego wykonaniem."""
    # Stawki za milion tokenów (lipiec 2026 – sprawdź oficjalne cenniki)
    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}",
    }

# Przed wysłaniem dużego promptu
estimation = estimate_cost(
    input_tokens=50_000,
    estimated_output_tokens=2_000,
    model="gpt-5.6-sol",
)
print(estimation)

Tabela stawek jest w tym przykładzie zaszyta na sztywno, z datą w komentarzu. Traktuj ją jako dane konfiguracyjne, które należy regularnie weryfikować względem oficjalnego cennika: oszacowanie wykonane na podstawie nieaktualnych cen jest bardziej niebezpieczne niż brak oszacowania, ponieważ buduje fałszywe poczucie bezpieczeństwa.

Na koniec poznaj limity każdego modelu, aby zaplanować swój budżet. Okna kontekstowe różnią się w zależności od modelu w rodzinie GPT-5.6 – sprawdź aktualne wartości na oficjalnej stronie modeli OpenAI i konfiguruj context_limit ze swoich ustawień, zamiast hardkodować go w kodzie wywołującym.

Kluczowe wnioski

  • Używaj tiktoken do liczenia tokenów przed każdym wywołaniem, uwzględniając narzut na wiadomość
  • Język francuski zużywa więcej tokenów niż angielski dla tej samej treści: dostosuj swoje szacunki
  • Zawsze rezerwuj budżet na tokeny wyjściowe w ramach okna kontekstowego
  • Zarządzaj kontekstem automatycznie, odrzucając najstarsze wiadomości
  • Szacuj koszty przed wysłaniem drogich żądań, używając zweryfikowanych stawek