凝聚距离矩阵如何工作？（pdist）

69

scipy.spatial.distance.pdist返回一个压缩距离矩阵。从文档中：

返回一个简化的距离矩阵Y。对于每个和（其中），度量dist（u = X [i]，v = X [j]）并存储在条目ij中。

我以为ij是故意的i*j。但是我认为我可能是错的。考虑

X = array([[1,2], [1,2], [3,4]])
dist_matrix = pdist(X)

然后文档说dist(X[0], X[2])应该是dist_matrix[0*2]。但是，dist_matrix[0*2]是0 －而不是2.8。

我应该使用什么公式访问给定i和的两个向量的相似性j？

python  numpy  scipy 
— 拉斐尔·阿尔梅达（Rafael Almeida）
source

Answers:

93

您可以这样看：假设xm是n。可能的m行对，一次选择两个itertools.combinations(range(m), 2)，例如，用于m=3：

>>> import itertools
>>> list(combinations(range(3),2))
[(0, 1), (0, 2), (1, 2)]

因此，如果d = pdist(x)，k第四个元组combinations(range(m), 2))给出与x关联的行的索引d[k]。

例：

>>> x = array([[0,10],[10,10],[20,20]])
>>> pdist(x)
array([ 10.        ,  22.36067977,  14.14213562])

第一个元素是dist(x[0], x[1])，第二个元素是，dist(x[0], x[2])第三个元素是dist(x[1], x[2])。

或者，您可以将其视为平方距离矩阵的上三角部分中的元素，并串在一起形成一维数组。

例如

>>> squareform(pdist(x)) 
array([[  0.   ,  10.   ,  22.361],
       [ 10.   ,   0.   ,  14.142],
       [ 22.361,  14.142,   0.   ]])

>>> y = array([[0,10],[10,10],[20,20],[10,0]])
>>> squareform(pdist(y)) 
array([[  0.   ,  10.   ,  22.361,  14.142],
       [ 10.   ,   0.   ,  14.142,  10.   ],
       [ 22.361,  14.142,   0.   ,  22.361],
       [ 14.142,  10.   ,  22.361,   0.   ]])
