Apprentissage de différentes techniques de détection d'anomalies

Par exemple, nous prenons des lectures de voiture. Nous avons vu deux compteurs de lecture, l'un pour le compteur kilométrique, qui enregistre ou mesure la vitesse à laquelle le véhicule se déplace, et le second est la lecture du régime qui enregistre le nombre de rotations effectuées par la roue de la voiture par minute.

Supposons que le compteur kilométrique s'affiche dans la plage de 0 à 60 mph et que le régime soit compris entre 0 et 750. Nous supposons que toutes les valeurs qui viennent doivent être en corrélation les unes avec les autres. Si le compteur kilométrique affiche une vitesse de 50 et que le régime indique 0 admission, les lectures sont incorrectes. Si le compteur kilométrique affiche une valeur supérieure à zéro, cela signifie que la voiture roulait, donc le régime devrait avoir des valeurs plus élevées, mais dans notre cas, il affiche une valeur de 0. c'est-à-dire des valeurs aberrantes multivariées.

C. Méthode de distance de Mahalanobis

Dans DBSCAN, nous avons utilisé des métriques de distance euclidiennes, mais dans ce cas, nous parlons de la méthode de distance de Mahalanobis. Nous pouvons également utiliser la distance de Mahalanobis avec DBSCAN.

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

Pourquoi euclidien est-il inadapté aux entités corrélées les unes aux autres ? La distance euclidienne ne peut pas trouver ou donnera des données incorrectes sur la proximité des deux points.

La méthode Mahalanobis utilise la distance entre les points et la distribution qui sont des données propres. La distance euclidienne est souvent entre deux points et son score z est calculé par x moins la moyenne et divisé par l'écart type. Dans Mahalanobis, le score z est égal à x moins la moyenne divisée par la matrice de covariance.

Par conséquent, quel effet a la division par la matrice de covariance ? Les valeurs de covariance seront élevées si les variables de votre ensemble de données sont fortement corrélées.

De même, si les valeurs de covariance sont faibles, la distance n'est pas significativement réduite si les données ne sont pas corrélées. Il le fait si bien qu'il aborde à la fois l'échelle et la corrélation des problèmes de variables.

Code

L'ensemble de données peut être extrait de Anomaly-/caret.csv à main · 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]])

import scipy as sp def distance(x=None, data=None, cov=None): x_m = x - np.mean(data) if not cov: cov = np.cov(data.values.T) inv_cov = sp. linalg.inv(cov) left = np.dot(x_m, inv_cov) m_distance = np.dot(left, x_m.T) return m_distance.diagonal() df_g= df[['carat', 'depth', 'price' ]].head(50) df_g['m_distance'] = distance(x=df_g, data=df[['carat', 'depth', 'price']]) df_g.head()

B. Méthode de Tukey pour la détection des valeurs aberrantes

La méthode Tukey est aussi souvent appelée méthode Box and Whisker ou Box plot.

La méthode Tukey utilise la plage supérieure et inférieure.

Fourchette supérieure = 75e centile -k*IQR

Fourchette inférieure = 25e centile + k* IQR

Voyons nos données Titanic avec une variable d'âge à l'aide d'un diagramme en boîte.

sns.boxplot(titanic['age'].values)

Nous pouvons voir sur l'image que la tache de boîte créée par Seaborn montre que de nombreux points entre 55 et 80 ans sont des valeurs aberrantes non comprises dans les quartiles. Nous allons détecter les gammes inférieure et supérieure en créant une fonction outliers_detect.

def outliers_detect(x, k = 1.5): x = np.array(x).copy().astype(float) premier = np.quantile(x, .25) troisième = np.quantile(x, .75) # Calcul IQR iqr = troisième - premier #Gamme supérieure et gamme inférieure inférieure = première - (k * iqr) supérieure = troisième + (k * iqr) retour inférieur, supérieur

outliers_detect(titanic['age'], k = 1.5)

(2.5, 54.5)

D. Détection par PyCaret

Nous utiliserons le même ensemble de données pour la détection par PyCaret.

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

Pycaret est un apprentissage automatique open source qui utilise un modèle d'apprentissage non supervisé pour détecter les valeurs aberrantes. Il a une méthode get_data pour utiliser l'ensemble de données dans pycaret lui-même, set_up pour la tâche de prétraitement avant la détection, prend généralement une trame de données mais a également de nombreuses autres fonctionnalités comme ignore_features, etc.

Autres méthodes create_model pour utiliser un algorithme. Nous allons d'abord utiliser Isolation Forest.

