我有4个2D numpy数组,名为a, b, c, d
,每个数组都由n
行和m
列组成。我需要做的是给b
和d
的每个元素一个如下计算的值(伪代码):
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。
有可能吗?
答案 0 :(得分:5)
编辑我将原来的答案保留在最底层。正如保罗在评论中指出的那样,最初的答案并没有真正回答OP的问题,并且可以通过ndimage过滤器更轻松地实现。以下更麻烦的功能应该做正确的事情。它需要两个数组a
和c
,并返回窗口最小值a
以及c
中a
窗口最小值位置的值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(我相信你应该),让我们来看看你想要实现的目标:
min_coords(array)
和a
的每个元素中运行c
,您可能会考虑“堆叠”同一数组的九个副本,每个副本由一些副本滚动偏移量,使用numpy.dstack()
和numpy.roll()
。然后,应用numpy.argmin(stacked_array, axis=2)
并获得一个包含0到8之间值的数组,其中每个值都映射到包含偏移索引的元组。然后,使用此原则,您的min_coords()
函数将被矢量化,一次在整个数组中操作,并返回一个数组,该数组为您提供一个偏移量,该偏移量将是包含偏移量的查找表的索引
如果您有兴趣详细说明,请发表评论。
希望这有帮助!