Apprendimento di diverse tecniche di rilevamento delle anomalie

Ad esempio, prendiamo le letture dell'auto. Abbiamo visto due contatori di lettura uno per il contachilometri, che registra o misura la velocità a cui si muove il veicolo, e il secondo è la lettura dei giri che registra il numero di giri compiuti dalla ruota dell'auto al minuto.

Supponiamo che il contachilometri mostri nell'intervallo 0-60 mph e rpm in 0-750. Partiamo dal presupposto che tutti i valori che vengono devono essere correlati tra loro. Se il contachilometri mostra una velocità di 50 e il numero di giri mostra 0 prese, le letture non sono corrette. Se il contachilometri mostra un valore maggiore di zero, significa che l'auto era in movimento, quindi i giri dovrebbero avere valori più alti, ma nel nostro caso mostra un valore 0. vale a dire, valori anomali multivariati.

C. Metodo della distanza di Mahalanobis

In DBSCAN, abbiamo utilizzato la metrica della distanza euclidea, ma in questo caso stiamo parlando del metodo della distanza di Mahalanobis. Possiamo anche usare la distanza di Mahalanobis con DBSCAN.

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

Perché Euclideo è inadatto alle entità correlate tra loro? La distanza euclidea non può trovare o fornirà dati errati su quanto vicini sono i due punti.

Il metodo Mahalanobis utilizza la distanza tra i punti e la distribuzione che è dati puliti. La distanza euclidea è spesso tra due punti e il suo punteggio z è calcolato per x meno la media e diviso per la deviazione standard. In Mahalanobis, il punteggio z è x meno la media divisa per la matrice di covarianza.

Quindi, che effetto ha la divisione per la matrice di covarianza? I valori di covarianza saranno elevati se le variabili nel set di dati sono altamente correlate.

Allo stesso modo, se i valori di covarianza sono bassi, la distanza non si riduce significativamente se i dati non sono correlati. Funziona così bene che affronta sia la scala che la correlazione dei problemi delle variabili.

Code

Il set di dati può essere preso da Anomaly-/caret.csv in 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]])

import scipy as sp def distance(x=None, data=None, cov=None): x_m = x - np.mean(data) se non 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[['carati', 'profondità', 'prezzo' ]].head(50) df_g['m_distance'] = distance(x=df_g, data=df[['carat', 'depth', 'price']]) df_g.head()

B. Metodo di Tukey per il rilevamento dei valori anomali

Il metodo Tukey è anche spesso chiamato metodo Box and Whisker o Box plot.

Il metodo Tukey utilizza la gamma superiore e inferiore.

Intervallo superiore = 75° percentile -k*IQR

Intervallo inferiore = 25° percentile + k* IQR

Vediamo i nostri dati sul Titanic con la variabile dell'età usando un box plot.

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

Possiamo vedere nell'immagine che il box blot creato da Seaborn mostra che molti punti tra i 55 e gli 80 anni sono valori anomali non all'interno dei quartili. Rileveremo l'intervallo inferiore e superiore creando una funzione outliers_detect.

def outliers_detect(x, k = 1.5): x = np.array(x).copy().astype(float) primo = np.quantile(x, .25) terzo = np.quantile(x, .75) # Calcolo IQR iqr = terzo - primo #Intervallo superiore e inferiore inferiore = primo - (k * iqr) superiore = terzo + (k * iqr) ritorno inferiore, superiore

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

(2.5, 54.5)

D. Rilevamento tramite PyCaret

Utilizzeremo lo stesso set di dati per il rilevamento da parte di PyCaret.

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

Pycaret è un machine learning open source che utilizza un modello di apprendimento non supervisionato per rilevare i valori anomali. Ha un metodo get_data per utilizzare il set di dati in pycaret stesso, set_up per l'attività di pre-elaborazione prima del rilevamento, di solito accetta frame di dati ma ha anche molte altre funzionalità come ignore_features, ecc.

Altri metodi create_model per l'utilizzo di un algoritmo. Useremo prima 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)

L'anomalia 1 indica valori anomali e l'anomalia 0 non mostra valori anomali.

Il colore giallo qui indica i valori anomali.

Ora vediamo un altro algoritmo, 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. forma

E. Rilevamento di anomalie tramite PyOD

PyOD è una libreria Python per il rilevamento di valori anomali in dati multivariati. È buono sia per l'apprendimento supervisionato che non supervisionato.

da pyod.models.iforest importare IForest da pyod.models.knn importare KNN 

Abbiamo importato la libreria e l'algoritmo.

from pyod.utils.data import generate_data from pyod.utils.data importvalua_print from pyod.utils.example import visualize 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,contaminazione=contaminazione,random_state=42)

cname_alg = 'KNN' # il nome dell'algoritmo è K Nearest Neighbors c = KNN() c.fit(X_train) #Adatta l'algoritmo y_trainpred = c.labels_ y_trainscores = c.decision_scores_ y_testpred = c.predict(X_test) y_testscores = c.decision_function(X_test) print("Dati di addestramento:") VALUT_print(cname_alg, y_train, y_train_scores) print("Dati di test:") Valut_print(cname_alg, y_test, y_test_scores) visualizze(cname_alg, X_train, y_train, X_test, y_test, y_trainpred,y_testpred, show_figure=Vero, save_figure=Vero)

Useremo l'algoritmo IForest.

fname_alg = 'IForest' # il nome dell'algoritmo è K Nearest Neighbors f = IForest() f.fit(X_train) #Adatta l'algoritmo 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("Dati di addestramento:") Valut_print(fname_alg, y_train_pred, y_train_scores) print("Dati di test:") Valut_print(fname_alg, y_test_pred, y_test_scores) visualizze(fname_alg, X_train, y_train, X_test, y_test_pred, y_train_pred,y_test_pred, show_figure=Vero, save_figure=Vero)

F. Rilevamento di anomalie da parte del profeta

Useremo il set di dati dei passeggeri aerei con le serie temporali profeta/example_air_passengers.csv in main · aster28/prophet (github.com)

importa profeta da profeta importa previsore da profeta importa Profeta m = Profeta()

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)

Il registro della colonna y non consente alcun valore negativo. Abbiamo suddiviso i nostri dati in train, test e memorizzato la previsione nella variabile forecast.

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

rilevare (prevedere)

Abbiamo preso l'anomalia come -1.

Conclusione

Qui discutiamo i vari metodi di rilevamento delle anomalie e li spieghiamo utilizzando il codice su tre set di dati di Titanic, passeggeri aerei e Caret per

Punti chiave

1. I valori anomali o il rilevamento delle anomalie possono essere rilevati utilizzando il metodo Box-Whisker o DBSCAN.

2. Il metodo della distanza euclidea viene utilizzato con gli elementi non correlati.

3. Il metodo Mahalanobis viene utilizzato con valori anomali multivariati.

4. Tutti i valori o punti non sono valori anomali. Alcuni sono rumori che dovrebbero essere spazzatura. I valori anomali sono dati validi che devono essere corretti.

5. Abbiamo utilizzato PyCaret per il rilevamento dei valori anomali utilizzando diversi algoritmi in cui l'anomalia è una, mostrata in giallo, e nessun valore anomalo in cui il valore anomalo è 0.

6. Abbiamo usato PyOD, che è la libreria di rilevamento di Python Outlier. Ha più di 40 algoritmi. Vengono utilizzate tecniche supervisionate e non supervisionate.

7. Abbiamo utilizzato Prophet e definito la funzione detect per delineare i valori anomali.

I media mostrati in questo articolo non sono di proprietà di Analytics Vidhya e vengono utilizzati a discrezione dell'autore.