7.8. Paarweise Metriken, Affinitäten und Kerne#

Das Untermodul sklearn.metrics.pairwise implementiert Hilfsprogramme zur Bewertung paarweiser Distanzen oder Affinitäten von Stichprobensätzen.

Dieses Modul enthält sowohl Distanzmetriken als auch Kerne. Hier wird eine kurze Zusammenfassung zu beiden gegeben.

Distanzmetriken sind Funktionen d(a, b), so dass d(a, b) < d(a, c) gilt, wenn die Objekte a und b als „ähnlicher“ als die Objekte a und c betrachtet werden. Zwei exakt gleiche Objekte hätten eine Distanz von Null. Eines der beliebtesten Beispiele ist die Euklidische Distanz. Um eine „echte“ Metrik zu sein, muss sie die folgenden vier Bedingungen erfüllen

1. d(a, b) >= 0, for all a and b
2. d(a, b) == 0, if and only if a = b, positive definiteness
3. d(a, b) == d(b, a), symmetry
4. d(a, c) <= d(a, b) + d(b, c), the triangle inequality

Kerne sind Ähnlichkeitsmaße, d.h. s(a, b) > s(a, c) gilt, wenn die Objekte a und b als „ähnlicher“ als die Objekte a und c betrachtet werden. Ein Kern muss auch positiv semidefinit sein.

Es gibt eine Reihe von Möglichkeiten, zwischen einer Distanzmetrik und einem Ähnlichkeitsmaß, wie z.B. einem Kern, umzuwandeln. Sei D die Distanz und S der Kern

  1. S = np.exp(-D * gamma), wobei eine Heuristik zur Wahl von

    gamma lautet 1 / num_features

  2. S = 1. / (D / np.max(D))

Die Distanzen zwischen den Zeilenvektoren von X und den Zeilenvektoren von Y können mit pairwise_distances ausgewertet werden. Wenn Y weggelassen wird, werden die paarweisen Distanzen der Zeilenvektoren von X berechnet. Ähnlich kann pairwise.pairwise_kernels verwendet werden, um den Kern zwischen X und Y mit verschiedenen Kernelfunktionen zu berechnen. Weitere Details finden Sie in der API-Referenz.

>>> import numpy as np
>>> from sklearn.metrics import pairwise_distances
>>> from sklearn.metrics.pairwise import pairwise_kernels
>>> X = np.array([[2, 3], [3, 5], [5, 8]])
>>> Y = np.array([[1, 0], [2, 1]])
>>> pairwise_distances(X, Y, metric='manhattan')
array([[ 4.,  2.],
       [ 7.,  5.],
       [12., 10.]])
>>> pairwise_distances(X, metric='manhattan')
array([[0., 3., 8.],
       [3., 0., 5.],
       [8., 5., 0.]])
>>> pairwise_kernels(X, Y, metric='linear')
array([[ 2.,  7.],
       [ 3., 11.],
       [ 5., 18.]])

7.8.1. Kosinus-Ähnlichkeit#

cosine_similarity berechnet das L2-normierte Skalarprodukt von Vektoren. Das heißt, wenn \(x\) und \(y\) Zeilenvektoren sind, ist ihre Kosinus-Ähnlichkeit \(k\) definiert als

\[k(x, y) = \frac{x y^\top}{\|x\| \|y\|}\]

Dies wird Kosinus-Ähnlichkeit genannt, da die Euklidische (L2) Normalisierung die Vektoren auf die Einheitskugel projiziert und ihr Skalarprodukt dann der Kosinus des Winkels zwischen den durch die Vektoren dargestellten Punkten ist.

Dieser Kern ist eine beliebte Wahl für die Berechnung der Ähnlichkeit von Dokumenten, die als tf-idf-Vektoren dargestellt werden. cosine_similarity akzeptiert scipy.sparse Matrizen. (Beachten Sie, dass die tf-idf-Funktionalität in sklearn.feature_extraction.text normalisierte Vektoren erzeugen kann, in welchem Fall cosine_similarity äquivalent zu linear_kernel ist, nur langsamer.)

Referenzen

7.8.2. Linearer Kern#

Die Funktion linear_kernel berechnet den linearen Kern, d.h. einen Spezialfall von polynomial_kernel mit degree=1 und coef0=0 (homogen). Wenn x und y Spaltenvektoren sind, ist ihr linearer Kern

\[k(x, y) = x^\top y\]

7.8.3. Polynomialer Kern#

