NumPy 1.14 - The numpy.ma module

Numpy.ma मॉड्यूल




numpy

Numpy.ma मॉड्यूल

दलील

नकाबपोश सरणियाँ ऐसी सरणियाँ हैं जिनमें गुम या अमान्य प्रविष्टियाँ हो सकती हैं। numpy.ma मॉड्यूल numpy.ma लगभग कार्य-समान प्रतिस्थापन प्रदान करता है जो मास्क के साथ डेटा सरणियों का समर्थन करता है।

एक नकाबपोश सरणी क्या है?

कई परिस्थितियों में, डेटासेट अमान्य डेटा की उपस्थिति से अधूरा या दागी हो सकता है। उदाहरण के लिए, एक सेंसर डेटा रिकॉर्ड करने में विफल हो सकता है, या एक अमान्य मूल्य दर्ज किया जा सकता है। numpy.ma मॉड्यूल नकाबपोश सरणियों को शुरू करके, इस मुद्दे को हल करने के लिए एक सुविधाजनक तरीका प्रदान करता है।

एक नकाबपोश सरणी एक मानक numpy.ndarray और एक मुखौटा का संयोजन है। एक मुखौटा या तो nomask , यह दर्शाता है कि संबद्ध सरणी का कोई मूल्य अमान्य नहीं है, या बुलियन का एक सरणी जो संबद्ध सरणी के प्रत्येक तत्व के लिए निर्धारित करता है कि क्या मूल्य मान्य है या नहीं। जब मुखौटा का एक तत्व False , तो संबंधित सरणी का संगत तत्व मान्य होता है और इसे बिना बोले कहा जाता है। जब मास्क का एक तत्व True , तो संबंधित एरे के संबंधित तत्व को नकाब (अमान्य) कहा जाता है।

पैकेज यह सुनिश्चित करता है कि गणना में नकाबपोश प्रविष्टियों का उपयोग नहीं किया जाता है।

चित्रण के रूप में, आइए निम्नलिखित डेटासेट पर विचार करें:

>>> import numpy as np
>>> import numpy.ma as ma
>>> x = np.array([1, 2, 3, -1, 5])

हम चौथी प्रविष्टि को अमान्य के रूप में चिह्नित करना चाहते हैं। सबसे आसान एक नकाबपोश सरणी बनाना है:

>>> mx = ma.masked_array(x, mask=[0, 0, 0, 1, 0])

अमान्य डेटा को ध्यान में रखते हुए, हम अब डेटासेट के माध्य की गणना कर सकते हैं:

>>> mx.mean()
2.75

numpy.ma मॉड्यूल

numpy.ma मॉड्यूल की मुख्य विशेषता MaskedArray क्लास है, जो numpy.ndarray एक उपवर्ग है। MaskedArray वर्ग अनुभाग में वर्ग, इसकी विशेषताओं और विधियों को अधिक विवरण में वर्णित किया गया है।

numpy.ma मॉड्यूल को numpy अतिरिक्त उपयोग किया जा सकता है:

>>> import numpy as np
>>> import numpy.ma as ma

दूसरे तत्व को अमान्य बनाने के लिए, हम करेंगे:

>>> y = ma.array([1, 2, 3], mask = [0, 1, 0])

एक नकाबपोश सरणी बनाने के लिए जहां 1.e20 के करीब सभी मान अमान्य हैं, हम करेंगे:

>>> z = masked_values([1.0, 1.e20, 3.0, 4.0], 1.e20)

नकाबपोश सरणियों के लिए निर्माण विधियों की एक पूरी चर्चा के लिए कृपया अनुभाग को देखें नकाबपोश सरणियों का निर्माण

Numpy.ma का उपयोग करना

नकाबपोश सरणियों का निर्माण

