python - numpy 数组之间的距离，按列

Question

我有 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]])

您可以从 arr2 中减去 arr1，方法是确保它们相互正确广播。我能想到的最好方法是进行转置并进行一些 reshape 。这些不创建副本——它们创建 View ——所以这不是那么浪费。 (虽然 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]])

现在我们所要做的就是在轴 1 上应用 numpy.linalg.norm。(您可以从多个 norms 中进行选择)。

>>> 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.])

---

根据您的修改，我们只需要做一点小调整。由于您想成对测试列，而不是按 block 测试，因此您需要一个滚动窗口。这可以通过相当简单的索引非常简单地完成:

>>> 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]])