对称 k 最近邻矩阵

Question

我需要在numpy中计算对称的成对相似矩阵 p

p_ij = 1 ： if i != j并且j在i的 k-最近邻中，反之亦然，否则p_ij = 0 。

为此，我需要一个对称的 k 最近邻矩阵。

这是我尝试过的：

def distance_matrix(A, B, squared=True):
    """
    get pairwise- euclidean distance or squared euclidean distance matrix
    :param A: array1
    :type A: numpy.array
    :param B: array2
    :type B: numpy.array
    :param squared: true if squared euclidean distance, false if euclidean distance
    :type squared: boolean
    :return: distance matrix between A and B
    :rtype: numpy.array
    """
    M = A.shape[0]
    N = B.shape[0]
    A_dots = (A * A).sum(axis=1).reshape((M, 1)) * np.ones(shape=(1, N))
    B_dots = (B * B).sum(axis=1) * np.ones(shape=(M, 1))
    D_squared = A_dots + B_dots - 2 * A.dot(B.T)
    D_squared = np.abs(D_squared)
    if not squared:
        D_squared = np.sqrt(D_squared)
    return D_squared


def pairwise_sim(x, k):
    """
    calculate pairwise similarity matrix for k nearest neighbours for each point i
    p_ij = 1 if i!=j and j among i k-nearest neighbour, else 0

    :param x: distance matrix
    :type x: numpy.array
    :param k: k nearest neighbours
    :type k: integer
    :return: k-nearest neighbours matrix for each points i
    :rtype: numpy.array
    """
    n, _ = np.shape(x)
    d = distance_matrix(x, x, squared=True)  # pairwise euclidean distance |y_i-y_j|^2 not necessary to take square-root
    neighbours = np.argsort(d, axis=1)[:, 1:k + 1]  # slicing row starting at 1 for skipping i==j p_ij -> p_ij = 0
    # sklearn alternative: nbrs = NearestNeighbors(n_neighbors=k+1, algorithm='ball_tree').fit(x)
    # dist, indi = nbrs.kneighbors(x)
    h = np.zeros((n, n))
    for i in range(n):
        h[i, neighbours[i, :]] = 1.0
    np.fill_diagonal(h, 0.0)  # zero diagonal
    return h

但是当我测试对称性时

def check_symmetric(a, rtol=1e-05, atol=1e-08):
    return np.allclose(a, a.T, rtol=rtol, atol=atol)

我被告知矩阵和转置不同。

一个简单的建议可能是：

h = np.maximum(h, hT) 。 但请注意，通过这样做，我每点可能会得到超过 k-neighbors。

例如k-neighbors=2 ，如果点i到j 、 r和s的最小距离相等，并且从j到i 、 k 、 l的最小距离相等，算法可以选择j和r作为i的最近邻, 和k和l作为j的最近邻。

h = np.maximum(h, hT)将因此从j->i创建一个附加条目，它现在有k+1最近邻。