Numpy:考虑项目的邻居及其在阵列中的位置的快速计算

时间:2013-04-03 22:19:47

标签: python numpy

我有4个2D numpy数组,名为a, b, c, d,每个数组都由n行和m列组成。我需要做的是给bd的每个元素一个如下计算的值(伪代码):

min_coords = min_of_neighbors_coords(x, y)
b[x,y] = a[x,y] * a[min_coords];
d[x,y] = c[min_coords];

其中min_of_neighbors_coords是一个函数,给定数组元素的坐标,返回具有较低值的'neighbor'元素的坐标。即,考虑到数组:

1, 2, 5
3, 7, 2
2, 3, 6

min_of_neighbors_coords(1, 1)将引用值为7的中心元素,并返回元组(0, 0):数字1的坐标。

我设法使用for循环(每个元素的元素),但算法非常慢,我正在寻找一种方法来改进它,避免循环并要求计算numpy。

有可能吗?

3 个答案:

答案 0 :(得分:5)

编辑我将原来的答案保留在最底层。正如保罗在评论中指出的那样,最初的答案并没有真正回答OP的问题,并且可以通过ndimage过滤器更轻松地实现。以下更麻烦的功能应该做正确的事情。它需要两个数组ac,并返回窗口最小值a以及ca窗口最小值位置的值def neighbor_min(a, c): ac = np.concatenate((a[None], c[None])) rows, cols = ac.shape[1:] ret = np.empty_like(ac) # Fill in the center win_ac = as_strided(ac, shape=(2, rows-2, cols, 3), strides=ac.strides+ac.strides[1:2]) win_ac = win_ac[np.ogrid[:2, :rows-2, :cols] + [np.argmin(win_ac[0], axis=2)]] win_ac = as_strided(win_ac, shape=(2, rows-2, cols-2, 3), strides=win_ac.strides+win_ac.strides[2:3]) ret[:, 1:-1, 1:-1] = win_ac[np.ogrid[:2, :rows-2, :cols-2] + [np.argmin(win_ac[0], axis=2)]] # Fill the top, bottom, left and right borders win_ac = as_strided(ac[:, :2, :], shape=(2, 2, cols-2, 3), strides=ac.strides+ac.strides[2:3]) win_ac = win_ac[np.ogrid[:2, :2, :cols-2] + [np.argmin(win_ac[0], axis=2)]] ret[:, 0, 1:-1] = win_ac[:, np.argmin(win_ac[0], axis=0), np.ogrid[:cols-2]] win_ac = as_strided(ac[:, -2:, :], shape=(2, 2, cols-2, 3), strides=ac.strides+ac.strides[2:3]) win_ac = win_ac[np.ogrid[:2, :2, :cols-2] + [np.argmin(win_ac[0], axis=2)]] ret[:, -1, 1:-1] = win_ac[:, np.argmin(win_ac[0], axis=0), np.ogrid[:cols-2]] win_ac = as_strided(ac[:, :, :2], shape=(2, rows-2, 2, 3), strides=ac.strides+ac.strides[1:2]) win_ac = win_ac[np.ogrid[:2, :rows-2, :2] + [np.argmin(win_ac[0], axis=2)]] ret[:, 1:-1, 0] = win_ac[:, np.ogrid[:rows-2], np.argmin(win_ac[0], axis=1)] win_ac = as_strided(ac[:, :, -2:], shape=(2, rows-2, 2, 3), strides=ac.strides+ac.strides[1:2]) win_ac = win_ac[np.ogrid[:2, :rows-2, :2] + [np.argmin(win_ac[0], axis=2)]] ret[:, 1:-1, -1] = win_ac[:, np.ogrid[:rows-2], np.argmin(win_ac[0], axis=1)] # Fill the corners win_ac = ac[:, :2, :2] win_ac = win_ac[:, np.ogrid[:2], np.argmin(win_ac[0], axis=-1)] ret[:, 0, 0] = win_ac[:, np.argmin(win_ac[0], axis=-1)] win_ac = ac[:, :2, -2:] win_ac = win_ac[:, np.ogrid[:2], np.argmin(win_ac[0], axis=-1)] ret[:, 0, -1] = win_ac[:, np.argmin(win_ac[0], axis=-1)] win_ac = ac[:, -2:, -2:] win_ac = win_ac[:, np.ogrid[:2], np.argmin(win_ac[0], axis=-1)] ret[:, -1, -1] = win_ac[:, np.argmin(win_ac[0], axis=-1)] win_ac = ac[:, -2:, :2] win_ac = win_ac[:, np.ogrid[:2], np.argmin(win_ac[0], axis=-1)] ret[:, -1, 0] = win_ac[:, np.argmin(win_ac[0], axis=-1)] return ret

(2, rows, cols)

返回是一个>>> a = np.random.randint(100, size=(5,5)) >>> c = np.random.randint(100, size=(5,5)) >>> a array([[42, 54, 18, 88, 26], [80, 65, 83, 31, 4], [51, 52, 18, 88, 52], [ 1, 70, 5, 0, 89], [47, 34, 27, 67, 68]]) >>> c array([[94, 94, 29, 6, 76], [81, 47, 67, 21, 26], [44, 92, 20, 32, 90], [81, 25, 32, 68, 25], [49, 43, 71, 79, 77]]) >>> neighbor_min(a, c) array([[[42, 18, 18, 4, 4], [42, 18, 18, 4, 4], [ 1, 1, 0, 0, 0], [ 1, 1, 0, 0, 0], [ 1, 1, 0, 0, 0]], [[94, 29, 29, 26, 26], [94, 29, 29, 26, 26], [81, 81, 68, 68, 68], [81, 81, 68, 68, 68], [81, 81, 68, 68, 68]]]) 数组,可以解压缩到两个数组中:

