Comparação de Algoritmos de Detecção de Anomalias

Introdução

Este laboratório compara diferentes algoritmos de detecção de anomalias em conjuntos de dados bidimensionais. Os conjuntos de dados contêm um ou dois modos (regiões de alta densidade) para ilustrar a capacidade dos algoritmos de lidar com dados multimodais. Para cada conjunto de dados, 15% das amostras são geradas como ruído uniforme aleatório. Os limites de decisão entre dados inliers e outliers são exibidos em preto, exceto para o Local Outlier Factor (LOF), pois ele não possui um método predict para ser aplicado em novos dados quando usado para detecção de outliers.

Dicas da Máquina Virtual

Após o arranque da máquina virtual, clique no canto superior esquerdo para mudar para a aba Notebook para aceder ao Jupyter Notebook para prática.

Às vezes, pode ser necessário esperar alguns segundos para que o Jupyter Notebook termine de carregar. A validação das operações não pode ser automatizada devido a limitações no Jupyter Notebook.

Se tiver problemas durante a aprendizagem, não hesite em contactar o Labby. Forneça feedback após a sessão e resolveremos prontamente o problema para si.

Importação de Bibliotecas Necessárias

Importe as bibliotecas necessárias para o laboratório.

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

Definição de Parâmetros

Defina os parâmetros necessários para o laboratório.

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

Definir Algoritmos de Detecção de Anomalias

Defina os algoritmos de detecção de anomalias a serem comparados.

anomaly_algorithms = [
    (
        "Covariância Robusta",
        EllipticEnvelope(contamination=outliers_fraction, random_state=42),
    ),
    ("SVM de Uma Classe", svm.OneClassSVM(nu=outliers_fraction, kernel="rbf", gamma=0.1)),
    (
        "SVM de Uma Classe (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,
            ),
        ),
    ),
    (
        "Floresta de Isolamento",
        IsolationForest(contamination=outliers_fraction, random_state=42),
    ),
    (
        "Fator Local de Desvio",
        LocalOutlierFactor(n_neighbors=35, contamination=outliers_fraction),
    ),
]

Definir Conjuntos de Dados

Defina os conjuntos de dados para o laboratório.

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 Classificadores

Compare os classificadores fornecidos nas configurações especificadas.

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):
    ## Adicionar 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)

        ## Ajustar os dados e marcar outliers
        if name == "Local Outlier Factor":
            y_pred = algorithm.fit_predict(X)
        else:
            y_pred = algorithm.fit(X).predict(X)

        ## plotar as linhas de nível e os pontos
        if name != "Local Outlier Factor":  ## LOF não 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()

Resumo

Este laboratório comparou diferentes algoritmos de detecção de anomalias em conjuntos de dados bidimensionais. Os conjuntos de dados continham um ou dois modos (regiões de alta densidade) para ilustrar a capacidade dos algoritmos de lidar com dados multimodais. Os limites de decisão entre dados internos e outliers foram exibidos em preto, exceto para o Local Outlier Factor (LOF), pois não possuía um método predict para ser aplicado em novos dados quando usado para detecção de outliers. O :class:~sklearn.svm.OneClassSVM mostrou-se sensível a outliers e, portanto, não teve um bom desempenho na detecção de outliers. O :class:sklearn.linear_model.SGDOneClassSVM foi uma implementação do One-Class SVM baseada em descida de gradiente estocástico (SGD). O :class:sklearn.covariance.EllipticEnvelope assumiu que os dados eram gaussianos e aprendeu uma elipse, e o :class:~sklearn.ensemble.IsolationForest e o :class:~sklearn.neighbors.LocalOutlierFactor pareceram ter um bom desempenho para conjuntos de dados multimodais.