Prefill विरुद्ध decode: पहिला token उशिरा का येतो?
Prefill compute-bound असल्याने time to first token ठरवतो, तर decode memory bandwidth-bound असल्याने tokens per second ठरवतो. तुमच्या मशीनवर दोन्ही वेगळे मोजा.
एका परिच्छेदात prefill विरुद्ध decode
Prefill विरुद्ध decode हा self-hosted LLM (large language model) च्या latency विषयीच्या बहुतेक प्रश्नांचे स्पष्टीकरण देणारा मुख्य फरक आहे. Prefill संपूर्ण prompt एका pass मध्ये वाचतो आणि त्याची मर्यादा compute असते. Decode उत्तर एका वेळी एक token लिहितो आणि त्याची मर्यादा memory bandwidth असते. Time to first token हे prefill चे मोजमाप आहे. Tokens per second हे decode चे मोजमाप आहे.
दोन्ही phases एकाच GPU (graphics processing unit) वर, समान weights वापरून आणि समान process मध्ये चालतात. त्यामुळे त्यांना एकाच workload प्रमाणे पाहणे स्वाभाविक आहे. प्रत्यक्षात ते एकच device सामायिक करणाऱ्या दोन वेगवेगळ्या programs प्रमाणे वागतात. त्यांना स्वतंत्रपणे पाहिल्यावर गोंधळात टाकणाऱ्या परिणामांची मोठी यादी समजण्यास सोपी होते.
Prefill compute-bound का असतो?
Prefill मध्ये संपूर्ण prompt प्रत्येक layer मधून एकदा पाठवला जातो. 2,000 token च्या prompt मुळे प्रत्येक matrix multiply साठी 2,000 rows इतके काम निर्माण होते. त्यामुळे GPU लोड केलेल्या weight च्या प्रत्येक byte साठी मोठ्या प्रमाणावर arithmetic करते. हलवलेल्या प्रत्येक byte मागील arithmetic चे हे गुणोत्तर arithmetic intensity म्हणून ओळखले जाते. Prefill मध्ये ते जास्त असते. Device आपल्या compute limit जवळ चालते आणि memory bus वर काही क्षमता मोकळी राहते.
Prefill दोन गोष्टी तयार करते: prompt मधील प्रत्येक token साठी KV cache (key आणि value tensors) आणि पहिला output token. हा pass पूर्ण होईपर्यंत reader पर्यंत काहीही पोहोचत नाही. त्यामुळे idle server वर first token पर्यंतचा बहुतेक वेळ prefill घेतो. याला time to first token (TTFT) म्हणतात. NVIDIA च्या benchmarking guide नुसार TTFT मध्ये request queuing आणि network latency यांचाही समावेश होतो. त्यामुळे busy server वर queue मधील प्रतीक्षा prompt इतकीच महत्त्वाची ठरू शकते.
Prompt ची लांबी वाढल्यावर prefill ची किंमत वाढते. Per layer matrix work हा linear भाग आहे. Attention हा quadratic भाग आहे. त्यात प्रत्येक token त्याच्या आधीच्या प्रत्येक token कडे लक्ष देतो. Context लांब झाल्यावर हा भाग महत्त्वाचा ठरतो. त्यामुळे prompt दुप्पट केल्यास TTFT मधील prefill भाग किमान दुप्पट होतो.
हे तुम्ही एका मिनिटात पाहू शकता. तुमच्या server वर 200 token चा prompt पाठवा. त्यानंतर प्रत्येक वेळी समान संख्येतील output tokens मागून 2,000 token चा prompt पाठवा. TTFT झपाट्याने वाढेल. पहिल्या token नंतरची streaming speed मात्र फारशी बदलणार नाही.
डिकोडची गती memory bandwidth मुळे मर्यादित का होते?
डिकोड प्रत्येक step मध्ये एक token तयार करते. तो एक token तयार करण्यासाठी GPU ने model मधील प्रत्येक weight memory मधून वाचला पाहिजे, प्रत्येक weight काही operations साठी वापरला पाहिजे आणि नंतर तो टाकून दिला पाहिजे. Arithmetic intensity जवळपास 1 असते. त्यामुळे compute units त्यांच्या बहुतांश वेळेत प्रतीक्षा करत असतात.
डिकोड धीमे असते कारण प्रत्येक token साठी संपूर्ण model memory मधून वाचावा लागतो. त्यामुळे memory bus गती ठरवते आणि compute units निष्क्रिय राहतात.
यामुळे single stream decode speed ची कमाल मर्यादा कागदावर करता येणाऱ्या arithmetic वर ठरते. Memory bandwidth ला weights व्यापत असलेल्या bytes ने भागा.
या तक्त्यामागील डेटा
[
{
"device": "CPU, dual channel DDR5-5600",
"mem_bandwidth_gb_s": 90,
"decode_ceiling_tok_s": 6
},
{
"device": "NVIDIA A10G",
"mem_bandwidth_gb_s": 600,
"decode_ceiling_tok_s": 38
},
{
"device": "NVIDIA L40S",
"mem_bandwidth_gb_s": 864,
"decode_ceiling_tok_s": 54
},
{
"device": "NVIDIA RTX 4090",
"mem_bandwidth_gb_s": 1008,
"decode_ceiling_tok_s": 63
},
{
"device": "NVIDIA A100 80GB SXM",
"mem_bandwidth_gb_s": 2039,
"decode_ceiling_tok_s": 127
},
{
"device": "NVIDIA H100 SXM",
"mem_bandwidth_gb_s": 3350,
"decode_ceiling_tok_s": 209
}
]Bandwidth स्तंभात प्रत्येक vendor ने प्रकाशित केलेला specification figure दिला आहे. Ceiling स्तंभात त्या figure ला 16 GB ने भागले आहे. 16 bit precision मध्ये साठवलेल्या 8 billion parameter model चा हा आकार आहे. ही arithmetic गणना आहे; benchmark result नाही. तुमचा मोजलेला rate यापेक्षा कमी असेल. तो किती कमी आहे हे जाणून घेणे उपयुक्त ठरते, कारण serving stack सुधारायचा की hardware बदलायचे हे त्यावरून समजते.
6 rows क्रमाने वाचा. Pattern स्पष्ट दिसतो. Dual channel DDR5 वरील CPU सुमारे 90 GB/s data हलवतो. त्यामुळे त्या model साठी decode ची कमाल गती सुमारे 6 tokens per second राहते. L40S ची गती सुमारे 54 पर्यंत पोहोचते. प्रकाशित bandwidth 3350 GB/s असलेला H100 SXM सुमारे 209 पर्यंत पोहोचतो.
Quantization हे decode speed साठी सर्वात प्रभावी एकल साधन का आहे, हे देखील यावरून स्पष्ट होते. तेच weights 16 ऐवजी 8 bits मध्ये साठवल्यास प्रत्येक token साठी वाचावे लागणारे weight bytes निम्मे होतात. त्यामुळे ceiling साधारणपणे दुप्पट होते. मात्र ceiling म्हणजे प्रत्यक्ष result नाही. KV cache त्याच्या स्वतःच्या आकारानुसार वाचला जातो. तसेच काही 8 bit formats प्रत्येक token साठी अतिरिक्त काम करतात. उदाहरणार्थ, vLLM आपल्या एका FP8 scheme साठी dynamic per token activation quantization चे दस्तऐवजीकरण करते. त्यामुळे मोजलेला gain सामान्यतः 2x पेक्षा कमी राहतो. हा lever याच कारणामुळे कार्य करतो: कमी memory हलवावी लागते, म्हणून ceiling पुढे सरकते.
माझ्या स्वतःच्या सर्व्हरवर प्रत्येक टप्पा कसा मोजू?
Ollama प्रतिसादाच्या body मध्ये ही विभागणी परत करते. Streaming नसलेली completion मागवा आणि counters वाचा.
curl -s http://localhost:11434/api/generate -d '{
"model": "llama3.2",
"prompt": "Explain memory bandwidth in two sentences.",
"stream": false
}' | jq '{prompt_eval_count, prompt_eval_duration, eval_count, eval_duration}'तुम्ही प्रत्यक्ष pull केलेला model tag वापरा. तो tag ollama list दाखवेल. prompt_eval_count आणि prompt_eval_duration हे prefill शी संबंधित आहेत: prompt token count आणि त्यासाठी लागलेला वेळ. eval_count आणि eval_duration हे decode शी संबंधित आहेत. Durations nanoseconds मध्ये असतात. त्यामुळे decode speed eval_count / eval_duration * 1e9 आणि prefill speed prompt_eval_count / prompt_eval_duration * 1e9 असते. Ollama च्या API reference नुसार prompt_eval_duration मध्ये फक्त cache न केलेले prompt tokens येतात. त्यामुळे सर्व्हरने नुकताच पाहिलेला नसलेल्या prompt वरून prefill rate मोजा. त्याच request मध्ये prefill rate ही decode rate पेक्षा खूप जास्त येण्याची अपेक्षा ठेवा. या दोन्ही दरांमधील फरकाचे स्पष्टीकरण पुढील सर्व भागांत दिले आहे.
vLLM सारख्या OpenAI compatible server साठी curl पहिला byte येईपर्यंतचा वेळ मोजू शकते.
curl -N -s -o /dev/null \
-w 'pretransfer %{time_pretransfer}s first_byte %{time_starttransfer}s\n' \
http://localhost:8000/v1/completions \
-H 'Content-Type: application/json' \
-d '{"model": "meta-llama/Llama-3.1-8B-Instruct", "prompt": "Explain memory bandwidth.", "max_tokens": 128, "stream": true}'time_starttransfer म्हणजे body मधील पहिला byte येण्याची वेळ. त्यामुळे "stream": true मध्ये TTFT आणि connection setup दोन्ही समाविष्ट असतात. Setup cost वजा करण्यासाठी time_pretransfer वजा करा. ही कमांड दोनदा चालवा आणि दुसरा result ठेवा, कारण पहिल्या call मध्ये model load होण्यासाठी लागणारा cold-start वेळ समाविष्ट होऊ शकतो.
vLLM ही विभागणी /metrics वर Prometheus metrics म्हणूनही प्रकाशित करते. curl -s http://localhost:8000/metrics | grep -E 'time_to_first_token|inter_token_latency' चालवल्यावर vllm:time_to_first_token_seconds आणि vllm:inter_token_latency_seconds हे histograms मिळतात. Queue depth साठी vllm:num_requests_running आणि vllm:num_requests_waiting जोडा. Cache pressure साठी vllm:kv_cache_usage_perc वापरा. Dashboard साठी हीच पाच नावे पुरेशी आहेत.
Load असताना vllm bench serve --model <name> --num-prompts 200 --request-rate 4 चालू server वर workload पाठवते आणि percentiles सह first token पर्यंतचा वेळ व प्रत्येक output token साठीची latency दाखवते. तुम्ही आधीपासून चालवत असलेल्या stack मध्ये हे दोन्ही टप्पे एकमेकांवर कसा परिणाम करतात हे पाहण्याचा हा सर्वात थेट मार्ग आहे. स्वतंत्र tool वापरायचे असल्यास NVIDIA चे GenAI-Perf आणि LLMPerf हीच मोजमापे करतात. कोणतेही tuning करण्यापूर्वी स्वच्छ baseline घ्या: local LLM वर tokens per second मोजण्याची पद्धत वापरल्यास reboot नंतरही टिकणारा baseline मिळतो.
पहिला token येण्यास विलंब होतो, पण streaming वेगावर परिणाम का होत नाही?
कारण system prompt हे prefill कार्य आहे. त्याशिवाय दुसरे काही होत नाही. पहिला token दिसण्यापूर्वी, prompt च्या उर्वरित भागासोबतच, तो एकदाच process केला जातो. त्यानंतर तो फक्त KV cache entries म्हणून उपलब्ध राहतो आणि decode प्रक्रियेत इतर सर्व entries सोबत त्यांचे वाचन केले जाते. त्यामुळे prefix caching नसल्यास, 3,000 token चा system prompt प्रत्येक request वेळी TTFT वाढवतो; परंतु tokens per second जवळजवळ बदलत नाही.
हा परिणाम पूर्णपणे शून्य नाही. त्या अतिरिक्त KV entries प्रत्येक decode step वेळी पुन्हा वाचल्या जातात. त्यामुळे अतिशय मोठा prompt decode प्रक्रिया थोडी मंद करतो. पुढील section मध्ये याचे स्पष्टीकरण आहे.
यावरील उपाय म्हणजे तोच prefix पुन्हा पुन्हा compute करणे थांबवणे. prefix caching असलेला server shared prefix चा KV cache जतन करतो आणि तो पुन्हा वापरतो. त्यामुळे समान system prompt असलेला दुसरा request prefill मधील तो भाग पूर्णपणे वगळतो. vLLM याला automatic prefix caching म्हणते; तुमच्या version मध्ये vllm serve --help तपासा, कारण releases नुसार default बदलले आहे. GPU मधील हा KV cache API provider कडून bill केल्या जाणाऱ्या prompt cache पेक्षा वेगळा आहे. कोणतेही tuning करण्यापूर्वी KV cache आणि prompt cache मधील फरक वाचणे उपयुक्त ठरेल.
संदर्भ भरत असताना decode धीमे का होते?
याची दोन कारणे आहेत. दोन्ही KV cache शी संबंधित आहेत.
पहिले कारण bandwidth आहे. प्रत्येक decode टप्प्यावर attention मागील प्रत्येक token च्या keys आणि values वाचते. प्रत्येक token साठी weights ची किंमत स्थिर असते. KV cache मात्र वाढत जाते. त्याचा आकार model च्या config.json वरून काढता येतो: प्रत्येक token साठी bytes = 2 गुणिले num_hidden_layers, गुणिले num_key_value_heads, गुणिले head dimension, गुणिले प्रत्येक element साठी bytes. config मध्ये ते दिले असल्यास head_dim वापरा. ते दिलेले नसल्यासच hidden_size भागिले num_attention_heads वापरा, कारण काही models ही दोन मूल्ये स्वतंत्रपणे सेट करतात. उदाहरणार्थ, Mistral NeMo मध्ये width 5,120 आणि 32 heads आहेत; परंतु head dimension 128 आहे, 160 नाही. सुरुवातीचा 2 हा एक key आणि एक value मोजतो.
सामान्य 8 billion parameter layout मध्ये 32 layers, GQA (grouped query attention) अंतर्गत 8 key आणि value heads, head dimension 128 आणि 16 bit precision असल्यास, 2 x 32 x 8 x 128 x 2 = 131,072 bytes, म्हणजे प्रत्येक token साठी सुमारे 128 KiB होतात. त्यामुळे 8,000 token च्या संभाषणासाठी प्रत्येक request ला सुमारे 1 GB KV cache लागतो.
दुसरे कारण capacity आहे. हा 1 GB weights किंवा दुसऱ्या user चा context ठेवण्यासाठी वापरता येत नाही. Server सुरुवातीला एकदाच KV pool चा आकार ठरवतो. vLLM मध्ये हे --gpu-memory-utilization द्वारे केले जाते. Pool पूर्ण भरल्यावर नवीन requests प्रतीक्षा करतात. vllm:num_requests_waiting वाढत जाणे आणि vllm:kv_cache_usage_perc जवळपास 1 वर राहणे हे या स्थितीचे अचूक लक्षण आहे. काही stacks running request ला थांबवून त्याचा cache नंतर पुन्हा मोजतात, queue मध्ये ठेवण्याऐवजी. User ला याचा अनुभव stream च्या मधोमध आलेल्या stall प्रमाणे येतो.
लांब context ची किंमत दोन प्रकारे मोजावी लागते: सुरुवातीला अधिक prefill काम, आणि उत्तराच्या उर्वरित भागात प्रत्येक token साठी अधिक memory read.
बॅचिंगमुळे throughput वाढतो आणि tail latency का वाढते?
Decode हे bandwidth-bound असल्यामुळे compute स्तरावर अतिरिक्त requests ची किंमत अत्यल्प असते. Weights चे एक read batch मधील प्रत्येक sequence साठी एक token तयार करू शकते. त्यामुळे batch size वाढवल्यावर एकूण throughput जवळपास रेषीय पद्धतीने वाढतो. KV pool संपेपर्यंत किंवा batch इतका मोठा होईपर्यंत ही वाढ सुरू राहते की workload पुन्हा compute-bound होतो. Continuous batching प्रत्येक step ला batch पुन्हा तयार करते. त्यामुळे एखादी request पूर्ण झाल्यावर ती बाहेर पडते आणि queued request शेजारच्या requests ची वाट न पाहता batch मध्ये येते.
याची किंमत percentiles मध्ये दिसते. आता प्रत्येक वापरकर्त्याचा पुढील token shared step मधील सर्वांत संथ भाग पूर्ण होईपर्यंत थांबतो. त्यामुळे p50, म्हणजे median, स्वीकारार्ह राहतो; पण p99, म्हणजे 100 पैकी सर्वांत संथ 1 request, अधिक लांबतो. लोकांना p99 जाणवतो, कारण वाक्याच्या मध्यभागी होणारा विराम त्यातून दिसतो.
Prefill मुळे हा परिणाम अधिक तीव्र होतो. Stream सुरू असताना मोठा prompt आल्यास device एका लांब step साठी व्यापला जातो आणि त्या वेळी streaming करणाऱ्या सर्वांना gap दिसतो. Chunked prefill मोठ्या prompt चे तुकडे करून आणि प्रत्येक तुकडा decode batches मध्ये मिसळून ही समस्या मोठ्या प्रमाणात कमी करते. October 2026 पर्यंत vLLM V1 engine हे default ने करते आणि --max-num-batched-tokens द्वारे हा समतोल नियंत्रित करण्याची सुविधा देते. vLLM tuning documentation मध्ये हा tradeoff स्पष्टपणे सांगितला आहे: सुमारे 2048 सारखी लहान values inter token latency (ITL) अधिक चांगली देतात, कारण कमी prefills decode मध्ये अडथळा आणतात. मोठ्या values TTFT अधिक चांगला देतात, कारण एका batch मध्ये अधिक prefill tokens बसतात. हा एकच flag prefill आणि decode यांमधील समतोल एका बदलता येणाऱ्या संख्येद्वारे नियंत्रित करतो. p99 कोणत्या बिंदूवर स्वीकारार्ह राहत नाही हा capacity चा प्रश्न आहे. एक self-hosted LLM किती concurrent users ना सेवा देऊ शकतो हे त्याच metrics च्या आधारे स्पष्ट करता येते.
मोठा GPU कधी कधी काहीही बदल का घडवून आणत नाही?
कारण मोठा GPU म्हणजे बहुतेक वेळा अधिक compute. पण decode साठी compute ची गरज नसते.
वरील chart मधील दोन rows ची तुलना करा. A100 80GB ची published bandwidth 2039 GB/s आहे, तर L40S ची 864 GB/s आहे. Decode ceiling देखील त्याच प्रमाणात आहे: अनुक्रमे 127 tokens per second आणि 54. बहुतेक मोजमापांनुसार RTX 4090 हे अतिशय वेगवान card आहे. त्याची 1008 GB/s bandwidth त्याची ceiling 63 पर्यंत नेते. दोन cards मध्ये इतर कोणतेही फरक असले, तरी single stream decode हे specification sheet वरील bandwidth line शी सुसंगत राहते.
म्हणून decode वेगवान करण्याचे दोन मार्ग आहेत: प्रत्येक token साठी कमी bytes वाचणे (weights quantize करणे किंवा लहान model चालवणे) किंवा अधिक bandwidth खरेदी करणे. Prefill हे याच्या उलट आहे. त्याला compute आवश्यक असते. त्यामुळे वेगवान card मुळे लांब prompts साठी TTFT खरोखर कमी होते. तक्रार अशी असेल की पहिला token येण्यासाठी चार seconds लागतात, तर चांगले hardware समस्या सोडवू शकते. तक्रार अशी असेल की text हळूहळू type होते, तर बहुधा तसे होणार नाही.
प्रिफिल आणि डीकोड वेगवेगळ्या workers वर चालवावे का?
मोठ्या serving stacks मध्ये हेच केले जाते. या तंत्राला prefill and decode disaggregation म्हणतात. Workers चा एक pool केवळ prefill चालवतो. दुसरा pool केवळ decode चालवतो. पहिल्या pool ने तयार केलेला KV cache fast interconnect द्वारे दुसऱ्या pool कडे पाठवला जातो. हे कार्य करते कारण या दोन्ही टप्प्यांना वेगवेगळे hardware आणि वेगवेगळे scheduling आवश्यक असते. Prefill ला compute आणि मोठे token batches आवश्यक असतात. Decode ला bandwidth आणि अनेक concurrent sequences आवश्यक असतात. त्यांना वेगळे केल्यामुळे प्रत्येक pool स्वतंत्रपणे scale करता येतो. तसेच एक मोठा prompt सर्व active streams ला थांबवून ठेवत नाही.
एकाच GPU असलेल्या single VPS (virtual private server) वर हे करणे जवळजवळ कधीही फायदेशीर ठरत नाही. तुम्ही एकाच device चे संसाधन त्याच्याविरुद्ध विभागत असता. तसेच cache मधील gigabytes चे pointer network transfer मध्ये रूपांतरित करता. प्रत्येक phase साठी स्वतंत्र संपूर्ण machines नियुक्त करता येतील इतके accelerators आणि दोन्ही pools व्यस्त ठेवण्यासाठी पुरेसा स्थिर traffic उपलब्ध झाल्यावर हे तंत्र फायदेशीर ठरते. त्यापेक्षा कमी स्तरावर, एका flag मुळे chunked prefill जवळपास तेवढेच isolation देते.
संख्या चुकीची असल्यास काय बदलावे
TTFT खूप जास्त असल्यास:
- prompt लहान करा. Prefill cost हे prompt tokens नुसार वाढते. Prefix caching नसल्यास system prompt ची किंमत प्रत्येक request वर मोजावी लागते.
- Prefix caching सुरू करा. त्यामुळे वारंवार येणारा prefix प्रत्येक वेळी पुन्हा compute करण्याऐवजी एकदाच compute केला जातो.
--max-num-batched-tokensवाढवा, जेणेकरून प्रत्येक step मध्ये अधिक prefill काम पूर्ण होईल.- model ला दोष देण्यापूर्वी queue तपासा.
vllm:num_requests_waitingशून्यापेक्षा जास्त असल्यास request सुरूच झालेली नव्हती. ही capacity ची समस्या आहे.
Tokens per second खूप कमी असल्यास:
- weights quantize करा. प्रत्येक weight साठी कमी bytes लागल्यामुळे प्रत्येक token साठी कमी bytes read करावे लागतात.
- तुमच्या card ची प्रकाशित memory bandwidth वरील chart शी तुलना करा आणि तुम्ही कमाल मर्यादेच्या किती जवळ आहात ते तपासा.
--max-num-batched-tokensकमी करा, जेणेकरून prefill मुळे decode मध्ये कमी वेळा व्यत्यय येईल.- context length तपासा. हजारो tokens पर्यंत वाढलेल्या conversation मध्ये प्रत्येक step वर खूप मोठा KV cache read केला जातो.
येथे runtime देखील महत्त्वाचे आहे, कारण Ollama आणि vLLM prefill आणि decode वेगवेगळ्या पद्धतीने schedule करतात, आणि एका runtime ला उपयुक्त ठरणारी setting दुसऱ्यावर काहीही परिणाम करू शकत नाही. प्रथम दोन्ही phases मध्ये measurement घ्या. त्यानंतर एका वेळी एकच गोष्ट बदला.
FAQ
माझ्या पहिल्या token ला काही सेकंद लागतात, पण त्यानंतरचे token जलद का stream होतात?
ही प्रतीक्षा prefill आहे आणि streaming म्हणजे decode आहे. कोणताही output उपलब्ध होण्यापूर्वी prefill संपूर्ण prompt वर एकाच compute-bound pass मध्ये प्रक्रिया करते. त्यामुळे त्याचा खर्च prompt च्या लांबीसोबत वाढतो. त्यानंतर decode प्रत्येक step मध्ये एक token तयार करते. हा वेग memory bandwidth ठरवते आणि prompt किती लांब आहे यावर तो जवळजवळ अवलंबून नसतो. प्रत्येक request सोबत मोठा system prompt पाठवणे हे याचे नेहमीचे कारण आहे. Prefix caching मुळे या खर्चाचा पुन्हा होणारा भाग टाळता येतो.
मोठा prompt असल्यास tokens per second चा वेग कमी होतो का?
थोडा कमी होतो, पण TTFT पेक्षा वेगळ्या कारणामुळे. प्रत्येक decode step मध्ये त्यापूर्वीच्या सर्व tokens चे keys आणि values वाचावे लागतात. त्यामुळे मोठ्या KV cache मुळे प्रत्येक token साठी अधिक bytes वाचावे लागतात. सामान्य 8 billion parameter layout मध्ये cache साधारण 128 KiB प्रति token असतो. त्यामुळे 8,000 token च्या context मध्ये प्रत्येक step वेळी साधारण 1 GB डेटा वाचला जातो. मोठ्या prompt चा मुख्य परिणाम अजूनही TTFT वर होतो; streaming speed वर नाही.
Decode speed चा अंदाज कोणती GPU specification देते?
Memory bandwidth. प्रकाशित bandwidth ला memory मधील weights च्या आकाराने भागल्यास एका stream साठीची arithmetic ceiling मिळते. अधिक compute पण समान bandwidth असलेले card अधिक जलद stream करणार नाही. म्हणूनच weights 8 bits मध्ये quantize केल्यास decode ceiling साधारण दुप्पट होते: प्रत्येक token साठी वाचावे लागणारे weight bytes अर्धे होतात. प्रत्यक्ष मोजलेली वाढ सहसा यापेक्षा कमी असते. कारण KV cache त्याच्या मूळ आकारातच वाचला जातो आणि काही 8 bit formats मध्ये activations quantize करण्यासारचे प्रत्येक token साठीचे अतिरिक्त काम असते.
वापरकर्ते वाढवल्यावर throughput वाढतो, पण प्रत्येक वापरकर्त्याला सेवा धीमी का वाटते?
Weights एकदा वाचल्यावर batch मधील प्रत्येक sequence साठी एक token तयार करता येतो. त्यामुळे batch size वाढल्यावर एकूण tokens per second वाढतात. परंतु प्रत्येक token ला आता shared step ची प्रतीक्षा करावी लागते. त्यामुळे त्याच वेळी प्रत्येक वापरकर्त्याची latency वाढते. Aggregate throughput number ऐवजी p99 inter token latency वर लक्ष ठेवा. तसेच requests queue होत आहेत की प्रत्यक्ष चालत आहेत हे पाहण्यासाठी vllm:num_requests_waiting तपासा.