8

我有 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可能的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。

4

3 回答 3

5

如果我正确理解您的问题，这将起作用。知道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]])
于 2012-06-19T15:13:15.303 回答
2

您可以使用 scipy.spatial.distance 中的 cdist 获取距离矩阵。一旦你有了距离矩阵，你就可以跨列求和并归一化以获得平均距离，如果那是你正在寻找的。

注意：cdist 不使用列，而是使用行来计算成对距离。

这里有一个使用“余弦”距离的示例：

from scipy.spatial.distance import cdist

arr1 = np.array( [[1, 7],
                 [4, 8],
                 [4, 0]] )

arr2 = array( [[1, 9, 3, 6, 2],
              [3, 9, 0, 2, 3],
              [6, 0, 2, 7, 4]] )

# distance matrix
D = cdist( arr1.transpose(), arr2.transpose(), 'cosine' )

# average distance array (each position corresponds to each column of arr1)
d1 = D.mean( axis=1 )

# average distance array (each position corresponds to each column of arr2)
d2 = D.mean( axis=0 )

# Results
d1 = array([ 0.23180963,  0.35643282])
d2 = array([ 0.31018485,  0.19337869,  0.46050302,  0.3233269 ,  0.18321265])

有很多距离可供选择。查看文档。

于 2012-06-19T15:16:39.673 回答
1

scipy.spatial.distance.cdist ？

于 2012-06-19T14:44:47.333 回答