Aprendizaje de diferentes técnicas de detección de anomalías

Por ejemplo, tomamos lecturas de automóviles. Hemos visto dos contadores de lectura uno para el cuentakilómetros, que registra o mide la velocidad a la que se desplaza el vehículo, y el segundo es el de lectura de rpm que registra el número de rotaciones que realiza la rueda del coche por minuto.

Suponga que el odómetro muestra en el rango de 0-60 mph y rpm en 0-750. Suponemos que todos los valores que vienen deben correlacionarse entre sí. Si el odómetro muestra una velocidad de 50 y las rpm muestran 0 consumos, las lecturas son incorrectas. Si el odómetro muestra un valor mayor a cero, eso significa que el auto estaba en movimiento, por lo que las rpm deberían tener valores más altos, pero en nuestro caso, muestra un valor de 0. es decir, valores atípicos de múltiples variables.

C. Método de distancia de Mahalanobis

En DBSCAN, usamos métricas de distancia euclidiana, pero en este caso, estamos hablando del método de distancia de Mahalanobis. También podemos usar la distancia de Mahalanobis con DBSCAN.

DBSCAN(eps=0.5, min_samples=3, metric='mahalanobis', metric_params={'V':np.cov(X)}, algorithm='brute', leaf_size=30, n_jobs=-1)

¿Por qué Euclidiano no es apto para entidades correlacionadas entre sí? La distancia euclidiana no puede encontrar o dará datos incorrectos sobre qué tan cerca están los dos puntos.

El método de Mahalanobis utiliza la distancia entre puntos y la distribución que son datos limpios. La distancia euclidiana suele estar entre dos puntos, y su puntuación z se calcula por x menos la media y se divide por la desviación estándar. En Mahalanobis, la puntuación z es x menos la media dividida por la matriz de covarianza.

Entonces, ¿qué efecto tiene dividir por la matriz de covarianza? Los valores de covarianza serán altos si las variables en su conjunto de datos están altamente correlacionadas.

De manera similar, si los valores de covarianza son bajos, la distancia no se reduce significativamente si los datos no están correlacionados. Lo hace tan bien que aborda tanto la escala como la correlación de los problemas de las variables.

Código

El conjunto de datos se puede tomar de Anomaly-/caret.csv en principal · aster28/Anomaly- (github.com)

df = pd.read_csv('caret.csv').iloc[:, [0,4,6]] df.head()

np.random.multivariate_normal(mean, cov, size = 5)
array([[ 0.0509196, 0.536808 ], [ 0.1081547, 0.9308906], [ 0.4545248, 1.4000731], [ 0.9803848, 0.9660610], [ 0.8079491 , 0.9687909]])

np.random.multivariate_normal(mean, cov, size = 5).T
array([[ 0.0586423, 0.8538419, 0.2910855, 5.3047358, 0.5449706], [ 0.6819089, 0.8020285, 0.7109037, 0.9969768, -0.7155739]])

importar scipy como sp def distancia(x=Ninguno, datos=Ninguno, cov=Ninguno): x_m = x - np.mean(datos) si no cov: cov = np.cov(datos.valores.T) inv_cov = sp. linalg.inv(cov) izquierda = np.dot(x_m, inv_cov) m_distance = np.dot(left, x_m.T) return m_distance.diagonal() df_g= df[['quilate', 'profundidad', 'precio' ]].head(50) df_g['m_distance'] = distancia(x=df_g, data=df[['quilate', 'profundidad', 'precio']]) df_g.head()

B. Método de Tukey para la detección de valores atípicos

El método de Tukey también suele denominarse método Box and Whisker o Box plot.

El método Tukey utiliza el rango superior e inferior.

Rango superior = percentil 75 -k*IQR

Rango inferior = percentil 25 + k* IQR

Veamos nuestros datos del Titanic con edad variable usando un diagrama de caja.

sns.boxplot(titanic['edad'].valores)

Podemos ver en la imagen que la mancha de caja creada por Seaborn muestra muchos puntos entre las edades de 55 y 80 años que son valores atípicos que no están dentro de los cuartiles. Detectaremos el rango inferior y superior haciendo una función outliers_detect.

def outliers_detect(x, k = 1.5): x = np.array(x).copy().astype(float) primero = np.quantile(x, .25) tercero = np.quantile(x, .75) # Cálculo de IQR iqr = tercero - primero #Rango superior y rango inferior inferior = primero - (k * iqr) superior = tercero + (k * iqr) volver inferior, superior

valores atípicos_detect(titánico['edad'], k = 1.5)

(2.5, 54.5)

D. Detección por PyCaret

Usaremos el mismo conjunto de datos para la detección por PyCaret.

de pycaret.anomaly import * setup_anomaly_data = setup(df)

Pycaret es un aprendizaje automático de código abierto que utiliza un modelo de aprendizaje no supervisado para detectar valores atípicos. Tiene un método get_data para usar el conjunto de datos en pycaret mismo, configuración para la tarea de preprocesamiento antes de la detección, generalmente toma el marco de datos pero también tiene muchas otras características como ignore_features, etc.

Otros métodos create_model para usar un algoritmo. Primero usaremos Isolation Forest.

ifor = create_model("iforest") plot_model(ifor) ifor_predictions = predecir_model(ifor, data = df) print(ifor_predictions) ifor_anomaly = ifor_predictions[ifor_predictions["Anomaly"] == 1] print(ifor_anomaly.head()) print( sifor_anomalía.forma)

La anomalía 1 indica valores atípicos y la anomalía 0 no muestra valores atípicos.

