LLM इन्फेरेंस का बड़े पैमाने पर गहन विश्लेषण — हर्षुल जैन (ऑडिबल) और तन्मय साह (स्वतंत्र AI शोधकर्ता)
AAI Engineer
컴퓨터/소프트웨어경제 뉴스AI/미래기술
스크립트
00:00:00तो सभी को नमस्कार। मेरा नाम हर्षल जैन है और यह तन्मय हैं। और हम
00:00:21LLM इन्फेरेंस पर इस दो घंटे की वर्कशॉप में आप सभी का स्वागत करना चाहते हैं।
00:00:26तो इस वर्कशॉप का उद्देश्य इस डोमेन को पहले सिद्धांतों से समझना है,
00:00:33इसमें गहराई से उतरना है और यह समझना है कि पूरे उद्योग में क्या चल रहा है।
00:00:39हमारे बारे में थोड़ी सी पृष्ठभूमि। तो मैं ऑडिबल में एक सीनियर सॉफ्टवेयर इंजीनियर हूँ।
00:00:47मैं पिछले पाँच वर्षों से ML/AI डेटा प्लेटफ़ॉर्म बना रहा हूँ और इसके साथ ही
00:00:53मैं LLM इन्फेरेंस पर यह ओपन सोर्स हैंडबुक लिख रहा हूँ। और
00:00:59तन्मय, वह शीआन बैंक कॉर्पोरेशन में सीनियर क्वांटिटेटिव मॉडलर हैं। उन्होंने
00:01:06हाल ही में अपनी पीएचडी पूरी की है और वह एजेंट वेरीफायर्स और
00:01:12वर्ल्ड मॉडल में सक्रिय रूप से शोध कर रहे हैं। तो यहाँ एक बार हाथ उठाकर बताएँ। LLM इन्फेरेंस के लिए कौन बिल्कुल नया है?
00:01:24ठीक है, बढ़िया। और किन लोगों ने इन मॉडलों को प्रोडक्शन में डिप्लॉय किया है? उन्होंने
00:01:33इसे ट्यून किया है, वे प्रोडक्शन ट्रैफ़िक को सर्व कर रहे हैं। ठीक है, बहुत बढ़िया। तो यह
00:01:42वर्कशॉप शुरुआती और मध्यम स्तर के लोगों के लिए लक्षित है। और सभी
00:01:48स्लाइड्स और अभ्यास रिपॉजिटरी में हैं, मैं उसे जल्द ही साझा करूँगा। यहाँ वर्कशॉप का
00:01:56त्वरित एजेंडा है। हम समस्या विवरण से शुरुआत करेंगे। हम
00:02:01LLM इन्फेरेंस के आसपास की कुछ मुख्य समस्याओं को समझने की कोशिश करेंगे। फिर हम समझें कि उन
00:02:08समस्याओं का कारण क्या है और वहाँ से अपनी नींव बनाएँ। इसके बाद हम दो तरह के
00:02:14ऑप्टिमाइज़ेशन में गोता लगाएँगे जो हम करते हैं, जैसे मॉडल ऑप्टिमाइज़ेशन और सर्विंग
00:02:19ऑप्टिमाइज़ेशन। और फिर हम विभिन्न सर्विंग इंजनों के बारे में सीखना शुरू करेंगे जो
00:02:25प्रोडक्शन में हमारे LLM इन्फेरेंस समाधानों को डिप्लॉय करने के लिए उपलब्ध हैं। और हम कुछ बेंचमार्क
00:02:32बेंचमार्क और इस बात पर निर्णय चार्ट दिखाएंगे कि किस इंजन का उपयोग करना है।
00:02:39बढ़िया। तो समस्याओं को समझने के लिए, पहले हमें यह जानना होगा कि LLM इन्फेरेंस क्या है। तो
00:02:47शायद हम में से बहुत से लोग पहले से ही यह जानते हैं। लेकिन हाँ, आप अपनी AI से जो भी करने को कहते हैं,
00:02:55चाहे वह वीडियो, ऑडियो जनरेट करना हो, किसी भी टेक्स्ट का विश्लेषण करना हो, अपनी मेडिकल रिपोर्ट का विश्लेषण करना हो या फिर अपने
00:03:02टैक्स बिलों का विश्लेषण करना हो, वह सब LLM इन्फेरेंस जैसा है। और आज यह बाज़ार लगभग 23 बिलियन डॉलर का है।
00:03:12सेमी-एनालिसिस ने हाल ही में साझा किया कि यदि आप LLM के साथ Google खोज क्वेरी जैसी किसी चीज़ का मॉडल बनाना चाहते हैं, तो आपको लगभग 36 बिलियन डॉलर के मुनाफे की खप की आवश्यकता है।
00:03:25और अपने खोज व्यवसाय को लाभदायक बनाए रखने के लिए क्वेरी की लागत 0.5 सेंट से कम होनी चाहिए।
00:03:33दूसरी ओर, बिजनेस इनसाइडर ने उल्लेख किया कि आपके AI को सही रास्ते पर लाया जाना चाहिए और हर किसी को अपने टोकन उपयोग का ऑडिट और बजट बनाना शुरू करना होगा।
00:03:43और यह सब हो रहा है। क्यों? क्योंकि आपका हार्डवेयर सीमित है, कंप्यूट महंगा है, आपका इन्फेरेंस महंगा है।
00:03:50और AI के अधिक से अधिक उपयोग की बढ़ती आवश्यकता के साथ, यह इन्फेरेंस लागत लगातार बढ़ती जा रही है।
00:04:03तो यह आँकड़ा, यह OpenAI का एक पुराना आँकड़ा है, लेकिन यह अभी भी सच है।
00:04:11तो यदि आप GPT-3 की प्रशिक्षण लागत को देखें, तो यह लगभग 4.6 मिलियन डॉलर थी। यह एक बार की लागत थी।
00:04:19लेकिन यदि आप इन्फेरेंस लागत को देखें जो कि रही है, तो यह एक आवर्ती लागत है क्योंकि यह एक परिचालन लागत है जो आने वाले प्रत्येक उपयोगकर्ता, आने वाले प्रत्येक टोकन और AI पर शुरू किए जाने वाले प्रत्येक सत्र के साथ बढ़ती है।
00:04:36और मूल रूप से इसका मुकाबला करने के केवल दो ही तरीके हैं, एक तरीका यह है कि आप अपने टोकन का उपयोग कम करें।
00:04:47दूसरा विकल्प यह है कि आपको अपने ग्राहकों और अपने लिए एक इन्फ्रेंस सेवा प्रदाता के रूप में अपने इन्फ्रेंस समाधानों को अनुकूलित करने का प्रयास करना चाहिए।
00:04:58और इसलिए, हम हर दूसरे दिन बहुत सारे नए समाधान सामने आते देख रहे हैं।
00:05:06और इसलिए विचार यह होगा कि, ठीक है, हम उन नींवों का निर्माण करने का प्रयास करेंगे जो हमें इसके बाद आने वाली किसी भी चीज़ को समझने और उसका मूल्यांकन करने में मदद करेंगी।
00:05:18तो, हाँ, शुरुआत करने के लिए, हम एक त्वरित डेमो करेंगे, यह इन्फेरेंस के आसपास की विभिन्न समस्याओं का एक छोटा सा डेमो है।
00:05:28और इसलिए यह एक रिपॉजिटरी है।
00:05:31मेरा मतलब है, आप इसे क्लोन कर सकते हैं या गिटहब पर भी खोल सकते हैं।
00:05:36इसे LLM इन्फेरेंस एट स्केल कहा जाता है।
00:05:39यहाँ थोड़ी पृष्ठभूमि, जैसे चार महीने पहले जब मैं LLM इन्फेरेंस के बारे में कुछ नहीं जानता था, तो मैंने इसे सीखना शुरू किया।
00:05:46मैंने देखा कि बहुत सारे संसाधन बिखरे हुए थे।
00:05:49इसलिए हमने इसे एक ही स्थान पर रखना शुरू किया ताकि इससे लोगों को लाभ हो सके।
00:05:55हाँ, तो मुझे वास्तव में इस स्लाइड शो मोड से बाहर निकलने दें और शायद इस विस्तारित मोड में जाने दें।
00:06:11हाँ, तो इस रिपॉजिटरी में, यदि आप एक रीडमी फ़ाइल देखते हैं, तो स्लाइड का एक लिंक है।
00:06:27तो यह, यह इस फ़ोल्डर की तरह होगा जहाँ आपके पास एक PPTX है और उसमें एक बेंचमार्क रिपोर्ट है।
00:06:34आप इसे हमेशा डाउनलोड कर सकते हैं और फिर डेमो उद्देश्यों के लिए, हमारे पास कुछ जुपिटर नोटबुक हैं।
00:06:43हमने मोलाब के साथ सहयोग किया है जो Google कोलाब का विकल्प हैं और वे मूल रूप से आपको क्या प्रदान करते हैं वह एक मुफ्त RTX 6000 GPU है।
00:06:54तो यह 100 जीबी रैम वाला जीपीयू है और हमने इन नोटबुक्स को पहले ही सेट अप कर लिया है ताकि इसके साथ प्रयोग करना आसान हो जाए और सभी संपत्तियां और सब कुछ आपके लिए प्रीसेट हैं।
00:07:09तो हम एक साधारण डेमो A से शुरुआत करेंगे।
00:07:16शायद, शायद, मुझे बस देखने दीजिए।
00:07:31हाँ, तो जब इन्फेरेंस की बात आती है, तो आपको किसी निश्चित मॉडल पर इन्फेरेंस करना होता है, है ना?
00:07:40तो, वर्कशॉप के उद्देश्यों के लिए, हम एक साधारण Mistral 7B मॉडल का उपयोग कर रहे हैं।
00:07:45यह लगभग 15 GB आकार का एक छोटा मॉडल है।
00:07:49तो हम इसे GPU में लोड करने जा रहे हैं।
00:07:53तो, और हम कुछ GPU आँकड़ों को भी देखेंगे।
00:07:58तो हम देखते हैं जैसे, ठीक है, हम 6000 ब्लैकवेल पर काम कर रहे हैं।
00:08:01तो, और आप सोच रहे होंगे कि मैं सेल नहीं चला रहा हूँ क्योंकि मुझे सम्मेलनों में वाई-फाई पर भरोसा नहीं है।
00:08:08तो, हाँ, तो मैं शायद केवल उन परिणामों पर जाऊँगा जो हमने पहले चलाए थे।
00:08:18हाँ, तो हमारे पास एक GPU है जो 102 GB का है।
00:08:22अब, सबसे पहले जो मेरे दिमाग में आता है वह यह है कि जब मैं LLM इन्फेरेंस करता हूँ तो मेरी मेमोरी की खपत कैसी दिखती है।
00:08:31इसलिए मैं इस मॉडल को लोड करता हूँ और देखता हूँ जैसे, ठीक है, यहाँ मेरे पास 15 GB है।
00:08:37तो मेरे पास लगभग 87.5 GB है।
00:08:40और अब जब मैं यहाँ इन्फेरेंस करता हूँ, तो मैं जो देखता हूँ वह यह है कि जितने अधिक इनपुट मैं पास करता हूँ, उतनी ही अधिक मेमोरी मुझे चाहिए।
00:08:52और यह धीरे-धीरे बढ़ रहा है, लेकिन यह अभी भी बढ़ रहा है।
00:08:56तो कल्पना कीजिए कि यदि आपके पास लगभग 4,000 या 16,000 या 32,000 टोकन की संदर्भ लंबाई है।
00:09:03तो यह मेमोरी वास्तव में बड़ी हो सकती है और आपको वास्तव में वे सभी आउट-ऑफ़-मेमोरी समस्याएँ मिल सकती हैं।
00:09:12तो निश्चित रूप से यह आपकी पहली समस्या है, जैसे टोकन में वृद्धि के साथ आपकी मेमोरी बढ़ जाती है।
00:09:18तो एक साधारण विज़ुअलाइज़ेशन के रूप में, यह ऐसा दिखता है।
00:09:24दूसरी समस्या जो आप देखेंगे वह यह है कि आपके पहले टोकन का समय बहुत, बहुत धीमा है।
00:09:32हम इसे TTFT नामक एक मीट्रिक द्वारा मापते हैं।
00:09:35यह इसका संक्षिप्त रूप है।
00:09:37और जब आप इनपुट आकार के साथ TTFT को मापने का प्रयास करते हैं, तो आप देखेंगे कि संदर्भ जितना लंबा होगा, आप देखेंगे कि यह TTFT धीमा होगा।
00:09:52तो अब दो समस्याएँ हैं।
00:09:54आपकी मेमोरी टोकन आकार के साथ बढ़ती है।
00:09:56आपका TTFT टोकन आकार के साथ बढ़ता है।
00:09:59क्षमा करें, टोकन आकार नहीं, संदर्भ आकार।
00:10:07और फिर तीसरा थ्रूपुट है।
00:10:09थ्रूपुट यह है कि आप प्रति सेकंड कितने टोकन सर्व कर सकते हैं?
00:10:13और फिर आप प्रति सेकंड कितने उपयोगकर्ताओं को सेवा दे सकते हैं?
00:10:16तो यदि आप अपने स्थानीय सिस्टम पर बहुत, बहुत सामान्य कार्यान्वयन करते हैं, तो यह बहुत क्रमिक होगा।
00:10:24इसलिए यदि आप पाँच अनुरोध भेजते हैं, तो समांतर के बजाय उन सभी पाँच अनुरोधों को क्रमिक रूप से पूरा किया जाएगा।
00:10:31और इसलिए यदि आपके पास कई उपयोगकर्ता हैं तो आपके अनुरोध को पूरा होने में मूल रूप से अधिक समय लगता है।
00:10:40तो ये तीन समस्याएँ हैं।
00:10:43चौथी भी है।
00:10:44मैंने यहाँ इसका वर्णन नहीं किया है।
00:10:45शायद जैसे-जैसे हम आगे बढ़ेंगे हम उस अंतर्ज्ञान का निर्माण करेंगे।
00:10:48लेकिन आइए याद रखें कि ये तीन समस्याएँ हैं, मेमोरी, TTFT और थ्रूपुट।
00:10:55बढ़िया।
00:10:56मैं वापस स्लाइड्स पर जाऊँगा।
00:11:02ठीक है।
00:11:03उत्तम।
00:11:04तो यह होना चाहिए।
00:11:17क्या यह दिखाई दे रहा है?
00:11:18हाँ।
00:11:19यह दिखाई दे रहा है।
00:11:20यह दिखाई दे रहा है।
00:11:21हाँ।
00:11:22यह दिखाई दे रहा है।
00:11:23यह दिखाई दे रहा है।
00:11:24यह दिखाई दे रहा है।
00:11:25हाँ।
00:11:26यह दिखाई दे रहा है।
00:11:27यह दिखाई दे रहा है।
00:11:28हाँ।
00:11:29यह दिखाई दे रहा है।
00:11:30हाँ।
00:11:31यह दिखाई दे रहा है।
00:11:32हाँ।
00:11:33यह दिखाई दे रहा है।
00:11:34हाँ।
00:11:35यह दिखाई दे रहा है।
00:11:36यह दिखाई दे रहा है।
00:11:37हाँ।
00:11:38यह दिखाई दे रहा है।
00:11:39हाँ।
00:11:40यह दिखाई दे रहा है।
00:11:41हाँ।
00:11:42यह दिखाई दे रहा है।
00:11:43हाँ।
00:11:44यह दिखाई दे रहा है।
00:11:45हाँ।
00:11:46हाँ।
00:11:47तो उस रिपॉजिटरी के भीतर, यदि आप एक वर्कशॉप फ़ोल्डर देखते हैं, तो आप वह रीडमी देखते हैं और फिर रीडमी
00:11:55में सभी लिंक, स्लाइड और डेमो हैं।
00:12:01क्या वह काम करता है?
00:12:06ठीक है।
00:12:07उत्तम।
00:12:09ठीक है।
00:12:10उत्तम।
00:12:16ठीक है।
00:12:17तो आइए बुनियादी बातों पर काम करना शुरू करें।
00:12:19आइए यह समझना शुरू करें कि उन समस्याओं के पीछे क्या कारण हैं।
00:12:25और इसके लिए, जैसे हमें इस इन्फेरेंस पाइपलाइन को देखना होगा।
00:12:32तो हमें एक इनपुट टेक्स्ट मिलता है।
00:12:35उस टेक्स्ट में कितने भी शब्द हो सकते हैं।
00:12:38आप उन्हें टोकन में बदलते हैं।
00:12:41तो सरलता के लिए, आप मान सकते हैं कि एक शब्द एक टोकन के बराबर है।
00:12:46फिर आप उन्हें एम्बेडिंग में बदलते हैं और फिर उन्हें ट्रांसफॉर्मर के पास भेजते हैं।
00:12:53जैसे ट्रांसफॉर्मर की 32 परतें होती हैं, लेकिन यह Mistral 7 के लिए विशिष्ट है।
00:12:58अलग-अलग मॉडलों में अलग-अलग प्रकार की परतें होती हैं।
00:13:01और फिर आप एक नया टोकन जनरेट करते हैं।
00:13:04और वह टोकन मूल रूप से इनपुट पर वापस जाता है।
00:13:06फिर आप दूसरा टोकन जनरेट करते हैं और यह प्रक्रिया चलती रहती है।
00:13:09अब इस पूरी पाइपलाइन में, आप देखेंगे कि आपके कंप्यूट का लगभग 95% हिस्सा इन ट्रांसफॉर्मर परतों द्वारा लिया जाता है।
00:13:18इसलिए यह देखना जरूरी है कि इस ट्रांसफॉर्मर परत के भीतर क्या होता है।
00:13:24इस ट्रांसफॉर्मर परत के भीतर, आपके पास और भी परतें होंगी।
00:13:28आपके पास एक नॉर्मलाइजेशन लेयर होती है।
00:13:30आपके पास एक अटेंशन लेयर होती है।
00:13:32आपके पास एक फीड फॉरवर्ड लेयर और सब कुछ होता है।
00:13:35और मुझे लगता है कि अटेंशन लेयर बहुत, बहुत प्रसिद्ध हो गई है।
00:13:40अटेंशन इज़ ऑल यू नीड, लोग।
00:13:42मुझे लगता है कि यह बहुत अच्छी तरह से जाना जाता है।
00:13:44तो अटेंशन सबसे अधिक कंप्यूट-इंटेंसिव लेयर है।
00:13:48और हमें यह समझने की जरूरत है कि उस अटेंशन लेयर के भीतर क्या होता है।
00:13:53तो अटेंशन क्या करता है?
00:13:56तो यदि आपके पास इनपुट टेक्स्ट है, तो इसे पिछले सभी टोकन के संबंध में प्रत्येक टोकन के अटेंशन स्कोर खोजने की आवश्यकता है।
00:14:05और ऐसा करने के लिए, इसे क्या करने की आवश्यकता है जैसे इसे प्रत्येक टोकन को की, क्वेरी और वैल्यू स्पेस में प्रोजेक्ट करने की आवश्यकता है।
00:14:14तो सरल शब्दों में, बस इसे समझें।
00:14:20जैसे यदि आपके पास 10 टोकन हैं, तो इसे 10 अलग-अलग क्वेरी, की और वैल्यू वेक्टर की आवश्यकता है।
00:14:26यदि 100 टोकन हैं, तो आपको 100 की और वैल्यू वेक्टर की आवश्यकता होगी।
00:14:31यदि 1000 टोकन हैं, तो आपको 1000 की वैल्यू वेक्टर की आवश्यकता होगी।
00:14:35और इसलिए जैसे-जैसे आप इनपुट का आकार बढ़ाते हैं, आपके की और वैल्यू वेक्टर की संख्या बढ़ती जाती है।
00:14:45और यदि आप प्रति टोकन KV आकार की गणना करते हैं, तो mistral 7b के लिए, यह 131 KV निकलता है।
00:14:54ऐसा इसलिए है क्योंकि आपके पास दो वेक्टर हैं, K और V।
00:14:59आपको आकार को गुणा करना होगा।
00:15:02एक वेक्टर 128 आयामों का है।
00:15:04आपको इसे 32 ट्रांसफॉर्मर परतों से गुणा करना होगा।
00:15:08और फिर आपको इसे KV हेड से गुणा करना होगा।
00:15:11mistral 7b के लिए, यह KV हेड हैं।
00:15:15यह 32 की तरह नहीं है क्योंकि यह एक अलग प्रकार के अटेंशन तंत्र का उपयोग करता है, जिसके बारे में हम निश्चित रूप से बात करेंगे।
00:15:23लेकिन हाँ, प्रति टोकन KV का आकार आपके 131 KV जैसा है।
00:15:30अब कल्पना कीजिए कि यदि आपके पास 4K контекст है, तो वह आकार आधा GB हो जाता है।
00:15:37यदि आप 16K контекст करते हैं, तो वह आकार 2.1 GB हो जाता है।
00:15:42अब इसे उपयोगकर्ताओं से गुणा करें।
00:15:45मान लीजिए कि आप एक साथ कई उपयोगकर्ताओं को सेवा दे सकते हैं।
00:15:49उसी समय उस GPU के भीतर, 4K контекст और 80 उपयोगकर्ताओं के साथ आपके पास 42 GB हो सकता है।
00:15:58और यदि आपका GPU केवल, मान लीजिए 24 GB है, तो आपकी मेमोरी पहले से ही खत्म हो रही है।
00:16:04इसलिए आप इतने सारे kontekst वाले इतने सारे उपयोगकर्ताओं को सेवा नहीं दे सकते।
00:16:11इसे देखने के लिए, GPU मेमोरी को देखें।
00:16:14तो GPU मेमोरी में मॉडल वेट्स होते हैं, जो काफी निश्चित होते हैं।
00:16:19ये प्री-ट्रेन वेट्स हैं।
00:16:21एक ओवरहेड भी है जो निश्चित है।
00:16:24वह भी, वह बदलता है, लेकिन यह इतना नहीं बदलता है।
00:16:29कुल मिलाकर, आप मान सकते हैं कि यह निश्चित है।
00:16:32और फिर बची हुई मेमोरी होती है।
00:16:35तो इस बची हुई मेमोरी का उपयोग आपकी KV मेमोरी, जैसे की और वैल्यू वेक्टर द्वारा किया जा रहा है।
00:16:41तो, मान लीजिए आपके पास एक उपयोगकर्ता है।
00:16:46आप केवल उतने ही की और वैल्यू वेक्टर या उतने ही टोकन की सेवा दे सकते हैं, जो इस पूरी 80GB मेमोरी में फिट हो सकते हैं जो बची है।
00:17:00तो हम इसे एक साधारण डेमो के साथ भी दिखा सकते हैं।
00:17:07ठीक है, बढ़िया।
00:17:08ठीक है, बढ़िया।
00:17:08मुझे देखने दीजिए कि क्या मैं वास्तव में इसे चला सकता हूँ।
00:17:14ठीक है, बढ़िया।
00:17:15मुझे देखने दीजिए कि क्या मैं वास्तव में इसे चला सकता हूँ।
00:17:15यह कहाँ है?
00:17:15ठीक है, बढ़िया।
00:17:16मुझे देखने दीजिए कि क्या मैं वास्तव में इसे चला सकता हूँ।
00:17:21यह कहाँ है?
00:17:22ठीक है, बढ़िया।
00:17:23ठीक है, बढ़िया।
00:17:24हाँ।
00:17:25हाँ।
00:17:25तो, आप देखेंगे कि मुझे देखने दीजिए कि क्या मैं वास्तव में इसे चला सकता हूँ।
00:17:31मुझे देखने दीजिए कि क्या मैं वास्तव में इसे चला सकता हूँ।
00:17:33मुझे देखने दीजिए कि क्या मैं इसे चला सकता हूँ।
00:17:34मुझे देखने दीजिए कि क्या मैं इसे चला सकता हूँ।
00:17:35मुझे देखने दीजिए कि क्या मैं इसे चला सकता हूँ।
00:17:36मुझे देखने दीजिए कि क्या मैं इसे चला सकता हूँ।
00:17:37ठीक है, बढ़िया।
00:17:38हाँ।
00:17:39तो, आप देखेंगे कि GPU जुड़ा हुआ है।
00:17:43ठीक है, बढ़िया।
00:17:44हाँ।
00:17:45तो, आप देखेंगे कि GPU जुड़ा हुआ है।
00:17:56तो, यहाँ हम गणित के आधार पर और हमारे द्वारा बनाई गई अंतर्ज्ञान के आधार पर मेमोरी की पुष्टि करने का प्रयास कर रहे हैं।
00:18:13जो हमने बनाई है।
00:18:14तो, मॉडल मेमोरी जैसे मान लीजिए यदि आपके पास 7 बिलियन पैरामीटर हैं, तो आप कर रहे हैं
00:18:1916-बिट परिशुद्धता।
00:18:20आपकी कुल मेमोरी 14.6 GB निकलती है।
00:18:23आप गणित के साथ मूल रूप से इसकी पुष्टि कर सकते हैं।
00:18:27तो, यदि आप वह सारा गणित करते हैं, तो वह 14.6 GB निकलता है।
00:18:33अब KV और KV आकार आता है।
00:18:37तो, यह KV आकार प्रति टोकन आपके 131 KV जैसा है।
00:18:42और यदि आप वह गणित करते हैं और इसे देखने का प्रयास करते हैं।
00:18:47ओह, बिल्कुल।
00:18:52रुकिए।
00:18:53ठीक है।
00:18:54और फिर आइए बस इसकी कल्पना करें।
00:19:07ठीक है, बढ़िया।
00:19:10बढ़िया।
00:19:11हाँ।
00:19:12तो, यह मेमोरी चार्ट है।
00:19:15तो, यदि आप देखते हैं कि जैसे-जैसे आपका kontekst बढ़ता है, आपकी मेमोरी बढ़ती जाती है।
00:19:21फिर ध्यान देने वाली एक और बात यह है कि जैसे-जैसे आपके उपयोगकर्ता बढ़ते हैं, आपकी मेमोरी भी बढ़ती जाती है।
00:19:28तो, यदि आप एक GPU पर 160 उपयोगकर्ताओं को सेवा देना चाहते हैं, तो आप समर्थन कर सकते हैं, आप केवल समर्थन कर सकते हैं
00:19:37एक कम kontekst लंबाई।
00:19:40तो, इस बात के बीच हमेशा एक ट्रेड-ऑफ होता है कि आप किस kontekst लंबाई की सेवा दे सकते हैं बनाम कितनी लागत
00:19:47आप अपने कई उपयोगकर्ताओं या समवर्ती उपयोगकर्ताओं को एक ही GPU में रखकर बचा सकते हैं।
00:19:54इसलिए आपको हमेशा वह ट्रेड-ऑफ अपनाना होगा।
00:19:57और हम कुछ और स्लाइडों में उस पर चर्चा करेंगे।
00:20:06क्या आप कृपया दोहरा सकते हैं?
00:20:10मुझे खेद है।
00:20:11मैं आपको सुन नहीं पा रहा हूँ।
00:20:12क्या आपको अलग-अलग kontekst लंबाई के साथ एक अलग पूल दिखाई देता है ताकि आप हल्की मेमोरी की सेवा दे सकें
00:20:25सही का?
00:20:26हाँ।
00:20:27बढ़िया।
00:20:28बढ़िया।
00:20:29ठीक है।
00:20:30अच्छा।
00:20:31तो, मुझे वापस आने दीजिए।
00:20:32तो, वह हल्की मेमोरी थी।
00:20:33हमें यह समझने की जरूरत है कि जब हमने kontekst लंबाई बढ़ाई तो पहले टोकन के लिए धीमा समय क्यों था।
00:20:53लंबाई।
00:20:54तो इसके लिए हमें अनुमान के दो चरणों को समझने की जरूरत है।
00:20:58और वे चरण प्री-फिल और डिकोड चरण हैं।
00:21:01मुझे लगता है कि आप सभी को ऐसा लगा होगा जैसे बहुत सारे लेख हैं, लेकिन हम बस इसे समझाना चाहते थे।
00:21:06तो, जब आप बहुत सारे, जैसे जब आप ये इनपुट टोकन भेजते हैं, तो आप क्या करना चाहते हैं, आप उन की और वैल्यू वेक्टर को बनाना चाहते हैं जो मैंने सभी टोकन के लिए उल्लेख किया था।
00:21:20फिर आप पिछले टोकन के संबंध में प्रत्येक टोकन के अटेंशन स्कोर की गणना करना चाहते हैं।
00:21:27यह सारा ऑपरेशन जो आप करते हैं, यह बहुत, बहुत मैट्रिक्स-भारी है।
00:21:31यह एक बहुत, बहुत कंप्यूट-भारी ऑपरेशन है।
00:21:34और हम सब जानते हैं कि GPU, वे भारी कंप्यूट कार्यभार के लिए बहुत उपयुक्त हैं।
00:21:41इसलिए हम प्री-फिल को कंप्यूट बाउंड कहते हैं।
00:21:46और इसे पूरा होने में कुछ समय लगता है।
00:21:49इसलिए, इस चरण को पूरा होने में जो भी समय लगता है, वह पहले टोकन का समय है।
00:21:55इसलिए, यदि आपके पास अधिक इनपुट टोकन हैं, तो आपको अधिक की वैल्यू वेक्टर जनरेट करने होंगे।
00:22:02आपको बहुत अधिक अटेंशन गणित करना होगा।
00:22:05और इस वजह से, आपका TTFT अधिक से अधिक धीमा हो जाता है।
00:22:12जबकि एक बार जब आप एक टोकन जनरेट कर लेते हैं, तो आपको दूसरे टोकन जनरेट करने के लिए, क्रमानुसार एक के बाद एक ऐसा करना जारी रखना होता है।
00:22:20लेकिन उस प्रक्रिया में, हर बार आपको पिछले सभी टोकन्स के की और वैल्यू वेक्टर बनाने होते हैं, जो प्री-फिल के समान ही है।
00:22:30जैसे आप वहाँ भी की वैल्यू वेक्टर बना रहे थे, यहाँ भी बना रहे हैं।
00:22:34लेकिन डिकोड चरण में, आप केवल नए टोकन के लिए अटेंशन गणित की गणना कर रहे हैं।
00:22:40और यही कारण है कि यह बहुत कम, कम कंप्यूट-ओरिएंटेड होता है।
00:22:45और इसे मेमोरी बाउंड भी कहा जाता है।
00:22:48हम थोड़ी देर में देखेंगे कि इसे मेमोरी बाउंड क्यों कहा जाता है।
00:22:54तो, एक क्लासिक टाइमलाइन में, आप प्री-फिल और डिकोड चरण को इस तरह देखेंगे।
00:22:59तो, प्री-फिल द्वारा लिया गया समय, वह आपका टाइम टू फर्स्ट टोकन है।
00:23:03और फिर आपके हर डिकोड स्टेप द्वारा लिया गया समय, वह मूल रूप से आपका इंटर-टोकन लेटेंसी है।
00:23:12तो, यह चौथा मीट्रिक है जिसके बारे में आपको चिंता करने की ज़रूरत है।
00:23:18जैसे आपके डिकोड स्टेप द्वारा कितना समय लिया जा रहा है?
00:23:21ठीक है।
00:23:22ठीक है।
00:23:23बढ़िया।
00:23:24अब, डिकोड स्टेप या डिकोड को समय क्यों लगता है?
00:23:34और इसे मेमोरी बाउंड ऑपरेशन क्यों कहा जाता है?
00:23:38आइए इसे समझने का प्रयास करते हैं।
00:23:40इसे समझने के लिए, हमें यह देखना होगा कि मैट्रिक्स मैथ उच्च स्तर पर GPU पर कैसे काम करता है।
00:23:47तो, GPU में दो प्रकार की मेमोरीज होती हैं।
00:23:50आपके पास हाई बैंडविड्थ मेमोरी होती है।
00:23:52आपके पास शेयर्ड मेमोरी होती है।
00:23:55तो, हाई बैंडविड्थ मेमोरी आकार में बड़ी होती है, लेकिन इसकी बैंडविड्थ कम होती है।
00:24:01कम बैंडविड्थ से मेरा मतलब है कि आप इससे कम दर पर डेटा ट्रांसफर कर सकते हैं।
00:24:06शेयर्ड मेमोरी की तुलना में, शेयर्ड मेमोरी आकार में छोटी होती है, लेकिन इसकी बैंडविड्थ बहुत-बहुत अधिक होती है।
00:24:13इसका मतलब है कि आप इसमें बहुत तेज़ी से डेटा अंदर और बाहर ट्रांसफर कर सकते हैं।
00:24:19तो, जब आपको मैट्रिक्स मैथ करना होता है, तो आपको हाई बैंडविड्थ मेमोरी से डेटा चunks में चुनना होता है।
00:24:27आपको इसे शेयर्ड मेमोरी में डालना होगा।
00:24:30वह गणित करना होगा।
00:24:32परिणाम को वापस हाई बैंडविड्थ मेमोरी में लिखना होगा।
00:24:38प्री-फिल चरण के लिए, जब आपको यह करना होता है, तो आपको यह मैट्रिक्स मैथ केवल एक बार करना होता है।
00:24:46लेकिन डिकोड चरण के लिए, आपको यह मैट्रिक्स मैथ बार-बार करना होगा क्योंकि आप प्रत्येक टोकन को क्रमानुसार जनरेट कर रहे हैं।
00:24:59और इसलिए, इससे कोई फर्क नहीं पड़ता कि आपका डिकोड कितना तेज़ है क्योंकि अब आप निश्चित गति से हाई बैंडविड्थ मेमोरी से शेयर्ड मेमोरी में अपना डेटा ट्रांसफर कर सकते हैं।
00:25:14क्योंकि आप हाई बैंडविड्थ मेमोरी की बैंडविड्थ गति से सीमित हैं।
00:25:18और इसलिए, यह आपके टोकन सीलिंग को नियंत्रित करता है, जैसे कि आप वास्तव में डिकोड स्टेप से किस दर पर टोकन जनरेट कर सकते हैं।
00:25:32यदि आप इसे रूफलाइन प्लॉट में देखें, तो एक बायाँ हिस्सा है जिसे मेमोरी बाउंड कहा जाता है।
00:25:42गणितीय रूप से, यह अंकगणितीय तीव्रता (arithmetic intensity) द्वारा नियंत्रित होता है।
00:25:47अंकगणितीय तीव्रता ट्रांसफर किए जा रहे डेटा के प्रति बाइट पर आपके द्वारा किए जाने वाले फ्लिप-फ्लॉप ऑपरेशंस की संख्या है।
00:25:55तो, डिकोड स्टेप के लिए, चूंकि आप बहुत सारा डेटा ट्रांसफर कर रहे हैं, जैसे पिछले सभी टोकन्स के की और वैल्यू वेक्टर, मॉडल वेट्स,
00:26:08लेकिन आप कम गणना कर रहे हैं क्योंकि आप केवल एक टोकन के लिए अटेंशन गणित की गणना कर रहे हैं।
00:26:13इसलिए, इसकी अंकगणितीय तीव्रता बहुत कम होती है।
00:26:18लेकिन प्री-फिल्ड चरण के लिए, आप डेटा को एक बार ट्रांसफर करते हैं, लेकिन फिर आप यह भारी गणना करते हैं।
00:26:27और इसलिए, इसकी अंकगणितीय तीव्रता बहुत अधिक होती है।
00:26:30तो, अब आप गणित के संदर्भ में जानते हैं कि प्री-फिल की अंकगणितीय तीव्रता आपके डिकोड की तुलना में इतनी अधिक क्यों है।
00:26:44ठीक है।
00:26:46तो, यह एक और छोटा सा डेमो है।
00:26:51ठीक है।
00:26:52हर बार मुझे करना होता है।
00:26:53ठीक है।
00:26:54ठीक है।
00:26:55बढ़िया।
00:26:56मुझे उम्मीद है कि यह पहले से है।
00:26:58तो, हाँ।
00:26:59फिर से, हम मॉडल लोड कर रहे हैं।
00:27:04अब, यह प्री-फिल्ड लागत है।
00:27:09तो, हम मूल रूप से क्या कर रहे हैं कि हम इनपुट टेक्स्ट प्राप्त कर रहे हैं और फिर हम इसे, प्री-फिल्ड स्टेप, इसमें लगने वाले समय को जनरेट करने का प्रयास कर रहे हैं।
00:27:22हम देखते हैं कि जैसे-जैसे हम इनपुट टोकन्स का आकार बढ़ाते हैं, यह प्री-फिल बढ़ता जाता है।
00:27:28तो, आप जानते हैं, और यही कारण है कि आपका DTFT बढ़ जाता है।
00:27:33और फिर आपका डिकोड समय।
00:27:36तो, डिकोड समय औसत पर लगभग समान रहता है।
00:27:41और इसलिए, यदि यह है कि आप कोल्ड स्टार्ट को नजरअंदाज करते हैं, तो आपका डिकोड समय औसत रेखा के लगभग आसपास होता है।
00:27:50यह अभी भी इनपुट आकार से प्रभावित होता है।
00:27:57ऐसा नहीं है कि यह एक स्थिर समय है।
00:28:00और ऐसा इसलिए है क्योंकि इसे अभी भी पिछले सभी टोकन्स के लिए मेमोरी से की और वैल्यू वेक्टर खींचने की आवश्यकता है।
00:28:07तो डिकोड स्टेप के साथ समय में अभी भी मूल रूप से थोड़ी सी वृद्धि दिखाई देगी।
00:28:15और फिर यह क्लासिक रूफ लाइन प्लॉट है।
00:28:20ठीक है।
00:28:22ठीक है।
00:28:23प्रस्तुति।
00:28:24ठीक है।
00:28:25ठीक है।
00:28:26ठीक है।
00:28:27तो, आइए अब थ्रूपुट आयाम को समझने का प्रयास करें।
00:28:43आप यह समझना चाहते हैं कि आप वास्तव में कितने उपयोगकर्ताओं को सेवा दे सकते हैं।
00:28:48और मुझे लगता है कि हमने GPU मेमोरी का एक आरेख देखा था जहाँ हमने देखा था कि की और वैल्यू वेक्टर के बढ़ने के लिए कुछ मेमोरी खाली होती है।
00:28:56ठीक है।
00:28:57तो मान लीजिए कि आपके पास सिर्फ एक ही उपयोगकर्ता है।
00:29:01कुल KV आकार क्या है जो आपके पास है जिसे आप मूल रूप से समर्थन दे सकते हैं?
00:29:09यह आपकी контекст सीमा (context limit) द्वारा परिभाषित होता है।
00:29:11अधिकतम उपयोगकर्ता जिन्हें आप समर्थन दे सकते हैं, वह यह है कि आपके GPU की जो भी उपलब्धता है, जैसे GPU में जो भी मेमोरी उपलब्ध है, उसे प्रति उपयोगकर्ता की और वैल्यू आकार से विभाजित करें।
00:29:25और जब आप ऐसा करते हैं, तो यह समवर्ती (concurrent) उपयोगकर्ताओं के रूप में सामने आता है।
00:29:32अब, मान लीजिए कि आपका GPU निश्चित है, आपका मॉडल निश्चित है, इसलिए आपका प्रति टोकन KV आकार निश्चित है।
00:29:46यहाँ केवल दो आयाम बचे हैं, जो कि कॉन्टेक्स्ट और आपके समवर्ती उपयोगकर्ता हैं।
00:29:53यदि आप अधिक समवर्ती उपयोगकर्ताओं को सेवा देना चाहते हैं, तो आपको कॉन्टेक्स्ट की लंबाई कम करनी होगी।
00:29:57यदि आप कॉन्टेक्स्ट की लंबाई कम करते हैं, तो यह आपकी गुणवत्ता को प्रभावित कर सकता है।
00:30:02तो ये वे दो आयाम हैं जिनके बीच हम अभी समझौता (trade-off) कर रहे हैं।
00:30:09फिर अगर हम, लेकिन क्या आप वास्तव में समवर्ती उपयोगकर्ताओं की अधिकतम संख्या को सेवा दे सकते हैं?
00:30:17एक आदर्श दुनिया में, शायद नहीं क्योंकि हर व्यवसाय का एक लेटेंसी SLA होता है जिसे हमें पूरा करना होता है।
00:30:27तो, यदि आपको याद हो कि डिकोड स्टेप में मैंने कहा था, यदि आपके पास अधिक इनपुट हैं तो डिकोड के लिए समय अभी भी बढ़ जाता है।
00:30:37यदि आपके पास अधिक उपयोगकर्ता हैं तो यह भी बढ़ जाता है।
00:30:40इसलिए यदि आपके पास उच्च बैच आकार है तो अंततः आपकी इंटर-टोकन लेटेंसी भी प्रभावित होती है।
00:30:51और आपका TTFT भी प्रभावित होता है।
00:30:53तो अब एक तीसरा आयाम है जिसके बारे में आपको चिंता करनी होगी, जो कि आपकी लेटेंसी है।
00:30:58तो आपके पास जो तीन आयाम हैं वे हैं गुणवत्ता, लेटेंसी और थ्रूपुट।
00:31:04तो यह इस ट्रेडऑफ त्रिभुज के रूप में सामने आता है जहाँ आपको दोनों में से किसी एक को चुनना होता है।
00:31:11तो एक प्रीमियम चैट एप्लिकेशन के लिए, आप निश्चित रूप से गुणवत्ता को प्राथमिकता देना चाहेंगे और आप लेटेंसी को प्राथमिकता देना चाहेंगे।
00:31:21आप नहीं चाहेंगे कि आपके उपयोगकर्ता प्रतीक्षा करें, जैसे अनंत रूप से नहीं, बल्कि शायद अधिक लेटेंसी के लिए।
00:31:30आप हमेशा GPU पर समर्थन करने वाले उपयोगकर्ताओं की संख्या का त्याग कर सकते हैं और अधिक ग्राहक-केंद्रित होते हुए उस लागत दर को उठा सकते हैं।
00:31:39तो, इस रूप में, और यदि आप किसी एजेंट, क्षमा करें, एसिंक्रोनस एजेंट वर्कलोड पर विचार करते हैं, तो आप निश्चित रूप से गुणवत्ता और थ्रूपुट को प्राथमिकता देना चाहेंगे।
00:31:53क्योंकि ये लंबे समय तक चलने वाले कार्य हैं।
00:31:56और आप बहुत-बहुत उच्च गुणवत्ता के साथ यथासंभव अधिक से अधिक समवर्ती कार्यों को सेवा देना चाहेंगे।
00:32:06और अक्सर ऐसा होता है कि हम सोचते हैं, ठीक है, अगर GPU बहुत महंगा GPU है, तो यह हमारे लिए उपयुक्त नहीं हो सकता है।
00:32:19लेकिन यह पता चलता है कि यह वास्तव में आपको प्रति मिलियन टोकन सबसे कम लागत दे सकता है।
00:32:27लेकिन आपको अधिकतम उपयोगकर्ताओं पर अपनी तरह की गणनाओं पर वास्तव में भरोसा करना होगा और आपको वास्तव में उन अनुमानों को सही ढंग से बनाना होगा।
00:32:40तो हमारे पास है, मुझे बस, ठीक है, बढ़िया।
00:32:55तो, कैपेसिटी कैलकुलेटर के लिए, कोलाब का एक लिंक है क्योंकि मैं इससे परिचित था।
00:33:01मुझे पूरे विजेट लाइब्रेरी से बाहर माइग्रेट करना पड़ा और मेरे पास समय नहीं था।
00:33:16तो, आलसी होने के कारण, मैंने वहाँ बस कोलाब चुन लिया।
00:33:20मेरी लैब से क्षमा प्रार्थी हूँ।
00:33:23तो, मेरा V-RAM कनेक्टेड है।
00:33:34ठीक है।
00:33:45तो, शायद वाई-फाई।
00:33:46ठीक है, बढ़िया।
00:34:02तो, हमने यहाँ जो किया है वह यह है कि हमने उनके V-RAM और बैंडविड्थ, फ्लिप-फ्लॉप और प्रति घंटे की लागत के साथ कुछ GPU को साझा किया है।
00:34:11फिर हमने इस तरह का एक साधारण क्षमता कैलकुलेटर बनाया है।
00:34:19यह सिर्फ एक KV विजुअलाइज़र है जहाँ आप इस तरह से करते हैं, जब आप टोकन्स की संख्या बढ़ाते हैं, तो आप देखते हैं कि KV का आकार बढ़ता है।
00:34:29और जब आप उपयोगकर्ताओं की संख्या बढ़ाते हैं, तो आपका आकार बहुत तेज दर से बढ़ रहा है।
00:34:37और फिर, इस क्षमता कैलकुलेटर में, इसे चलने दें।
00:34:47तो हमारे पास एक मॉडल है जो 7 बिलियन पैरामीटर वाला मॉडल है जिसे हमने चुना है।
00:34:56हमने प्रिसिजन को FP16 पर सेट किया है।
00:35:01अब, हम तय करते हैं, GPU का निर्णय लेने का तरीका यह है कि आपको यह तय करना होगा कि आपकी क्या आवश्यकता है, जैसे आपको पहले एक आयाम को तय करना होगा जिसकी आपको सबसे अधिक परवाह है।
00:35:15तो, प्रीमियम चैट के लिए, मैंने उल्लेख किया कि लेटेंसी निश्चित रूप से वही है।
00:35:21और फिर जैसे एसिंक्रोनस वर्कलोड के लिए, न्यूनतम बैच आकार जिसे आप एक ही GPU से हल करना चाहते हैं, वह दूसरा आयाम है।
00:35:31तो आप इन्हें पहले तय करना चाहते हैं।
00:35:34तो मैं एक प्रीमियम चैट एप्लिकेशन की तरह आगे बढ़ूँगा।
00:35:39तो मैं 10 मिलीसेकंड लेटेंसी के साथ आगे बढ़ सकता हूँ।
00:35:44न्यूनतम बैच आकार, मुझे परवाह नहीं है।
00:35:46जैसे मैं कर सकता हूँ, इसलिए मैं शायद दो के साथ ठीक हूँ।
00:35:53ठीक है।
00:35:54तो, एक ही GPU पर शायद सात समवर्ती उपयोगकर्ताओं के साथ।
00:35:59और जैसे मेरी कॉन्टेक्स्ट सीमा मेरे लिए बहुत महत्वपूर्ण है क्योंकि मैं गुणवत्ता पर भी ध्यान केंद्रित करना चाहता हूँ।
00:36:07और इसलिए, मुझे कुछ GPU दिखाई देते हैं।
00:36:10तो, H-100 80GB, यह लगभग 8 डॉलर प्रति घंटा है।
00:36:15लेकिन जैसे, क्या मैं 300x हूँ?
00:36:19क्या यह है?
00:36:20हाँ।
00:36:21तो यह लगभग 10 डॉलर प्रति घंटे के आसपास है।
00:36:24तो, अगर आप वह सारा थ्रूपुट गणित करते हैं जो हमने पहले गणित में साझा किया था, तो आप प्रति मिलियन डॉलर टोकन की अपनी लागत का पता लगा सकते हैं।
00:36:34वह बहुत, बहुत, वह कम हो सकता है।
00:36:37इसलिए, आपको उन आयामों को तय करके ऐसी गणनाएँ करने की आवश्यकता है और आपको अपने प्रकार के अनुमान की लागत को कम करने के लिए अपने GPU का निर्णय लेने की आवश्यकता है।
00:36:49तो, यह कम से कम पहला कदम है जो आप अनुमान को अनुकूलित करने की दिशा में उठा सकते हैं।
00:36:56ठीक है।
00:37:01तो, अगली स्लाइड।
00:37:04मुझे करने दीजिए।
00:37:08ठीक है, बहुत बढ़िया।
00:37:10और इसलिए, अब अगली चीज़ मॉडल अनुकूलन के बारे में है।
00:37:15तो, अब हम मूल रूप से उस नींव का निर्माण कर चुके हैं जहाँ हमने कुछ दर्द बिंदुओं, उन दर्द बिंदुओं के पीछे के कारणों, को समझा कि वे क्यों हो रहे थे।
00:37:23हम उस GPU क्षमता वाली चीज़ को कैसे संबोधित कर सकते हैं।
00:37:29हमें यह समझने की ज़रूरत है कि हम क्या कर सकते हैं, जैसे हम इसके बारे में आगे क्या कर सकते हैं।
00:37:33तो, यह मॉडल अनुकूलन के बारे में है और मुझे लगता है कि मैं तन्मय को आमंत्रित करना चाहूंगा।
00:37:39वह इन मॉडल अनुकूलनों के बारे में अधिक बात कर सकते हैं बशर्ते उन्होंने इस पर काम किया हो जैसे कि अपने शोध के समय।
00:37:47ठीक है।
00:37:48ठीक है।
00:37:49मैं नियंत्रित कर सकता हूँ।
00:37:50मैं नियंत्रित कर सकता हूँ।
00:37:54हाँ।
00:37:55यहाँ।
00:37:56ठीक है।
00:37:57नमस्ते सभी को।
00:37:58माइक चेक।
00:37:59क्या अंत में मुझे सुना जा रहा है?
00:38:00हाँ।
00:38:01ठीक है।
00:38:02तो, नमस्ते।
00:38:03मैं तन्मय शाह हूँ।
00:38:04मैं एक वरिष्ठ क्वांट मॉडलर के रूप में काम करता हूँ और साथ ही मैं एक एआई शोधकर्ता भी हूँ।
00:38:08तो, ध्यान एजेंट सत्यापन पर है और अभी दुनिया के मॉडल बना रहा है।
00:38:13तो, इसके लिए, मॉडल अनुकूलन।
00:38:16मॉडल अनुकूलन शुरू करने से पहले, तो मैंने एक शोध टेम्पलेट बनाया है ताकि हमारे लिए इन सभी जटिल चीजों को समझना आसान हो सके।
00:38:25तो, हमारा टेम्पलेट सरल है।
00:38:28पहला, हम समस्या की पहचान करेंगे।
00:38:30दूसरा चरण, हम दो एल्गोरिदम का उपयोग करके समस्या को हल करेंगे।
00:38:34ये सिर्फ नकली एल्गोरिदम हैं।
00:38:35तो, पहले एल्गोरिदम को शुतुरमुर्ग एल्गोरिदम कहा जाता है।
00:38:39जब भी हम देखते हैं, शुतुरमुर्ग की तरह, जब भी हम कोई समस्या देखते हैं, तो शुतुरमुर्ग अपना सिर रेत में डाल लेता है।
00:38:46तो, वही काम हम करेंगे।
00:38:47जब भी हमारे सामने कोई समस्या आएगी, हम उसे नजरअंदाज कर देंगे।
00:38:51तो, यह एक महत्वपूर्ण एल्गोरिथ्म है जिसका हमें पालन करना चाहिए।
00:38:55दूसरा बनाया गया है, इसे विश्व कप एल्गोरिथ्म कहा जाता है।
00:38:59उदाहरण के लिए, हम नहीं जानते कि इस फीफा विश्व कप को कौन जीतेगा।
00:39:03तो, आयोजकों ने क्या किया, उन्होंने 48 टीमों को 12 समूहों में विभाजित कर दिया।
00:39:11फिर राउंड 32, तो राउंड 32 अभी वर्तमान में चल रहा है।
00:39:16फिर राउंड 16, फिर क्वार्टर फाइनल, फिर सेमीफाइनल और फाइनल।
00:39:21तो, वे क्या कर रहे हैं कि वे इसे छोटी समस्याओं में तोड़ रहे हैं और उपयोगी परिणाम आगे बढ़ रहे हैं।
00:39:30तो, इस मॉडल अनुकूलन, उन सभी चीजों को समझने के लिए हम उसी सादृश्य या उसी एल्गोरिथ्म का उपयोग करेंगे।
00:39:38तो, हाँ, चलिए शुरू करते हैं।
00:39:41तो, मेरे पास एक H100 GPU है।
00:39:46मुझे इस ओपन सोर्स मॉडल का उपयोग करना है, जिसे GPT OSS 120 बिलियन पैरामीटर मॉडल कहा जाता है।
00:39:54तो, अभी मुझे लगता है कि यह है, इसलिए उन्होंने इसे BF float 16 पर प्रशिक्षित किया है और वजन 240 गीगाबाइट है।
00:40:02मुझे क्या करना चाहिए?
00:40:04यह वह समस्या है जो हमारे पास है।
00:40:07पहली बात, जो हमें करनी है वह है 240 गीगाबाइट और 80 गीगाबाइट H100।
00:40:16तो, और मुझे केवल एक GPU में फिट होना है, कई GPU में नहीं।
00:40:21तो, हम क्या कर सकते हैं?
00:40:22मुझे लगता है कि सरल कदम यह है कि बस इसे संपीड़ित करें।
00:40:27लेकिन हमें इसे कैसे संपीड़ित करना चाहिए?
00:40:29यह एक और चुनौती है।
00:40:30इसलिए, यदि हम BF float 16 को FP8 में संपीड़ित करते हैं, तो यह लगभग 120 गीगाबाइट होगा।
00:40:38लेकिन हमारा GPU H100 अभी भी 80 गीगाबाइट है।
00:40:42तो, मुझे लगता है कि उन्होंने जो किया वह यह है कि उन्होंने इसे आगे MXFP4 में संपीड़ित किया।
00:40:49और मुझे लगता है कि आकार लगभग 65 गीगाबाइट है।
00:40:53तो, यह कुछ ऐसा है जो हम कर सकते हैं, संपीड़ित कर सकते हैं, लेकिन सवाल।
00:40:59तो, और हम इस शुतुरमुर्ग एल्गोरिथ्म का उपयोग करेंगे।
00:41:03हम यह मान रहे हैं कि एक बड़े मॉडल को छोटे आकार में संपीड़ित करने में कोई नुकसान नहीं होता है।
00:41:10तो, दूसरी बात, इस वाले में, ठीक है, हाँ।
00:41:16तो, इस वाले में, इस स्लाइड में, हमने इस Mistral 7B का उपयोग किया है।
00:41:20तो, सात अरब पैरामीटर।
00:41:22तो, यह एक छोटा मॉडल है, सात अरब पैरामीटर।
00:41:25तो, यदि आप इसे दो बाइट से गुणा करते हैं, तो इसका वजन लगभग 14 है।
00:41:3114.5 गीगाबाइट, जो H100 या A40 में भी आसानी से फिट हो सकता है।
00:41:38तो, आगे, हम क्या कर सकते हैं कि Mistral 7B की तरह, फ्लोटिंग पॉइंट 16 को संपीड़ित करने के बजाय, हम int8 या int4 या nf4 जैसी विभिन्न तकनीकों को लागू कर सकते हैं।
00:41:53तो, मूल रूप से, हमें बस शुतुरमुर्ग एल्गोरिथ्म का उपयोग करना है और बस यह विश्वास करना है कि कोई गुणवत्ता हानि जैसी चीजें नहीं हैं।
00:42:01लेकिन, किसी तरह, हमें कुछ बाहरी बेंचमार्क पर कुछ प्रकार के परीक्षण करके गणितीय रूप से भी यह साबित करना होगा कि यह काम कर रहा है या नहीं।
00:42:10तो, और यह पोस्ट-ट्रेनिंग क्वांटाइजेशन जैसी चीज़ के अंतर्गत आता है।
00:42:16कोई इसे फाइन-ट्यूनिंग के दौरान भी कर सकता है।
00:42:20कोई इस प्रकार का क्वांटाइजेशन भी कर सकता है।
00:42:22यह क्वांट-अवेयर ट्रेनिंग जैसी चीज़ के अंतर्गत आता है।
00:42:25तो, चलिए हमारी अगली समस्या पर चलते हैं।
00:42:31तो, हमारे पास यह विशाल मैट्रिक्स हैं।
00:42:37तो, बस 1,000 गुणा 1,000 आयाम, मैट्रिक्स A, और दूसरा मैट्रिक्स 1,000 गुणा 1,000 की कल्पना करें।
00:42:51तो, यदि आप इन दोनों मैट्रिक्स से गुणा करते हैं, तो संचालन की संख्या 1,000 की घात Q होगी।
00:43:00और यह कंप्यूटिंग के मामले में एक तरह की समस्या है।
00:43:06तो, हम चाहते थे कि हमारा मैट्रिक्स गुणन तेज हो और इससे मेमोरी की बचत हो।
00:43:13तो, हमें क्या करना चाहिए?
00:43:15हमारे पास एक विशाल मैट्रिक्स है।
00:43:17ठीक है, इसे लेते हैं, श्री 4096 गुणा 4096।
00:43:23चीजों को तेज करने और मेमोरी 4096 गुणा 4096 को बचाने की हमारी समस्या को हल करने के लिए हमें क्या करना चाहिए।
00:43:33तो, पहली बात यह है कि हम सिर्फ अपने विश्व कप एल्गोरिथ्म का उपयोग करेंगे।
00:43:37हम एक यादृच्छिक संख्या तय कर सकते हैं, ब्लॉक को लंबवत रूप से तोड़ सकते हैं।
00:43:42इससे कोई फर्क नहीं पड़ता कि आप इसे क्या चुन रहे हैं।
00:43:45तो, मान लीजिए हमारे पास 4096 कॉलम हैं।
00:43:51हम इसे प्रत्येक 128 कॉलम के समूह में तोड़ देंगे।
00:43:57तो, 128, 128, 128, 128, 128 लंबवत रूप से।
00:44:03तो, अगर हम इस 4096 को विभाजित करते हैं तो हमें ये 32 ब्लॉक मिल जाएंगे।
00:44:09फिर, इस काम को करने से क्या होगा?
00:44:13तो, अगर हम इसे लंबवत रूप से विभाजित करते हैं, तो हम प्रक्रिया को तेज करने के लिए कई GPU का उपयोग कर सकते हैं।
00:44:21तो, इस प्रकार की चीज़ को मल्टी-हेड अटेंशन कहा जाता है।
00:44:26तो, हम और क्या कर सकते हैं?
00:44:29हमारे पास एक बड़ा मैट्रिक्स है जैसे, जैसा कि मैंने उल्लेख किया है कि शुतुरमुर्ग एल्गोरिथ्म।
00:44:36तो, हमारी मुख्य समस्या आकार देना है।
00:44:39तो, हम क्या कर सकते हैं कि उन सभी 32 लंबवत ब्लॉकों के होने के बजाय, हम 31 ब्लॉक फेंक देंगे।
00:44:49और हम यह मानेंगे कि एक ब्लॉक इतना पर्याप्त है कि सभी प्रश्न उन ब्लॉकों को संभाल सकते हैं।
00:44:57हमारा नुकसान लगभग नगण्य होगा।
00:45:00और हम इस एल्गोरिथ्म के साथ आते हैं।
00:45:04और इस एल्गोरिथ्म को मल्टी-क्वेरी अटेंशन कहा जाता है।
00:45:08तो, जैसा कि हम देख सकते हैं, अभी हम दो स्पेक्ट्रम पर हैं।
00:45:12एक मल्टी-हेड अटेंशन है, जहाँ हम इसे 32 ब्लॉकों में विभाजित करते हैं और अलग-अलग GPU का उपयोग करते हैं या कुछ समानांतर प्रसंस्करण करते हैं।
00:45:22और साथ ही, हम सिर्फ 31 ब्लॉक फेंक रहे हैं।
00:45:26और हम इसे मल्टी-क्वेरी अटेंशन कह रहे हैं।
00:45:31तो, दोनों चरम सीमाओं पर, हमें किसी मध्य मार्ग के साथ आना चाहिए।
00:45:38हम कह सकते हैं कि सभी 31 को फेंकने के बजाय, शायद हम कुछ ब्लॉकों को एक साथ समूहित कर सकते हैं।
00:45:49और हम मान सकते हैं कि समान ब्लॉक समान प्रकार के प्रश्नों पर ध्यान देंगे।
00:45:58तो, इस प्रकार की तकनीक ग्रुपेड क्वेरी अटेंशन के अंतर्गत आती है, जो अभी बहुत लोकप्रिय है।
00:46:04यहाँ तक कि Mistral या अन्य मॉडलों में भी, यह ग्रुपेड क्वेरी अटेंशन काम करता है।
00:46:11तो, अभी, हमने समझ लिया है कि हमारे पास एक बड़ा मैट्रिक्स है।
00:46:16हम इसे अपनी इच्छानुसार विभाजित कर सकते हैं और कुछ गणितीय गणना करके,
00:46:19यह साबित कर सकते हैं कि नुकसान लगभग नगण्य चीज़ है।
00:46:23तो, हम और क्या कर सकते हैं?
00:46:25तो, उसके बाद, इस ग्रुपेड क्वेरी अटेंशन के बाद,
00:46:34देखिए, हमारे पास एक बड़ा मैट्रिक्स है।
00:46:38एक कुंजी है और एक मूल्य है।
00:46:42आइए उस मैट्रिक्स को एक लेटेंट वेक्टर में संपीड़ित करें।
00:46:47और फिर लेटेंट वेक्टर से हमारे मूल मैट्रिक्स में पुनर्निर्माण के लिए कुछ एल्गोरिथ्म के साथ आएं।
00:46:55तो, इस प्रकार की रणनीति इसके अंतर्गत आती है।
00:46:59मल्टी-हेड लेटेंट अटेंशन।
00:47:02लेकिन फिर से, इसमें रस्सी के साथ कुछ समस्याएं हैं क्योंकि रस्सी स्थिति-निर्भर है और यह स्थिति-स्वतंत्र प्रकार की चीज़ है।
00:47:10तो, किसी को कुंजियों के लिए भी कुछ सूचकांक शामिल करने की आवश्यकता है, ताकि कोई इसे मैप कर सके।
00:47:16लेकिन फिर से, मुख्य समस्या यह है कि हम उन सभी बड़े मैट्रिक्स को क्यों गुणा कर रहे हैं।
00:47:25तो, क्योंकि यह इस तरह है कि यह ध्यान तंत्र काम करता है, कि प्रत्येक टोकन हर टोकन पर ध्यान देगा।
00:47:33तो, इसके बारे में क्या ख्याल है, आइए, सभी पिछले टोकन पर ध्यान न दें, केवल उन महत्वपूर्ण टोकन पर ध्यान दें, जो हमारे लिए महत्वपूर्ण हैं।
00:47:42तो, यह एक तरह का, यह क्षेत्र विकसित हो रहा है।
00:47:46तो, यह स्पार्स, डीपसीक स्पार्स अटेंशन के अंतर्गत आता है।
00:47:51तो, हाँ।
00:47:53और, हाँ, तो, ठीक है।
00:47:56अगला।
00:47:59हाँ, तो अगला है फ्लैश अटेंशन।
00:48:02तो, फ्लैश अटेंशन में, मुख्य समस्या यह है कि,
00:48:09तो वर्तमान में, तो वर्तमान में, तो वर्तमान में, वर्तमान में नहीं, तो अभी, लगभग हर कोई फ्लैश अटेंशन का उपयोग करता है, लेकिन 2022 या 2023 में।
00:48:20तो, यह इस तरह काम करता है।
00:48:23यह इस तरह काम करता है कि, तो, यह Q, K, क्वेरी और की मैट्रिक्स, वे HBM में थे।
00:48:34यह लोड होता है, यह, पहले, यह हमारे टेंसर कोर में लोड होता है, और यह कुछ, यह कुछ गणना करता है, और फिर यह इसे वापस HBM में लिख देगा।
00:48:47और फिर, यह प्रक्रिया कई बार चलती है।
00:48:51तो, फ्लैश अटेंशन में, उन्होंने क्या किया है, वह यह है कि पूरे मैट्रिक्स को गुणा करने के बजाय,
00:48:59तो उन्होंने इसे बस विभाजित कर दिया, जैसे, हमारे वर्ल्ड कप एल्गोरिदम की तरह, बड़े मैट्रिक्स को एक छोटे टाइल में विभाजित कर दिया,
00:49:05और केवल उन छोटे टाइलों को SBM में रखा, ताकि यह तेजी से गुणा प्रक्रिया कर सके,
00:49:13और इस ऑनलाइन सॉफ्टमैक्स की गणना करने के लिए, कुछ तीन चर (variables) का ट्रैक रखता है।
00:49:20तो, हाँ, तो यह सिर्फ गणित है, इसलिए यदि हमारे पास मल्टी-हेड अटेंशन है, यदि यह 524 kV के लिए है,
00:49:34तो यह इस बात पर निर्भर करता है कि हम कितना समूहीकरण (grouping) चाहते हैं, और इसलिए, यदि 32 kV हेड के बजाय, हम केवल 8 kV हेड का उपयोग करना चाहते हैं,
00:49:47तो, हम 4x गुना संपीड़न (compression) प्राप्त कर सकते हैं, और यह मल्टी-हेड लेटेंट अटेंशन है।
00:49:54यह फॉर्मूला मॉडल दर मॉडल इस बात पर निर्भर करता है कि आपके मॉडल में कितने लेयर हैं।
00:50:00तो, मूल DeepSeek पेपर में, मुझे लगता है कि उनके पास कुछ 128 आयाम, 128, एक बिंदु, मुझे सटीक आयाम याद नहीं है, लेकिन उसके अनुसार,
00:50:11उन्होंने इस एक लेटेंट वेक्टर का उपयोग किया है, जिसमें उन्होंने आयाम के रूप में 512 और रोपे इंडेक्स के लिए कुछ 64 का उपयोग किया है,
00:50:23और फिर वे दिखाते हैं कि यह मल्टी-हेड अटेंशन की तुलना में 56x अधिक संपीड़ित है।
00:50:32ठीक है।
00:50:33हाँ, तो, तो हाँ, तो यह है, तो यह है, यह ट्रेड-ऑफ आरेख है, यहाँ मुझे लगता है कि हमने इस रैखिक ध्यान (linear attention) या Mamba के बारे में बात नहीं की है।
00:50:50तो मुख्य समस्या यह है कि यह सब मैट्रिक्स गुणन है, अभी हर कोई अटेंशन का उपयोग कर रहा है।
00:50:56मान लीजिए भविष्य में, यदि हम अटेंशन का उपयोग नहीं करना चाहते हैं, तो अनुक्रमिक रूप से टोकन उत्पन्न करने के बजाय, शायद डिफ्यूजन मॉडल का उपयोग करें,
00:51:07जहाँ हम सब कुछ एक साथ उत्पन्न कर सकते हैं, तो ये सभी एल्गोरिदम भी बदल जाएंगे।
00:51:14लेकिन यहाँ, मुझे लगता है कि उनके पास दो और हैं, एक रैखिक ध्यान (linear attention) है और एक Mamba है।
00:51:19तो, इस स्लाइड के अनुसार, यदि हम कुछ भी संपीड़ित नहीं कर रहे हैं, तो MHA बस यह है कि हम प्रक्रिया को समानांतर कर रहे हैं।
00:51:29तो, कोई गुणवत्ता हानि नहीं है, इसलिए यह अच्छा है, और फिर यह ग्रुप क्वेरी अटेंशन है, जो, मुझे लगता है कि लगभग हर मॉडल सिर्फ GQA और DSA जैसी चीज़ों का उपयोग कर रहा है।
00:51:42हाँ।
00:51:43मुझे लगता है कि वही चीज़ हम अटेंशन मैकेनिज्म स्कोरकार्ड में प्रदान कर रहे हैं, इसलिए, मुझे लगता है कि यह वाला, MHA गुणवत्ता अच्छी है, थ्रूपुट ठीक है।
00:51:56और ग्रुप क्वेरी अटेंशन के लिए, यह आपके उपयोग के मामले (use case) पर भी निर्भर करता है, हालांकि, हाँ, हालांकि गुणवत्ता मल्टी-हेड अटेंशन के लगभग समान है, लेकिन उपयोग का मामला भी बहुत मायने रखता है।
00:52:10हाँ, मल्टी-क्वेरी अटेंशन सिर्फ एक चरम सीमा है।
00:52:13हम, मुझे नहीं पता क्यों, लेकिन हम बस यह मान रहे हैं कि हमें केवल एक ब्लॉक की आवश्यकता है, और सभी क्वेरी उन छोटे, छोटे ब्लॉकों पर ध्यान देंगी।
00:52:24तो MQA के लिए गुणवत्ता इतनी बेहतरीन नहीं है।
00:52:29और यह मल्टी-हेड लेटेंट अटेंशन, तो, हाँ, यदि आपने कुछ आजमाया है, तो ये डीप-सीक मॉडल हैं, इसलिए मुझे लगता है कि वे गुणवत्ता के मामले में बहुत अच्छा काम कर रहे हैं, इसके अलावा, स्लाइडिंग विंडो।
00:52:44तो ये सभी कुछ तकनीकें हैं जो, हाँ, ये सभी कुछ तकनीकें हैं, जैसे, विंडो को समायोजित करना, ये सभी चीजें, और हर चीज को गुणा करने के बजाय, रैखिक ध्यान (linear attention) सिर्फ यह कह रहा है कि पहले हर चीज का सारांश दें, और फिर इसमें देखें, और फिर Mamba, यह सिर्फ एक स्टेट-स्पेस मॉडल है, हाँ।
00:53:09तो, मॉडल जैसे अनुकूलन के लिए, हमारे पास यहाँ दो नोटबुक भी हैं।
00:53:28तो, होगा, मुझे इस पर जाना होगा।
00:53:35ठीक है, तो क्वांटाइजेशन के लिए, जैसे डेमो, यह, क्या यह पहले से चल रहा है? नहीं।
00:53:51मुझे इसे चलाने दीजिए।
00:53:54ठीक है, तो हम मॉडल लोड कर रहे हैं, जो कि Mistral 7B जैसा है।
00:54:10तो यह वाला, FP16 बेसलाइन के साथ है।
00:54:20रुकिए।
00:54:21क्या यह चला?
00:54:21रुकिए।
00:54:22क्या यह चला?
00:54:23ठीक है।
00:54:24तो, यह, दो मिलीसेकंड है, यह चल गया है।
00:54:27क्या यह चला?
00:54:28ঠিক है।
00:54:29तो, हाँ, इस बार, यह FP16 सटीकता के साथ उस मॉडल को प्राप्त कर रहा है।
00:54:35ठीक है।
00:54:36तो, यह, दो मिलीसेकंड है, यह चल गया है।
00:54:40क्या यह चला?
00:54:41ठीक है।
00:54:42तो, हाँ, इस बार, यह FP16 सटीकता के साथ उस मॉडल को प्राप्त कर रहा है।
00:54:47वाई-फाई।
00:54:58इसमें समय लगने वाला है।
00:55:03ठीक है।
00:55:08हाँ, यह, क्योंकि यह हगिंग फेस से वेट्स डाउनलोड कर रहा है।
00:55:14हूँ?
00:55:17हाँ, तो, Molab है, जैसे, ऑनलाइन चल रहा है।
00:55:22हाँ।
00:55:23क्योंकि इसे हगिंग फेस के माध्यम से नेटवर्क कॉल करने और प्राप्त करने की आवश्यकता है।
00:55:30मुझे नहीं पता, जैसे, लेकिन इसे डाउनलोड होने में समय लग रहा है, शायद।
00:55:35ठीक है।
00:55:36ठीक है।
00:55:37ठीक है।
00:55:38ठीक है।
00:55:39ठीक है।
00:55:40तो, यहाँ हम देखते हैं, जैसे, मेमोरी का आकार FP16 सटीकता के साथ लगभग 15 GB है।
00:56:00हम int 8 के साथ, जैसा कि तल्मुद ने बात की थी, 2x संपीड़न करने का प्रयास कर रहे हैं।
00:56:15ठीक है।
00:56:16तो हम देखते हैं, जैसे आपकी मेमोरी का आकार अब, जैसे, 0.7, 0.5 GB है।
00:56:21इसका मतलब यह है कि अब आपके पास अपने KV को बढ़ने के लिए अधिक मेमोरी है।
00:56:27इसका मतलब है कि आप या तो उच्च संदर्भ सीमा (context limit) को हल कर सकते हैं या आप वहाँ अधिक समवर्ती उपयोगकर्ताओं (concurrent users) को संभाल सकते हैं।
00:56:36तो, यदि आप int 4 में करते हैं, तो मूल रूप से, आप 4x संपीड़न कर रहे हैं।
00:56:41तो, 4x संपीड़न के साथ, यह और भी कम होगा।
00:56:45यह होगा, मुझे लगता है कि लगभग 3 से 4 GB।
00:56:50हाँ, 4.5 GB।
00:56:51और, हाँ।
00:56:52तो, यह है, रुकिए।
00:56:53तो, यह सिर्फ एक बुनियादी प्लॉट है, जैसे, तो, ये, जैसे, सैद्धांतिक संख्याएँ हैं।
00:57:09हम यहाँ कोई थ्रूपुट परीक्षण नहीं कर रहे हैं।
00:57:12लेकिन, आमतौर पर, आप देखेंगे, जैसे आपकी मेमोरी बढ़ जाती है।
00:57:15तो आपके पास थोड़ा अधिक थ्रूपुट भी होगा।
00:57:21हमारे द्वारा अध्ययन किए गए कुछ बेंचमार्क से, हमने देखा, जैसे int 8 संपीड़न।
00:57:26इसमें, जैसे, कम थ्रूपुट होता है।
00:57:32ठीक है।
00:57:33और फिर, अटेंशन मैकेनिज्म पर, जैसे, एक डेमो है।
00:57:42तो, अटेंशन के लिए, ठीक है।
00:57:45मुझे इसे चलाना होगा।
00:57:58ठीक है।
00:57:59तो, यह चल गया है।
00:58:02ओह।
00:58:03रुकिए।
00:58:04यह क्यों कह रहा है कि कोई GPU नहीं मिला?
00:58:09मुझे कहना चाहिए कि GPU का पता लगाया जाना चाहिए।
00:58:18ओह।
00:58:19ठीक है।
00:58:29रुकिए।
00:58:30रुकिए।
00:58:30रुकिए।
00:58:50यह आश्चर्यजनक है।
00:58:57मुझे लगता है कि यह किसी कारण से GPU का पता लगाने में सक्षम नहीं है।
00:59:05हमारे पास यहाँ एक GPU है।
00:59:11ठीक है।
00:59:12कोई बात नहीं।
00:59:14हाँ।
00:59:14तो, लेकिन यहाँ मूल विचार यह था कि, जैसे आप अलग-अलग अटेंशन मैकेनिज्म का उपयोग करके,
00:59:26जैसे मल्टी-हेड से ग्रुप क्वेरी अटेंशन और फिर MLA की ओर बढ़ने के लिए गणना को संपीड़ित करने की दिशा में आगे बढ़ते हैं।
00:59:33आप कुछ अनुकूलन देखना शुरू कर देंगे।
00:59:38मुझे लगता है कि कल रात हम कुछ बेंचमार्किंग कर रहे थे।
00:59:43मैं इस हिस्से को सुधारना चाहता था।
00:59:45तो, यह 56x नहीं था।
00:59:48यह 14x था।
00:59:50मूल रूप से, डेमो में गणना की एक गलती थी, जैसे कि इसमें लेयर की संख्या से गुणा नहीं किया गया था।
01:00:02हाँ।
01:00:03तो, उसके लिए क्षमा चाहते हैं।
01:00:04तो, यह MLA आपके मल्टी-हेड अटेंशन की तुलना में लगभग 14x बचत है।
01:00:15तो अब जब हमें दर्द बिंदुओं (pain points), बुनियादी बातों, अनुकूलन के एक पक्ष, जो कि मॉडल अनुकूलन है, की समझ हो गई है, तो हम इस बारे में बात करना चाहते हैं कि आप सर्विसिंग पक्ष पर क्या कर सकते हैं।
01:00:31तो पहली बात यह है कि हमने देखा, जैसे जब आप एक साधारण डिकोड चरण निष्पादित करते हैं, तो आप इसे खींच रहे हैं, आप मूल रूप से मॉडल वेट को खींच रहे हैं और फिर आप सभी पिछले टोकन के लिए की और वैल्यू वेक्टर की पुनर्गणना कर रहे हैं।
01:00:50भले ही आपने सभी टोकन के लिए उन वैक्टर की गणना पहले ही कर ली हो।
01:00:55तो निश्चित रूप से, जैसे बहुत अधिक गणना बर्बादी होती है।
01:01:02और यदि आप इसकी समय जटिलता (time complexity) का विश्लेषण करते हैं, तो यह O of N स्क्वायर निकलेगी।
01:01:07और इसे हल करने का तरीका मेमोरी के खिलाफ एक क्लासिक ट्रेड-ऑफ है।
01:01:12आप टोकन के मुकाबले उन वैक्टर की मेमोरी को बनाए रख सकते हैं और आप उस मेमोरी को संदर्भित कर सकते हैं।
01:01:19तो, उस मेमोरी को KVCache कहा जाता था।
01:01:24और, प्रवाह कुछ इस तरह दिखता है।
01:01:27और फिर, इस KVCache के आधार पर, ऐसे चार अनुकूलन थे जो वास्तव में संभव थे।
01:01:35पहला पैक्ड अटेंशन (paged attention) के बारे में है।
01:01:42तो, अंतर क्या है, आज समस्या क्या है?
01:01:45तो, जब आप जीपीयू में इनपुट के रूप में कई अनुरोध भेजते हैं, तो ये अनुरोध एक बैच में होते हैं।
01:01:52प्रत्येक अनुरोध को एक निरंतर मेमोरी स्टोरेज आवंटित किया जाता है।
01:01:58मान लीजिए, मैं सिर्फ एक उदाहरण ले रहा हूँ, मान लीजिए, 2 केवी।
01:02:05हालाँकि, आपके अनुरोध को केवल, मान लीजिए, 1 केवी की आवश्यकता थी।
01:02:11तो, वहाँ मेमोरी का लगभग 50% हिस्सा खंडित (fragmented) हो जाता है।
01:02:19और यह खंडन (fragmentation) मुख्य रूप से मेमोरी की बर्बादी का कारण बनता है।
01:02:24इसका मतलब है कि मेमोरी में ऐसी जगह थी जहाँ आप अधिक अनुरोधों को संभाल सकते थे, लेकिन आप ऐसा नहीं कर सके क्योंकि आप मेमोरी के उस निरंतर (contiguous) ब्लॉक की तलाश कर रहे थे।
01:02:36तो, इसके लिए प्रेरणा ली गई थी कि ओएस (OS) कैसे काम करता है।
01:02:41जैसे, आप एक तार्किक (logical) मेमोरी बनाए रखते हैं और मूल रूप से आपके पास एक भौतिक (physical) मेमोरी होती है।
01:02:47तो, तार्किक मेमोरी में, ऐसा महसूस होता रहेगा कि हर टोकन के लिए केवी वेक्टर निरंतर (contiguous) है।
01:02:59लेकिन यह एक अलग भौतिक पते (physical address) पर मैप हो रहा होगा।
01:03:06तो, इससे वास्तव में बहुत अधिक मेमोरी बचाने में मदद मिली।
01:03:11और यह तभी संभव हुआ जब उन्होंने मेमोरी को ब्लॉकों के एक सेट के रूप में माना।
01:03:18और अनुरोधों की आवश्यकतानुसार आप उन ब्लॉकों को गतिशील रूप से (dynamically) आवंटित करेंगे।
01:03:22जैसे-जैसे नए टोकन आते हैं और उन्हें उस तरह की मेमोरी की आवश्यकता होती है।
01:03:27दूसरा तरीका यह है कि जब आप बैच में कई अनुरोध भेज रहे होते हैं,
01:03:39तो जीपीयू उन अनुरोधों को ले रहा होता है।
01:03:42लेकिन यह तब तक नए बैच को स्वीकार नहीं करता जब तक कि उस बैच के सभी अनुरोध पूरे नहीं हो जाते।
01:03:49तो, आरेख (diagram) अधिकृत मेमोरी जैसा दिखता है।
01:03:52लेकिन यहाँ यह इस बारे में अधिक है कि जीपीयू अगला बैच लेने के लिए कब उपलब्ध है।
01:03:59तो, एक ऐसी समयावधि होती है जहाँ जीपीयू वास्तव में बेकार (idle) बैठा रहता है।
01:04:04और आप इसे हल करना चाहते हैं।
01:04:08और इसके लिए, विचार यह था कि, ठीक है, निरंतर बैचिंग (continuous batching) करते हैं।
01:04:17तो, निरंतर बैचिंग ने थ्रूपुट में भी काफी मदद की क्योंकि अब आप अधिक अनुरोधों को काफी तेزی से भेज सकते हैं।
01:04:24यह सुनिश्चित करते रहें कि जीपीयू को हमेशा काम मिलता रहे, यह हमेशा व्यस्त रहे और बेकार न बैठे।
01:04:33तो, आप उस कंप्यूट (compute) की बचत कर रहे हैं।
01:04:36तीसरा है, प्रीफिक्स कैशिंग (prefix caching)।
01:04:39तो, आपको याद होगा, केवी कैश ने टोकन्स में एक ही अनुरोध के लिए गणना को बचाने में आपकी मदद की थी।
01:04:46लेकिन क्या होगा यदि कई अनुरोधों में आपके पास समान टोकन हों?
01:04:53आप मूल रूप से इसके खिलाफ कैसे बचत करते हैं?
01:04:55तो, प्रीफिक्स कैशिंग, जिसे VLLM द्वारा पेश किया गया था, ठीक इसी का मुकाबला करती है।
01:05:04और फिर तीसरा है, जैसे, हमने चौथे के बारे में बात की, वास्तव में।
01:05:10तो, हमने मॉडल को क्वांटाइज करने के बारे में बात की, लेकिन आप केवी वेट्स को भी क्वांटाइज कर सकते हैं।
01:05:21तो, इसका मतलब है कि अब आपको अपनी कुंजी (key) और मान (value) वैक्टर के लिए कम जगह की आवश्यकता है।
01:05:28इसका मतलब है कि आप मेमोरी में अधिक कुंजी और मान वैक्टर को संभाल सकते हैं।
01:05:32और इसका मतलब है कि आप अधिक टोकन परोस सकते हैं।
01:05:34इसका मतलब है कि आप अधिक संदर्भ सीमा (context limit) दे सकते हैं।
01:05:37और इसका मतलब है कि आप बेहतर मॉडल गुणवत्ता प्रदान कर सकते हैं।
01:05:41और यह सब VLLM में पहले से ही मौजूद है।
01:05:51आपको वास्तव में उस पहिए को फिर से आविष्कार करने की आवश्यकता नहीं है।
01:05:56और आप इस VLLM को प्रोडक्शन में तैनात कर सकते हैं और आप मूल रूप से वह वृद्धि देख सकते हैं।
01:06:03तो, आगे, हमारे पास एक बेंचमार्क है जो हमने किया था।
01:06:08तो, यह बेंचमार्क था, मुझे देखने दीजिए कि क्या वह मेरे पास है।
01:06:14यहाँ।
01:06:17डेमो।
01:06:22तो, इस बेंचमार्क को करने में लगभग एक घंटा लगता है क्योंकि आपको लगातार वीएलएलएम (VLLM) सर्वर को रोकना और पुनरारंभ करना पड़ता है और आपको मॉडल लोड करने होते हैं और सब कुछ करना पड़ता है।
01:06:35तो, परीक्षण करने में काफी समय लगता है, लेकिन मैं यहाँ वास्तव में आपको बता सकता हूँ कि हम क्या कर रहे हैं।
01:06:41तो, हमने मॉडल को वही रखा है, जैसे Mistral 7B।
01:06:46और फिर, हमारे पास इनपुट प्रश्नों का वह सेट है जिसे हम भेज रहे हैं।
01:06:53इन्हें प्रॉम्प्ट के रूप में मानें।
01:06:56फिर, हमारे पास यहाँ कुछ सहायक (helper) फ़ंक्शन हैं, जैसे यह जाँच करना कि सर्वर चालू है या नहीं।
01:07:01यह सर्वर VLLM सर्वर है।
01:07:04फिर, VLLM मेट्रिक्स प्राप्त करने के लिए सहायक फ़ंक्शन हैं।
01:07:09और मैं बात करूँगा कि वे मेट्रिक्स क्या हैं।
01:07:14फिर, बहुत सारे बेंचमार्क और अन्य चीजें हैं।
01:07:17और फिर, आपको केवी उपयोग (KV usage) और अन्य चीजों को मापना होगा।
01:07:22तो, ये सहायक फ़ंक्शन हैं।
01:07:24तो, बेसलाइन बहुत सरल है।
01:07:26जैसे, हमारे पास एक हगिंग फेस बेसलाइन है।
01:07:29यह एलएलएम को टेक्स्ट भेजना, प्रतिक्रिया वापस पाना जैसी कच्ची प्रक्रिया है।
01:07:36हम यहाँ कुछ परिणाम देखते हैं।
01:07:38हमने देखा कि हगिंग फेस का थ्रूपुट लगभग 51 टोकन प्रति सेकंड है।
01:07:44पहले टोकन का समय (Time to first token) लगभग 54 था।
01:07:46और फिर, इंटर-टोकन विलंबता (inter-token latency) 19 थी।
01:07:49यह सब H100 पर चलाया गया था।
01:07:56और फिर, हम एक बहुत ही डिफ़ॉल्ट VLLM सर्वर शुरू करते हैं।
01:08:00तो, डिफ़ॉल्ट रूप से, VLLM आपको पेज्ड अटेंशन, निरंतर बैचिंग और केवी कैशिंग प्रदान करता है।
01:08:08तो, तीन चीजें डिफ़ॉल्ट रूप से मौजूद होती हैं।
01:08:13और फिर, जब आप उन बेंचमार्क की तुलना करने का प्रयास करते हैं, तो आप देखते हैं कि आपका थ्रूपुट लगभग 15x है।
01:08:21आप प्रति सेकंड अधिक टोकन परोसने में सक्षम हैं।
01:08:24फिर, आपके पहले टोकन का समय, वह भी बढ़ जाता है।
01:08:34और फिर, इंटर-टोकन विलंबता, यह कम हो जाती है।
01:08:38और फिर, आपका केवी बनाम उपयोगकर्ता और संदर्भ (context) बढ़ जाता है।
01:08:43अब, जब आप इस पर प्रीफिक्स कैशिंग लागू करते हैं।
01:08:51तो, प्रीफिक्स कैशिंग के साथ, आप देखते हैं कि आपका थ्रूपुट और अधिक बढ़ जाता है।
01:08:57आपका TTFT कम हो जाता है।
01:08:59आपकी इंटर-टोकन विलंबता लगभग समान है।
01:09:02और फिर, उपयोगकर्ताओं के मुकाबले आपका केवी कैश उपयोग कम हो रहा है।
01:09:09संदर्भ (context) की तुलना में, यह कम नहीं हो रहा है।
01:09:12यह लगभग समान है।
01:09:14मुझे लगता है कि यह भी लगभग समान है।
01:09:16यह कोई बहुत बड़ी बात नहीं है।
01:09:19जब आप इसके ऊपर केवी क्वांटाइजेशन लागू करते हैं।
01:09:25तो, आप देखते हैं कि थ्रूपुट लगभग समान है।
01:09:33आपके पहले टोकन का समय समान है।
01:09:36आपकी टोकन विलंबता समान है।
01:09:39लेकिन फिर, आपका केवी उपयोग वास्तव में कम हो जाता है।
01:09:42ऐसा इसलिए है क्योंकि आपने अपने की-वैल्यू स्पेस को क्वांटाइज कर लिया है।
01:09:49और फिर, स्पेक्युलेटिव डिकोडिंग की एक अवधारणा है जिसके बारे में तन्मय बात करेंगे।
01:09:54तो, जब आप उनका बेंचमार्क करने का प्रयास करते हैं, तो आप यह भी देखते हैं कि वहाँ केवी का उपयोग थोड़ा कम होता है।
01:10:06हालाँकि परिणाम लगभग समान हैं।
01:10:08तो, हाँ, मेरा मतलब है, कुल मिलाकर, ये सभी मेट्रिक्स हैं।
01:10:21शायद मुझे ज़ूम आउट करना चाहिए।
01:10:25ठीक है।
01:10:26यह नहीं हो रहा है।
01:10:27ज़ूम आउट।
01:10:28यह काम नहीं कर रहा है।
01:10:29बढ़िया।
01:10:30तो, हाँ, ये VLLM बेंचमार्क हैं।
01:10:35वैसे, यह आपका प्रोडक्शन डिफ़ॉल्ट है।
01:10:38जब हम अन्य इंजन के बारे में बात करने का प्रयास करेंगे तो हम उस निर्णय वृक्ष (decision tree) को भी साझा करेंगे।
01:10:48तो, हाँ, हमें इस बारे में बात करनी चाहिए कि इसके अलावा हम और कौन सी इन्फेरेंस ऑप्टिमाइजेशन कर सकते हैं।
01:10:58और कौन-कौन से अन्य समाधान सामने आए।
01:11:02इसलिए मैं एक बार फिर तन्मय को आमंत्रित करना चाहूँगा।
01:11:07वह इनमें से कुछ ऑप्टिमाइजेशन के बारे में बात करने जा रहे हैं।
01:11:11ओह, माफ़ कीजिए।
01:11:12मुझे बहुत खेद है।
01:11:13मैंने स्लाइड्स सक्षम नहीं की थीं।
01:11:26क्या था?
01:11:27ठीक है।
01:11:28बढ़िया।
01:11:29उत्कृष्ट।
01:11:30कौन सा?
01:11:31स्पेक्युलेटिव डिकोडिंग।
01:11:32हाँ।
01:11:33शुक्रिया, हर्षल।
01:11:34हाँ।
01:11:35तो, ये सब स्पेक्युलेटिव डिकोडिंग हैं।
01:11:40ये सभी, जिसे हम कहते हैं, एक ही तरह के सोडे के अलग-अलग स्वाद हैं।
01:11:46तो, यह तकनीक डिकोडिंग एक्सीलरेटर के अंतर्गत आती है।
01:11:51तो पहला, हम केवल इस स्पेक्युलेटिव डिकोडिंग के बारे में बात कर रहे हैं, लेकिन इसके अन्य रूप भी हैं, जैसे सेल्फ-स्पेक्युलेटिव, ईगल (Eagle), मेडुसा।
01:12:01मुझे लगता है कि केवल यही, ईगल एल्गोरिदम पसंद है।
01:12:05तो आइए स्पेक्युलेटिव डिकोडिंग से शुरू करते हैं।
01:12:06ठीक है।
01:12:07ठीक है।
01:12:08तो आइए इस बात से शुरू करें कि स्पेक्युलेटिव डिकोडिंग क्या है।
01:12:09मुख्य समस्या यह है कि ट्रांसफॉर्मर आर्किटेक्चर में, ये सभी टोकन क्रमिक रूप से, एक-एक करके उत्पन्न होते हैं।
01:12:26क्यों न किसी छोटे मॉडल का उपयोग किया जाए और किसी छोटे मॉडल को शायद चार या पाँच टोकन उत्पन्न करने दिए जाएँ।
01:12:37और यह टीचर मॉडल, या हम कह सकते हैं, हमारे वर्ल्ड कप एल्गोरिदम के अनुसार, हम रेफरी कह सकते हैं।
01:12:43तो रेफरी तय करेगा कि वह कितने टोकन स्वीकार करता है।
01:12:48और यह लूप लगातार चलता रहता है।
01:12:51और हमारी धारणा यह है कि कुछ ऐसे डोमेन हैं जहाँ इस तरह की चीजें काम करेंगी।
01:12:59जैसे शायद कोडिंग में, जहाँ लगभग कोई रचनात्मकता (creativity) नहीं होती है।
01:13:05प्रत्येक कोड या सिंटैक्स लगभग समान होता है।
01:13:08तो शायद यह इसमें मदद कर सकता है।
01:13:10लेकिन व्यक्तिगत परीक्षण के आधार पर, मुझे यह स्पेक्युलेटिव डिकोडिंग बिल्कुल भी उपयोगी नहीं लगी।
01:13:18लेकिन, अन्य तकनीकें जैसे सेल्फ-स्पेक्युलेटिव डिकोडिंग, जहाँ टीचर मॉडल में भी एक हेड, सहायक हेड होता है, और यह बेस मॉडल या छोटे मॉडल की तरह ही काम करता है।
01:13:35लेकिन फिर यह EGLE आया, EGLE 1, 2, 3, मुझे नहीं पता इसके कितने संस्करण हैं, लेकिन यह सिर्फ यह कह रहा है कि टोकन जनरेट करने के बजाय, आइए एक छोटा मॉडल प्रशिक्षित करें और मुख्य मॉडल की परतों में से एक से अपनी विशेषताएँ लें ताकि टोकन जनरेट करने के बजाय, यह यह विशेषता जनरेट करे।
01:14:02इसलिए, अन्य प्रकार की तकनीकों की तुलना में EGLE बेहतर है।
01:14:10और फिर एक और MEDUSA है, जो सिर्फ यह कह रहा है कि इन सभी टोकन को समांतर रूप से जनरेट करें।
01:14:17ठीक है, तो यहाँ, इस स्लाइड में।
01:14:21हाँ।
01:14:22अगली स्लाइड।
01:14:24ठीक है।
01:14:25ठीक है।
01:14:26ठीक है, हाँ।
01:14:27ठीक है।
01:14:28अब हम आते हैं, अब हम इस पर आएंगे, प्रीफिक्स कैशिंग।
01:14:34तो, मुझे नहीं पता कि लोग इसका उपयोग कर रहे हैं या नहीं, स्टैटिक प्रीफिक्स कैशिंग।
01:14:39लेकिन बात यह है कि प्रीफिक्स कैशिंग की मुख्य समस्या यह है कि कभी-कभी हम टाइप करते हैं और एक छोटी सी गलती कर बैठते हैं।
01:14:47और यह मानक स्टैटिक प्रीफिक्स कैशिंग मूल रूप से एक प्रॉम्प्ट लेता है, कुछ हैशिंग करता है।
01:14:53और फिर अगली बार जब उपयोगकर्ता इसी तरह का प्रश्न पूछता है, तो यह हैश का मिलान करने का प्रयास करता है।
01:14:58इसलिए, यदि हैश बराबर है, तो यह उन सभी k और b की पुनर्गणना करने के बजाय, इसे सीधे स्टोरेज से ले लेगा।
01:15:09लेकिन, आप जानते हैं कि कभी-कभी हम गलती कर देते हैं या शायद हम एक शब्द या अक्षर बदल देते हैं, कुछ ऐसा ही।
01:15:15फिर हमारे पास कैश मिस हिट रेट बहुत अधिक होता है।
01:15:21इसलिए यह वाला, रेडिक्स ट्री।
01:15:25तो रेडिक्स ट्री बहुत लोकप्रिय हो रहा है और एजेंट के कारण भी।
01:15:30इसलिए, मुझे लगता है कि लगभग हर कोई एजेंट का उपयोग कर रहा है और अधिकांश गणना टेस्ट-टाइम, इन्फेरेंस के दौरान हो रही है।
01:15:38जहाँ हम एक ही तरह के प्रश्न और प्रॉम्प्ट बार-बार पूछते रहते हैं।
01:15:42उदाहरण के लिए, आप एक विशेषज्ञ सॉफ्टवेयर इंजीनियर हैं, गुणा 200 बार।
01:15:48इस प्रकार का लूप इस एजेंटिक प्रकार की चीज़ों के अंदर चलता रहता है।
01:15:55जहाँ रेडिक्स ट्री में इसी तरह की चीज़ों को रखना या संग्रहीत करना आवश्यक है।
01:16:03तो रेडिक्स ट्री इस प्रीफिक्स ट्री का सिर्फ एक उन्नत संस्करण है जहाँ यदि किसी नोड की कोई शाखा नहीं है तो हम उसे संक्षिप्त कर देंगे।
01:16:17और इस तरह के काम के लिए जहाँ हम एक ही चीज़ को बार-बार दोहराते हैं।
01:16:24यह रेडिक्स ट्री बहुत मदद करता है और sglang प्रीफिक्स कैशिंग के लिए इस तरह के एल्गोरिदम का उपयोग करता है।
01:16:35ठीक है, हाँ, फिर एक और चीज़ है।
01:16:38एक है टेंसर, RT, LLM।
01:16:41यह बहुत भ्रमित करने वाला है।
01:16:42जब मैंने पहली बार शुरुआत की थी, तो मैं भ्रमित था।
01:16:46टेंसर, RT, LLM क्या है?
01:16:49तो, हाँ, टेंसर, RT सिर्फ एक मानक SDK प्रकार की चीज़ है।
01:16:55टेंसर, RT, LLM सिर्फ एक इन्फेरेंस इंजन है।
01:16:59बिल्कुल VLM, sglang की तरह।
01:17:01लेकिन समस्या यह है कि यह NVIDIA से संबंधित है।
01:17:05उन्होंने प्रत्येक परत और हर समस्या को अनुकूलित किया है।
01:17:10जैसा कि मैंने हमारे विश्व कप एल्गोरिदम में उल्लेख किया है, उन्होंने हार्डवेयर स्तर पर भी सब कुछ तोड़ दिया और सब कुछ अनुकूलित कर लिया।
01:17:18तो, हाँ, ठीक है, अगला।
01:17:23हाँ, तो इस कार्यशाला के लिए, हमने कुछ बेंचमार्किंग भी की, जैसे कौन सा सबसे अच्छा है।
01:17:33तो हमारा सेटअप कुछ इसी तरह का था।
01:17:36इसलिए, हमने दो प्रकार के परीक्षण किए।
01:17:39पहला एजेंटिक परीक्षण के बिना है, जहाँ हम सिर्फ...
01:17:44तो हमने शेयर जीपीटी, इस डेटासेट का उपयोग किया, और VLM और sglang का उपयोग करके उन प्रश्नों को पूछा।
01:17:57ठीक है।
01:18:05हाँ, ठीक है।
01:18:07और मैं इसे ज़ूम इन कर देता हूँ।
01:18:12ठीक है, बढ़िया।
01:18:13ठीक है, हाँ, इस कार्यशाला के लिए, हमने H100 का उपयोग किया, और हमारा पहला परीक्षण यह था कि हमने सिर्फ पूछा...
01:18:23हमने शेयर जीपीटी से प्रश्न लिए और उन्हें VLM, sglang में डाला, और हमने पाया कि वास्तव में इसमें कोई सांख्यिकीय अंतर नहीं है कि कौन सा बेहतर है।
01:18:34तो दोनों में लगभग समान प्रकार...
01:18:37इसलिए, दोनों प्रति सेकंड समान प्रकार के अनुरोध, RTTFT और विलंबता को पूरा कर रहे हैं।
01:18:43लेकिन एकमात्र अंतर हमने एजेंटिक ब्रांचिंग के दौरान देखा।
01:18:50तो हमने जो किया वह यह था कि हमने इसी तरह का प्रश्न पूछा कि आप दुनिया के सर्वश्रेष्ठ सॉफ्टवेयर इंजीनियर हैं।
01:18:59तो बस शहर में ट्रैफिक जाम की समस्या का समाधान करें।
01:19:04फिर, हमने इसे LLM में डाला।
01:19:08LLM कुछ आउटपुट जनरेट करता है।
01:19:10फिर हमने राउंड टू भी किया।
01:19:13तो, एक बार जब यह LLM यह आउटपुट जनरेट कर लेता है, तो राउंड टू में, हमने विशेष रूप से उल्लेख किया कि...
01:19:22प्रस्ताव की समीक्षा करें और एक से दस तक रेटिंग दें।
01:19:28तो ये दो टर्न हमने किए, और यह लूप बार-बार दोहराता रहता है।
01:19:35हमने जो पाया वह यह है कि इस प्रकार के वर्कफ़्लो के लिए जहाँ सब कुछ मानक है, वे सभी प्रॉम्प्ट और संदर्भ इंजीनियरिंग तस्वीर में आते हैं।
01:19:47इसलिए, यदि हम इस उचित एजेंटिक ब्रांचिंग को करते हैं, तो मुझे लगता है कि यह HGLang तीन से चार गुना बेहतर है।
01:19:54लेकिन फिर से, यह शायद अलग-अलग सेटअप पर निर्भर करता है।
01:19:58यदि आप ऐसा करते हैं, तो आपको अलग परिणाम मिल सकते हैं।
01:20:02ठीक है।
01:20:03हाँ।
01:20:04तो, मुझे लगता है...
01:20:06क्या हमने इसे GitHub पर अपलोड किया?
01:20:08हाँ।
01:20:09ठीक है।
01:20:10हाँ।
01:20:11तो, पीडीएफ भी ड्राइव में है।
01:20:15यह स्लाइड्स जैसा ही लिंक है।
01:20:18तो यहाँ एक त्वरित सारांश है।
01:20:22तो, एक मानक API वर्कलोड थ्रूपुट पर, आप देखेंगे कि VLLM और SGLang एक जैसे होंगे।
01:20:31तो, यदि आपके पास...
01:20:33यदि आपके पास मानक वर्कलोड है, तो निश्चित रूप से VLLM के साथ जाएं।
01:20:36यह वैसे भी प्रोडक्शन डिफॉल्ट है।
01:20:38लेकिन तन्मय यह भी कह रहे थे कि जब आप इसे एजेंटिक वर्कलोड जैसा बनाने की कोशिश करते हैं, तो यहीं पर आपका SGLang वास्तव में चमकता है।
01:20:50और यह आपको एक तरह से सभी लाभ प्रदान करता है।
01:20:55तो, हाँ।
01:20:58VLLM को डिफ़ॉल्ट के रूप में रखें।
01:21:00लेकिन यदि आपके पास एजेंटिक वर्कलोड है, तो शायद SGLang की ओर बढ़ने का प्रयास करें।
01:21:05यदि आप VLLM भाग से खुश नहीं हैं।
01:21:09ठीक है।
01:21:10मुझे...
01:21:15रुकिए।
01:21:18ठीक है।
01:21:21और फिर जैसे...
01:21:29जैसे 120 बिलियन पर एक तुलना की गई है।
01:21:33जैसे GPT OSS 120 बिलियन के लिए।
01:21:36यह एक बेंचमार्क है जिसे PlayPy द्वारा तैयार किया गया था।
01:21:42तो, यहाँ एक ब्लॉग लिंक है।
01:21:46ओह, बढ़िया।
01:21:48ठीक है।
01:21:49हाँ।
01:21:50तो, उन्होंने ऐसा ही बेंचमार्क किया और इसमें टेंसरRT LLM को शामिल किया।
01:21:57निश्चित रूप से, आप हमेशा इन बेंचमार्क से गुजर सकते हैं और यह समझने का प्रयास कर सकते हैं कि मूल रूप से आपके उपयोग के मामले के अनुकूल क्या है।
01:22:05जैसा कि हमने उल्लेख किया है जैसे टेंसरRT, वे हार्डवेयर पक्ष को भी अनुकूलित करने का प्रयास करते हैं, जिसमें चरम हार्डवेयर प्रदर्शन होता है।
01:22:16और फिर इस बात के संदर्भ में कि जब आप अपने इंजन को चित्रित करना चाहते हैं, एक बार जब आप VLLM, SGLang, TencerRT के बीच पता लगा लेते हैं, तो कुछ नए इंजन उभर रहे हैं।
01:22:29निश्चित रूप से NVIDIA डायनेमो।
01:22:43तो वे एजेंटिक सत्र रूटिंग के लिए भी हैं।
01:22:49हगिंग फेस हमेशा मौजूद हैं।
01:22:51यह एक साधारण नोस ओवर है।
01:22:53फिर एक MSTAR इंजन है जिसे हाल ही में स्टैनफोर्ड द्वारा प्रस्तावित किया गया था।
01:23:00मल्टी-मॉडल के लिए NVIDIA डायनेमो।
01:23:05तो निश्चित रूप से आप उनका पता लगा सकते हैं।
01:23:08और जब आप मूल रूप से कोशिश करते हैं, तो एक त्वरित सारांश देने के लिए, हम एक बेसलाइन से शुरुआत करते हैं।
01:23:15हम यह पता लगाने की कोशिश करते हैं कि कौन सा मॉडल हमारे उपयोग के मामलों में फिट बैठ सकता है।
01:23:22तो आप DeepSeq जैसा कुछ चुन सकते हैं।
01:23:27आप ऐसा चुन सकते हैं, Mistral 7B मत चुनिए।
01:23:30मेरा मतलब है, यह अच्छा नहीं है।
01:23:32लेकिन, हाँ।
01:23:35तो आप अपना मॉडल चुनते हैं और आप छोटी मेमोरी रखना चाहते हैं और आप उस बड़े मॉडल को छोटी मेमोरी में फिट करने का प्रयास करना चाहते हैं।
01:23:44ताकि आप GPU लागत पर लागत बचा सकें।
01:23:47तो आप वह सारी क्वांटाइजेशन कर सकते हैं।
01:23:51फिर आप हुड के तहत सही सर्विसिंग इंजन का उपयोग करके वे सभी सर्विसिंग अनुकूलन लागू कर सकते हैं।
01:23:58तो, वह वास्तव में आपको वह थ्रूपुट प्रदान कर सकता है जो आप वास्तव में चाहते हैं।
01:24:07और अब, कुछ ऐसा जो आप घर वापस जाने के बाद कर सकते हैं क्योंकि हम वास्तव में यहाँ की सभी सामग्री पर नहीं जा सकते हैं, वह निश्चित रूप से कुछ स्रोत जानकारी जैसे विभिन्न ध्यान तंत्र, इन इंजनों में से विभिन्न के बारे में पढ़ना है।
01:24:27जैसे ऑनलाइन मौजूद विभिन्न बेंचमार्क को पढ़ने का प्रयास करें।
01:24:34और फिर, बहुत सारे गहन गाइड या इसके अगले चरण हैं जो कुछ KV निष्कासन रणनीतियों के बारे में सीखना है।
01:24:45तो दुनिया एक अलग KV कैश इंजीनियरिंग डोमेन रखने की दिशा में आगे बढ़ रही है।
01:24:50तो आप समझना चाहते हैं कि वहाँ क्या चल रहा है।
01:24:52तो, KV इविक्ट, कैश कम्प्रेशन, हाइब्रिड मेमोरी।
01:24:57तो वहाँ बहुत सारे समाधान हो रहे हैं।
01:25:01इसलिए हमेशा उन बुनियादी बातों या मूल सिद्धांतों पर बने रहने का प्रयास करें।
01:25:08और यह देखने का प्रयास करें कि कौन सा समाधान मूल रूप से किस समस्या को हल करता है और क्या आपको वास्तव में अपने उपयोग के मामले के लिए उस समस्या को हल करने की आवश्यकता है।
01:25:17और फिर, वितरित LLM इन्फेरेंस है जो कुल मिलाकर एक अलग बिंदु है।
01:25:26आपको शायद वहाँ भी सभी आंतरिक चीज़ों पर जाने, सभी व्यावहारिक काम करने के लिए दो घंटे की कार्यशाला की आवश्यकता होगी।
01:25:40हाँ, और यह कुछ ऐसा है जिसे हम AI इंजीनियर न्यूयॉर्क सत्र के लिए प्रस्तावित करने का प्रयास कर रहे हैं जो LLM इन्फेरेंस के उन्नत अनुभागों में गहराई से उतरना है।
01:25:51तो यह कार्यशाला शुरुआती और मध्यम स्तर के लिए अधिक थी।
01:25:55तो, इस फॉर्म में हमारे पास फीडबैक और रुचि दोनों के लिए विकल्प हैं।
01:26:02अगर आपको लगता है कि कुछ हिस्सों में सुधार की जरूरत है, तो निश्चित रूप से वह फीडबैक भी दें।
01:26:09और यदि आप इस वर्कशॉप को न्यू यॉर्क फेयर में देखना चाहते हैं, तो कृपया अपनी रुचि अवश्य दर्ज करें।
01:26:22हैं?
01:26:24ओह, यह कैसे संभव है?
01:26:27बूम।
01:26:32मुझे जरा जांच लेने दीजिए।
01:26:37ठीक है।
01:26:38क्या?
01:26:39हाँ।
01:26:40यूआरएल काम कर रहा है ना?
01:26:41हाँ।
01:26:42क्यूआर कोड नहीं?
01:26:43ठीक है।
01:26:44शायद मैं उन दोनों को आपस में जोड़ना भूल गया।
01:26:45ठीक है।
01:26:46बढ़िया।
01:26:46हाँ।
01:26:47तो, अगर आप वह दे सकें।
01:26:49ठीक है।
01:26:50बढ़िया।
01:26:51हाँ।
01:26:52तो, अगर आप वह दे सकें।
01:26:53ठीक है।
01:26:54हाँ।
01:26:55ठीक है।
01:26:56बढ़िया।
01:26:57हाँ।
01:26:58तो, अगर आप वह दे सकें।
01:26:59मुझे बस।
01:27:00ठीक है।
01:27:00ठीक है।
01:27:01बढ़िया।
01:27:02हाँ।
01:27:02तो, अगर आप वह दे सकें।
01:27:03मुझे बस।
01:27:04ठीक है।
01:27:05वह ठीक रहेगा।
01:27:06अरे, और हाँ, मुझे लगता है कि हमें अब इस वर्कशॉप को समाप्त करना चाहिए।
01:27:13और मुझे यकीन है कि आप में से कई लोगों के पास बहुत सारे सवाल होंगे।
01:27:14तो, हम उन सबका उत्तर ऑफ़लाइन दे सकते हैं।
01:27:15हम मिल सकते हैं, और उन सवालों पर चर्चा कर सकते हैं।
01:27:16हाँ।
01:27:17ज़रूर।
01:27:18ज़रूर।
01:27:19अरे, आप सभी का धन्यवाद।
01:27:20जुड़ने के लिए धन्यवाद।
01:27:21मुझे लगता है कि यह वास्तव में।
01:27:22अरे, आप सभी का धन्यवाद।
01:27:23अरे, आप सभी का धन्यवाद।
01:27:24जुड़ने के लिए धन्यवाद।
01:27:25अरे, आप सभी का धन्यवाद।
01:27:26जुड़ने के लिए धन्यवाद।
01:27:27मुझे लगता है कि यह वास्तव में।
01:27:28ओह, ठीक है।
01:27:29अरे, ठीक है।
01:27:30वह ठीक रहेगा।
01:27:31अरे, और हाँ, मुझे लगता है कि हमें अब इस वर्कशॉप को समाप्त करना चाहिए।
01:27:33अरे, और हाँ, मुझे लगता है कि हमें अब इस वर्कशॉप को समाप्त करना चाहिए।
01:27:36और मुझे यकीन है कि आप में से कई लोगों के पास बहुत सारे सवाल होंगे।
01:27:39तो, हम उन सबका उत्तर ऑफ़लाइन ले सकते हैं।
01:27:41हम मिल सकते हैं, और उन सवालों पर चर्चा कर सकते हैं।
01:27:42हाँ, बिल्कुल।
01:27:43अरे, आप सभी का धन्यवाद।
01:27:44मुझे लगता है कि यह बहुत सार्थक रहा और आप सभी यहाँ आए।
01:27:49अरे, बहुत-बहुत धन्यवाद।
01:27:50हाँ, शुक्रिया।
커뮤니티 글
아직 글이 없습니다. 이 영상에 대한 첫 번째 글을 작성해 보세요!
이 영상에 대해 글쓰기