Die Funktion polynomial_kernel berechnet den Polynomkern vom Grad d zwischen zwei Vektoren. Der Polynomkern repräsentiert die Ähnlichkeit zwischen zwei Vektoren. Konzeptionell betrachtet der Polynomkern nicht nur die Ähnlichkeit zwischen Vektoren unter derselben Dimension, sondern auch über die Dimensionen hinweg. Bei der Verwendung in maschinellen Lernalgorithmen ermöglicht dies die Berücksichtigung von Feature-Interaktionen.

Der Polynomkern ist definiert als

\[k(x, y) = (\gamma x^\top y +c_0)^d\]

wobei

  • x, y sind die Eingangsvektoren

  • d ist der Kerngrad

Wenn \(c_0 = 0\), wird der Kern als homogen bezeichnet.

7.8.4. Sigmoid-Kern#

Die Funktion sigmoid_kernel berechnet den Sigmoid-Kern zwischen zwei Vektoren. Der Sigmoid-Kern ist auch als hyperbolischer Tangens oder Multilayer Perceptron bekannt (da er im Bereich der neuronalen Netze oft als Aktivierungsfunktion eines Neurons verwendet wird). Er ist definiert als

\[k(x, y) = \tanh( \gamma x^\top y + c_0)\]

wobei

  • x, y sind die Eingangsvektoren

  • \(\gamma\) ist als Steigung bekannt

  • \(c_0\) ist als Achsenabschnitt bekannt

7.8.5. RBF-Kern#

Die Funktion rbf_kernel berechnet den Radialbasis-Funktions (RBF) Kern zwischen zwei Vektoren. Dieser Kern ist definiert als

\[k(x, y) = \exp( -\gamma \| x-y \|^2)\]

wobei x und y die Eingangsvektoren sind. Wenn \(\gamma = \sigma^{-2}\), ist der Kern als Gaußscher Kern mit einer Varianz von \(\sigma^2\) bekannt.

7.8.6. Laplace-Kern#

Die Funktion laplacian_kernel ist eine Variante des Radialbasis-Funktions-Kerns, definiert als

\[k(x, y) = \exp( -\gamma \| x-y \|_1)\]

wobei x und y die Eingangsvektoren sind und \(\|x-y\|_1\) die Manhattan-Distanz zwischen den Eingangsvektoren ist.

Es hat sich als nützlich in der ML bei der Anwendung auf verrauschte Daten erwiesen. Siehe z.B. Machine learning for quantum mechanics in a nutshell.

7.8.7. Chi-Quadrat-Kern#

Der Chi-Quadrat-Kern ist eine sehr beliebte Wahl für das Training von nichtlinearen SVMs in Computer-Vision-Anwendungen. Er kann mit chi2_kernel berechnet und dann an eine SVC mit kernel="precomputed" übergeben werden

>>> from sklearn.svm import SVC
>>> from sklearn.metrics.pairwise import chi2_kernel
>>> X = [[0, 1], [1, 0], [.2, .8], [.7, .3]]
>>> y = [0, 1, 0, 1]
>>> K = chi2_kernel(X, gamma=.5)
>>> K
array([[1.        , 0.36787944, 0.89483932, 0.58364548],
       [0.36787944, 1.        , 0.51341712, 0.83822343],
       [0.89483932, 0.51341712, 1.        , 0.7768366 ],
       [0.58364548, 0.83822343, 0.7768366 , 1.        ]])

>>> svm = SVC(kernel='precomputed').fit(K, y)
>>> svm.predict(K)
array([0, 1, 0, 1])

Er kann auch direkt als Argument für kernel verwendet werden

>>> svm = SVC(kernel=chi2_kernel).fit(X, y)
>>> svm.predict(X)
array([0, 1, 0, 1])

Der Chi-Quadrat-Kern ist gegeben durch

\[k(x, y) = \exp \left (-\gamma \sum_i \frac{(x[i] - y[i]) ^ 2}{x[i] + y[i]} \right )\]

Die Daten werden als nicht-negativ angenommen und oft so normalisiert, dass sie eine L1-Norm von eins haben. Die Normalisierung wird durch die Verbindung zur Chi-Quadrat-Distanz begründet, die eine Distanz zwischen diskreten Wahrscheinlichkeitsverteilungen ist.

Der Chi-Quadrat-Kern wird am häufigsten auf Histogrammen (Bags) von visuellen Wörtern verwendet.

Referenzen