Python SciPy distance.cdist用法及代码示例

本文简要介绍 python 语言中 scipy.spatial.distance.cdist 的用法。

用法:
scipy.spatial.distance.cdist(XA, XB, metric='euclidean', *, out=None, **kwargs)#

计算两个输入集合中每对之间的距离。

有关常见调用约定，请参阅注释。

参数：：

XA： array_like

\(m_A\) by \(n\) 数组 \(m_A\) 在 \(n\) 维空间中的原始观测值。输入转换为浮点类型。

XB： array_like

\(m_B\) by \(n\) 数组 \(m_B\) 在 \(n\) 维空间中的原始观测值。输入转换为浮点类型。

metric： str 或可调用，可选

要使用的距离度量。如果是字符串，距离函数可以是‘braycurtis’, ‘canberra’, ‘chebyshev’, ‘cityblock’, ‘correlation’, ‘cosine’, ‘dice’, ‘euclidean’, ‘hamming’, ‘jaccard’, ‘jensenshannon’、‘kulczynski1’, ‘mahalanobis’、‘matching’, ‘minkowski’, ‘rogerstanimoto’, ‘russellrao’, ‘seuclidean’, ‘sokalmichener’, ‘sokalsneath’, ‘sqeuclidean’, ‘yule’。

**kwargs：字典，可选

指标的额外参数：请参阅每个指标文档以获取所有可能参数的列表。

一些可能的论点：

p：标量 p-norm 申请 Minkowski，加权和未加权。默认值：2。

w: 数组支持权重的指标的权重向量(例如 Minkowski)。

V: 数组标准化欧几里得的方差向量。默认值：var(vstack([XA, XB]), axis=0, ddof=1)

VI：数组 Mahalanobis 的协方差矩阵的逆矩阵。默认值：inv(cov(vstack([XA, XB].T))).T

out: ndarray 输出数组如果不是None，距离矩阵Y存储在这个数组中。

Y： ndarray: 返回一个\(m_A\) by \(m_B\) 距离矩阵。对于每个 \(i\) 和 \(j\) ，度量 dist(u=XA[i], v=XB[j]) 被计算并存储在第 \(ij\) 条目中。

抛出：：

ValueError: 如果 XA 和 XB 的列数不同，则会引发异常。

注意：

以下是常见的调用约定：

Y = cdist(XA, XB, 'euclidean')

使用欧几里德距离(2-范数)作为点之间的距离度量来计算\(m\) 点之间的距离。这些点在矩阵 X 中排列为 \(m\) \(n\) 维行向量。
Y = cdist(XA, XB, 'minkowski', p=2.)

使用 Minkowski 距离 \(\|u-v\|_p\) ( \(p\) -norm) 计算距离，其中 \(p > 0\) (请注意，如果 \(0 < p < 1\) ，这只是 quasi-metric )。
Y = cdist(XA, XB, 'cityblock')

计算点之间的城市街区或曼哈顿距离。
Y = cdist(XA, XB, 'seuclidean', V=None)

计算标准化欧几里得距离。两个n-vectorsu和v之间的标准化欧几里得距离是

\[\sqrt{\sum {(u_i-v_i)^2 / V[x_i]}}.\]

V是方差向量； V[i] 是对点的所有第 i 个分量计算的方差。如果未通过，则自动计算。
Y = cdist(XA, XB, 'sqeuclidean')

计算向量之间的平方欧几里得距离\(\|u-v\|_2^2\)。
Y = cdist(XA, XB, 'cosine')

计算向量 u 和 v 之间的余弦距离，

\[1 - \frac{u \cdot v} {{\|u\|}_2 {\|v\|}_2}\]

其中 \(\|*\|_2\) 是其参数 * 的 2 范数，而 \(u \cdot v\) 是 \(u\) 和 \(v\) 的点积。
Y = cdist(XA, XB, 'correlation')

计算向量 u 和 v 之间的相关距离。这是

\[1 - \frac{(u - \bar{u}) \cdot (v - \bar{v})} {{\|(u - \bar{u})\|}_2 {\|(v - \bar{v})\|}_2}\]

其中 \(\bar{v}\) 是向量 v 的元素的平均值，而 \(x \cdot y\) 是 \(x\) 和 \(y\) 的点积。
Y = cdist(XA, XB, 'hamming')

计算归一化的汉明距离，或两个不同意的 n-vectors u 和 v 之间的向量元素的比例。为了节省内存，矩阵X 可以是布尔类型。
Y = cdist(XA, XB, 'jaccard')

计算点之间的 Jaccard 距离。给定两个向量 u 和 v ，Jaccard 距离是那些不同意的元素的比例 u[i] 和 v[i] 其中至少有一个是非零的。
Y = cdist(XA, XB, 'jensenshannon')

计算两个概率数组之间的Jensen-Shannon 距离。给定两个概率向量 \(p\) 和 \(q\) ，Jensen-Shannon 距离为

\[\sqrt{\frac{D(p \parallel m) + D(q \parallel m)}{2}}\]

其中\(m\) 是\(p\) 和\(q\) 的逐点均值，\(D\) 是Kullback-Leibler 散度。
Y = cdist(XA, XB, 'chebyshev')

计算点之间的切比雪夫距离。两个n-vectors、u和v之间的切比雪夫距离是它们各自元素之间的最大范数1距离。更准确地说，距离由下式给出

\[d(u,v) = \max_i {|u_i-v_i|}.\]
Y = cdist(XA, XB, 'canberra')

计算点之间的堪培拉距离。 u 和 v 两点之间的堪培拉距离为

\[d(u,v) = \sum_i \frac{|u_i-v_i|} {|u_i|+|v_i|}.\]
Y = cdist(XA, XB, 'braycurtis')

计算点之间的Bray-Curtis 距离。两点u和v之间的Bray-Curtis距离为

\[d(u,v) = \frac{\sum_i (|u_i-v_i|)} {\sum_i (|u_i+v_i|)}\]
Y = cdist(XA, XB, 'mahalanobis', VI=None)

计算点之间的马氏距离。 u 和 v 两点之间的马氏距离为 \(\sqrt{(u-v)(1/V)(u-v)^T}\)，其中 \((1/V)\)(VI 变量)是逆协方差。如果VI 不是None，则VI 将用作逆协方差矩阵。
Y = cdist(XA, XB, 'yule')

计算布尔向量之间的 Yule 距离。 (参见 yule 函数文档)
Y = cdist(XA, XB, 'matching')

‘hamming’ 的同义词。
Y = cdist(XA, XB, 'dice')

计算布尔向量之间的骰子距离。 (参见 dice 函数文档)
Y = cdist(XA, XB, 'kulczynski1')

计算布尔向量之间的 kulczynski 距离。 (参见 kulczynski1 函数文档)
Y = cdist(XA, XB, 'rogerstanimoto')

计算布尔向量之间的Rogers-Tanimoto 距离。 (参见 rogerstanimoto 函数文档)
Y = cdist(XA, XB, 'russellrao')

计算布尔向量之间的Russell-Rao 距离。 (参见 russellrao 函数文档)
Y = cdist(XA, XB, 'sokalmichener')

计算布尔向量之间的Sokal-Michener 距离。 (参见 sokalmichener 函数文档)
Y = cdist(XA, XB, 'sokalsneath')

计算向量之间的Sokal-Sneath 距离。 (参见 sokalsneath 函数文档)
Y = cdist(XA, XB, f)

使用用户提供的 2 元函数 f 计算 X 中所有向量对之间的距离。例如，向量之间的欧几里得距离可以计算如下：
```
dm = cdist(XA, XB, lambda u, v: np.sqrt(((u-v)**2).sum()))
```
请注意，您应该避免传递对此库中定义的距离函数之一的引用。例如，：
```
dm = cdist(XA, XB, sokalsneath)
```
将使用 Python 函数 sokalsneath 计算 X 中向量之间的成对距离。这将导致 sokalsneath 被调用 \({n \choose 2}\) 次，这是低效的。相反，优化的 C 版本更加高效，我们使用以下语法来调用它：
```
dm = cdist(XA, XB, 'sokalsneath')
```

例子：

求四个二维坐标之间的欧几里得距离：

>>> from scipy.spatial import distance
>>> import numpy as np
>>> coords = [(35.0456, -85.2672),
...           (35.1174, -89.9711),
...           (35.9728, -83.9422),
...           (36.1667, -86.7833)]
>>> distance.cdist(coords, coords, 'euclidean')
array([[ 0.    ,  4.7044,  1.6172,  1.8856],
       [ 4.7044,  0.    ,  6.0893,  3.3561],
       [ 1.6172,  6.0893,  0.    ,  2.8477],
       [ 1.8856,  3.3561,  2.8477,  0.    ]])

求从 3-D 点到单位立方体角的曼哈顿距离：

>>> a = np.array([[0, 0, 0],
...               [0, 0, 1],
...               [0, 1, 0],
...               [0, 1, 1],
...               [1, 0, 0],
...               [1, 0, 1],
...               [1, 1, 0],
...               [1, 1, 1]])
>>> b = np.array([[ 0.1,  0.2,  0.4]])
>>> distance.cdist(a, b, 'cityblock')
array([[ 0.7],
       [ 0.9],
       [ 1.3],
       [ 1.5],
       [ 1.5],
       [ 1.7],
       [ 2.1],
       [ 2.3]])

相关用法

注：本文由纯净天空筛选整理自scipy.org大神的英文原创作品 scipy.spatial.distance.cdist。非经特殊声明，原始代码版权归原作者所有，本译文未经允许或授权，请勿转载或复制。

用法:

参数 ：：

返回 ：：

抛出 ：：

注意：

例子：

参数：：

返回：：

抛出：：