Verschillende technieken voor anomaliedetectie leren

We nemen bijvoorbeeld autometingen op. We hebben twee afleesmeters gezien, een voor de kilometerteller, die de snelheid registreert of meet waarmee het voertuig beweegt, en de tweede is de aflezing van het toerental dat het aantal omwentelingen per minuut van het autowiel registreert.

Stel dat de kilometerteller aangeeft in het bereik van 0-60 mph en rpm in 0-750. We gaan ervan uit dat alle waarden die komen, met elkaar moeten correleren. Als de kilometerteller een snelheid van 50 aangeeft en het toerental 0 inlaten aangeeft, zijn de meetwaarden onjuist. Als de kilometerteller een waarde hoger dan nul aangeeft, betekent dit dat de auto in beweging was, dus het toerental zou hogere waarden moeten hebben, maar in ons geval geeft het een 0-waarde aan. dwz multivariate uitschieters.

C. Mahalanobis-afstandsmethode

In DBSCAN gebruikten we euclidische afstandsmetrieken, maar in dit geval hebben we het over de Mahalanobis-afstandsmethode. We kunnen ook Mahalanobis-afstand gebruiken met DBSCAN.

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

Waarom is Euclidisch ongeschikt voor entiteiten die met elkaar in verband staan? Euclidische afstand kan niet vinden of geeft onjuiste gegevens over hoe dichtbij de twee punten zijn.

Mahalanobis-methode gebruikt de afstand tussen punten en distributie die schone gegevens zijn. Euclidische afstand is vaak tussen twee punten, en de z-score wordt berekend door x min gemiddelde en gedeeld door standaarddeviatie. In Mahalanobis is de z-score x minus het gemiddelde gedeeld door de covariantiematrix.

Welk effect heeft delen door de covariantiematrix dus? De covariantiewaarden zullen hoog zijn als de variabelen in uw dataset sterk gecorreleerd zijn.

Evenzo, als de covariantiewaarden laag zijn, wordt de afstand niet significant verkleind als de gegevens niet gecorreleerd zijn. Het doet het zo goed dat het zowel de schaal als de correlatie van de variabelen aanpakt.

Code

Dataset kan worden overgenomen van Anomaly-/caret.csv op hoofd · 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) indien niet 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'] = afstand(x=df_g, data=df[['carat', 'depth', 'price']]) df_g.head()

B. Tukey's methode voor detectie van uitschieters

De Tukey-methode wordt ook vaak Box and Whisker- of Boxplot-methode genoemd.

De Tukey-methode maakt gebruik van het bovenste en onderste bereik.

Bovenste bereik = 75e percentiel -k*IQR

Onderste bereik = 25e percentiel + k* IQR

Laten we onze Titanic-gegevens met leeftijdsvariabele bekijken met behulp van een boxplot.

sns.boxplot(titanic['leeftijd'].waarden)

We kunnen in de afbeelding zien dat de door Seaborn gemaakte box-blot laat zien dat veel stippen tussen de leeftijd van 55 en 80 uitschieters zijn die niet binnen de kwartielen vallen. We zullen het onderste en bovenste bereik detecteren door een functie outliers_detect te maken.

def outliers_detect(x, k = 1.5): x = np.array(x).copy().astype(float) eerste = np.quantile(x, .25) derde = np.quantile(x, .75) # IQR-berekening iqr = derde - eerste #Bovenste bereik en onderste bereik onderste = eerste - (k * iqr) bovenste = derde + (k * iqr) retour onderste, bovenste

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

(2.5, 54.5)

D. Detectie door PyCaret

We zullen dezelfde dataset gebruiken voor detectie door PyCaret.

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

Pycaret is een open-source machine learning die een leermodel zonder toezicht gebruikt om uitschieters te detecteren. Het heeft een get_data-methode voor het gebruik van de dataset in pycaret zelf, set_up voor preprocessing-taak vóór detectie, neemt meestal een dataframe in beslag, maar heeft ook vele andere functies zoals ignore_features, enz.

