numpy.ma (नकाबपोश) सरणी मतलब विधि असंगत वापसी प्रकार

Question

मैंने देखा है कि numpy masked-array mean method रिटर्न विभिन्न प्रकार जब यह शायद नहीं करना चाहिए है:

import numpy as np 

A = np.ma.masked_equal([1,1,0], value=0) 
B = np.ma.masked_equal([1,1,1], value=0) # no masked values 

type(A.mean()) 
#numpy.float64 
type(B.mean()) 
#numpy.ma.core.MaskedArray 

अन्य numpy.ma.core.MaskedArray तरीकों के अनुरूप होने लगते हैं

type(A.sum()) == type(B.sum()) 
# True 
type(A.prod()) == type(B.prod()) 
# True 
type(A.std()) == type(B.std()) 
# True 
type(A.mean()) == type(B.mean()) 
# False 

क्या कोई इसे समझा सकता है?

अद्यतन:

if self._mask is nomask: 
     result = super(MaskedArray, self).mean(axis=axis, dtype=dtype) 

np.ma.nomaskFalse है: के रूप में साथ

C = np.ma.masked_array([1, 1, 1], mask=[False, False, False]) 
type(C.mean()) == type(A.mean()) 
# True 

Answer 1

B.mask शुरू होता है टिप्पणी में बताया।

masked_array(data = [1 1 1], 
      mask = False, 
     fill_value = 0) 

A के लिए मुखौटा एक सरणी है कि आकार में data से मेल खाता है:

यह आपके B के लिए मामला है। B में यह एक स्केलर है, False, और mean एक विशेष मामले के रूप में इसे संभालने में कामयाब रहा है।

मुझे यह देखने के लिए थोड़ा और खोदने की जरूरत है कि इसका क्या अर्थ है।

In [127]: np.mean(B) 
Out[127]: 
masked_array(data = 1.0, 
      mask = False, 
     fill_value = 0) 

In [141]: super(np.ma.MaskedArray,B).mean() 
Out[141]: 
masked_array(data = 1.0, 
      mask = False, 
     fill_value = 0) 

मुझे यकीन नहीं है कि मदद करता है; np.ndarray विधियों और np फ़ंक्शन और np.ma विधियों के बीच कुछ परिपत्र संदर्भ हैं, जो यह पहचानना मुश्किल बनाता है कि वास्तव में कौन से कोड का उपयोग किया जा रहा है। ऐसा लगता है कि यह संकलित mean विधि का उपयोग कर रहा है, लेकिन यह स्पष्ट नहीं है कि मास्किंग को कैसे संभाला जाता है।

मुझे आश्चर्य है अगर इरादे

np.mean(B.data) # or 
B.data.mean() 

उपयोग करने के लिए है और super विधि लाने सही दृष्टिकोण नहीं है।

किसी भी मामले में, एक ही सरणी, लेकिन एक वेक्टर मास्क के साथ स्केलर देता है।

In [132]: C 
Out[132]: 
masked_array(data = [1 1 1], 
      mask = [False False False], 
     fill_value = 0) 

In [133]: C.mean() 
Out[133]: 1.0 

====================

nomask शॉर्टकट के बिना इस पद्धति का प्रयास किया जा रहा है, के बाद एक त्रुटि को जन्म देती है

 dsum = self.sum(axis=axis, dtype=dtype) 
     cnt = self.count(axis=axis) 
     if cnt.shape ==() and (cnt == 0): 
      result = masked 
     else: 
      result = dsum * 1./cnt 

self.countnomask मामले में एक स्केलर देता है, लेकिन नियमित मास्किंग में np.int32। तो cnt.shape चुक्स।

trace एकमात्र अन्य मुखौटा विधि है जो इस super(MaskedArray...) 'शॉर्टकट' की कोशिश करती है। मतलब कोड के बारे में स्पष्ट रूप से कुछ है।

====================

प्रासंगिक बग मुद्दा: https://github.com/numpy/numpy/issues/5769

करने के लिए कि एक ही सवाल यहाँ पिछले साल उठाया गया था अनुसार: Testing equivalence of means of Numpy MaskedArray instances raises attribute error

ऐसा लगता है कि mean के साथ बहुत सारे मास्किंग समस्याएं हैं। अब विकास मास्टर में, या निकट भविष्य में फिक्स हो सकते हैं।