BroadRouter

LLM लेटेंसी: TTFT, टोकन प्रति सेकंड और एंड-टू-एंड समय

BroadNet Inference टीम · 4 मिनट में पढ़ें · प्रकाशित · अपडेट किया गया

टाइम टू फ़र्स्ट टोकन (TTFT) पहले आउटपुट टोकन से पहले का इंतज़ार है। टोकन प्रति सेकंड बताता है कि उसके बाद जवाब कितनी तेज़ी से स्ट्रीम होता है। एंड-टू-एंड लेटेंसी कुल समय है: TTFT और जनरेशन का समय (≈ आउटपुट टोकन ÷ स्पीड)। प्रॉम्प्ट की लंबाई और क्यू TTFT तय करते हैं, मॉडल का आकार और लोड स्पीड, और जवाब की लंबाई कुल समय। तीनों को p50 और p95 पर मापें।

“API धीमा है” के तीन अलग मतलब हो सकते हैं, और हर एक का इलाज अलग है। चैट यूज़र पहले शब्द का इंतज़ार करता है। एजेंट पूरी टूल कॉल का इंतज़ार करता है। बैच जॉब को प्रति घंटे टोकन से मतलब है। यह पोस्ट तीनों संख्याओं को परिभाषित करती है, दिखाती है कि अपने कोड से उन्हें कैसे मापें, और हर सुधार को उस संख्या से जोड़ती है जिसे वह असल में बदलता है।

TTFT, टोकन प्रति सेकंड और एंड-टू-एंड लेटेंसी क्या हैं?

NVIDIA की बेंचमार्किंग गाइड साफ़ परिभाषाएँ देती है, और वे क्लाइंट से दिखने वाली चीज़ों से मेल खाती हैं:

मेट्रिक क्या मापता है किसे महसूस होता है किस पर निर्भर
टाइम टू फ़र्स्ट टोकन (TTFT) अनुरोध भेजा → पहला टोकन मिला चैट यूज़र नेटवर्क, क्यू, प्रॉम्प्ट की लंबाई (prefill), कैश हिट
इंटर-टोकन लेटेंसी (ITL) टोकन के बीच का औसत अंतर स्ट्रीम हो रहे जवाब के पाठक मॉडल का आकार, हार्डवेयर, सर्वर लोड
प्रति यूज़र टोकन प्रति सेकंड पहले टोकन के बाद के आउटपुट टोकन ÷ जनरेशन का समय (पहले से आख़िरी टोकन तक); 1 ÷ औसत ITL के बराबर पाठक, एजेंट ITL जैसा ही
एंड-टू-एंड लेटेंसी अनुरोध भेजा → आख़िरी टोकन मिला एजेंट, API, बैच TTFT + जनरेशन का समय

इन्हें जोड़ने वाला फ़ॉर्मूला:

एंड-टू-एंड ≈ TTFT + (आउटपुट टोकन − 1) × ITL ≈ TTFT + आउटपुट टोकन ÷ प्रति यूज़र टोकन प्रति सेकंड

प्रति यूज़र स्पीड और सर्वर का थ्रूपुट एक नहीं हैं; थ्रूपुट वह कुल टोकन है जो सर्वर सभी यूज़र के लिए बनाता है, और प्रोवाइडर एक को बढ़ा सकता है जबकि दूसरा घटता है।

BroadNet अपने प्लान मॉडल के लिए जो सामान्य स्पीड प्रकाशित करता है, लगभग 100 टोकन प्रति सेकंड, उसे लें। जनरेशन का समय जवाब की लंबाई के साथ बढ़ता है: 4,000 टोकन की कोड फ़ाइल बनने में 50 टोकन के वर्गीकरण से लगभग अस्सी गुना समय लगता है, जबकि दोनों एक ही TTFT का इंतज़ार करते हैं। छोटे जवाबों में इंतज़ार का ज़्यादातर हिस्सा TTFT है; लंबे जवाबों में स्पीड और लंबाई।

रीज़निंग मॉडल के लिए चौथी संख्या क्यों चाहिए?

DeepSeek V4.1 Flash जैसे रीज़निंग मॉडल जवाब देने से पहले सोचते हैं, और यह सोचना भी आउटपुट टोकन है। अगर मॉडल लगभग 100 टोकन प्रति सेकंड पर 800 टोकन रीज़निंग में लगाता है, तो पहला दिखने वाला शब्द आने से पहले यूज़र को उन सभी 800 टोकन के बनने का इंतज़ार करना पड़ता है, भले ही नेटवर्क पर TTFT तेज़ दिखे। इसलिए टाइम टू फ़र्स्ट कंटेंट टोकन अलग से मापें। BroadNet Inference पर reasoning_effort: "low" आसान क़दमों के लिए सोचने का समय घटाता है; रीज़निंग गाइड इसका नफ़ा-नुक़सान समझाती है।

