What actually runs: a measurement study of language model placement and decode speed on the Apple Neural Engine
एप्पल न्यूरल इंजन पर लैंग्वेज मॉडल प्लेसमेंट और डिकोड स्पीड के एक कठोर मापन अध्ययन के माध्यम से, लेखक यह प्रदर्शित करते हैं कि केवल मॉडल आर्किटेक्चर के बजाय कंप्यूटेशनल एक्सप्रेशन और वेट एनकोडिंग, एक्सीलरेटर रेजिडेंसी और प्रदर्शन को निर्धारित करते हैं, जिससे एक ऐसी डिजाइन प्रक्रिया प्राप्त होती है जो काफी छोटे और तेज़ टेनरी मॉडल्स प्राप्त करने के लिए एनकोडिंग दक्षता को प्राथमिकता देती है।
मूल पेपर CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/) के तहत लाइसेंस किया गया है। नीचे दिए गए पेपर की यह व्याख्या AI से तैयार की गई है। इसे लेखकों ने नहीं लिखा है। तकनीकी सटीकता के लिए मूल पेपर देखें। पूरा डिस्क्लेमर पढ़ें
कल्पना कीजिए कि एक स्मार्टफोन किसी बातचीत को समझने की कोशिश कर रहा है। इसे करने के लिए, इसे अपने डिवाइस पर ही एक विशाल डिजिटल मस्तिष्क, यानी एक लैंग्वेज मॉडल, चलाना होगा। इसके सुचारू रूप से काम करने के लिए, फोन को एक विशेष, अत्यंत तेज़ प्रोसेसर का उपयोग करने की आवश्यकता है जो विशेष रूप से इसी तरह की सोच के लिए बनाया गया है, न कि अपने सामान्य उद्देश्य वाले मुख्य मस्तिष्क का। चुनौती यह है कि यह विशेष प्रोसेसर बहुत चूजी (picky) है; यह केवल कुछ खास प्रकार की गणनाओं को ही चलाएगा, और वह अन्य गणनाओं को चलाने से इनकार कर देगा, भले ही वे गणितीय रूप से समान ही क्यों न हों। वर्षों से, डेवलपर्स ने अनुमान लगाने की कोशिश की है कि कौन सी गणनाएँ काम करेंगी और उन्हें कैसे तेज़ बनाया जाए, और अक्सर ऐसे नियमों पर भरोसा किया है जो गलत साबित हुए। उन्होंने माना कि यदि कोई मॉडल पर्याप्त छोटा है, तो वह तेज़ प्रोसेसर पर चल जाएगा, या यह कि संख्याओं को छोटा करने से हमेशा मदद मिलेगी। लेकिन किसी ने वास्तव में प्रोसेसर को यह देखने के लिए नहीं देखा कि वह वास्तव में क्या कर रहा है, या यह मापने के लिए नहीं कि मॉडल का आकार और उसके नंबरों को स्टोर करने का तरीका उसकी गति को कैसे बदलता है।
शाहिर एम ए नामक एक शोधकर्ता ने केवल अनुमान लगाना बंद करने और देखना शुरू करने का निर्णय लिया। एक एप्पल कंप्यूटर का उपयोग करते हुए जिसमें M1 चिप लगी थी, उन्होंने प्रयोगों की एक श्रृंखला बनाई ताकि यह देखा जा सके कि वास्तव में क्या होता है जब एक लैंग्वेज मॉडल फोन के विशेष प्रोसेसर पर चलने की कोशिश करता है, जिसे न्यूरल इंजन के रूप में जाना जाता है। उन्होंने केवल यह नहीं देखा कि सॉफ्टवेयर क्या कहता था कि वह करेगा; उन्होंने चिप के माध्यम से बहने वाली वास्तविक बिजली और डेटा को मापा ताकि देख सकें कि वास्तव में क्या हो रहा है। उन्होंने एक ही गणितीय ऑपरेशन को बनाने के दर्जनों अलग-अलग तरीकों का परीक्षण किया, विभिन्न आकारों के वास्तविक मॉडल प्रशिक्षित किए, और यह भी बदला कि मॉडल के भीतर संख्याओं को कैसे स्टोर किया जाता है, जो मानक परिशुद्धता (standard precision) से लेकर बहुत संकुचित, कम-परिशुद्धता वाले प्रारूपों तक फैला हुआ था। उनका लक्ष्य सरल था: यह पता लगाना कि वास्तव में क्या एक मॉडल को तेज़ प्रोसेसर पर ले जाता है और एक बार वहां पहुँचने के बाद वह कितनी तेज़ी से बोल सकता है।
पहली चीज़ जो उन्होंने खोजी, वह यह थी कि प्रोसेसर इस बात की परवाह नहीं करता कि गणना का अर्थ क्या है, बल्कि इस बात की कि उसे कैसे लिखा गया है। उन्होंने पाया कि यदि आप एक विशिष्ट प्रकार का नॉर्मलाइजेशन (normalization)—एक ऐसा चरण जो मॉडल को उसके नंबरों को स्थिर रखने में मदद करता है—एक तरीके से लिखते हैं, तो प्रोसेसर उसे तुरंत स्वीकार कर लेता है और पूरी गति से चलाता है। लेकिन यदि आप ठीक उसी गणितीय चरण को निर्देशों के थोड़े अधिक जटिल सेट का उपयोग करके लिखते हैं, तो प्रोसेसर उसे छूने से भी इनकार कर देता है और फोन को अपने धीमे, सामान्य-उद्देश्य वाले मस्तिष्क का उपयोग करने के लिए मजबूर कर देता है। यह ऐसा है जैसे प्रोसेसर गणित की एक विशिष्ट बोली बोलता है; यदि आप सही बोली का उपयोग करते हैं, तो वह सुनता है, लेकिन यदि आप किसी अन्य बोली का उपयोग करते हैं, भले ही अर्थ समान हो, तो वह दूर हट जाता है। इसका मतलब है कि एक डेवलपर जिस तरह से कोड लिखता है, वह गणित के समान ही महत्वपूर्ण है।
दूसरी, और शायद सबसे आश्चर्यजनक खोज यह थी कि मॉडल का आकार एकमात्र चीज़ नहीं है जो यह तय करती है कि क्या वह तेज़ प्रोसेसर पर चल सकता है। शोधकर्ताओं ने पाया कि लगभग छब्बीस मिलियन पैरामीटर्स वाला एक मॉडल, जो मानक परिशुद्धता में लिखा गया था, विशेष प्रोसेसर पर चलने के लिए बहुत छोटा था। उसे धीमे मस्तिष्क पर चलने के लिए मजबूर किया गया, जिससे प्रत्येक शब्द उत्पन्न करने में एक सेकंड से अधिक का समय लग गया। हालाँकि, जब उन्होंने उसी मॉडल को लिया और उसके भीतर के नंबरों को संकुचित किया ताकि कम बिट्स का उपयोग किया जा सके, तो प्रोसेसर ने अचानक उसे स्वीकार कर लिया। संकुचित संस्करण तेज़ प्रोसेसर पर चला और एक सेकंड से भी कम समय में शब्द उत्पन्न किए। वास्तव में, छोटे मॉडलों के लिए, संख्याओं को संकुचित करना ही उन्हें तेज़ प्रोसेसर पर लाने का एकमात्र तरीका था। प्रोसेसर का एक छिपा हुआ नियम था: वह छोटे मॉडलों को तब तक नहीं चलाएगा जब तक कि वे संकुचित न हों। इसने इस सामान्य धारणा को उलट दिया कि बड़े मॉडल ही हमेशा तेज़ प्रोसेसर की आवश्यकता रखते हैं; यहाँ, छोटे मॉडलों को अंदर आने के लिए संपीड़न (compression) की आवश्यकता थी।
एक बार मॉडल तेज़ प्रोसेसर के अंदर पहुँच गया, तो गति लगभग पूरी तरह से इस बात से निर्धारित होती थी कि कितना डेटा स्थानांतरित होना है, न कि गणित कितना जटिल है। शोधकर्ताओं ने डेटा के प्रवाह को मापा और पाया कि मॉडल द्वारा उत्पन्न प्रत्येक शब्द के लिए, उसे अपने वेट्स (weights)—वे नंबर जो उसका ज्ञान बनाते हैं—का पूरा सेट प्रोसेसर के माध्यम से स्ट्रीम करना पड़ता है। यह हर एक शब्द के लिए होता था, चाहे बातचीत कितनी भी लंबी क्यों न हो। इस कारण से, गति सीधे तौर पर उन वेट्स में मौजूद बिट्स की संख्या से जुड़ी थी। एक मॉडल जिसमें संकुचित, कम-परुद्धता वाले नंबर थे, ने बहुत कम डेटा स्थानांतरित किया और इसलिए वह बहुत तेज़ था। उन्होंने पाया कि दो-बिट नंबरों वाला एक मॉडल मानक नंबरों वाले मॉडल की तुलना में लगभग तीन गुना तेज़ था, क्योंकि उसे बहुत कम डेटा स्थानांतरित करना पड़ा। मॉडल द्वारा उपयोग किए जाने वाले गणित का प्रकार, जैसे कि क्या वह अटेंशन (attention) या कन्वोल्यूशन (convolution) पर अधिक ध्यान केंद्रित करता है, एक बार प्रोसेसर पर चलने के बाद गति के लिए बहुत कम मायने रखता था। एकमात्र चीज़ जो मायने रखती थी, वह थी स्थानांतरित किए जाने वाले डेटा का आकार।
शोधकर्ताओं ने निष्कर्ष निकाला कि फोन के लिए लैंग्वेज मॉडल बनाने का सबसे अच्छा तरीका संपीड़न (compression) से शुरू करना है, न कि आकार से। एक बड़े मॉडल को बनाने और फिर उसे छोटा करने की कोशिश करने के बजाय, सबसे पहले सबसे अधिक संकुचित प्रारूप चुनना चाहिए, और फिर उपलब्ध मेमोरी बजट को अधिक पैरामीटर्स जोड़ने पर खर्च करना चाहिए। उन्होंने पाया कि पच्चीस मिलियन पैरामीटर्स वाला एक मॉडल, जो एक विशिष्ट प्रकार के संकुचित गणित का उपयोग करता है, केवल दस मेगाबाइट स्थान में फिट हो सकता है और लगभग छह-दशमलव-छठा मिलीसेकंड में शब्द उत्पन्न कर सकता है। यह उन मानक, असंकुचित मॉडलों की तुलना में लगभग दस गुना छोटा और तीन गुना तेज़ था जिन्हें डेवलपर्स आमतौर पर शुरुआत में उपयोग करते हैं। अध्ययन ने दिखाया कि तेज़, ऑन-डिवाइस लैंग्वेज मॉडल का मार्ग मॉडल को बड़ा या अधिक जटिल बनाने के बारे में नहीं है, बल्कि गणित को लिखने के सही तरीके और नंबरों को स्टोर करने के सही तरीके को चुनने के बारे में है। डेटा के वास्तविक प्रवाह को मापकर, उन्होंने सिद्ध किया कि गति की कुंजी केवल एक तेज़ प्रोसेसर होना नहीं है, बल्कि यह जानना है कि उसे सटीक रूप से कैसे खिलाया जाए।
अपने क्षेत्र के पेपरों की भीड़ में उलझे हुए हैं?
आपके रिसर्च कीवर्ड से मेल खाने वाले सबसे नए और अलग सोच वाले पेपरों का रोज़ाना Digest पाएँ—तकनीकी सारांश के साथ, आपकी भाषा में।