Question

我有一个M x N矩阵X和一个1 x N矩阵Y。我想做的就是用基于列的Y的适当值替换X中的任何0项。

如果

X = np.array([[0, 1, 2], [3, 0, 5]])

和

Y = np.array([10, 20, 30])

所需的最终结果将是[[10，1，2]，[3，20，5]]。

这可以通过生成一个M x N矩阵直接完成，其中每行都是Y，然后使用过滤器数组：

Y = np.ones((X.shape[0], 1)) * Y.reshape(1, -1)
X[X==0] = Y[X==0]

但是可以使用numpy的广播功能来做到这一点吗？

Answer 1

好的。不用物理重复Y，而是使用numpy.broadcast_to，以Y的形式创建X的广播视图：

expanded = numpy.broadcast_to(Y, X.shape)

mask = X==0
x[mask] = expanded[mask]

Answer 2

展开X，使其更通用：

In [306]: X = np.array([[0, 1, 2], [3, 0, 5],[0,1,0]])

where标识0；第二个数组标识列

In [307]: idx = np.where(X==0)
In [308]: idx
Out[308]: (array([0, 1, 2, 2]), array([0, 1, 0, 2]))


In [309]: Z = X.copy()
In [310]: Z[idx]
Out[310]: array([0, 0, 0, 0])       # flat list of where to put the values
In [311]: Y[idx[1]]
Out[311]: array([10, 20, 10, 30])   # matching list of values by column

In [312]: Z[idx] = Y[idx[1]]
In [313]: Z
Out[313]: 
array([[10,  1,  2],
       [ 3, 20,  5],
       [10,  1, 30]])

不进行广播，但可以合理地清理numpy。

与broadcast_to方法相比的时间

In [314]: %%timeit 
     ...: idx = np.where(X==0)
     ...: Z[idx] = Y[idx[1]]
     ...: 
9.28 µs ± 157 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
In [315]: %%timeit
     ...: exp = np.broadcast_to(Y,X.shape)
     ...: mask=X==0
     ...: Z[mask] = exp[mask]
     ...: 
19.5 µs ± 513 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

速度更快，尽管样本量很小。

制作expanded Y的另一种方法是使用repeat：

In [319]: %%timeit
     ...: exp = np.repeat(Y[None,:],3,0)
     ...: mask=X==0
     ...: Z[mask] = exp[mask]
     ...: 
10.8 µs ± 55.3 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

时间接近我的where。事实证明broadcast_to相对较慢：

In [321]: %%timeit
     ...: exp = np.broadcast_to(Y,X.shape)
     ...: 
10.5 µs ± 52.9 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
In [322]: %%timeit
     ...: exp = np.repeat(Y[None,:],3,0)
     ...: 
3.76 µs ± 11.6 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

我们必须进行更多测试，以查看这是否仅是由于安装成本所致，还是相对时间是否仍适用于更大的阵列。

脾气暴躁：您可以使用广播逐行替换值吗？

2 个答案: