Comment masquer une numpy tableau 2D?

Dire que j'ai un tableau à deux dimensions de coordonnées qui ressemble à quelque chose comme

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

Précédemment dans mon travail jusqu'à présent, j'ai généré un masque qui finit par ressembler à

mask = [False,False,True]

Lorsque j'essaie d'utiliser ce masque sur le 2D coordonner vecteur, j'obtiens une erreur

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.`

qui fait sens, je suppose. J'ai donc essayé d'utiliser simplement le masque suivant à la place:

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

Et ce que je reçois est proche:

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

à ce que je m'attends (et l'envie):

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

Il doit y avoir un moyen plus facile de faire cela?

OriginalL'auteur Anonymous | 2016-07-05

6

Est-ce ce que vous recherchez?
```
import numpy as np
x[~np.array(mask)]
# array([[1, 2],
#        [2, 3]])
```
Ou de numpy masqué tableau:
```
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)
```
Ah je vois, ce que j'ai essayé ne fonctionne, je ne peux pas compresser. Hm. est-il un moyen de supprimer masqué éléments d'un tableau sans perdre la dimension de la matrice? np.ma.compressed() fait les deux.
Je ne suis pas trop sur masqués tableau, probablement le même niveau que vous. Juste essayer de le faire fonctionner. Eh bien, si vous essayez de supprimer des éléments, je pense que la logique de l'index n'est pas une mauvaise façon.

OriginalL'auteur Psidom

Votre x est 3x2:

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

Faire un 3-élément booléen masque:

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

Qui peut être utilisé pour sélectionner les lignes où il est Vrai, ou si elle est Fausse. Dans les deux cas, le résultat est 2d:

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

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

C'est sans l'aide de la MaskedArray sous-classe. Pour faire un tel tableau, nous avons besoin d'un masque qui correspond à x en forme. Il n'y a pas de disposition pour le masquage qu'une dimension.

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)

L'application de compressed à qui produit un raveled tableau: array([1, 2, 2, 3])

Depuis le masquage est l'élément par élément, il pourrait masquer un élément dans la ligne 1, 2 de la rangée 2, etc. Donc, en général,compressing, en supprimant les éléments masqués, ne cède pas d'un tableau 2d. La forme aplatie est le seul général choix.

np.ma a plus de sens quand il y a une diffusion de la masqués valeurs. Il n'est pas d'une grande utilité si vous voulez sélectionner ou désélectionner l'ensemble des lignes ou des colonnes.

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

Ici sont plus typique masqué tableaux:

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)

OriginalL'auteur hpaulj

2

Depuis aucune de ces solutions n'a fonctionné pour moi, j'ai pensé à écrire ce qu'une solution n'a, peut-être qu'il sera utile pour quelqu'un d'autre. J'utilise python 3.x et j'ai travaillé sur les deux tableaux 3D. L'une, que j'appelle data_3D contient les valeurs flottantes des enregistrements dans un scanner du cerveau, et de l'autre, template_3D contenant des entiers qui représentent les régions du cerveau. Je voulais choisir les valeurs de data_3D correspondant à un nombre entier region_code comme par template_3D:
```
my_mask = np.in1d(template_3D, region_code).reshape(template_3D.shape)
data_3D_masked = data_3D[my_mask]
```
ce qui me donne un tableau 1D de seulement pertinents enregistrements.

OriginalL'auteur CrossEntropy
1

Dans votre dernier exemple, le problème n'est pas le masque. Il est de votre utilisation de compressed. À partir de la docstring de compressed:
```
Return all the non-masked data as a 1-D array.
```
Donc compressed aplatit le nonmasked valeurs dans un 1-d de la matrice. (Il le doit, car il n'y a aucune garantie que les données compressées aura un n-dimensions de la structure.)

Prendre un coup d'oeil à la masqués tableau avant de le compresser:
```
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)
```
Vous avez raison, son bon avant que je le compresser. Je vais lire la documentation pour un moyen de supprimer les éléments masqués, tout en préservant la matrice de la dimensionnalité. Merci
Si je comprends ce que vous essayez de faire, @Psidom première suggestion semble raisonnable. En particulier, vous n'avez probablement pas besoin d'un masqués tableau. Indexer un tableau normal avec un booléen tableau.

OriginalL'auteur Warren Weckesser

Vous devez vous connecter pour publier un commentaire.