11

作为大学项目，我正在使用 Lucas Kanade 方法编写光流脚本。虽然它运作良好，但有些事情我无法弄清楚。它在开始时使用几 MB 内存，但该数量每秒都在迅速增加。当它为 1 帧 480p 电影计算 OF 时，它使用了大约 1GB。当它达到 1.9GB 时，它会突然停止并停留在那里，即使离开了几个小时。

我尝试在另一台 PC 上运行脚本，它“仅”使用 1GB。

这真的很奇怪，因为根据我的计算，它应该使用少于 100MB 的空间。

最让我吃惊的是，脚本计算一帧后，我打印了垃圾收集器正在观看的对象数量，大约是 200 万，然后在强制收集后再次打印，结果完全一样。我等待计算第二帧（同时内存使用量增加了约 1GB），脚本打印了 GC 正在监视的对象数量 - 完全相同的数字接近 200 万。那么这是什么意思呢？那个 numpy 是用 C 语言编写的并且有内存泄漏？

我真的很想了解这种行为。

这是代码： http: //pastebin.com/WSi7akY4

4

1 回答 1

21

虽然它不能解释您的内存问题，但委婉地说，您的实现是次优的。您不仅没有充分利用 numpy 的功能，而且您的算法流程也不太擅长避免重复计算。我认为您只是在资源不足的情况下运行系统，不是因为 python 或 numpy 出现问题，而是因为您创建了太多不必要的列表列表...

在查看了维基百科关于 Lucas-Kanade 算法的条目后，我重写了您的 main 函数，如下所示：

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,)) #Ix2, Iy2, Ixy, Ixt, Iyt
    params[..., 0] = I_x * I_x # I_x2
    params[..., 1] = I_y * I_y # I_y2
    params[..., 2] = I_x * I_y # I_xy
    params[..., 3] = I_x * I_t # I_xt
    params[..., 4] = I_y * I_t # I_yt
    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，因此它使用 Cramer 规则对求解进行矢量化。

为了比较，我将您的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 图像，速度提高了 x2000。我不敢为全尺寸 480p 图像测试您的方法，但上面的函数每秒可以处理随机 854x480 数组上的大约 5 次计算，没有任何问题。

我建议您以类似于上面建议的方式重写您的代码，充分利用 numpy。将您的完整代码发布到Code Review将是一个很好的起点。但是，当您的代码一开始就如此低效时，寻找对对象的杂散引用确实没有意义！

于 2013-01-14T20:06:29.607 回答