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.