क्लाइंट से लेटेंसी कैसे मापें?

जहाँ आपके यूज़र हैं, वहीं से मापें, स्ट्रीमिंग चालू रखकर। सर्वर-साइड टाइमर नेटवर्क और किसी भी प्रॉक्सी का समय छोड़ देते हैं।

import os, time, statistics
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])

def timed(model, messages, max_tokens=1500):
    t0 = time.perf_counter()
    first = first_content = None
    usage = None
    stream = client.chat.completions.create(
        model=model, messages=messages, max_tokens=max_tokens,
        stream=True, stream_options={"include_usage": True},
    )
    for chunk in stream:
        now = time.perf_counter()
        if chunk.choices:
            if first is None:
                first = now
            if chunk.choices[0].delta.content and first_content is None:
                first_content = now
        if chunk.usage:
            usage = chunk.usage
    end = time.perf_counter()
    out = usage.completion_tokens if usage else 0
    return {
        "ttft": first - t0,
        "ttfct": (first_content or end) - t0,
        "e2e": end - t0,
        "tps": (out - 1) / (end - first) if out > 1 and end > first else 0,
        "prompt_tokens": usage.prompt_tokens if usage else None,
    }

runs = [timed("broadnet/gemma-4-26b-a4b", [{"role": "user", "content": "Summarise SSE in 100 words."}]) for _ in range(50)]
for k in ("ttft", "ttfct", "e2e", "tps"):
    xs = sorted(r[k] for r in runs)
    print(k, "p50", round(statistics.median(xs), 3), "p95", round(xs[int(len(xs) * 0.95) - 1], 3))

निष्पक्ष बेंचमार्क के पाँच नियम:

  1. प्रॉम्प्ट की लंबाई तय रखें और उसे बताएँ। 500 प्रॉम्प्ट टोकन और 200,000 प्रॉम्प्ट टोकन पर TTFT अलग संख्याएँ हैं। टोकन काउंटर भेजने से पहले बता देता है कि टेस्ट प्रॉम्प्ट कितना लंबा है।
  2. आउटपुट की लंबाई तय रखें, max_tokens और ऐसे प्रॉम्प्ट से जो उसे भर दे, ताकि टोकन प्रति सेकंड की तुलना हो सके।
  3. p50 और p95 बताएँ, औसत नहीं। यूज़र को धीमे सिरे (tail) की लेटेंसी ही याद रहती है।
  4. रन को समय में फैलाएँ। दिन भर में लोड बदलता है।
  5. पहले वॉर्म-अप करें। पहली कॉल DNS, TLS और कनेक्शन सेटअप का समय भी भरती है; एक ही क्लाइंट दोबारा इस्तेमाल करें।

हर संख्या असल में किससे सुधरती है?

सुधारना है यह करें क्यों
TTFT प्रॉम्प्ट प्रीफ़िक्स छोटा करें या कैश करें prefill का समय प्रॉम्प्ट की लंबाई के साथ बढ़ता है; कैश किए गए प्रीफ़िक्स काम बचाते हैं
TTFT कनेक्शन गर्म रखें, पास का रीजन इस्तेमाल करें सेटअप और राउंड ट्रिप हटते हैं
टाइम टू फ़र्स्ट कंटेंट टोकन रीज़निंग effort घटाएँ, या आसान क़दमों के लिए बिना रीज़निंग वाला मॉडल लें जवाब से पहले कम छिपी सोच
टोकन प्रति सेकंड उस क़दम के लिए छोटा या तेज़ मॉडल लें decode स्पीड मॉडल के आकार और सर्विंग पर निर्भर है
एंड-टू-एंड छोटा आउटपुट माँगें (स्कीमा, शब्द सीमा) आउटपुट की लंबाई ITL को कई गुना करती है
कई कॉल का एंड-टू-एंड स्वतंत्र कॉल अपनी कॉन्करेंसी सीमा के अंदर समानांतर चलाएँ हर कॉल वैसी ही रहती है, फिर भी कुल समय घटता है
महसूस होने वाली लेटेंसी यूज़र तक स्ट्रीम करें मॉडल लिखता रहता है और यूज़र पढ़ता रहता है

आउटपुट की लंबाई सबसे कम आँका गया उपाय है। “explain your answer” के बजाय “इन चार फ़ील्ड वाला JSON” माँगने से, बिना किसी इंफ़्रास्ट्रक्चर बदलाव के, जनरेशन का समय दस गुना तक घट सकता है। इसमें स्ट्रक्चर्ड आउटपुट मदद करता है।

