我正在尝试研究如何加速使用numpy的Python函数。我从lineprofiler收到的输出结果如下，这表明绝大部分时间花在ind_y, ind_x = np.where(seg_image == i)行上。
seg_image是一个整数数组，它是分割图像的结果，从而找到seg_image == i提取特定分割对象的像素。我循环遍历了很多这些对象（在下面的代码中我只是循环5进行测试，但实际上我将循环超过20,000），并且需要很长时间才能运行！
有np.where电话可以加速的方式吗？或者，倒数第二行（也占很大比例的时间）可以加速吗？
理想的解决方案是立即在整个数组上运行代码，而不是循环，但我不认为这是可能的，因为我需要运行的某些函数存在副作用（例如扩展分段对象会使其与下一个区域“碰撞”，从而在以后给出不正确的结果。
有没有人有任何想法？
Line # Hits Time Per Hit % Time Line Contents
==============================================================
5 def correct_hot(hot_image, seg_image):
6 1 239810 239810.0 2.3 new_hot = hot_image.copy()
7 1 572966 572966.0 5.5 sign = np.zeros_like(hot_image) + 1
8 1 67565 67565.0 0.6 sign[:,:] = 1
9 1 1257867 1257867.0 12.1 sign[hot_image > 0] = -1
10
11 1 150 150.0 0.0 s_elem = np.ones((3, 3))
12
13 #for i in xrange(1,seg_image.max()+1):
14 6 57 9.5 0.0 for i in range(1,6):
15 5 6092775 1218555.0 58.5 ind_y, ind_x = np.where(seg_image == i)
16
17 # Get the average HOT value of the object (really simple!)
18 5 2408 481.6 0.0 obj_avg = hot_image[ind_y, ind_x].mean()
19
20 5 333 66.6 0.0 miny = np.min(ind_y)
21
22 5 162 32.4 0.0 minx = np.min(ind_x)
23
24
25 5 369 73.8 0.0 new_ind_x = ind_x - minx + 3
26 5 113 22.6 0.0 new_ind_y = ind_y - miny + 3
27
28 5 211 42.2 0.0 maxy = np.max(new_ind_y)
29 5 143 28.6 0.0 maxx = np.max(new_ind_x)
30
31 # 7 is + 1 to deal with the zero-based indexing, + 2 * 3 to deal with the 3 cell padding above
32 5 217 43.4 0.0 obj = np.zeros( (maxy+7, maxx+7) )
33
34 5 158 31.6 0.0 obj[new_ind_y, new_ind_x] = 1
35
36 5 2482 496.4 0.0 dilated = ndimage.binary_dilation(obj, s_elem)
37 5 1370 274.0 0.0 border = mahotas.borders(dilated)
38
39 5 122 24.4 0.0 border = np.logical_and(border, dilated)
40
41 5 355 71.0 0.0 border_ind_y, border_ind_x = np.where(border == 1)
42 5 136 27.2 0.0 border_ind_y = border_ind_y + miny - 3
43 5 123 24.6 0.0 border_ind_x = border_ind_x + minx - 3
44
45 5 645 129.0 0.0 border_avg = hot_image[border_ind_y, border_ind_x].mean()
46
47 5 2167729 433545.8 20.8 new_hot[seg_image == i] = (new_hot[ind_y, ind_x] + (sign[ind_y, ind_x] * np.abs(obj_avg - border_avg)))
48 5 10179 2035.8 0.1 print obj_avg, border_avg
49
50 1 4 4.0 0.0 return new_hot
答案 0 :(得分：4)
编辑我已将原始答案留在底部以备记录，但我实际上已经在午餐时更详细地查看了您的代码，我认为使用np.where是一个大错：
In [63]: a = np.random.randint(100, size=(1000, 1000))
In [64]: %timeit a == 42
1000 loops, best of 3: 950 us per loop
In [65]: %timeit np.where(a == 42)
100 loops, best of 3: 7.55 ms per loop
你可以在需要获得点的实际坐标的1/8的时间内获得一个布尔数组（可用于索引）！
当然会对您执行的功能进行裁剪，但ndimage具有find_objects函数，该函数返回封闭的切片，并且看起来非常快：
In [66]: %timeit ndimage.find_objects(a)
100 loops, best of 3: 11.5 ms per loop
这会返回一个包含所有对象的切片元组的列表，在找到一个对象的索引时需要多50％的时间。
它可能无法开箱即用，因为我现在无法测试它，但我会将您的代码重组为以下内容：
def correct_hot_bis(hot_image, seg_image):
# Need this to not index out of bounds when computing border_avg
hot_image_padded = np.pad(hot_image, 3, mode='constant',
constant_values=0)
new_hot = hot_image.copy()
sign = np.ones_like(hot_image, dtype=np.int8)
sign[hot_image > 0] = -1
s_elem = np.ones((3, 3))
for j, slice_ in enumerate(ndimage.find_objects(seg_image)):
hot_image_view = hot_image[slice_]
seg_image_view = seg_image[slice_]
new_shape = tuple(dim+6 for dim in hot_image_view.shape)
new_slice = tuple(slice(dim.start,
dim.stop+6,
None) for dim in slice_)
indices = seg_image_view == j+1
obj_avg = hot_image_view[indices].mean()
obj = np.zeros(new_shape)
obj[3:-3, 3:-3][indices] = True
dilated = ndimage.binary_dilation(obj, s_elem)
border = mahotas.borders(dilated)
border &= dilated
border_avg = hot_image_padded[new_slice][border == 1].mean()
new_hot[slice_][indices] += (sign[slice_][indices] *
np.abs(obj_avg - border_avg))
return new_hot
你仍然需要弄清楚碰撞，但你可以通过使用基于np.unique的方法同时计算所有指数来获得大约2倍的加速：
a = np.random.randint(100, size=(1000, 1000))
def get_pos(arr):
pos = []
for j in xrange(100):
pos.append(np.where(arr == j))
return pos
def get_pos_bis(arr):
unq, flat_idx = np.unique(arr, return_inverse=True)
pos = np.argsort(flat_idx)
counts = np.bincount(flat_idx)
cum_counts = np.cumsum(counts)
multi_dim_idx = np.unravel_index(pos, arr.shape)
return zip(*(np.split(coords, cum_counts) for coords in multi_dim_idx))
In [33]: %timeit get_pos(a)
1 loops, best of 3: 766 ms per loop
In [34]: %timeit get_pos_bis(a)
1 loops, best of 3: 388 ms per loop
请注意，每个对象的像素以不同的顺序返回，因此您不能简单地比较两个函数的返回值来评估相等性。但他们都应该返回相同的。
答案 1 :(得分：2)
你可以做同样的一点时间就是保存seg_image == i的结果，这样你就不需要计算两次了。你是在第15和第15行计算的。 47，您可以添加seg_mask = seg_image == i然后重复使用该结果（为了分析目的，将该部分分开也可能是好事。）
虽然你可以做一些其他的小事来勉强一点性能，但根本问题是你使用的是O（M * N）算法，其中M是段数，N是你的形象的大小。从你的代码中我不清楚是否有更快的算法来完成相同的事情，但这是我尝试寻找加速的第一个地方。