Andere methoden create_model voor het gebruik van een algoritme. We zullen eerst Isolation Forest gebruiken.

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_anomaly.shape)

Afwijking 1 geeft uitschieters aan en Afwijking 0 geeft geen uitschieters aan.

De gele kleur geeft hier uitschieters aan.

Laten we nu een ander algoritme bekijken, K Nearest Neighbours (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. vorm geven aan

E. Anomaliedetectie door PyOD

PyOD is een python-bibliotheek voor de detectie van uitschieters in multivariate gegevens. Het is goed voor zowel begeleid als onbewaakt leren.

van pyod.models.iforest importeren IForest van pyod.models.knn importeren KNN 

We hebben de bibliotheek en het algoritme geïmporteerd.

van pyod.utils.data importeren genereren_data van pyod.utils.data importeren evalueren_print van pyod.utils.example importeren visualiseren trein= 300 test=100 besmetten = 0.1 X_train, X_test, y_train, y_test = generated_data(n_train=train, n_test=test , n_features=2,besmetting=besmet,random_state=42)

cname_alg = 'KNN' # de naam van het algoritme is K Nearest Neighbours c = KNN() c.fit(X_train) #Plaats het algoritme y_trainpred = c.labels_ y_trainscores = c.decision_scores_ y_testpred = c.predict(X_test) y_testscores = c.decision_function(X_test) print("Trainingsgegevens:") evalueren_print(cname_alg, y_train, y_train_scores) print("Testgegevens:") evalueren_print(cname_alg, y_test, y_test_scores) visualiseren(cname_alg, X_train, y_train, X_test, y_test, y_trainpred,y_testpred, show_figure=True, save_figure=True)

We zullen het IForest-algoritme gebruiken.

fname_alg = 'IForest' # de naam van het algoritme is K Nearest Neighbours f = IForest() f.fit(X_train) #Plaats het algoritme 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("Trainingsgegevens:") evalueren_print(fname_alg, y_train_pred, y_train_scores) print("Testgegevens:") evalueren_print(fname_alg, y_test_pred, y_test_scores) visualiseren(fname_alg, X_train, y_train, X_test, y_test_pred, y_train_pred,y_test_pred, show_figure=True, save_figure=True)

F. Detectie van afwijkingen door Prophet

We gebruiken de dataset voor vliegtuigpassagiers met tijdreeksen Prophet/example_air_passengers.csv op main · aster28/prophet (github.com)

importeer profeet van profeet importeer voorspeller van profeet importeer profeet m = profeet()

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)

De log van de y-kolom maakt geen negatieve waarde mogelijk. We hebben onze gegevens opgesplitst in trainen, testen en de voorspelling opgeslagen in de variabele prognose.

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

detecteren (voorspelling)

We namen de anomalie als -1.

Conclusie

We bespreken hier de verschillende methoden voor anomaliedetectie en leggen ze uit aan de hand van de code op drie datasets van Titanic, Air passagiers en Caret om

Sleutelpunten

1. Uitschieters of anomaliedetectie kunnen worden gedetecteerd met behulp van de Box-Whisker-methode of door DBSCAN.

2. Euclidische afstandsmethode wordt gebruikt met de items die niet gecorreleerd zijn.

3. Mahalanobis-methode wordt gebruikt met multivariate uitschieters.

4. Alle waarden of punten zijn geen uitschieters. Sommige zijn geluiden die rotzooi zouden moeten zijn. Uitschieters zijn geldige gegevens die moeten worden aangepast.

5. We gebruikten PyCaret voor de detectie van uitschieters door verschillende algoritmen te gebruiken waarbij de afwijking één is, weergegeven in gele kleuren, en geen uitbijters waarbij de uitbijter 0 is.

6. We gebruikten PyOD, de Python Outlier-detectiebibliotheek. Het heeft meer dan 40 algoritmen. Bewaakte en onbewaakte technieken worden gebruikt.

7. We gebruikten Prophet en definieerden de functie detecteren om de uitschieters te schetsen.

De in dit artikel getoonde media zijn geen eigendom van Analytics Vidhya en worden naar goeddunken van de auteur gebruikt.