虽然它没有解释你的记忆问题,但是可以说你的实现并不太好。你不仅没有充分利用numpy的能力,而且算法的流程也不能很好地避免重复计算。我认为你只是耗尽了系统资源,不是因为python或numpy出了问题,而是因为你创建了太多不必要的列表嵌套列表嵌套列表...
在查看
Lucas-Kanade算法的维基百科条目后,我重新编写了你的主函数如下:
def lucas_kanade_np(im1, im2, win=2):
assert im1.shape == im2.shape
I_x = np.zeros(im1.shape)
I_y = np.zeros(im1.shape)
I_t = np.zeros(im1.shape)
I_x[1:-1, 1:-1] = (im1[1:-1, 2:] - im1[1:-1, :-2]) / 2
I_y[1:-1, 1:-1] = (im1[2:, 1:-1] - im1[:-2, 1:-1]) / 2
I_t[1:-1, 1:-1] = im1[1:-1, 1:-1] - im2[1:-1, 1:-1]
params = np.zeros(im1.shape + (5,))
params[..., 0] = I_x * I_x
params[..., 1] = I_y * I_y
params[..., 2] = I_x * I_y
params[..., 3] = I_x * I_t
params[..., 4] = I_y * I_t
del I_x, I_y, I_t
cum_params = np.cumsum(np.cumsum(params, axis=0), axis=1)
del params
win_params = (cum_params[2 * win + 1:, 2 * win + 1:] -
cum_params[2 * win + 1:, :-1 - 2 * win] -
cum_params[:-1 - 2 * win, 2 * win + 1:] +
cum_params[:-1 - 2 * win, :-1 - 2 * win])
del cum_params
op_flow = np.zeros(im1.shape + (2,))
det = win_params[...,0] * win_params[..., 1] - win_params[..., 2] **2
op_flow_x = np.where(det != 0,
(win_params[..., 1] * win_params[..., 3] -
win_params[..., 2] * win_params[..., 4]) / det,
0)
op_flow_y = np.where(det != 0,
(win_params[..., 0] * win_params[..., 4] -
win_params[..., 2] * win_params[..., 3]) / det,
0)
op_flow[win + 1: -1 - win, win + 1: -1 - win, 0] = op_flow_x[:-1, :-1]
op_flow[win + 1: -1 - win, win + 1: -1 - win, 1] = op_flow_y[:-1, :-1]
return op_flow
它使用两个嵌套调用
np.cumsum
和排斥-包容原理来计算窗口参数。由于每个点要解决的方程组只有2x2,因此它使用克莱默法则对其进行向量化求解。
为了比较,我将您的
lucas_kanade
函数重命名为
lucas_kanade_op
,并对最后一个语句进行了单个更改,以便返回一个numpy数组:
def lucas_kanade_op(im1, im2, win=2) :
...
return np.array(opfl)
我记录了两种方法的时间(并检查它们都输出相同的结果),毫不意外,利用numpy可以大幅提升效率:
rows, cols = 100, 100
im1 = np.random.rand(rows, cols)
im2 = np.random.rand(rows, cols)
ans1 = lucas_kanade_op(im1, im2)
ans2 = lucas_kanade_np(im1, im2)
np.testing.assert_almost_equal(ans1,ans2)
import timeit
print 'op\'s time:', timeit.timeit('lucas_kanade_op(im1, im2)',
'from __main__ import lucas_kanade_op, im1, im2',
number=1)
print 'np\'s time:', timeit.timeit('lucas_kanade_np(im1, im2)',
'from __main__ import lucas_kanade_np, im1, im2',
number=1)
这将打印输出:
op's time: 5.7419579567
np's time: 0.00256002154425
那么对于一个较小的100x100像素的图像,速度提高了2000倍。我没有敢测试您的方法是否适用于全尺寸480p图像,但是上面的函数可以处理大约每秒5个随机854x480数组的计算,而且没有任何问题。
我建议您按照上述方式重写代码,充分利用numpy。将您的完整代码发布到
Code Review可能是一个好的起点。但是,如果您的代码本身效率低下,那么寻找杂散对象的引用就没有什么意义了!