Aprendendo Diferentes Técnicas de Detecção de Anomalias

Por exemplo, fazemos leituras de carros. Vimos dois medidores de leitura um para o hodômetro, que registra ou mede a velocidade com que o veículo está se movendo, e o segundo é a leitura de rpm que registra o número de rotações feitas pela roda do carro por minuto.

Suponha que o odômetro mostre na faixa de 0-60 mph e rpm em 0-750. Assumimos que todos os valores que vêm devem estar correlacionados entre si. Se o hodômetro mostrar uma velocidade de 50 e a rotação mostrar 0 entradas, as leituras estão incorretas. Se o odômetro mostrar um valor maior que zero, significa que o carro estava em movimento, então a rotação deveria ter valores maiores, mas no nosso caso, mostra um valor 0. ou seja, outliers multivariados.

C. Método de distância de Mahalanobis

No DBSCAN, usamos métricas de distância euclidiana, mas, neste caso, estamos falando do método de distância de Mahalanobis. Também podemos usar a distância de Mahalanobis com DBSCAN.

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

Por que o euclidiano é inadequado para entidades correlacionadas entre si? A distância euclidiana não pode encontrar ou fornecerá dados incorretos sobre a proximidade dos dois pontos.

O método de Mahalanobis usa a distância entre os pontos e a distribuição que são dados limpos. A distância euclidiana geralmente está entre dois pontos, e seu escore z é calculado por x menos a média e dividido pelo desvio padrão. Em Mahalanobis, o escore z é x menos a média dividida pela matriz de covariância.

Portanto, que efeito tem a divisão pela matriz de covariância? Os valores de covariância serão altos se as variáveis ​​em seu conjunto de dados estiverem altamente correlacionadas.

Da mesma forma, se os valores de covariância forem baixos, a distância não será reduzida significativamente se os dados não estiverem correlacionados. Ele se sai tão bem que aborda tanto a escala quanto a correlação das questões das variáveis.

Code

O conjunto de dados pode ser obtido de Anomaly-/caret.csv em 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) if not cov: cov = np.cov(data.values.T) inv_cov = sp. linalg.inv(cov) esquerda = np.dot(x_m, inv_cov) m_distance = np.dot(esquerda, x_m.T) return m_distance.diagonal() df_g= df[['carat', 'profundidade', 'preço' ]].head(50) df_g['m_distance'] = distância(x=df_g, data=df[['carat', 'profundidade', 'preço']]) df_g.head()

B. Método de Tukey para detecção de outliers

O método de Tukey também é frequentemente chamado de método Box and Whisker ou Box plot.

O método de Tukey utiliza a faixa superior e inferior.

Faixa superior = 75º percentil -k*IQR

Faixa inferior = 25º percentil + k* IQR

Vamos ver nossos dados do Titanic com a variável de idade usando um gráfico de caixa.

sns.boxplot(titanic['idade'].valores)

Podemos ver na imagem que o box blot criado por Seaborn mostra que muitos pontos entre 55 e 80 anos são valores discrepantes fora dos quartis. Detectaremos o intervalo inferior e superior criando uma função outliers_detect.

def outliers_detect(x, k = 1.5): x = np.array(x).copy().astype(float) primeiro = np.quantile(x, .25) terceiro = np.quantile(x, .75) # Cálculo IQR iqr = terceiro - primeiro #Intervalo superior e intervalo inferior inferior = primeiro - (k * iqr) superior = terceiro + (k * iqr) retornar inferior, superior

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

(2.5, 54.5)

D. Detecção por PyCaret

Usaremos o mesmo conjunto de dados para detecção pelo PyCaret.

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

Pycaret é um aprendizado de máquina de código aberto que usa um modelo de aprendizado não supervisionado para detectar outliers. Ele tem um método get_data para usar o conjunto de dados no próprio pycaret, set_up para tarefa de pré-processamento antes da detecção, geralmente leva quadro de dados, mas também possui muitos outros recursos como ignore_features, etc.

