Question

如何在大矩阵中找到小矩阵的最佳“匹配”？例如：

 small=[[1,2,3],
        [4,5,6],
        [7,8,9]]



    big=[[2,4,2,3,5],
         [6,0,1,9,0],
         [2,8,2,1,0],
         [7,7,4,2,1]]

将匹配定义为矩阵中数字的差，因此位置（1,1）的匹配就好像小数字5等于大矩阵的数字0（因此坐标中小矩阵的中心数（1 ，1）大矩阵。

位置（1,1）的匹配值为： m（1,1）= | 2-1 | + | 4-2 | + | 2-3 | + | 6-4 | + | 0-5 | + | 1-6 | + | 2-7 | + | 8−8 | + | 2−9 | = 28

目标是找到这些矩阵中可能的最低差异。

小的矩阵总是具有奇数行和列，因此很容易找到它的中心。

Answer 1

您可以遍历可行的行和列，并用big压缩small的切片以计算差异之和，并使用min找到差异中的最小值：

from itertools import islice
min(
    (
        sum(
            sum(abs(x - y) for x, y in zip(a, b))
            for a, b in zip(
                (
                    islice(r, col, col + len(small[0]))
                    for r in islice(big, row, row + len(small))
                ),
                small
            )
        ),
        (row, col)
    )
    for row in range(len(big) - len(small) + 1)
    for col in range(len(big[0]) - len(small[0]) + 1)
)

或一行：

min((sum(sum(abs(x - y) for x, y in zip(a, b)) for a, b in zip((islice(r, col, col + len(small[0])) for r in islice(big, row, row + len(small))), small)), (row, col)) for row in range(len(big) - len(small) + 1) for col in range(len(big[0]) - len(small[0]) + 1))

这将返回：(24, (1, 0))

Answer 2

手工完成：

small=[[1,2,3],
       [4,5,6],
       [7,8,9]]


big=[[2,4,2,3,5],
     [6,0,1,9,0],
     [2,8,2,1,0],
     [7,7,4,2,1]]

# collect all the sums    
summs= [] 

# k and j are the offset into big

for k in range(len(big)-len(small)+1):
    # add inner list for one row
    summs.append([])
    for j in range(len(big[0])-len(small[0])+1):
        s = 0
        for row in range(len(small)):
            for col in range(len(small[0])):
                s += abs(big[k+row][j+col]-small[row][col])
        # add to the inner list
        summs[-1].append(s)

print(summs)

输出：

[[28, 29, 38], [24, 31, 39]]

如果您只是对较大的坐标感兴趣，请将(rowoffset,coloffset,sum)的元组存储在列表中，不要将列表框放入列表中。您可以通过以下方式将min()与密钥一起使用：

summs = []
for k in range(len(big)-len(small)+1):
    for j in range(len(big[0])-len(small[0])+1):
        s = 0
        for row in range(len(small)):
            for col in range(len(small[0])):
                s += abs(big[k+row][j+col]-small[row][col])
        summs .append( (k,j,s) )  # row,col, sum

print ("Min value for bigger matrix at ", min(summs , key=lambda x:x[2]) )

输出：

Min value for bigger matrix at  (1, 0, 24)

如果您具有“绘制”功能，则只会返回行数最少的列，即col偏移量。

Answer 3

另一个可能的解决方案是，返回最小差和big矩阵中的坐标：

small=[[1,2,3],
       [4,5,6],
       [7,8,9]]

big=[[2,4,2,3,5],
     [6,0,1,9,0],
     [2,8,2,1,0],
     [7,7,4,2,1]]

def difference(small, matrix):
    l = len(small)
    return sum([abs(small[i][j] - matrix[i][j]) for i in range(l) for j in range(l)])

def getSubmatrices(big, smallLength):
    submatrices = []
    bigLength = len(big)
    step = (bigLength // smallLength) + 1
    for i in range(smallLength):
        for j in range(step):
            tempMatrix = [big[j+k][i:i+smallLength] for k in range(smallLength)]
            submatrices.append([i+1,j+1,tempMatrix])
    return submatrices

def minDiff(small, big):
    submatrices = getSubmatrices(big, len(small))
    diffs = [(x,y, difference(small, submatrix)) for x, y, submatrix in submatrices]
    minDiff = min(diffs, key=lambda elem: elem[2])
    return minDiff

y, x, diff = minDiff(small, big)

print("Minimum difference: ", diff)
print("X = ", x)
print("Y = ", y)

输出：

Minimum difference:  24
X =  1
Y =  2

Answer 4

我会用numpy来解决这个问题。

首先，我将数组转换为numpy数组

import numpy as np

small = np.array([[1,2,3], [4,5,6], [7,8,9]])
big = np.array([[2,4,2,3,5], [6,0,1,9,0], [2,8,2,1,0], [7,7,4,2,1]])

然后我将初始化一个数组以存储测试的结果（可选：还有一个字典）

result_shape = np.array(big.shape) - np.array(small.shape) + 1
results = np.zeros((result_shape[0], result_shape[1]))
result_dict = {}

然后在可以将小矩阵放置在大矩阵上的位置上进行迭代，并计算差值：

insert = np.zeros(big.shape)
for i in range(results.shape[0]):
    for j in range(results.shape):
        insert[i:small.shape[0] + i, j:small.shape[1] + j] = small
        results[i, j] = np.sum(np.abs(big - insert)[i:3+i, j:3+j])
        # Optional dictionary 
        result_dict['{}{}'.format(i, j)] = np.sum(np.abs(big - insert)[i:3+i, j:3+j])

然后您可以print(results)并获得：

[[ 28.  29.  38.]
 [ 24.  31.  39.]]

和/或由于小矩阵在大矩阵上的位置存储在字典的键中，因此您可以通过按键操作获得小矩阵在大矩阵上的位置，其中差异最小： >

pos_min = [int(i) for i in list(min(result_dict, key=result_dict.get))]

，如果您print(pos_min)，您将获得：

[1, 0]

然后，如果您需要索引来进行任何操作，则可以根据需要对其进行迭代。希望这会有所帮助！

python中的矩阵匹配

4 个答案: