Numpy: बग: np.vectorize () फ़ंक्शन पहले तत्व पर दो बार काम करते हैं (जैसा कि देखा जाता है कि फ़ंक्शन एक उत्परिवर्तित वस्तु को संशोधित करता है)

को निर्मित 8 मार्च 2017 · 7टिप्पणियाँ · स्रोत: numpy/numpy

मेरे पास शब्दकोशों की एक सूची है। मैं एक फ़ंक्शन लागू करने के लिए np.vectorize का उपयोग करने की कोशिश कर रहा हूं जो सूची में प्रत्येक शब्दकोश के लिए शब्दकोश तत्वों को संशोधित करता है। परिणाम दिखाते हैं कि वेक्टराइज़ पहले तत्व पर दो बार अभिनय कर रहा है। क्या यह एक बग है जिसे ठीक किया जा सकता है? (शायद इस तथ्य से संबंधित है कि पहले तत्व पर चेक प्रकार को वेक्टराइज़ करें?) नीचे कुछ उदाहरण मामले और आउटपुट हैं:

कोई शब्दकोश संशोधन के साथ एक साधारण परीक्षण का मामला:

def fcn1(x):
    return x['b']
a = [{'b': 1} for _ in range(3) ]
print(a)
print(np.vectorize(fcn1)(a))
print(a, '\n\n')

उत्पादन:

[{'b': 1}, {'b': 1}, {'b': 1}]
[1 1 1]
[{'b': 1}, {'b': 1}, {'b': 1}]

अब शब्दकोश को संशोधित करें और देखें कि फ़ंक्शन पहले तत्व से दो बार लागू होता है:

def fcn2(x):
    x['b'] += 1
    return x['b']
a = [{'b': 1} for _ in range(3) ]
print(a)
print(np.vectorize(fcn2)(a))
print(a, '\n\n')

उत्पादन:

[{'b': 1}, {'b': 1}, {'b': 1}]
[3 2 2]
[{'b': 3}, {'b': 2}, {'b': 2}]

बग की स्थिरता की जांच करने के लिए एक अलग संशोधन का प्रयास करें:

def fcn3(x):
    x['b'] *= 2
    return x['b']
a = [{'b': 1} for _ in range(3) ]
print(a)
print(np.vectorize(fcn3)(a))
print(a, '\n\n')

उत्पादन:

[{'b': 1}, {'b': 1}, {'b': 1}]
[4 2 2]
[{'b': 4}, {'b': 2}, {'b': 2}]

आप वास्तव में रिटर्न वैल्यू प्रदान किए बिना ही काम कर सकते हैं (जो कि मेरे उपयोग मामले में इसका उपयोग करने की कोशिश कर रहा है):

def fcn4(x):
    x['b'] += 1
a = [{'b': 1} for _ in range(3) ]
print(a)
np.vectorize(fcn4)(a)
print(a, '\n\n')

उत्पादन:

[{'b': 1}, {'b': 1}, {'b': 1}]
[{'b': 3}, {'b': 2}, {'b': 2}]

और वैसे, लंबाई 3 की सूची के बारे में कुछ खास नहीं है, आप इसे बदल सकते हैं और केवल पहले तत्व के दोहरे-संशोधित होने के समान व्यवहार को देख सकते हैं।

मैंने Numpy संस्करण 1.11.3 और 1.12.0 दोनों का उपयोग करके व्यवहार की पुष्टि की है

संपादित करें:
मुझे एक ऐसा काम मिला, जिसके बारे में इसकी पुष्टि "पहले तत्व पर प्रकार का परीक्षण" भी करता है। यदि आप otypes तर्क निर्दिष्ट करते हैं, तो पहला तत्व दो बार हिट नहीं होता है:

def fcn(x):
    x['b'] += 1
    return x['b']
a = [{'b': 1} for _ in range(3)]
print a
print np.vectorize(fcn, otypes=[dict])(a)
print a, '\n\n'

उत्पादन:

[{'b': 1}, {'b': 1}, {'b': 1}]
[2 2 2]
[{'b': 2}, {'b': 2}, {'b': 2}]

00 - Bug

स्रोत

danjump

👍2

सबसे उपयोगी टिप्पणी

"यदि ओट्स को निर्दिष्ट नहीं किया जाता है, तो आउटपुट की संख्या निर्धारित करने के लिए पहले तर्क के साथ फ़ंक्शन पर कॉल का उपयोग किया जाएगा। इस कॉल के परिणाम कैश हो जाएंगे यदि फ़ंक्शन को दो बार कॉल करने से रोकने के लिए सही है। हालांकि, कार्यान्वित करने के लिए। कैश, मूल फ़ंक्शन को लपेटा जाना चाहिए जो बाद की कॉल को धीमा कर देगा, इसलिए केवल ऐसा करें यदि आपका फ़ंक्शन महंगा है। "
https://docs.scipy.org/doc/numpy/reference/generated/numpy.vectorize.html