एक नकाबपोश सरणी के निर्माण के कई तरीके हैं।

  • पहली संभावना है कि सीधे MaskedArray वर्ग का आह्वान किया MaskedArray
  • एक दूसरी संभावना दो नकाबपोश सरणी कंस्ट्रक्टर, array और masked_array

    array (डेटा [, dtype, copy, ऑर्डर, मास्क,…]) संभवतः नकाबपोश मूल्यों के साथ एक सरणी वर्ग।
    masked_array MaskedArray उपनाम
  • एक तीसरा विकल्प मौजूदा सरणी का दृश्य लेना है। उस स्थिति में, दृश्य का मुखौटा nomask करने के लिए सेट किया nomask यदि सरणी का कोई नाम फ़ील्ड नहीं है, या सरणी के रूप में उसी संरचना के साथ बूलियन का एक सरणी अन्यथा।

    >>> x = np.array([1, 2, 3])
    >>> x.view(ma.MaskedArray)
    masked_array(data = [1 2 3],
                 mask = False,
           fill_value = 999999)
    >>> x = np.array([(1, 1.), (2, 2.)], dtype=[('a',int), ('b', float)])
    >>> x.view(ma.MaskedArray)
    masked_array(data = [(1, 1.0) (2, 2.0)],
                 mask = [(False, False) (False, False)],
           fill_value = (999999, 1e+20),
                dtype = [('a', '<i4'), ('b', '<f8')])
    
  • फिर भी एक और संभावना निम्न कार्यों में से किसी का उपयोग करना है:

    asarray ([ए, डीटाइप, ऑर्डर]) इनपुट को दिए गए डेटा-प्रकार के एक नकाबपोश सरणी में परिवर्तित करें।
    asanyarray ([, dtype]) उपवर्गों को संरक्षित करते हुए, इनपुट को एक नकाबपोश सरणी में बदलें।
    fix_invalid ([, मास्क, कॉपी, fill_value]) नकाबपोश अमान्य डेटा के साथ इनपुट लौटाएं और एक फिल वैल्यू द्वारा प्रतिस्थापित करें।
    masked_equal (एक्स, मूल्य [, कॉपी]) किसी दिए गए मान के बराबर एक सरणी मास्क।
    masked_greater (x, मान [, प्रतिलिपि]) किसी दिए गए मान से अधिक एक सरणी मास्क।
    masked_greater_equal (x, मान [, प्रतिलिपि]) किसी सरणी को किसी दिए गए मान से अधिक या उसके बराबर में मास्क करें।
    masked_inside (x, v1, v2 [, कॉपी]) किसी दिए गए अंतराल के अंदर एक सरणी मास्क।
    masked_invalid ([, कॉपी]) एक सरणी को अमान्य मानों (NaNs या infs) में मास्क करें।
    masked_less (x, मान [, प्रतिलिपि]) किसी दिए गए मान से कम पर एक सरणी मास्क।
    masked_less_equal (x, मान [, प्रतिलिपि]) किसी सरणी को किसी दिए गए मान से कम या बराबर के बराबर रखें।
    masked_not_equal (x, मान [, प्रतिलिपि]) एक एरे को मास्क करें जहां दिए गए मान के बराबर not
    masked_object (x, मान [, कॉपी, सिकोड़ें]) एरे x मास्क करें जहां डेटा मूल्य के बराबर है।
    masked_outside (x, v1, v2 [, कॉपी]) किसी दिए गए अंतराल के बाहर एक सरणी मास्क।
    masked_values (x, मान [, rtol, atol, copy,…]) फ्लोटिंग पॉइंट समानता का उपयोग करते हुए मास्क।
    masked_where (स्थिति, एक [, प्रतिलिपि]) एक एरे को मास्क करें जहां एक शर्त पूरी होती है।

डेटा एक्सेस करना

एक नकाबपोश सरणी के अंतर्निहित डेटा को कई तरीकों से एक्सेस किया जा सकता है:

  • data विशेषता के माध्यम से। आउटपुट व्यूह सरणी numpy.ndarray पर अंतर्निहित डेटा के प्रकार के आधार पर एक numpy.ndarray रूप में numpy.ndarray और उसके एक उपवर्ग के रूप में सरणी का एक दृश्य है।
  • __array__ विधि के माध्यम से। आउटपुट तो एक numpy.ndarray
  • सीधे एक numpy.ndarray या उसके उपवर्ग (जो वास्तव में data विशेषता का उपयोग करता है) के रूप में नकाबपोश सरणी का एक दृश्य लेने से।
  • getdata फ़ंक्शन का उपयोग करके।

इनमें से कोई भी तरीका पूरी तरह से संतोषजनक नहीं है अगर कुछ प्रविष्टियों को अमान्य के रूप में चिह्नित किया गया है। एक सामान्य नियम के रूप में, जहां किसी भी मुखौटे वाली प्रविष्टियों के बिना सरणी का प्रतिनिधित्व आवश्यक है, सरणी को filled विधि से भरने की सिफारिश की जाती है।

नकाब तक पहुँचना

एक नकाबपोश सरणी का mask इसकी mask विशेषता के माध्यम से सुलभ है। हमें यह ध्यान रखना चाहिए कि मास्क में एक True प्रविष्टि एक अमान्य डेटा को इंगित करती है।

