使用 2d 数组在 for 循环上进行更快的迭代

Question

我在计算视差图估计误差的优化方面遇到了问题。

为了计算错误，我创建了一个 class 并为每个错误调用了方法。我需要对每个像素进行迭代以获得错误。这个数组很大，因为我正在迭代大小为 1937 x 1217 的图像。你知道怎么优化吗？

这是我的方法代码：

编辑：

def mreError(self):
    s_gt = self.ref_disp_norm
    s_all = self.disp_bin
    s_r = self.disp_norm 

    s_gt = s_gt.astype(np.float32)
    s_r = s_r.astype(np.float32)
    n, m = s_gt.shape
    all_arr = []

    for i in range(0, n):
        for j in range(0, m):

            if s_all[i,j] == 255:
                if s_gt[i,j] == 0:
                    sub_mre = 0
                else:   
                    sub_mre = np.abs(s_gt[i,j] - s_r[i,j]) / s_gt[i,j]
                all_arr.append(sub_mre)

    mre_all = np.mean(all_arr)
    return mre_all

Answer 1

您可以简单地使用数组运算符，而不是将它们应用于 for 循环中的每个元素：

import numpy as np

# Creating 2000x2000 Test-Data
s_gt = np.random.randint(0,2,(2000,2000)).astype(np.float32)
s_r = np.random.randint(0,2,(2000,2000)).astype(np.float32)
s_all = np.random.randint(0,256,(2000,2000)).astype(np.float32)


def calc(s_gt, s_r, s_all):
    n, m = s_gt.shape
    all_arr = []
    for i in range(0, n):
        for j in range(0, m):
            if s_gt[i,j] == 0:
                sub_mre = 0
            else:   
                sub_mre = np.abs(s_gt[i,j] - s_r[i,j]) / s_gt[i,j]
    
            if s_all[i,j] == 255:
                all_arr.append(sub_mre)
    
    mre_all = np.mean(all_arr)
    return mre_all

def calc_optimized(s_gt, s_r, s_all):
    sub_mre = np.abs((s_gt-s_r)/s_gt)
    sub_mre[s_gt==0] = 0
    return np.mean(sub_mre[s_all == 255])

当我测试两种不同方法的速度时：

%time calc(s_gt, s_r, s_all)
Wall time: 27.6 s
Out[53]: 0.24686379928315413

%time calc_optimized(s_gt, s_r, s_all)
Wall time: 63.3 ms
__main__:34: RuntimeWarning: divide by zero encountered in true_divide
__main__:34: RuntimeWarning: invalid value encountered in true_divide
Out[54]: 0.2468638

Answer 2

你的方法的直接矢量化是

def method_1(self):
    # get s_gt, s_all, s_r
    sub_mre = np.zeros((s_gt.shape), dtype=np.float32)
    idx = s_gt != 0
    sub_mre[idx] = np.abs((s_gt[idx] - s_r[idx]) / s_gt[idx])
    return np.mean(sub_mre[s_all == 255])

但是由于您只对 s_all 为 255 的像素进行平均，因此您也可以先对这些像素进行过滤，然后再对其余的进行过滤

def method_2(self):
    idx = s_all == 255
    s_gt = s_gt[idx].astype(np.float32)
    s_r = s_r[idx].astype(np.float32)
    sub_mre = np.zeros_like(s_gt)
    idx = s_gt != 0
    sub_mre[idx] = np.abs((s_gt[idx] - s_r[idx]) / s_gt[idx])
    return np.mean(sub_mre)

就我个人而言，我更喜欢第一种方法，除非第二种方法会产生更快的结果。仅调用函数一次并花费，例如 40 毫秒 vs 5 毫秒并不明显，函数的可读性更重要。

Answer 3

您可以只将图像设为灰色（这会大大加快计算速度）去看看这个link您是如何做到的。

使用 2d 数组在 for 循环上进行更快的迭代

Faster iteration on for loop with 2d arrays

python

numpy

opencv

disparity-mapping

depth-testing