Factor de Atípico Local para la Detección de Novedades

Introducción

En este laboratorio, usaremos el algoritmo Local Outlier Factor (LOF) para realizar la detección de novedades. LOF es un método no supervisado de detección de anomalías que identifica la desviación de densidad local de un punto de datos dado con respecto a sus vecinos. Considera las muestras que tienen una densidad sustancialmente menor que sus vecinos como valores atípicos.

Consejos sobre la VM

Una vez finalizada la inicialización de 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 bibliotecas

Comenzaremos importando las bibliotecas necesarias. Usaremos scikit-learn, numpy y matplotlib.

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

Generar datos

Generaremos algunos datos para el entrenamiento, la prueba y los valores atípicos usando numpy. Generaremos 100 observaciones de entrenamiento normales, 20 observaciones de prueba normales y 20 observaciones novedosas 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))

Entrenar el modelo

Ahora entrenaremos el modelo LOF usando los datos de entrenamiento. Establecemos el número de vecinos en 20 y la novedad en verdadera. También establecemos la contaminación en 0.1.

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

Evaluar el modelo

Evaluaremos el modelo entrenado con los datos de prueba y los datos de valores atípicos. Usaremos el método predict para predecir las etiquetas de los datos de prueba y los datos de valores atípicos. Luego contaremos el número de errores en los datos de prueba y los datos de valores atípicos.

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

Visualizar los resultados

Visualizaremos los resultados trazando los datos de entrenamiento, prueba y valores atípicos, junto con la frontera aprendida. También mostraremos el número de errores en los datos de prueba y los datos de valores atípicos.

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

plt.title("Novelty Detection with 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],
    [
        "frontier aprendida",
        "observaciones de entrenamiento",
        "nuevas observaciones regulares",
        "nuevas observaciones anormales",
    ],
    loc="upper left",
    prop=matplotlib.font_manager.FontProperties(size=11),
)
plt.xlabel(
    "errores novedad regular: %d/40 ; errores novedad anormal: %d/40"
    % (n_error_test, n_error_outliers)
)
plt.show()

Resumen

En este laboratorio, usamos el algoritmo Local Outlier Factor (LOF) para realizar la detección de novedades. Generamos datos para el entrenamiento, la prueba y los valores atípicos, entrenamos el modelo LOF, evaluamos el modelo y visualizamos los resultados.