एक और संभावना getmask और getmaskarray कार्यों का उपयोग करना है। getmask(x) का मास्क आउटपुट करता है यदि x एक नकाबपोश सरणी है, और विशेष मूल्य nomask अन्यथा। getmaskarray(x) का मास्क आउटपुट करता है यदि x एक नकाबपोश सरणी है। यदि x में कोई अमान्य प्रविष्टि नहीं है या नकाबपोश सरणी नहीं है, तो फ़ंक्शन x रूप में कई तत्वों के साथ False की बूलियन सरणी को आउटपुट करता है।

केवल मान्य प्रविष्टियों तक पहुँचना

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

>>> x = ma.array([[1, 2], [3, 4]], mask=[[0, 1], [1, 0]])
>>> x[~x.mask]
masked_array(data = [1 4],
             mask = [False False],
       fill_value = 999999)

मान्य डेटा को पुनर्प्राप्त करने का एक अन्य तरीका compressed विधि का उपयोग करना है, जो एक आयामी आयाम (या इसके उपवर्गों में से एक, baseclass विशेषता के मूल्य के आधार पर) लौटाता है:

>>> x.compressed()
array([1, 4])

ध्यान दें कि compressed का उत्पादन हमेशा 1D होता है।

मुखौटा को संशोधित करना

प्रविष्टि दर्ज करना

एक नकाबपोश सरणी के एक या कई विशिष्ट प्रविष्टियों को अमान्य के रूप में चिह्नित करने का अनुशंसित तरीका उनके लिए masked विशेष मूल्य प्रदान करना है:

>>> x = ma.array([1, 2, 3])
>>> x[0] = ma.masked
>>> x
masked_array(data = [-- 2 3],
             mask = [ True False False],
       fill_value = 999999)
>>> y = ma.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
>>> y[(0, 1, 2), (1, 2, 0)] = ma.masked
>>> y
masked_array(data =
 [[1 -- 3]
  [4 5 --]
  [-- 8 9]],
             mask =
 [[False  True False]
  [False False  True]
  [ True False False]],
       fill_value = 999999)
>>> z = ma.array([1, 2, 3, 4])
>>> z[:-2] = ma.masked
>>> z
masked_array(data = [-- -- 3 4],
             mask = [ True  True False False],
       fill_value = 999999)

दूसरी संभावना mask सीधे संशोधित करने की है, लेकिन यह उपयोग हतोत्साहित करता है।

ध्यान दें

एक सरल, गैर-संरचित डेटाटाइप के साथ एक नया नकाबपोश सरणी बनाते समय, मुखौटा शुरू में विशेष मूल्य के nomask सेट किया nomask , जो बूलियन False लगभग मेल खाता है। nomask एक तत्व को सेट करने की कोशिश करना nomask अपवाद के साथ विफल हो जाएगा, क्योंकि बूलियन आइटम असाइनमेंट का समर्थन नहीं करता है।

किसी सरणी की सभी प्रविष्टियों को एक बार में मुखौटा को True बताकर मास्क लगाया जा सकता है:

>>> x = ma.array([1, 2, 3], mask=[0, 0, 1])
>>> x.mask = True
>>> x
masked_array(data = [-- -- --],
             mask = [ True  True  True],
       fill_value = 999999)

अंत में, विशिष्ट प्रविष्टियों को नकाब और / या बिना मास्क के मल के अनुक्रम से असाइन किया जा सकता है:

>>> x = ma.array([1, 2, 3])
>>> x.mask = [0, 1, 0]
>>> x
masked_array(data = [1 -- 3],
             mask = [False  True False],
       fill_value = 999999)

एक प्रविष्टि अनमास्किंग

एक या कई विशिष्ट प्रविष्टियों को अनमस्क करने के लिए, हम उन्हें केवल एक या कई नए मान्य मान निर्दिष्ट कर सकते हैं:

>>> x = ma.array([1, 2, 3], mask=[0, 0, 1])
>>> x
masked_array(data = [1 2 --],
             mask = [False False  True],
       fill_value = 999999)
>>> x[-1] = 5
>>> x
masked_array(data = [1 2 5],
             mask = [False False False],
       fill_value = 999999)

ध्यान दें

प्रत्यक्ष असाइनमेंट द्वारा एक प्रविष्टि को hardmask करना चुपचाप विफल हो जाएगा यदि नकाबपोश सरणी में हार्ड मास्क है, जैसा कि hardmask विशेषता द्वारा दिखाया गया है। मास्क को ओवरराइट करने से रोकने के लिए यह सुविधा शुरू की गई थी। एक प्रविष्टि के soften_mask को बाध्य करने के लिए जहां सरणी में एक हार्ड मास्क है, आवंटन से पहले soften_mask विधि का उपयोग करके पहले मुखौटा को नरम करना होगा। इसे फिर से सख्त किया जा सकता है:

