Anomalieerkennung mit Isolation Forest

Einführung

In diesem Lab werden wir den Prozess des Einsatzes von Isolation Forest zur Anomalieerkennung durchgehen. Wir beginnen mit der Erzeugung eines Datensatzes mit zwei Clustern und einigen Ausreißern, trainieren dann ein Isolation Forest-Modell, um die Ausreißer zu identifizieren. Schließlich werden wir die Entscheidungsgrenze des Modells visualisieren, um zu sehen, wie es die Inneren und die Ausreißer trennt.

Tipps für die VM

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 nutzen.

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

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

Datenerzeugung

Wir werden einen Datensatz mit zwei Clustern und einigen Ausreißern erzeugen. Die Cluster werden durch Zufallsstichproben aus der Standardnormalverteilung generiert. Einer von ihnen wird sphärisch sein, und der andere wird leicht deformiert sein. Die Ausreißer werden durch Zufallsstichproben aus einer Gleichverteilung generiert.

import numpy as np
from sklearn.model_selection import train_test_split

n_samples, n_outliers = 120, 40
rng = np.random.RandomState(0)
covariance = np.array([[0.5, -0.1], [0.7, 0.4]])
cluster_1 = 0.4 * rng.randn(n_samples, 2) @ covariance + np.array([2, 2])  ## allgemein
cluster_2 = 0.3 * rng.randn(n_samples, 2) + np.array([-2, -2])  ## sphärisch
outliers = rng.uniform(low=-4, high=4, size=(n_outliers, 2))

X = np.concatenate([cluster_1, cluster_2, outliers])
y = np.concatenate(
    [np.ones((2 * n_samples), dtype=int), -np.ones((n_outliers), dtype=int)]
)

X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, random_state=42)

Visualisiere den Datensatz

Wir können die resultierenden Cluster visualisieren, um zu sehen, wie der Datensatz aussieht.

import matplotlib.pyplot as plt

scatter = plt.scatter(X[:, 0], X[:, 1], c=y, s=20, edgecolor="k")
handles, labels = scatter.legend_elements()
plt.axis("square")
plt.legend(handles=handles, labels=["Ausreißer", "Innerpunkte"], title="wahre Klasse")
plt.title("Gaußsche Innerpunkte mit \ngleichmäßig verteilten Ausreißern")
plt.show()

Trainiere das Modell

Wir werden ein Isolation Forest-Modell mit den Trainingsdaten trainieren.

from sklearn.ensemble import IsolationForest

clf = IsolationForest(max_samples=100, random_state=0)
clf.fit(X_train)

Zeichne die diskrete Entscheidungsgrenze

Wir werden die Klasse DecisionBoundaryDisplay verwenden, um eine diskrete Entscheidungsgrenze zu visualisieren. Die Hintergrundfarbe gibt an, ob eine Probe in einem bestimmten Bereich als Ausreißer vorhergesagt wird oder nicht. Der Streudiagramm zeigt die wahren Labels an.

import matplotlib.pyplot as plt
from sklearn.inspection import DecisionBoundaryDisplay

disp = DecisionBoundaryDisplay.from_estimator(
    clf,
    X,
    response_method="predict",
    alpha=0.5,
)
disp.ax_.scatter(X[:, 0], X[:, 1], c=y, s=20, edgecolor="k")
disp.ax_.set_title("Binäre Entscheidungsgrenze \nvon IsolationForest")
plt.axis("square")
plt.legend(handles=handles, labels=["Ausreißer", "Innerpunkte"], title="wahre Klasse")
plt.show()

Zeichne die Entscheidungsgrenze basierend auf der Pfadlänge

Durch Festlegung von response_method="decision_function" repräsentiert der Hintergrund der DecisionBoundaryDisplay die Normalitätsmessung einer Beobachtung. Ein solcher Score wird durch die über einen Wald von zufälligen Bäumen gemittelte Pfadlänge gegeben, die selbst durch die Tiefe des Blattes (oder gleichwertig die Anzahl der Aufteilungen) angegeben wird, die erforderlich ist, um eine gegebene Probe zu isolieren.

disp = DecisionBoundaryDisplay.from_estimator(
    clf,
    X,
    response_method="decision_function",
    alpha=0.5,
)
disp.ax_.scatter(X[:, 0], X[:, 1], c=y, s=20, edgecolor="k")
disp.ax_.set_title("Entscheidungsgrenze basierend auf der Pfadlänge \nvon IsolationForest")
plt.axis("square")
plt.legend(handles=handles, labels=["Ausreißer", "Innerpunkte"], title="wahre Klasse")
plt.colorbar(disp.ax_.collections[1])
plt.show()

Zusammenfassung

In diesem Lab haben wir gelernt, wie man Isolation Forest für die Anomalieerkennung verwendet. Wir haben einen Datensatz mit zwei Clustern und einigen Ausreißern erzeugt, ein Isolation Forest-Modell trainiert, um die Ausreißer zu identifizieren, und die Entscheidungsgrenze des Modells visualisiert, um zu sehen, wie es die Innerpunkte und Ausreißer trennt.