मैट्रिक्स गुणन के रूप में गणनाओं को व्यक्त करना उन्हें तेज क्यों बनाता है?

Question

TensorFlow का उपयोग करते हुए Google के MNist ट्यूटोरियल में , एक गणना प्रदर्शित की जाती है जिसमें एक कदम वेक्टर द्वारा मैट्रिक्स को गुणा करने के बराबर होता है। Google पहले एक तस्वीर दिखाता है जिसमें प्रत्येक संख्यात्मक गुणन और इसके अलावा गणना में जाने वाले पूर्ण में लिखा होता है। इसके बाद, वे एक तस्वीर दिखाते हैं जिसमें इसे मैट्रिक्स गुणा के रूप में व्यक्त किया जाता है, यह दावा करते हुए कि गणना का यह संस्करण है, या कम से कम, तेज हो सकता है:

यदि हम इसे समीकरणों के रूप में लिखते हैं, तो हम प्राप्त करते हैं:

हम इस प्रक्रिया को "वेक्टराइज़" कर सकते हैं, इसे मैट्रिक्स गुणा और वेक्टर जोड़ में बदल सकते हैं। यह कम्प्यूटेशनल दक्षता के लिए सहायक है। (यह सोचने का एक उपयोगी तरीका भी है।)

मुझे पता है कि इस तरह के समीकरण आमतौर पर मशीन लर्निंग चिकित्सकों द्वारा मैट्रिक्स गुणन प्रारूप में लिखे जाते हैं, और निश्चित रूप से कोड थकाऊ के दृष्टिकोण या गणित को समझने से ऐसा करने के फायदे देख सकते हैं। मुझे समझ में नहीं आता कि Google का दावा है कि लॉन्गहैंड फॉर्म से मैट्रिक्स फॉर्म में परिवर्तित करना "कम्प्यूटेशनल दक्षता के लिए सहायक है"

मैट्रिक्स गुणन के रूप में गणनाओं को व्यक्त करके सॉफ्टवेयर में प्रदर्शन में सुधार कब, क्यों और कैसे संभव होगा? अगर मैं एक मानव के रूप में दूसरी (मैट्रिक्स-आधारित) छवि में मैट्रिक्स गुणन की गणना करने के लिए था, तो मैं इसे पहले (स्केलर) छवि में दिखाए गए प्रत्येक अलग-अलग गणना के क्रमिक रूप से करूँगा। मेरे लिए, वे कुछ भी नहीं हैं लेकिन गणना के समान अनुक्रम के लिए दो सूचनाएं हैं। यह मेरे कंप्यूटर के लिए अलग क्यों है? स्केलर की तुलना में कंप्यूटर तेजी से मैट्रिक्स गणना करने में सक्षम क्यों होगा?

Answer 1

यह स्पष्ट लग सकता है, लेकिन कंप्यूटर सूत्रों को निष्पादित नहीं करते हैं , वे कोड को निष्पादित करते हैं , और कितना समय लगता है कि निष्पादन सीधे उस कोड पर निर्भर करता है जो वे निष्पादित करते हैं और केवल उस कोड को लागू करने वाली अवधारणा पर अप्रत्यक्ष रूप से। कोड के दो तार्किक रूप से समान टुकड़ों में बहुत अलग प्रदर्शन विशेषताएं हो सकती हैं। विशेष रूप से मैट्रिक्स गुणन में फसल होने की संभावना वाले कुछ कारण:

• कई सूत्र का उपयोग करना। लगभग कोई आधुनिक सीपीयू नहीं है जिसमें कई कोर नहीं हैं, कई में 8 तक हैं, और उच्च-प्रदर्शन कंप्यूटिंग के लिए विशेष मशीनों में आसानी से कई सॉकेट्स में 64 हो सकते हैं। एक सामान्य प्रोग्रामिंग भाषा में, स्पष्ट तरीके से कोड लिखना, उनमें से केवल एक का उपयोग करता है । दूसरे शब्दों में, यह उस मशीन के उपलब्ध कंप्यूटिंग संसाधनों के 2% से कम का उपयोग कर सकता है जिस पर वह चल रहा है।
• SIMD निर्देशों का उपयोग करना (भ्रामक रूप से, इसे "वैश्वीकरण" भी कहा जाता है, लेकिन प्रश्न में पाठ उद्धरण की तुलना में एक अलग अर्थ में)। संक्षेप में, 4 या 8 या इसलिए स्केलर अंकगणितीय निर्देशों के बजाय, सीपीयू को एक निर्देश दें जो 4 या 8 पर अंकगणित करता है या समानांतर में रजिस्टर करता है। यह शाब्दिक रूप से कुछ गणनाएं कर सकता है (जब वे पूरी तरह से स्वतंत्र हैं और निर्देश सेट के लिए फिट हैं) 4 या 8 बार तेजी से।
• कैश का बेहतर उपयोग करना । मेमोरी एक्सेस तेजी से होती है यदि वे अस्थायी और स्थानिक रूप से सुसंगत हैं , अर्थात, लगातार पहुंचें पास के पते पर होती हैं और जब एक पते पर दो बार पहुंचते हैं तो आप इसे लंबे ठहराव के बजाय त्वरित उत्तराधिकार में दो बार एक्सेस करते हैं।
• GPU जैसे त्वरक का उपयोग करना। ये उपकरण सीपीयू से बहुत अलग जानवर हैं और उन्हें कुशलतापूर्वक प्रोग्रामिंग करना अपने आप में एक संपूर्ण कला है। उदाहरण के लिए, उनके पास सैकड़ों कोर हैं, जिन्हें कुछ दर्जन कोर के समूहों में बांटा गया है, और ये समूह संसाधनों को साझा करते हैं - वे स्मृति के कुछ KiB साझा करते हैं जो सामान्य मेमोरी की तुलना में बहुत तेज़ है, और जब समूह का कोई कोर निष्पादित करता है ifउस समूह के अन्य सभी लोगों को इसका इंतजार करना होगा।
• कई मशीनों (सुपर कंप्यूटरों में बहुत महत्वपूर्ण!) पर काम वितरित करें जो नए सिरदर्द का एक बड़ा सेट पेश करता है, लेकिन निश्चित रूप से, अधिक से अधिक कंप्यूटिंग संसाधनों तक पहुंच प्रदान कर सकता है।
• होशियार एल्गोरिदम। मैट्रिक्स गुणन के लिए सरल O (n ^ 3) एल्गोरिथ्म, ठीक से ऊपर दिए गए ट्रिक्स के साथ अनुकूलित, अक्सर उचित मैट्रिक्स आकारों के लिए उप-क्यूबिक वाले की तुलना में तेज़ होते हैं, लेकिन कभी-कभी वे जीतते हैं। विशेष मामलों जैसे विरल मैट्रिस के लिए, आप विशेष एल्गोरिदम लिख सकते हैं।