>>> x = ma.array([1, 2, 3], mask=[0, 0, 1], hard_mask=True)
>>> x
masked_array(data = [1 2 --],
             mask = [False False  True],
       fill_value = 999999)
>>> x[-1] = 5
>>> x
masked_array(data = [1 2 --],
             mask = [False False  True],
       fill_value = 999999)
>>> x.soften_mask()
>>> x[-1] = 5
>>> x
masked_array(data = [1 2 5],
             mask = [False False  False],
       fill_value = 999999)
>>> x.harden_mask()

एक नकाबपोश सरणी के सभी नकाबपोश प्रविष्टियों को nomask करने के लिए (बशर्ते कि मुखौटा एक कठिन मुखौटा नहीं है), सबसे सरल उपाय मुखौटा को निरंतर nomask असाइन करना है:

>>> x = ma.array([1, 2, 3], mask=[0, 0, 1])
>>> x
masked_array(data = [1 2 --],
             mask = [False False  True],
       fill_value = 999999)
>>> x.mask = ma.nomask
>>> x
masked_array(data = [1 2 3],
             mask = [False False False],
       fill_value = 999999)

अनुक्रमण और टुकड़ा करने की क्रिया

MaskedArray का उपवर्ग है, यह अनुक्रमण और स्लाइसिंग के लिए अपने तंत्र को विरासत में मिला है।

बिना किसी नाम वाले फ़ील्ड के नकाबपोश सरणी की एकल प्रविष्टि तक पहुँचने पर, आउटपुट या तो एक स्केलर होता है (यदि मास्क की संगत प्रविष्टि False ) या विशेष मूल्य का masked (यदि मुखौटा की संगत प्रविष्टि True )

>>> x = ma.array([1, 2, 3], mask=[0, 0, 1])
>>> x[0]
1
>>> x[-1]
masked_array(data = --,
             mask = True,
       fill_value = 1e+20)
>>> x[-1] is ma.masked
True

यदि नकाबपोश सरणी ने फ़ील्ड्स का नाम दिया है, तो एक एकल प्रविष्टि का उपयोग करना एक numpy.void ऑब्जेक्ट देता है यदि फ़ील्ड्स में से कोई भी नकाबपोश नहीं है, या 0d नकाबपोश सरणी एक ही dtype के साथ प्रारंभिक सरणी के रूप में है यदि फ़ील्ड में से कम से कम एक नकाबपोश है।

>>> y = ma.masked_array([(1,2), (3, 4)],
...                mask=[(0, 0), (0, 1)],
...               dtype=[('a', int), ('b', int)])
>>> y[0]
(1, 2)
>>> y[-1]
masked_array(data = (3, --),
             mask = (False, True),
       fill_value = (999999, 999999),
            dtype = [('a', '<i4'), ('b', '<i4')])

एक स्लाइस को एक्सेस करते समय, आउटपुट एक नकाबपोश सरणी है, जिसकी data विशेषता मूल डेटा का एक दृश्य है, और जिसका मुखौटा या तो nomask (यदि मूल सरणी में कोई अमान्य प्रविष्टियाँ नहीं थीं) या मूल के संबंधित स्लाइस का एक दृश्य मुखौटा। मूल को मुखौटा के किसी भी संशोधन के प्रसार को सुनिश्चित करने के लिए दृश्य की आवश्यकता होती है।

>>> x = ma.array([1, 2, 3, 4, 5], mask=[0, 1, 0, 0, 1])
>>> mx = x[:3]
>>> mx
masked_array(data = [1 -- 3],
             mask = [False  True False],
       fill_value = 999999)
>>> mx[1] = -1
>>> mx
masked_array(data = [1 -1 3],
             mask = [False False False],
       fill_value = 999999)
>>> x.mask
array([False,  True, False, False,  True])
>>> x.data
array([ 1, -1,  3,  4,  5])

संरचित डेटाटाइप के साथ एक नकाबपोश सरणी के एक क्षेत्र तक पहुंचना एक MaskedArray रिटर्न देता है।

नकाबपोश बंदियों पर कार्रवाई

अंकगणित और तुलनात्मक संचालन नकाबपोश सरणियों द्वारा समर्थित हैं। जितना संभव हो, एक नकाबपोश सरणी की अवैध प्रविष्टियों को संसाधित नहीं किया जाता है, जिसका अर्थ है कि ऑपरेशन के पहले और बाद में संबंधित data प्रविष्टियां समान होनी चाहिए।

