परिचय: TensorRT-LLM आपके वीकेंड बनाने लायक क्यों है
यदि आपने कभी GPU को 60% उपयोग पर बैठे हुए देखा है, जबकि आपका LLM रेंगता है, तो आप जानते हैं कि टेबल पर मुफ्त प्रदर्शन बचा है। TensorRT-LLM उस हेडरूम को थ्रूपुट में बदल देता है: फ्यूज्ड कर्नेल, पेज्ड अटेंशन, क्वांटाइजेशन और ग्राफ-लेवल ऑप्टिमाइजेशन जो लेटेंसी को कम करते हैं और टोकन-प्रति-सेकंड को बढ़ाते हैं। इस हाउ-टू गाइड में, हम इंस्टॉल से लेकर इंजन निर्माण से लेकर सर्विसिंग तक एंड-टू-एंड जाएंगे—ताकि आप NVIDIA GPU पर तेजी से, सस्ते इन्फ्रेंस को आत्मविश्वास से तैनात कर सकें।
यह ट्यूटोरियल एक व्यावहारिक और समाधान-उन्मुख शैली में लिखा गया है। हम कॉपी करने योग्य कमांड, सामान्य कमियों और FP16 बनाम INT8, बैचिंग और KV कैश रणनीतियों के लिए निर्णय बिंदुओं के साथ एक प्रश्न-आधारित संरचना का उपयोग करेंगे। हम उचित होने पर गहरे गोता लगाने के लिए आधिकारिक संसाधनों का भी संदर्भ लेंगे।
आप क्या सीखेंगे
- TensorRT-LLM के लिए वातावरण कैसे स्थापित करें
- इंजन निर्माण के लिए मॉडल (Hugging Face या चेकपॉइंट से) कैसे तैयार करें
- FP16/INT8 इंजन कैसे बनाएं और प्रदर्शन को कैसे ट्यून करें
- Python/C++ और HTTP सर्विसिंग के माध्यम से इन्फ्रेंस कैसे चलाएं
- बेंचमार्क, बैच और डीबग कैसे करें
यह किसके लिए है
- ML इंजीनियर NVIDIA GPU पर LLM तैनात कर रहे हैं
- उत्पादन में लागत/विलंबता को अनुकूलित करने वाले व्यवसायी
- PyTorch ट्रांसफॉर्मर से अत्यधिक अनुकूलित इन्फ्रेंस में जाने वाले बिल्डर
- TensorRT-LLM क्या है और आपको इसका उपयोग कब करना चाहिए?
TensorRT-LLM एक इन्फ्रेंस स्टैक है जो ट्रांसफॉर्मर मॉडल को अत्यधिक अनुकूलित GPU “इंजन” में संकलित करता है। कच्चे PyTorch या जेनेरिक रनटाइम की तुलना में, आपको आमतौर पर मिलता है:
- बड़े बैच आकार पर उच्च थ्रूपुट
- पेज्ड KV कैश और क्वांटाइजेशन के साथ बेहतर मेमोरी दक्षता
इसका उपयोग तब करें जब आप NVIDIA GPU पर चलाते हैं और उत्पादन-ग्रेड प्रदर्शन की परवाह करते हैं। यह विशेष रूप से डिकोडर-ओनली LLM (जैसे, Llama, Mistral, Phi, BLOOM) और चैटबॉट, RAG और हाई-QPS API सेवाओं जैसे परिदृश्यों के लिए मूल्यवान है।
- पूर्वापेक्षाएँ और वातावरण सेटअप
मुख्य आवश्यकताएँ
- हाल ही की कंप्यूट क्षमता वाला NVIDIA GPU (जैसे, Ampere, Ada, Hopper)
- मिलान करने वाले CUDA और TensorRT संस्करण, साथ ही उपयुक्त ड्राइवर
- Python 3.8+ और यदि स्रोत से संकलित किया जा रहा है तो निर्माण उपकरण
वर्जनिंग नोट: इंस्टॉल करने से पहले संगत CUDA/TensorRT संस्करणों और सुविधाओं के लिए हमेशा आधिकारिक TensorRT समर्थन मैट्रिक्स और रिलीज नोट्स की जाँच करें।
क्विक-स्टार्ट विकल्प
- कंटेनराइज्ड: पूर्व-स्थापित CUDA/TensorRT के साथ NVIDIA के कंटेनरों का उपयोग करें—वर्जन मिसमैच से बचने का सबसे तेज़ तरीका।
- नेटिव इंस्टॉल: बेस TensorRT के लिए आधिकारिक क्विक स्टार्ट का पालन करें, फिर TensorRT-LLM को ऊपर से लेयर करें।
- अपने मॉडल को तैयार करना (Hugging Face → TensorRT-LLM)
सामान्य स्रोत
- Hugging Face: Llama/Mistral/BLOOM वेरिएंट
- स्थानीय चेकपॉइंट: कस्टम फाइन-ट्यून
तैयारी चेकलिस्ट
- पुष्टि करें कि TensorRT-LLM द्वारा मॉडल आर्किटेक्चर समर्थित है।
- मॉडल वेट और टोकेनाइज़र डाउनलोड करें।
- यदि आवश्यक हो, तो सेफटेन्सर को अपेक्षित प्रारूपों में परिवर्तित करें या प्रोजेक्ट की स्क्रिप्ट के माध्यम से ONNX में निर्यात करें।
टिप: आधिकारिक क्विक स्टार्ट में अक्सर मॉडल प्राप्त करने और सही मध्यवर्ती रूप में परिवर्तित करने के लिए स्क्रिप्ट शामिल होती हैं। BLOOM उदाहरण के साथ एक ट्यूटोरियल-शैली के वॉकथ्रू के लिए, Hugging Face LLM को TensorRT-LLM में परिवर्तित करने पर Dell की गाइड देखें।
- TensorRT-LLM इंजन का निर्माण (वर्कफ़्लो का दिल)
अवधारणाएँ जो आपको पता होनी चाहिए
- इंजन: संकलित, हार्डवेयर-अनुकूलित आर्टिफैक्ट जिसे आप इन्फ्रेंस के लिए लोड करते हैं।
- परिशुद्धता: एक मजबूत बेसलाइन के लिए FP16/BF16; यदि सटीकता बनी रहती है तो उच्च थ्रूपुट के लिए INT8 या FP8।
- KV कैश: पेज्ड KV कैश मेमोरी फ़्रेग्मेंटेशन को कम करता है और लंबी-संदर्भ प्रदर्शन को बढ़ाता है।
उच्च-स्तरीय चरण
- बिल्ड कॉन्फ़िगरेशन को परिभाषित करें: अधिकतम बैच, अनुक्रम लंबाई, परिशुद्धता, क्वांटाइजेशन और GPU आर्किटेक्चर।
- अपने मॉडल चेकपॉइंट और टोकेनाइज़र की ओर इशारा करें।
- अपने लक्षित GPU के लिए इंजन संकलित करें।
संदर्भ: आधिकारिक डॉक्स और कॉन्फ़िगरेशन के साथ इंजन का निर्माण। यदि आप Hugging Face टेक्स्ट जनरेशन इन्फ्रेंस (TGI) के माध्यम से सेवा करने की योजना बना रहे हैं, तो प्रति GPU आर्क और कॉन्फ़िगरेशन प्रीकंपाइलिंग इंजन पर TRT-LLM बैकएंड नोट्स देखें।
स्टार्टर निर्णय ट्री
- पहला निर्माण: FP16, मध्यम अधिकतम अनुक्रम लंबाई (जैसे, 4K–8K), मध्यम बैच (जैसे, 4–8)। शुद्धता को मान्य करें।
- स्केलिंग अप: पेज्ड KV कैश सक्षम करें। अधिकतम बैच/बीम आकार बढ़ाएँ। FP8 या INT8 के साथ प्रयोग करें।
- उत्पादन: लेटेंसी/QPS SLO को पूरा करने वाले पिन कॉन्फ़िगरेशन; परिदृश्य के अनुसार अलग-अलग इंजन बनाएँ (शॉर्ट प्रॉम्प्ट बनाम लॉन्ग-कॉन्टेक्स्ट)।
- इन्फ्रेंस चलाना: Python, C++, और HTTP
आपके पास तीन सामान्य रास्ते हैं:
- Python: त्वरित प्रोटोटाइप, पाइपलाइनों और नोटबुक के लिए आदर्श।
- C++: अधिकतम प्रदर्शन, मूल सेवाओं में एकीकरण।
- HTTP सर्विसिंग: स्केलेबल परिनियोजन के लिए TRT-LLM बैकएंड या रनटाइम के सर्विसिंग उदाहरणों के साथ TGI का उपयोग करें।
Hugging Face TGI बैकएंड
- अपने सटीक GPU/परिशुद्धता सेटअप के लिए इंजन प्रीकंपाइल करें।
- TRT-LLM बैकएंड के साथ TGI स्पिन करें और इसे इंजन dir पर इंगित करें।
- /generate या openai-संगत मार्गों के माध्यम से अनुरोध भेजें और प्रतिकृतियों के साथ स्केल करें।
- प्रदर्शन ट्यूनिंग जो वास्तव में सुई को हिलाती है
कहाँ से शुरू करें
- परिशुद्धता: FP16 आपकी विश्वसनीय बेसलाइन है। INT8/FP8 विलंबता को और कम कर सकता है, लेकिन गुणवत्ता को मान्य करें।
- बैचिंग: डायनेमिक बैचिंग और अनुरोध कोलेसिंग नाटकीय रूप से थ्रूपुट बढ़ाते हैं; टेल लेटेंसी को मापें।
- पेज्ड KV कैश: लंबे प्रॉम्प्ट और स्ट्रीमिंग के लिए आवश्यक; मेमोरी प्रेशर को कम करता है।
- अधिकतम लंबाई: बड़ी अधिकतम अनुक्रम लंबाई इंजन आकार बढ़ाती है और घड़ी को कम कर सकती है; फिट-फॉर-पर्पस इंजन बनाएँ।
व्यावहारिक सुझाव
- यथार्थवादी प्रॉम्प्ट के साथ बेंचमार्क: प्रीफिल बनाम डिकोड चरणों को अलग-अलग मापें।
- टोकेनाइज़र थ्रूपुट मायने रखता है: यदि आपका फ्रेमवर्क इसका समर्थन करता है तो इसे GPU पर करें।
- CUDA ग्राफ़/फ्यूज्ड कर्नेल पर नज़र रखें: वे CPU ओवरहेड और कर्नेल लॉन्च विलंबता को कम करते हैं।
- मल्टी-GPU के लिए: अपने मॉडल आकार और विलंबता आवश्यकताओं के अनुसार टेंसर समानांतर या पाइपलाइन समानांतर को प्राथमिकता दें।
- बेंचमार्किंग: जीत साबित करें
चेकलिस्ट
- लक्षित बैच आकार पर टोकन/सेकंड (थ्रूपुट)
- पहले टोकन का समय (TTFT) और प्रति अनुरोध एंड-टू-एंड विलंबता
- पीक QPS के तहत GPU उपयोग और मेमोरी हेडरूम
- सटीकता: यदि आप क्वांटाइज करते हैं तो BLEU/परप्लेक्सिटी या कार्य-विशिष्ट evals
शुद्धता और डेल्टा को मान्य करने के लिए बेसलाइन (PyTorch बनाम TensorRT-LLM) में सुसंगत बीज और प्रॉम्प्ट सेट का उपयोग करें।
- डीबगिंग और सामान्य कमियाँ
- मिसमैच किए गए संस्करण: आधिकारिक समर्थन मैट्रिक्स के अनुसार CUDA, ड्राइवरों और TensorRT संस्करणों को संरेखित करें।
- डिवाइस के लिए अमान्य इंजन: विशेष रूप से अपने GPU आर्किटेक्चर के लिए इंजन को फिर से बनाएँ।
- निर्माण के दौरान OOM: अधिकतम अनुक्रम लंबाई या बैच कम करें; पेज्ड KV सक्षम करें; क्वांटाइजेशन पर विचार करें।
- INT8 के साथ सटीकता में गिरावट: डोमेन-प्रतिनिधि डेटा पर कैलिब्रेट करें; प्रति-टेंसर क्वांटाइजेशन आज़माएं और परत-वार संवेदनशीलता को सत्यापित करें।
- उच्च थ्रूपुट के बावजूद धीमी TTFT: पेज्ड KV कैश को ट्यून करें, CUDA ग्राफ़ को सक्षम करें और टोकेनाइज़र बॉटलनेक की जाँच करें।
- उदाहरण वर्कफ़्लो: Hugging Face मॉडल से उत्पादन तक
परिदृश्य: आप A100 पर कम-विलंबता चैट मॉडल चाहते हैं।
- मॉडल चुनें: 7B–13B Llama/Mistral वेरिएंट।
- तैयार करें: वेट और टोकेनाइज़र डाउनलोड करें; सत्यापित करें कि आर्किटेक्चर समर्थित है।
- पहला इंजन: FP16, अधिकतम इनपुट 4K, अधिकतम आउटपुट 1K, बैच 4; पेज्ड KV चालू।
- मान्य करें: अपने PyTorch बेसलाइन के साथ आउटपुट की तुलना करें।
- अनुकूलित करें: INT8 या FP8 आज़माएं; TTFT और थ्रूपुट को मापें। सर्वर मोड के लिए बैच बढ़ाएँ।
- सर्व करें: TGI TRT-LLM बैकएंड का उपयोग करें; लोड बैलेंसर के पीछे प्रतिकृतियों को स्केल करें; स्ट्रीमिंग जोड़ें।
- GPU प्रति थ्रूपुट: अपने लक्षित संदर्भ पर टोकन/सेकंड मापें। उस QPS क्षमता की गणना करने के लिए उपयोग करें।
- 1M टोकन प्रति मूल्य: तेज़ डिकोडिंग और उच्च बैच उपयोग के साथ, TRT-LLM आमतौर पर टोकन प्रति लागत को कम करता है।
- राइट-साइज़ इंजन: हेडरूम कचरे को कम करने के लिए शॉर्ट-फॉर्म और लॉन्ग-फॉर्म के लिए अलग-अलग इंजन बनाएँ।
- गाइड के अंदर अक्सर पूछे जाने वाले प्रश्न
प्रश्न: क्या मुझे प्रत्येक GPU प्रकार के लिए इंजन को फिर से बनाने की आवश्यकता है?
उत्तर: हाँ। इंजन हार्डवेयर-विशिष्ट हैं। प्रत्येक GPU आर्किटेक्चर के लिए बनाएँ जिस पर आप परिनियोजन करेंगे।
प्रश्न: INT8 गुणवत्ता को कितना प्रभावित करता है?
उत्तर: यह मॉडल और कार्य पर निर्भर करता है। अच्छे कैलिब्रेशन डेटा के साथ, कई मॉडल पर्याप्त गति प्रदान करते हुए लगभग-FP16 गुणवत्ता बनाए रखते हैं।
प्रश्न: क्या मैं लंबे संदर्भ (जैसे, 32K) चला सकता हूँ?
उत्तर: हाँ, लेकिन मेमोरी की सावधानीपूर्वक योजना बनाएँ। पेज्ड KV कैश का उपयोग करें और ब्लॉक आकार को ट्यून करें; ध्यान दें कि लंबे संदर्भ इंजन फ़ुटप्रिंट और डिकोड लागत बढ़ाते हैं।
प्रश्न: क्या TGI आवश्यक है?
उत्तर: नहीं। आप सीधे Python/C++ चला सकते हैं। TGI ऑटोस्केलिंग और लॉगिंग के साथ उत्पादन-ग्रेड HTTP API के लिए सुविधाजनक है।
वर्कफ़्लो त्वरण के लिए ध्यान देने योग्य
यदि आप बार-बार प्रॉम्प्ट पर दोहराते हैं, तो इंजन में आउटपुट की तुलना करते हैं, या प्रयोगों का दस्तावेजीकरण करते हैं, तो एक साइड-बाय-साइड AI सहायक जो त्वरित पुनर्प्रयासों, कोड ब्लॉक निष्पादन और वेब स्निपेट का समर्थन करता है, आपकी लूप को गति दे सकता है। वैसे, Sider.AI इंजीनियरों के लिए ट्यून किया गया एक डेस्कटॉप अनुभव प्रदान करता है—बेंचमार्क कैप्चर करने, प्रॉम्प्ट का परीक्षण करने और अपने TensorRT-LLM पाइपलाइन को अनुकूलित करते समय अपने नोट्स को व्यवस्थित करने के लिए उपयोगी। अगले चरण चेकलिस्ट
- अपने वातावरण को मान्य करने के लिए आधिकारिक त्वरित प्रारंभ पढ़ें।
- समर्थन मैट्रिक्स में CUDA/TensorRT संगतता की पुष्टि करें।
- इंजन-निर्माण गाइड का पालन करें और पहले FP16 चुनें।
- यदि TGI के माध्यम से सेवा कर रहे हैं, तो इंजन प्रीकंपाइल करें और TRT-LLM बैकएंड कॉन्फ़िगर करें।
- वैकल्पिक रूप से, BLOOM जैसे Hugging Face मॉडल के लिए एक ट्यूटोरियल-शैली वॉकथ्रू की समीक्षा करें।
मुख्य बातें
- TensorRT-LLM आपके ट्रांसफॉर्मर को अधिकतम थ्रूपुट और कम विलंबता के लिए GPU-नेटिव इंजन में संकलित करता है।
- FP16 से प्रारंभ करें, पेज्ड KV कैश सक्षम करें और मापें। फिर अधिक गति के लिए INT8/FP8 का अन्वेषण करें।
- इंजन GPU- और कॉन्फ़िग-विशिष्ट हैं; प्रति परिनियोजन लक्ष्य बनाएँ।
- उत्पादन के लिए, इंजन को एक मजबूत सर्विसिंग परत (जैसे, TGI) के साथ जोड़ें और TTFT, थ्रूपुट और गुणवत्ता की निगरानी करें।
अक्सर पूछे जाने वाले प्रश्न
Q1: मैं TensorRT-LLM को सही तरीके से कैसे स्थापित और सेट अप करूं?
मिलान करने वाले CUDA/TensorRT के साथ एक कंटेनर का उपयोग करें या संस्करण विचलन से बचने के लिए आधिकारिक त्वरित प्रारंभ और समर्थन मैट्रिक्स का पालन करें। इंजन संकलित करने से पहले GPU ड्राइवर और निर्माण उपकरण सत्यापित करें।
Q2: Hugging Face मॉडल के साथ TensorRT-LLM का उपयोग कैसे करें?
इंजन बनाने से पहले मॉडल और टोकेनाइज़र डाउनलोड करें, समर्थन की पुष्टि करें और आवश्यकतानुसार कनवर्ट करें। यदि TGI के साथ सेवा कर रहे हैं, तो अपने GPU के लिए इंजन संकलित करें और बैकएंड को इंजन निर्देशिका पर इंगित करें।
Q3: मुझे TensorRT-LLM के लिए FP16, FP8 या INT8 का चयन करना चाहिए?
स्थिरता के लिए FP16 से प्रारंभ करें, फिर थ्रूपुट बढ़ाने के लिए FP8/INT8 आज़माएं। क्वांटाइजेशन के बाद हमेशा कार्य सटीकता को मान्य करें।
Q4: क्या मैं HTTP पर TensorRT-LLM सर्व कर सकता हूँ?
हाँ। आप सीधे Python/C++ का उपयोग कर सकते हैं या स्ट्रीमिंग के साथ स्केलेबल, उत्पादन-तैयार API के लिए Hugging Face TGI के TRT-LLM बैकएंड के माध्यम से सेवा कर सकते हैं।
Q5: TensorRT-LLM का उपयोग करते समय सामान्य प्रदर्शन बाधाएँ क्या हैं?
टोकेनाइज़र ओवरहेड, सबऑप्टिमल बैचिंग और पेज्ड KV कैश की कमी सामान्य मुद्दे हैं। बैच आकार को ट्यून करें, CUDA ग्राफ़ सक्षम करें और समग्र टोकन-प्रति-सेकंड के विरुद्ध TTFT की निगरानी करें।
