[PYTHON] Détection d'anomalies par encodeur automatique à l'aide de keras [Exemple d'implémentation pour les débutants]

Ce que j'ai fait dans cet article

** - Défi pour implémenter un encodeur automatique en utilisant keras

• Détection d'anomalie mise en œuvre par apprentissage non supervisé
• Évaluez l'effet du taux de rappel et du taux de précision **

introduction

L'apprentissage non supervisé est généralement moins précis que l'apprentissage supervisé, mais au prix de nombreux avantages. Plus précisément, en tant que scène où l'apprentissage non supervisé est utile

** - Données dont le modèle n'est pas bien compris --Données variant dans le temps --Données non étiquetées **

Etc.

Dans l'apprentissage non supervisé, vous apprenez ** la structure derrière les données ** à partir des données elles-mêmes. Cela vous permet de tirer parti de davantage de données non étiquetées, ce qui peut ouvrir la voie à de nouvelles applications.

Donc, cette fois, je présenterai ** une méthode de détection des anomalies par apprentissage non supervisé **. Il existe différents types de détection d'anomalies, mais ici nous allons introduire le code pour la ** détection d'anomalies ** lors de l'utilisation d'un encodeur automatique.

Données et code ["Apprentissage non supervisé avec python"](url https://www.amazon.co.jp/Python%E3%81%A7%E3%81%AF%E3%81%98%E3%82 % 81% E3% 82% 8B% E6% 95% 99% E5% B8% AB% E3% 81% AA% E3% 81% 97% E5% AD% A6% E7% BF% 92-% E2% 80% 95% E6% A9% 9F% E6% A2% B0% E5% AD% A6% E7% BF% 92% E3% 81% AE% E5% 8F% AF% E8% 83% BD% E6% 80% A7% E3% 82% 92% E5% BA% 83% E3% 81% 92% E3% 82% 8B% E3% 83% A9% E3% 83% 99% E3% 83% AB% E3% 81% AA% E3% 81% 97% E3% 83% 87% E3% 83% BC% E3% 82% BF% E3% 81% AE% E5% 88% A9% E7% 94% A8-Ankur-Patel / dp / 4873119103) J'ai le droit de le faire.

Données à traiter

Utilisez un ensemble de données pour la détection de la fraude par carte de crédit. Il semble que les données aient été utilisées à l'origine dans kaggle.

Vous pouvez télécharger les données à partir de ce qui suit. https://github.com/aapatel09/handson-unsupervised-learning/blob/master/datasets/credit_card_data/credit_card.csv

Importer la bibliothèque

Puisqu'il s'agit d'un ouvrage de référence, il contient des éléments inutiles.

python

'''Main'''
import numpy as np
import pandas as pd
import os, time, re
import pickle, gzip

'''Data Viz'''
import matplotlib.pyplot as plt
import seaborn as sns
color = sns.color_palette()
import matplotlib as mpl

%matplotlib inline

'''Data Prep and Model Evaluation'''
from sklearn import preprocessing as pp
from sklearn.model_selection import train_test_split 
from sklearn.model_selection import StratifiedKFold 
from sklearn.metrics import log_loss
from sklearn.metrics import precision_recall_curve, average_precision_score
from sklearn.metrics import roc_curve, auc, roc_auc_score

'''TensorFlow and Keras'''
import tensorflow as tf
import keras
from keras import backend as K
from keras.models import Sequential, Model
from keras.layers import Activation, Dense, Dropout
from keras.layers import BatchNormalization, Input, Lambda
from keras import regularizers
from keras.losses import mse, binary_crossentropy

sns.set("talk")

Télécharger les données

python

data = pd.read_csv("credit_card.csv")
dataX = data.copy().drop(["Class","Time"],axis=1)
dataY = data["Class"].copy()

print("dataX shape:{},dataY shape:{}".format(dataX.shape,dataY.shape))
dataX.head()

Je pense que les données seront sorties comme ça. Il devrait en fait y avoir 29 lignes.

--dataX contient des données représentant l'utilisation de 284807 cartes --dataY dispose de données indiquant si 284807 personnes ont fait faillite

Cela signifie que. Vous ne pouvez pas dire à partir de ces données quel type d'utilisation représente la carte.

Vue d'ensemble de la méthode de détection des anomalies

Ensuite, je vais vous présenter comment détecter les anomalies. Selon les données ci-dessus, environ 0,2% des utilisateurs sont victimes d'abus. En d'autres termes, la plupart des données sont utilisées normalement.

Par conséquent, je pense que la structure des données de ces ** données abusées est différente de celle des données normales **. Il s'agit d'une tentative de révéler cette différence dans la structure des données à l'aide d'un encodeur automatique.

Alors, comment l'auto-encodeur peut-il brûler des données anormales? Comme indiqué ci-dessous, l'encodeur automatique est ** une fois compressé en données avec un nombre réduit de dimensions, puis reconstruit à nouveau en données avec le même nombre de dimensions. ** **

Les données reconstruites ont généralement les mêmes valeurs que les données d'origine. Cependant, ** les données anormales seront différentes des données normales et seront différentes des données d'origine **.

Le fait qu'il s'agisse de données anormales ou non est déterminé en prenant l'erreur entre les données d'origine et les données reconstruites.

Au début, je n'étais pas très propre, mais quand j'y pense, c'est incroyablement rationnel. Cependant, à titre de mise en garde, cette méthode suppose que ** le nombre de données anormales est très faible par rapport aux données normales **. En effet, s'il y a beaucoup de données anormales, la reconstruction des données normales ne fonctionnera pas.

Création de données d'entraînement et de données d'évaluation

python

#Mettre à l'échelle la conversion de sorte que la moyenne de toutes les entités soit de 0 et l'écart type de 1.
featuresToScale = dataX.columns
sX = pp.StandardScaler(copy=True, with_mean=True, with_std=True)
dataX.loc[:,featuresToScale] = sX.fit_transform(dataX[featuresToScale])

#Divisez en données d'entraînement et en données de test
X_train, X_test, y_train, y_test = \
  train_test_split(dataX,dataY,test_size=0.33,random_state=2018,stratify=dataY)

X_train_AE = X_train.copy()
X_test_AE = X_test.copy()

Implémentation de l'encodeur automatique

Ensuite, comment monter l'encodeur automatique.

Ici, nous allons créer un encodeur automatique ** qui utilise une fonction d'activation linéaire à deux couches. ** La différence est que les données de réponse correctes ne sont pas utilisées, donc les données de réponse correctes sont les mêmes que les données d'entraînement. ** **

python

#Construction d'un codeur automatique utilisant une fonction d'activation linéaire à deux couches

model = Sequential()
model.add(Dense(units=27,activation="linear",input_dim=29)) #Déterminez le nombre de couches pour condenser les données avec des unités.
model.add(Dense(units=29,activation="linear"))

model.compile(optimizer="adam",loss="mean_squared_error",metrics="accuracy")
num_epochs = 3
batch_size = 32

history = model.fit(x=X_train_AE,y=X_train_AE,
                    epochs=num_epochs,
                    batch_size=batch_size,
                    shuffle=True,
                    validation_data=(X_train_AE,X_train_AE),
                    verbose=1)

Créer une fonction d'évaluation

À ce stade, l'encodeur automatique est terminé. Puis pour évaluer cet encodeur automatique

** - Une fonction qui calcule la différence entre les données d'origine et les données optimisées

• Taux de conformité - Fonction pour dessiner la courbe de rappel, la courbe AUC **

Créer un.

La première est une fonction qui calcule l'erreur de reconstruction. C'est juste une erreur carrée, donc cela ne semble pas être si difficile.

python

#Fonction de score anormal qui calcule l'erreur la plus élevée entre la quantité de caractéristiques d'origine et la matrice de quantité de caractéristiques nouvellement reconstruite
#Calculer et normaliser la somme des erreurs quadratiques entre 0 et 1
#Près de 1 est anormal, près de 0 est normal
def anomalyScores(originalDF,reduceDF):
  loss = np.sum((np.array(originalDF)-np.array(reduceDF))**2,axis=1)
  loss = pd.Series(data=loss,index=originalDF.index)
  loss = (loss-np.min(loss))/(np.max(loss)-np.min(loss))
  return loss

Vient ensuite la fonction pour dessiner la courbe de taux de rappel de précision et la courbe AUC.

python

#Taux de conformité-再現率曲線、平均Taux de conformité、auROC曲線をプロットする
def plotResults(trueLabels, anomalyScores,returnPreds=False):
  preds = pd.concat([trueLabels,anomalyScores],axis=1)
  preds.columns = ["trueLabel","anomalyScore"]

  #Taux de conformité à chaque seuil(precision)Et rappelez-vous(recall)Calculer
  precision, recall, thresholds = precision_recall_curve(preds["trueLabel"],preds["anomalyScore"])
  average_precision = average_precision_score(preds["trueLabel"],preds["anomalyScore"])

  #Taux de conformité-Courbe de taux de rappel
  plt.step(recall,precision,color="k",alpha=0.7,where="post")
  plt.fill_between(recall,precision,step="post",alpha=0.3,color="k")

  plt.xlabel("Recall")
  plt.ylabel("Precision")
  plt.ylim([0,1.05])
  plt.xlim([0,1.0])

  plt.title("Precision-Recall Curve:Average Precision={0:0.2f}".format(average_precision))

  fpr,tpr,thresholds = roc_curve(preds["trueLabel"],preds["anomalyScore"])
  areaUnderROC = auc(fpr,tpr)
 
 #Courbe AUC
  plt.figure()
  plt.plot(fpr,tpr,color="r",lw=2,label="ROC curve")
  plt.plot([0,1],[0,1],color="k",lw=2,linestyle="--")
  plt.xlabel("False positive Rate")
  plt.ylabel("True Postive Rate")
  plt.ylim([0,1.05])
  plt.xlim([0,1.0])

  plt.title("Receiver operating characteristic: Area under the curve = {0:0.2f}".format(areaUnderROC))
  plt.legend(loc="lower right")
  plt.show()

  if returnPreds == True:
    return preds

Cette fonction crée une trame de données qui stocke les étiquettes des données de réponse correctes et des valeurs aberrantes. Les fonctions clés sont ** precision_recall_curve et roc_curve **.

** precision_recall_curve est une fonction qui calcule la précision et le rappel lorsque le seuil passe de 1 à 0 **.

Par exemple, lorsque le seuil est 0, tous les 0 et plus sont considérés comme des erreurs. En d'autres termes, tout est jugé comme une erreur. Lorsque cela se produit, la précision sera de 0 et le rappel sera de 1. C'est une fonction pratique qui calcule cela pour chaque seuil.

** roc_curve calcule le taux de faux positifs et le taux de vrais positifs pour chaque seuil **.

Par exemple, lorsque le seuil est 0, tous les 0 et plus sont jugés positifs. Ensuite, le taux de vrais positifs sera de 1 car il y a 0 faux négatifs. De plus, le taux de faux positifs est de 1 car il n'y a pas de vrais négatifs. C'est une fonction pratique qui détermine le rapport à divers seuils comme celui-ci.

Résultat de l'évaluation de la détection d'anomalies par le codeur automatique

Ensuite, c'est le résultat de l'évaluation du codeur automatique qui a été implémenté plus tôt.

Tout d'abord, à partir du graphique du taux de précision-taux de rappel. Lorsque le taux de rappel sur l'axe horizontal est de 75%, la valeur du taux de précision sur l'axe vertical est d'environ 60%. Cela signifie que ** 75% des utilisations frauduleuses peuvent être capturées, et 60% des utilisations frauduleuses ainsi capturées sont en fait des données frauduleuses **.

Vient ensuite la courbe au ROC. C'est un indice pour augmenter le taux de vrais positifs tout en maintenant le taux de faux positifs bas. L'indice à ce moment était de 0,92.

À partir de ces résultats, il a été constaté que ** la classification est possible dans une certaine mesure sans formation en utilisant des données de réponses correctes **. Pour apprendre à améliorer encore la précision

--Introduire le décrochage --Modifier la fonction d'activation --Modifier le nombre de nœuds lors de la compression

Cela sera considéré.

À la fin

Les points forts de l'apprentissage non supervisé sont qu'il peut être appris sans une grande quantité de données d'étiquettes et qu'il est flexible aux modifications des données.

Personnellement, je trouve intéressant de comprendre la structure derrière les données par apprentissage automatique. Comment diable apprenez-vous ... C'est un monde difficile à imaginer et à verbaliser.

En plus d'identifier d'autres choses, le livre présente également des moyens de générer réellement les données. (Machine Boltzmann limitée, apprentissage en profondeur, GAN, etc.)

J'espère que cela sera utile pour l'apprentissage de tous.