numpy数组之间的距离,按列

Question

我在2D中有2个数组,其中列向量是特征向量.一个阵列的大小为F x A,另一个阵列的大小为F x B,其中A << B.例如,A = 2且F = 3(B可以是任何东西):

arr1 = np.array( [[1, 4],
                  [2, 5],
                  [3, 6]] )

arr2 = np.array( [[1, 4, 7, 10, ..],
                  [2, 5, 8, 11, ..],
                  [3, 6, 9, 12, ..]] )

我想计算每个可能的片段之间的距离arr1和arr2相同大小的片段(在这种情况下,3x2)arr2.列向量是相互独立的,所以我相信我应该计算每个列向量之间的距离arr1和列向量的集合,范围从i到i + A,arr2并取这些距离的总和(不确定).

numpy是否提供了一种有效的方法,或者我是否必须从第二个数组中获取切片,并使用另一个循环计算每个列向量arr1与切片中相应列向量之间的距离？

示例清晰,使用上述阵列:

>>> magical_distance_func(arr1, arr2[:,:2])
[0, 10.3923..]
>>> # First, distance between arr2[:,:2] and arr1, which equals 0.
>>> # Second, distance between arr2[:,1:3] and arr1, which equals 
>>> diff = arr1 - np.array( [[4,7],[5,8],[6,9]] )
>>> diff
[[-3, -3], [-3, -3], [-3, -3]]
>>> # this happens to consist only of -3's. Norm of each column vector is:
>>> norm1 = np.linalg.norm([:,0])
>>> norm2 = np.linalg.norm([:,1])
>>> # would be extremely good if this worked for an arbitrary number of norms
>>> totaldist = norm1 + norm2
>>> totaldist
10.3923...

当然,转换数组也很好,如果这意味着cdist可以以某种方式在这里使用.

Answer 1

如果我正确理解你的问题,这将有效.知道numpy,可能有更好的方法,但这至少相当简单.我使用了一些人为的坐标来表明计算是按预期工作的.

>>> arr1
array([[0, 3],
       [1, 4],
       [2, 5]])
>>> arr2
array([[ 3,  6,  5,  8],
       [ 5,  8, 13, 16],
       [ 2,  5,  2,  5]])

您可以减去arr1从arr2通过确保它们相互播出正确.我能想到的最好的方法是进行转置并进行一些重塑.这些不会创建副本 - 它们创建视图 - 所以这不是那么浪费.(dist虽然是副本.)

>>> dist = (arr2.T.reshape((2, 2, 3)) - arr1.T).reshape((4, 3))
>>> dist
array([[ 3,  4,  0],
       [ 3,  4,  0],
       [ 5, 12,  0],
       [ 5, 12,  0]])

现在我们所要做的就是numpy.linalg.norm跨轴1 应用.(您可以从几个规范中进行选择).

>>> numpy.apply_along_axis(numpy.linalg.norm, 1, dist)
array([  5.,   5.,  13.,  13.])

假设您想要简单的欧氏距离,您也可以直接进行; 不确定这是更快还是更慢所以尝试两者:

>>> (dist ** 2).sum(axis=1) ** 0.5
array([  5.,   5.,  13.,  13.])

根据您的编辑,我们只需做一个小调整.由于您希望成对地测试列,而不是按块,因此需要滚动窗口.这可以通过相当简单的索引非常简单地完成:

>>> arr2.T[numpy.array(zip(range(0, 3), range(1, 4)))]
array([[[ 3,  5,  2],
        [ 6,  8,  5]],

       [[ 6,  8,  5],
        [ 5, 13,  2]],

       [[ 5, 13,  2],
        [ 8, 16,  5]]])

将其与其他技巧相结合:

>>> arr2_pairs = arr2.T[numpy.array(zip(range(0, 3), range(1, 4)))]
>>> dist = arr2_pairs - arr1.T
>>> (dist ** 2).sum(axis=2) ** 0.5
array([[  5.        ,   5.        ],
       [  9.69535971,   9.69535971],
       [ 13.        ,  13.        ]])

但是,从列表推导转换数组往往很慢.这可能是更快地使用stride_tricks -在这里再次,看看哪一个适合你的目的最好的:

>>> as_strided(arr2.T, strides=(8, 8, 32), shape=(3, 2, 3))
array([[[ 3,  5,  2],
        [ 6,  8,  5]],

       [[ 6,  8,  5],
        [ 5, 13,  2]],

       [[ 5, 13,  2],
        [ 8, 16,  5]]])

这实际上操纵了numpy在内存块上移动的方式,允许小数组模拟更大的数组.

>>> arr2_pairs = as_strided(arr2.T, strides=(8, 8, 32), shape=(3, 2, 3))
>>> dist = arr2_pairs - arr1.T
>>> (dist ** 2).sum(axis=2) ** 0.5
array([[  5.        ,   5.        ],
       [  9.69535971,   9.69535971],
       [ 13.        ,  13.        ]])

所以现在你有一个简单的二维数组,对应于每对列的距离.现在只需要接听mean电话即可argmin.

>>> normed = (dist ** 2).sum(axis=2) ** 0.5
>>> normed.mean(axis=1)
array([  5.        ,   9.69535971,  13.        ])
>>> min_window = normed.mean(axis=1).argmin()
>>> arr2[:,[min_window, min_window + 1]]
array([[3, 6],
       [5, 8],
       [2, 5]])