बढ़ते आयामों के साथ पायथन / Numpy सरणी संचालन पैमाने का प्रदर्शन कैसे होता है?

Question

सरणी आयामों को बढ़ाने के साथ पायथन / नेम्पी सरणियों को कैसे किया जाता है?

यह कुछ व्यवहार पर आधारित है जिसे मैंने इस प्रश्न के लिए पायथन कोड को बेंचमार्क करते समय देखा था: इस जटिल अभिव्यक्ति को संख्यात्मक स्लाइस का उपयोग करके कैसे व्यक्त करें

समस्या ज्यादातर एक सरणी को आबाद करने के लिए अनुक्रमण को शामिल करती है। मैंने पाया कि पायथन लूप में साइथॉन और नेम्पी संस्करणों का उपयोग करने के फायदे (बहुत-अच्छे नहीं) शामिल सरणियों के आकार के आधार पर भिन्न होते हैं। Numpy और Cython दोनों एक बिंदु तक बढ़ते प्रदर्शन लाभ का अनुभव करते हैं (कहीं-कहीं मोटे तौर पर लिए Cython और N = 2000 मेरे लैपटॉप पर Numpy के लिए), जिसके बाद उनके फायदे में गिरावट आई (Cython फ़ंक्शन सबसे तेज़ रहा)।$N=500$$N=2000$

क्या यह हार्डवेयर परिभाषित है? बड़े सरणियों के साथ काम करने के संदर्भ में, सबसे अच्छा अभ्यास क्या है कि किसी को कोड के लिए पालन करना चाहिए जहां प्रदर्शन की सराहना की जाती है?

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

Comments

क्या आपने सुन्न करने की कोशिश की है ? वहाँ भी, उदाहरण के लिए, यह बात जो ब्लो और कैरे की ओर इशारा करती है , सभी का मतलब चीजों को गति देना है (और संभवतः मेमोरी बैंडविड्थ सीमाओं को दरकिनार करके)।

— 0 0

क्या आप प्रोफ़ाइल के लिए उपयोग किए गए कोड को पोस्ट कर सकते हैं। यहाँ शायद कुछ चीजें चल रही हैं।

— मेवप्लप

Answer 1

$4$$16 kB$

def timeit(size):
     t0 = time.time()
     for _ in xrange(10):
         np.random.random(size)
     return time.time() - t0

sizes = np.logspace(1, 6, 40)
times = [timeit(s) for s in sizes]

इस बेंचमार्क के साथ कुछ चीजें गलत हैं, एक शुरुआत के लिए, मैं कचरा संग्रह को अक्षम नहीं कर रहा हूं और मैं सबसे अच्छा समय नहीं, बल्कि मेरे साथ सहन कर रहा हूं।

$8000$$64 kB$

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

• बड़े बैंडविड्थ (जैसे एक बहुपद का मूल्यांकन) पर बुनियादी संचालन, मेमोरी बैंडविड्थ द्वारा सीमित। उपयोग Numexpr या (यदि डेटा बहुत बड़ा है) Pytables । वे अन्य अनुकूलन के बीच कैश आकार को ध्यान में रखने के लिए अनुकूलित हैं।
• प्रदर्शन महत्वपूर्ण कोड: यदि आप प्रत्येक माइक्रोसेकंड को निचोड़ना चाहते हैं, तो आपको पहले स्थान पर पायथन का उपयोग नहीं करना चाहिए। वेक्टरित साइथन को लिखना और संकलक को छोड़ना यह वही करता है जो शायद सबसे अच्छा तरीका है।

टिप्पणियों में, एवर्ट ने कैयर्रे का उल्लेख किया। ध्यान दें, यहां तक ​​कि काम करना, विकास बंद हो गया है और इसे स्टैंडअलोन प्रोजेक्ट के रूप में छोड़ दिया गया है। कार्यक्षमता को "नई पीढ़ी के नॉम्पी" बनाने के लिए चल रही परियोजना के बजाय ब्लेज़ में शामिल किया जाएगा ।