Question

我在2D中有2个数组，其中列向量是特征向量。一个阵列的大小为F×A，另一个阵列的大小为F×B，其中A <1。 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片段（在本例中为3x2）之间的距离。列向量是相互独立的，所以我相信我应该计算arr1中每个列向量与i到i + A之间的列向量集合之间的距离{{1并获取这些距离的总和（不确定）。

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

清晰度示例，使用上述阵列：

arr1

当然，转换数组也很好，如果这意味着可以在某种程度上使用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]])

现在我们所要做的就是在轴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.])

根据您的修改，我们只需进行一次小调整。由于您希望成对地测试列，而不是按块，因此需要滚动窗口。这可以通过相当简单的索引非常简单地完成：

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

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

有很多距离可用。查看documentation。

Answer 3

scipy.spatial.distance.cdist？

numpy数组之间的距离，按列

3 个答案: