मैं numpy arrays के साथ दक्षता को अधिकतम कैसे कर सकता हूं?

Question

मुझे सिर्फ नमस्ते पता चल रहा है, और मैं सी-जैसी दक्षता के अपने दावों से प्रभावित हूं क्योंकि इसकी एनडैरे में स्मृति पहुंच है। मैं अपने लिए इन और पायथनिक सूचियों के बीच मतभेद देखना चाहता था, इसलिए मैंने एक त्वरित समय परीक्षण चलाया, इसके बिना कुछ सरल कार्यों को निष्पादित किया। अम्पी ने अपेक्षित के रूप में, सरणी के आवंटन और अंकगणितीय परिचालन में परिमाण के क्रम से नियमित सूचियों को बाहर निकाला। लेकिन कोड के इस खंड, दोनों परीक्षणों में समान, एक दूसरे का 1/8 के बारे में एक नियमित रूप से सूची के साथ थोड़ा 2.5 सेकंड से अधिक numpy साथ ले लिया, और:

file = open('timing.log','w') 
for num in a2: 
    if num % 1000 == 0: 
     file.write("Multiple of 1000!\r\n") 

file.close() 

किसी को भी पता है क्यों यह हो सकता है, और अगर वहाँ क्या कुछ अन्य सिंटैक्स मुझे इस तरह के संचालन के लिए उपयोग करना चाहिए ताकि एनन्ड्रे क्या कर सकता है?

धन्यवाद ...

संपादित करें: वेन की टिप्पणी का जवाब देने के ... मैं उन दोनों को बार-बार और विभिन्न क्रम में समय समाप्त हो गया और काफी समान परिणाम हर बार मिला है, तो मुझे शक है यह एक और प्रक्रिया है। मैंने numpy आयात के बाद फ़ाइल के शीर्ष पर

start = time()

डाल दिया और फिर मेरे पास

print 'Time after traversal:\t',(time() - start)

जैसे वक्तव्य हैं।

Answer 1

a2 एक NumPy सरणी है, है ना? एक संभावित कारण यह न्यूमपी में इतना समय ले सकता है (यदि अन्य प्रक्रियाओं की गतिविधि इसके लिए जिम्मेदार नहीं है क्योंकि वेन वर्नर ने सुझाव दिया है) कि आप पाइथन लूप का उपयोग करके सरणी पर फिर से चल रहे हैं। पुनरावृत्ति के हर चरण में, पायथन को NumPy सरणी से एक मूल्य प्राप्त करना होता है और इसे एक पायथन पूर्णांक में परिवर्तित करना होता है, जो विशेष रूप से तेज़ ऑपरेशन नहीं होता है।

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

file.write("Multiple of 1000!\r\n" * (a2 % 1000 == 0).sum()) 

शुद्ध पायथन बराबर करने के लिए है कि तुलना करने की कोशिश करें,

file.write("Multiple of 1000!\r\n" * sum(filter(lambda i: i % 1000 == 0, a2))) 

या

file.write("Multiple of 1000!\r\n" * sum(1 for i in a2 if i % 1000 == 0)) 

Answer 2

मैं आश्चर्य नहीं है कि आपके स्निपेट का उपयोग करते समय न्यूमपी खराब तरीके से वाई/आर/टी पायथन निर्मित करता है। NumPy में प्रदर्शन लाभ के एक बड़े समूह का छोरों से बचने और बजाय अनुक्रमण द्वारा सरणी का उपयोग से उत्पन्न होती है:

NumPy में, यह इस तरह से कुछ करने के लिए और अधिक आम है:

A = NP.random.randint(10, 100, 100).reshape(10, 10) 
w = A[A % 2 == 0] 
NP.save("test_file.npy", w) 

Answer 3

पर-तत्व का उपयोग कर सकते है numpy arrays के लिए बहुत धीमी है। वेक्टर ऑपरेशंस का उपयोग करें:

$ python -mtimeit -s 'import numpy as np; a2=np.arange(10**6)' ' 
> sum(1 for i in a2 if i % 1000 == 0)' 
10 loops, best of 3: 1.53 sec per loop 

$ python -mtimeit -s 'import numpy as np; a2=np.arange(10**6)' ' 
> (a2 % 1000 == 0).sum()' 
10 loops, best of 3: 22.6 msec per loop 

$ python -mtimeit -s 'import numpy as np; a2= range(10**6)' ' 
> sum(1 for i in a2 if i % 1000 == 0)' 
10 loops, best of 3: 90.9 msec per loop