बहुत सारे स्मार्ट लोगों ने सामान्य रेखीय बीजगणित संचालन के लिए बहुत ही कुशल कोड लिखा है , उपरोक्त ट्रिक्स का उपयोग करते हुए और बहुत अधिक और आमतौर पर बेवकूफ प्लेटफॉर्म-विशिष्ट ट्रिक्स के साथ भी। इसलिए, अपने सूत्र को मैट्रिक्स गुणा में रूपांतरित करना और फिर उस अनुकूलन प्रयास से एक परिपक्व रैखिक बीजगणित पुस्तकालय लाभ में कॉल करके उस गणना को लागू करना । इसके विपरीत, यदि आप एक उच्च-स्तरीय भाषा में स्पष्ट रूप से सूत्र लिखते हैं, तो मशीन कोड जो अंततः उत्पन्न होता है, उन सभी चालों का उपयोग नहीं करेगा और उतना तेज़ नहीं होगा। यह भी सच है यदि आप मैट्रिक्स फॉर्मूलेशन लेते हैं और इसे एक भोले मैट्रिक्स गुणन दिनचर्या को कॉल करके कार्यान्वित करते हैं जो आपने खुद को लिखा था (फिर से, स्पष्ट तरीके से)।

कोड फास्ट बनाने से काम चल जाता है , और अक्सर यदि आप प्रदर्शन के अंतिम औंस चाहते हैं तो यह बहुत काम आता है। क्योंकि कई महत्वपूर्ण गणनाओं को रैखिक बीजगणित संचालन के एक जोड़े के संयोजन के रूप में व्यक्त किया जा सकता है, इन कार्यों के लिए अत्यधिक अनुकूलित कोड बनाना किफायती है। आपका एक विशेष उपयोग मामला, हालांकि? आपके अलावा किसी को भी इस बात की परवाह नहीं है, इसलिए इसमें से बिल्ली को अनुकूलित करना किफायती नहीं है।

Answer 2

(विरल) मैट्रिक्स-सदिश गुणन अत्यधिक समानांतर है। यदि आपका डेटा बड़ा है और आपके निपटान में सर्वर फ़ार्म है, तो यह बहुत आसान है।

इसका मतलब है कि आप मैट्रिक्स और वेक्टर को विखंडू में विभाजित कर सकते हैं और अलग-अलग मशीनों को कुछ काम करने दे सकते हैं। फिर उनके कुछ परिणामों को एक दूसरे के साथ साझा करें और फिर अंतिम परिणाम प्राप्त करें।

आपके उदाहरण में ऑपरेशन निम्नानुसार होंगे

1. ग्रिड में उनके समन्वय के अनुसार प्रत्येक डब्ल्यूएक्स, वाई धारण करने वाले प्रोसेसर की एक ग्रिड सेटअप करें

2. प्रत्येक कॉलम (लागत O(log height)) के साथ स्रोत वेक्टर प्रसारित करें

3. स्थानीय स्तर पर लागत (लागत O(width of submatrix * heightof submatrix)) के लिए प्रत्येक प्रोसेसर है

4. राशि (लागत O(log width)) का उपयोग करके प्रत्येक पंक्ति के साथ परिणाम को संक्षिप्त करें

यह अंतिम ऑपरेशन वैध है क्योंकि योग सहयोगी है।

यह भी अतिरेक में निर्माण की अनुमति देता है और आपको एक मशीन में सभी जानकारी डालने से बचने देता है।

छोटे 4x4 मैट्रीस के लिए जैसे आप ग्राफिक्स में देखते हैं यह इसलिए है क्योंकि सीपीयू के पास उन कार्यों से निपटने के लिए विशेष निर्देश और रजिस्टर हैं।

Answer 3

सबसे शिक्षाप्रद बात यह होगी कि अपने कोड के प्रदर्शन की तुलना एल्डी-कार्यान्वित मैट्रिक्स गुणन के प्रदर्शन से करें।

हमेशा कुछ निचले स्तर का अनुकूलन होता है जिसके बारे में आपने सोचा नहीं था, यहाँ आप एक उदाहरण पा सकते हैं:

https://simulationcorner.net/index.php?page=fastmatrixvector