Lære forskjellige teknikker for å oppdage anomalier

For eksempel tar vi bilavlesninger. Vi har sett to avlesningsmålere, en for kilometertelleren, som registrerer eller måler hastigheten kjøretøyet beveger seg med, og den andre er turtallsavlesningen som registrerer antall rotasjoner bilhjulet gjør per minutt.

Anta at kilometertelleren viser i området 0-60 mph og rpm i 0-750. Vi antar at alle verdiene som kommer skal korrelere med hverandre. Hvis kilometertelleren viser 50 hastighet og rpm viser 0 inntak, er avlesningene feil. Hvis kilometertelleren viser en verdi mer enn null, betyr det at bilen beveget seg, så turtallet burde ha høyere verdier, men i vårt tilfelle viser det en 0-verdi. dvs. multivariate uteliggere.

C. Mahalanobis avstandsmetode

I DBSCAN brukte vi euklidiske avstandsmålinger, men i dette tilfellet snakker vi om avstandsmetoden Mahalanobis. Vi kan også bruke Mahalanobis-avstand med DBSCAN.

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

Hvorfor er euklidisk uegnet for enheter relatert til hverandre? Euklidisk avstand kan ikke finne eller vil gi feil data om hvor nærme de to punktene er.

Mahalanobis-metoden bruker avstanden mellom poeng og distribusjon som er rene data. Euklidisk avstand er ofte mellom to punkter, og dens z-poengsum beregnes ved x minus gjennomsnitt og dividert med standardavvik. I Mahalanobis er z-skåren x minus gjennomsnittet delt på kovariansmatrisen.

Derfor, hvilken effekt har deling med kovariansmatrisen? Kovariansverdiene vil være høye hvis variablene i datasettet ditt er sterkt korrelerte.

Tilsvarende, hvis kovariansverdiene er lave, reduseres ikke avstanden signifikant hvis dataene ikke er korrelert. Det gjør det så bra at det tar for seg både omfanget og korrelasjonen til variablene.

Kode

Datasett kan tas fra Anomaly-/caret.csv at 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]])

importer scipy som sp def distance(x=Ingen, data=Ingen, cov=Ingen): x_m = x - np.mean(data) hvis ikke 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'] = avstand(x=df_g, data=df[['carat', 'depth', 'price']]) df_g.head()

B. Tukeys metode for uteliggerdeteksjon

Tukey-metoden kalles også ofte Box and Whisker eller Box plot-metoden.

Tukey-metoden bruker øvre og nedre rekkevidde.

Øvre område = 75. persentil -k*IQR

Nedre område = 25. persentil + k* IQR

La oss se våre Titanic-data med aldersvariabel ved å bruke et boksplott.

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

Vi kan se på bildet at boksflekken laget av Seaborn viser at mange prikker mellom 55 og 80 år er uteliggere ikke innenfor kvartilene. Vi vil oppdage nedre og øvre område ved å lage en funksjon outliers_detect.

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-beregning iqr = tredje - første #Øvre område og nedre område nedre = første - (k * iqr) øvre = tredje + (k * iqr) retur nedre, øvre

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

(2.5, 54.5)

D. Deteksjon av PyCaret

Vi vil bruke det samme datasettet for deteksjon av PyCaret.

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

Pycaret er en åpen kildekode maskinlæring som bruker en uovervåket læringsmodell for å oppdage uteliggere. Den har en get_data-metode for å bruke datasettet i selve pycaret, set_up for forhåndsbehandlingsoppgave før deteksjon, tar vanligvis dataramme, men har også mange andre funksjoner som ignore_features, etc.

Andre metoder create_model for bruk av en algoritme. Vi skal først bruke Isolation Forest.

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

Anomali 1 indikerer uteliggere, og anomali 0 viser ingen uteliggere.

Den gule fargen her indikerer uteliggere.

La oss nå se en annen algoritme, 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. form

E. Anomalideteksjon av PyOD

PyOD er ​​et pythonbibliotek for deteksjon av uteliggere i multivariate data. Det er bra både for veiledet og uovervåket læring.

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

Vi importerte biblioteket og algoritmen.

fra pyod.utils.data import gener_data fra pyod.utils.data import evaluate_print fra pyod.utils.example import visualize train= 300 test=100 kontaminere = 0.1 X_train, X_test, y_train, y_test = generer_data(n_train=tog, n_test=test , n_features=2,contamination=contaminate,random_state=42)

cname_alg = 'KNN' # navnet på algoritmen er K Nærmeste naboer c = KNN() c.fit(X_train) #Tilpass algoritmen y_trainpred = c.labels_ y_trainscores = c.decision_scores_ y_testpred = c.predicty(X_testscores) c.decision_function(X_test) print("Opplæringsdata:") evaluate_print(cname_alg, y_train, y_train_scores) print("Test Data:") evaluate_print(cname_alg, y_test, y_test_scores) visualize(cname_alg, X_train, X, _ y_trainpred,y_testpred, show_figure=True, save_figure=True)

Vi vil bruke IForest-algoritmen.

fname_alg = 'IForest' # navnet på algoritmen er K Nærmeste naboer f = IForest() f.fit(X_train) #Tilpass algoritmen y_train_pred = c.labels_ y_train_scores = c.decision_scores_ y_test_pred = c_testy_testy_test = c_test c.decision_function(X_test) print("Opplæringsdata:") evaluate_print(fname_alg, y_train_pred, y_train_scores) print("Test Data:") evaluate_print(fname_alg, y_test_pred, y_test_scores) visualize,(fname_train_alg,_x_train_alg,_x_train_alg,_fname_ y_train_pred,y_test_pred, show_figure=True, save_figure=True)

F. Anomalideteksjon av profeten

Vi vil bruke flypassasjerdatasettet med tidsserier prophet/example_air_passengers.csv at main · aster28/prophet (github.com)

import profet fra profet import spåmann fra profet import Profet m = Profet()

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)

Loggen til y-kolonnen aktiverer ingen negativ verdi. Vi delte dataene våre inn i tog, test og lagret prediksjonen i variabelprognosen.

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['ekte']-forcast['yhat_upper']/in_range forcast.loc[ forcast['anomaly']==-1, 'imp']= forcast['yhat_lower']-forcast['real']/in_range return forcast

oppdage (prognose)

Vi tok anomalien som -1.

konklusjonen

Vi diskuterer her de ulike metodene for deteksjon av anomalier og forklarer dem ved å bruke koden på tre datasett med Titanic, Air-passasjerer og Caret for å

Viktige punkter

1. Outliers eller anomalideteksjon kan oppdages ved hjelp av Box-Whisker-metoden eller ved DBSCAN.

2. Euklidisk avstandsmetode brukes med elementene som ikke er korrelert.

3. Mahalanobis-metoden brukes med Multivariate uteliggere.

4. Alle verdiene eller poengene er ikke uteliggere. Noen er lyder som burde være søppel. Outliers er gyldige data som må justeres.

5. Vi brukte PyCaret for deteksjon av uteliggere ved å bruke forskjellige algoritmer der anomalien er én, vist i gule farger, og ingen uteliggere der uteliggeren er 0.

6. Vi brukte PyOD, som er Python Outlier-deteksjonsbiblioteket. Den har mer enn 40 algoritmer. Overvåket og uovervåket teknikker det brukes.

7. Vi brukte Prophet og definerte funksjonen detect for å skissere avvikene.

Mediene vist i denne artikkelen eies ikke av Analytics Vidhya og brukes etter forfatterens skjønn.