有效地从第三个数组中的两个数组中获取每对元素的最小值

Question

我有两个 N 浮点数组（充当 (x,y) 坐标并且可能有重复）和关联的 z 数组 N 浮点数（充当坐标的权重）。

对于每对 (x,y) 浮点数，我需要选择具有最小关联 z 值的对。我已经定义了一个 selectMinz() 函数来执行此操作（请参见下面的代码），但它需要的时间太长。

如何提高此功能的性能？

import numpy as np
import time


def getData():
    N = 100000
    x = np.arange(0.0005, 0.03, 0.001)
    y = np.arange(6., 10., .05)
    # Select N values for x,y, where values can be repeated
    x = np.random.choice(x, N)
    y = np.random.choice(y, N)
    z = np.random.uniform(10., 15., N)
    return x, y, z


def selectMinz(x, y, z):
    """
    Select the minimum z for each (x,y) pair.
    """
    xy_unq, z_unq = [], []
    # For each (x,y) pair
    for i, xy in enumerate(zip(*[x, y])):
        # If this xy pair was already stored in the xy_unq list
        if xy in xy_unq:
            # If the stored z value associated with this xy pair is
            # larger than this new z[i] value
            if z_unq[xy_unq.index(xy)] > z[i]:
                # Store this smaller value instead
                z_unq[xy_unq.index(xy)] = z[i]
        else:
            # Store the xy pair, and its associated z value
            xy_unq.append(xy)
            z_unq.append(z[i])

    return xy_unq, z_unq


# Define data with the proper format.
x, y, z = getData()

s = time.clock()
xy_unq, z_unq = selectMinz(x, y, z)  # <-- TAKES TOO LONG (~15s in my system)
print(time.clock() - s)

Answer 1

步骤：

1. 使用lex-sort 使x-y 对按顺序出现。或者，我们可以使用缩放方法将其中一个数组按另一个数组的值范围进行缩放，然后将其与另一个数组相加，最后使用argsort 得到 lex 排序的等效索引。
2. 使用np.minimum.reduceat 获取由对分组定义的区间中的最小值。

因此，我们将有一个矢量化解决方案，就像这样 -

def selectMinz_vectorized(x, y, z):
    # Get grouped lex-sort indices
    sidx = (y + x*(y.max() - y.min() + 1)).argsort()
    # or sidx = np.lexsort([x, y])

    # Lex-sort x, y, z
    x_sorted = x[sidx]
    y_sorted = y[sidx]
    z_sorted = z[sidx]

    # Get equality mask between each sorted X and Y elem against previous ones.
    # The non-zero indices of its inverted mask gives us the indices where the 
    # new groupings start. We are calling those as cut_idx.
    seq_eq_mask = (x_sorted[1:] == x_sorted[:-1]) & (y_sorted[1:] == y_sorted[:-1])
    cut_idx = np.flatnonzero(np.concatenate(( [True], ~seq_eq_mask)))

    # Use those cut_idx to get intervalled minimum values
    minZ = np.minimum.reduceat(z_sorted, cut_idx)

    # Make tuples of the groupings of x,y and the corresponding min Z values
    return (zip(x_sorted[cut_idx], y_sorted[cut_idx]), minZ.tolist())

示例运行 -

In [120]: np.c_[x,y,z]
Out[120]: 
array([[  0.,   1.,  69.],
       [  2.,   0.,  47.],
       [  1.,   0.,  62.],
       [  0.,   2.,  33.],
       [  1.,   7.,  32.],
       [  1.,   0.,  50.],
       [  2.,   0.,  55.]])

In [121]: selectMinz(x,y,z) # original method
Out[121]: 
([(0.0, 1.0), (2.0, 0.0), (1.0, 0.0), (0.0, 2.0), (1.0, 7.0)],
 [69.0, 47.0, 50.0, 33.0, 32.0])

