Question

我有一个以下结构的三维数组：

x = np.array([[[1,2],
               [3,4]],
              [[5,6],
               [7,8]]], dtype=np.double)

另外，我有一个索引数组

idx = np.array([[0,1],[1,3]], dtype=np.int)

idx的每一行定义每个子数组沿0 x轴放置到二维数组K的行/列索引初始化为

K = np.zeros((4,4), dtype=np.double)

我想使用花哨的索引/广播来执行没有for循环的索引。我目前这样做：

for i, id in enumerate(idx):

    idx_grid = np.ix_(id,id)

    K[idx_grid] += x[i]

结果如下：

>>> K = array([[ 1.,  2.,  0.,  0.],
               [ 3.,  9.,  0.,  6.],
               [ 0.,  0.,  0.,  0.],
               [ 0.,  7.,  0.,  8.]])

这可能与花式索引有关吗？

Answer 1

这是一种替代方式。在您的问题中定义了x，idx和K：

indices = (idx[:,None] + K.shape[1]*idx).ravel('f')
np.add.at(K.ravel(), indices, x.ravel())

然后我们有：

>>> K
array([[ 1.,  2.,  0.,  0.],
       [ 3.,  9.,  0.,  6.],
       [ 0.,  0.,  0.,  0.],
       [ 0.,  7.,  0.,  8.]])

要在NumPy阵列上执行无缓冲的inplace添加，您需要使用np.add.at（以避免在+=循环中使用for）。

但是，将这些索引添加的2D索引数组列表和相应数组传递给np.add.at稍微有点问题。这是因为该函数将这些数组列表解释为更高维数组并引发IndexErrors。

传入1D阵列要简单得多。您可以暂时将K和x拉平，为您提供一维零数组和一维数组，以添加到这些零。唯一令人讨厌的部分是从idx构建相应的1D索引数组，在该数组中添加值。如上所示，这可以通过使用算术运算符进行广播然后进行漫游来完成。

Answer 2

预期操作是从accumulation到x索引的idx个idx值之一。您可以将那些bins个位置视为直方图数据的x，并将# Get size info of expected output N = idx.max()+1 # Extend idx to cover two axes, equivalent to `np.ix_` idx1 = idx[:,None,:] + N*idx[:,:,None] # "Accumulate" values from x into places indexed by idx1 K = np.bincount(idx1.ravel(),x.ravel()).reshape(N,N)值视为您需要为这些二进制位累积的权重。现在，要执行这样的分箱操作，可以使用np.bincount。这是一个这样的实现 -

In [361]: # Create x and idx, with idx having unique elements in each row of idx, 
     ...: # as otherwise the intended operation is not clear
     ...: 
     ...: nrows = 100
     ...: max_idx = 100
     ...: ncols_idx = 2
     ...: 
     ...: x = np.random.rand(nrows,ncols_idx,ncols_idx)
     ...: idx = np.random.randint(0,max_idx,(nrows,ncols_idx))
     ...: 
     ...: valid_mask = ~np.any(np.diff(np.sort(idx,axis=1),axis=1)==0,axis=1)
     ...: 
     ...: x = x[valid_mask]
     ...: idx = idx[valid_mask]
     ...:

运行时测试 -

1）创建输入：

In [362]: # Define the original and proposed (bincount based) approaches
     ...: 
     ...: def org_approach(x,idx):
     ...:   N = idx.max()+1
     ...:   K = np.zeros((N,N), dtype=np.double)
     ...:   for i, id in enumerate(idx):    
     ...:       idx_grid = np.ix_(id,id)    
     ...:       K[idx_grid] += x[i]         
     ...:   return K
     ...: 
     ...: 
     ...: def bincount_approach(x,idx):
     ...:   N = idx.max()+1
     ...:   idx1 = idx[:,None,:] + N*idx[:,:,None]
     ...:   return np.bincount(idx1.ravel(),x.ravel()).reshape(N,N)
     ...:

2）定义功能：

In [363]: %timeit org_approach(x,idx)
100 loops, best of 3: 2.13 ms per loop

In [364]: %timeit bincount_approach(x,idx)
10000 loops, best of 3: 32 µs per loop

3）最后计时：

let t = Type.GetType("Microsoft.FSharp.Core.LanguagePrimitives.IntrinsicFunctions")

Answer 3

我认为这不是有效的，因为你在循环中有+=。这意味着，你必须“爆炸”＃34;您的数组idx按一个维度进行，并使用np.sum(x[...], axis=...)再次减少它。一个小的优化是：

import numpy as np

xx = np.array([[[1, 2],
               [3, 4]],
              [[5, 6],
               [7, 8]]], dtype=np.double)

idx = np.array([[0, 1], [1, 3]], dtype=np.int)

K0, K1 = np.zeros((4, 4), dtype=np.double), np.zeros((4, 4), dtype=np.double)

for k, i in enumerate(idx):
    idx_grid = np.ix_(i, i)
    K0[idx_grid] += xx[k]

for x, i in zip(xx, idx):
    K1[np.ix_(i, i)] += x

print("K1 == K0:", np.allclose(K1, K0))  # prints: K1 == K0: True

PS：不要将id用作变量名，因为它是Python关键字。

Numpy将三维数组索引为二维数组

3 个答案: