Question

假设我有一个二进制40*40矩阵。在此矩阵中，值可以是1或0。

我需要解析整个矩阵，对于任何值== 1，请应用以下内容：

如果满足以下条件，则将该值保持为1，否则将其修改回0：

条件：在N*N的平方中（以当前评估值为中心），我至少可以计算M个值== 1。

N和M是可以为算法设置的参数，自然是N<20（在这种情况下）和M<(N*N - 1)。

显而易见的算法是遍历整个图像，然后每次值== 1时进行迭代。围绕该值执行另一次搜索。它将构成一个O ^ 3复杂算法。有什么想法可以提高效率吗？

编辑：一些代码使此操作更易于理解。

让我们创建一个随机初始化的1s和0s的40 * 40矩阵。 5％（任意选择）的值为1s，95％的值为0s。

import matplotlib.pyplot as plt
import numpy as np

%matplotlib inline

def display_array(image):
    image_display_ready = image * 255

    print(image_display_ready)

    plt.imshow(image_display_ready, cmap='gray')
    plt.show()

image = np.zeros([40,40])

for _ in range(80):  # 5% of the pixels are == 1
    i, j = np.random.randint(40, size=2)
    image[i, j] = 1

# Image displayed on left below before preprocessing    
display_array(image)   

def cleaning_algorithm_v1(src_image, FAT, LR, FLAG, verbose=False):
    """
    FAT  = 4 # False Alarm Threshold (number of surrounding 1s pixel values)
    LR   = 8 # Lookup Range +/- i/j value
    FLAG = 2 # 1s pixels kept as 1s after processing are flag with this value.
    """

    rslt_img = np.copy(src_image)

    for i in range(rslt_img.shape[0]):
        for j in  range(rslt_img.shape[1]):

            if rslt_img[i, j] >= 1:

                surrounding_abnormal_pixels = list()

                lower_i = max(i - LR, 0)
                upper_i = min(i + LR + 1, rslt_img.shape[0])

                lower_j = max(j - LR, 0)
                upper_j = min(j + LR + 1, rslt_img.shape[1])

                abnormal_pixel_count = 0

                for i_k in range(lower_i, upper_i):
                    for j_k in range(lower_j, upper_j):

                        if i_k == i and j_k == j:
                            continue

                        pixel_value = rslt_img[i_k, j_k]

                        if pixel_value >= 1:
                            abnormal_pixel_count += 1

                if abnormal_pixel_count >= FAT:
                    rslt_img[i, j] = FLAG

    rslt_img[rslt_img != FLAG] = 0
    rslt_img[rslt_img == FLAG] = 1

    return rslt_img

# Image displayed on right below after preprocessing  
display_array(cleaning_algorithm_v1(image, FAT=10, LR=6, FLAG=2))

其中给出以下内容：

Answer 1

使用卷积怎么样？

您的内核将是1的NxN窗口。在这种情况下，内核是可分离的，因此您可以将卷积处理为2个1-D卷积。您可以执行以下操作：

import numpy as np
from scipy.ndimage.filters import convolve1d
from time import time

mat = np.random.random_integers(0, 1, (40, 40))

N = 5
M = 15

window = np.ones((N, ), dtype=np.int)

start = time()

interm = convolve1d(mat, window, axis=0)
result = convolve1d(interm, window, axis=1)

[rows, cols] = np.where(result >= M)
result[:, :] = 0
result[(rows, cols)] = 1

end = time()
print "{} seconds".format(end - start)
0.00155591964722 seconds

不确定如何比较复杂度，但是在各种python深度学习库中卷积都得到了很好的优化。

有优化该算法的想法吗？

编辑：一些代码使此操作更易于理解。

1 个答案: