Local Outlier Factor pour la détection de nouveauté

Introduction

Dans ce laboratoire, nous utiliserons l'algorithme Local Outlier Factor (LOF) pour effectuer la détection de nouveauté. LOF est une méthode de détection d'anomalies non supervisée qui identifie l'écart de densité locale d'un point de données donné par rapport à ses voisins. Elle considère les échantillons dont la densité est sensiblement plus faible que celle de leurs voisins comme des 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 limites 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.

Importation des bibliothèques

Nous allons commencer par importer les bibliothèques nécessaires. Nous utiliserons scikit-learn, numpy et matplotlib.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.neighbors import LocalOutlierFactor

Générer des données

Nous allons générer des données pour l'entraînement, les tests et les anomalies à l'aide de numpy. Nous allons générer 100 observations d'entraînement normales, 20 observations de test normales et 20 observations de nouveauté anormales.

np.random.seed(42)

xx, yy = np.meshgrid(np.linspace(-5, 5, 500), np.linspace(-5, 5, 500))
X = 0.3 * np.random.randn(100, 2)
X_train = np.r_[X + 2, X - 2]
X = 0.3 * np.random.randn(20, 2)
X_test = np.r_[X + 2, X - 2]
X_outliers = np.random.uniform(low=-4, high=4, size=(20, 2))

Entraîner le modèle

Nous allons maintenant entraîner le modèle LOF à l'aide des données d'entraînement. Nous définissons le nombre de voisins à 20 et la nouveauté à vrai. Nous définissons également la contamination à 0,1.

clf = LocalOutlierFactor(n_neighbors=20, novelty=True, contamination=0.1)
clf.fit(X_train)

Évaluer le modèle

Nous allons évaluer le modèle entraîné sur les données de test et les données d'anomalies. Nous utiliserons la méthode predict pour prédire les étiquettes des données de test et des données d'anomalies. Nous compterons ensuite le nombre d'erreurs dans les données de test et les données d'anomalies.

y_pred_test = clf.predict(X_test)
y_pred_outliers = clf.predict(X_outliers)
n_error_test = y_pred_test[y_pred_test == -1].size
n_error_outliers = y_pred_outliers[y_pred_outliers == 1].size

Visualiser les résultats

Nous allons visualiser les résultats en traçant les données d'entraînement, de test et les données d'anomalies ainsi que la frontière apprise. Nous afficherons également le nombre d'erreurs dans les données de test et les données d'anomalies.

Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

plt.title("Détection de nouveauté avec LOF")
plt.contourf(xx, yy, Z, levels=np.linspace(Z.min(), 0, 7), cmap=plt.cm.PuBu)
a = plt.contour(xx, yy, Z, levels=[0], linewidths=2, colors="darkred")
plt.contourf(xx, yy, Z, levels=[0, Z.max()], colors="palevioletred")

s = 40
b1 = plt.scatter(X_train[:, 0], X_train[:, 1], c="white", s=s, edgecolors="k")
b2 = plt.scatter(X_test[:, 0], X_test[:, 1], c="blueviolet", s=s, edgecolors="k")
c = plt.scatter(X_outliers[:, 0], X_outliers[:, 1], c="gold", s=s, edgecolors="k")
plt.axis("tight")
plt.xlim((-5, 5))
plt.ylim((-5, 5))
plt.legend(
    [a.collections[0], b1, b2, c],
    [
        "frontière apprise",
        "observations d'entraînement",
        "nouvelles observations régulières",
        "nouvelles observations anormales"
    ],
    loc="upper left",
    prop=matplotlib.font_manager.FontProperties(size=11)
)
plt.xlabel(
    "erreurs nouvelles régulières : %d/40 ; erreurs nouvelles anormales : %d/40"
    % (n_error_test, n_error_outliers)
)
plt.show()

Sommaire

Dans ce laboratoire, nous avons utilisé l'algorithme Local Outlier Factor (LOF) pour effectuer une détection de nouveauté. Nous avons généré des données pour l'entraînement, les tests et les anomalies, entraîné le modèle LOF, évalué le modèle et visualisé les résultats.