如何正确屏蔽 numpy 二维数组？

Question

假设我有一个二维坐标数组，看起来像

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

到目前为止，在我之前的工作中，我生成了一个面具，最终看起来像

mask = [False,False,True]

当我尝试在 2D 坐标向量上使用此蒙版时，出现错误

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]])

必须有更简单的方法来做到这一点？

Answer 1

这是您要找的吗？

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

或者从numpy 掩码数组：

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)

Answer 2

你的x是 3x2：

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

制作一个 3 元素布尔掩码：

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

这可用于选择为 True 或为 False 的行。 在这两种情况下，结果都是 2d：

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

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

这是不使用 MaskedArray 子类的。 为了制作这样的数组，我们需要一个在形状上与x匹配的掩码。 没有规定仅屏蔽一维。

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会产生一个散乱的数组： array([1, 2, 2, 3])

由于屏蔽是逐个元素进行的，它可以屏蔽第 1 行中的一个元素，第 2 行中的第 2 行等。因此，通常compressing 、移除被屏蔽的元素不会产生二维数组。 扁平形式是唯一的通用选择。

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)

Answer 3

由于这些解决方案都不适合我，我想写下解决方案的作用，也许对其他人有用。 我使用 python 3.x 并且我处理了两个 3D 数组。 一个，我称之为data_3D包含脑部扫描记录的浮点值，另一个， template_3D包含代表大脑区域的整数。 我想从data_3D选择这些值，对应于每个template_3D的整数region_code ：

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

这给了我一个只有相关录音的一维数组。

Answer 4

使用np.where你可以做各种各样的事情：

x_maskd = np.where(mask, x, 0)

Answer 5

如果你有

A =  [[  8.   0. 165.  22. 164.  47. 184. 185.]
      [  0.   6. -74. -27.  63.  49. -46. -48.]
      [165. -74.   0.   0.   0.   0.   0.   0.]
      [ 22. -27.   0.   0.   0.   0.   0.   0.]
      [164.  63.   0.   0.   0.   0.   0.   0.]
      [ 47.  49.   0.   0.   0.   0.   0.   0.]
      [184. -46.   0.   0.   0.   0.   0.   0.]
      [185. -48.   0.   0.   0.   0.   0.   0.]]

你的面具是

mask = np.array([True, True, True, False, True, False, True, False])

然后你的蒙面 A 变成

A[mask, :][:, mask] = [[  8.   0. 165. 164. 184.]
                       [  0.   6. -74.  63. -46.]
                       [165. -74.   0.   0.   0.]
                       [164.  63.   0.   0.   0.]
                       [184. -46.   0.   0.   0.]]

Answer 6

在您的最后一个示例中，问题不在于掩码。 这是您使用的compressed . 从compressed的文档字符串：

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

因此compressed将非屏蔽值展平为一维数组。 （必须如此，因为不能保证压缩数据将具有 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)

Answer 7

masked_X = np.where(mask, X, 0)是屏蔽数据最快和最简单的方法：

X = np.array([[2,-1,4],
              [3,-3,1],
              [9,-7,2]])

mask = np.identity(3)

时间测量：

%timeit np.where(mask,X,0)

每个循环 969 ns ± 14.6 ns（7 次运行的平均值 ± 标准偏差，每次 1000000 次循环）

%timeit np.ma.array(X, mask=mask)

每个循环 6.47 µs ± 85.9 ns（7 次运行的平均值 ± 标准偏差，每次 100000 次循环）

我让你总结！