Erlernen verschiedener Techniken der Anomalieerkennung

Zum Beispiel nehmen wir Autoauslesungen vor. Wir haben zwei Zähler gesehen, einen für den Kilometerzähler, der die Geschwindigkeit aufzeichnet oder misst, mit der sich das Fahrzeug bewegt, und der zweite ist der Drehzahlmesser, der die Anzahl der Umdrehungen des Autorads pro Minute aufzeichnet.

Angenommen, der Kilometerzähler zeigt im Bereich von 0-60 mph und U / min in 0-750 an. Wir gehen davon aus, dass alle kommenden Werte miteinander korrelieren sollten. Wenn der Kilometerzähler eine Geschwindigkeit von 50 und die Drehzahl 0 Einlässe anzeigt, sind die Messwerte falsch. Wenn der Kilometerzähler einen Wert über Null anzeigt, bedeutet dies, dass sich das Auto bewegt hat, also sollte die Drehzahl höhere Werte haben, aber in unserem Fall zeigt sie einen Wert von 0 an. dh multivariate Ausreißer.

C. Mahalanobis-Distanzmethode

In DBSCAN haben wir euklidische Distanzmetriken verwendet, aber in diesem Fall sprechen wir über die Mahalanobis-Distanzmethode. Wir können auch die Mahalanobis-Distanz mit DBSCAN verwenden.

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

Warum ist Euklidisch ungeeignet für Entitäten, die miteinander korreliert sind? Die euklidische Distanz kann keine falschen Daten darüber finden, wie nahe die beiden Punkte sind, oder wird falsche Daten liefern.

Die Mahalanobis-Methode verwendet den Abstand zwischen Punkten und die Verteilung, die saubere Daten sind. Die euklidische Distanz liegt oft zwischen zwei Punkten, und ihr Z-Score wird aus x minus Mittelwert berechnet und durch die Standardabweichung dividiert. In Mahalanobis ist der z-Score x minus Mittelwert dividiert durch die Kovarianzmatrix.

Welchen Effekt hat also die Division durch die Kovarianzmatrix? Die Kovarianzwerte sind hoch, wenn die Variablen in Ihrem Datensatz stark korrelieren.

Wenn die Kovarianzwerte niedrig sind, wird der Abstand in ähnlicher Weise nicht wesentlich verringert, wenn die Daten nicht korreliert sind. Es ist so gut, dass es sowohl die Skala als auch die Korrelation der Variablenprobleme anspricht.

Code

Datensatz kann entnommen werden Anomaly-/caret.csv im Hauptverzeichnis · 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[['Karat', 'Tiefe', 'Preis' ]].Kopf(50) df_g['m_Abstand'] = Abstand(x=df_g, Daten=df[['Karat', 'Tiefe', 'Preis']]) df_g.Kopf()

B. Tukey-Verfahren zur Ausreißererkennung

Die Tukey-Methode wird auch oft als Box-and-Whisker- oder Box-Plot-Methode bezeichnet.

Die Tukey-Methode verwendet den oberen und unteren Bereich.

Oberer Bereich = 75. Perzentil -k*IQR

Unterer Bereich = 25. Perzentil + k* IQR

Sehen wir uns unsere Titanic-Daten mit Altersvariable anhand eines Boxplots an.

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

Wir können im Bild sehen, dass der von Seaborn erstellte Box Blot zeigt, dass viele Punkte im Alter zwischen 55 und 80 Ausreißer sind, die nicht innerhalb der Quartile liegen. Wir werden den unteren und oberen Bereich erkennen, indem wir eine Funktion outliers_detect erstellen.

def outliers_detect(x, k = 1.5): x = np.array(x).copy().astype(float) first = np.quantile(x, .25) Third = np.quantile(x, .75) # IQR-Berechnung iqr = Third - First #Upper Range und Lower Range Lower = First - (k * iqr) Upper = Third + (k * iqr) return Lower, Upper

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

(2.5, 54.5)

D. Erkennung durch PyCaret

Wir werden denselben Datensatz zur Erkennung durch PyCaret verwenden.

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

Pycaret ist ein Open-Source-Machine Learning, das ein unüberwachtes Lernmodell verwendet, um Ausreißer zu erkennen. Es hat eine get_data-Methode zur Verwendung des Datensatzes in pycaret selbst, set_up für die Vorverarbeitungsaufgabe vor der Erkennung, nimmt normalerweise einen Datenrahmen auf, hat aber auch viele andere Funktionen wieignore_features usw.

