Comparación de algoritmos de detección de anomalías

Introducción

Esta práctica compara diferentes algoritmos de detección de anomalías en conjuntos de datos bidimensionales. Los conjuntos de datos contienen una o dos modalidades (regiones de alta densidad) para ilustrar la capacidad de los algoritmos para manejar datos multimodales. Para cada conjunto de datos, el 15% de las muestras se generan como ruido uniforme aleatorio. Los límites de decisión entre valores normales y valores atípicos se muestran en negro, excepto para el Factor de Atipicidad Local (Local Outlier Factor - LOF), ya que no tiene un método de predicción que se pueda aplicar a nuevos datos cuando se utiliza para la detección de valores atípicos.

Consejos sobre la VM

Una vez que se haya iniciado la VM, haga clic en la esquina superior izquierda para cambiar a la pestaña Cuaderno y acceder a Jupyter Notebook para practicar.

A veces, es posible que tenga que esperar unos segundos a que Jupyter Notebook termine de cargarse. La validación de las operaciones no se puede automatizar debido a las limitaciones de Jupyter Notebook.

Si tiene problemas durante el aprendizaje, no dude en preguntar a Labby. Deje su retroalimentación después de la sesión y resolveremos rápidamente el problema para usted.

Skills Graph

Importar las bibliotecas necesarias

Importa las bibliotecas necesarias para la práctica.

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

Establecer parámetros

Establece los parámetros necesarios para la práctica.

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

Definir algoritmos de detección de anomalías

Define los algoritmos de detección de anomalías que se van a comparar.

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),
    ),
]

Definir conjuntos de datos

Define los conjuntos de datos para la práctica.

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),
]

Comparar clasificadores

Compara los clasificadores dados en los ajustes dados.

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):
    ## Añadir valores atípicos
    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)

        ## Ajustar los datos y etiquetar valores atípicos
        if name == "Local Outlier Factor":
            y_pred = algorithm.fit_predict(X)
        else:
            y_pred = algorithm.fit(X).predict(X)

        ## Graficar las líneas de nivel y los puntos
        if name!= "Local Outlier Factor":  ## LOF no implementa 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()

Resumen

Esta práctica comparó diferentes algoritmos de detección de anomalías en conjuntos de datos bidimensionales. Los conjuntos de datos contenían una o dos modalidades (regiones de alta densidad) para ilustrar la capacidad de los algoritmos para lidiar con datos multimodales. Los límites de decisión entre valores normales e atípicos se mostraron en negro, excepto para Local Outlier Factor (LOF), ya que no tenía un método de predicción que se pudiera aplicar a nuevos datos cuando se utilizaba para la detección de valores atípicos. Se encontró que :class:~sklearn.svm.OneClassSVM era sensible a los valores atípicos y, por lo tanto, no funcionó muy bien para la detección de valores atípicos. :class:sklearn.linear_model.SGDOneClassSVM era una implementación de One-Class SVM basada en el descenso del gradiente estocástico (SGD). :class:sklearn.covariance.EllipticEnvelope asumía que los datos eran gaussianos y aprendía una elipse, y :class:~sklearn.ensemble.IsolationForest y :class:~sklearn.neighbors.LocalOutlierFactor parecieron funcionar razonablemente bien para conjuntos de datos multimodales.