scipy.spatial.distance.

cdist#

scipy.spatial.distance.cdist(XA, XB, metric='euclidean', *, out=None, **kwargs)[Quelle]#

Berechnet die Distanz zwischen jedem Paar der beiden Input-Sammlungen.

Siehe Hinweise für gängige Aufrufkonventionen.

Parameter:

XAarray_like

Ein Array der Größe \(m_A\) mal \(n\) mit \(m_A\) ursprünglichen Beobachtungen in einem \(n\)-dimensionalen Raum. Die Eingaben werden in den Float-Typ konvertiert.

XBarray_like

Ein Array der Größe \(m_B\) mal \(n\) mit \(m_B\) ursprünglichen Beobachtungen in einem \(n\)-dimensionalen Raum. Die Eingaben werden in den Float-Typ konvertiert.

metricstr oder callable, optional

Die zu verwendende Distanzmetrik. Wenn eine Zeichenkette, kann die Distanzfunktion sein: ‘braycurtis’, ‘canberra’, ‘chebyshev’, ‘cityblock’, ‘correlation’, ‘cosine’, ‘dice’, ‘euclidean’, ‘hamming’, ‘jaccard’, ‘jensenshannon’, ‘kulczynski1’, ‘mahalanobis’, ‘matching’, ‘minkowski’, ‘rogerstanimoto’, ‘russellrao’, ‘seuclidean’, ‘sokalmichener’, ‘sokalsneath’, ‘sqeuclidean’, ‘yule’.

**kwargsdict, optional

Zusätzliche Argumente für metric: siehe die Dokumentation jeder Metrik für eine Liste aller möglichen Argumente.

Einige mögliche Argumente

p : scalar Das p-Norm-Maß für Minkowski, gewichtet und ungewichtet. Standard: 2.

w : array_like Der Gewichtsvektor für Metriken, die Gewichte unterstützen (z.B. Minkowski).

V : array_like Der Varianzvektor für standardisiertes Euklidisch. Standard: var(vstack([XA, XB]), axis=0, ddof=1)

VI : array_like Die Inverse der Kovarianzmatrix für Mahalanobis. Standard: inv(cov(vstack([XA, XB].T))).T

out : ndarray Das Ausgabearray. Wenn nicht None, wird die Distanzmatrix Y in diesem Array gespeichert.

Rückgabe:

Yndarray: Eine Distanzmatrix der Größe \(m_A\) mal \(m_B\) wird zurückgegeben. Für jedes \(i\) und \(j\) wird die Metrik dist(u=XA[i], v=XB[j]) berechnet und im \(ij\)-ten Eintrag gespeichert.

Löst aus:

ValueError: Eine Ausnahme wird ausgelöst, wenn XA und XB nicht die gleiche Anzahl von Spalten haben.

Hinweise

Die folgenden sind übliche Aufrufkonventionen

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

Berechnet die Distanz zwischen \(m\) Punkten unter Verwendung der Euklidischen Distanz (2-Norm) als Distanzmetrik zwischen den Punkten. Die Punkte sind als \(m\) \(n\)-dimensionale Zeilenvektoren in der Matrix X angeordnet.
Y = cdist(XA, XB, 'minkowski', p=2.)

Berechnet die Distanzen unter Verwendung der Minkowski-Distanz \(\|u-v\|_p\) (\(p\)-Norm), wobei \(p > 0\) (beachten Sie, dass dies nur eine Quasimetrik ist, wenn \(0 < p < 1\)).
Y = cdist(XA, XB, 'cityblock')

Berechnet die Cityblock- oder Manhattan-Distanz zwischen den Punkten.
Y = cdist(XA, XB, 'seuclidean', V=None)

Berechnet die standardisierte Euklidische Distanz. Die standardisierte Euklidische Distanz zwischen zwei n-Vektoren u und v ist

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

V ist der Varianzvektor; V[i] ist die Varianz, die über alle i-ten Komponenten der Punkte berechnet wird. Wenn nicht übergeben, wird sie automatisch berechnet.
Y = cdist(XA, XB, 'sqeuclidean')

Berechnet die quadrierte Euklidische Distanz \(\|u-v\|_2^2\) zwischen den Vektoren.
Y = cdist(XA, XB, 'cosine')

Berechnet die Kosinusdistanz zwischen den Vektoren u und v,

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

wobei \(\|*\|_2\) die 2-Norm seines Arguments * ist und \(u \cdot v\) das Skalarprodukt von \(u\) und \(v\) ist.
Y = cdist(XA, XB, 'correlation')

Berechnet die Korrelationsdistanz zwischen den Vektoren u und v. Dies ist

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

wobei \(\bar{v}\) der Mittelwert der Elemente des Vektors v ist und \(x \cdot y\) das Skalarprodukt von \(x\) und \(y\) ist.
Y = cdist(XA, XB, 'hamming')

Berechnet die normalisierte Hamming-Distanz, oder den Anteil der Vektorelemente zwischen zwei n-Vektoren u und v, die sich unterscheiden. Um Speicher zu sparen, kann die Matrix X vom Typ boolean sein.
Y = cdist(XA, XB, 'jaccard')