कैश वाला उपाय कैशिंग के लिए प्रॉम्प्ट का ढाँचा में समझाया गया है। समानांतर चलाने वाला उपाय जल्दी ही रेट लिमिट से टकराता है; 429 एरर सँभालना देखें।

प्रॉम्प्ट की लंबाई इस संतुलन को कैसे बदलती है?

TTFT प्रॉम्प्ट के साथ बढ़ता है, क्योंकि लिखना शुरू करने से पहले मॉडल को हर इनपुट टोकन प्रोसेस करना होता है। यही बहुत लंबे प्रॉम्प्ट की छिपी लागत है और लंबा कॉन्टेक्स्ट बनाम RAG वाले फ़ैसले का हिस्सा भी: 10 लाख (1M) टोकन का प्रॉम्प्ट ऐसे सवालों के जवाब दे देता है जो RAG नहीं दे सकता, लेकिन वह धीरे शुरू होता है। अगर इंटरैक्टिव स्पीड मायने रखती है, तो मुख्य रास्ता छोटा रखें और बड़ा कॉन्टेक्स्ट तभी भेजें जब सवाल को उसकी ज़रूरत हो।

BroadNet Inference कहाँ फ़िट होता है

BroadNet अपने प्लान मॉडल के लिए लगभग 100 टोकन प्रति सेकंड की सामान्य स्पीड प्रकाशित करता है और मानक SSE फ़ॉर्मैट में स्ट्रीम करता है, इसलिए ऊपर का कोड बिना बदलाव के चलता है। यह TTFT के आँकड़े या लेटेंसी SLA प्रकाशित नहीं करता, इसलिए फ़ैसला करने से पहले अपने प्रॉम्प्ट पर मापें; $1 का एक Meteor घंटा 50 रन के बेंचमार्क के लिए काफ़ी है, और शुरुआती क्रेडिट Gemma 4 VL 26B पर एक बेंचमार्क कवर कर देता है। अगर आपको बड़े पैमाने पर एक सेकंड से कम की गारंटीड लेटेंसी चाहिए, तो सावधानी से टेस्ट करें: उपयोग के अनुसार भुगतान वाली key एक साथ 4 चालू अनुरोध देती है, जो बड़े वॉल्यूम वाली रियल-टाइम सर्विंग से ज़्यादा ऐप और एजेंट के लिए ठीक है। मॉडल और उनकी कीमतें मॉडल और कीमत पेज पर हैं।

अक्सर पूछे जाने वाले सवाल

LLM API के लिए अच्छा टाइम टू फ़र्स्ट टोकन कितना होता है?

चैट के लिए छोटे प्रॉम्प्ट पर लगभग एक सेकंड से कम तेज़ लगता है। लंबे प्रॉम्प्ट और रीज़निंग मॉडल स्वभाव से ज़्यादा समय लेते हैं। TTFT की तुलना सिर्फ़ एक जैसी प्रॉम्प्ट लंबाई और एक ही मॉडल पर करें।

क्या टोकन प्रति सेकंड और थ्रूपुट एक ही चीज़ है?

पूरी तरह नहीं। प्रति यूज़र टोकन प्रति सेकंड बताता है कि एक जवाब कितनी तेज़ी से स्ट्रीम होता है। थ्रूपुट वह कुल टोकन है जो सर्वर सभी यूज़र के लिए मिलाकर बनाता है। प्रोवाइडर कुल थ्रूपुट बढ़ा सकता है, जबकि हर यूज़र की स्पीड घटती है।

रीज़निंग मॉडल पर TTFT इतना ज़्यादा क्यों होता है?

मॉडल दिखने वाले जवाब से पहले छिपे हुए रीज़निंग टोकन बनाता है। पहला टोकन जल्दी आ सकता है, लेकिन पहला कंटेंट टोकन सोचना पूरा होने तक रुका रहता है। आसान कामों के लिए reasoning_effort कम करें।

क्या स्ट्रीमिंग से लेटेंसी घटती है?

एंड-टू-एंड समय कम नहीं होता। लेकिन यूज़र जवाब लिखे जाते समय ही उसे पढ़ने लगता है, इसलिए महसूस होने वाली लेटेंसी लगभग TTFT तक घट जाती है।

भरोसेमंद लेटेंसी बेंचमार्क के लिए कितने अनुरोध चाहिए?

इतने कि आख़िरी सिरे (tail) की लेटेंसी दिख जाए। हर प्रॉम्प्ट आकार पर पचास से सौ अनुरोध काम लायक p95 देते हैं। उन्हें दिन भर में फैलाएँ, क्योंकि लोड बदलता रहता है।

Markdown में पढ़ेंChatGPT से पूछेंClaude से पूछेंPerplexity से पूछें