ऑपरेटरों की तुलना में NumPy कार्यों के साथ तत्व-वार संचालन तेजी से हैं?

Question

मैं हाल ही में great SO post पर आया था जिसमें उपयोगकर्ता सुझाव देता है कि numpy.sum पाइथन के sum से तेज़ है जब यह न्यूप्पी सरणी से निपटने की बात आती है।

इससे मुझे लगता है कि, ऑपरेटर की तुलना में न्यूम्पी कार्यों के साथ तेजी से न्यूमपी एरे पर तत्व-वार ऑपरेशंस हैं? यदि हां, तो यह मामला क्यों है?

निम्नलिखित उदाहरण पर विचार करें।

import numpy as np 
a = np.random.random(1e10) 
b = np.random.random(1e10) 

np.subtract(a, b) मज़बूती से a - b तुलना में तेजी से हो जाएगा?

Answer 1

नहीं, एक महत्वपूर्ण तरीके से नहीं।

कारण np.sum, तेजी से sum है कि sum "भोलेपन से" iterable से अधिक पुनरावृति करने के लिए (इस मामले, numpy सरणी में), बुला तत्वों '__add__ ऑपरेटर (जो एक महत्वपूर्ण ओवरहेड लगाता है) लागू किया गया है, जबकि numpy के कार्यान्वयन sum का अनुकूलन किया गया है, उदाहरण के लिए इस तथ्य का लाभ उठाते हुए यह तत्वों के प्रकार (प्रकार) को जानता है, और वे स्मृति में संगत हैं।

यह np.subtract(arr1, arr2) और arr1-arr2 के साथ मामला नहीं है। उत्तरार्द्ध मोटे तौर पर पूर्व में अनुवाद करता है।

तथ्य इस तथ्य से उत्पन्न होता है कि कोई पाइथन में घटाव ऑपरेटर को ओवरराइड कर सकता है, इसलिए numpy arrays अनुकूलित संस्करण का उपयोग करने के लिए इसे ओवरराइड करते हैं। sum ऑपरेशन, हालांकि, अतिसंवेदनशील नहीं है, इसलिए numpy इसका एक वैकल्पिक अनुकूलित संस्करण प्रदान करता है।

Answer 2

वास्तव में नहीं। आप समय को आसानी से जांच सकते हैं।

a = np.random.normal(size=1000) 
b = np.random.normal(size=1000) 

%timeit np.subtract(a, b) 
# 1000000 loops, best of 3: 1.57 µs per loop 

%timeit a - b 
# 1000000 loops, best of 3: 1.47 µs per loop 

%timeit np.divide(a, b) 
# 100000 loops, best of 3: 3.51 µs per loop 

%timeit a/b 
# 100000 loops, best of 3: 3.38 µs per loop 

numpy फ़ंक्शंस वास्तव में एक पतला धीमा प्रतीत होता है। मुझे यकीन नहीं है कि यह महत्वपूर्ण है, लेकिन मुझे संदेह है कि यह एक ही कार्यान्वयन के शीर्ष पर कुछ अतिरिक्त फ़ंक्शन कॉल ओवरहेड की वजह से हो सकता है।

संपादित करें: @unutbu नोटों के रूप में, यह शायद इसलिए है क्योंकि np.add और दोस्तों के अतिरिक्त प्रकार की जाँच भूमि के ऊपर कन्वर्ट करने के लिए arrays के लिए जब आवश्यक सरणी-पसंद करती है, तो np.add([1, 2], [3, 4]) सामान की तरह काम करता है।

Answer 3

@ shx2 द्वारा शानदार उत्तर।

मैं सिर्फ sum बनाम np.sum पर थोड़ा विस्तार होगा:

• निर्मित sum एक सरणी के माध्यम से जाना होगा, तत्व एक-एक करके और उन्हें एक एक अजगर वस्तु में बदलने से पहले ले उन्हें पाइथन वस्तुओं के रूप में एक साथ जोड़ना।
• np.sum व्यक्तिगत मूल्यों के किसी भी रूपांतरण के बिना सरणी मूल कोड में एक अनुकूलित पाश का उपयोग कर, योग होगा

हर के रूपांतरण (के रूप में shx2 बताते हैं, यह महत्वपूर्ण एकरूपता और सरणी सामग्री की समीपता की आवश्यकता है) एक पायथन ऑब्जेक्ट के लिए सरणी तत्व उपरि के प्रमुख स्रोत तक है।

वैसे, यह भी बताता है कि क्यों यह गूंगा है पायथन के standard-library C array type गणित के लिए उपयोग करने के लिए। sum(list) एक बहुत तेजी सेsum(array.array) से है।

Answer 4

a-b एक समारोह कॉल a.__rsub__(b) में तब्दील हो। इस प्रकार यह वैरिएबल से संबंधित विधि का उपयोग करता है (उदाहरण के लिए संकलित numpy कोड अगर a एक सरणी है)।

In [20]: a.__rsub__?? 
Type:  method-wrapper 
String Form:<method-wrapper '__rsub__' of numpy.ndarray object at 0xad27a88> 
Docstring: x.__rsub__(y) <==> y-x 

np.subtract(x1, x2[, out]) के लिए दस्तावेज़ से पता चलता है कि यह एक ufunc है। ufunc अक्सर __rsub__ तरह संकलित संचालन उपयोग करें, लेकिन ufunc प्रोटोकॉल फिट करने के लिए भूमि के ऊपर का एक सा जोड़ सकते हैं।

कई अन्य मामलों में np.foo(x, args)x.foo(args) पर अनुवाद करता है।

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