ifor = create_model("iforest") plot_model(ifor) ifor_predictions = predict_model(ifor, data = df) print(ifor_predictions) ifor_anomaly = ifor_predictions[ifor_predictions["Anomaly"] == 1] print(ifor_anomaly.head()) print( ifor_anomalie.shape)

L'anomalie 1 indique des valeurs aberrantes et l'anomalie 0 ne montre aucune valeur aberrante.

La couleur jaune indique ici les valeurs aberrantes.

Voyons maintenant un autre algorithme, K Nearest Neighbors (KNN)

knn = create_model("knn") plot_model(knn) knn_pred = predict_model(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. façonner

E. Détection d'anomalies par PyOD

PyOD est une bibliothèque python pour la détection des valeurs aberrantes dans les données multivariées. Il est bon à la fois pour l'apprentissage supervisé et non supervisé.

depuis pyod.models.iforest importer IForest depuis pyod.models.knn importer KNN 

Nous avons importé la bibliothèque et l'algorithme.

depuis pyod.utils.data importez generate_data depuis pyod.utils.data importez évaluez_print depuis pyod.utils.example importez visualisez train= 300 test=100 contaminate = 0.1 X_train, X_test, y_train, y_test = generate_data(n_train=train, n_test=test , n_features=2,contamination=contaminer,random_state=42)

cname_alg = 'KNN' # le nom de l'algorithme est K Nearest Neighbors c = KNN() c.fit(X_train) #Adapter l'algorithme y_trainpred = c.labels_ y_trainscores = c.decision_scores_ y_testpred = c.predict(X_test) y_testscores = c.decision_function(X_test) print("Training Data:") assess_print(cname_alg, y_train, y_train_scores) print("Test Data:") evaluation_print(cname_alg, y_test, y_test_scores) visualize(cname_alg, X_train, y_train, X_test, y_test, y_trainpred,y_testpred, show_figure=Vrai, save_figure=Vrai)

Nous utiliserons l'algorithme IForest.

fname_alg = 'IForest' # le nom de l'algorithme est K Nearest Neighbors f = IForest() f.fit(X_train) #Adapter l'algorithme 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("Training Data:") assess_print(fname_alg, y_train_pred, y_train_scores) print("Test Data:") evaluation_print(fname_alg, y_test_pred, y_test_scores) visualize(fname_alg, X_train, y_train, X_test, y_test_pred, y_train_pred,y_test_pred, show_figure=Vrai, save_figure=Vrai)

F. Détection d'anomalies par le Prophète

Nous utiliserons l'ensemble de données sur les passagers aériens avec des séries chronologiques Prophet/example_air_passengers.csv sur main · aster28/prophet (github.com)

importer un prophète depuis un prophète importer un prévisionniste depuis un prophète importer un prophète m = Prophète()

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

data.columns = ['ds', 'y'] data['y'] = np.where(data['y'] != 0, np.log(data['y']), 0)

Le Log de la colonne y n'autorise aucune valeur négative. Nous divisons nos données en train, testons et stockons la prédiction dans la prévision variable.

train, test= train_test_split(data, random_state =42) m.fit(train[['ds','y']]) forecast = m.predict(test) def detect(forecast): forcast = forecast[['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

détecter (prévoir)

Nous avons pris l'anomalie comme -1.

Conclusion

Nous discutons ici des différentes méthodes de détection d'anomalies et les expliquons en utilisant le code sur trois ensembles de données de Titanic, de passagers aériens et de Caret pour

Points clés

1. Les valeurs aberrantes ou la détection d'anomalies peuvent être détectées à l'aide de la méthode Box-Whisker ou par DBSCAN.

2. La méthode de la distance euclidienne est utilisée avec les éléments non corrélés.

3. La méthode Mahalanobis est utilisée avec les valeurs aberrantes multivariées.

4. Toutes les valeurs ou tous les points ne sont pas des valeurs aberrantes. Certains sont des bruits qui devraient être des ordures. Les valeurs aberrantes sont des données valides qui doivent être ajustées.

5. Nous avons utilisé PyCaret pour la détection des valeurs aberrantes en utilisant différents algorithmes où l'anomalie est 0, affichée en jaune, et aucune valeur aberrante où la valeur aberrante est XNUMX.

6. Nous avons utilisé PyOD, qui est la bibliothèque de détection Python Outlier. Il a plus de 40 algorithmes. Des techniques supervisées et non supervisées sont utilisées.

7. Nous avons utilisé Prophet et défini la fonction detect pour souligner les valeurs aberrantes.

Les médias présentés dans cet article n'appartiennent pas à Analytics Vidhya et sont utilisés à la discrétion de l'auteur.