Question

我有一个由（X，Y，Z，A）值组成的2D Numpy数组，其中（X，Y，Z）是3D空间中的笛卡尔坐标，A是该位置的某个值。作为一个例子..

__X__|__Y__|__Z__|__A_
  13 |  7  |  21 | 1.5
  9  |  2  |  7  | 0.5
  15 |  3  |  9  | 1.1
  13 |  7  |  21 | 0.9
  13 |  7  |  21 | 1.7
  15 |  3  |  9  | 1.1

是否有一种有效的方法可以找到（X，Y）的所有独特组合，并添加它们的值？例如，（13,7）的总数将是（1.5 + 0.9 + 1.7），或4.1。

Answer 1

scipy.sparse矩阵获取此类信息，但仅用于2d

sparse.coo_matrix((data, (row, col)))

其中row和col是您的X，Y和Z之类的索引。它总结了重复。

这样做的第一步是lexical种索引。这使得匹配坐标的点彼此相邻。

我相信实际的分组和求和是在编译代码中完成的。在numpy术语中快速执行此操作的部分困难在于每组中将有可变数量的元素。有些是独特的，有些可能有3个或更多。

Python itertools有一个groupby工具。熊猫也有分组功能。我还可以设想使用default_dict对值进行分组和求和。

ufunc reduceat也可能有效，但在1d比2或3更容易使用。

如果忽略Z，稀疏coo_matrix方法可能最简单。

In [2]: X=np.array([13,9,15,13,13,15])
In [3]: Y=np.array([7,2,3,7,7,3])
In [4]: A=np.array([1.5,0.5,1.1,0.9,1.7,1.1])
In [5]: M=sparse.coo_matrix((A,(X,Y)))
In [15]: M.sum_duplicates()
In [16]: M.data
Out[16]: array([ 0.5,  2.2,  4.1])
In [17]: M.row
Out[17]: array([ 9, 15, 13])
In [18]: M.col
Out[18]: array([2, 3, 7])
In [19]: M
Out[19]: 
<16x8 sparse matrix of type '<class 'numpy.float64'>'
    with 3 stored elements in COOrdinate format>

这就是我对lexsort的想法

In [32]: Z=np.array([21,7,9,21,21,9])
In [33]: xyz=np.stack([X,Y,Z],1)
In [34]: idx=np.lexsort([X,Y,Z])
In [35]: idx
Out[35]: array([1, 2, 5, 0, 3, 4], dtype=int32)
In [36]: xyz[idx,:]
Out[36]: 
array([[ 9,  2,  7],
       [15,  3,  9],
       [15,  3,  9],
       [13,  7, 21],
       [13,  7, 21],
       [13,  7, 21]])
In [37]: A[idx]
Out[37]: array([ 0.5,  1.1,  1.1,  1.5,  0.9,  1.7])

当这样排序时，Z坐标变得更加明显，至少为此目的是“多余的”。

使用reduceat对群组求和：

In [40]: np.add.reduceat(A[idx],[0,1,3])  
Out[40]: array([ 0.5,  2.2,  4.1])

（现在我只是看了[0,1,3]列表）

Answer 2

方法＃1

将每一行作为视图，然后将每个行转换为标量，然后使用np.unique将每行标记为从(0......n), with n as no. of unique scalars based on the uniqueness among others and finally use np.bincount开始的最小标量根据之前获得的唯一标量执行最后一列的求和。

这是实施 -

def get_row_view(a):
    void_dt = np.dtype((np.void, a.dtype.itemsize * np.prod(a.shape[1:])))
    a = np.ascontiguousarray(a)
    return a.reshape(a.shape[0], -1).view(void_dt).ravel()

def groupby_cols_view(x):
    a = x[:,:2].astype(int)   
    a1D = get_row_view(a)     
    _, indx, IDs = np.unique(a1D, return_index=1, return_inverse=1)
    return np.c_[x[indx,:2],np.bincount(IDs, x[:,-1])]

方法＃2

与方法＃1相同，但我们不会使用view，而是为每一行生成等效的线性索引，从而将每一行减少为标量。其余工作流程与第一种方法相同。

实施 -

def groupby_cols_linearindex(x):
    a = x[:,:2].astype(int)   
    a1D = a[:,0] + a[:,1]*(a[:,0].max() - a[:,1].min() + 1)    
    _, indx, IDs = np.unique(a1D, return_index=1, return_inverse=1)
    return np.c_[x[indx,:2],np.bincount(IDs, x[:,-1])]

示例运行

In [80]: data
Out[80]: 
array([[ 2.        ,  5.        ,  1.        ,  0.40756048],
       [ 3.        ,  4.        ,  6.        ,  0.78945661],
       [ 1.        ,  3.        ,  0.        ,  0.03943097],
       [ 2.        ,  5.        ,  7.        ,  0.43663582],
       [ 4.        ,  5.        ,  0.        ,  0.14919507],
       [ 1.        ,  3.        ,  3.        ,  0.03680583],
       [ 1.        ,  4.        ,  8.        ,  0.36504428],
       [ 3.        ,  4.        ,  2.        ,  0.8598825 ]])

In [81]: groupby_cols_view(data)
Out[81]: 
array([[ 1.        ,  3.        ,  0.0762368 ],
       [ 1.        ,  4.        ,  0.36504428],
       [ 2.        ,  5.        ,  0.8441963 ],
       [ 3.        ,  4.        ,  1.64933911],
       [ 4.        ,  5.        ,  0.14919507]])

In [82]: groupby_cols_linearindex(data)
Out[82]: 
array([[ 1.        ,  3.        ,  0.0762368 ],
       [ 1.        ,  4.        ,  0.36504428],
       [ 3.        ,  4.        ,  1.64933911],
       [ 2.        ,  5.        ,  0.8441963 ],
       [ 4.        ,  5.        ,  0.14919507]])

针对唯一值的高效数据筛选（Python）

2 个答案: