छोटे मॉडलों के लिए बड़े क्लस्टर — डैनियल स्वोनावा, सुपरलिंक्ड
AAI Engineer
Computing/SoftwareSmall Business/StartupsInternet Technology
Transcript
00:00:00समीक्षक: डेनिस आरक्यू
00:00:12ठीक है।
00:00:14मुझे लगता है कि आप लोग मुझे सुन सकते हैं।
00:00:15मैं खुद को निश्चित रूप से सुन सकता हूँ।
00:00:19जो भी पास आएगा उसे एक टी-शर्ट मिलेगी।
00:00:21मेरा यही मतलब था।
00:00:22यहाँ एक बैग भरा हुआ टी-शर्ट्स का रखा है।
00:00:25और सवालों के लिए भी।
00:00:26शायद अंत में कुछ सवाल भी होंगे।
00:00:28अगर आप सवाल पूछेंगे, तो आपको भी टी-शर्ट मिलेगी।
00:00:31और अगर आप अंदाज़ा लगा सकें कि इस स्लाइड के बैकग्राउंड में क्या है,
00:00:35तो आपको भी टी-शर्ट मिलेगी।
00:00:39कोई अंदाज़ा?
00:00:42यह क्या दर्शाता है?
00:00:44बैकग्राउंड में यह तस्वीर।
00:00:49नहीं?
00:00:50क्या किसी ने ट्रांसफॉर्मर मॉडल देखा है?
00:00:55हाँ, पॉजिशनल एनकोडिंग।
00:00:57बहुत अच्छे।
00:00:58आपको टी-शर्ट मिलती है, सर।
00:00:59ठीक है।
00:01:00तो आज हम मुख्य रूप से छोटे ओपन-सोर्स मॉडल्स पर चर्चा करेंगे और यह कि वे अब कितने बेहतरीन हैं और कैसे वे अनूठी चुनौतियाँ पैदा करते हैं जब आप अपने खुद के क्लाउड में उनमें से कई को सर्व करना चाहते हैं।
00:01:15हम जिस भी चीज़ पर चर्चा करेंगे वह एक तरह से ओपन-सोर्स है।
00:01:19इसे खुद करें।
00:01:20यह इस तरह की चीज़ है जहाँ आप बस, जानते हैं, एक कमांड चला सकते हैं और पूरे स्टैक के मालिक बन सकते हैं।
00:01:26तो यहाँ पहेली का कोई भी हिस्सा प्रोप्राइटरी, आप जानते हैं, नहीं है।
00:01:31आइए इसकी शुरुआत करते हैं।
00:01:33ठीक है।
00:01:34ठीक है।
00:01:35यह काम करता है।
00:01:36ठीक है।
00:01:37तो छोटे मॉडल।
00:01:38छोटे मॉडलों से हमारा क्या मतलब है?
00:01:40आप जानते हैं, आप जिससे भी पूछें, उसके आधार पर, मैं इसके बारे में ऐसे सोचता हूँ कि ये मूल रूप से ऐसे मॉडल हैं जिन्हें आप दो-तीन पीढ़ी पुराने एनवीडिया हार्डवेयर पर चला सकते हैं।
00:01:49पूरा मॉडल एक जीपीयू में फिट हो जाता है और इसलिए इन्हें सर्व करना आसान होता है।
00:01:56वे जीपीयू उपलब्ध हैं और वे किफायती भी हैं।
00:02:01और फिर ज़्यादातर लोग सोचते हैं, ठीक है, छोटे मॉडल, परिणामों की गुणवत्ता के मामले में कुछ ना कुछ समझौता करना पड़ेगा।
00:02:10और उम्मीद है कि मैं इस बातचीत में आपको यह समझाने में अच्छा काम कर पाऊँगा कि वास्तव में विशिष्ट कार्यों के लिए, आप फ्रंटियर या फ्रंटियर से आगे के प्रदर्शन पर हो सकते हैं और अन्य सभी स्पष्ट लाभ प्राप्त कर सकते हैं, है ना?
00:02:22लागत की भारी बचत और संभावित रूप से काफी बड़े विलंबता या थ्रूपुट सुधार, बिल्कुल।
00:02:35तो यह उन चार्टों में से एक है जिन्हें हम दिखाना पसंद करते हैं।
00:02:38यह समय के साथ आर्टिफिशियल एनालिसिस इंटेलिजेंस इंडेक्स है।
00:02:42और वे आमतौर पर आपको जो नहीं दिखाते हैं वह यह है कि ओपन-सोर्स मॉडलों का एक ब्रेकडाउन है जिसके बारे में आपको सोचना चाहिए, है ना?
00:02:49वहाँ GLM 5.2 इत्यादि हैं, मान लीजिए 750 बिलियन पैरामीटर वाले उन प्रकार के फ्रंटियर ओपन-सोर्स मॉडल।
00:02:57लेकिन फिर छोटे ओपन-सोर्स मॉडल हैं जो बड़े वाले और फ्रंटियर के पीछे-पीछे चल रहे हैं।
00:03:04आप देख सकते हैं कि आजकल फ्रंटियर को कम रिटर्न मिल रहे हैं और छोटे मॉडल आगे निकल रहे हैं, है ना?
00:03:10तो आप इस तरह का अभिसरण, शीर्ष पर संतृप्ति और छोटे मॉडलों की वृद्धि देखते हैं।
00:03:16और, आप जानते हैं, मान लीजिए QN 3627B, GPT 5.1 के प्रदर्शन के आसपास कहीं है।
00:03:23तो यदि आपके पास कोई वर्कफ़्लो है, कोई पाइपलाइन है जो, आप जानते हैं, GPT 5.1 के साथ चल सकती है,
00:03:29अब आप इसे एक छोटे मॉडल पर ले जा सकते हैं और, आप जानते हैं, चर्चा किए गए सभी लाभ प्राप्त कर सकते हैं।
00:03:35तो छोटे मॉडल, अब कमतर नहीं हैं।
00:03:38अब, यह इस बारे में भी है कि आप छोटे मॉडलों का उपयोग कैसे करते हैं, है ना?
00:03:44तो आप उस 27 बिलियन पैरामीटर वाले QN 36 को अपने किसी पूरी तरह से सामान्यीकृत, मैं आपको कुछ भी करने के लिए प्रॉम्प्ट कर सकता हूँ, प्रकार के मॉडल के रूप में नहीं पढ़ सकते।
00:03:53नहीं, आपको उस दृष्टिकोण को अपनाना होगा जहाँ आप मूल रूप से सामान्यीकृत मॉडल वर्कलोड से कार्यों के टुकड़े का पता लगाते हैं।
00:04:00और फिर प्रति कार्य, आप पता लगाते हैं कि ओपन-सोर्स में कौन सा मॉडल उस कार्य के लिए सबसे उपयुक्त है।
00:04:05आप कुछ मूल्यांकन चलाते हैं, शायद कुछ अनुकूलन जिसकी हम चर्चा करेंगे।
00:04:08और फिर, आप जानते हैं, इस तरह आप वास्तव में इसे उत्पादन में धकेलने के लिए सही गुणवत्ता तक पहुँचते हैं।
00:04:15तो यहाँ एक अनुबंध समीक्षा एजेंट का कुछ उदाहरण दिया गया है जो, आप जानते हैं, नौ अलग-अलग मॉडलों का उपयोग करता है।
00:04:20यह उस प्रकार का आकार है जो आपको अपने वर्कलोड और अपने एजेंटों में दिखाई देगा जब आप अपने सेटअप के लिए छोटे मॉडलों का उपयोग करने की ओर बढ़ेंगे।
00:04:28आप देखना शुरू करेंगे कि, ठीक है, अलग-अलग अनुरोधों के झुंड या एक मॉडल के साथ एक एपीआई को हथौड़े से मारने के बजाय,
00:04:36आप इसके बजाय मॉडलों के बेड़े का उपयोग करना चाहेंगे।
00:04:38और फिर आपकी समस्या यह है, ठीक है, मैं इन सभी अलग-अलग चीज़ों को इस तरह से कैसे सर्व करूँ कि मेरे इंफ्रा लोग पागल न हो जाएँ, है ना?
00:04:45और यह सिर्फ उन एजेंटों में से एक है जिसे आप चला रहे हो सकते हैं।
00:04:48और आपकी कंपनी में इनमें से, आप जानते हैं, 10 हो सकते हैं।
00:04:51तो हम किस प्रकार, आप जानते हैं, बुनियादी ढांचा दायरे का विस्तार इस प्रकार का है।
00:04:57अब, उन सभी विभिन्न कार्यों में जिनका मैंने उल्लेख किया है, एक ओपन-सोर्स मॉडल है जो उपयोग किए जाने की प्रतीक्षा में बैठा है।
00:05:05OCR से लेकर दस्तावेजों पर प्रश्न उत्तर देने तक, छवियों को लेबल करने, SQL उत्पन्न करने, कोड की समीक्षा करने तक।
00:05:14उन कार्यों के लिए ओपन-सोर्स मॉडल फाइन-ट्यून और प्रशिक्षित किए गए हैं।
00:05:19आप जानते हैं, यदि आप ऐसे ओपन-सोर्स मॉडल का उपयोग करते हैं जिसे वियतनामी में रसीदों पर OCR करने के लिए प्रशिक्षित किया गया है, तो उस प्रोजेक्ट ने वियतनामी में सबसे अधिक रसीदें देखी हैं, है ना?
00:05:28कोई ऐसा व्यक्ति है जिसने, जैसे, अधिक से अधिक डेटा एकत्र करने के लिए समय निकाला।
00:05:32और उस कार्य पर, वह मॉडल लगभग किसी भी अन्य चीज़ से बेहतर प्रदर्शन करेगा।
00:05:35और हगिंग फेस पर सैकड़ों-हजारों मॉडल हैं जो ऐसे दिखते हैं, है ना?
00:05:41तो यह बस, यह सब वहीं बैठा है और यह सब मुफ़्त है, मूल रूप से, ज्यादातर काफी अनुमत लाइसेंस।
00:05:46तो मॉडल मौजूद हैं, आप जानते हैं, यह बाधा नहीं है।
00:05:50और, आप जानते हैं, हम 2024 से ओपन-सोर्स AI के बारे में बात कर रहे हैं।
00:05:56और अब तक यह वास्तव में नहीं हो रहा है।
00:05:59और जिस हद तक यह कंपनियों में हो रहा है, यह मूल रूप से इसके बराबर है, जैसे ओपन-सोर्स AI का मतलब AWS Bedrock है।
00:06:05सिवाय इसके कि जब आप Bedrock में मॉडल कैटलॉग को देखते हैं, तो यह उपलब्ध मॉडल प्रकारों में बहुत, आप जानते हैं, संयमित है।
00:06:14ये मॉडल पुराने हैं, अक्सर, आप जानते हैं, अत्याधुनिक से दो-तीन साल पीछे।
00:06:19और जब आप Bedrock में किसी भी प्रकार का फाइन-ट्यूनिंग करते हैं, तो वास्तव में आपके पास फाइन-ट्यून या प्रशिक्षित कलाकृतियाँ नहीं होती हैं।
00:06:25इसलिए आप, आप जानते हैं, इसे अपने व्यवसाय में वास्तविक लाभ के रूप में उपयोग नहीं कर सकते।
00:06:29यह एक तरह से Bedrock इंफ्रा से सर्व करना जारी रखता है।
00:06:32तो यह अब प्रोप्राइटरी पर है, यदि आप ओपन-सोर्स बुनियादी ढाँचे पर छोटे मॉडल सर्विंग करते हैं, VLLM, SGLang, विभिन्न समाधान,
00:06:41बस यह जान लें कि ये चीज़ें किसी विशिष्ट मॉडल या किसी विशिष्ट हार्डवेयर मॉडल संयोजन के लिए ट्यून नहीं की गई हैं।
00:06:48आपको ट्यूनिंग करनी होगी, है ना? यह डू-इट-योरसेल्फ है।
00:06:51ये सभी उपकरण इस बात पर गाइड के साथ आते हैं कि वास्तव में ट्यूनिंग कैसे करें, पैरामीटर स्वीप, आपके ट्रैफ़िक के अनुकूल बनाना, इत्यादि।
00:07:00जब भी आप इनमें से किसी एक टूल को अपनाने का प्रयास करते हैं तो यह एक प्रकार की ओपन-एंडेड शोध परियोजना होती है।
00:07:05तो यह वास्तव में ऐसी चीज़ नहीं है, तरह से, आप इसे लेते हैं और यह एक इंजीनियरिंग प्रोजेक्ट की तरह है,
00:07:10और एक हफ्ते बाद आपके पास एक उच्च-प्रदर्शन सर्वेक्षण बुनियादी ढांचा है।
00:07:14यह इस तरह काम नहीं करता है।
00:07:15और यह ओपन-सोर्स टूल के साथ एक तरह की विशिष्ट समस्या है, है ना?
00:07:19यह थोड़ा सा, जैसे, बहुत अधिक डू-इट-योरसेल्फ है।
00:07:21और फिर, छोटे मॉडलों के लिए इस प्रकार पूर्व-ट्यून न होने के अलावा, छोटे मॉडल वर्कलोड और ट्रैफ़िक जो कई अलग-अलग मॉडलों का उपयोग करते हैं
00:07:32अनुमान प्रकार के समूहों के लिए समीकरण को एक तरह से पलट देता है, है ना?
00:07:37तो सामान्य तौर पर, जब आप एक बड़े मॉडल को सर्व करने का प्रयास करते हैं, तो आपकी समस्याएँ होती हैं, मैं उस मॉडल को कई GPU में कैसे साझा करूँ?
00:07:44शीर्ष पर एक ऐसा राउटर कैसे हो जो इन सभी श्रमिकों की स्थिति को समझता हो, आप जानते हैं, KVCache स्थिति और इसी तरह,
00:07:51और फिर यह एक टॉप-डाउन रूटिंग निर्णय लेता है कि, ठीक है, यह अनुरोध इस कार्यकर्ता या श्रमिकों के इस समूह में जाता है इत्यादि, है ना?
00:07:59यह एक बहुत ही टॉप-डाउन सेटअप है।
00:08:01लेकिन अगर आपके पास छोटे और तेज़ अनुरोध हैं, और उनमें से कई हैं, तो इस प्रकार का टॉप-डाउन रूटिंग बाधा बन जाता है, है ना?
00:08:09क्योंकि राउटर के पास कार्यकर्ता की स्थिति का थोड़ा पुराना संस्करण होता है, और श्रमिकों को संतृप्त करना वास्तव में कठिन होता है
00:08:16यदि आपके पास शीर्ष पर उस प्रकार का अग्रिम निर्णय है जिसे इनमें से प्रत्येक कार्यकर्ता पर स्थानीय कतारों को संतुलित करने के मामले में पूरी तरह से सही होना है।
00:08:26क्योंकि कई छोटे अनुरोध हैं, है ना?
00:08:29और, आप जानते हैं, जैसे, हमने छोटे मॉडलों और इस प्रकार के ट्रैफ़िक के लिए VLM और SGLang राउटर के साथ प्रयोग किया है,
00:08:37और निरंतर भार के तहत अपने GPU उपयोग को 20%, 30% से अधिक प्राप्त करना बहुत कठिन है।
00:08:44और समस्या यह है कि वे बैच ठीक से आकार के नहीं होते हैं, मूल रूप से, क्योंकि आपके पास वह रूटिंग बाधा है।
00:08:51और फिर तीसरी समस्या यह है कि छोटे मॉडलों के साथ, आपको LORAS और सामान्य रूप से मॉडल अनुकूलन से बहुत लाभ होता है।
00:08:57और इसलिए आपके पास जिस ट्रैफ़िक को सर्व करना है, उसमें (आप जानते हैं) लोग आपके पास आते हैं और कहते हैं,
00:09:03“अरे, मेरे पास 10 LORAS हैं। हम अपने सर्विंग स्टैक के साथ इसका उपयोग कैसे करें?”
00:09:08या, “मेरे पास यह कस्टम फाइन-ट्यून है जो मैंने कल रात बनाया था। आप जानते हैं, मैं इसे उत्पादन में सर्व करना चाहता हूँ।”
00:09:14और उन LORAS को वहाँ ऊपर लाने में AI इंजीनियर और बुनियादी ढांचे के व्यक्ति के बीच यह बातचीत,
00:09:21कस्टम मॉडल वहाँ ऊपर, वह चीज़ है जो समय लेती है।
00:09:24और मूल रूप से, संगठनात्मक वेग में वह मुख्य हत्यारा बात कर रहा है, है ना?
00:09:30जैसे आदर्श रूप से, आप चाहेंगे कि बुनियादी ढांचा इंजीनियर अपना काम करें, और आप चाहेंगे कि वे AI इंजीनियर अपना काम करें।
00:09:37और उन्हें दिन-प्रतिदिन के मोड में संचालित करने के लिए बात करने की आवश्यकता नहीं है।
00:09:41तो, आप जानते हैं, वे मूल रूप से एक-दूसरे को नहीं रोक रहे हैं।
00:09:45और छोटे मॉडलों के आसपास मॉडल अनुकूलन की इस प्रकार की इच्छा इसे तोड़ देती है और बहुत आगे-पीछे बनाती है।
00:09:51और यह एक समस्या है, है ना?
00:09:54तो ये कुछ ऐसी चुनौतियाँ हैं जो इस बात से जुड़ी हैं कि, ठीक है, हमारे पास कई छोटे मॉडल हैं।
00:09:58हमारे पास एक क्लस्टर कैसे हो? हम इसे कुशलता से कैसे सर्व करें?
00:10:02तो हम काफी समय से इस समस्या पर काम कर रहे हैं।
00:10:05दरअसल, मैं सुपरलिंक्ड से डेनियल हूँ। मैंने परिचय छोड़ दिया था।
00:10:09तो हम, सैन फ्रांसिस्को की एक वीसी-समर्थित कंपनी हैं।
00:10:13और हम पिछले कुछ वर्षों से एआई-संचालित सर्च, डॉक्यूमेंट प्रोसेसिंग सिस्टम और एजेंट बना रहे हैं।
00:10:20और हमारी मुख्य समस्या हमेशा इन्फेंस रही है, खास तौर पर वे समस्याएँ जिनका मैंने वर्णन किया है।
00:10:26इसलिए हमने अलग-अलग वातावरणों में छोटे मॉडलों के बड़े और व्यापक बेड़े को चलाने के लिए क्लस्टर की विभिन्न टोपोलॉजी पर बार-बार विचार और अन्वेषण किया है।
00:10:37क्योंकि कभी-कभी आपको किसी ऐसे वातावरण में किसी प्लेटफॉर्म के साथ तैनाती करनी होती है जहाँ पता नहीं क्या उपलब्ध है।
00:10:44छोटे मॉडल इसे आसान बनाते हैं क्योंकि किसी भी वातावरण में आप कुछ L4 या छोटे GPU कोटा प्राप्त कर सकते हैं जो बहुत आसान है।
00:10:52तो यह एक तरह से -- मैं उस क्लस्टर की टोपोलॉजी के बारे में थोड़ा बताऊंगा जिस पर हम पहुँचे हैं।
00:10:58और वैसे, यह पूरी चीज़ Apache 2.0 है, पूरी तरह से ओपन सोर्स।
00:11:03आप लोग इसे ले सकते हैं और इसे रैप कर सकते हैं और अब आप एक इन्फेंस स्टार्टअप हैं।
00:11:08यह कंट्रोल प्लेन से लेकर GPU पर चलने वाली चीज़ तक पूरी तरह से ओपन सोर्स है।
00:11:14तो हमने इसमें कोई कसर नहीं छोड़ी है।
00:11:18और इसकी टोपोलॉजी यह है कि मूल रूप से एक गेटवे होता है।
00:11:21और एक राउटर होने के बजाय जो यह पहले से तय करता है कि क्या कहाँ जाएगा, एक गेटवे होता है जो कुछ अनुरोधों को पार्स करता है और अनुरोध में कुछ मेटाडेटा जोड़ता है।
00:11:30उस अनुरोध को एक साझा कतार में और कुछ साइड चैनलों में डालता है।
00:11:36मैं इसके बारे में थोड़ा विस्तार से बताऊंगा।
00:11:37और फिर वर्कर डेटा को वर्कर तक धकेलने के बजाय उस केंद्रीकृत कतार से खींचते हैं।
00:11:44और इस तरह वे खुद को बेहतर तरीके से संतृप्त कर सकते हैं।
00:11:47और फिर वर्कर सेटअप -- मुझे लगता है कि इसके लिए मेरे पास एक स्लाइड है -- यह बताएगा कि हम विभिन्न मॉडल आर्किटेक्चर की जटिलता को कैसे समाहित करते हैं
00:11:57Workers के एक ऐसे सुसंगत समूह में, जिनमें आपस में मुकाबले वाली Python आवश्यकताएँ और इस तरह की चीज़ें न हों।
00:12:03तो यह कुल मिलाकर इसकी टोपोलॉजी है।
00:12:06और यह एक अनुरोध का जीवनचक्र जैसा है।
00:12:11तो शायद मैं यहाँ से कुछ चीज़ों का उल्लेख करूँ।
00:12:15OpenAI प्रकार के API मानक के बारे में हमें जो चीज़ पसंद नहीं है, वह है base64 एनकोडेड प्रकार का JSON।
00:12:25छोटे मॉडलों के लिए अच्छा नहीं है, उच्च थ्रूपुट के लिए अच्छा नहीं है।
00:12:28इसलिए हम हर जगह मैसेज पैक का उपयोग करते हैं, एक बाइनरी प्रारूप की तरह।
00:12:31इस तरह हम वास्तविक API गेटवे के माध्यम से सभी मल्टीमॉडल डेटा को भी आगे बढ़ा सकते हैं।
00:12:37तो ऐसा नहीं है कि, अरे, यहाँ बाइनरी डेटा है और फिर यहाँ अनुरोध है।
00:12:42और फिर क्लस्टर को कुछ बाइनरी डेटा, छवियों या वीडियो को लोड करना शुरू करने के लिए आपके क्लाउड स्टोरेज तक पहुँच की आवश्यकता होती है।
00:12:48हम इसे किसी तरह एन्कोड करते हैं और इसे गेटवे के माध्यम से आगे बढ़ाते हैं।
00:12:53और फिर गेटवे आंतरिक कतार को जाम न करने के लिए इनमें से कुछ भारी टुकड़ों को अलग करता है और अनुरोध के कतार में होने के दौरान क्लाउड स्टोरेज पर इसे स्थगित कर देता है।
00:13:02इसलिए यह इनमें से कुछ ऐसे अनुरोधों को विभाजित करता है जो, मान लीजिए, एक मेगाबाइट से अधिक हैं और फिर बैकएंड में क्लाउड स्टोरेज का उपयोग करता है।
00:13:09लेकिन एक उपयोगकर्ता के रूप में, आप अपने सभी बिट्स और बाइट्स को API परत में धकेलते हैं और इसकी वजह से यह एक साफ-सुथरा इंटरफ़ेस है।
00:13:19तो मूल रूप से पूरा स्टैक REST है, इसलिए गेटवे REST है, वर्कर REST है, और फिर एक सॉकेट पर, स्थानीय रूप से, यह विभिन्न रनटाइम्स से जुड़ता है।
00:13:30और हमारे पास रनटाइम के रूप में मुख्य रूप से PyTorch, Candle और SGLang हैं।
00:13:35और फिर जब हम ऑप्टिमाइज़ेशन करते हैं, तो मैं इस बारे में बात करूंगा कि हम कैसे सुनिश्चित करते हैं कि हम जिस किसी भी रनटाइम का उपयोग कर रहे हैं
00:13:43और उस रनटाइम में जो भी कोड चल रहा है, वह सबसे कुशल हो।
00:13:47इसके लिए मूल रूप से हमारे पास एक ऑटो-रिसर्च लूप है।
00:13:50लेकिन हाँ, तो एक अनुरोध का जीवनचक्र कुछ ऐसा दिखता है।
00:13:54और एक बात यह है कि आप वास्तव में यह सुनिश्चित करना चाहते हैं कि गेटवे जिस पर अनुरोध सबसे पहले पहुँचता है, वह बहुत अधिक काम न करे।
00:14:05क्योंकि तब यह एक बॉटमलेक बन जाता है, है ना?
00:14:07इसलिए आप पूरे अनुरोध को पार्स भी नहीं करना चाहते हैं।
00:14:09आप पैकेट को देखना चाहते हैं और आने वाली चीज़ के सामान्य आकार का पता लगाना चाहते हैं, एनोटेशन करना चाहते हैं,
00:14:16और फिर आपके पास वर्कर्स हैं, आपके पास जितने भी वर्कर हैं, सैकड़ों GPU जो कतार की स्थिति को देखते हैं और फिर वहाँ से खींचते हैं।
00:14:25और कतार NATS Jetstream का उपयोग करती है, और वह चीज़ प्रति सेकंड दस लाख अनुरोध कर सकती है।
00:14:32जैसे, इसके लिए बॉटमलेक बनना बहुत कठिन है।
00:14:35तो, हाँ, आदर्श रूप से आप इन सभी विभिन्न घटकों से गुजरते समय सीरियलाइज़, डीसीरियलाइज़ नहीं करना चाहते हैं।
00:14:42यह मूल रूप से एक स्पष्ट बात है।
00:14:45यह एक छोटा सा एनिमेशन है जो केंद्रीकृत कतार के पीछे के विचार को दर्शाता है, है ना?
00:14:51तो टॉप-डाउन राउटर स्थानीय कतारों को बिल्कुल सही तरीके से भरने की कोशिश करने के बजाय, जो कि मूल रूप से असंभव है,
00:15:01पूरा विचार यह है कि, अरे, क्या हम किसी तरह कतार को केंद्रीकृत कर सकते हैं और क्या वर्कर इसके बजाय अपने स्वयं के बैच बनाने का कार्य उठा सकते हैं
00:15:09बैच की लागत के अपने अनुमान के साथ और फिर, बहुत अधिक कुशल बन सकते हैं?
00:15:15अब, एक बात और एक तरह से साइड नोट, एक बार जब आप इन चीज़ों पर काम करना शुरू करते हैं, तो आपको एहसास होता है कि वास्तव में यह अनुमान लगाना बहुत कठिन है कि बैच को वास्तव में इष्टतम आकार का बनाने के लिए साझा कतार से कितनी चीज़ें उठानी हैं।
00:15:30और इसलिए आप कुछ ऐसा तंत्र चाहेंगे जो आपको कतार में कुछ चीज़ें वापस रखने की अनुमति दे।
00:15:35यदि आपको पता चलता है, ओह, जैसे मैंने थोड़ा सा अधिक खींच लिया है।
00:15:37और यह एक नेटवर्क हब है, है ना?
00:15:39तो यह एक समस्या है।
00:15:40और हमारे पास उन मशीनों के लिए इसके लिए विशेष अनुकूलन है जिनमें स्थानीय रूप से कई GPU हैं, है ना?
00:15:46तो मशीन स्थानीय कतार का एक अतिरिक्त तत्व है जो इस तथ्य का लाभ उठाता है कि एक मशीन पर कई GPU पर चलने वाली स्थानीय प्रक्रियाएं आगे-पीछे थोड़ी बातचीत कर सकती हैं,
00:15:59जो कि नेटवर्क पर, अतिरिक्त मिलीसेकंड जोड़ देगा।
00:16:03और इसलिए हम इसे नेटवर्क पर नहीं करते हैं, केवल तभी जब हम मल्टी-GPU मशीनों पर वर्कर्स को एक साथ रखते हैं।
00:16:11और, मेरा मतलब है, हम यहाँ 5% अंतर के बारे में बात नहीं कर रहे हैं, है ना?
00:16:16तो, जैसे, आप कतार को केंद्रीकृत करते हैं और अब आपको क्लस्टर का दोगुना थ्रूपुट मिलता है।
00:16:19तो यह महत्वपूर्ण है।
00:16:22मैंने तीन अलग-अलग रनटाइम का उल्लेख किया।
00:16:25तो, मूल रूप से, यह या तो है, हम लिखते हैं, मान लीजिए उन मॉडलों के लिए जो केवल एनकोडर हैं, हम PyTorch कोड लिखते हैं।
00:16:33और हम इसे अनुकूलित करते हैं और हमारे पास एक ऑटो-रिसर्च लूप है जो इसे अनुकूलित करता है।
00:16:38कैंडल के लिए भी यही है।
00:16:39हमने कुछ समय पहले ही कैंडल के साथ खेलना शुरू किया है।
00:16:42हम अभी भी इसे PyTorch प्रदर्शन के आस-पास भी प्रदर्शन करने में सक्षम नहीं कर पा रहे हैं।
00:16:45तो यह थोड़ा अधिक शोध परियोजना है।
00:16:47यह सिर्फ निर्भरता है, जैसे, PyTorch के साथ वर्कर Docker इमेज लगभग 12 गीगाबाइट है।
00:16:54और वर्कर मूल रूप से बाइनरी, कैंडल के साथ स्थिर रूप से जुड़ा बाइनरी शायद उसका लगभग 10% है, है ना?
00:17:01और यदि आप ठंडी अवस्था से जागने और विभिन्न मशीनों पर इन छवियों को लोड करने की परवाह करते हैं,
00:17:08तो 12 गीग से एक गीगाबाइट या इसके जैसी किसी चीज़ पर जाना एक बड़ा अंतर पैदा करता है।
00:17:13तो यह कैंडल के पीछे की प्रेरणा है।
00:17:15यह सिर्फ PyTorch से वही प्रदर्शन प्राप्त करना बहुत कठिन है।
00:17:20और फिर SG-Lang हमारे पास एक गो-टू बेसलाइन के रूप में है।
00:17:25जैसे हमें उन सभी मापदंडों की इष्टतम ट्यूनिंग के साथ SG-Lang जितना अच्छा प्रदर्शन करना चाहिए, जिसका मैंने उल्लेख किया है कि आपको ट्यूनिंग करनी होगी।
00:17:34यहाँ कुछ नंबर दिए गए हैं।
00:17:37तो उदाहरण के लिए, जब हम SG-Lang को सॉकेट और हमारे रेस्ट साइडकार के साथ लपेटते हैं,
00:17:43वास्तव में हम मूल SG-Lang प्रदर्शन में सुधार कर सकते हैं क्योंकि हम बैचिंग पक्ष पर कुछ ऐसा करते हैं जो मूल रूप से SG-Lang नहीं करता है।
00:17:54और शायद आप इसे ऐसा करने के लिए बना सकते हैं।
00:17:57यदि आप ऐसा करते हैं जैसे, यदि आप SG-Lang में कस्टम प्लगइन विकसित करते हैं और इस तरह की चीज़ें,
00:18:00जैसे शायद आप हमारे प्रदर्शन से मेल खा सकते हैं क्योंकि, आप जानते हैं,
00:18:04आप समान तर्क को SG-Lang कोर सर्वर में धकेल सकते हैं।
00:18:07लेकिन अब आप कस्टम कोड विकसित कर रहे हैं जो केवल SG-Lang के साथ काम करता है।
00:18:11और छोटे मॉडलों से यहाँ पूरा सबक यह है कि रनटाइम बहुत विविध हैं, है ना?
00:18:16आप जरूरी नहीं कि किसी विशेष रनटाइम में फंसे रहना चाहें क्योंकि ऐसा है, आप जानते हैं,
00:18:22हमारे पास, मुझे लगता है कि लगभग 50 अलग-अलग एडेप्टर हैं जिन्हें हम अब विभिन्न मॉडलों के लिए पैरामीटरित करते हैं।
00:18:28और इसलिए आपको इस प्रकार की अंतर्निहित जटिलता से किसी तरह निपटना होगा।
00:18:32और यह शायद किसी एक विशिष्ट रनटाइम के लिए कई प्लगइन बनाकर नहीं है।
00:18:36यह शायद किसी प्रकार का अमूर्तता है, जो हमारे मामले में यह रेस्ट साइडकार अवधारणा और फिर सॉकेट है।
00:18:47अब मैं कुछ अलग संख्याओं के बारे में बात करूंगा, लेकिन बेंचमार्किंग के आसपास की भाषा के संदर्भ में, आप जानते हैं,
00:18:53नी इस अवधारणा की तरह है जब आप सर्वर पर ट्रैफ़िक बढ़ाते हैं,
00:18:57जब आप इससे अधिक और अधिक थ्रूपुट का अनुरोध करते हैं,
00:19:01और यह आपको अधिक से अधिक थ्रूपुट देता है, तब आप रैखिक रूप से ऊपर जाते हैं।
00:19:05और फिर एक बिंदु पर आप इस बिंदु पर पहुँच जाते हैं जहाँ आप अधिक और अधिक मांगते हैं जो आ नहीं रहा है।
00:19:09तो आप समतल हो जाते हैं और विलंबता बढ़ जाती है।
00:19:12इसलिए हम इसे घुटना कहते हैं और यह बेंचमार्किंग में एक उपयोगी अवधारणा है,
00:19:17क्योंकि यह संतृप्ति का बिंदु है, है ना?
00:19:20यह विलंबता को नुकसान पहुँचाए बिना अधिकतम प्रदर्शन है।
00:19:23तो बस आपको यह विचार देने के लिए कि अपेक्षाकृत छोटे हार्डवेयर पर क्या संभव है, है ना?
00:19:32और छोटे मॉडलों के विभिन्न प्रकार।
00:19:34तो यह RTX Pro 6000 पर मापा जाता है।
00:19:37हम NVIDIA L4, A100, RTX Pro 6000, H100, उस श्रेणी के साथ काम करते हैं।
00:19:46फिर से, वे GPU किसी भी क्लाउड में मांग पर बहुत अधिक आसानी से उपलब्ध हैं।
00:19:52अधिकांश महाद्वीपों में कोटा है, आप जानते हैं।
00:19:56और इस तरह की चीज़ों पर, आप मूल रूप से एम्बेडिंग मॉडल के लिए प्राप्त कर सकते हैं,
00:20:01यहाँ तक कि सैकड़ों मिलियन मापदंडों तक,
00:20:05आप एम्बेडिंग में एन्कोड किए गए प्रति सेकंड सैकड़ों हज़ार टोकन प्राप्त कर सकते हैं, है ना?
00:20:12तो सोचिए कि आप वहाँ बैठे हैं, और OpenAI API पर अपना टेक्स्ट एम्बेडिंग ट्री चला रहे हैं।
00:20:17इसके बजाय आप एक जीपीयू रख सकते हैं और प्रति सेकंड पांच लाख टोकन सिस्टम में डालकर वेक्टर प्राप्त कर सकते हैं।
00:20:26है ना?
00:20:28जैसे, क्या यह बात समझ आ रही है?
00:20:31आपके पास प्रति सेकंड पांच लाख टोकन हैं जिन्हें आप एक सिंगल जीपीयू में डाल रहे हैं जो बहुत बड़ा भी नहीं है,
00:20:38बजाय इसके कि आप उन सबको किसी मैनेज्ड एम्बेडिंग एंडपॉइंट पर भेजें और कई गुना अधिक पैसे चुकाएं।
00:20:49है ना?
00:20:50और इन कॉल्स के लिए आप कम लेटेंसी पा सकते हैं, जैसे कुछ मिलीसेकंड, है ना?
00:20:55जैसे यदि आप कोहिरे, ओपनएआई एपीआई आदि का उपयोग करते हैं, तो ये सैकड़ों मिलीसेकंड होते हैं, है ना?
00:21:02और यह कोई रॉकेट साइंस नहीं है।
00:21:03आप जानते हैं, कुछ जीपीयू और उनके आस-पास के कुछ इन्फ्रास्ट्रक्चर के साथ आप भारी लागत बचा सकते हैं, लेटेंसी में भारी सुधार कर सकते हैं और संचालन को काफी आसान बना सकते हैं, है ना?
00:21:17तो यह बहुत आसान मौका है, यदि आप ओपन-सोर्स मॉडल, छोटे मॉडल से शुरुआत करते हैं, तो एम्बेडिंग्स बहुत आसान विकल्प हैं, है ना?
00:21:26लेकिन बात यहीं खत्म नहीं होती।
00:21:27तो मान लीजिए आप नेम्ड एंटिटी रिकग्निशन को देखना चाहते हैं।
00:21:33आप मल्टी-वेक्टर सर्च, या टेक्स्ट के जनरेशन या स्ट्रक्चर्ड आउटपुट आदि को देखना चाहते हैं।
00:21:42आप टास्क के हिसाब से जनरेटिव मॉडल से प्रति सेकंड हजारों टोकन आउटपुट पा सकते हैं, नीचे दिए गए एक जीपीयू के लिए प्रति सेकंड लगभग पाँच सौ टोकन।
00:21:58और मान लीजिए आप सिंथेटिक डेटा जनरेट कर रहे हैं, अपने फाइन-ट्यूनिंग और ईवल्स के लिए एनोटेशन जनरेट कर रहे हैं, तो इसे किसी मैनेज्ड एंडपॉइंट पर न करें।
00:22:11यह एक बेहतरीन टास्क है क्योंकि यह आपके नियंत्रण में होता है।
00:22:14आप गुणवत्ता की जांच कर सकते हैं।
00:22:16यह आपके अपने इन्फ्रास्ट्रक्चर पर ओपन-सोर्स मॉडल के लिए एक आदर्श कार्य है।
00:22:20और फिर, यदि उन जीपीयू के आस-पास का इन्फ्रास्ट्रक्चर उचित है, तो आपको उन जीपीयू की संख्या के साथ रैखिक स्केलिंग मिलेगी।
00:22:31अब, छोटे मॉडल सर्विंग से जुड़ा एक और विचार यह है कि सामान्यतः आपके पास प्रति मॉडल वर्कर पूल होता है, है ना?
00:22:44आपके पास वर्कर और नोड्स का एक सेट होता है, उनमें जीपीयू होते हैं, आप उन्हें चालू करते हैं और मॉडल को पहले से लोड करते हैं।
00:22:51मॉडल को लोड होने में दसियों मिनट लगते हैं क्योंकि वे अरबों पैरामीटर के होते हैं।
00:22:55और इसलिए आप खुश होते हैं, ठीक है, वे आखिरकार लोड हो गए, अब मेरे पास एक वर्कर पूल है।
00:22:59यह मानसिकता छोटे मॉडल के साथ वास्तव में काम नहीं करती है।
00:23:02हाँ, हाँ, जल्दी से।
00:23:04कितना, कितना समय बचा है?
00:23:06छह मिनट ऊपर हो गए।
00:23:07ओह, छह मिनट ऊपर हो गए।
00:23:08ठीक है।
00:23:09ठीक है।
00:23:10तो एक ही जीपीयू पर मॉडल पैक करना तेज होता है।
00:23:12यह इस बारे में है कि आप अभी भी कुछ मॉडल को पिन करना चाहते हैं, लेकिन मेमोरी प्रेशर के आधार पर लेजी लोडिंग और इविक्शन भी करना चाहते हैं।
00:23:26आप यह पता लगाना चाहते हैं कि दोनों को कैसे मिलाया जाए।
00:23:28यहाँ ऑटो रिसर्च के बारे में थोड़ी सी जानकारी है।
00:23:32हमारे पास नए मॉडल और उनके प्रदर्शन के लिए समर्थन जोड़ने के वास्ते ऑटो रिसर्च लूप हैं।
00:23:39हम उन ऑटो रिसर्च लूप में फीड करने के लिए माप करने वास्ते बहुत सारे आंतरिक टूलिंग बनाते हैं ताकि नंबरों को आगे बढ़ाया जा सके।
00:23:47और शायद सबसे महत्वपूर्ण बात यह है कि जब हम किसी मॉडल के लिए समर्थन जारी करते हैं, तो उसकी पूरी ट्यूनिंग हो चुकी होती है, है ना?
00:23:53इसलिए ऐसा नहीं है कि, ठीक है, आइए पैरामीटर स्वीप करते हैं।
00:23:55हम पूरे क्लस्टर के लिए एंड-टू-एंड कॉन्फ़िगरेशन बंडल करते हैं।
00:24:00यह ऑटो रिसर्च लूप के लिए एक सेटअप है।
00:24:03एक मेटा लूप है जो हार्नेस बनाता है जो फिर लूप को चलाता है।
00:24:08और ऊपर एक डैशबोर्ड है जो यह समझने में मदद करता है कि यह कैसे काम करता है।
00:24:12हमारे पास इसके लिए कस्टम यूआई हैं।
00:24:15और इसका एक परिणाम एक लोरा था जिसे प्रशिक्षित करने में 80 सेंट लगे और इसने प्रूफ ऑफ कॉन्सेप्ट के रूप में जर्मन लीगल टेक्स्ट में पुनर्प्राप्ति की गुणवत्ता में 18% का सुधार किया।
00:24:27और बस इतना ही।
00:24:29तो छोटे मॉडल अच्छे हैं।
00:24:30वे सर्व करने में अपेक्षाकृत आसान हैं।
00:24:32वे वास्तव में बहुत सस्ते और तेज हैं।
00:24:35यह बहुत शानदार है।
00:24:36और वह क्यूआर कोड हमारे क्लस्टर के गिटहब रिपॉजिटरी पर जाता है जिसके बारे में मैंने अभी बताया।
00:24:43हमें एक स्टार दें।
00:24:44और आनंद लें सेल्फ-होस्टिंग का।
00:24:45धन्यवाद।
00:24:46धन्यवाद।
00:24:47धन्यवाद।
Community Posts
No posts yet. Be the first to write about this video!
Write about this video