Introduction
Ce laboratoire compare différents algorithmes de détection d'anomalies sur des jeux de données bidimensionnels. Les jeux de données contiennent une ou deux modes (régions de forte densité) pour illustrer la capacité des algorithmes à gérer les données multimodales. Pour chaque jeu de données, 15 % des échantillons sont générés comme bruit uniforme aléatoire. Les limites de décision entre les données valides et les anomalies sont affichées en noir, sauf pour le Local Outlier Factor (LOF) car il n'a pas de méthode de prédiction à appliquer sur de nouvelles données lorsqu'il est utilisé pour la détection d'anomalies.
Conseils sur la machine virtuelle
Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Carnet de notes pour accéder à Jupyter Notebook pour la pratique.
Parfois, vous devrez peut-être attendre quelques secondes pour que Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations de Jupyter Notebook.
Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez des commentaires après la session, et nous résoudrons rapidement le problème pour vous.
Importez les bibliothèques requises
Importez les bibliothèques nécessaires pour le laboratoire.
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
Définissez les paramètres
Définissez les paramètres requis pour le laboratoire.
n_samples = 300
outliers_fraction = 0.15
n_outliers = int(outliers_fraction * n_samples)
n_inliers = n_samples - n_outliers
Définissez les algorithmes de détection d'anomalies
Définissez les algorithmes de détection d'anomalies à comparer.
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),
),
]
Définissez les jeux de données
Définissez les jeux de données pour le laboratoire.
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),
]
Comparez les classifieurs
Comparez les classifieurs donnés dans les paramètres donnés.
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):
## Ajoutez des anomalies
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)
## Ajustez les données et marquez les anomalies
if name == "Local Outlier Factor":
y_pred = algorithm.fit_predict(X)
else:
y_pred = algorithm.fit(X).predict(X)
## Tracez les lignes de niveau et les points
if name!= "Local Outlier Factor": ## LOF n'implémente pas 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()
Sommaire
Ce laboratoire a comparé différents algorithmes de détection d'anomalies sur des jeux de données bidimensionnels. Les jeux de données contenaient un ou deux modes (régions de forte densité) pour illustrer la capacité des algorithmes à gérer les données multimodales. Les limites de décision entre les données normales et les anomalies ont été affichées en noir, sauf pour le Local Outlier Factor (LOF) car il n'avait pas de méthode de prédiction à appliquer sur de nouvelles données lorsqu'il était utilisé pour la détection d'anomalies. La classe :class:~sklearn.svm.OneClassSVM s'est révélée sensible aux anomalies et n'a donc pas très bien fonctionné pour la détection d'anomalies. La classe :class:sklearn.linear_model.SGDOneClassSVM était une implémentation de la One-Class SVM basée sur la descente de gradient stochastique (SGD). La classe :class:sklearn.covariance.EllipticEnvelope supposait que les données étaient gaussiennes et apprenait une ellipse, et les classes :class:~sklearn.ensemble.IsolationForest et :class:~sklearn.neighbors.LocalOutlierFactor semblaient fonctionner raisonnablement bien pour les jeux de données multimodaux.