如何使用向量化从数组中选择最接近数组中的值的值？

Question

我有一个值数组，我想从一个选项数组中替换为哪个选项是线性最接近的。

关键是选项的大小是在运行时定义的。

import numpy as np
a = np.array([[0, 0, 0], [4, 4, 4], [9, 9, 9]])
choices = np.array([1, 5, 10])

如果选择的大小是静态的，我会简单地使用 np.where

d = np.where(np.abs(a - choices[0]) > np.abs(a - choices[1]), 
      np.where(np.abs(a - choices[0]) > np.abs(a - choices[2]), choices[0], choices[2]),
         np.where(np.abs(a - choices[1]) > np.abs(a - choices[2]), choices[1], choices[2]))

获取输出：

>>d
>>[[1, 1, 1], [5, 5, 5], [10, 10, 10]]

有没有办法在保持矢量化的同时更动态地执行此操作。

Answer 1

从a中减去选项，找到结果最小值的索引，代入。

a = np.array([[0, 0, 0], [4, 4, 4], [9, 9, 9]])
choices = np.array([1, 5, 10])
b = a[:,:,None] - choices
np.absolute(b,b)
i = np.argmin(b, axis = -1)
a = choices[i]
print a

>>> 
[[ 1  1  1]
 [ 5  5  5]
 [10 10 10]]

a = np.array([[0, 3, 0], [4, 8, 4], [9, 1, 9]])
choices = np.array([1, 5, 10])
b = a[:,:,None] - choices
np.absolute(b,b)
i = np.argmin(b, axis = -1)
a = choices[i]
print a

>>>    
[[ 1  1  1]
 [ 5 10  5]
 [10  1 10]]
>>> 

---

额外的维度被添加到a，以便从a 的每个元素中减去choices 的每个元素。 choices 在第三维 This link has a decent graphic 中是 broadcast 与 a。 b.shape 是 (3,3,3)。 EricsBroadcastingDoc 是一个很好的解释，最后有一个图形 3-d 示例。

第二个例子：

>>> print b
[[[ 1  5 10]
  [ 2  2  7]
  [ 1  5 10]]

 [[ 3  1  6]
  [ 7  3  2]
  [ 3  1  6]]

 [[ 8  4  1]
  [ 0  4  9]
  [ 8  4  1]]]
>>> print i
[[0 0 0]
 [1 2 1]
 [2 0 2]]
>>> 

最终分配使用Index Array 或Integer Array Indexing。

在第二个示例中，请注意元素 a[0,1] 有一个 tie，可以替换为一个或五个。

Answer 2

更详细地解释二战的excellent answer：

这个想法是创建一个新维度，它使用numpy broadcasting 将a 的每个元素与choices 中的每个元素进行比较。对于a 中的任意数量的维度，使用ellipsis syntax 很容易做到这一点：

>>> b = np.abs(a[..., np.newaxis] - choices)
array([[[ 1,  5, 10],
        [ 1,  5, 10],
        [ 1,  5, 10]],
       [[ 3,  1,  6],
        [ 3,  1,  6],
        [ 3,  1,  6]],
       [[ 8,  4,  1],
        [ 8,  4,  1],
        [ 8,  4,  1]]])

将argmin 沿您刚刚创建的轴（最后一个轴，标签为-1）为您提供choices 中您想要替换的所需索引：

>>> np.argmin(b, axis=-1)
array([[0, 0, 0],
       [1, 1, 1],
       [2, 2, 2]])

这最终允许您从choices 中选择那些元素：

>>> d = choices[np.argmin(b, axis=-1)]
>>> d
array([[ 1,  1,  1],
       [ 5,  5,  5],
       [10, 10, 10]])

---

对于非对称形状：

假设a 具有形状(2, 5)：

>>> a = np.arange(10).reshape((2, 5))
>>> a
array([[0, 1, 2, 3, 4],
       [5, 6, 7, 8, 9]])

然后你会得到：

>>> b = np.abs(a[..., np.newaxis] - choices)
>>> b
array([[[ 1,  5, 10],
        [ 0,  4,  9],
        [ 1,  3,  8],
        [ 2,  2,  7],
        [ 3,  1,  6]],

       [[ 4,  0,  5],
        [ 5,  1,  4],
        [ 6,  2,  3],
        [ 7,  3,  2],
        [ 8,  4,  1]]])

这很难读，但它的意思是，b 有形状：

>>> b.shape
(2, 5, 3)

前两个维度来自a的形状，也就是(2, 5)。最后一个维度是您刚刚创建的维度。为了获得更好的想法：

>>> b[:, :, 0]  # = abs(a - 1)
array([[1, 0, 1, 2, 3],
       [4, 5, 6, 7, 8]])
>>> b[:, :, 1]  # = abs(a - 5)
array([[5, 4, 3, 2, 1],
       [0, 1, 2, 3, 4]])
>>> b[:, :, 2]  # = abs(a - 10)
array([[10,  9,  8,  7,  6],
       [ 5,  4,  3,  2,  1]])

注意b[:, :, i] 是a 和choices[i] 之间的绝对差，对于每个i = 1, 2, 3。

希望这有助于更清楚地解释这一点。

Answer 3

我喜欢broadcasting，我自己也会这样做。但是，对于大型数组，我想建议使用 np.searchsorted 的另一种方法，以保持内存效率，从而实现性能优势，就像这样 -

def searchsorted_app(a, choices):
    lidx = np.searchsorted(choices, a, 'left').clip(max=choices.size-1)
    ridx = (np.searchsorted(choices, a, 'right')-1).clip(min=0)
    cl = np.take(choices,lidx) # Or choices[lidx]
    cr = np.take(choices,ridx) # Or choices[ridx]
    mask = np.abs(a - cl) > np.abs(a - cr)
    cl[mask] = cr[mask]
    return cl

请注意，如果choices中的元素没有排序，我们需要在sorter和np.searchsorted中添加额外的参数。

运行时测试-

In [160]: # Setup inputs
     ...: a = np.random.rand(100,100)
     ...: choices = np.sort(np.random.rand(100))
     ...: 

In [161]: def broadcasting_app(a, choices): # @wwii's solution
     ...:     return choices[np.argmin(np.abs(a[:,:,None] - choices),-1)]
     ...: 

In [162]: np.allclose(broadcasting_app(a,choices),searchsorted_app(a,choices))
Out[162]: True

In [163]: %timeit broadcasting_app(a, choices)
100 loops, best of 3: 9.3 ms per loop

In [164]: %timeit searchsorted_app(a, choices)
1000 loops, best of 3: 1.78 ms per loop

相关帖子：Find elements of array one nearest to elements of array two