有效使用numpy_索引输出

Question

>>> import numpy_indexed as npi
>>> import numpy as np
>>> a = np.array([[0,0,1,1,2,2], [4,4,8,8,10,10]]).T
>>> a
array([[ 0,  4],
       [ 0,  4],
       [ 1,  8],
       [ 1,  8],
       [ 2, 10],
       [ 2, 10]])
>>> npi.group_by(a[:, 0]).sum(a[:,1])

(array([0, 1, 2]), array([ 8, 16, 20], dtype=int32))

我想在大型集合（约1m行）上对第一列聚集的第二列的子集执行计算。有没有一种有效的（和/或矢量化的）方法来使用group_byby numpy_indexed的输出，以便在这些计算的输出中添加一个新列？在上面的sum示例中，我希望生成下面的输出。在

如果有一种不首先使用numpy_indexed的有效方法来实现这一点，那也将非常有帮助。在

^{pr2}$

Answer 1

每个索引对象都有一个逆属性，它将减少的值映射回其原始范围；为了举例说明，我们可以写下：

index = npi.as_index(keys)
unique_keys = index.unique
unique_keys[index.inverse] == keys  # <- should be all true

而且这个属性也在GroupBy对象上公开；因为实际上将分组值映射回它们的输入范围是一个非常有用的操作：

^{pr2}$

一般来说，numpy_索引的来源可以启发如何执行这种常见的操作；group_按.var面临着同样的问题，例如，将每个组的平均值广播回组成它的组的每个元素，以计算每组中的错误。但是更好的教程当然也不会有什么坏处。在

你能对你要解决的问题作一个更高层次的描述吗？当你对npi所提供的设计模式有了更为自如的思考时，你就可以从更高的层次上简化你的代码。在

Answer 2

一种使用^{}生成那些唯一标记和间隔移位索引的方法，然后^{}为{}-

_,idx,tags = np.unique(a[:,0], return_index=1, return_inverse=1)
out = np.c_[a, np.add.reduceat(a[:,1],idx)[tags]]

另一种避免使用np.unique并可能对性能有益的方法如下-

^{pr2}$

为了进一步提高性能，我们应该使用np.bincount。因此，np.add.reduceat(a[:,1],idx)可以被np.bincount(tags, a[:,1])代替。在

样本运行-

In [271]: a    # Using a more generic sample
Out[271]: 
array([[11,  4],
       [11,  4],
       [14,  8],
       [14,  8],
       [16, 10],
       [16, 10]])

In [272]: _,idx,tags = np.unique(a[:,0], return_index=1, return_inverse=1)

In [273]: np.c_[a, np.add.reduceat(a[:,1],idx)[tags]]
Out[273]: 
array([[11,  4,  8],
       [11,  4,  8],
       [14,  8, 16],
       [14,  8, 16],
       [16, 10, 20],
       [16, 10, 20]])]

现在，列出的方法假设第一列已经排序。如果不是这样，我们需要按第一列argsort对数组进行排序，然后使用建议的方法。因此，对于未排序的案例，我们需要以下内容作为预处理-

a = a[a[:,0].argsort()]

---

对抗np.unique

让我们根据内置的flatnonzero+cumsum来计时基于自定义np.unique的方法来创建移位索引：idx和基于唯一性的id/tags:tags。对于这种情况，我们事先知道labels列已经排序，我们避免任何排序，就像np.unique所做的那样。这使我们在性能上有优势。所以，让我们来验证一下。在

方法-

def nonzero_cumsum_based(A):
    idx = np.concatenate(( [0] ,np.flatnonzero(A[1:] > A[:-1])+1 ))
    tags = np.zeros(len(A), dtype=int)
    tags[idx[1:]] = 1
    np.cumsum(tags, out = tags)
    return idx, tags

def unique_based(A):
    _,idx,tags = np.unique(A, return_index=1, return_inverse=1)
    return idx, tags

使用自定义函数-

In [438]: a
Out[438]: 
array([[11,  4],
       [11,  4],
       [14,  8],
       [14,  8],
       [16, 10],
       [16, 10]])

In [439]: idx, tags = nonzero_cumsum_based(a[:,0])

In [440]: idx
Out[440]: array([0, 2, 4])

In [441]: tags
Out[441]: array([0, 0, 1, 1, 2, 2])

时间安排-

In [444]: a = np.c_[np.sort(randi(10,10000,(100000))), randi(0,10000,(100000))]

In [445]: %timeit unique_based(a[:,0])
100 loops, best of 3: 4.3 ms per loop

In [446]: %timeit nonzero_cumsum_based(a[:,0])
1000 loops, best of 3: 486 µs per loop

In [447]: a = np.c_[np.sort(randi(10,10000,(1000000))), randi(0,10000,(1000000))]

In [448]: %timeit unique_based(a[:,0])
10 loops, best of 3: 50.2 ms per loop

In [449]: %timeit nonzero_cumsum_based(a[:,0])
100 loops, best of 3: 3.98 ms per loop