Neighborhood Components Analysis

Einführung

Dieses Labor zielt darauf ab, die Verwendung der Neighborhood Components Analysis (NCA) beim Lernen einer Distanzmetrik zu demonstrieren, die die Genauigkeit der Nachbarklassifikation maximiert. Es bietet eine visuelle Darstellung dieser Metrik im Vergleich zum ursprünglichen Punktraum.

VM-Tipps

Nachdem der VM-Start abgeschlossen ist, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu öffnen.

Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund der Einschränkungen von Jupyter Notebook nicht automatisiert werden.

Wenn Sie bei der Lernphase Probleme haben, können Sie Labby um Hilfe bitten. Geben Sie nach der Sitzung Feedback ab, und wir werden das Problem für Sie prompt beheben.

Datenpunkte generieren

Wir beginnen mit der Erzeugung eines Datensatzes von 9 Proben aus 3 Klassen und zeichnen die Punkte im ursprünglichen Raum. Für dieses Beispiel konzentrieren wir uns auf die Klassifizierung des Punktes Nr. 3.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.neighbors import NeighborhoodComponentsAnalysis
from matplotlib import cm
from scipy.special import logsumexp

X, y = make_classification(
    n_samples=9,
    n_features=2,
    n_informative=2,
    n_redundant=0,
    n_classes=3,
    n_clusters_per_class=1,
    class_sep=1.0,
    random_state=0,
)

plt.figure(1)
ax = plt.gca()
for i in range(X.shape[0]):
    ax.text(X[i, 0], X[i, 1], str(i), va="center", ha="center")
    ax.scatter(X[i, 0], X[i, 1], s=300, c=cm.Set1(y[[i]]), alpha=0.4)

ax.set_title("Originalpunkte")
ax.axes.get_xaxis().set_visible(False)
ax.axes.get_yaxis().set_visible(False)
ax.axis("equal")  ## damit die Grenzen als Kreise richtig angezeigt werden

Nachbarn visualisieren

Wir visualisieren nun die Verbindungen zwischen den Datenpunkten, wobei die Dicke der Verbindung zwischen Punkt Nr. 3 und einem anderen Punkt proportional zu ihrer Entfernung ist.

def link_thickness_i(X, i):
    diff_embedded = X[i] - X
    dist_embedded = np.einsum("ij,ij->i", diff_embedded, diff_embedded)
    dist_embedded[i] = np.inf

    ## berechne exponentiierte Entfernungen (verwende die log-sum-exp-Methode,
    ## um numerische Instabilitäten zu vermeiden)
    exp_dist_embedded = np.exp(-dist_embedded - logsumexp(-dist_embedded))
    return exp_dist_embedded


def relate_point(X, i, ax):
    pt_i = X[i]
    for j, pt_j in enumerate(X):
        thickness = link_thickness_i(X, i)
        if i!= j:
            line = ([pt_i[0], pt_j[0]], [pt_i[1], pt_j[1]])
            ax.plot(*line, c=cm.Set1(y[j]), linewidth=5 * thickness[j])


i = 3
relate_point(X, i, ax)
plt.show()

Ein Embedding lernen

Wir verwenden nun die NCA, um ein Embedding zu lernen und die Punkte nach der Transformation zu zeichnen. Wir nehmen dann das Embedding und finden die nächsten Nachbarn.

nca = NeighborhoodComponentsAnalysis(max_iter=30, random_state=0)
nca = nca.fit(X, y)

plt.figure(2)
ax2 = plt.gca()
X_embedded = nca.transform(X)
relate_point(X_embedded, i, ax2)

for i in range(len(X)):
    ax2.text(X_embedded[i, 0], X_embedded[i, 1], str(i), va="center", ha="center")
    ax2.scatter(X_embedded[i, 0], X_embedded[i, 1], s=300, c=cm.Set1(y[[i]]), alpha=0.4)

ax2.set_title("NCA-Embedding")
ax2.axes.get_xaxis().set_visible(False)
ax2.axes.get_yaxis().set_visible(False)
ax2.axis("equal")
plt.show()

Zusammenfassung

In diesem Labor haben wir gezeigt, wie man die NCA verwendet, um eine Distanzmetrik zu lernen, die die Genauigkeit der Nachbarklassifikation maximiert. Wir haben die Verbindungen zwischen den Datenpunkten visualisiert und den ursprünglichen Punktraum mit dem transformierten Raum verglichen.