def bd_from_ac(a, c):
    b,d = neighbor_min(a, c)
    return a*b, d

OP的案例可以解决为:

In [3]: a = np.random.rand(1000, 1000)

In [4]: c = np.random.rand(1000, 1000)

In [5]: %timeit bd_from_ac(a, c)
1 loops, best of 3: 570 ms per loop

虽然性能受到严重打击,但仍然很快:

min_neighbor

除了获取它之外,您并没有真正使用最小邻近元素的坐标,因此您也可以跳过该部分并创建(m, n)函数。如果您不想使用cython进行快速循环,则必须使用滚动窗口视图,例如Paul的链接中所述。这通常会将您的(m-2, n-2, 3, 3)数组转换为相同数据的np.min视图,然后您将在最后两个轴上应用(m-2, n-2, 3)

不幸的是,您必须一次应用一个轴,因此您必须创建数据的def neighbor_min(a): rows, cols = a.shape ret = np.empty_like(a) # Fill in the center win_a = as_strided(a, shape=(m-2, n, 3), strides=a.strides+a.strides[:1]) win_a = win_a.min(axis=2) win_a = as_strided(win_a, shape=(m-2, n-2, 3), strides=win_a.strides+win_a.strides[1:]) ret[1:-1, 1:-1] = win_a.min(axis=2) # Fill the top, bottom, left and right borders win_a = as_strided(a[:2, :], shape=(2, cols-2, 3), strides=a.strides+a.strides[1:]) ret[0, 1:-1] = win_a.min(axis=2).min(axis=0) win_a = as_strided(a[-2:, :], shape=(2, cols-2, 3), strides=a.strides+a.strides[1:]) ret[-1, 1:-1] = win_a.min(axis=2).min(axis=0) win_a = as_strided(a[:, :2], shape=(rows-2, 2, 3), strides=a.strides+a.strides[:1]) ret[1:-1, 0] = win_a.min(axis=2).min(axis=1) win_a = as_strided(a[:, -2:], shape=(rows-2, 2, 3), strides=a.strides+a.strides[:1]) ret[1:-1, -1] = win_a.min(axis=2).min(axis=1) # Fill the corners ret[0, 0] = a[:2, :2].min() ret[0, -1] = a[:2, -2:].min() ret[-1, -1] = a[-2:, -2:].min() ret[-1, 0] = a[-2:, :2].min() return ret 副本。幸运的是,您可以分两步计算最小值,首先是沿一个轴进行窗口化和最小化,然后沿另一个轴进行最小化,并获得相同的结果。因此,最多您将获得与输入大小相当的中间存储空间。如果需要,您甚至可以将输出数组重用为中间存储并避免内存分配,但这是left as exercise ...

以下功能可以做到这一点。它有点冗长,因为它不仅要处理中心区域,还要处理四个边缘和四个角落的特殊情况。除此之外,它是一个非常紧凑的实现:

>>> a = np.random.randint(10, size=(5, 5))
>>> a
array([[0, 3, 1, 8, 9],
       [7, 2, 7, 5, 7],
       [4, 2, 6, 1, 9],
       [2, 8, 1, 2, 3],
       [7, 7, 6, 8, 0]])
>>> neighbor_min(a)
array([[0, 0, 1, 1, 5],
       [0, 0, 1, 1, 1],
       [2, 1, 1, 1, 1],
       [2, 1, 1, 0, 0],
       [2, 1, 1, 0, 0]])

您现在可以执行以下操作:

def bd_from_ac(a, c):
    return a*neighbor_min(a), neighbor_min(c)

原来的问题可以解决为:

In [2]: m, n = 1000, 1000

In [3]: a = np.random.rand(m, n)

In [4]: c = np.random.rand(m, n)

In [5]: %timeit bd_from_ac(a, c)
1 loops, best of 3: 123 ms per loop

作为绩效基准:

{{1}}

答案 1 :(得分:2)

查找a[min_coords]是一个滚动窗口操作。我们在this post中概述了几个聪明的解决方案。你想要创建c [min_coords]数组是你选择的解决方案的副作用。

我希望这会有所帮助。我有空的时候可以发布一些示例代码。

答案 2 :(得分:2)

我有兴趣帮助你,我相信在你的问题范围之外可能有更好的解决方案,但为了把时间花在编写代码上,我必须得到你的一些反馈,因为我不是100我确定我明白你的需要。

要考虑的一件事:如果你是C#开发人员,也许C#的“强力”实现可以胜过Numpy的巧妙实现,所以你至少可以考虑测试用C#实现的相当简单的操作。 Geotiff(我想你正在阅读)有一个相对友好的规范,我想可能有.NET GeoTiff库。

但是假设你想尝试一下Numpy(我相信你应该),让我们来看看你想要实现的目标:

  1. 如果要在数组min_coords(array)a的每个元素中运行c,您可能会考虑“堆叠”同一数组的九个副本,每个副本由一些副本滚动偏移量,使用numpy.dstack()numpy.roll()。然后,应用numpy.argmin(stacked_array, axis=2)并获得一个包含0到8之间值的数组,其中每个值都映射到包含偏移索引的元组。
  2. 然后,使用此原则,您的min_coords()函数将被矢量化,一次在整个数组中操作,并返回一个数组,该数组为您提供一个偏移量,该偏移量将是包含偏移量的查找表的索引

    如果您有兴趣详细说明,请发表评论。

    希望这有帮助!