Local Outlier Factor für die Neuheitserkennung

Machine LearningMachine LearningBeginner
Jetzt üben

This tutorial is from open-source community. Access the source code

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einführung

In diesem Lab werden wir den Local Outlier Factor (LOF)-Algorithmus verwenden, um Neuheitserkennung durchzuführen. LOF ist eine unüberwachte Methode zur Ausreißererkennung, die die lokale Dichtabweichung eines gegebenen Datenpunkts im Vergleich zu seinen Nachbarn identifiziert. Sie betrachtet die Stichproben, die eine wesentlich geringere Dichte als ihre Nachbarn haben, als Ausreißer.

Tipps für die virtuelle Maschine (VM)

Nachdem die VM gestartet wurde, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und auf Jupyter Notebook für die Übung zuzugreifen.

Manchmal müssen Sie möglicherweise einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Aufgrund von Einschränkungen in Jupyter Notebook kann die Validierung von Vorgängen nicht automatisiert werden.

Wenn Sie während des Lernens Probleme haben, können Sie sich gerne an Labby wenden. Geben Sie uns nach der Sitzung Feedback, und wir werden das Problem umgehend für Sie lösen.

Bibliotheken importieren

Wir beginnen mit dem Importieren der erforderlichen Bibliotheken. Wir werden scikit-learn, numpy und matplotlib verwenden.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.neighbors import LocalOutlierFactor

Daten generieren

Wir werden einige Daten für das Training, das Testen und die Ausreißer mit numpy generieren. Wir werden 100 normale Trainingsbeobachtungen, 20 normale Testbeobachtungen und 20 abnormale, neuartige Beobachtungen generieren.

np.random.seed(42)

xx, yy = np.meshgrid(np.linspace(-5, 5, 500), np.linspace(-5, 5, 500))
X = 0.3 * np.random.randn(100, 2)
X_train = np.r_[X + 2, X - 2]
X = 0.3 * np.random.randn(20, 2)
X_test = np.r_[X + 2, X - 2]
X_outliers = np.random.uniform(low=-4, high=4, size=(20, 2))

Das Modell trainieren

Wir werden jetzt das LOF-Modell mit den Trainingsdaten trainieren. Wir setzen die Anzahl der Nachbarn auf 20 und die Neuheit (novelty) auf true. Wir setzen auch die Kontamination (contamination) auf 0,1.

clf = LocalOutlierFactor(n_neighbors=20, novelty=True, contamination=0.1)
clf.fit(X_train)

Das Modell auswerten

Wir werden das trainierte Modell anhand der Test- und Ausreißer-Daten auswerten. Wir verwenden die predict-Methode, um die Labels der Test- und Ausreißer-Daten vorherzusagen. Anschließend zählen wir die Anzahl der Fehler in den Test- und Ausreißer-Daten.

y_pred_test = clf.predict(X_test)
y_pred_outliers = clf.predict(X_outliers)
n_error_test = y_pred_test[y_pred_test == -1].size
n_error_outliers = y_pred_outliers[y_pred_outliers == 1].size

Die Ergebnisse visualisieren

Wir werden die Ergebnisse visualisieren, indem wir die Trainings-, Test- und Ausreißer-Daten zusammen mit der gelernten Grenze (frontier) plotten. Wir werden auch die Anzahl der Fehler in den Test- und Ausreißer-Daten anzeigen.

Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

plt.title("Novelty Detection with LOF")
plt.contourf(xx, yy, Z, levels=np.linspace(Z.min(), 0, 7), cmap=plt.cm.PuBu)
a = plt.contour(xx, yy, Z, levels=[0], linewidths=2, colors="darkred")
plt.contourf(xx, yy, Z, levels=[0, Z.max()], colors="palevioletred")

s = 40
b1 = plt.scatter(X_train[:, 0], X_train[:, 1], c="white", s=s, edgecolors="k")
b2 = plt.scatter(X_test[:, 0], X_test[:, 1], c="blueviolet", s=s, edgecolors="k")
c = plt.scatter(X_outliers[:, 0], X_outliers[:, 1], c="gold", s=s, edgecolors="k")
plt.axis("tight")
plt.xlim((-5, 5))
plt.ylim((-5, 5))
plt.legend(
    [a.collections[0], b1, b2, c],
    [
        "learned frontier",
        "training observations",
        "new regular observations",
        "new abnormal observations",
    ],
    loc="upper left",
    prop=matplotlib.font_manager.FontProperties(size=11),
)
plt.xlabel(
    "errors novel regular: %d/40 ; errors novel abnormal: %d/40"
    % (n_error_test, n_error_outliers)
)
plt.show()

Zusammenfassung

In diesem Lab haben wir den Local Outlier Factor (LOF)-Algorithmus verwendet, um eine Neuheitserkennung (novelty detection) durchzuführen. Wir haben Daten für das Training, das Testen und die Ausreißer generiert, das LOF-Modell trainiert, das Modell ausgewertet und die Ergebnisse visualisiert.