अधिकांश स्मृति-कारगर तरीका

Question

मैं सबसे स्मृति-कारगर तरीका एक जटिल numpy ndarray

arr = np.empty((250000, 150), dtype='complex128') # common size 

का पूर्ण वर्ग मूल्य की गणना करने के लिए देख रहा हूँ

मुझे एक ufunc नहीं मिला है जो वास्तव में np.abs()**2 करेगा।

उस आकार और प्रकार की एक सरणी के रूप में लगभग आधा जीबी लगता है, मैं मुख्य रूप से स्मृति-कुशल तरीके की तलाश में हूं।

मैं इसे पोर्टेबल भी पसंद करूंगा, इसलिए आदर्श रूप से यूफुनक्स का कुछ संयोजन।

अब तक मेरी समझ है कि इस यह बेकार की गणना के बारे में सबसे अच्छा

result = np.abs(arr) 
result **= 2 

(**0.5)**2 होना चाहिए, लेकिन यथा-स्थान **2 गणना करना चाहिए। कुल मिलाकर शीर्ष स्मृति आवश्यकता केवल मूल सरणी आकार + परिणाम सरणी आकार है, जो 1.5 * मूल सरणी आकार होना चाहिए क्योंकि परिणाम वास्तविक है।

अगर मैं बेकार **2 कॉल से छुटकारा प्राप्त करना चाहता था कि मैं इस

result = arr.real**2 
result += arr.imag**2 

की तरह कुछ करने के लिए होगा लेकिन अगर मैं गलत नहीं हूँ, यह मैं के लिए स्मृति को आबंटित करने का मतलब होगा वास्तविक और काल्पनिक भाग गणना दोनों, इसलिए शीर्ष स्मृति उपयोग 2.0 * मूल सरणी आकार होगा। arr.real गुण भी एक गैर-संगत सरणी लौटाते हैं (लेकिन यह कम चिंता का विषय है)।

क्या मुझे कुछ भी याद आ रही है? क्या ऐसा करने के कोई बेहतर तरीके हैं?

संपादित करें 1: मैं यह स्पष्ट नहीं बनाने के लिए माफी चाहता हूँ, मैं आगमन के ऊपर लिख नहीं करना चाहते, तो मैं यह के रूप में बाहर का उपयोग नहीं कर सकते हैं।

Answer 1

धन्यवाद numba.vectorize करने के लिए numba के हाल के संस्करण, कार्य के लिए एक numpy सार्वभौमिक कार्य बनाने बहुत आसान है:

@numba.vectorize([numba.float64(numba.complex128),numba.float32(numba.complex64)]) 
def abs2(x): 
    return x.real**2 + x.imag**2 

मेरी मशीन पर, मैं एक तीन गुना speedup कि मध्यवर्ती सरणियों बनाता है एक शुद्ध-numpy संस्करण की तुलना में लगता है:

>>> x = np.random.randn(10000).view('c16') 
>>> y = abs2(x) 
>>> np.all(y == x.real**2 + x.imag**2) # exactly equal, being the same operation 
True 
>>> %timeit np.abs(x)**2 
10000 loops, best of 3: 81.4 µs per loop 
>>> %timeit x.real**2 + x.imag**2 
100000 loops, best of 3: 12.7 µs per loop 
>>> %timeit abs2(x) 
100000 loops, best of 3: 4.6 µs per loop 

Answer 2

arr.real और arr.imag केवल जटिल सरणी में दृश्य हैं। तो कोई अतिरिक्त मेमोरी आवंटित नहीं है।

Answer 3

यदि आपका प्राथमिक लक्ष्य स्मृति को संरक्षित करना है, तो NumPy के ufuncs एक वैकल्पिक out पैरामीटर लेते हैं जो आपको आउटपुट को आपके चयन की सरणी में निर्देशित करने देता है। जब आप संचालन करना चाहते हैं तो यह उपयोगी हो सकता है।

आप अपनी पहली विधि को यह मामूली संशोधन करना है, तो आप आपरेशन arr पर पूरी तरह से जगह में प्रदर्शन कर सकते हैं:

np.abs(arr, out=arr) 
arr **= 2 

---

एक जटिल तरीका है कि केवल एक थोड़ा अतिरिक्त सकता है स्मृति का उपयोग करता है arr को जगह में संशोधित करने के लिए, वास्तविक मानों की नई सरणी की गणना करें और फिर arr को पुनर्स्थापित करें।

इसका मतलब है संकेतों के बारे में जानकारी संग्रहीत करना (जब तक कि आप नहीं जानते कि आपके जटिल संख्याओं में सकारात्मक वास्तविक और काल्पनिक भाग हैं)। प्रत्येक वास्तविक या काल्पनिक मूल्य के संकेत के लिए केवल एक बिट की आवश्यकता होती है, इसलिए यह 1/16 + 1/16 == 1/8arr की स्मृति (आपके द्वारा बनाए गए फ्लोट की नई सरणी के अतिरिक्त) का उपयोग करता है।

>>> signs_real = np.signbit(arr.real) # store information about the signs 
>>> signs_imag = np.signbit(arr.imag) 
>>> arr.real **= 2 # square the real and imaginary values 
>>> arr.imag **= 2 
>>> result = arr.real + arr.imag 
>>> arr.real **= 0.5 # positive square roots of real and imaginary values 
>>> arr.imag **= 0.5 
>>> arr.real[signs_real] *= -1 # restore the signs of the real and imagary values 
>>> arr.imag[signs_imag] *= -1 

भंडारण signbits की कीमत पर, arr अपरिवर्तित है और result मूल्यों हम चाहते हैं रखती है।

Answer 4

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

यहाँ एक तेजी से समाधान है, परिणाम res में संग्रहीत के साथ:

import numpy as np 
res = arr.conjugate() 
np.multiply(arr,res,out=res) 

जहाँ हम यानी एक जटिल संख्या के पेट की संपत्ति, abs(z) = sqrt(z*z.conjugate) शोषण, ताकि abs(z)**2 = z*z.conjugate