कैसे एक numpy 2 डी सरणी ठीक से मुखौटा करने के लिए?

मैं निर्देशांक के एक दो आयामी सरणी ऐसाकैसे एक numpy 2 डी सरणी ठीक से मुखौटा करने के लिए?

x = array([[1,2],[2,3],[3,4]])

पहले अपने काम में

कुछ अब तक लग रहा है कहो, मैं एक मुखौटा है कि

mask = [False,False,True]

की तरह कुछ के लिए देख समाप्त होता है उत्पन्न जब मैं 2 डी समन्वय वेक्टर पर इस मुखौटा का उपयोग करने का प्रयास करता हूं, तो मुझे एक त्रुटि मिलती है

newX = np.ma.compressed(np.ma.masked_array(x,mask)) 

>>>numpy.ma.core.MaskError: Mask and data not compatible: data size 
    is 6, mask size is 3.`

जो समझ में आता है, मुझे लगता है।

mask2 = np.column_stack((mask,mask)) 
newX = np.ma.compressed(np.ma.masked_array(x,mask2))

और क्या मैं कर रहा है करीब:: तो मैं बस निम्नलिखित मुखौटा के बजाय का उपयोग करने की कोशिश की

>>>array([1,2,2,3])

मैं क्या उम्मीद करेंगे (और चाहते हैं) के लिए

>>>array([[1,2],[2,3]])

ऐसा करने का एक आसान तरीका होना चाहिए?

स्रोत

2016-07-05 Anonymous

क्या आप यह देख रहे हैं?

import numpy as np 
x[~np.array(mask)] 
# array([[1, 2], 
#  [2, 3]])

या numpy masked array से:

newX = np.ma.array(x, mask = np.column_stack((mask, mask))) 
newX 

# masked_array(data = 
# [[1 2] 
# [2 3] 
# [-- --]], 
#    mask = 
# [[False False] 
# [False False] 
# [ True True]], 
#  fill_value = 999999)

स्रोत

2016-07-05 01:30:28 Psidom

आह मैं देखता हूं, तो मैं जो कोशिश कर रहा था वह काम करता है, मैं बस इसे संपीड़ित नहीं कर सकता। हम्म। सरणी की आयामी खोने के बिना सरणी के मुखौटे तत्वों को निकालने का कोई तरीका है? 'np.ma.compressed()' दोनों करता है। – Anonymous

मैं मास्क किए गए सरणी के बारे में बहुत कुछ नहीं करता, शायद आपके जैसा ही स्तर। बस इसे काम करने की कोशिश कर रहा है। खैर, यदि आप तत्वों को हटाने की कोशिश कर रहे हैं, तो मुझे लगता है कि तर्क सूचकांक खराब तरीका नहीं है। – Psidom

अपने पिछले उदाहरण में, समस्या मुखौटा नहीं है। यह compressed का उपयोग है। compressed की docstring से:

Return all the non-masked data as a 1-D array.

तो compressed एक 1-डी सरणी में nonmasked मूल्यों सपाट। (यह करने के लिए, कोई गारंटी नहीं कि संकुचित डेटा एक n आयामी संरचना होगा क्योंकि वहाँ है।)

इससे पहले कि आप सेक नकाबपोश सरणी पर एक नज़र डालें:

In [8]: np.ma.masked_array(x, mask2) 

Out[8]: 
masked_array(data = 
[[1 2] 
[2 3] 
[-- --]], 
      mask = 
[[False False] 
[False False] 
[ True True]], 
     fill_value = 999999)

स्रोत

2016-07-05 01:46:09

आप सही हैं, इसे संपीड़ित करने से पहले यह सही है। सरणी आयाम को संरक्षित करते समय मैं मुखौटा तत्वों को हटाने के लिए दस्तावेज़ों को पढ़ूंगा। धन्यवाद – Anonymous

अगर मैं समझता हूं कि आप क्या करने की कोशिश कर रहे हैं, तो @ Psidom का पहला सुझाव उचित दिखता है। विशेष रूप से, आपको शायद मुखौटा सरणी की आवश्यकता नहीं है। बस एक बूलियन सरणी के साथ एक नियमित सरणी सूचकांक। –

आपका x 3x2 है :

In [380]: rowmask=np.array([False,False,True])

In [379]: x 
Out[379]: 
array([[1, 2], 
     [2, 3], 
     [3, 4]])

एक 3 तत्व बूलियन मुखौटा बनाओ इसका उपयोग उन पंक्तियों का चयन करने के लिए किया जा सकता है जहां यह सच है, या जहां यह गलत है। दोनों मामलों में परिणाम 2 डी:

In [381]: x[rowmask,:] 
Out[381]: array([[3, 4]]) 

In [382]: x[~rowmask,:] 
Out[382]: 
array([[1, 2], 
     [2, 3]])

यह मास्कडएरे सबक्लास का उपयोग किए बिना है। इस तरह की सरणी बनाने के लिए, हमें एक मुखौटा चाहिए जो आकार में x से मेल खाता है। केवल एक आयाम मास्किंग के लिए प्रावधान नहीं है।, array([1, 2, 2, 3])

के बाद से मास्किंग तत्व द्वारा तत्व है, यह एक तत्व पंक्ति 1, 2 में पंक्ति 2 आदि में तो सामान्य compressing में मुखौटा सकता है को हटाने:

In [393]: xmask=np.stack((rowmask,rowmask),-1) # column stack 

In [394]: xmask 
Out[394]: 
array([[False, False], 
     [False, False], 
     [ True, True]], dtype=bool) 

In [395]: np.ma.MaskedArray(x,xmask) 
Out[395]: 
masked_array(data = 
[[1 2] 
[2 3] 
[-- --]], 
      mask = 
[[False False] 
[False False] 
[ True True]], 
     fill_value = 999999)

कि करने के लिए compressed लागू करना एक raveled सरणी का उत्पादन मुखौटा तत्व, एक 2 डी सरणी नहीं मिलेगा। चपटा हुआ रूप ही एकमात्र सामान्य विकल्प है।

np.ma मास्क किए गए मानों की बिखरने पर सबसे अधिक समझ में आता है। यदि आप पूरी पंक्तियों या स्तंभों को चुनना, या अचयनित करना चाहते हैं, तो यह बहुत अधिक मूल्य नहीं है।

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

यहाँ और अधिक विशिष्ट नकाबपोश सरणियों:

In [403]: np.ma.masked_inside(x,2,3) 
Out[403]: 
masked_array(data = 
[[1 --] 
[-- --] 
[-- 4]], 
      mask = 
[[False True] 
[ True True] 
[ True False]], 
     fill_value = 999999) 

In [404]: np.ma.masked_equal(x,2) 
Out[404]: 
masked_array(data = 
[[1 --] 
[-- 3] 
[3 4]], 
      mask = 
[[False True] 
[ True False] 
[False False]], 
     fill_value = 2) 

In [406]: np.ma.masked_outside(x,2,3) 
Out[406]: 
masked_array(data = 
[[-- 2] 
[2 3] 
[3 --]], 
      mask = 
[[ True False] 
[False False] 
[False True]], 
     fill_value = 999999)

स्रोत

2016-07-05 02:37:16 hpaulj

के बाद से इन समाधानों में से कोई भी मेरे लिए काम किया है, मैं लिखने के बारे में सोचा नीचे क्या समाधान किया, शायद यह किसी और के लिए उपयोगी होगा। मैं अजगर 3.x का उपयोग करता हूं और मैंने दो 3 डी सरणी पर काम किया। एक, जिसे मैं data_3D पर कॉल करता हूं, में मस्तिष्क स्कैन में रिकॉर्डिंग के फ्लोट वैल्यू होते हैं, और दूसरा, template_3D में पूर्णांक होते हैं जो मस्तिष्क के क्षेत्रों का प्रतिनिधित्व करते हैं। मैं एक पूर्णांक region_code करने के लिए इसी प्रति template_3D रूप data_3D से उन मूल्यों को चुनने के लिए चाहता था:

my_mask = np.in1d(template_3D, region_code).reshape(template_3D.shape) 
data_3D_masked = data_3D[my_mask]

जो मुझे केवल प्रासंगिक रिकॉर्डिंग की एक -1 डी सरणी देता है।

स्रोत

2017-06-08 10:31:03 CrossEntropy

कैसे एक numpy 2 डी सरणी ठीक से मुखौटा करने के लिए?

उत्तर

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