Lär dig olika tekniker för att detektera anomali

Till exempel tar vi bilavläsningar. Vi har sett två avläsningsmätare en för vägmätaren, som registrerar eller mäter hastigheten med vilken fordonet rör sig, och den andra är rpm-avläsningen som registrerar antalet varv som bilhjulet gör per minut.

Anta att vägmätaren visar i intervallet 0-60 mph och rpm i 0-750. Vi antar att alla värden som kommer ska korrelera med varandra. Om vägmätaren visar ett varvtal på 50 och varvtalet visar 0 intag, är avläsningarna felaktiga. Om vägmätaren visar ett värde mer än noll betyder det att bilen rörde sig, så varvtalet borde ha högre värden, men i vårt fall visar det ett 0-värde. dvs. avvikelser med flera varianter.

C. Mahalanobis avståndsmetod

I DBSCAN använde vi euklidiska avståndsmått, men i det här fallet talar vi om avståndsmetoden Mahalanobis. Vi kan också använda Mahalanobis-avstånd 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)

Varför är euklidisk olämplig för entiteter relaterade till varandra? Euklidiskt avstånd kan inte hitta eller kommer att ge felaktiga uppgifter om hur nära de två punkterna är.

Mahalanobis-metoden använder avståndet mellan punkter och distribution som är ren data. Euklidiskt avstånd är ofta mellan två punkter, och dess z-poäng beräknas med x minus medelvärde och dividerat med standardavvikelse. I Mahalanobis är z-poängen x minus medelvärdet dividerat med kovariansmatrisen.

Därför, vilken effekt har dividering med kovariansmatrisen? Kovariansvärdena kommer att vara höga om variablerna i din datauppsättning är starkt korrelerade.

På liknande sätt, om kovariansvärdena är låga, reduceras avståndet inte signifikant om data inte är korrelerade. Det går så bra att det tar upp både skalan och korrelationen av variablernas frågor.

Koda

Dataset kan hämtas från 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]])

importera scipy som sp def avstånd(x=Inga, data=Inga, cov=Inga): x_m = x - np.mean(data) om inte 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'] = distans(x=df_g, data=df[['carat', 'depth', 'price']]) df_g.head()

B. Tukeys metod för avvikande upptäckt

Tukey-metoden kallas också ofta för Box and Whisker eller Box plot-metoden.

Tukey-metoden använder övre och nedre intervallet.

Övre intervall = 75:e percentilen -k*IQR

Nedre intervall = 25:e percentilen + k* IQR

Låt oss se våra Titanic-data med åldersvariabel med hjälp av en boxplot.

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

Vi kan se på bilden att box blot som skapats av Seaborn visar att många prickar mellan 55 och 80 år är extremvärden som inte ligger inom kvartilerna. Vi kommer att detektera lägre och övre intervall genom att göra en funktion outliers_detect.

def outliers_detect(x, k = 1.5): x = np.array(x).copy().astype(float) first = np.quantil(x, .25) tredje = np.quantil(x, .75) # IQR-beräkning iqr = tredje - första # Övre intervall och nedre intervall lägre = första - (k * iqr) övre = tredje + (k * iqr) retur lägre, övre

outliers_detect(titanic['ålder'], k = 1.5)

(2.5, 54.5)

D. Detektion av PyCaret

Vi kommer att använda samma datauppsättning för upptäckt av PyCaret.

från pycaret.anomaly import * setup_anomaly_data = setup(df)

Pycaret är en maskininlärning med öppen källkod som använder en oövervakad inlärningsmodell för att upptäcka extremvärden. Den har en get_data-metod för att använda datamängden i själva pycaret, set_up för förbearbetningsuppgift före upptäckt, tar vanligtvis dataram men har också många andra funktioner som ignore_features, etc.

Andra metoder create_model för att använda en algoritm. Vi kommer först att använda 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_anomaly.shape)

Anomali 1 indikerar extremvärden och avvikelse 0 visar inga extremvärden.

Den gula färgen här indikerar extremvärden.

Låt oss nu se en annan algoritm, 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("kluster") 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. Anomalidetektering av PyOD

