如何将值数组和掩码组合成矩阵？

Question

如何将值数组和掩码组合成一个矩阵，该矩阵只包含数组中的每个值一次，但仅在掩码非零的地方？ 你可以说我想用数组中的值填充掩码矩阵。

我实际上并不关心结果中原始元素的顺序。

mask = [[0, 1, 0], [1, 0, 1], [0, 1, 0]]
values = [1, 2, 3, 4]
result = some_magical_operation(mask, values)

# output: result = [[0, 1, 0], [2, 0, 3], [0, 4, 0]]

# alternative output: result2 = [[0, 2, 0], [1, 0, 3], [0, 4, 0]]
# alternative output: result3 = [[0, 4, 0], [3, 0, 2], [0, 1, 0]]

注意：我的实际矩阵比这密度要小得多。

Answer 1

In [229]: mask = [[0, 1, 0], [1, 0, 1], [0, 1, 0]] 
     ...: values = [1, 2, 3, 4]                                                          
In [230]: mask = np.array(mask, bool)                                                    
In [231]: mask                                                                           
Out[231]: 
array([[False,  True, False],
       [ True, False,  True],
       [False,  True, False]])
In [232]: res =  np.zeros(mask.shape, int)                                               

如果mask是 boolean，那么它可以用于索引res的相关槽，用于获取值或分配它们。

In [233]: res[mask]                                                                      
Out[233]: array([0, 0, 0, 0])

In [234]: res[mask]= values                                                              
In [235]: res                                                                            
Out[235]: 
array([[0, 1, 0],
       [2, 0, 3],
       [0, 4, 0]])

要使用scipy.sparse你可以这样做：

In [241]: from scipy import sparse                                                       

从mask制作一个稀疏矩阵：

In [243]: M = sparse.csr_matrix(mask, dtype=int)                                         
In [244]: M                                                                              
Out[244]: 
<3x3 sparse matrix of type '<class 'numpy.longlong'>'
    with 4 stored elements in Compressed Sparse Row format>
In [245]: M.A                                                                            
Out[245]: 
array([[0, 1, 0],
       [1, 0, 1],
       [0, 1, 0]], dtype=int64)

然后用 values 替换它的data values ：

In [246]: M.data                                                                         
Out[246]: array([1, 1, 1, 1], dtype=int64)                                                         
In [250]: M.data[:] = values                                                             
In [251]: M.A                                                                            
Out[251]: 
array([[0, 1, 0],
       [2, 0, 3],
       [0, 4, 0]], dtype=int64)

Answer 2

这是我尝试过的东西，

mask = [[0, 1, 0], [1, 0, 1], [0, 1, 0]]
val = [1, 2, 3, 4]
result=list()
k=0

for i in mask:
    for j in range(0,len(i)):
        if i[j]!=0:
            i[j]=val[k]
            k+=1
    result.append(i)
print(result)

output：

[[0, 1, 0], [2, 0, 3], [0, 4, 0]]

还需要对此代码进行一些小的修改：

1. 检查 val[k] 是否没有用完索引

Answer 3

我不知道是否有 NumPy function 为此，所以我创建了自己的：

import numpy as np


def some_magical_operation_ndarray(m: np.ndarray, v: np.ndarray) -> np.ndarray:
    res = np.zeros(m.shape)
    n = 0
    for i in range(m.shape[0]):
        for j in range(m.shape[1]):
            if not m[i, j] == 0:
                res[i, j] = v[n]
                n += 1
                if n == len(v):
                    n = 0
    return res


mask = np.asarray([[0, 1, 0], [1, 0, 1], [0, 1, 0]])
values = np.asarray([1, 2, 3, 4])
result = some_magical_operation_ndarray(mask, values)
print(result)

如果您想使用列表而不是 ndarray，则此解决方案将起作用：

def some_magical_operation_list(m: list, v: list) -> list:
    res = []
    n = 0
    for i in range(len(m)):
        res.append([])
        for j in range(len(m[i])):
            if not m[i][j] == 0:
                res[i].append(v[n])
                n += 1
                if n == len(v):
                    n = 0
            else:
                res[i].append(0)
    return res


mask = [[0, 1, 0], [1, 0, 1], [0, 1, 0]]
values = [1, 2, 3, 4]
result = some_magical_operation_list(mask, values)
print(result)

Answer 4

尝试这个：

_mask = np.nonzero(mask)
mask[_mask] = values

应该完全按照您的要求工作。

带有测试集的示例：

mask = np.random.randint(0, 2, (7,3))
mask[_mask] = np.arange(1, _mask[0].shape[0] + 1)    # the RHS is a test equivalent to 'values'

结果：

>>> mask (original):
array([[0, 0, 1],
       [1, 0, 0],
       [1, 1, 1],
       [0, 1, 1],
       [0, 1, 1],
       [0, 1, 0],
       [0, 1, 1]])

>>> mask (modified):
array([[ 0,  0,  1],
       [ 2,  0,  0],
       [ 3,  4,  5],
       [ 0,  6,  7],
       [ 0,  8,  9],
       [ 0, 10,  0],
       [ 0, 11, 12]])

如果您不想修改mask本身，请制作mask副本并在复制的数组上使用_mask 。