Învățarea diferitelor tehnici de detectare a anomaliilor

De exemplu, luăm citiri pentru mașini. Am văzut două contoare de citire, unul pentru contorul de parcurs, care înregistrează sau măsoară viteza cu care se deplasează vehiculul, iar al doilea este citirea rpm care înregistrează numărul de rotații făcute de roata mașinii pe minut.

Să presupunem că odometrul arată în intervalul 0-60 mph și rpm în 0-750. Presupunem că toate valorile care vin ar trebui să se coreleze între ele. Dacă odometrul arată o viteză de 50 și rpm arată 0 admisii, citirile sunt incorecte. Dacă odometrul arată o valoare mai mare decât zero, înseamnă că mașina se mișca, deci turația ar trebui să aibă valori mai mari, dar în cazul nostru arată o valoare 0. adică valori aberante cu mai multe variabile.

C. Metoda distanței Mahalanobis

În DBSCAN, am folosit metrica distanței euclidiene, dar în acest caz, vorbim despre metoda distanței Mahalanobis. De asemenea, putem folosi distanța Mahalanobis cu DBSCAN.

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

De ce este euclidianul impropriu pentru entități corelate între ele? Distanța euclidiană nu poate găsi sau va oferi date incorecte despre cât de aproape sunt cele două puncte.

Metoda Mahalanobis folosește distanța dintre puncte și distribuție care este date curate. Distanța euclidiană este adesea între două puncte, iar scorul său z este calculat cu x minus media și împărțit la abaterea standard. În Mahalanobis, scorul z este x minus media împărțită la matricea de covarianță.

Prin urmare, ce efect are împărțirea la matricea de covarianță? Valorile de covarianță vor fi ridicate dacă variabilele din setul de date sunt foarte corelate.

În mod similar, dacă valorile covarianței sunt scăzute, distanța nu este redusă semnificativ dacă datele nu sunt corelate. Se descurcă atât de bine încât abordează atât problematica de amploare, cât și corelarea variabilelor.

Cod

Setul de date poate fi preluat din Anomaly-/caret.csv la principal · 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) dacă nu 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'] = distanta(x=df_g, data=df[['carat', 'depth', 'price']]) df_g.head()

B. Metoda lui Tukey pentru detectarea valorii aberante

Metoda Tukey este adesea numită și metoda Box and Whisker sau Box plot.

Metoda Tukey utilizează intervalul superior și inferior.

Interval superior = a 75-a percentilă -k*IQR

Interval inferior = a 25-a percentila + k* IQR

Să vedem datele noastre Titanic cu variabila de vârstă folosind un diagramă cu casete.

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

Putem vedea în imagine că pata de casetă creată de Seaborn arată că multe puncte între 55 și 80 de ani sunt valori aberante care nu se încadrează în quartile. Vom detecta intervalul inferior și superior făcând o funcție 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) # Calcul IQR iqr = al treilea - primul #Interval superior și intervalul inferior inferior = primul - (k * iqr) superior = al treilea + (k * iqr) returnare inferior, superior

outliers_detect(titanic['vârsta'], k = 1.5)

(2.5, 54.5)

D. Detectare prin PyCaret

Vom folosi același set de date pentru detectarea de către PyCaret.

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

Pycaret este o învățare automată open-source care utilizează un model de învățare nesupravegheat pentru a detecta valorile aberante. Are o metodă get_data pentru utilizarea setului de date în pycaret în sine, set_up pentru sarcina de preprocesare înainte de detectare, de obicei preia un cadru de date, dar are și multe alte caracteristici precum ignore_features etc.

Alte metode create_model pentru utilizarea unui algoritm. Vom folosi mai întâi 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["Anomalie"] == 1] print(ifor_anomaly()) print(.head()) ifor_anomaly.shape)

Anomalia 1 indică valori aberante, iar Anomalia 0 nu indică valori aberante.

