Optælling og budgettering af tokens
På denne side
Forståelse af tokens
Tokens er den grundlæggende måleenhed for store sprogmodeller (LLM’er). Hvert API-kald faktureres i tokens, og hver model afviser anmodninger, der overskrider dens kontekstvindue. Hvis du mestrer optælling af tokens, kan du gøre tre ting, som approksimation ikke kan: forudsige omkostninger, før du pådrager dig dem, optimere dine prompts baseret på hårde tal frem for mavefornemmelser og overholde kontekstgrænser uden først at opdage en overfyldning, når API’et smider en fejl.
Optælling med tiktoken
Biblioteket tiktoken anvender præcis samme tokenisering som modellen. Du instansierer en encoder til målmodellen og tæller derefter længden af den kodede sekvens.
import tiktoken
# Encoder til GPT-modeller
encoder = tiktoken.encoding_for_model("gpt-5.6-terra")
def count_tokens(text: str) -> int:
"""Tæller antallet af tokens i en tekst."""
return len(encoder.encode(text))
# Eksempler
print(count_tokens("Hello")) # ~1-2 tokens
print(count_tokens("Hello world")) # ~3-4 tokens
print(count_tokens("Development")) # ~2-3 tokens (accenttegn koster mere)
Det tredje eksempel fortjener et øjebliks eftertanke. „Development” koster mere, end tegnlængden umiddelbart antyder, fordi tegn med accenttegn tokeniseres mindre effektivt. I praksis forbruger et fransk korpus flere tokens end et tilsvarende engelsk: Hvis du har estimeret dit budget ved hjælp af engelske prompts og derefter deployer på fransk, vil din faktura overstige din prognose.
Et API-kald indeholder mere end rå tekst: Hver besked inkluderer en rolle, nogle gange et navn, og API’et tilføjer strukturelle tokens. Følgende funktion inkorporerer dette overhead for at give et realistisk totaltal.
def count_conversation_tokens(messages: list[dict]) -> int:
"""Tæller tokens i en samtale (beskeder + overhead)."""
total = 0
for message in messages:
total += 4 # Overhead pr. besked (rolle osv.)
total += count_tokens(message["content"])
if message.get("name"):
total += count_tokens(message["name"])
total += 2 # Slut-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)}")
Ved en samtale på tre beskeder er overhead ubetydeligt. Ved en historik på to hundrede korte beskeder – typisk for en supportchat – løber det op i næsten tusind tokens, du ikke har taget højde for.
Budgettering før kald
Kontekstvinduet er ikke kun et input-budget: Det er et delt budget mellem det, du sender, og det, modellen genererer. Hvis du fylder vinduet helt op med dit prompt, vil svaret blive afskåret. Strukturen BudgetTokens gør denne allokering eksplicit ved at reservere en del til outputtet på forhånd.
from dataclasses import dataclass
@dataclass
class BudgetTokens:
"""Administrerer token-budgettet for et kald."""
context_limit: int # Modelvindue
system_tokens: int = 0 # System-prompt
history_tokens: int = 0 # Samtalehistorik
user_tokens: int = 0 # Nuværende besked
output_reserve: int = 2000 # Reserveret til 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}"
)
# Eksempel med et kontekstvindue 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 overskredet — komprimering kræves")
Metoden report gør mere end at hjælpe med fejlfinding. Log den på en stikprøve af produktionsanmodninger, så vil du straks se, hvilken komponent der fortærer din kontekst. I de fleste applikationer kommer overraskelsen fra historikken, sjældent fra system-promptet, som alle holder øje med.
Dernæst skal du handle, når budgettet overskrides. Funktionen prepare_context anvender den enkleste og mest robuste regel: Behold de seneste beskeder og drop de ældste, så snart budgettet er brugt op. Iterationen kører baglæns og indsætter i starten for at genoprette den kronologiske rækkefølge.
def prepare_context(
system_prompt: str,
history: list[dict],
message: str,
model_limit: int = 128_000,
output_reserve: int = 4_000,
) -> list[dict]:
"""Forbereder konteksten under overholdelse af token-budgettet."""
system_tokens = count_tokens(system_prompt)
message_tokens = count_tokens(message)
history_budget = (
model_limit - system_tokens - message_tokens - output_reserve
)
# Behold de seneste beskeder inden for budgettet
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}]
)
Denne afkortning er brutal: Alt, der falder uden for budgettet, går tabt. Når ældre kontekst virkelig betyder noget – f.eks. en kundesag sporet over flere uger – skal du erstatte ren sletning med den komprimeringsstrategi, der blev dækket i den foregående lektion.
Estimering af omkostninger før spending
De dyreste faktureringsfejl opstår ved batchbehandling: Du kører en gennemgang af 10.000 dokumenter og opdager beløbet dagen efter. Ved at estimere først, på få millisekunders lokal beregning, undgår du dette scenarie.
def estimate_cost(
input_tokens: int,
estimated_output_tokens: int,
model: str = "gpt-5.6-terra",
) -> dict:
"""Estimerer omkostningerne ved et kald før udførelse."""
# Satser pr. million tokens (juli 2026 — tjek officielle priser)
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}",
}
# Før afsendelse af et stort prompt
estimation = estimate_cost(
input_tokens=50_000,
estimated_output_tokens=2_000,
model="gpt-5.6-sol",
)
print(estimation)
Pristabellen er hardcodet i dette eksempel med datoen i en kommentar. Behandl den som konfigurationsdata, som du regelmæssigt skal verificere mod den officielle prisliste: Et estimat beregnet på forældede priser er farligere end slet intet estimat, fordi det skaber falsk tillid.
Til sidst skal du kende grænserne for hver model for at planlægge dit budget. Kontekstvinduer varierer fra model til model inden for GPT-5.6-familien – konsulter den officielle OpenAI-side om modeller for aktuelle værdier, og konfigurér context_limit ud fra dine indstillinger i stedet for at hardcode det i kald-koden.
Vigtige pointer
- Brug
tiktokentil at tælle tokens før hvert kald under hensyntagen til overhead pr. besked - Fransk forbruger flere tokens end engelsk for tilsvarende indhold: Justér dine estimater
- Reserver altid et budget til output-tokens inden for kontekstvinduet
- Administrér kontekst automatisk ved at droppe de ældste beskeder
- Estimér omkostninger før afsendelse af dyre anmodninger ved hjælp af verificerede satser