Outros métodos create_model para usar um algoritmo. Primeiro usaremos 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)

A anomalia 1 indica outliers e a anomalia 0 não mostra outliers.

A cor amarela aqui indica outliers.

Agora vamos ver outro algoritmo, 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. forma

E. Detecção de anomalias por PyOD

PyOD é uma biblioteca Python para a detecção de outliers em dados multivariados. É bom tanto para aprendizado supervisionado quanto não supervisionado.

de pyod.models.iforest importar IForest de pyod.models.knn importar KNN 

Importamos a biblioteca e o algoritmo.

de pyod.utils.data importar generate_data de pyod.utils.data importar avaliar_imprimir de pyod.utils.example importar visualizar trem= 300 teste=100 contaminar = 0.1 X_train, X_test, y_train, y_test = generate_data(n_train=train, n_test=teste , n_features=2,contaminação=contaminar,random_state=42)

cname_alg = 'KNN' # o nome do algoritmo é K Nearest Neighbors c = KNN() c.fit(X_train) #Fit o algoritmo y_trainpred = c.labels_ y_trainscores = c.decision_scores_ y_testpred = c.predict(X_test) y_testscores = c.decision_function(X_test) print("Dados de treinamento:") avalia_print(cname_alg, y_train, y_train_scores) print("Dados de teste:") avalia_print(cname_alg, y_test, y_test_scores) visualize(cname_alg, X_train, y_train, X_test, y_test, y_trainpred,y_testpred, show_figure=Verdadeiro, save_figure=Verdadeiro)

Usaremos o algoritmo IForest.

fname_alg = 'IForest' # o nome do algoritmo é K Nearest Neighbors f = IForest() f.fit(X_train) #Ajuste o 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("Dados de treinamento:") avalia_print(fname_alg, y_train_pred, y_train_scores) print("Dados de teste:") avalia_print(fname_alg, y_test_pred, y_test_scores) visualize(fname_alg, X_train, y_train, X_test, y_test_pred, y_train_pred,y_test_pred, show_figure=Verdadeiro, save_figure=Verdadeiro)

F. Detecção de Anomalias pelo Profeta

Usaremos o conjunto de dados de passageiros aéreos com séries temporais profeta/example_air_passengers.csv em principal · aster28/profeta (github.com)

importar profeta de profeta importar previsão de profeta importar Profeta m = Profeta()

dados = pd.read_csv('air_pass.csv') dados.head()

data.columns = ['ds', 'y'] data['y'] = np.where(data['y'] != 0, np.log(data['y']), 0)

O Log da coluna y não habilita nenhum valor negativo. Dividimos nossos dados em treinar, testar e armazenar a previsão na variável previsão.

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

detectar (previsão)

Tomamos a anomalia como -1.

Conclusão

Discutimos aqui os vários métodos de detecção de anomalias e os explicamos usando o código em três conjuntos de dados do Titanic, passageiros aéreos e Caret para

Pontos chave

1. Outliers ou detecção de anomalias podem ser detectados usando o método Box-Whisker ou por DBSCAN.

2. O método da distância euclidiana é usado com os itens não correlacionados.

3. O método de Mahalanobis é usado com outliers multivariados.

4. Todos os valores ou pontos não são outliers. Alguns são ruídos que deveriam ser lixo. Outliers são dados válidos que precisam ser ajustados.

5. Usamos PyCaret para detecção de outliers usando diferentes algoritmos onde a anomalia é uma, mostrada em cores amarelas, e sem outliers onde o outlier é 0.

6. Usamos o PyOD, que é a biblioteca de detecção de outliers do Python. Possui mais de 40 algoritmos. Técnicas supervisionadas e não supervisionadas são usadas.

7. Usamos o Prophet e definimos a função detect para delinear os outliers.

A mídia mostrada neste artigo não é propriedade da Analytics Vidhya e é usada a critério do Autor.