Għadd u baġitjar tat-tokens
F'din il-paġna
Fehim tat-tokens
It-tokens huma l-unità fundamentali ta’ kejl għall-LLMs. Kull sejħa API tiġi fatturata f’tokens, u kull mudell jiċħad talbiet li jaqbżu t-tieqa tal-kuntest tiegħu. Li tmexxi l-għadd tat-tokens jippermettilek tagħmel tliet affarijiet li l-approssimazzjoni ma tistax: tbassar l-ispejjeż qabel ma tincurrhom, tottimizza l-prompts tiegħek ibbażat fuq numri konkreti minflok sens intern, u tirrispetta l-limiti tal-kuntest mingħajr ma tiskopri overflow biss meta l-API tarmi żball.
Għadd b’tiktoken
Il-librerija tiktoken tapplika l-istess tokenizzazzjoni eżatta tal-mudell. Tistanzja encoder għall-mudell fil-mira, imbagħad tgħodd it-tul tas-sekwenza kodifikata.
import tiktoken
# Encoder għal mudelli GPT
encoder = tiktoken.encoding_for_model("gpt-5.6-terra")
def count_tokens(text: str) -> int:
"""Tgħodd in-numru ta' tokens f'test."""
return len(encoder.encode(text))
# Eżempji
print(count_tokens("Hello")) # ~1-2 tokens
print(count_tokens("Hello world")) # ~3-4 tokens
print(count_tokens("Development")) # ~2-3 tokens (l-aċċenti jiswew aktar)
It-tielet eżempju jeħtieġ waqfa. “Development” jiswi aktar milli jissuġġerixxi t-tul tal-karattri tiegħu għax karattri b’aċċenti jiġu tokenizzati b’mod inqas effiċjenti. Fil-prattika, corpus bil-Franċiż jikkonsma aktar tokens minn wieħed ekwivalenti bl-Ingliż: jekk stimejt il-baġit tiegħek bl-użu ta’ prompts bl-Ingliż u mbagħad iddispjajtajh bil-Franċiż, il-kont attwali tiegħek jaqbeż il-previżjoni tiegħek.
Sejħa API ġġorr aktar minn test sempliċi: kull messaġġ jinkludi rwol, xi kultant isem, u l-API żżid tokens strutturali. Il-funzjoni li ġejja tinkorpora dan l-overhead biex tipprovdi total realistiku.
def count_conversation_tokens(messages: list[dict]) -> int:
"""Tgħodd tokens f'konversazzjoni (messaġġi + overhead)."""
total = 0
for message in messages:
total += 4 # Overhead għal kull messaġġ (rwol, eċċ.)
total += count_tokens(message["content"])
if message.get("name"):
total += count_tokens(message["name"])
total += 2 # Tokens tat-tmiem
return total
conversation = [
{"role": "system", "content": "Int assistent tekniku."},
{"role": "user", "content": "Spjega l-mikroservizzi."},
{"role": "assistant", "content": "Il-mikroservizzi huma arkitettura..."},
]
print(f"Total tokens: {count_conversation_tokens(conversation)}")
Fuq konversazzjoni ta’ tliet messaġġi, l-overhead huwa negliġibbli. Fuq storja ta’ mitejn messaġġ qasir—tipiku għal chat ta’ appoġġ—dan jammonta għal kważi elf token li ma kontx ikkunsidrajt.
Baġitjar qabel is-sejħa
It-tieqa tal-kuntest mhix baġit ta’ input: hija baġit kondiviż bejn dak li tibgħat u dak li l-mudell jiġġenera. Jekk timla t-tieqa sal-quċċata bil-prompt tiegħek, ir-risposta tiġi maqtugħa. L-istruttura BudgetTokens tagħmel din l-allokazzjoni espliċita billi tirriżerva porzjon għall-output minn qabel.
from dataclasses import dataclass
@dataclass
class BudgetTokens:
"""Timmaniġġja l-baġit tat-tokens għal sejħa."""
context_limit: int # Tieqa tal-mudell
system_tokens: int = 0 # Prompt tas-sistema
history_tokens: int = 0 # Storja tal-konversazzjoni
user_tokens: int = 0 # Messaġġ kurrenti
output_reserve: int = 2000 # Irriżervat għar-risposta
@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"Kuntest: {self.context_limit} | "
f"Sistema: {self.system_tokens} | "
f"Storja: {self.history_tokens} | "
f"Utent: {self.user_tokens} | "
f"Riżerva output: {self.output_reserve} | "
f"Disponibbli: {self.available_tokens}"
)
# Eżempju b'tieqa ta' kuntest ta' 128K token
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("Baġit maqbuż — meħtieġa kompattazzjoni")
Il-metodu report jagħmel aktar milli jgħin fid-debugging. Irreġistrah fuq kampjun ta’ talbiet tal-produzzjoni, u minnufih tara liema komponent qed jikkonsma l-kuntest tiegħek. Fil-biċċa l-kbira tal-applikazzjonijiet, is-sorpriża tiġi mill-istorja, rari mill-prompt tas-sistema li kulħadd jissorvelja.
Sussegwentement, trid taġixxi meta l-baġit jinqabeż. Il-funzjoni prepare_context tapplika l-aktar regola sempliċi u robusta: żomm l-aktar messaġġi riċenti u neħħi l-eqdem waħdethom hekk kif il-baġit jintemm. L-iterazzjoni timxi lura, tidħol fil-bidu biex terġa’ tistabbilixxi l-ordni kronoloġika.
def prepare_context(
system_prompt: str,
history: list[dict],
message: str,
model_limit: int = 128_000,
output_reserve: int = 4_000,
) -> list[dict]:
"""Tħejji l-kuntest filwaqt li tirrispetta l-baġit tat-tokens."""
system_tokens = count_tokens(system_prompt)
message_tokens = count_tokens(message)
history_budget = (
model_limit - system_tokens - message_tokens - output_reserve
)
# Żomm l-aktar messaġġi riċenti fil-baġit
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}]
)
Dan it-tronkament huwa brutali: kull ħaġa li taqa’ barra mill-baġit tintilef. Meta l-kuntest antik verament jimpotta—fajl ta’ klijent traċċat fuq diversi ġimgħat—ibdel it-tħassir pur bl-istrateġija ta’ kompattazzjoni koperta fil-lezzjoni preċedenti.
Stima tal-ispiża qabel ma tonfoq
L-aktar żbalji ta’ fatturazzjoni għaljin ġejjin mill-ipproċessar bil-batch: tmexxi pass fuq 10,000 dokument u tiskopri l-ammont l-għada. L-istima minn qabel, f’ftit millisekondi ta’ kalkolu lokali, tevita dan ix-xenarju.
def estimate_cost(
input_tokens: int,
estimated_output_tokens: int,
model: str = "gpt-5.6-terra",
) -> dict:
"""Tistma l-ispiża ta' sejħa qabel ma twettaqha."""
# Rati għal kull miljun token (Lulju 2026 — iċċekkja l-prezzijiet uffiċjali)
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}",
}
# Qabel ma tibgħat prompt kbir
estimation = estimate_cost(
input_tokens=50_000,
estimated_output_tokens=2_000,
model="gpt-5.6-sol",
)
print(estimation)
It-tabella tar-rati hija mwaħħla f’dan l-eżempju, bid-data f’kumment. Itrattaha bħala data ta’ konfigurazzjoni biex tivverifika regolarment mal-grilja tal-prezzijiet uffiċjali: stima kkalkulata fuq prezzijiet antikati hija aktar perikoluża minn l-ebda stima, għax tispira kunfidenza falza.
Fl-aħħar nett, af il-limiti ta’ kull mudell biex tippjana l-baġit tiegħek. It-twieqi tal-kuntest ivarjaw minn mudell għal mudell fil-familja GPT-5.6—ikkonsulta l-paġna uffiċjali tal-mudelli ta’ OpenAI għal valuri kurrenti, u kkonfigura context_limit mill-settings tiegħek minflok ma twaħħalha fil-kodiċi tas-sejħa.
Punti Ewlenin
- Uża
tiktokenbiex tgħodd it-tokens qabel kull sejħa, filwaqt li tikkunsidra l-overhead għal kull messaġġ - Il-Franċiż jikkonsma aktar tokens mill-Ingliż għal kontenut ekwivalenti: aġġusta l-istimi tiegħek
- Dejjem irriżerva baġit għat-tokens tal-output fit-tieqa tal-kuntest
- Immaniġġja l-kuntest awtomatikament billi tneħħi l-eqdem messaġġi
- Stma l-ispejjeż qabel ma tibgħat talbiet għaljin, bl-użu ta’ rati vverifikati