Καταμέτρηση και προϋπολογισμός tokens
Σε αυτήν τη σελίδα
Κατανόηση των tokens
Τα tokens αποτελούν τη θεμελιώδη μονάδα μέτρησης για τα LLMs. Κάθε κλήση API χρεώνεται με βάση τα tokens και κάθε μοντέλο απορρίπτει αιτήματα που υπερβαίνουν το παράθυρο πλαισίου του. Η εξοικείωση με την καταμέτρηση tokens σας επιτρέπει να κάνετε τρία πράγματα που η κατά προσέγγιση εκτίμηση δεν μπορεί: να προβλέπετε το κόστος πριν το επωμιστείτε, να βελτιστοποιείτε τα prompts σας βάσει σκληρών αριθμών και όχι διαισθήσεων, και να σέβεστε τα όρια πλαισίου χωρίς να ανακαλύπτετε μια υπερχείλιση μόνο όταν η API πετάει σφάλμα.
Καταμέτρηση με το tiktoken
Η βιβλιοθήκη tiktoken εφαρμόζει ακριβώς την ίδια tokenization με το μοντέλο. Δημιουργείτε έναν κωδικοποιητή (encoder) για το στοχευόμενο μοντέλο και στη συνέχεια μετράτε το μήκος της κωδικοποιημένης ακολουθίας.
import tiktoken
# Encoder για μοντέλα GPT
encoder = tiktoken.encoding_for_model("gpt-5.6-terra")
def count_tokens(text: str) -> int:
"""Μετρά τον αριθμό των tokens σε ένα κείμενο."""
return len(encoder.encode(text))
# Παραδείγματα
print(count_tokens("Hello")) # ~1-2 tokens
print(count_tokens("Hello world")) # ~3-4 tokens
print(count_tokens("Development")) # ~2-3 tokens (οι τόνοι κοστίζουν περισσότερο)
Το τρίτο παράδειγμα αξίζει μια παύση. Η λέξη “Development” κοστίζει περισσότερο από ό,τι θα υπέθετε κανείς βάσει του μήκους των χαρακτήρων της, επειδή οι χαρακτήρες με τόνους κάνουν την tokenization λιγότερο αποδοτική. Στην πράξη, ένα γαλλικό σώμα κειμένου καταναλώνει περισσότερα tokens από ένα ισοδύναμο αγγλικό: αν εκτιμήσατε τον προϋπολογισμό σας χρησιμοποιώντας αγγλικά prompts και στη συνέχεια αναπτύξατε σε γαλλικό περιβάλλον, ο πραγματικός σας λογαριασμός θα υπερβεί την πρόβλεψή σας.
Μια κλήση API μεταφέρει περισσότερα από απλό κείμενο: κάθε μήνυμα περιλαμβάνει έναν ρόλο, μερικές φορές ένα όνομα, και η API προσθέτει δομικά tokens. Η ακόλουθη συνάρτηση ενσωματώνει αυτό το γενικό κόστος (overhead) για να παρέχει έναν ρεαλιστικό συνολικό αριθμό.
def count_conversation_tokens(messages: list[dict]) -> int:
"""Μετρά τα tokens σε μια συνομιλία (μηνύματα + γενικό κόστος)."""
total = 0
for message in messages:
total += 4 # Γενικό κόστος ανά μήνυμα (ρόλος, κλπ.)
total += count_tokens(message["content"])
if message.get("name"):
total += count_tokens(message["name"])
total += 2 # Tokens λήξης
return total
conversation = [
{"role": "system", "content": "Είστε ένας τεχνικός βοηθός."},
{"role": "user", "content": "Εξηγήστε τα microservices."},
{"role": "assistant", "content": "Τα microservices είναι μια αρχιτεκτονική..."},
]
print(f"Συνολικά tokens: {count_conversation_tokens(conversation)}")
Σε μια συνομιλία τριών μηνυμάτων, το γενικό κόστος είναι αμελητέο. Σε ένα ιστορικό διακοσίων σύντομων μηνυμάτων—τυπικό για μια συνομιλία υποστήριξης—αυτό αθροίζεται σε σχεδόν χίλια tokens που δεν λάβατε υπόψη.
Προϋπολογισμός πριν την κλήση
Το παράθυρο πλαισίου δεν είναι ένας προϋπολογισμός μόνο για την είσοδο: είναι ένας κοινός προϋπολογισμός μεταξύ αυτού που στέλνετε και αυτού που παράγει το μοντέλο. Αν γεμίσετε το παράθυρο μέχρι επάνω με το prompt σας, η απάντηση θα περικοπεί. Η δομή BudgetTokens καθιστά αυτή την κατανομή ρητή, δεσμεύοντας εκ των προτέρων ένα μέρος για την έξοδο.
from dataclasses import dataclass
@dataclass
class BudgetTokens:
"""Διαχειρίζεται τον προϋπολογισμό tokens για μια κλήση."""
context_limit: int # Παράθυρο μοντέλου
system_tokens: int = 0 # System prompt
history_tokens: int = 0 # Ιστορικό συνομιλίας
user_tokens: int = 0 # Τρέχον μήνυμα
output_reserve: int = 2000 # Δεσμευμένο για την απάντηση
@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"Πλαίσιο: {self.context_limit} | "
f"System: {self.system_tokens} | "
f"Ιστορικό: {self.history_tokens} | "
f"Χρήστης: {self.user_tokens} | "
f"Δέσμευση εξόδου: {self.output_reserve} | "
f"Διαθέσιμα: {self.available_tokens}"
)
# Παράδειγμα με παράθυρο πλαισίου 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("Ο προϋπολογισμός ξεπεράστηκε — απαιτείται συμπίεση")
Η μέθοδος report κάνει περισσότερα από το να βοηθά στην αποσφαλμάτωση. Καταγράψτε την σε ένα δείγμα αιτημάτων παραγωγής και θα δείτε αμέσως ποιο στοιχείο καταναλώνει το πλαίσιο σας. Στις περισσότερες εφαρμογές, η έκπληξη προέρχεται από το ιστορικό, σπάνια από το system prompt που όλοι παρακολουθούν.
Στη συνέχεια, πρέπει να δράσετε όταν ο προϋπολογισμός ξεπεραστεί. Η συνάρτηση prepare_context εφαρμόζει τον απλούστερο και πιο robust κανόνα: κρατήστε τα πιο πρόσφατα μηνύματα και απορρίψτε τα παλαιότερα μόλις εξαντληθεί ο προϋπολογισμός. Η επανάληψη τρέχει ανάποδα, εισάγοντας στην αρχή για να αποκατασταθεί η χρονολογική σειρά.
def prepare_context(
system_prompt: str,
history: list[dict],
message: str,
model_limit: int = 128_000,
output_reserve: int = 4_000,
) -> list[dict]:
"""Προετοιμάζει το πλαίσιο σεβόμενη τον προϋπολογισμό tokens."""
system_tokens = count_tokens(system_prompt)
message_tokens = count_tokens(message)
history_budget = (
model_limit - system_tokens - message_tokens - output_reserve
)
# Κρατήστε τα πιο πρόσφατα μηνύματα εντός προϋπολογισμού
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}]
)
Αυτή η περικοπή είναι βίαιη: οτιδήποτε πέφτει εκτός προϋπολογισμού χάνεται. Όταν το παλαιότερο πλαίσιο έχει πραγματική σημασία—για παράδειγμα, ένας φάκελος πελάτη που παρακολουθείται για αρκετές εβδομάδες—αντικαταστήστε την απλή διαγραφή με τη στρατηγική συμπίεσης που καλύφθηκε στο προηγούμενο μάθημα.
Εκτίμηση κόστους πριν τη δαπάνη
Τα πιο ακριβά σφάλματα χρέωσης προέρχονται από την επεξεργασία παρτίδων (batch processing): εκτελείτε μια διέλευση σε 10.000 έγγραφα και ανακαλύπτετε το ποσό την επόμενη μέρα. Η εκτίμηση εκ των προτέρων, με λίγα χιλιοστά του δευτερολέπτου τοπικού υπολογισμού, αποφεύγει αυτό το σενάριο.
def estimate_cost(
input_tokens: int,
estimated_output_tokens: int,
model: str = "gpt-5.6-terra",
) -> dict:
"""Εκτιμά το κόστος μιας κλήσης πριν την εκτέλεσή της."""
# Τιμές ανά εκατομμύριο tokens (Ιούλιος 2026 — ελέγξτε τις επίσημες τιμές)
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}",
}
# Πριν την αποστολή ενός μεγάλου prompt
estimation = estimate_cost(
input_tokens=50_000,
estimated_output_tokens=2_000,
model="gpt-5.6-sol",
)
print(estimation)
Ο πίνακας τιμών είναι σκληρά κωδικοποιημένος σε αυτό το παράδειγμα, με την ημερομηνία σε ένα σχόλιο. Αντιμετωπίστε τον ως δεδομένα διαμόρφωσης που πρέπει να επαληθεύετε τακτικά έναντι του επίσημου τιμολογίου: μια εκτίμηση που υπολογίζεται με ξεπερασμένες τιμές είναι πιο επικίνδυνη από το να μην υπάρχει καθόλου εκτίμηση, επειδή εμπνέει ψευδή αυτοπεποίθηση.
Τέλος, γνωρίστε τα όρια κάθε μοντέλου για να σχεδιάσετε τον προϋπολογισμό σας. Τα παράθυρα πλαισίου διαφέρουν από μοντέλο σε μοντέλο εντός της οικογένειας GPT-5.6—συμβουλευτείτε την επίσημη σελίδα μοντέλων της OpenAI για τις τρέχουσες τιμές και διαμορφώστε το context_limit από τις ρυθμίσεις σας αντί να το κωδικοποιείτε σκληρά στον κώδικα κλήσης.
Βασικά σημεία
- Χρησιμοποιήστε το
tiktokenγια να μετράτε τα tokens πριν από κάθε κλήση, λαμβάνοντας υπόψη το γενικό κόστος ανά μήνυμα - Τα γαλλικά καταναλώνουν περισσότερα tokens από τα αγγλικά για ισοδύναμο περιεχόμενο: προσαρμόστε τις εκτιμήσεις σας
- Δεσμεύετε πάντα έναν προϋπολογισμό για tokens εξόδου εντός του παραθύρου πλαισίου
- Διαχειριστείτε αυτόματα το πλαίσιο απορρίπτοντας τα παλαιότερα μηνύματα
- Εκτιμήστε το κόστος πριν στείλετε ακριβά αιτήματα, χρησιμοποιώντας επαληθευμένες τιμές