Salt la conținutul principal
Română— Alege o limbă
Meniu

Numărarea și bugetarea tokenilor

Lecția 12 din 20 Actualizată 28 iulie 2026 Avansat
Pe această pagină
  1. Înțelegerea tokenilor
  2. Numărarea cu tiktoken
  3. Bugetarea înainte de apel
  4. Estimarea costului înainte de cheltuire
  5. Puncte cheie

Înțelegerea tokenilor

Tokenii reprezintă unitatea fundamentală de măsură pentru modelele LLM. Fiecare apel API este facturat în tokeni, iar fiecare model respinge cererile care depășesc fereastra sa de context. Stăpânirea numărării tokenilor vă permite să faceți trei lucruri pe care aproximarea nu le poate oferi: să preziceți costurile înainte de a le incurge, să vă optimizați prompturile pe baza unor date concrete și nu a intuiției, și să respectați limitele de context fără a descoperi o depășire doar atunci când API-ul aruncă o eroare.

Numărarea cu tiktoken

Biblioteca tiktoken aplică exact aceeași tokenizare ca și modelul. Instanțiați un encoder pentru modelul țintă, apoi numărați lungimea secvenței codificate.

import tiktoken

# Encoder pentru modelele GPT
encoder = tiktoken.encoding_for_model("gpt-5.6-terra")

def count_tokens(text: str) -> int:
    """Numără numărul de tokeni dintr-un text."""
    return len(encoder.encode(text))

# Exemple
print(count_tokens("Hello"))           # ~1-2 tokeni
print(count_tokens("Hello world"))     # ~3-4 tokeni
print(count_tokens("Development"))     # ~2-3 tokeni (accentele costă mai mult)

Al treilea exemplu merită o pauză de reflecție. Cuvântul „Development“ costă mai mult decât ar sugera lungimea sa în caractere, deoarece caracterele accentuate se tokenizează mai puțin eficient. În practică, un corpus în franceză consumă mai mulți tokeni decât unul echivalent în engleză: dacă v-ați estimat bugetul folosind prompturi în engleză și apoi l-ați implementat în franceză, factura reală va depăși previziunea dumneavoastră.

Un apel API conține mai mult decât text brut: fiecare mesaj include un rol, uneori un nume, iar API-ul adaugă tokeni structurali. Funcția următoare încorporează această suprasarcină pentru a oferi un total realist.

def count_conversation_tokens(messages: list[dict]) -> int:
    """Numără tokenii într-o conversație (mesaje + suprasarcină)."""
    total = 0
    for message in messages:
        total += 4  # Suprasarcină per mesaj (rol, etc.)
        total += count_tokens(message["content"])
        if message.get("name"):
            total += count_tokens(message["name"])
    total += 2  # Tokeni de final
    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)}")

La o conversație de trei mesaje, suprasarcina este neglijabilă. La un istoric de două sute de mesaje scurte—tipic pentru un chat de suport—aceasta se acumulează până la aproape o mie de tokeni pe care nu i-ați luat în calcul.

Bugetarea înainte de apel

Fereastra de context nu este un buget doar pentru intrare: este un buget partajat între ceea ce trimiteți și ceea ce generează modelul. Dacă umpleți fereastra până la refuz cu promptul dumneavoastră, răspunsul va fi trunchiat. Structura BudgetTokens face această alocare explicită, rezervând din start o porțiune pentru ieșire.

from dataclasses import dataclass

@dataclass
class BudgetTokens:
    """Gestionează bugetul de tokeni pentru un apel."""
    context_limit: int       # Fereastra modelului
    system_tokens: int = 0   # Prompt de sistem
    history_tokens: int = 0  # Istoricul conversației
    user_tokens: int = 0     # Mesajul curent
    output_reserve: int = 2000 # Rezervat pentru răspuns

    @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}"
        )

# Exemplu cu o fereastră de context de 128K tokeni
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("Buget depășit — este necesară compactarea")

Metoda report face mai mult decât să ajute la depanare. Înregistrați-o (log) pe un eșantion de cereri din producție și veți vedea imediat care componentă vă consumă contextul. În majoritatea aplicațiilor, surpriza vine din istoric, rareori din promptul de sistem pe care toată lumea îl monitorizează.

În continuare, trebuie să acționați când bugetul este depășit. Funcția prepare_context aplică regula cea mai simplă și robustă: păstrați mesajele cele mai recente și renunțați la cele mai vechi imediat ce bugetul este epuizat. Iterarea se face în ordine inversă, inserând la început pentru a restabili ordinea cronologică.

def prepare_context(
    system_prompt: str,
    history: list[dict],
    message: str,
    model_limit: int = 128_000,
    output_reserve: int = 4_000,
) -> list[dict]:
    """Pregătește contextul respectând bugetul de tokeni."""

    system_tokens = count_tokens(system_prompt)
    message_tokens = count_tokens(message)
    history_budget = (
        model_limit - system_tokens - message_tokens - output_reserve
    )

    # Păstrează mesajele cele mai recente în limita bugetului
    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}]
    )

Această trunchiere este brutală: orice cade în afara bugetului este pierdut. Atunci când contextul mai vechi contează cu adevărat—un dosar de client urmărit pe parcursul mai multor săptămâni—înlocuiți ștergerea pură cu strategia de compactare abordată în lecția anterioară.

Estimarea costului înainte de cheltuire

Cele mai costisitoare erori de facturare provin din procesarea în loturi: rulați o trecere pe 10.000 de documente și descoperiți suma a doua zi. Estimarea prealabilă, în câțiva milisecunde de calcul local, evită acest scenariu.

def estimate_cost(
    input_tokens: int,
    estimated_output_tokens: int,
    model: str = "gpt-5.6-terra",
) -> dict:
    """Estimează costul unui apel înainte de executarea acestuia."""
    # Tarife per milion de tokeni (iulie 2026 — verificați prețurile oficiale)
    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}",
    }

# Înainte de a trimite un prompt mare
estimation = estimate_cost(
    input_tokens=50_000,
    estimated_output_tokens=2_000,
    model="gpt-5.6-sol",
)
print(estimation)

Tabelul de tarife este codificat rigid în acest exemplu, cu data într-un comentariu. Tratați-l ca pe o dată de configurare pe care trebuie să o verificați regulat față de grila oficială de prețuri: o estimare calculată pe baza unor prețuri învechite este mai periculoasă decât lipsa oricărei estimări, deoarece inspiră o încredere falsă.

În final, cunoașteți limitele fiecărui model pentru a vă planifica bugetul. Ferestrele de context variază de la un model la altul în cadrul familiei GPT-5.6—consultați pagina oficială OpenAI Models pentru valorile curente și configurați context_limit din setările dumneavoastră, în loc să îl codificați rigid în codul de apelare.

Puncte cheie

  • Folosiți tiktoken pentru a număra tokenii înainte de fiecare apel, luând în calcul suprasarcina per mesaj
  • Franceza consumă mai mulți tokeni decât engleza pentru un conținut echivalent: ajustați-vă estimările
  • Rezervați întotdeauna un buget pentru tokenii de ieșire în cadrul ferestrei de context
  • Gestionați contextul automat renunțând la mesajele cele mai vechi
  • Estimați costurile înainte de a trimite cereri costisitoare, folosind tarife verificate