Andere Methoden create_model zur Verwendung eines Algorithmus. Wir werden zuerst Isolation Forest verwenden.

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

Anomalie 1 zeigt Ausreißer an und Anomalie 0 zeigt keine Ausreißer.

Die gelbe Farbe weist hier auf Ausreißer hin.

Sehen wir uns nun einen anderen Algorithmus an, K Nearest Neighbors (KNN)

knn = create_model("knn") plot_model(knn) knn_pred = Vorhersage_model(knn, data = df) print(knn_pred) knn_anomaly = knn_pred[knn_pred["Anomalie"] == 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["Anomalie"] == 1] print(clus_anomaly.head()) clus_anomaly. gestalten

E. Anomalieerkennung durch PyOD

PyOD ist eine Python-Bibliothek zur Erkennung von Ausreißern in multivariaten Daten. Es eignet sich sowohl für überwachtes als auch für unüberwachtes Lernen.

aus pyod.models.iforest import IForest aus pyod.models.knn import KNN 

Wir haben die Bibliothek und den Algorithmus importiert.

aus pyod.utils.data import generate_data aus pyod.utils.data import auswerten_druck aus pyod.utils.example import visual 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=contaminate,random_state=42)

cname_alg = 'KNN' # der Name des Algorithmus ist K Nearest Neighbors c = KNN() c.fit(X_train) #Passen Sie den Algorithmus an y_trainpred = c.labels_ y_trainscores = c.decision_scores_ y_testpred = c.predict(X_test) y_testscores = c.decision_function(X_test) print("Trainingsdaten:") auswerten_drucken(cname_alg, y_train, y_train_scores) print("Testdaten:") auswerten_print(cname_alg, y_test, y_test_scores) visualisieren(cname_alg, X_train, y_train, X_test, y_test, y_trainpred,y_testpred, show_figure=True, save_figure=True)

Wir verwenden den IForest-Algorithmus.

fname_alg = 'IForest' # der Name des Algorithmus ist K Nearest Neighbors f = IForest() f.fit(X_train) #Passen Sie den Algorithmus an 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("Trainingsdaten:") auswerten_drucken(fname_alg, y_train_pred, y_train_scores) print("Testdaten:") auswerten_print(fname_alg, y_test_pred, y_test_scores) visualisieren(fname_alg, X_train, y_train, X_test, y_test_pred, y_train_pred,y_test_pred, show_figure=Wahr, save_figure=Wahr)

F. Erkennung von Anomalien durch Prophet

Wir werden den Fluggastdatensatz mit Zeitreihen verwenden prophet/example_air_passengers.csv im Hauptmenü · aster28/prophet (github.com)

import prophet von prophet import prognostiker von prophet import prophet m = Prophet()

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)

Das Log der y-Spalte lässt keinen negativen Wert zu. Wir haben unsere Daten in Trainieren, Testen aufgeteilt und die Vorhersage in der Variablen Prognose gespeichert.

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

erkennen (vorhersagen)

Wir nahmen die Anomalie als -1.

Zusammenfassung

Wir diskutieren hier die verschiedenen Methoden der Anomalieerkennung und erklären sie anhand des Codes von drei Datensätzen von Titanic, Air Passengers und Caret

Wichtige Punkte

1. Ausreißer oder Anomalieerkennung können mit der Box-Whisker-Methode oder mit DBSCAN erkannt werden.

2. Die Methode der euklidischen Distanz wird mit nicht korrelierten Elementen verwendet.

3. Die Mahalanobis-Methode wird mit multivariaten Ausreißern verwendet.

4. Alle Werte oder Punkte sind keine Ausreißer. Einige sind Geräusche, die Müll sein sollten. Ausreißer sind gültige Daten, die angepasst werden müssen.

5. Wir haben PyCaret zur Erkennung von Ausreißern verwendet, indem wir verschiedene Algorithmen verwendet haben, bei denen die Anomalie eins ist und in gelben Farben angezeigt wird, und keine Ausreißer, bei denen der Ausreißer 0 ist.

6. Wir haben PyOD verwendet, die Python-Bibliothek zur Erkennung von Ausreißern. Es verfügt über mehr als 40 Algorithmen. Es werden überwachte und unüberwachte Techniken verwendet.

7. Wir haben Prophet verwendet und die Funktion detect definiert, um die Ausreißer zu skizzieren.

Die in diesem Artikel gezeigten Medien sind nicht Eigentum von Analytics Vidhya und werden nach Ermessen des Autors verwendet.