Räkning och budgetering av tokens
På denna sida
Förstå tokens
Tokens är den grundläggande mätenheten för stora språkmodeller (LLM). Varje API-anrop debiteras i tokens, och varje modell avvisar förfrågningar som överskrider dess kontextfönster. Att bemästra tokenräkning gör att du kan göra tre saker som uppskattningar inte klarar av: förutse kostnader innan de uppstår, optimera dina prompts baserat på hårda siffror istället för magkänsla, och respektera kontextgränser utan att upptäcka en överflöd först när API:t kastar ett fel.
Räkna med tiktoken
Biblioteket tiktoken använder exakt samma tokenisering som modellen. Du instansierar en kodare för målmodellen och räknar sedan längden på den kodade sekvensen.
import tiktoken
# Kodare för GPT-modeller
encoder = tiktoken.encoding_for_model("gpt-5.6-terra")
def count_tokens(text: str) -> int:
"""Räknar antalet tokens i en text."""
return len(encoder.encode(text))
# Exempel
print(count_tokens("Hello")) # ~1-2 tokens
print(count_tokens("Hello world")) # ~3-4 tokens
print(count_tokens("Development")) # ~2-3 tokens (accenttecken kostar mer)
Det tredje exemplet förtjänar en paus. Ordet “Development” kostar mer än vad dess teckenlängd antyder eftersom tecken med accenttecken tokeniseras mindre effektivt. I praktiken konsumerar en fransk textkropp fler tokens än en motsvarande engelsk: om du uppskattade din budget med engelska prompts och sedan distribuerade på franska, kommer din faktiska faktura att överstiga din prognos.
Ett API-anrop innehåller mer än rå text: varje meddelande inkluderar en roll, ibland ett namn, och API:t lägger till strukturella tokens. Följande funktion inkorporerar detta överhead för att ge en realistisk totalsumma.
def count_conversation_tokens(messages: list[dict]) -> int:
"""Räknar tokens i en konversation (meddelanden + överhead)."""
total = 0
for message in messages:
total += 4 # Överhead per meddelande (roll, etc.)
total += count_tokens(message["content"])
if message.get("name"):
total += count_tokens(message["name"])
total += 2 # Sluttokens
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)}")
Vid en konversation med tre meddelanden är överheadet försumbart. Vid en historik på tvåhundra korta meddelanden – typiskt för en supportchatt – summeras det till nästan tusen tokens du inte räknat med.
Budgetering innan anrop
Kontextfönstret är inte en input-budget: det är en delad budget mellan det du skickar och det modellen genererar. Om du fyller fönstret till brädden med din prompt kommer svaret att trunkeras. Strukturen BudgetTokens gör denna allokering explicit genom att reservera en del för utdata i förväg.
from dataclasses import dataclass
@dataclass
class BudgetTokens:
"""Hanterar tokenbudgeten för ett anrop."""
context_limit: int # Modellfönster
system_tokens: int = 0 # Systemprompt
history_tokens: int = 0 # Konversationshistorik
user_tokens: int = 0 # Aktuellt meddelande
output_reserve: int = 2000 # Reserverat för svar
@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}"
)
# Exempel med ett kontextfönster på 128K tokens
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 överskriden — kompaktering krävs")
Metoden report gör mer än att hjälpa till vid felsökning. Logga den på ett urval av produktionsförfrågningar, så ser du omedelbart vilken komponent som konsumerar ditt kontext. I de flesta applikationer kommer överraskningen från historiken, sällan från systemprompten som alla övervakar.
Därefter måste du agera när budgeten överskrids. Funktionen prepare_context tillämpar den enklaste och mest robusta regeln: behåll de senaste meddelandena och släng de äldsta så snart budgeten är uttömd. Iterationen körs baklänges och infogar i huvudet för att återställa den kronologiska ordningen.
def prepare_context(
system_prompt: str,
history: list[dict],
message: str,
model_limit: int = 128_000,
output_reserve: int = 4_000,
) -> list[dict]:
"""Förbereder kontexten med respekt för tokenbudgeten."""
system_tokens = count_tokens(system_prompt)
message_tokens = count_tokens(message)
history_budget = (
model_limit - system_tokens - message_tokens - output_reserve
)
# Behåll de senaste meddelandena inom 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}]
)
Denna trunkering är brutal: allt som hamnar utanför budgeten går förlorat. När äldre kontext verkligen spelar roll – exempelvis en kundfil som spårats över flera veckor – bör du ersätta ren radering med kompakteringsstrategin som behandlades i föregående lektion.
Uppskatta kostnad innan du spenderar
De dyraste faktureringsfelen kommer från batchbearbetning: du kör en genomgång på 10 000 dokument och upptäcker beloppet dagen efter. Att uppskatta först, på några millisekunders lokal beräkning, undviker detta scenario.
def estimate_cost(
input_tokens: int,
estimated_output_tokens: int,
model: str = "gpt-5.6-terra",
) -> dict:
"""Uppskattar kostnaden för ett anrop innan det utförs."""
# Priser per miljon tokens (juli 2026 — kontrollera officiell prissättning)
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}",
}
# Innan en stor prompt skickas
estimation = estimate_cost(
input_tokens=50_000,
estimated_output_tokens=2_000,
model="gpt-5.6-sol",
)
print(estimation)
Pristabellen är hårdkodad i detta exempel, med datumet i en kommentar. Behandla den som konfigurationsdata som du regelbundet måste verifiera mot den officiella prislistan: en uppskattning baserad på föråldrade priser är farligare än ingen uppskattning alls, eftersom den inger falsk tillit.
Slutligen, känn till gränserna för varje modell för att planera din budget. Kontextfönster varierar mellan modeller inom GPT-5.6-familjen – konsultera den officiella OpenAI-sidan för modeller för aktuella värden, och konfigurera context_limit från dina inställningar istället för att hårdkoda det i anropskoden.
Viktiga punkter
- Använd
tiktokenför att räkna tokens före varje anrop, med hänsyn till överhead per meddelande - Franska konsumerar fler tokens än engelska för motsvarande innehåll: justera dina uppskattningar
- Reservera alltid en budget för utdatatokens inom kontextfönstret
- Hantera kontext automatiskt genom att ta bort de äldsta meddelandena
- Uppskatta kostnader innan du skickar dyra förfrågningar, med verifierade priser