Culoarea galbenă aici indică valori aberante.

Acum să vedem un alt 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["Anomalie"] == 1] knn_anomaly.knn_anomaly.

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.shead())clus_anomaly.shead formă

E. Detectarea anomaliilor prin PyOD

PyOD este o bibliotecă python pentru detectarea valorii aberante în datele multivariate. Este bun atât pentru învățarea supravegheată, cât și pentru învățarea nesupravegheată.

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

Am importat biblioteca și algoritmul.

din pyod.utils.data import generate_data din pyod.utils.data import evaluate_print din pyod.utils.example import vizualiza tren= 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' # numele algoritmului este K Nearest Neighbors c = KNN() c.fit(X_train) #Fit the algorithm y_trainpred = c.labels_ y_trainscores = c.decision_scores_ y_testpred = c.predict(X_train) =_ c.decision_function(X_test) print("Date de antrenament:") evaluate_print(cname_alg, y_train, y_train_scores) print("Test Data:") evaluate_print(cname_alg, y_test, y_test_scores) vizualizare(cname_alg, X_train, y_train, X_test y_trainpred,y_testpred, show_figure=Adevărat, save_figure=Adevărat)

Vom folosi algoritmul IForest.

fname_alg = 'IForest' # numele algoritmului este K Nearest Neighbors f = IForest() f.fit(X_train) #Fit the algoritmy y_train_pred = c.labels_ y_train_scores = c.decision_scores_ y_test_pred =_test_testpred =__testpred_y__ c.decision_function(X_test) print("Date de antrenament:") evaluate_print(fname_alg, y_train_pred, y_train_scores) print("Test Data:") evaluate_print(fname_alg, y_test_pred, y_test_scores) vizualize(fname_alg, X_train, X_test, y_test y_train_pred,y_test_pred, show_figure=True, save_figure=True)

F. Detectarea anomaliilor de către Profet

Vom folosi setul de date despre pasagerii aerieni cu serii cronologice prophet/example_air_passengers.csv la principal · aster28/prophet (github.com)

import profet din profet import prognozator din 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)

Jurnalul coloanei y nu permite nicio valoare negativă. Ne-am împărțit datele în tren, testare și stocat predicția în prognoza variabilă.

train, test= train_test_split(date, 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 = prognoza ['yhat_upper']-forcast['yhat_lower'] forcast.loc[forcast['anomaly']==1, 'imp'] = forcast['real']-forcast['yhat_upper']/in_range forcast.loc[ prognoză['anomalie']==-1, 'imp']= prognoză['yhat_lower']-forcast['real']/in_range return forcast

detecta (prognoză)

Am luat anomalia ca fiind -1.

Concluzie

Aici discutăm despre diferitele metode de detectare a anomaliilor și le explicăm folosind codul din trei seturi de date Titanic, Air pasageri și Caret pentru

Puncte cheie

1. Valorile aberante sau detectarea anomaliilor pot fi detectate folosind metoda Box-Whisker sau prin DBSCAN.

2. Metoda distanței euclidiene este utilizată cu itemii necorelați.

3. Metoda Mahalanobis este utilizată cu valori aberante Multivariate.

4. Toate valorile sau punctele nu sunt valori aberante. Unele sunt zgomote care ar trebui să fie gunoi. Valorile aberante sunt date valide care trebuie ajustate.

5. Am folosit PyCaret pentru detectarea valorii aberante, folosind diferiți algoritmi în care anomalia este una, afișată în culori galbene, și fără valori aberante în cazul în care valoarea anormală este 0.

6. Am folosit PyOD, care este biblioteca de detectare Python Outlier. Are peste 40 de algoritmi. Se utilizează tehnici supravegheate și nesupravegheate.

7. Am folosit Prophet și am definit funcția detect pentru a contura valorile aberante.

Media prezentată în acest articol nu este deținută de Analytics Vidhya și este utilizată la discreția Autorului.