为什么 np.compress 比布尔索引更快？

What is np.compress内部做的事情使它比布尔索引更快？

在这个例子中，compress速度提高了约 20%，但节省的时间因数据大小而异a和数量True布尔数组中的值b，但是在我的机器上compress总是更快。

import numpy as np

a = np.random.rand(1000000,4)
b = (a[:,0]>0.5)

%timeit a[b]
#>>> 10 loops, best of 3: 24.7 ms per loop
%timeit a.compress(b, axis=0)
#>>> 10 loops, best of 3: 20 ms per loop

The 布尔索引的文档 https://docs.scipy.org/doc/numpy-1.12.0/user/basics.indexing.html#boolean-or-mask-index-arrays says

返回的是数据的副本，而不是切片获得的视图

相比之下，压缩文档 https://docs.scipy.org/doc/numpy/reference/generated/numpy.compress.html say

返回沿给定轴选定的数组切片”。

然而，使用这里提供的方法 http://ipython-books.github.io/featured-01/用于确定两个数组是否共享相同的数据缓冲区表明这两种方法都不与其父级共享数据a，我认为这意味着这两种方法都不会返回实际的切片。

def get_data_base(arr):
    base = arr
    while isinstance(base.base, np.ndarray):
        base = base.base
    return base

def arrays_share_data(x, y):
    return get_data_base(x) is get_data_base(y) 

arrays_share_data(a, a.compress(b, axis=0))
#>>> False
arrays_share_data(a, a[b])
#>>> False

我只是好奇，因为我在工作中经常执行这些操作。我运行通过 Anaconda 安装的 python 3.5.2、numpy v 1.11.1。

Tracing a.compress通过几层函数调用numpy github我到了

/numpy/core/src/multiarray/item_selection.c
PyArray_Compress(PyArrayObject *self, PyObject *condition, int axis,
             PyArrayObject *out)
    # various checks
    res = PyArray_Nonzero(cond);
    ret = PyArray_TakeFrom(self, PyTuple_GET_ITEM(res, 0), axis,
                       out, NPY_RAISE);

使用您的样本阵列，compress和做一样where得到一个索引数组，然后take:

In [135]: a.shape
Out[135]: (1000000, 4)
In [136]: b.shape
Out[136]: (1000000,)
In [137]: a.compress(b, axis=0).shape
Out[137]: (499780, 4)
In [138]: a.take(np.nonzero(b)[0], axis=0).shape
Out[138]: (499780, 4)
In [139]: timeit a.compress(b, axis=0).shape
100 loops, best of 3: 14.3 ms per loop
In [140]: timeit a.take(np.nonzero(b)[0], axis=0).shape
100 loops, best of 3: 14.3 ms per loop

事实上，如果我在 [] 索引中使用这个索引数组，我会得到可比较的时间：

In [141]: idx=np.where(b)[0]
In [142]: idx.shape
Out[142]: (499780,)
In [143]: timeit a[idx,:].shape
100 loops, best of 3: 14.6 ms per loop
In [144]: timeit np.take(a,idx, axis=0).shape
100 loops, best of 3: 9.9 ms per loop

np.take代码涉及更多，因为它包括clip and wrap modes.

[] 索引被翻译成__getitem__调用，并通过各个层。我还没有发现代码差异很大，但我认为可以肯定地说compress（更确切地说take）只是采取更直接的路线来完成任务，从而获得适度的速度提升。 30-50% 的速度差异表明编译代码细节存在差异，而不是诸如此类的重大差异views vs copies，或解释与编译。