python矩阵想成_Python-如何生成成对汉明距离矩阵

beginner with Python here. So I'm having trouble trying to calculate the resulting binary pairwise hammington distance matrix between the rows of an input matrix using only the numpy library. I'm supposed to avoid loops and use vectorization. If for instance I have something like:

[ 1, 0, 0, 1, 1, 0]

[ 1, 0, 0, 0, 0, 0]

[ 1, 1, 1, 1, 0, 0]

The matrix should be something like:

[ 0, 2, 3]

[ 2, 0, 3]

[ 3, 3, 0]

ie if the original matrix was A and the hammingdistance matrix is B. B[0,1] = hammingdistance (A[0] and A[1]). In this case the answer is 2 as they only have two different elements.

So for my code is something like this

def compute_HammingDistance(X):

hammingDistanceMatrix = np.zeros(shape = (len(X), len(X)))

hammingDistanceMatrix = np.count_nonzero ((X[:,:,None] != X[:,:,None].T))

return hammingDistanceMatrix

However it seems to just be returning a scalar value instead of the intended matrix. I know I'm probably doing something wrong with the array/vector broadcasting but I can't figure out how to fix it. I've tried using np.sum instead of np.count_nonzero but they all pretty much gave me something similar.

解决方案

Try this approach, create a new axis along axis = 1, and then do broadcasting and count trues or non zero with sum:

(arr[:, None, :] != arr).sum(2)

# array([[0, 2, 3],

# [2, 0, 3],

# [3, 3, 0]])

def compute_HammingDistance(X):

return (X[:, None, :] != X).sum(2)

Explanation:

1) Create a 3d array which has shape (3,1,6)

arr[:, None, :]

#array([[[1, 0, 0, 1, 1, 0]],

# [[1, 0, 0, 0, 0, 0]],

# [[1, 1, 1, 1, 0, 0]]])

2) this is a 2d array has shape (3, 6)

arr

#array([[1, 0, 0, 1, 1, 0],

# [1, 0, 0, 0, 0, 0],

# [1, 1, 1, 1, 0, 0]])

3) This triggers broadcasting since their shape doesn't match, and the 2d array arr is firstly broadcasted along the 0 axis of 3d array arr[:, None, :], and then we have array of shape (1, 6) be broadcasted against (3, 6). The two broadcasting steps together make a cartesian comparison of the original array.

arr[:, None, :] != arr

#array([[[False, False, False, False, False, False],

# [False, False, False, True, True, False],

# [False, True, True, False, True, False]],

# [[False, False, False, True, True, False],

# [False, False, False, False, False, False],

# [False, True, True, True, False, False]],

# [[False, True, True, False, True, False],

# [False, True, True, True, False, False],

# [False, False, False, False, False, False]]], dtype=bool)

4) the sum along the third axis count how many elements are not equal, i.e, trues which gives the hamming distance.