Vergleich von Anomalieerkennungsalgorithmen

Einführung

In diesem Lab werden verschiedene Anomalieerkennungsalgorithmen auf zweidimensionalen Datensätzen verglichen. Die Datensätze enthalten eine oder zwei Modi (Regionen mit hoher Dichte), um die Fähigkeit der Algorithmen zur Bewältigung multimodaler Daten zu illustrieren. Für jeden Datensatz werden 15% der Proben als zufälliger gleichmäßiger Rausch erzeugt. Die Entscheidungsgrenzen zwischen Inlinern und Outlinern werden in Schwarz angezeigt, ausgenommen für den Local Outlier Factor (LOF), da er keine Vorhersagemethode hat, die auf neue Daten angewendet werden kann, wenn er zur Anomalieerkennung verwendet wird.

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 ö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 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 ab, und wir werden das Problem für Sie prompt beheben.

Skills Graph

Importieren der erforderlichen Bibliotheken

Importieren Sie die erforderlichen Bibliotheken für das Lab.

import time

import numpy as np
import matplotlib
import matplotlib.pyplot as plt

from sklearn import svm
from sklearn.datasets import make_moons, make_blobs
from sklearn.covariance import EllipticEnvelope
from sklearn.ensemble import IsolationForest
from sklearn.neighbors import LocalOutlierFactor
from sklearn.linear_model import SGDOneClassSVM
from sklearn.kernel_approximation import Nystroem
from sklearn.pipeline import make_pipeline

Parameter festlegen

Legen Sie die erforderlichen Parameter für das Lab fest.

n_samples = 300
outliers_fraction = 0.15
n_outliers = int(outliers_fraction * n_samples)
n_inliers = n_samples - n_outliers

Definieren von Anomalieerkennungsalgorithmen

Definieren Sie die Anomalieerkennungsalgorithmen, die verglichen werden sollen.

anomaly_algorithms = [
    (
        "Robust covariance",
        EllipticEnvelope(contamination=outliers_fraction, random_state=42),
    ),
    ("One-Class SVM", svm.OneClassSVM(nu=outliers_fraction, kernel="rbf", gamma=0.1)),
    (
        "One-Class SVM (SGD)",
        make_pipeline(
            Nystroem(gamma=0.1, random_state=42, n_components=150),
            SGDOneClassSVM(
                nu=outliers_fraction,
                shuffle=True,
                fit_intercept=True,
                random_state=42,
                tol=1e-6,
            ),
        ),
    ),
    (
        "Isolation Forest",
        IsolationForest(contamination=outliers_fraction, random_state=42),
    ),
    (
        "Local Outlier Factor",
        LocalOutlierFactor(n_neighbors=35, contamination=outliers_fraction),
    ),
]

Definieren von Datensätzen

Definieren Sie die Datensätze für das Lab.

blobs_params = dict(random_state=0, n_samples=n_inliers, n_features=2)
datasets = [
    make_blobs(centers=[[0, 0], [0, 0]], cluster_std=0.5, **blobs_params)[0],
    make_blobs(centers=[[2, 2], [-2, -2]], cluster_std=[0.5, 0.5], **blobs_params)[0],
    make_blobs(centers=[[2, 2], [-2, -2]], cluster_std=[1.5, 0.3], **blobs_params)[0],
    4.0
    * (
        make_moons(n_samples=n_samples, noise=0.05, random_state=0)[0]
        - np.array([0.5, 0.25])
    ),
    14.0 * (np.random.RandomState(42).rand(n_samples, 2) - 0.5),
]

Vergleichen von Klassifizierern

Vergleichen Sie die angegebenen Klassifizierer unter den angegebenen Einstellungen.

xx, yy = np.meshgrid(np.linspace(-7, 7, 150), np.linspace(-7, 7, 150))

plt.figure(figsize=(len(anomaly_algorithms) * 2 + 4, 12.5))
plt.subplots_adjust(
    left=0.02, right=0.98, bottom=0.001, top=0.96, wspace=0.05, hspace=0.01
)

plot_num = 1
rng = np.random.RandomState(42)

for i_dataset, X in enumerate(datasets):
    ## Add outliers
    X = np.concatenate([X, rng.uniform(low=-6, high=6, size=(n_outliers, 2))], axis=0)

    for name, algorithm in anomaly_algorithms:
        t0 = time.time()
        algorithm.fit(X)
        t1 = time.time()
        plt.subplot(len(datasets), len(anomaly_algorithms), plot_num)
        if i_dataset == 0:
            plt.title(name, size=18)

        ## fit the data and tag outliers
        if name == "Local Outlier Factor":
            y_pred = algorithm.fit_predict(X)
        else:
            y_pred = algorithm.fit(X).predict(X)

        ## plot the levels lines and the points
        if name!= "Local Outlier Factor":  ## LOF does not implement predict
            Z = algorithm.predict(np.c_[xx.ravel(), yy.ravel()])
            Z = Z.reshape(xx.shape)
            plt.contour(xx, yy, Z, levels=[0], linewidths=2, colors="black")

        colors = np.array(["#377eb8", "#ff7f00"])
        plt.scatter(X[:, 0], X[:, 1], s=10, color=colors[(y_pred + 1) // 2])

        plt.xlim(-7, 7)
        plt.ylim(-7, 7)
        plt.xticks(())
        plt.yticks(())
        plt.text(
            0.99,
            0.01,
            ("%.2fs" % (t1 - t0)).lstrip("0"),
            transform=plt.gca().transAxes,
            size=15,
            horizontalalignment="right",
        )
        plot_num += 1

plt.show()

Zusammenfassung

In diesem Lab wurden verschiedene Anomalieerkennungsalgorithmen auf zweidimensionalen Datensätzen verglichen. Die Datensätze enthielten eine oder zwei Modi (Regionen mit hoher Dichte), um die Fähigkeit der Algorithmen zur Bewältigung von multimodalen Daten zu illustrieren. Die Entscheidunggrenzen zwischen Inlier und Outlier wurden in Schwarz dargestellt, ausgenommen für den Local Outlier Factor (LOF), da er keine Predict-Methode hatte, die auf neue Daten angewendet werden konnte, wenn er zur Anomalieerkennung verwendet wurde. Es stellte sich heraus, dass die :class:~sklearn.svm.OneClassSVM empfindlich gegenüber Ausreißern war und daher für die Anomalieerkennung nicht sehr gut performierte. Die :class:sklearn.linear_model.SGDOneClassSVM war eine Implementierung der One-Class SVM auf der Grundlage des stochastischen Gradientenabstiegs (SGD). Die :class:sklearn.covariance.EllipticEnvelope nahm an, dass die Daten normalverteilt seien, und lernte eine Ellipse, und :class:~sklearn.ensemble.IsolationForest und :class:~sklearn.neighbors.LocalOutlierFactor schienen für multimodale Datensätze ziemlich gut zu funktionieren.