El color amarillo aquí indica valores atípicos.

Ahora veamos otro algoritmo, K vecinos más cercanos (KNN)

knn = create_model("knn") plot_model(knn) knn_pred = predecir_modelo(knn, data = df) print(knn_pred) knn_anomaly = knn_pred[knn_pred["Anomaly"] == 1] knn_anomaly.head() knn_anomaly.shape

clus = create_model("cluster") plot_model(clus) clus_pred = predict_model(clus, data = df) print(clus_pred) clus_anomaly = clus_predictions[clus_pred["Anomaly"] == 1] print(clus_anomaly.head()) clus_anomaly. forma

E. Detección de anomalías por PyOD

PyOD es una biblioteca de Python para la detección de valores atípicos en datos multivariados. Es bueno tanto para el aprendizaje supervisado como no supervisado.

desde pyod.models.iforest importar IForest desde pyod.models.knn importar KNN 

Importamos la biblioteca y el algoritmo.

desde pyod.utils.data importar generar_datos desde pyod.utils.data importar evaluar_imprimir desde pyod.utils.ejemplo importar visualizar tren= 300 prueba=100 contaminar = 0.1 X_tren, X_prueba, y_tren, y_prueba = generar_datos(n_tren=entrenar, n_prueba=prueba , n_características=2,contaminación=contaminar,estado_aleatorio=42)

cname_alg = 'KNN' # el nombre del algoritmo es K Vecinos más cercanos c = KNN() c.fit(X_train) #Ajustar el algoritmo y_trainpred = c.labels_ y_trainscores = c.decision_scores_ y_testpred = c.predict(X_test) y_testscores = c.decision_function(X_test) print("Datos de entrenamiento:") evaluar_print(cname_alg, y_train, y_train_scores) print("Datos de prueba:") evaluar_print(cname_alg, y_test, y_test_scores) visualizar(cname_alg, X_train, y_train, X_test, y_test, y_trainpred,y_testpred, show_figure=Verdadero, save_figure=Verdadero)

Usaremos el algoritmo IForest.

fname_alg = 'IForest' # el nombre del algoritmo es K Vecinos más cercanos f = IForest() f.fit(X_train) #Ajustar el algoritmo y_train_pred = c.labels_ y_train_scores = c.decision_scores_ y_test_pred = c.predict(X_test) y_test_scores = c.decision_function(X_test) print("Datos de entrenamiento:") evaluar_print(fname_alg, y_train_pred, y_train_scores) print("Datos de prueba:") evaluar_print(fname_alg, y_test_pred, y_test_scores) visualizar(fname_alg, X_train, y_train, X_test, y_test_pred, y_train_pred,y_test_pred, show_figure=Verdadero, save_figure=Verdadero)

F. Detección de anomalías por Prophet

Usaremos el conjunto de datos de pasajeros aéreos con series de tiempo profeta/example_air_passengers.csv en principal · aster28/profeta (github.com)

importar profeta de profeta importar pronosticador de profeta importar Profeta m = Profeta()

datos = pd.read_csv('air_pass.csv') datos.head()

datos.columnas = ['ds', 'y'] datos['y'] = np.where(datos['y'] != 0, np.log(datos['y']), 0)

El registro de la columna y no permite ningún valor negativo. Dividimos nuestros datos en entrenar, probar y almacenar la predicción en el pronóstico variable.

tren, prueba= tren_prueba_división(datos, estado_aleatorio =42) m.fit(tren[['ds','y']]) pronóstico = m.predict(prueba) def detect(pronóstico): pronóstico = pronóstico[['ds ', 'yhat', 'yhat_lower', 'yhat_upper']].copy() forcast['real']= data['y'] forcast['anomaly'] =0 forcast.loc[forcast['real'] > forcast['yhat_upper'], 'anomaly']=1 forcast.loc[forcast['real']< forcast['yhat_lower'], 'anomaly']=-1 forcast['imp']=0 in_range = forcast ['yhat_upper']-forcast['yhat_lower'] forcast.loc[forcast['anomaly']==1, 'imp'] = forcast['real']-forcast['yhat_upper']/in_range forcast.loc[ forcast['anomaly']==-1, 'imp']= forcast['yhat_lower']-forcast['real']/in_range return forcast

detectar (pronosticar)

Tomamos la anomalía como -1.

Conclusión

Aquí discutimos los diversos métodos de detección de anomalías y los explicamos usando el código en tres conjuntos de datos de Titanic, pasajeros aéreos y Caret para

Lista de verificación

1. Los valores atípicos o la detección de anomalías se pueden detectar mediante el método Box-Whisker o mediante DBSCAN.

2. Se utiliza el método de la distancia euclidiana con los elementos no correlacionados.

3. El método de Mahalanobis se usa con valores atípicos multivariados.

4. Todos los valores o puntos no son atípicos. Algunos son ruidos que deberían ser basura. Los valores atípicos son datos válidos que deben ajustarse.

5. Usamos PyCaret para la detección de valores atípicos usando diferentes algoritmos donde la anomalía es una, que se muestra en colores amarillos, y no hay valores atípicos donde el valor atípico es 0.

6. Utilizamos PyOD, que es la biblioteca de detección de valores atípicos de Python. Tiene más de 40 algoritmos. Se utilizan técnicas supervisadas y no supervisadas.

7. Utilizamos Prophet y definimos la función de detección para delinear los valores atípicos.

Los medios que se muestran en este artículo no son propiedad de Analytics Vidhya y se utilizan a discreción del autor.