हम मतलाब में गणना की गति बढ़ाते हैं

शुभ दोपहर, प्यारे खाबरोवित्स!

मैं आपके ध्यान में एक लेख लाता हूं जो हाल ही में मतलाब क्लस्टर के पोस्ट ने मुझे करने के लिए प्रेरित किया। एक समय में, मुझे विषय के लेखक के समान समस्याओं का सामना करना पड़ा, हालांकि, उत्पादकता बढ़ाने के लिए, मैं वितरित कंप्यूटिंग के जंगल में नहीं गया, लेकिन बस अपने कोड को यथासंभव अनुकूलित करने का फैसला किया। मतलाब में यह कैसे करना है, मैं विवरण के लिए कटौती के तहत पूछता हूं।

लेख जीवन के अनुभव का वर्णन है और एक अंग्रेजी-भाषा के प्रकाशन का एक मुफ्त अनुवाद है।

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

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

नीचे आधिकारिक मैटलैब प्रलेखन के कुछ प्रमुख अंश दिए गए हैं जो आपको मटलब में कुशल प्रक्रियाएँ लिखने में मदद करेंगे। आप जुनूनी हो सकते हैं और कोड के अनुकूलन के काम के समय के कई मानव-घंटे खर्च कर सकते हैं, जो कुछ ही सेकंड में कार्यक्रम के निष्पादन के समय को जीतने में मदद करेगा, लेकिन मैं दोहराता हूं कि यह मेरी उत्पादन की जरूरत थी।

यदि आप निम्नलिखित तकनीकों का उपयोग करते हैं तो आपके कार्यक्रमों का प्रदर्शन काफी बढ़ सकता है:

• वेक्टर ऑपरेशन का उपयोग करें, लूप नहीं;
• वैक्टर और मैट्रिस के लिए मेमोरी उपदेश का उपयोग करें;

आइए इनमें से प्रत्येक बिंदु पर अधिक विस्तार से विचार करें।

लूप के बजाय वेक्टर ऑपरेशन का उपयोग करना

निम्नलिखित उदाहरण पर विचार करें:
dx = pi/30;
nx = 1 + 2*pi/dx;
for i = 1:nx
x(i) = (i-1)*dx;
y(i) = sin(3*x(i));
end
यह बिल्कुल स्पष्ट है कि वैक्टर x और y इसमें बनाए जा रहे हैं। हालांकि, मतलाब मक्खी पर चर के लिए स्मृति आवंटित करता है। चक्र के पहले पास के दौरान, दो वैक्टर लंबाई की एक ही रेखा पर बनाए जाते हैं। 1. प्रत्येक अगले चरण में, वैक्टर की लंबाई बढ़ जाती है। चक्र के प्रत्येक रन के दौरान, मेमोरी को मैटलैब चर के लिए आवंटित किया जाएगा, जो प्रोसेसर समय लेता है।
वैक्टर को परिभाषित करने की निम्न विधि का उपयोग करना बेहतर होता है:
x = 0:pi/30:2*pi
y = sin(3*x);
कोड की पहली पंक्ति एक पंक्ति वेक्टर x बनाती है, जिसके तहत मेमोरी आकार को उसकी लंबाई के अनुरूप आवंटित किया जाता है और वेक्टर तत्वों को आसन्न रैम कोशिकाओं में संग्रहीत किया जाता है। कोड की दूसरी पंक्ति दूसरी पंक्ति के वेक्टर के निर्माण की शुरुआत करती है, जिसके तहत मतलब तुरंत इस प्रश्न पर वापस आए बिना, आवश्यक मेमोरी आवंटित करता है।
मुख्य बात याद रखें: मतलाब वेक्टर और मैट्रिक्स कंप्यूटिंग के लिए अधिक अनुकूलित है, और यही कारण है कि इसे विकसित किया गया था।

वैक्टर और मैट्रिसेस के लिए प्रीलेकलिंग मेमोरी

हालांकि मतलाब स्वचालित रूप से वैक्टर और मैट्रिसेस के आकार को समायोजित कर देता है, लेकिन मेट्रिक्स से पहले का चयन करना बेहतर होता है। प्री-एलोकेशन केवल एक बार मेमोरी के आवंटन का ख्याल रखता है, और यह सुनिश्चित करता है कि मैट्रिक्स तत्वों को आसन्न मेमोरी सेल्स (कॉलम में) में संग्रहीत किया जाएगा।
निम्नलिखित कोड पर विचार करें:
dx = pi/30;
nx = 1 + 2*pi/dx;
nx2 = nx/2;

for i = 1:nx2
x(i) = (i-1)*dx;
y(i) = sin(3*x(i));
end

for i = nx2+1:nx
x(i) = (i-1)*dx;
y(i) = sin(5*x(i));
end
यह कोड अनुकूलित नहीं है, क्योंकि हम लोगों को सोच रहे हैं, हम वैक्टर x और y का आकार जानते हैं, और हम इस ज्ञान का उपयोग कर सकते हैं:
dx = pi/30;
nx = 1 + 2*pi/dx;
nx2 = nx/2;

x = zeros(1,nx);
y = zeros(1,nx);

for i = 1:nx2
x(i) = (i-1)*dx;
y(i) = sin(3*x(i));
end

for i = nx2+1:nx
x(i) = (i-1)*dx;
y(i) = sin(5*x(i));
end
इस कोड को परिवर्तित कर दिया गया है, लेकिन अभी भी बिट्स हैं जिनसे आप पूर्व-आवंटन नियम लागू कर सकते हैं। वैक्टर x (i) = ..., और y (i) = ... वेक्टरीकरण का लाभ नहीं उठाते हैं।
सबसे अच्छा तरीका इस तरह से लिखना होगा:
dx = pi/30;
nx = 1 + 2*pi/dx;
nx2 = nx/2;
x = zeros(1,nx);
y = x;

for i = 1:nx2
x(i) = (i-1)*dx;
y(i) = sin(3*x(i));
end

for i = nx2+1:nx
x(i) = (i-1)*dx;
y(i) = sin(5*x(i));
end
मुझे उम्मीद है कि यह लेख किसी और के लिए उपयोगी होगा, एक समय पर इसने मुझे बहुत प्रतीक्षा समय बचाया और कार्य को सफलतापूर्वक पूरा करने में मदद की।