Премини към основното съдържание
Български— Изберете език
Меню

Броене и бюджетиране на токени

Урок 12 от 20 Обновен 28 юли 2026 г. Напреднало
На тази страница
  1. Разбиране на токените
  2. Броене с tiktoken
  3. Бюджетиране преди обаждането
  4. Оценка на разходите преди харчене
  5. Ключови изводи

Разбиране на токените

Токените са основната единица за измерване при големите езикови модели (LLM). Всяко API обаждане се таксува в токени и всеки модел отхвърля заявки, надвишаващи неговия прозорец на контекста. Овладяването на броенето на токени Ви позволява да направите три неща, които приблизителните оценки не могат: да предвидите разходите, преди да ги понесете, да оптимизирате подканите си въз основа на твърди числа, а не на усещане, и да спазвате лимитите на контекста, без да откривате препълване едва когато API върне грешка.

Броене с tiktoken

Библиотеката tiktoken прилага точно същата токенизация като модела. Инстанцирате енкодер за целевия модел и след това броите дължината на кодираната последователност.

import tiktoken

# Encoder for GPT models
encoder = tiktoken.encoding_for_model("gpt-5.6-terra")

def count_tokens(text: str) -> int:
    """Counts the number of tokens in a text."""
    return len(encoder.encode(text))

# Examples
print(count_tokens("Hello"))           # ~1-2 tokens
print(count_tokens("Hello world"))     # ~3-4 tokens
print(count_tokens("Development"))     # ~2-3 tokens (accents cost more)

Третият пример заслужава внимание. Думата “Development” струва повече, отколкото би подсказала дължината ѝ в знаци, защото символите с диакритични знаци се токенизират по-малко ефективно. На практика един френски корпус консумира повече токени от еквивалентен английски: ако сте оценили бюджета си, използвайки подкани на английски, а след това внедрите решение на френски, действителната Ви сметка ще надвиши прогнозата.

Едно API обаждане носи повече от суров текст: всяко съобщение включва роля, понякога име, а API добавя и структурни токени. Следната функция включва тези допълнителни разходи, за да предостави реалистичен общ брой.

def count_conversation_tokens(messages: list[dict]) -> int:
    """Counts tokens in a conversation (messages + overhead)."""
    total = 0
    for message in messages:
        total += 4  # Overhead per message (role, etc.)
        total += count_tokens(message["content"])
        if message.get("name"):
            total += count_tokens(message["name"])
    total += 2  # End tokens
    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)}")

При разговор от три съобщения допълнителните разходи са незначителни. При история от двеста кратки съобщения – типично за чат за поддръжка – те се сумират до почти хиляда токена, които не сте взели предвид.

Бюджетиране преди обаждането

Прозорецът на контекста не е бюджет само за входни данни: това е споделен бюджет между това, което изпращате, и това, което моделът генерира. Ако запълните прозореца докрай с Вашата подкана, отговорът ще бъде съкратен. Структурата BudgetTokens прави това разпределение явно, като запазва част от капацитета за изхода предварително.

from dataclasses import dataclass

@dataclass
class BudgetTokens:
    """Manages the token budget for a call."""
    context_limit: int       # Model window
    system_tokens: int = 0   # System prompt
    history_tokens: int = 0  # Conversation history
    user_tokens: int = 0     # Current message
    output_reserve: int = 2000 # Reserved for response

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

# Example with a 128K token context window
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")

Методът report прави повече от това да помага за отстраняване на грешки. Запишете го в логовете за извадка от производствените заявки и веднага ще видите кой компонент консумира Вашия контекст. В повечето приложения изненадата идва от историята, рядко от системната подкана, която всички следят.

След това трябва да действате, когато бюджетът е надвишен. Функцията prepare_context прилага най-простото и най-устойчиво правило: запазете най-новите съобщения и премахнете най-старите, щом бюджетът се изчерпи. Итерацията върви в обратен ред, като вмъква елементите в началото, за да възстанови хронологичния ред.

def prepare_context(
    system_prompt: str,
    history: list[dict],
    message: str,
    model_limit: int = 128_000,
    output_reserve: int = 4_000,
) -> list[dict]:
    """Prepares the context while respecting the token budget."""

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

    # Keep the most recent messages within budget
    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}]
    )

Това съкращаване е брутално: всичко, което попада извън бюджета, се губи. Когато по-старият контекст наистина има значение – например файл на клиент, проследяван в продължение на няколко седмици – заменете чистото изтриване със стратегията за компресиране, разгледана в предишния урок.

Оценка на разходите преди харчене

Най-скъпите грешки при фактурирането идват от пакетната обработка: стартирате обработка на 10 000 документа и откривате сумата едва на следващия ден. Предварителната оценка, чрез няколко милисекунди локални изчисления, избягва този сценарий.

def estimate_cost(
    input_tokens: int,
    estimated_output_tokens: int,
    model: str = "gpt-5.6-terra",
) -> dict:
    """Estimates the cost of a call before executing it."""
    # Rates per million tokens (July 2026 — check official pricing)
    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}",
    }

# Before sending a large prompt
estimation = estimate_cost(
    input_tokens=50_000,
    estimated_output_tokens=2_000,
    model="gpt-5.6-sol",
)
print(estimation)

Таблицата с тарифите е вградена в този пример, като датата е посочена в коментар. Третирайте я като конфигурационни данни, които да проверявате редовно спрямо официалната ценова листа: оценка, изчислена на базата на остарели цени, е по-опасна от липсата на оценка изобщо, защото внушава фалшива увереност.

Накрая, познавайте лимитите на всеки модел, за да планирате бюджета си. Прозорците на контекста варират от модел до модел в рамките на семейството GPT-5.6 – консултирайте се с официалната страница на OpenAI за моделите за актуални стойности и конфигурирайте context_limit от Вашите настройки, вместо да го вграждате директно в кода за обаждане.

Ключови изводи

  • Използвайте tiktoken, за да броите токените преди всяко обаждане, като отчитате допълнителните разходи за всяко съобщение
  • Френският език консумира повече токени от английския за еквивалентно съдържание: коригирайте оценките си
  • Винаги запазвайте бюджет за изходни токени в рамките на прозореца на контекста
  • Управлявайте контекста автоматично, като премахвате най-старите съобщения
  • Оценявайте разходите преди изпращане на скъпи заявки, използвайки проверени тарифи