PyOD är ett pytonbibliotek för detektering av extremvärden i multivariat data. Det är bra både för övervakat och oövervakat lärande.

från pyod.models.iforest import IForest från pyod.models.knn import KNN 

Vi importerade biblioteket och algoritmen.

från pyod.utils.data import generera_data från pyod.utils.data import evaluate_print från pyod.utils.example import visualize train= 300 test=100 kontaminera = 0.1 X_train, X_test, y_train, y_test = generera_data(n_train=tåg, n_test=test , n_features=2,contamination=contaminate,random_state=42)

cname_alg = 'KNN' # namnet på algoritmen är K Närmaste grannar c = KNN() c.fit(X_train) #Anpassa algoritmen y_trainpred = c.labels_ y_trainscores = c.decision_scores_ y_testpred = c.predicty(X_testscores)s c.decision_function(X_test) print("Träningsdata:") evaluate_print(cname_alg, y_train, y_train_scores) print("Testdata:") evaluate_print(cname_alg, y_test, y_test_scores) visualize(cname_alg, X_train, X_testy, _ y_trainpred,y_testpred, show_figure=True, save_figure=True)

Vi kommer att använda IForest-algoritmen.

fname_alg = 'IForest' # namnet på algoritmen är K Närmaste grannar f = IForest() f.fit(X_train) #Fit the algoritm c.decision_function(X_test) print("Träningsdata:") evaluate_print(fname_alg, y_train_pred, y_train_scores) print("Testdata:") evaluate_print(fname_alg, y_test_pred, y_test_scores) visualisera,(fname_train,_alg,_x_,train_alg,_fname_alg, y_train_pred,y_test_pred, show_figure=True, save_figure=True)

F. Avvikelsedetektering av profeten

Vi kommer att använda flygpassagerardataset med tidsserier prophet/example_air_passengers.csv at main · aster28/prophet (github.com)

importera profet från profet import prognosmakare från 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 för y-kolumnen tillåter inget negativt värde. Vi delade upp våra data i tåg, testade och lagrade förutsägelsen i variabelprognosen.

train, test= train_test_split(data, random_state =42) m.fit(train[['ds','y']]) forecast = m.predict(test) def detect(forecast): forcast = prognos[['ds] ', 'yhat', 'yhat_lower', 'yhat_upper']].copy() forcast['real']= data['y'] forcast['anomali'] =0 forcast.loc[forcast['real'] > forcast['yhat_upper'], 'anomaly']=1 forcast.loc[forcast['real']< forcast['yhat_lower'], 'anomaly']=-1 forcast['imp']=0 in_range = prognostiserat ['yhat_upper']-forcast['yhat_lower'] forcast.loc[forcast['anomaly']==1, 'imp'] = prognostiserat['riktig']-forcast['yhat_upper']/in_range forcast.loc[ forcast['anomali']==-1, 'imp']= prognos['yhat_lower']-forcast['real']/in_range return forcast

detektera (prognos)

Vi tog anomalien som -1.

Slutsats

Vi diskuterar här olika metoder för avvikelsedetektering och förklarar dem med hjälp av koden på tre datauppsättningar av Titanic, Air passagerare och Caret för att

Viktiga punkter

1. Outliers eller anomalidetektering kan detekteras med Box-Whisker-metoden eller med DBSCAN.

2. Euklidisk avståndsmetod används med objekten som inte är korrelerade.

3. Mahalanobis-metoden används med multivariata extremvärden.

4. Alla värden eller poäng är inte extremvärden. Vissa är ljud som borde vara skräp. Outliers är giltiga data som behöver justeras.

5. Vi använde PyCaret för att detektera extremvärden genom att använda olika algoritmer där anomalien är en, visas i gula färger, och inga extremvärden där extremvärdet är 0.

6. Vi använde PyOD, som är Python Outlier-detekteringsbiblioteket. Den har mer än 40 algoritmer. Övervakade och oövervakade tekniker används.

7. Vi använde Prophet och definierade funktionen detektera för att beskriva extremvärdena.

Medierna som visas i den här artikeln ägs inte av Analytics Vidhya och används efter författarens gottfinnande.