Berechnet die Jaccard-Distanz zwischen den Punkten. Gegeben sind zwei Vektoren u und v. Die Jaccard-Distanz ist der Anteil der Elemente u[i] und v[i], die sich unterscheiden, wobei mindestens einer von ihnen ungleich Null ist.
Y = cdist(XA, XB, 'jensenshannon')

Berechnet die Jensen-Shannon-Distanz zwischen zwei Wahrscheinlichkeitsarrays. Gegeben sind zwei Wahrscheinlichkeitsvektoren \(p\) und \(q\), die Jensen-Shannon-Distanz ist

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

wobei \(m\) der punktweise Mittelwert von \(p\) und \(q\) ist und \(D\) die Kullback-Leibler-Divergenz ist.
Y = cdist(XA, XB, 'chebyshev')

Berechnet die Chebyshev-Distanz zwischen den Punkten. Die Chebyshev-Distanz zwischen zwei n-Vektoren u und v ist die maximale Norm-1-Distanz zwischen ihren jeweiligen Elementen. Genauer gesagt, die Distanz ist gegeben durch

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

Berechnet die Canberra-Distanz zwischen den Punkten. Die Canberra-Distanz zwischen zwei Punkten u und v ist

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

Berechnet die Bray-Curtis-Distanz zwischen den Punkten. Die Bray-Curtis-Distanz zwischen zwei Punkten u und v ist

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

Berechnet die Mahalanobis-Distanz zwischen den Punkten. Die Mahalanobis-Distanz zwischen zwei Punkten u und v ist \(\sqrt{(u-v)(1/V)(u-v)^T}\), wobei \((1/V)\) (die Variable VI) die inverse Kovarianz ist. Wenn VI nicht None ist, wird VI als inverse Kovarianzmatrix verwendet.
Y = cdist(XA, XB, 'yule')

Berechnet die Yule-Distanz zwischen den booleschen Vektoren. (siehe Dokumentation der Funktion yule)
Y = cdist(XA, XB, 'matching')

Synonym für ‘hamming’.
Y = cdist(XA, XB, 'dice')

Berechnet die Dice-Distanz zwischen den booleschen Vektoren. (siehe Dokumentation der Funktion dice)
Y = cdist(XA, XB, 'kulczynski1')

Berechnet die Kulczynski-Distanz zwischen den booleschen Vektoren. (siehe Dokumentation der Funktion kulczynski1)

Veraltet seit Version 1.15.0: Diese Metrik ist veraltet und wird in SciPy 1.17.0 entfernt. Ersetzen Sie die Verwendung von cdist(XA, XB, 'kulczynski1') durch 1 / cdist(XA, XB, 'jaccard') - 1.
Y = cdist(XA, XB, 'rogerstanimoto')

Berechnet die Rogers-Tanimoto-Distanz zwischen den booleschen Vektoren. (siehe Dokumentation der Funktion rogerstanimoto)
Y = cdist(XA, XB, 'russellrao')

Berechnet die Russell-Rao-Distanz zwischen den booleschen Vektoren. (siehe Dokumentation der Funktion russellrao)
Y = cdist(XA, XB, 'sokalmichener')

Berechnet die Sokal-Michener-Distanz zwischen den booleschen Vektoren. (siehe Dokumentation der Funktion sokalmichener)

Veraltet seit Version 1.15.0: Diese Metrik ist veraltet und wird in SciPy 1.17.0 entfernt. Ersetzen Sie die Verwendung von cdist(XA, XB, 'sokalmichener') durch cdist(XA, XB, 'rogerstanimoto').
Y = cdist(XA, XB, 'sokalsneath')

Berechnet die Sokal-Sneath-Distanz zwischen den Vektoren. (siehe Dokumentation der Funktion sokalsneath)
Y = cdist(XA, XB, f)

Berechnet die Distanz zwischen allen Vektorpaaren in X unter Verwendung der vom Benutzer bereitgestellten 2-stelligen Funktion f. Zum Beispiel könnte die Euklidische Distanz zwischen den Vektoren wie folgt berechnet werden:
```
dm = cdist(XA, XB, lambda u, v: np.sqrt(((u-v)**2).sum()))
```
Beachten Sie, dass Sie vermeiden sollten, eine Referenz auf eine der in dieser Bibliothek definierten Distanzfunktionen zu übergeben. Zum Beispiel:
```
dm = cdist(XA, XB, sokalsneath)
```
würde die paarweisen Distanzen zwischen den Vektoren in X unter Verwendung der Python-Funktion sokalsneath berechnen. Dies würde dazu führen, dass sokalsneath \({n \choose 2}\) Mal aufgerufen wird, was ineffizient ist. Stattdessen ist die optimierte C-Version effizienter, und wir rufen sie mit der folgenden Syntax auf:
```
dm = cdist(XA, XB, 'sokalsneath')
```

Beispiele

Finden Sie die Euklidischen Distanzen zwischen vier 2D-Koordinaten

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

Finden Sie die Manhattan-Distanz von einem 3D-Punkt zu den Ecken des Einheitswürfels

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