Броене и бюджетиране на токени
На тази страница
Разбиране на токените
Токените са основната единица за измерване при големите езикови модели (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, за да броите токените преди всяко обаждане, като отчитате допълнителните разходи за всяко съобщение - Френският език консумира повече токени от английския за еквивалентно съдържание: коригирайте оценките си
- Винаги запазвайте бюджет за изходни токени в рамките на прозореца на контекста
- Управлявайте контекста автоматично, като премахвате най-старите съобщения
- Оценявайте разходите преди изпращане на скъпи заявки, използвайки проверени тарифи