Numpy：通过分箱从关联中查找最小值和最大值

Question

先决条件

这是从这个衍生出来的问题。所以，一些引入的问题会类似于post.

问题

假设 result 是一个二维数组，values 是一个一维数组。 values 包含与 result 中的每个元素关联的一些值。 values 中的元素到 result 的映射存储在 x_mapping 和 y_mapping 中。 result 中的位置可以与不同的值相关联。现在，我必须找到按关联分组的值的最小值和最大值。

一个更好说明的例子。

min_result数组：

[[0, 0],
[0, 0],
[0, 0],
[0, 0]]

max_result数组：

[[0, 0],
[0, 0],
[0, 0],
[0, 0]]

values数组：

[ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.]

注意：此处result数组和values数组的元素数量相同。但事实可能并非如此。尺寸之间完全没有关系。

x_mapping 和 y_mapping 具有从 1D values 到 2D result（最小值和最大值）的映射。 x_mapping、y_mapping 和 values 的大小相同。

x_mapping - [0, 1, 0, 0, 0, 0, 0, 0]

y_mapping - [0, 3, 2, 2, 0, 3, 2, 1]

这里，第一个值（values[0]）和第五个值（values[4]）的 x 为 0，y 为 0（x_mapping[0] 和 y_mappping[0]），因此关联result[0, 0]。如果我们计算该组的最小值和最大值，我们将分别得到 1 和 5 作为结果。所以，min_result[0, 0] 将有 1 而 max_result[0, 0] 将有 5.

请注意，如果根本没有关联，则 result 的默认值将为零。

当前工作解决方案

x_mapping = np.array([0, 1, 0, 0, 0, 0, 0, 0])
y_mapping = np.array([0, 3, 2, 2, 0, 3, 2, 1])
values = np.array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.], dtype=np.float32)
max_result = np.zeros([4, 2], dtype=np.float32)
min_result = np.zeros([4, 2], dtype=np.float32) 
min_result[-y_mapping, x_mapping] = values # randomly initialising from values
for i in range(values.size):
    x = x_mapping[i]
    y = y_mapping[i]
    # maximum
    if values[i] > max_result[-y, x]:
        max_result[-y, x] = values[i]
    # minimum
    if values[i] < min_result[-y, x]:
        min_result[-y, x] = values[i]

min_result,

[[1., 0.],
[6., 2.],
[3., 0.],
[8., 0.]]

max_result,

[[5., 0.],
[6., 2.],
[7., 0.],
[8., 0.]]

失败的解决方案

#1

min_result = np.zeros([4, 2], dtype=np.float32)
np.minimum.reduceat(values, [-y_mapping, x_mapping], out=min_result)

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-17-126de899a90e> in <module>()
1 min_result = np.zeros([4, 2], dtype=np.float32)
----> 2 np.minimum.reduceat(values, [-y_mapping, x_mapping], out=min_result)

ValueError: object too deep for desired array

#2

min_result = np.zeros([4, 2], dtype=np.float32)
np.minimum.reduceat(values, lidx, out= min_result)

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-24-07e8c75ccaa5> in <module>()
1 min_result = np.zeros([4, 2], dtype=np.float32)
----> 2 np.minimum.reduceat(values, lidx, out= min_result)

ValueError: operands could not be broadcast together with remapped shapes [original->remapped]: (4,2)->(4,) (8,)->() (8,)->(8,)

#3

lidx = ((-y_mapping) % 4) * 2 + x_mapping #from mentioned post
min_result = np.zeros([8], dtype=np.float32)
np.minimum.reduceat(values, lidx, out= min_result).reshape(4,2)

[[1., 4.],
[5., 5.],
[1., 3.],
[5., 7.]]

问题

如何使用np.minimum.reduceat和np.maximum.reduceat解决这个问题？我正在寻找针对运行时优化的解决方案。

旁注

我正在使用 Numpy 版本 1.14.3 和 Python 3.5.2

Answer 1

方法 #1

同样，最直观的是numpy.ufunc.at。现在，由于这些缩减将针对现有值执行，因此我们需要使用最大值初始化输出以实现最小缩减，并使用最小值初始化最大缩减。因此，实施将是 -

min_result[-y_mapping, x_mapping] = values.max()
max_result[-y_mapping, x_mapping] = values.min()

np.minimum.at(min_result, [-y_mapping, x_mapping], values)
np.maximum.at(max_result, [-y_mapping, x_mapping], values)

方法 #2

为了利用 np.ufunc.reduceat，我们需要对数据进行排序 -

m,n = max_result.shape
out_dtype = max_result.dtype
lidx = ((-y_mapping)%m)*n + x_mapping

sidx = lidx.argsort()
idx = lidx[sidx]
val = values[sidx]

m_idx = np.flatnonzero(np.r_[True,idx[:-1] != idx[1:]])
unq_ids = idx[m_idx]

max_result_out.flat[unq_ids] = np.maximum.reduceat(val, m_idx)
min_result_out.flat[unq_ids] = np.minimum.reduceat(val, m_idx)

Numpy：通过分箱从关联中查找最小值和最大值

Numpy: Finding minimum and maximum values from associations through binning

python

numpy

numpy-ufunc

array-broadcasting

先决条件

问题

当前工作解决方案

失败的解决方案

#1

#2

#3

问题

旁注