[PYTHON] Abnormalitätserkennung durch Auto-Encoder mit Keras [Implementierungsbeispiel für Anfänger]

Was ich in diesem Artikel gemacht habe

** - Herausforderung, Auto-Encoder mit Keras zu implementieren

• Implementierte Erkennung von Anomalien durch unbeaufsichtigtes Lernen
• Bewerten Sie den Effekt anhand der Rückrufrate und der Präzisionsrate **

Einführung

Unbeaufsichtigtes Lernen ist im Allgemeinen weniger genau als überwachtes Lernen, geht jedoch zu Lasten vieler Vorteile. Insbesondere als Szene, in der unbeaufsichtigtes Lernen nützlich ist

** - Daten, deren Muster nicht gut verstanden wird

• Zeitlich variierende Daten
• Unbeschriftete Daten **

Und so weiter.

Beim unbeaufsichtigten Lernen lernen Sie ** die Struktur hinter den Daten ** aus den Daten selbst. Auf diese Weise können Sie mehr unbeschriftete Daten nutzen, was den Weg für neue Anwendungen ebnen kann.

Dieses Mal werde ich ** eine Methode zur Erkennung von Anomalien mithilfe von unbeaufsichtigtem Lernen ** vorstellen. Es gibt verschiedene Arten der Anomalieerkennung, aber hier wird der Code für die ** Anomalieerkennung ** bei Verwendung eines automatischen Encoders eingeführt.

Daten und Code ["Unüberwachtes Lernen mit 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) Ich darf.

Zu behandelnde Daten

Verwenden Sie einen Datensatz zur Erkennung von Kreditkartenbetrug. Es scheint, dass die Daten ursprünglich in Kaggle verwendet wurden.

Sie können die Daten von folgenden herunterladen. https://github.com/aapatel09/handson-unsupervised-learning/blob/master/datasets/credit_card_data/credit_card.csv

Bibliothek importieren

Da es sich um ein Nachschlagewerk handelt, enthält es einige unnötige Elemente.

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")

Daten herunterladen

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()

Ich denke, dass die Daten so ausgegeben werden. Es sollte eigentlich 29 Zeilen geben.

--dataX enthält Daten zur Verwendung von 284807 Karten --dataY hat Daten darüber, ob 284807 Personen bankrott gegangen sind

Es bedeutet das. Anhand dieser Daten können Sie nicht erkennen, für welche Art der Nutzung die Karte steht.

Übersicht über die Methode zur Erkennung von Anomalien

Als nächstes werde ich vorstellen, wie Anomalien erkannt werden. Nach den oben genannten Daten werden etwa 0,2% der Benutzer missbraucht. Mit anderen Worten, die meisten Daten werden normal verwendet.

Daher denke ich, dass sich die Datenstruktur dieser ** missbrauchten Daten von der der normalen Daten ** unterscheidet. Dies ist ein Versuch, diesen Unterschied in der Datenstruktur mithilfe eines Auto-Encoders aufzudecken.

Wie kann der Auto-Encoder abnormale Daten ausbrennen? Was ist ein Auto-Encoder? ** Nach dem Komprimieren auf Daten mit einer reduzierten Anzahl von Dimensionen wird er in Daten mit derselben Anzahl von Dimensionen wie unten gezeigt rekonstruiert. ** ** **

Die rekonstruierten Daten haben normalerweise die gleichen Werte wie die Originaldaten. ** Abnormale Daten unterscheiden sich jedoch von normalen Daten und von den Originaldaten **.

Ob es sich um abnormale Daten handelt oder nicht, wird bestimmt, indem der Fehler zwischen den Originaldaten und den rekonstruierten Daten genommen wird.

Anfangs war ich nicht sehr sauber, aber wenn ich darüber nachdenke, ist es wahnsinnig rational. Als Einschränkung wird bei dieser Methode jedoch davon ausgegangen, dass ** die Anzahl abnormaler Daten im Vergleich zu normalen Daten sehr gering ist **. Dies liegt daran, dass die Rekonstruktion normaler Daten bei vielen abnormalen Daten nicht funktioniert.

Erstellung von Trainingsdaten und Bewertungsdaten

python

#Skalieren Sie die Konvertierung so, dass der Durchschnitt aller Features 0 und die Standardabweichung 1 beträgt.
featuresToScale = dataX.columns
sX = pp.StandardScaler(copy=True, with_mean=True, with_std=True)
dataX.loc[:,featuresToScale] = sX.fit_transform(dataX[featuresToScale])

#Teilen Sie in Trainingsdaten und Testdaten
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()

Implementierung des Auto Encoders

Als nächstes wird beschrieben, wie der Auto-Encoder montiert wird.

Hier erstellen wir einen Auto-Encoder **, der eine zweischichtige lineare Aktivierungsfunktion verwendet. ** Der Unterschied besteht darin, dass die richtigen Antwortdaten nicht verwendet werden, sodass die richtigen Antwortdaten mit den Trainingsdaten übereinstimmen. ** ** **

python

#Aufbau eines Auto-Encoders mit einer zweischichtigen linearen Aktivierungsfunktion

model = Sequential()
model.add(Dense(units=27,activation="linear",input_dim=29)) #Bestimmen Sie, wie viele Ebenen Daten mit Einheiten verdichten sollen.
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)