चेतावनी

हमें इस बात पर बल देने की आवश्यकता है कि यह व्यवहार व्यवस्थित नहीं हो सकता है, कि नकाबपोश डेटा कुछ मामलों में ऑपरेशन से प्रभावित हो सकता है और इसलिए उपयोगकर्ताओं को शेष अपरिवर्तित इस डेटा पर भरोसा नहीं करना चाहिए।

numpy.ma मॉड्यूल अधिकांश ufuncs के विशिष्ट कार्यान्वयन के साथ आता है। वैधता और द्विआधारी फ़ंक्शन जिनके पास वैधता डोमेन है (जैसे log या divide ) जब भी इनपुट मास्क किया जाता है या वैधता डोमेन के बाहर गिरता है, तो masked निरंतर लौटते हैं:

>>> ma.log([-1, 0, 1, 2])
masked_array(data = [-- -- 0.0 0.69314718056],
             mask = [ True  True False False],
       fill_value = 1e+20)

नकाबपोश सरणियाँ भी मानक सुन्न ufuncs का समर्थन करती हैं। आउटपुट तो एक नकाबपोश सरणी है। जहां भी इनपुट होता है, वहां एक ufunc का परिणाम नकाबपोश होता है। एक इनपुट के किसी भी नकाब पर जहां भी बाइनरी ufunc का परिणाम होता है, नकाबपोश होता है। यदि ufunc वैकल्पिक संदर्भ आउटपुट भी लौटाता है (एक 3-तत्व tuple जिसमें ufunc का नाम, उसके तर्क और उसका डोमेन होता है), संदर्भ संसाधित होता है और आउटपुट नकाबपोश सरणी की प्रविष्टियाँ जहाँ भी वैधता के बाहर संगत गिरावट आती हैं, वहां अंकित की जाती हैं डोमेन:

>>> x = ma.array([-1, 1, 0, 2, 3], mask=[0, 0, 0, 0, 1])
>>> np.log(x)
masked_array(data = [-- -- 0.0 0.69314718056 --],
             mask = [ True  True False False  True],
       fill_value = 1e+20)

उदाहरण

किसी दिए गए मान के साथ डेटा अनुपलब्ध डेटा का प्रतिनिधित्व करता है

आइए तत्वों की एक सूची पर विचार करें, x , जहां -9999 के मान हैं। लापता डेटा का प्रतिनिधित्व करते हैं। हम डेटा के औसत मूल्य और विसंगतियों के वेक्टर की गणना करना चाहते हैं (औसत से विचलन):

>>> import numpy.ma as ma
>>> x = [0.,1.,-9999.,3.,4.]
>>> mx = ma.masked_values (x, -9999.)
>>> print mx.mean()
2.0
>>> print mx - mx.mean()
[-2.0 -1.0 -- 1.0 2.0]
>>> print mx.anom()
[-2.0 -1.0 -- 1.0 2.0]

लापता डेटा में भरना

मान लीजिए कि अब हम उसी डेटा को प्रिंट करना चाहते हैं, लेकिन औसत मूल्य द्वारा प्रतिस्थापित लापता मूल्यों के साथ।

>>> print mx.filled(mx.mean())
[ 0.  1.  2.  3.  4.]

संख्यात्मक ऑपरेशन

गुम मूल्यों, शून्य से विभाजित, नकारात्मक संख्याओं की वर्गमूल आदि के बारे में चिंता किए बिना संख्यात्मक कार्यों को आसानी से किया जा सकता है।

>>> import numpy as np, numpy.ma as ma
>>> x = ma.array([1., -1., 3., 4., 5., 6.], mask=[0,0,0,0,1,0])
>>> y = ma.array([1., 2., 0., 4., 5., 6.], mask=[0,0,0,0,0,1])
>>> print np.sqrt(x/y)
[1.0 -- -- 1.0 -- --]

आउटपुट के चार मान अमान्य हैं: पहला एक ऋणात्मक संख्या के वर्गमूल को लेने से आता है, दूसरा विभाजन से शून्य और अंतिम दो में जहां इनपुट से मुखौटे थे।

चरम मूल्यों की अनदेखी

आइए 0 और 1. के बीच यादृच्छिक फ़्लोट्स की एक सरणी d पर विचार करें। हम सीमा के बाहर किसी भी डेटा को अनदेखा करते हुए d के मूल्यों की औसत गणना करना चाहते हैं [0.1, 0.9] :

>>> print ma.masked_outside(d, 0.1, 0.9).mean()