Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Għadd u baġitjar tat-tokens

Lezzjoni 12 / 20 Aġġornat 28 ta’ Lulju 2026 Avvanzat
F'din il-paġna
  1. Fehim tat-tokens
  2. Għadd b’tiktoken
  3. Baġitjar qabel is-sejħa
  4. Stima tal-ispiża qabel ma tonfoq
  5. Punti Ewlenin

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 tiktoken biex 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