तो यह अच्छी तरह से प्रलेखित व्यवहार है, लेकिन लगता है कि उल्टा है। तो शायद बग फिक्स की तुलना में इसकी अधिक वृद्धि।

warut-vijit 8 मार्च 2017

👍3

सभी 7 टिप्पणियाँ

मैंने अभी अपनी पोस्ट को एक नए परीक्षण के साथ संपादित किया है जो प्रथम आइटम प्रकार आईएस की जांच करने की पुष्टि करता है जो समस्या का कारण बनता है

danjump 8 मार्च 2017

सरल परीक्षण:

a = np.array([1, 2, 3])
def f(x):
    print('got', x)
    return x
fv = np.vectorize(f)
y = fv(a)

देता है:

got 1
got 1
got 2
got 3

eric-wieser 8 मार्च 2017

warut-vijit 8 मार्च 2017

👍3

आह, स्पष्ट रूप से मैंने सभी डॉक्स को अच्छी तरह से नहीं पढ़ा। यह दोहरी कॉल के मुद्दे को ठीक करता है लेकिन धीमी निष्पादन की कीमत पर। इसलिए मुझे लगता है कि प्रदर्शन को बनाए रखते हुए इस दोहरे कॉलिंग को रोकने का कोई तरीका नहीं है?

danjump 8 मार्च 2017

उदाहरण के लिए, numpy/lib/function_base.py vectorize _get_ufunc_and_otypes() , मुझे लगता है कि आप इन पंक्तियों को संशोधित कर सकते हैं।

inputs = [arg.flat[0] for arg in args]
outputs = func(*inputs)

सेवा:

#earlier
import copy

...

inputs = copy.deepcopy([arg.flat[0] for arg in args])
outputs = func(*inputs)

और फिर आपको कैशिंग का उपयोग नहीं करना होगा या ओटीपी को निर्दिष्ट नहीं करना होगा, लेकिन मुझे लगता है कि आप वास्तविक परिवर्तनशील तत्वों को दो बार मारने से बचते हैं। लेकिन मैं इस बात से अनभिज्ञ हूं कि कैशिंग की तुलना में कितना प्रदर्शन हिट होगा।

मैं सिर्फ यह समझ पा रहा हूं कि कैशिंग व्यवहार को महंगी फ़ंक्शन निष्पादन समय को ध्यान में रखते हुए बनाया गया था, न कि किसी फ़ंक्शन के मामले के बारे में सोचकर एक परिवर्तनशील वस्तु को संशोधित करना। मुझे लगता है कि कैशिंग के प्रदर्शन हिट के बिना उत्परिवर्तित वस्तु संशोधन को समायोजित करना संभव है, जो एक लंबे समय के निष्पादन का समय था।

danjump 8 मार्च 2017

मुझे लगता है कि बहुत बड़ी वस्तुओं की सरणियों पर वेक्टरकृत संचालन के लिए, यह वास्तव में अधिक कम्प्यूटेशनल रूप से गहन हो सकता है कि फ़ंक्शन को लागू करने के लिए पहले तत्व की एक गहरी प्रतिलिपि बनाने के लिए। तो यह एक अच्छा विचार हो सकता है कि उस कार्यक्षमता का होना यदि उपयोगकर्ता otype निर्दिष्ट नहीं करता है, लेकिन फिर प्रलेखन में कहें कि प्रदर्शन तब तक हिट हो सकता है जब तक otype बड़े के सरणियों के लिए निर्दिष्ट न हो। वस्तुओं। @ एरिक-वेसर आपको क्या लगता है?

warut-vijit 8 मार्च 2017

copy.deepcopy() कई इनपुट पर सुरक्षित नहीं है, इसलिए दुर्भाग्य से यह एक व्यवहार्य विकल्प नहीं है।

इसे ठीक करने का एकमात्र तरीका vectorize के कोर को फिर से लिखना होगा, जो वर्तमान में numpy.frompyfunc का उपयोग करता है वास्तव में सुन्न ufunc बनाने के लिए। एक वैकल्पिक आंतरिक लूप बनाने की आवश्यकता होगी, जैसा कि हम np.apply_along_axis लिए उपयोग करते हैं। दुर्भाग्य से, प्रदर्शन में गिरावट से बचने के लिए, मुझे लगता है कि हमें सी में लूप करने की आवश्यकता होगी (जैसे frompyfunc निर्माण ufunc में होता है)।

shoyer 9 मार्च 2017

क्या यह पृष्ठ उपयोगी था?

0 / 5 - 0 रेटिंग्स

सबसे उपयोगी टिप्पणी

सभी 7 टिप्पणियाँ

संबंधित मुद्दों