In [122]: selectMinz_vectorized(x,y,z)
Out[122]: 
([(1.0, 0.0), (2.0, 0.0), (0.0, 1.0), (0.0, 2.0), (1.0, 7.0)],
 [50.0, 47.0, 69.0, 33.0, 32.0])

---

这是我最初的方法，它涉及创建一个堆叠数组，然后执行这些操作。实现看起来像这样 -

def selectMinz_vectorized_v2(x, y, z):
    d = np.column_stack((x,y,z))
    sidx = np.lexsort(d[:,:2].T)
    b = d[sidx]  
    cut_idx = np.r_[0,np.flatnonzero(~(b[1:,:2] == b[:-1,:2]).all(1))+1]
    minZ = np.minimum.reduceat(b[:,-1], cut_idx)
    return ([tuple(i) for i in b[cut_idx,:2]], minZ.tolist())

---

向量化方法的基准测试

方法-

# Pruned version of the approach posted earlier
def selectMinz_vectorized_pruned(x, y, z):
    sidx = (y + x*(y.max() - y.min() + 1)).argsort()
    x_sorted = x[sidx]
    y_sorted = y[sidx]
    z_sorted = z[sidx]
    seq_eq_mask = (x_sorted[1:] == x_sorted[:-1]) & (y_sorted[1:] == y_sorted[:-1])
    cut_idx = np.flatnonzero(np.concatenate(( [True], ~seq_eq_mask)))
    minZ = np.minimum.reduceat(z_sorted, cut_idx)
    return x_sorted[cut_idx], y_sorted[cut_idx], minZ

def numpy_indexed_app(x,y,z): # @Eelco Hoogendoorn's soln
    return npi.group_by((x, y)).min(z)

时间安排 -

In [141]: x,y,z=getData(10000)

In [142]: %timeit selectMinz_vectorized_pruned(x, y, z)
     ...: %timeit numpy_indexed_app(x,y,z)
     ...: 
1000 loops, best of 3: 763 µs per loop
1000 loops, best of 3: 1.09 ms per loop

In [143]: x,y,z=getData(100000)

In [144]: %timeit selectMinz_vectorized_pruned(x, y, z)
     ...: %timeit numpy_indexed_app(x,y,z)
     ...: 
100 loops, best of 3: 8.53 ms per loop
100 loops, best of 3: 12.9 ms per loop

Answer 2

将xy_unq 和z_unq 的数据结构更改为包含这两条信息的字典，使我的系统上的时间从~7 秒缩短到~0.1 秒。

def selectMinz(x, y, z):
    """
    Select the minimum z for each (x,y) pair.
    """
    xy_unq = {}
    # For each (x,y) pair
    for i, xy in enumerate(zip(*[x, y])):
        # If this xy pair was already stored in the xy_unq list
        if xy in xy_unq:
            # If the stored z value associated with this xy pair is
            # larger than this new z[i] value
            if xy_unq[xy] > z[i]:
                # Store this smaller value instead
                xy_unq[xy] = z[i]
        else:
            # Store the xy pair, and its associated z value
            xy_unq[xy] = z[i]

    return xy_unq.keys(), xy_unq.values()

对我来说，上述方法的时间范围从 ~0.106s 到 ~0.11s。这是另一种方法，代码行数更少，但需要更多时间（~0.14）：

def selectMinz(x, y, z):
    """
    Select the minimum z for each (x,y) pair.
    """
    xy_unq = {}
    # For each (x,y) pair
    for i, xy in enumerate(zip(*[x, y])):
        # If this xy pair was already stored in the xy_unq list
        if xy in xy_unq:
            # Store the value that is smaller between the current stored value and the new z[i]
            xy_unq[xy] = min(xy_unq[xy], z[i])
        else:
            # Store the xy pair, and its associated z value
            xy_unq[xy] = z[i]

    return xy_unq.keys(), xy_unq.values()

Answer 3

numpy_indexed 包（免责声明：我是它的作者）包含以优雅高效的方式解决此类分组问题的功能：

import numpy_indexed as npi
xy_unq, z_unq = npi.group_by((x, y)).min(z)