scipy.spatial.distance.

pdist#

scipy.spatial.distance.pdist(X, metric='euclidean', *, out=None, **kwargs)[Quelle]#

Paarweise Abstände zwischen Beobachtungen im n-dimensionalen Raum.

Siehe Hinweise für gängige Aufrufkonventionen.

Parameter:

Xarray_like

Eine m x n-Matrix mit m ursprünglichen Beobachtungen in einem n-dimensionalen Raum.

metricstr oder Funktion, optional

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

outndarray, optional

Das Ausgabearray. Wenn nicht None, wird die kondensierte Distanzmatrix Y in diesem Array gespeichert.

**kwargsdict, optional

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

Einige mögliche Argumente

p : scalar Die p-Norm für Minkowski-, gewichtete und ungewichtete Distanzen. Standard: 2.

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

V : ndarray Der Varianzvektor für standardisierte Euklidische Distanz. Standard: var(X, axis=0, ddof=1)

VI : ndarray Die Inverse der Kovarianzmatrix für Mahalanobis-Distanz. Standard: inv(cov(X.T)).T

Rückgabe:

Yndarray: Gibt eine kondensierte Distanzmatrix Y zurück. Für jedes \(i\) und \(j\) (wobei \(i<j<m\)), wobei m die Anzahl der ursprünglichen Beobachtungen ist. Die Metrik dist(u=X[i], v=X[j]) wird berechnet und im Eintrag m * i + j - ((i + 2) * (i + 1)) // 2 gespeichert.

Siehe auch

squareform: konvertiert zwischen kondensierten Distanzmatrizen und quadratischen Distanzmatrizen.

Hinweise

Siehe squareform für Informationen zur Berechnung des Index eines Eintrags oder zur Umwandlung der kondensierten Distanzmatrix in eine redundante quadratische Matrix.

Die folgenden sind gängige Aufrufkonventionen.

Y = pdist(X, 'euclidean')

Berechnet den Abstand 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 = pdist(X, 'minkowski', p=2.)

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

Berechnet die City-Block- oder Manhattan-Distanz zwischen den Punkten.
Y = pdist(X, '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 wurde. Wenn V nicht übergeben wird, wird es automatisch berechnet.
Y = pdist(X, 'sqeuclidean')

Berechnet die quadrierte Euklidische Distanz \(\|u-v\|_2^2\) zwischen den Vektoren.
Y = pdist(X, '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 = pdist(X, 'correlation')

Berechnet die Korrelationsdistanz zwischen den Vektoren u und v. Diese 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 = pdist(X, '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 = pdist(X, 'jaccard')

Berechnet die Jaccard-Distanz zwischen den Punkten. Gegeben zwei Vektoren, u und v, ist die Jaccard-Distanz der Anteil der Elemente u[i] und v[i], die sich unterscheiden.
Y = pdist(X, 'jensenshannon')

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

\[\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 = pdist(X, 'chebyshev')

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

\[d(u,v) = \max_i {|u_i-v_i|}\]
Y = pdist(X, '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 = pdist(X, '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 = pdist(X, '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 = pdist(X, 'yule')

Berechnet die Yule-Distanz zwischen jedem Paar von booleschen Vektoren. (siehe Dokumentation der Funktion yule)
Y = pdist(X, 'matching')

Synonym für ‘hamming’.
Y = pdist(X, 'dice')

Berechnet die Dice-Distanz zwischen jedem Paar von booleschen Vektoren. (siehe Dokumentation der Funktion dice)
Y = pdist(X, 'kulczynski1')

Berechnet die Kulczynski1-Distanz zwischen jedem Paar von 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 pdist(X, 'kulczynski1') durch 1 / pdist(X, 'jaccard') - 1.
Y = pdist(X, 'rogerstanimoto')

Berechnet die Rogers-Tanimoto-Distanz zwischen jedem Paar von booleschen Vektoren. (siehe Dokumentation der Funktion rogerstanimoto)
Y = pdist(X, 'russellrao')

Berechnet die Russell-Rao-Distanz zwischen jedem Paar von booleschen Vektoren. (siehe Dokumentation der Funktion russellrao)
Y = pdist(X, 'sokalmichener')

Berechnet die Sokal-Michener-Distanz zwischen jedem Paar von 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 pdist(X, 'sokalmichener') durch pdist(X, 'rogerstanimoto').
Y = pdist(X, 'sokalsneath')

Berechnet die Sokal-Sneath-Distanz zwischen jedem Paar von booleschen Vektoren. (siehe Dokumentation der Funktion sokalsneath)
Y = pdist(X, 'kulczynski1')

Berechnet die Kulczynski 1-Distanz zwischen jedem Paar von booleschen Vektoren. (siehe Dokumentation der Funktion kulczynski1)
Y = pdist(X, f)

Berechnet den Abstand zwischen allen Paaren von Vektoren in X unter Verwendung der benutzerdefinierten 2-stelligen Funktion f. Zum Beispiel könnte die Euklidische Distanz zwischen den Vektoren wie folgt berechnet werden:
```
dm = pdist(X, 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 = pdist(X, sokalsneath)
```
würde die paarweisen Abstände 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 = pdist(X, 'sokalsneath')
```

Beispiele

>>> import numpy as np
>>> from scipy.spatial.distance import pdist

x ist ein Array von fünf Punkten im dreidimensionalen Raum.

>>> x = np.array([[2, 0, 2], [2, 2, 3], [-2, 4, 5], [0, 1, 9], [2, 2, 4]])

pdist(x) ohne zusätzliche Argumente berechnet die 10 paarweisen Euklidischen Abstände

>>> pdist(x)
array([2.23606798, 6.40312424, 7.34846923, 2.82842712, 4.89897949,
       6.40312424, 1.        , 5.38516481, 4.58257569, 5.47722558])

Die folgende Zeile berechnet die paarweisen Minkowski-Distanzen mit p = 3.5

>>> pdist(x, metric='minkowski', p=3.5)
array([2.04898923, 5.1154929 , 7.02700737, 2.43802731, 4.19042714,
       6.03956994, 1.        , 4.45128103, 4.10636143, 5.0619695 ])

Die paarweisen City-Block- oder Manhattan-Distanzen

>>> pdist(x, metric='cityblock')
array([ 3., 11., 10.,  4.,  8.,  9.,  1.,  9.,  7.,  8.])