1. Übersicht
In diesem Lab erstellen und trainieren Sie mit AI Platform Notebooks ein Modell zur Identifizierung betrügerischer Transaktionen. Außerdem lernen Sie die Vorhersagen des Modells mit dem Explainable AI SDK kennen. Die Betrugserkennung ist eine Art der Anomalieerkennung speziell für Finanzdienstleistungen und stellt einige interessante Herausforderungen für ML-Modelle dar: inhärent unausgeglichene Datasets und die Notwendigkeit, die Ergebnisse eines Modells zu erklären.
Lerninhalte
Die folgenden Themen werden behandelt:
- Unausgeglichene Datasets verarbeiten
- Betrugserkennungsmodell mit tf.keras in AI Platform Notebooks erstellen und bewerten
- Verwenden Sie das Explainable AI SDK aus dem Notebook, um zu verstehen, warum das Modell Transaktionen als betrügerisch klassifiziert hat
- Modell mit Erläuterungen in AI Platform bereitstellen und Vorhersagen und Erläuterungen zum bereitgestellten Modell abrufen
Die Gesamtkosten für das Lab in Google Cloud belaufen sich auf 1$.
2. Vorteile der Betrugserkennung
Die Anomalieerkennung kann ein guter Kandidat für maschinelles Lernen sein, da es oft schwierig ist, eine Reihe regelbasierter Anweisungen zu schreiben, um Ausreißer in Daten zu identifizieren. Die Betrugserkennung ist eine Art der Anomalieerkennung, die beim maschinellen Lernen zwei interessante Herausforderungen mit sich bringt:
- Sehr unausgeglichene Datasets: Da Anomalien, nun ja, Anomalien sind, gibt es nicht viele davon. ML funktioniert am besten, wenn Datasets ausgewogen sind. So kann es kompliziert werden, wenn Ausreißer weniger als 1% Ihrer Daten ausmachen.
- Die Ergebnisse müssen erklärt werden: Wenn Sie nach betrügerischen Aktivitäten suchen, möchten Sie wahrscheinlich wissen, warum ein System etwas als betrügerisch markiert hat, anstatt es einfach zu verraten. Erklärbarkeitstools können Ihnen dabei helfen.
3. Richten Sie Ihre Umgebung ein.
Sie benötigen ein Google Cloud Platform-Projekt mit aktivierter Abrechnung, um dieses Codelab auszuführen. Folgen Sie dieser Anleitung, um ein Projekt zu erstellen.
Schritt 1: Cloud AI Platform Models API aktivieren
Rufen Sie in der Cloud Console den Bereich AI Platform-Modelle auf und klicken Sie auf „Aktivieren“, falls die Option noch nicht aktiviert ist.
Schritt 2: Compute Engine API aktivieren
Gehen Sie zu Compute Engine und wählen Sie Aktivieren aus, falls dies noch nicht geschehen ist. Sie benötigen dies zum Erstellen Ihrer Notebookinstanz.
Schritt 3: AI Platform Notebooks-Instanz erstellen
Rufen Sie in der Cloud Console den Bereich AI Platform Notebooks auf und klicken Sie auf Neue Instanz. Wählen Sie dann den Instanztyp TensorFlow Enterprise 2.1 ohne GPUs aus:
Verwenden Sie die Standardoptionen und klicken Sie dann auf Erstellen. Nachdem die Instanz erstellt wurde, wählen Sie JupyterLab öffnen aus:
Wählen Sie beim Öffnen der Instanz das Python 3-Notebook aus dem Launcher aus:
Schritt 4: Python-Pakete importieren
Erstellen Sie eine neue Zelle und importieren Sie die Bibliotheken, die wir in diesem Codelab verwenden:
import itertools
import numpy as np
import pandas as pd
import tensorflow as tf
import json
import matplotlib as mpl
import matplotlib.pyplot as plt
import explainable_ai_sdk
from sklearn.utils import shuffle
from sklearn.metrics import confusion_matrix
from sklearn.preprocessing import StandardScaler
from tensorflow import keras
from explainable_ai_sdk.metadata.tf.v2 import SavedModelMetadataBuilder
4. Daten herunterladen und verarbeiten
Wir verwenden dieses synthetisch generierte Dataset von Kaggle, um unser Modell zu trainieren. Das ursprüngliche Dataset enthält 6,3 Millionen Zeilen, von denen 8.000 betrügerische Transaktionen sind – nur 0,1% des gesamten Datasets!
Schritt 1: Kaggle-Dataset herunterladen und mit Pandas lesen
Wir stellen Ihnen das Kaggle-Dataset in Google Cloud Storage zur Verfügung. Sie können es herunterladen, indem Sie den folgenden gsutil-Befehl in Ihrem Jupyter-Notebook ausführen:
!gsutil cp gs://financial_fraud_detection/fraud_data_kaggle.csv .
Als Nächstes lesen wir das Dataset als Pandas DataFrame und zeigen eine Vorschau an:
data = pd.read_csv('fraud_data_kaggle.csv')
data = data.drop(columns=['type'])
data.head()
In der Vorschau sollte in etwa Folgendes angezeigt werden:
Schritt 2: Unausgeglichene Daten berücksichtigen
Wie bereits erwähnt, enthält das Dataset derzeit 99,9% der Beispiele, die nicht betrügerisch sind. Wenn wir ein Modell mit den Daten so trainieren, wie es ist, wird es wahrscheinlich eine Genauigkeit von 99,9% erreichen, indem es errät, dass jede Transaktion keine betrügerische Transaktion ist, nur weil 99,9% der Daten nicht betrügerisch sind.
Es gibt verschiedene Ansätze für den Umgang mit unausgewogenen Daten. Hier verwenden wir ein Verfahren namens Downsampling. Downsampling bedeutet, dass nur ein kleiner Teil der Mehrheitsklasse für das Training verwendet wird. In diesem Fall „ohne Betrug“ ist die Mehrheitsklasse, da sie 99,9% der Daten ausmacht.
Zur Verkleinerung unseres Datasets nehmen wir alle ca. 8.000 betrügerischen Beispiele und eine Zufallsstichprobe von ca. 31.000 Fällen, bei denen es sich nicht um Betrug handelt. Auf diese Weise enthält das resultierende Dataset 25% Betrugsfälle im Vergleich zu den 0, 1% zuvor.
Teilen Sie die Daten zunächst in zwei DataFrames auf, einen für Betrug und einen für den Schutz vor Betrug. (Wir werden diese später im Codelab verwenden, wenn wir unser Modell bereitstellen):
fraud = data[data['isFraud'] == 1]
not_fraud = data[data['isFraud'] == 0]
Nehmen Sie dann eine Zufallsstichprobe der Fälle, die kein Betrug sind. Wir verwenden 0,005 %, da wir so eine Aufteilung von 25/75 zwischen Betrug und nicht betrügerischen Transaktionen erhalten. Damit können Sie die Daten wieder zusammenführen und mischen. Zur Vereinfachung entfernen wir auch einige Spalten, die wir nicht für das Training verwenden:
# Take a random sample of non fraud rows
not_fraud_sample = not_fraud.sample(random_state=2, frac=.005)
# Put it back together and shuffle
df = pd.concat([not_fraud_sample,fraud])
df = shuffle(df, random_state=2)
# Remove a few columns (isFraud is the label column we'll use, not isFlaggedFraud)
df = df.drop(columns=['nameOrig', 'nameDest', 'isFlaggedFraud'])
# Preview the updated dataset
df.head()
Jetzt haben wir ein viel ausgewogeneres Dataset. Wenn wir jedoch feststellen, dass unser Modell ungefähr 75% Genauigkeit erreicht, ist es sehr wahrscheinlich, dass es als „kein Betrug“ rät. in jedem Fall.
Schritt 3: Daten in Trainings- und Test-Datasets aufteilen
Der letzte Schritt vor dem Erstellen des Modells ist das Aufteilen der Daten. Wir verwenden eine Trainings-/Testaufteilung von 80/20:
train_test_split = int(len(df) * .8)
train_set = df[:train_test_split]
test_set = df[train_test_split:]
train_labels = train_set.pop('isFraud')
test_labels = test_set.pop('isFraud')
*E) A. Lopez-Rojas , A. Elmir und S. Axelsson. „PaySim: A Financial Mobile Money Simulator for Fraud Detection“. In: The 28th European Modeling and Simulation Symposium-EMSS, Larnaka, Zypern. 2016
5. tf.keras-Modell erstellen, trainieren und bewerten
Wir erstellen den Build mit der tf.keras API von TensorFlow. Der Modellcode in diesem Abschnitt basiert auf dieser Anleitung aus der TensorFlow-Dokumentation. Zuerst normalisieren wir die Daten. Dann erstellen und trainieren wir unser Modell. Dabei verwenden wir den Parameter class_weight, um das verbleibende Datenungleichgewicht zu berücksichtigen.
Schritt 1: Daten normalisieren
Beim Trainieren eines Modells mit numerischen Daten ist es wichtig, die Daten zu normalisieren, insbesondere wenn jede Spalte in einen anderen Bereich fällt. Dies kann dazu beitragen, zu verhindern, dass Verluste während des Trainings explodieren. Wir können unsere Daten so normalisieren:
scaler = StandardScaler()
train_set = scaler.fit_transform(train_set) # Only normalize on the train set
test_set = scaler.transform(test_set)
# clip() ensures all values fall within the range [-5,5]
# useful if any outliers remain after normalizing
train_set = np.clip(train_set, -5, 5)
test_set = np.clip(test_set, -5, 5)
Sehen wir uns dann eine Vorschau der normalisierten Daten an:
train_set
Schritt 2: Klassengewichtungen festlegen
Beim Downsampling der Daten wollten wir dennoch einen Teil der nicht betrügerischen Transaktionen beibehalten, damit wir keine Informationen zu diesen Transaktionen verloren haben, weshalb wir keine vollständige Ausgewogenheit der Daten boten. Da das Dataset immer noch unausgewogen ist und uns die korrekte Identifizierung betrügerischer Transaktionen wichtig ist, möchten wir, dass unser Modell betrügerischen Beispielen in unserem Dataset mehr Gewicht verleiht.
Mit dem Keras-Parameter class_weight können wir genau angeben, wie oft wir die Beispiele aus jeder Klasse gewichten möchten, je nachdem, wie oft sie im Dataset vorkommen:
weight_for_non_fraud = 1.0 / df['isFraud'].value_counts()[0]
weight_for_fraud = 1.0 / df['isFraud'].value_counts()[1]
class_weight = {0: weight_for_non_fraud, 1: weight_for_fraud}
Wir verwenden diese Variable beim Trainieren unseres Modells im nächsten Schritt.
Schritt 3: Modell trainieren und bewerten
Wir erstellen unser Modell mit der Keras Sequential Model API, mit der wir unser Modell als Ebenenstapel definieren können. Es gibt eine Reihe von Messwerten, die wir während des Trainings verfolgen. Sie helfen uns zu verstehen, wie unser Modell in jeder Klasse in unserem Dataset abschneidet.
METRICS = [
keras.metrics.TruePositives(name='tp'),
keras.metrics.FalsePositives(name='fp'),
keras.metrics.TrueNegatives(name='tn'),
keras.metrics.FalseNegatives(name='fn'),
keras.metrics.BinaryAccuracy(name='accuracy'),
keras.metrics.Precision(name='precision'),
keras.metrics.Recall(name='recall'),
keras.metrics.AUC(name='auc'),
]
def make_model(metrics = METRICS):
model = keras.Sequential([
keras.layers.Dense(
16, activation='relu',
input_shape=(train_set.shape[-1],)),
keras.layers.Dropout(0.5),
keras.layers.Dense(1, activation='sigmoid'),
])
model.compile(
optimizer=keras.optimizers.Adam(lr=1e-3),
loss=keras.losses.BinaryCrossentropy(),
metrics=metrics)
return model
Anschließend definieren wir einige globale Variablen für die Verwendung während des Trainings sowie einige Parameter für das vorzeitige Beenden.
EPOCHS = 100
BATCH_SIZE = 512
early_stopping = tf.keras.callbacks.EarlyStopping(
monitor='val_auc',
verbose=1,
patience=10,
mode='max',
restore_best_weights=True)
Schließlich rufen wir die oben definierte Funktion auf, um das Modell zu erstellen:
model = make_model()
model.summary()
Wir können unser Modell mit der fit()-Methode trainieren und die oben definierten Parameter übergeben:
results = model.fit(
train_set,
train_labels,
batch_size=BATCH_SIZE,
epochs=EPOCHS,
callbacks = [early_stopping],
validation_data=(test_set, test_labels),
class_weight=class_weight)
Das Training dauert einige Minuten.
Schritt 4: Modellmesswerte visualisieren
Nachdem wir nun ein trainiertes Modell haben, sehen wir uns an, wie unser Modell abgeschnitten hat, indem wir verschiedene Messwerte während unserer Trainingsphasen darstellen:
mpl.rcParams['figure.figsize'] = (12, 10)
colors = plt.rcParams['axes.prop_cycle'].by_key()['color']
def plot_metrics(history):
metrics = ['loss', 'auc', 'precision', 'recall']
for n, metric in enumerate(metrics):
name = metric.replace("_"," ").capitalize()
plt.subplot(2,2,n+1)
plt.plot(history.epoch, history.history[metric], color=colors[0], label='Train')
plt.plot(history.epoch, history.history['val_'+metric],
color=colors[0], linestyle="--", label='Val')
plt.xlabel('Epoch')
plt.ylabel(name)
if metric == 'loss':
plt.ylim([0, plt.ylim()[1]])
elif metric == 'auc':
plt.ylim([0.8,1])
else:
plt.ylim([0,1])
plt.legend()
plot_metrics(results)
Ihre Grafiken sollten in etwa so aussehen (aber nicht dasselbe):
Schritt 5: Wahrheitsmatrix drucken
Mit einer Wahrheitsmatrix lässt sich gut visualisieren, wie unser Modell im gesamten Test-Dataset abgeschnitten hat. Für jede Klasse wird der Prozentsatz der Testbeispiele angezeigt, die unser Modell richtig und falsch vorhergesagt hat. Scikit Learn verfügt über einige Dienstprogramme zum Erstellen und Darstellen von Wahrheitsmatrizen, die wir hier verwenden.
Am Anfang unseres Notebooks haben wir das Dienstprogramm confusion_matrix importiert. Um sie zu verwenden, erstellen wir zuerst eine Liste der Vorhersagen unseres Modells. Hier runden wir die von unserem Modell zurückgegebenen Werte so, dass diese Liste mit unserer Liste der Ground-Truth-Labels übereinstimmt:
predicted = model.predict(test_set)
y_pred = []
for i in predicted.tolist():
y_pred.append(int(round(i[0])))
Jetzt können wir dies zusammen mit unseren Ground-Truth-Labels in die confusion_matrix-Methode einspeisen:
cm = confusion_matrix(test_labels.values, y_pred)
print(cm)
Dies zeigt uns die absoluten Zahlen für die richtigen und falschen Vorhersagen unseres Modells in unserem Test-Dataset. Die Zahl oben links gibt an, wie viele Beispiele aus unserem Test-Dataset korrekt als betrügerisch vorhergesagt wurden. Die Zahl rechts unten gibt an, wie viele korrekt als betrügerisch vorhergesagt wurden. Diese Zahl ist für uns am wichtigsten. Sie können sehen, dass die Mehrzahl der Stichproben für jede Klasse korrekt vorhergesagt wurde.
Zur Vereinfachung der Visualisierung haben wir die plot_confusion_matrix-Funktion aus den Scikit Learn-Dokumenten angepasst. Definieren Sie die Funktion hier:
def plot_confusion_matrix(cm, classes,
normalize=False,
title='Confusion matrix',
cmap=plt.cm.Blues):
"""
This function prints and plots the confusion matrix.
Normalization can be applied by setting `normalize=True`.
"""
plt.imshow(cm, interpolation='nearest', cmap=cmap)
plt.title(title)
plt.colorbar()
tick_marks = np.arange(len(classes))
plt.xticks(tick_marks, classes, rotation=45)
plt.yticks(tick_marks, classes)
if normalize:
cm = np.round(cm.astype('float') / cm.sum(axis=1)[:, np.newaxis], 3)
thresh = cm.max() / 2.
for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
plt.text(j, i, cm[i, j],
horizontalalignment="center",
color="white" if cm[i, j] > thresh else "black")
plt.tight_layout()
plt.ylabel('True label')
plt.xlabel('Predicted label')
Erstellen Sie das Diagramm, indem Sie die Daten aus unserem Modell übergeben. Wir setzen normalize hier auf True, damit die Wahrheitsmatrix die Anzahl der richtigen und falschen Vorhersagen als Prozentsätze anzeigt:
classes = ['not fraud', 'fraud']
plot_confusion_matrix(cm, classes, normalize=True)
Die Ausgabe sieht ungefähr so aus (die genauen Zahlen können variieren):
Hier sehen wir,dass unser Modell etwa 85% der 1.594 betrügerischen Transaktionen aus unserem Test-Dataset korrekt vorhergesagt hat. Beachten Sie, dass der Schwerpunkt in diesem Lab nicht auf der Modellqualität liegt. Wenn Sie ein Betrugserkennungsmodell in der Produktion bereitstellen, sollten Sie für die Betrugsklasse wahrscheinlich eine Genauigkeit von mehr als 85% erreichen. In diesem Lab lernen Sie die Tools kennen, mit denen Sie Modelle erklären können, die mit unausgeglichenen Datasets trainiert wurden.
Als Nächstes verwenden wir das Explainable AI SDK, um zu verstehen, auf welche Features unser Modell sich für diese Vorhersagen verlässt.
6. Explainable AI SDK verwenden
Das Explainable AI SDK bietet Dienstprogrammmethoden, um Erläuterungen zu Ihrem Modell zu erhalten. Es ist in Tensorflow AI Platform Notebook-Instanzen vorinstalliert. Beachten Sie, dass wir es zu Beginn des Labs in unser Notebook importiert haben. Mit dem SDK können wir Feature-Attributionen von unserem Modell in der Notebookinstanz erhalten. Das bedeutet, dass wir unser Modell nicht in der Cloud bereitstellen müssen, um es zu verwenden.
In diesem Abschnitt exportieren wir das Modell, das wir gerade als Tensorflow-SavedModel trainiert haben, und verweisen dann das SDK auf die gespeicherten Modell-Assets, um Erläuterungen zu erhalten.
Schritt 1: Trainiertes Modell exportieren
Zuerst speichern wir unser Modell in einem Verzeichnis in unserer Notebook-Instanz:
model_dir = 'fraud_model'
tf.saved_model.save(model, model_dir)
Wenn Sie die Ordneransicht in der linken Seitenleiste Ihres Notebooks aktualisieren, sollte ein neues Verzeichnis namens fraud_model/ erstellt werden.
Schritt 2: Erklärungsmetadaten mit dem SDK abrufen
Als Nächstes verweisen wir das Explainable AI SDK auf dieses Verzeichnis. Dadurch werden Metadaten generiert, die für Modellerklärungen erforderlich sind. Die Methode get_metadata() zeigt Metadaten an, die das SDK aus Ihrem Modell ableitet, z. B. Eingabenamen:
model_builder = SavedModelMetadataBuilder(model_dir)
metadata = model_builder.get_metadata()
print(metadata)
Erklärbarkeit hilft uns, die Frage zu beantworten: „Warum hielt unser Modell dies für Betrug?“
Schritt 3: Referenz des Modells angeben
Bei tabellarischen Daten gibt der Explainable AI-Dienst Attributionswerte für jedes Feature zurück. Diese Werte geben an, wie stark sich ein bestimmtes Feature auf die Vorhersage ausgewirkt hat. Nehmen wir an, der Betrag einer bestimmten Transaktion hat dazu geführt, dass unser Modell die prognostizierte Betrugswahrscheinlichkeit um 0,2 % erhöht hat. Sie denken vielleicht „0,2% relativ zu was?“. Das bringt uns zum Konzept der Baseline.
Die Basislinie für unser Modell ist im Wesentlichen das, mit dem es verglichen wird. Wir wählen den Basiswert für jedes Feature in unserem Modell aus. Die Basisvorhersage wird folglich zu dem Wert, den unser Modell prognostiziert, wenn die Merkmale auf der Basislinie festgelegt sind.
Die Auswahl einer Referenz hängt von der Vorhersageaufgabe ab, die Sie lösen. Bei numerischen Features ist es üblich, den Medianwert der einzelnen Elemente in Ihrem Datensatz als Basislinie zu verwenden. Im Fall der Betrugserkennung ist dies jedoch nicht genau das, was wir wollen. Wir möchten Ihnen vor allem die Fälle erklären, in denen unser Modell eine Transaktion als betrügerisch einstuft. Das bedeutet, dass der Basisfall, den wir vergleichen möchten, nicht betrügerische Transaktionen sind.
Um dies zu berücksichtigen, verwenden wir die Medianwerte der nicht betrügerischen Transaktionen in unserem Dataset als Basis. Wir können den Medianwert ermitteln, indem wir den oben extrahierten DataFrame not_fraud_sample verwenden und ihn so skalieren, dass er mit den erwarteten Eingaben des Modells übereinstimmt:
not_fraud_sample = not_fraud_sample.drop(columns=['nameOrig', 'nameDest', 'isFlaggedFraud', 'isFraud'])
baseline = scaler.transform(not_fraud_sample.values)
baseline = np.clip(baseline, -5, 5)
baseline_values = np.median(baseline, axis=0)
Beachten Sie, dass wir keine Referenzen angeben müssen. Andernfalls verwendet das SDK 0 als Referenz für jeden Eingabewert, den unser Modell erwartet. In unserem Anwendungsfall zur Betrugserkennung ist es sinnvoll, eine Baseline anzugeben. Das gehen wir so vor:
input_name = list(metadata['inputs'])[0]
model_builder.set_numeric_metadata(input_name, input_baselines=[baseline_values.tolist()], index_feature_mapping=df.columns.tolist()[:6])
model_builder.save_metadata(model_dir)
Mit der oben beschriebenen Methode save_metadata() wurde im Verzeichnis unseres Modells eine Datei namens explanation_metadata.json erstellt. Wechseln Sie in Ihrem Notebook zum Verzeichnis „Fraud_model/“, um zu prüfen, ob die Datei erstellt wurde. Enthält Metadaten, die das SDK zum Generieren von Featureattributionen verwendet.
Schritt 4: Modellerklärungen abrufen
Wir können jetzt Feature-Attributionen für einzelne Beispiele abrufen. Dazu erstellen wir zuerst mithilfe des SDK einen lokalen Verweis auf unser Modell:
local_model = explainable_ai_sdk.load_model_from_local_path(
model_dir,
explainable_ai_sdk.SampledShapleyConfig()
)
Lassen Sie uns als Nächstes Vorhersagen und Erläuterungen zu unserem Modell anhand einer Beispieltransaktion abrufen, die als Betrügerisch klassifiziert werden sollte:
fraud_example = [0.722,0.139,-0.114,-0.258,-0.271,-0.305]
response = local_model.explain([{input_name: fraud_example}])
response[0].visualize_attributions()
Dadurch sollte eine Visualisierung erstellt werden, die so aussieht:
In diesem Beispiel stellt der anfängliche Kontostand des Kontos vor der Transaktion der wichtigste Indikator für Betrug dar und hat die Vorhersage unseres Modells von der Baseline um mehr als 0,5 gesteigert. Der Transaktionsbetrag, der daraus resultierende Kontostand im Zielkonto und der Schritt waren die nächsten wichtigen Indikatoren. Im Dataset wird der „Schritt“ stellt eine Zeiteinheit dar (ein Schritt entspricht 1 Stunde). Attributionswerte können auch negativ sein.
Der „Näherungsfehler“ der über den Visualisierungen gedruckt wird, lässt Sie wissen, wie sehr Sie der Erklärung vertrauen können. Im Allgemeinen bedeutet ein Fehler von mehr als 5 %, dass Sie sich möglicherweise nicht auf die Featureattributionen verlassen können. Denken Sie daran, dass Ihre Erläuterungen nur so gut sind wie die verwendeten Trainingsdaten und das verwendete Modell. Wenn Sie Ihre Trainingsdaten und Ihr Modell verbessern oder eine andere Modellreferenz ausprobieren, kann der Näherungsfehler verringert werden.
Sie können diesen Fehler möglicherweise auch reduzieren, indem Sie die Anzahl der in Ihrer Erklärungsmethode verwendeten Schritte erhöhen. Sie können dies mit dem SDK ändern, indem Sie Ihrer Erklärungskonfiguration einen path_count-Parameter hinzufügen (der Standardwert ist 10, wenn Sie nichts angeben):
local_model = explainable_ai_sdk.load_model_from_local_path(
model_dir,
explainable_ai_sdk.SampledShapleyConfig(path_count=20)
)
Bei diesem Modell gibt es noch viel mehr, was Sie mit Explainable AI tun können. Hier einige Ideen:
- Wir senden viele Beispiele an unser Modell und ermitteln den Durchschnitt der Attributionswerte, um festzustellen, ob bestimmte Funktionen insgesamt wichtiger sind. Wir könnten damit unser Modell verbessern und möglicherweise Funktionen entfernen, die nicht so wichtig sind.
- Falsch-positive Ergebnisse finden, die unser Modell als Betrug markiert, aber keine betrügerischen Transaktionen sind, und ihre Attributionswerte untersuchen
- Verwenden Sie eine andere Baseline und sehen Sie sich an, wie sich das auf die Attributionswerte auswirkt
🎉 Glückwunsch! 🎉
Sie haben gelernt, wie Sie unausgeglichene Daten berücksichtigen, ein TensorFlow-Modell so trainieren, dass betrügerische Transaktionen erkannt werden, und das Explainable AI SDK verwenden, um festzustellen, auf welche Features Ihr Modell sich am meisten verlässt, um individuelle Vorhersagen zu treffen. Wenn du möchtest, kannst du hier aufhören. Die Verwendung des SDK in einem Notebook soll den Modellentwicklungsprozess vereinfachen, da Sie Zugriff auf Erläuterungen erhalten, bevor Sie ein Modell bereitstellen. Wahrscheinlich möchten Sie ein Modell bereitstellen, mit dem Sie zufrieden sind, um Vorhersagen im großen Maßstab zu erhalten. Wenn das auf Sie zutrifft, fahren Sie mit dem optionalen nächsten Schritt fort. Wenn Sie fertig sind, fahren Sie mit dem Schritt Bereinigen fort.
7. Optional: Modell in AI Platform Prediction bereitstellen
In diesem Schritt erfahren Sie, wie Sie Ihr Modell in AI Platform Prediction bereitstellen.
Schritt 1: Kopieren Sie das gespeicherte Modellverzeichnis in einen Cloud Storage-Bucket.
Mit den zuvor ausgeführten SDK-Schritten haben Sie alles, was Sie zum Bereitstellen Ihres Modells in AI Platform benötigen. Zur Vorbereitung auf die Bereitstellung müssen Sie die SavedModel-Assets und die Erklärungsmetadaten in einem Cloud Storage-Bucket ablegen, den der Explainable AI-Dienst lesen kann.
Dazu definieren wir einige Umgebungsvariablen. Geben Sie in die Werte unten den Namen Ihres Google Cloud-Projekts und den Namen des Buckets ein, den Sie erstellen möchten (muss global eindeutig sein).
# Update these to your own GCP project and model
GCP_PROJECT = 'your-gcp-project'
MODEL_BUCKET = 'gs://storage_bucket_name'
Jetzt können Sie einen Storage-Bucket zum Speichern der exportierten TensorFlow-Modell-Assets erstellen. Wir verweisen AI Platform auf diesen Bucket, wenn wir das Modell bereitstellen.
Führen Sie den folgenden gsutil-Befehl in Ihrem Notebook aus, um einen Bucket zu erstellen:
!gsutil mb -l 'us-central1' $MODEL_BUCKET
Kopieren Sie dann Ihr lokales Modellverzeichnis in diesen Bucket:
!gsutil -m cp -r ./$model_dir/* $MODEL_BUCKET/explanations
Schritt 2: Modell bereitstellen
Als Nächstes definieren wir einige Variablen, die wir in unseren Bereitstellungsbefehlen verwenden:
MODEL = 'fraud_detection'
VERSION = 'v1'
model_path = MODEL_BUCKET + '/explanations'
Wir können das Modell mit dem folgenden gcloud-Befehl erstellen:
!gcloud ai-platform models create $MODEL --region=us-central1
Jetzt können wir unsere erste Version dieses Modells mit gcloud bereitstellen. Die Bereitstellung der Version dauert etwa 5 bis 10 Minuten:
!gcloud beta ai-platform versions create $VERSION \
--model $MODEL \
--origin $model_path \
--runtime-version 2.1 \
--framework TENSORFLOW \
--python-version 3.7 \
--machine-type n1-standard-4 \
--explanation-method 'sampled-shapley' \
--num-paths 10 \
--region=us-central1
Im Flag origin übergeben wir den Cloud Storage-Speicherort des gespeicherten Modells und der Metadatendatei. Explainable AI bietet derzeit zwei verschiedene Erklärungsmethoden für tabellarische Modelle. Hier verwenden wir Sampled Shapley. Der Parameter num-paths gibt die Anzahl der Pfade an, die für jedes Eingabefeature erfasst werden. Im Allgemeinen gilt: Je komplexer das Modell, desto mehr Näherungsschritte sind erforderlich, um eine angemessene Konvergenz zu erreichen.
Führen Sie den folgenden gcloud-Befehl aus, um zu prüfen, ob das Modell korrekt bereitgestellt wurde:
!gcloud ai-platform versions describe $VERSION --model $MODEL --region=us-central1
Der Status sollte READY sein.
Schritt 3: Vorhersagen und Erläuterungen für das bereitgestellte Modell abrufen
Zum Zweck der Erklärbarkeit ist es uns am wichtigsten, Fälle zu erklären, in denen unser Modell Betrug prognostiziert. Wir senden fünf Testbeispiele an unser Modell, bei denen es sich alles um betrügerische Transaktionen handelt.
Wir verwenden die Google Cloud CLI, um Vorhersagen abzurufen. Führen Sie den folgenden Code aus, um die Indizes aller Betrugsbeispiele aus unserem Test-Dataset abzurufen:
fraud_indices = []
for i,val in enumerate(test_labels):
if val == 1:
fraud_indices.append(i)
Als Nächstes speichern wir fünf Beispiele in dem von unserem Modell erwarteten Format und schreiben sie in eine Datei:
num_test_examples = 5
instances = []
for i in range(num_test_examples):
ex = test_set[fraud_indices[i]]
instances.append({input_name: ex.tolist()})
with open('prediction.json', 'a') as outputfile:
json.dump({"instances": instances}, outputfile)
Wir können diese fünf Beispiele mit gcloud an unser Modell senden:
!gcloud beta ai-platform explain \
--model=$MODEL \
--version=$VERSION \
--region='us-central1' \
--json-request=prediction.json
In der JSON-Antwort sehen Sie die Attributionswerte für jedes Feature in diesen Beispielen. Der Schlüssel example_score für jedes Beispiel enthält die Vorhersage des Modells – in diesem Fall die prozentuale Wahrscheinlichkeit, dass eine bestimmte Transaktion betrügerisch ist.
8. Bereinigen
Wenn Sie dieses Notebook weiterverwenden möchten, empfehlen wir Ihnen, es bei Nichtgebrauch auszuschalten. Wählen Sie in der Notebooks-UI in der Cloud Console das Notebook und dann Beenden aus:
Wenn Sie alle Ressourcen löschen möchten, die Sie in diesem Lab erstellt haben, löschen Sie einfach die Notebookinstanz, anstatt sie zu beenden.
Gehen Sie im Navigationsmenü der Cloud Console zu „Storage“ und löschen Sie beide Buckets, die Sie zum Speichern Ihrer Modell-Assets erstellt haben.