Auswerten einer Bewertungsfunktion

Zu diesem Zeitpunkt ist der automatische Encoder abgeschlossen. Dann, um diesen Auto-Encoder auszuwerten

** - Eine Funktion, die die Differenz zwischen den Originaldaten und den optimierten Daten berechnet

• Compliance-Rate-Funktion zum Zeichnen der Rückrufkurve, AUC-Kurve **

Ein ... kreieren.

Die erste ist eine Funktion, die den Rekonstruktionsfehler berechnet. Dies ist nur ein quadratischer Fehler, daher scheint es nicht so schwierig zu sein.

python

#Anomale Bewertungsfunktion, die den höchsten Fehler zwischen der ursprünglichen Merkmalsmenge und der neu rekonstruierten Merkmalsmengenmatrix berechnet
#Berechnen und normalisieren Sie die Summe der quadratischen Fehler zwischen 0 und 1
#Nahe 1 ist abnormal, nahe 0 ist 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

Als nächstes folgt die Funktion, die die Präzisionsrückrufratenkurve und die AUC-Kurve zeichnet.

python

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

  #Konformitätsrate bei jedem Schwellenwert(precision)Und erinnere dich(recall)Berechnung
  precision, recall, thresholds = precision_recall_curve(preds["trueLabel"],preds["anomalyScore"])
  average_precision = average_precision_score(preds["trueLabel"],preds["anomalyScore"])

  #Compliance-Rate-Rückrufkurve
  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)
 
 #AUC-Kurve
  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

Diese Funktion erstellt einen Datenrahmen, in dem die Bezeichnungen der richtigen Antwortdaten und Ausreißer gespeichert sind. Die Schlüsselfunktionen sind ** precision_recall_curve und roc_curve **.

** präzise_recall_curve ist eine Funktion, die die Genauigkeit und den Rückruf berechnet, wenn der Schwellenwert von 1 auf 0 geändert wird **.

Wenn beispielsweise der Schwellenwert 0 ist, werden alle 0 und höher als Fehler beurteilt. Mit anderen Worten, alles wird als Fehler beurteilt. In diesem Fall ist die Genauigkeit 0 und der Rückruf 1. Dies ist eine praktische Funktion, die dies für jeden Schwellenwert berechnet.

** roc_curve berechnet die False Positive Rate und die True Positive Rate für jeden Schwellenwert **.

Wenn beispielsweise der Schwellenwert 0 ist, werden alle 0 und höher als positiv beurteilt. Dann ist die wahre positive Rate 1, weil es 0 falsche negative gibt. Außerdem beträgt die Falsch-Positiv-Rate 1, da keine echten Negative vorliegen. Es ist eine praktische Funktion, die das Verhältnis bei verschiedenen Schwellenwerten wie diesem bestimmt.

Bewertungsergebnis der Anomalieerkennung durch Auto-Encoder

Dann ist es das Bewertungsergebnis des Auto-Encoders, das tatsächlich früher implementiert wurde.

Zunächst aus dem Diagramm des Präzisionsrückrufs. Wenn die Rückrufrate auf der horizontalen Achse 75% beträgt, beträgt der Wert der Präzisionsrate auf der vertikalen Achse etwa 60%. Dies bedeutet, dass ** 75% der betrügerischen Nutzung erfasst werden können und 60% der auf diese Weise erfassten betrügerischen Nutzung tatsächlich betrügerische Daten sind **.

Als nächstes folgt die Au-ROC-Kurve. Es ist ein Index, um die wahre positive Rate zu erhöhen und gleichzeitig die falsche positive Rate niedrig zu halten. Der Index betrug zu diesem Zeitpunkt 0,92.

Aus diesen Ergebnissen wurde herausgefunden, dass eine ** Klassifizierung bis zu einem gewissen Grad ohne Training unter Verwendung korrekter Antwortdaten ** möglich ist. Zum Lernen, um die Genauigkeit weiter zu verbessern

• Ausfall einführen --Ändern Sie die Aktivierungsfunktion --Ändern Sie die Anzahl der Knoten beim Komprimieren

Es wird berücksichtigt.

Am Ende

Die Stärken des unbeaufsichtigten Lernens liegen darin, dass es ohne eine große Menge an Etikettendaten erlernt werden kann und flexibel auf Änderungen der Daten reagiert.

Persönlich finde ich es interessant, die Struktur hinter den Daten durch maschinelles Lernen zu verstehen. Wie um alles in der Welt lernst du ... Es ist eine Welt, die schwer vorstellbar und verbalisierbar ist.

Das Buch identifiziert nicht nur andere Dinge, sondern bietet auch Möglichkeiten, die Daten tatsächlich zu generieren. (Begrenzte Boltzmann-Maschine, Deep Learning, GAN usw.)

Ich hoffe, es wird für das Lernen aller hilfreich sein.