>>> pdist(y)
array([ 10.   ,  22.361,  14.142,  14.142,  10.   ,  22.361])
— 沃伦·韦克瑟
source
1
我知道了，很有趣。看起来，正方形更易于使用。sq_form [i，j]将为我提供y [i]和y [j]之间的精确距离。但是，我认为压缩形式在内存方面更好。也许我应该多读一点有关正方形的内容。但是没有一个简单的公式可以将i，j转换为dist位置，然后呢？
— 拉斐尔·阿尔梅达
2
这是实际记录的行为吗？当然，这是有道理的，但是API中没有任何东西使它看起来应该与匹配combinations(range(m), 2))，它对应于距离矩阵的下三角。为什么不上层呢？
— VF1
为什么说它对应于下三角形？例如，list(combinations(range(4), 2))给出[(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]。该列表中的每个元组都具有（row_index，column_index）的形式，因此它对应于上三角。
— 沃伦·韦克瑟
39

压缩距离矩阵到全距离矩阵

由pdist返回的压缩距离矩阵可以使用以下公式转换为完整距离矩阵scipy.spatial.distance.squareform：

>>> import numpy as np
>>> from scipy.spatial.distance import pdist, squareform
>>> points = np.array([[0,1],[1,1],[3,5], [15, 5]])
>>> dist_condensed = pdist(points)
>>> dist_condensed
array([  1.        ,   5.        ,  15.5241747 ,   4.47213595,
        14.56021978,  12.        ])

使用squareform转换到全矩阵：

>>> dist = squareform(dist_condensed)
array([[  0.        ,   1.        ,   5.        ,  15.5241747 ],
       [  1.        ,   0.        ,   4.47213595,  14.56021978],
       [  5.        ,   4.47213595,   0.        ,  12.        ],
       [ 15.5241747 ,  14.56021978,  12.        ,   0.        ]])

点i，j之间的距离存储在dist [i，j]中：

>>> dist[2, 0]
5.0
>>> np.linalg.norm(points[2] - points[0])
5.0

简明指数

可以将用于访问方矩阵元素的索引转换为压缩矩阵中的索引：

def square_to_condensed(i, j, n):
    assert i != j, "no diagonal elements in condensed matrix"
    if i < j:
        i, j = j, i
    return n*j - j*(j+1)//2 + i - 1 - j

例：

>>> square_to_condensed(1, 2, len(points))
3
>>> dist_condensed[3]
4.4721359549995796
>>> dist[1,2]
4.4721359549995796

缩略索引

另外，没有sqaureform的另一个方向是可能的，这在运行时和内存消耗方面更好：

import math

def calc_row_idx(k, n):
    return int(math.ceil((1/2.) * (- (-8*k + 4 *n**2 -4*n - 7)**0.5 + 2*n -1) - 1))

def elem_in_i_rows(i, n):
    return i * (n - 1 - i) + (i*(i + 1))//2

def calc_col_idx(k, i, n):
    return int(n - elem_in_i_rows(i + 1, n) + k)

def condensed_to_square(k, n):
    i = calc_row_idx(k, n)
    j = calc_col_idx(k, i, n)
    return i, j

例：

>>> condensed_to_square(3, 4)
(1.0, 2.0)

使用Squareform进行运行时比较

>>> import numpy as np
>>> from scipy.spatial.distance import pdist, squareform
>>> points = np.random.random((10**4,3))
>>> %timeit dist_condensed = pdist(points)
1 loops, best of 3: 555 ms per loop

事实证明，创建方形形式确实很慢：

>>> dist_condensed = pdist(points)
>>> %timeit dist = squareform(dist_condensed)
1 loops, best of 3: 2.25 s per loop

如果我们要搜索具有最大距离的两个点，则在全矩阵中搜索为O（n）而在压缩形式中仅搜索O（n / 2）也就不足为奇了：

>>> dist = squareform(dist_condensed)
>>> %timeit dist_condensed.argmax()
10 loops, best of 3: 45.2 ms per loop
>>> %timeit dist.argmax()
10 loops, best of 3: 93.3 ms per loop

在两种情况下，几乎都不需要花费两点就可以得到两点的理想值，但是计算浓缩指数当然会有些开销：

>>> idx_flat = dist.argmax()
>>> idx_condensed = dist.argmax()
>>> %timeit list(np.unravel_index(idx_flat, dist.shape))
100000 loops, best of 3: 2.28 µs per loop
>>> %timeit condensed_to_square(idx_condensed, len(points))
100000 loops, best of 3: 14.7 µs per loop
— 轻的
source
2
我有一个方形的距离矩阵-是否有一个转换为压缩形式的函数？（即与之相反squareform）...链接之类的函数期望压缩形式...编辑该squareform函数将双向执行...方式很酷... “ ...反之亦然。 ” 编辑2我称其为“ square -form”应为“ redundant” EDIT 3，并且链接将同时适用于这两种形式...
— 红豆2016年
1
@Red Pea正方形是其自身的逆函数（即，在完整的距离矩阵上运行时，会将其转换为正方形）
— moustachio
你是如何找出calc_row_idx并calc_col_idx？
— CMCDragonkai
如果我没记错的话，@ CMCDragonkai的想法是square_to_condensed()使用二次公式从i或j中提取公式并通过i或j求解。据我所记得，该计算有点麻烦，但是它仅涉及基本代数，并说明了不可能求解的某些原因（因为它是负数或复杂的）。绘制一个带有对角线为空的三角形矩阵示例会有所帮助。
— lumbric '18
在Python 3中，“索引索引”应使用整数除法//而不是浮点除法/，以便输出为整数。
— 麦克风
18

压缩矩阵的向量对应于正方形矩阵的底部三角形区域。要转换该三角形区域中的点，您需要计算三角形左侧的点数，以及列中的上方数。

您可以使用以下函数进行转换：

q = lambda i,j,n: n*j - j*(j+1)/2 + i - 1 - j

检查：

import numpy as np
from scipy.spatial.distance import pdist, squareform
x = np.random.uniform( size = 100 ).reshape( ( 50, 2 ) )
d = pdist( x )
ds = squareform( d )
for i in xrange( 1, 50 ):
    for j in xrange( i ):
        assert ds[ i, j ] == d[ q( i, j, 50 ) ]
— 尚克
source
2
请注意，它实际上是底部三角形区域，对于某些人可能很奇怪。
— shaunc 2014年
2
下三角是上三角的转置，因为距离矩阵是对称的，即，交换j，i-> i，j可获得相同的结果。您的解决方案使用较低三角形的解释，但是较高三角形的版本没有什么不对的地方（我认为这是人们对此的更常见的理解方式）
— David Marx
我正在尝试朝相反的方向移动：给定距离矩阵的索引（即平面向量），如何在不强制将其强制为正方形的情况下获取与该值相对应的矩阵索引（i，j） ？
— 大卫·马克思
squareform按行序列化距离向量。这意味着较小的索引始终是第一：（0,1），（0,2），（0,3）......
6

这是上三角版本（i <j），对某些人来说一定很有趣：

condensed_idx = lambda i,j,n: i*n + j - i*(i+1)/2 - i - 1

这很容易理解：

  1. 与i*n + j你去广场上形成矩阵的位置;
  2. 与- i*(i+1)/2删除下三角（包括对角线）中之前，我的所有行;
  3. 当- i您删除对角线之前的第i行中的头寸时；
  4. 与- 1您卸下对角线行我的位置。

检查：

import scipy
from scipy.spatial.distance import pdist, squareform
condensed_idx = lambda i,j,n: i*n + j - i*(i+1)/2 - i - 1
n = 50
dim = 2
x = scipy.random.uniform(size = n*dim).reshape((n, dim))
d = pdist(x)
ds = squareform(d)
for i in xrange(1, n-1):
    for j in xrange(i+1, n):
        assert ds[i, j] == d[condensed_idx(i, j, n)]
— 朱洪波
source
5

我有同样的问题。而且我发现使用起来更简单numpy.triu_indices：

import numpy as np
from scipy.spatial.distance import pdist, squareform
N = 10

# Calculate distances
X = np.random.random((N,3))
dist_condensed = pdist(X)

# Get indexes: matrix indices of dist_condensed[i] are [a[i],b[i]]
a,b = np.triu_indices(N,k=1)

# Fill distance matrix
dist_matrix = np.zeros((N,N))
for i in range(len(dist_condensed)):
    dist_matrix[a[i],b[i]] = dist_condensed[i]
    dist_matrix[b[i],a[i]] = dist_condensed[i]

# Compare with squareform output
np.all(dist_matrix == squareform(distances))
— Rustam Guliev
source
4

如果要访问与pdist平方距离矩阵的第（i，j）个元素相对应的元素，则数学公式如下：假设i < j（否则为翻转索引）if为i == j，则答案为0。 

X = random((N,m))
dist_matrix = pdist(X)

那么第（i，j）个元素是dist_matrix [ind]其中 

ind = (N - array(range(1,i+1))).sum()  + (j - 1 - i).
— 用户名
source
1
请注意array(range(1,i+1))).sum() == ((i+1)*i)/2（Google为“ Young Gauss”）。
— lumbric '16
如果我有一个数组array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])有N = 5，您的公式在行i = 3，列j = 2(5 - np.array(range(1,3+1))).sum() + (2 - 1 - 3)会给我7，并且应该给我5
— 维罗尼卡
3

如果有人在寻找逆变换（即给定元素索引idx，找出(i, j)与之对应的元素），那么这里是一个合理的矢量化解决方案：

def actual_indices(idx, n):
    n_row_elems = np.cumsum(np.arange(1, n)[::-1])
    ii = (n_row_elems[:, None] - 1 < idx[None, :]).sum(axis=0)
    shifts = np.concatenate([[0], n_row_elems])
    jj = np.arange(1, n)[ii] + idx - shifts[ii]
    return ii, jj

n = 5
k = 10
idx = np.random.randint(0, n, k)
a = pdist(np.random.rand(n, n))
b = squareform(a)

ii, jj = actual_indices(idx, n)]
assert np.allclose(b[ii, jj, a[idx])

我用它来找出矩阵中最接近的行的索引。

m = 3  # how many closest
lowest_dist_idx = np.argpartition(-a, -m)[-m:]
ii, jj = actual_indices(lowest_dist_idx, n)  # rows ii[0] and jj[0] are closest
— 本·乌斯曼
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.