Μέτρηση και ανάλυση της καθυστέρησης
Σε αυτήν τη σελίδα
Γιατί η καθυστέρηση είναι η νούμερο ένα μετρική σας
Όταν αναπτύσσετε μια εφαρμογή που τροφοδοτείται από LLM σε περιβάλλον παραγωγής, η καθυστέρηση που αντιλαμβάνονται οι χρήστες σας καθορίζει άμεσα την υιοθέτησή της. Μια απάντηση που χρειάζεται 8 δευτερόλεπτα για να εμφανιστεί διώχνει το 70% των χρηστών: κλείνουν την καρτέλα, επαναλαμβάνουν το αίτημα ή καταλήγουν στο συμπέρασμα ότι το εργαλείο δεν λειτουργεί. Καμία βελτίωση στην ποιότητα δεν μπορεί να αντισταθμίσει αυτή την απώλεια, διότι συμβαίνει πριν καν ο χρήστης διαβάσει την απάντηση.
Η πρόκληση στην παραγωγή είναι ότι το «είναι αργό» δεν αποτελεί διάγνωση. Η ίδια διάρκεια των οκτώ δευτερολέπτων θα μπορούσε να οφείλεται σε ένα υπερβολικά μεγάλο prompt συστήματος, σε μια υπερβολικά φιλόδοξη ρύθμιση συλλογισμού, σε έναν κακώς τοποθετημένο διακομιστή εφαρμογής ή σε μετα-επεξεργασία που περιμένει ολόκληρη την απάντηση πριν εμφανίσει οτιδήποτε. Κάθε αιτία απαιτεί διαφορετική διόρθωση και η διόρθωση της λάθος δεν αλλάζει τίποτα. Αυτό το μάθημα σας διδάσκει να μετράτε, να αναλύετε και να διαγιγνώσκετε την καθυστέρηση από άκρο σε άκρο, ώστε να μετατρέπετε ένα παράπονο σε έναν αριθμό που επιδέχεται δράση.
Συνιστώσες της καθυστέρησης
Η συνολική καθυστέρηση κλήσης API αναλύεται σε τέσσερα τμήματα που πρέπει να διαχωρίσετε. Η καθυστέρηση δικτύου είναι ο χρόνος μετάβασης μεταξύ του διακομιστή σας και του API του OpenAI· είναι αόρατη στα αρχεία καταγραφής της εφαρμογής σας, αλλά μπορεί να ξεπεράσει τα 100 χιλιοστά του δευτερολέπτου αν ο διακομιστής σας βρίσκεται μακριά από το σημείο πρόσβασης. Ο Χρόνος έως το Πρώτο Token (TTFT) μετρά την καθυστέρηση πριν παραχθεί το πρώτο token: αυτό είναι το τμήμα που οι χρήστες αντιλαμβάνονται ως «αναμονή», καθώς η οθόνη παραμένει κενή μέχρι να ολοκληρωθεί. Στη συνέχεια, ο Χρόνος ανά Token Εξόδου (TPOT) περιγράφει την ταχύτητα παραγωγής για κάθε επόμενο token· πολλαπλασιαζόμενος με το μήκος της απάντησης, δίνει τη διάρκεια κύλισης του κειμένου. Τέλος, η καθυστέρηση εφαρμογής καλύπτει ό,τι κάνει ο δικός σας διακομιστής πριν και μετά την κλήση: ανάκτηση εγγράφων, συναρμολόγηση του prompt, επικύρωση του JSON εξόδου και εγγραφή στη βάση δεδομένων.
Αυτή η ανάλυση δεν είναι ακαδημαϊκή άσκηση. Μια ομάδα που ανακαλύπτει ότι το TTFT της είναι ικανοποιητικό αλλά η καθυστέρηση της εφαρμογής προσθέτει δύο δευτερόλεπτα, δεν θα αλλάξει μοντέλο: θα εξετάσει το ερώτημα SQL για την ανάκτηση του συμφραζομένου.
Μέτρηση με Python
Ορίστε πώς να οργανώσετε μια κλήση στο Responses API για να καταγράψετε κάθε τμήμα:
import time
import openai
client = openai.OpenAI()
def measure_latency(prompt: str, model: str = "gpt-5.6-terra") -> dict:
"""Measure decomposed latency of an API call."""
metrics = {}
start_total = time.perf_counter()
# Stream the call to measure TTFT
stream = client.responses.create(
model=model,
input=prompt,
stream=True,
)
first_token = True
output_tokens = 0
for event in stream:
if event.type == "response.output_text.delta":
if first_token:
metrics["ttft"] = time.perf_counter() - start_total
start_generation = time.perf_counter()
first_token = False
output_tokens += 1
metrics["total_duration"] = time.perf_counter() - start_total
metrics["output_tokens"] = output_tokens
if output_tokens > 1:
metrics["tpot"] = (
(metrics["total_duration"] - metrics["ttft"]) / (output_tokens - 1)
)
return metrics
result = measure_latency("Explain Bayes' theorem in 3 sentences.")
for key, value in result.items():
print(f"{key}: {value:.4f}" if isinstance(value, float) else f"{key}: {value}")
Το βασικό συμπέρασμα από αυτόν τον κώδικα είναι η χρήση του stream=True. Χωρίς ροή δεδομένων, δεν μπορείτε να απομονώσετε το TTFT: το API επιστρέφει μόνο μετά την πλήρη απάντηση, οπότε μετράτε μόνο ένα συνολικό χρόνο. Ο χρονομετρητής ξεκινά πριν την κλήση, σταματά στην πρώτη διαφοροποίηση κειμένου και η υπόλοιπη διάρκεια διαιρούμενη με τον αριθμό των υπόλοιπων tokens δίνει το TPOT. Εκτελέστε το ίδιο prompt σε δύο μοντέλα ή με δύο ρυθμίσεις συλλογισμού και, μέσα σε λίγα λεπτά, θα έχετε τη ποσοτική σύγκριση που αντικαθιστά τις εικασίες της ομάδας σας.
Διάγνωση σημείων συμφόρησης
Ένα υψηλό TTFT, πάνω από δύο δευτερόλεπτα, υποδεικνύει τρεις αιτίες. Η πιο συνηθισμένη είναι ένα υπερβολικά μεγάλο prompt συστήματος που δεν τίθεται σε cache: το μοντέλο πρέπει να καταναλώσει several χιλιάδες tokens πριν ξεκινήσει να γράφει, σε κάθε κλήση. Ακολουθεί μια υψηλή ρύθμιση συλλογισμού—high, xhigh ή max στο GPT-5.6—η οποία κάνει σκόπιμα το μοντέλο να «σκέφτεται» πριν παράγει οποιαδήποτε ορατή έξοδο· αυτό δεν είναι σφάλμα, είναι αναμενόμενη συμπεριφορά, αλλά πρέπει να αποτελεί συνειδητή επιλογή και όχι ρύθμιση κληρονομημένη από ένα πρωτότυπο. Τέλος, θα μπορούσε να υπάρχει μια αιχμή φόρτου από την πλευρά του OpenAI, την οποία δεν μπορείτε να ελέγξετε: γι’ αυτό ακριβώς χρειάζεστε συνεχή μέτρηση και όχι έναν εφάπαξ έλεγχο, ώστε να τη διακρίνετε από τις άλλες δύο.
Ένα υψηλό TPOT, πάνω από 50 ms ανά token, ερμηνεύεται διαφορετικά. Ένα πολύ υψηλό max_output_tokens ωθεί το μοντέλο να παράγει μεγάλες ακολουθίες και η συνολική διάρκεια αυξάνεται μηχανικά, ακόμα κι αν κάθε token φτάνει με κανονική ταχύτητα. Η χρήση σύνθετης κλήσης συναρτήσεων με πολλά δηλωμένα εργαλεία επιβαρύνει επίσης την παραγωγή. Συγκεκριμένα, μια ομάδα που άφησε δεκαπέντε εργαλεία στο σχήμα της ενώ τα μισά δεν χρησιμοποιούνται πλέον, θα πληρώνει αυτό το γενικό κόστος σε κάθε κλήση.
Εργαλεία παρακολούθησης
Η μέτρηση μία φορά δεν αρκεί: πρέπει να παρακολουθείτε την κατανομή με την πάροδο του χρόνου, διότι η ουρά της κατανομής είναι που δημιουργεί αιτήματα υποστήριξης. Για συνεχή παρακολούθηση στην παραγωγή, ενσωματώστε αυτές τις μετρικές στη στοίβα παρατηρησιμότητάς σας:
import logging
from dataclasses import dataclass, field
@dataclass
class LatencyMetrics:
"""Aggregates latency metrics over a sliding window."""
measurements: list[dict] = field(default_factory=list)
def add(self, measurement: dict) -> None:
self.measurements.append(measurement)
if len(self.measurements) > 1000:
self.measurements = self.measurements[-1000:]
@property
def ttft_p50(self) -> float:
values = sorted(m["ttft"] for m in self.measurements if "ttft" in m)
if not values:
return 0.0
return values[len(values) // 2]
@property
def ttft_p99(self) -> float:
values = sorted(m["ttft"] for m in self.measurements if "ttft" in m)
if not values:
return 0.0
idx = int(len(values) * 0.99)
return values[min(idx, len(values) - 1)]
def report(self) -> str:
return (
f"TTFT p50={self.ttft_p50:.3f}s p99={self.ttft_p99:.3f}s | "
f"Samples: {len(self.measurements)}"
)
Το κυλιόμενο παράθυρο των χιλίων μετρήσεων αποτρέπει την απεριόριστη αύξηση της μνήμης, διατηρώντας παράλληλα ένα αντιπροσωπευτικό δείγμα της πρόσφατης κίνησης. Το κρίσιμο σημείο είναι ότι αυτή η κλάση εκθέτει δύο εκατοστημόρια και όχι έναν μέσο όρο: ένα p50 των 700 ms με p99 των 6 δευτερολέπτων περιγράφει μια υπηρεσία που οι περισσότεροι χρήστες βρίσκουν γρήγορη και μια μειοψηφία μη χρησιμοποιήσιμη. Ένας μέσος όρος θα είχε αποκρύψει και τις δύο πραγματικότητες. Συνδέστε τη μέθοδο report() στο εργαλείο μετρικών σας και ορίστε ένα όριο ειδοποίησης στο p99 πριν αγγίξετε το υπόλοιπο σύστημα.
Βασικά σημεία
- Η καθυστέρηση αναλύεται σε TTFT + παραγωγή (TPOT × tokens) + δίκτυο
- Να μετράτε πάντα με ροή δεδομένων (streaming) για να λάβετε το πραγματικό TTFT
- Παρακολουθείτε τα εκατοστημόρια p50 και p99, όχι μόνο τον μέσο όρο
- Η επιλογή μοντέλου και οι ρυθμίσεις συλλογισμού επηρεάζουν άμεσα την καθυστέρηση: το GPT-5.6 Terra με χαμηλό συλλογισμό αποκρίνεται ταχύτερα από το GPT-5.6 Sol με υψηλό συλλογισμό