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.
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.