1. Übersicht
In diesem Lab verwenden Sie AI Platform Notebooks, um ein Modell zum Erkennen betrügerischer Transaktionen zu erstellen und zu trainieren. Außerdem lernen Sie, die Vorhersagen des Modells mit dem Explainable AI SDK zu interpretieren. Die Betrugserkennung ist eine Art der Anomalieerkennung, die speziell auf Finanzdienstleistungen zugeschnitten ist. Sie stellt ML-Modelle vor einige interessante Herausforderungen: von Natur aus unausgewogene Datasets und die Notwendigkeit, die Ergebnisse eines Modells zu erklären.
Lerninhalte
Die folgenden Themen werden behandelt:
- Umgang mit unausgeglichenen Datasets
- Betrugserkennungsmodell mit tf.keras in AI Platform Notebooks erstellen und bewerten
- Verwenden Sie das Explainable AI SDK im Notebook, um zu verstehen, warum das Modell Transaktionen als betrügerisch eingestuft hat.
- Modell mit Erklärungen in AI Platform bereitstellen und Vorhersagen und Erklärungen zum bereitgestellten Modell abrufen
Die Gesamtkosten für die Ausführung dieses Labs in Google Cloud betragen etwa 1$.
2. Warum Betrugserkennung?
Die Anomalieerkennung ist ein guter Anwendungsfall für maschinelles Lernen, 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 und stellt zwei interessante Herausforderungen für das maschinelle Lernen dar:
- Sehr unausgeglichene Datasets: Da Anomalien eben Anomalien sind, gibt es nicht viele davon. ML funktioniert am besten, wenn Datasets ausgeglichen sind. Es kann also kompliziert werden, wenn Ausreißer weniger als 1% Ihrer Daten ausmachen.
- 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 gekennzeichnet hat, anstatt sich nur darauf zu verlassen. Dabei können Tools zur Erklärbarkeit helfen.
3. Richten Sie Ihre Umgebung ein.
Für dieses Codelab benötigen Sie ein Google Cloud Platform-Projekt mit aktivierter Abrechnung. Folgen Sie dieser Anleitung, um ein Projekt zu erstellen.
Schritt 1: Cloud AI Platform Models API aktivieren
Rufen Sie in der Cloud Console den Abschnitt „AI Platform-Modelle“ auf und klicken Sie auf „Aktivieren“, falls die API noch nicht aktiviert ist.
Schritt 2: Compute Engine API aktivieren
Rufen Sie Compute Engine auf und wählen Sie Aktivieren aus, falls die API noch nicht aktiviert ist. Sie benötigen diese, um Ihre Notebook-Instanz zu erstellen.
Schritt 3: AI Platform Notebooks-Instanz erstellen
Rufen Sie in der Cloud Console den Abschnitt „AI Platform Notebooks“ auf und klicken Sie auf Neue Instanz. Wählen Sie dann den Instanztyp TensorFlow Enterprise 2.1 ohne GPUs aus:
Übernehmen Sie die Standardoptionen und klicken Sie auf Erstellen. Nachdem die Instanz erstellt wurde, klicken Sie auf JupyterLab öffnen:
Wenn Sie die Instanz öffnen, wählen Sie im Launcher das Python 3-Notebook 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 haben das Kaggle-Dataset in Google Cloud Storage für Sie verfügbar gemacht. 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 den Datensatz als Pandas DataFrame und sehen uns eine Vorschau an:
data = pd.read_csv('fraud_data_kaggle.csv')
data = data.drop(columns=['type'])
data.head()
Die Vorschau sollte in etwa so aussehen:
Schritt 2: Ungleichgewicht in Daten berücksichtigen
Wie oben erwähnt, enthält das Dataset derzeit 99,9% nicht betrügerische Beispiele. Wenn wir ein Modell mit den Daten trainieren, wie sie sind, wird es wahrscheinlich eine Genauigkeit von 99,9% erreichen, indem es einfach davon ausgeht, dass jede Transaktion nicht betrügerisch ist, da 99,9% der Daten nicht betrügerische Fälle sind.
Es gibt verschiedene Ansätze für den Umgang mit unausgeglichenen Daten. Hier verwenden wir eine Technik namens Downsampling. Beim Downsampling wird nur ein kleiner Prozentsatz der Mehrheitsklasse für das Training verwendet. In diesem Fall ist „nicht betrügerisch“ die Mehrheitsklasse, da sie 99,9% der Daten ausmacht.
Um unser Dataset zu unterziehen, verwenden wir alle etwa 8.000 betrügerischen Beispiele und eine zufällige Stichprobe von etwa 31.000 nicht betrügerischen Fällen. Das resultierende Dataset enthält dann 25% Betrugsfälle im Vergleich zu den 0,1 %, die wir zuvor hatten.
Teilen Sie die Daten zuerst in zwei DataFrames auf, einen für Betrug und einen für Nicht-Betrug. Wir werden dies später im Codelab beim Bereitstellen unseres Modells verwenden:
fraud = data[data['isFraud'] == 1]
not_fraud = data[data['isFraud'] == 0]
Ziehen Sie dann eine zufällige Stichprobe der Fälle, die nicht betrügerisch sind. Wir verwenden 0,005 %, da dies zu einer Aufteilung von 25 % betrügerischen und 75 % nicht betrügerischen Transaktionen führt. So können Sie die Daten wieder zusammensetzen und mischen. Zur Vereinfachung werden auch einige Spalten entfernt, die nicht für das Training verwendet werden:
# 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 einen viel ausgewogeneren Datensatz. Wenn unser Modell jedoch eine Genauigkeit von etwa 75% erreicht, ist es wahrscheinlich, dass es in jedem Fall „nicht betrügerisch“ schätzt.
Schritt 3: Daten in Trainings- und Test-Datasets aufteilen
Bevor wir unser Modell erstellen, müssen wir unsere Daten aufteilen. Wir verwenden eine 80/20-Aufteilung in Trainings- und Testdaten:
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, Larnaca, Cyprus. 2016
5. tf.keras-Modell erstellen, trainieren und bewerten
Wir verwenden die 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 Ungleichgewicht der Daten zu berücksichtigen.
Schritt 1: Daten normalisieren
Wenn Sie ein Modell mit numerischen Daten trainieren, ist es wichtig, die Daten zu normalisieren, insbesondere wenn die einzelnen Spalten in unterschiedlichen Bereichen liegen. So kann verhindert werden, dass der Verlust während des Trainings explodiert. Wir können unsere Daten mit den folgenden Methoden 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 nun die normalisierten Daten in der Vorschau an:
train_set
Schritt 2: Klassengewichte festlegen
Beim Downsampling der Daten wollten wir weiterhin eine Teilmenge der nicht betrügerischen Transaktionen beibehalten, damit wir keine Informationen zu diesen Transaktionen verlieren. Aus diesem Grund haben wir die Daten nicht perfekt ausgeglichen. Da der Datensatz immer noch unausgeglichen ist und wir vor allem betrügerische Transaktionen richtig identifizieren möchten, soll unser Modell betrügerischen Beispielen in unserem Datensatz mehr Gewicht verleihen.
Mit dem Keras-Parameter class_weight können wir genau angeben, wie viel Gewicht wir Beispielen aus jeder Klasse geben möchten, basierend darauf, 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 im nächsten Schritt, wenn wir unser Modell trainieren.
Schritt 3: Modell trainieren und bewerten
Wir erstellen unser Modell mit der Keras Sequential Model API, mit der wir unser Modell als Stapel von Layern definieren können. Während des Trainings werden verschiedene Messwerte erfasst, anhand derer wir die Leistung unseres Modells für jede Klasse in unserem Dataset nachvollziehen können.
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, die während des Trainings verwendet werden, 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)
Abschließend rufen wir die oben definierte Funktion auf, um unser Modell zu erstellen:
model = make_model()
model.summary()
Wir können unser Modell mit der Methode fit() 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 ein trainiertes Modell haben, sehen wir uns an, wie es abgeschnitten hat. Dazu stellen wir verschiedene Messwerte über die Trainingsepochen hinweg dar:
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 (sind aber nicht exakt gleich):
Schritt 5: Wahrheitsmatrix ausgeben
Eine Wahrheitsmatrix ist eine gute Möglichkeit, die Leistung unseres Modells im Test-Dataset zu visualisieren. Für jede Klasse wird der Prozentsatz der Testbeispiele angezeigt, die das Modell richtig und falsch vorhergesagt hat. Scikit-Learn bietet einige Dienstprogramme zum Erstellen und Darstellen von Konfusionsmatrizen, die wir hier verwenden.
Am Anfang des Notebooks haben wir das confusion_matrix-Dienstprogramm importiert. Dazu erstellen wir zuerst eine Liste der Vorhersagen unseres Modells. Hier runden wir die von unserem Modell zurückgegebenen Werte, damit 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 diese Daten zusammen mit unseren Ground-Truth-Labels in die Methode confusion_matrix einfügen:
cm = confusion_matrix(test_labels.values, y_pred)
print(cm)
Hier sehen wir die absoluten Zahlen der richtigen und falschen Vorhersagen unseres Modells für unseren Testsatz. Die Zahl oben links gibt an, wie viele Beispiele aus unserem Test-Dataset unser Modell korrekt als nicht betrügerisch vorhergesagt hat. Die Zahl unten rechts gibt an, wie viele Transaktionen korrekt als betrügerisch vorhergesagt wurden. Das ist die wichtigste Zahl. Sie sehen, dass die meisten Stichproben für jede Klasse richtig vorhergesagt wurden.
Um dies zu veranschaulichen, haben wir die plot_confusion_matrix-Funktion aus der Scikit-Learn-Dokumentation übernommen. 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')
Und erstellen Sie das Diagramm, indem Sie ihm die Daten aus unserem Modell übergeben. Wir setzen normalize hier auf True, damit in der Wahrheitsmatrix die Anzahl der richtigen und falschen Vorhersagen als Prozentsätze angezeigt wird:
classes = ['not fraud', 'fraud']
plot_confusion_matrix(cm, classes, normalize=True)
Die Ausgabe sollte etwa so aussehen (die genauen Zahlen können abweichen):
Hier sehen wir,dass unser Modell etwa 85% der 1.594 betrügerischen Transaktionen aus unserem Testsatz korrekt vorhergesagt hat. In diesem Lab geht es nicht um die Modellqualität. Wenn Sie ein Betrugserkennungsmodell in der Produktion bereitstellen, möchten Sie wahrscheinlich eine Genauigkeit von mehr als 85% für die Betrugsklasse. In diesem Lab lernen Sie die Tools kennen, mit denen sich Modelle erklären lassen, die mit unausgewogenen Datasets trainiert wurden.
Als Nächstes verwenden wir das Explainable AI SDK, um zu ermitteln, auf welche Features sich unser Modell bei diesen Vorhersagen stützt.
6. Explainable AI SDK verwenden
Das Explainable AI SDK bietet Hilfsmethoden zum Abrufen von Erläuterungen zu Ihrem Modell. Es ist auf TensorFlow AI Platform Notebook-Instanzen vorinstalliert. Wir haben es zu Beginn des Labs in unser Notebook importiert. Mit dem SDK können wir Feature-Beiträge aus unserem Modell in der Notebook-Instanz abrufen. Das bedeutet, dass wir unser Modell nicht in der Cloud bereitstellen müssen, um es zu verwenden.
In diesem Abschnitt exportieren wir das gerade trainierte Modell als TensorFlow SavedModel und verweisen dann mit dem SDK auf unsere gespeicherten Modell-Assets, um Erklärungen zu erhalten.
Schritt 1: Trainiertes Modell exportieren
Speichern wir das Modell zuerst 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 mit dem Namen fraud_model/ angezeigt werden.
Schritt 2: Metadaten für Erklärungen mit dem SDK abrufen
Als Nächstes verweisen wir das Explainable AI SDK auf dieses Verzeichnis. Dadurch werden Metadaten generiert, die für die Erläuterungen des Modells 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)
Mithilfe der Erklärbarkeit können wir die Frage beantworten: „Warum hat unser Modell diese Transaktion als betrügerisch eingestuft?“
Schritt 3: Baseline des Modells festlegen
Bei tabellarischen Daten gibt der Explainable AI-Dienst Attributionswerte für jedes Feature zurück. Diese Werte geben an, wie stark ein bestimmtes Feature die Vorhersage beeinflusst hat. Angenommen, der Betrag einer bestimmten Transaktion hat dazu geführt, dass unser Modell die vorhergesagte Wahrscheinlichkeit für Betrug um 0,2 % erhöht hat. Sie fragen sich vielleicht: „0,2% relativ zu was?“ Das bringt uns zum Konzept der Baseline.
Die Baseline für unser Modell ist im Grunde das, womit es verglichen wird. Wir wählen den Basiswert für jedes Feature in unserem Modell aus. Die Basisvorhersage ist dann der Wert, den unser Modell vorhersagt, wenn die Features auf den Basiswert festgelegt sind.
Die Auswahl einer Baseline hängt von der Vorhersageaufgabe ab, die Sie lösen möchten. Bei numerischen Features wird häufig der Medianwert jedes Features in Ihrem Dataset als Baseline verwendet. Bei der Betrugserkennung ist das jedoch nicht genau das, was wir wollen. Wir möchten vor allem erklären, wann unser Modell eine Transaktion als betrügerisch kennzeichnet. Das bedeutet, dass wir nicht betrügerische Transaktionen als Baseline-Szenario für den Vergleich verwenden.
Um dies zu berücksichtigen, verwenden wir die Medianwerte der nicht betrügerischen Transaktionen in unserem Dataset als Baseline. Wir können den Median mit dem oben extrahierten DataFrame not_fraud_sample abrufen und ihn so skalieren, dass er den erwarteten Eingaben unseres Modells entspricht:
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 Baseline angeben müssen. Andernfalls verwendet das SDK 0 als Baseline für jeden Eingabewert, den unser Modell erwartet. In unserem Anwendungsfall zur Betrugserkennung ist es sinnvoll, eine Baseline festzulegen. Das tun wir im Folgenden:
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)
Durch Ausführen der Methode save_metadata() oben wurde im Verzeichnis unseres Modells eine Datei mit dem Namen explanation_metadata.json erstellt. Rufen Sie in Ihrem Notebook das Verzeichnis „fraud_model/“ auf, um zu prüfen, ob die Datei erstellt wurde. Diese enthält Metadaten, die vom SDK zum Generieren von Attributen für Funktionen verwendet werden.
Schritt 4: Erklärungen für das Modell abrufen
Jetzt können wir Attributionswerte für einzelne Beispiele abrufen. Dazu erstellen wir zuerst mit dem SDK einen lokalen Verweis auf unser Modell:
local_model = explainable_ai_sdk.load_model_from_local_path(
model_dir,
explainable_ai_sdk.SampledShapleyConfig()
)
Als Nächstes rufen wir Vorhersagen und Erläuterungen für unser Modell anhand einer Beispieltransaktion ab, 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()
Wenn Sie diesen Code ausführen, sollte eine Visualisierung wie die folgende erstellt werden:
In diesem Beispiel war der ursprüngliche Kontostand des Kontos vor der Transaktion der größte Indikator für Betrug, der die Vorhersage unseres Modells um mehr als 0, 5 über den Baseline-Wert hinaus erhöhte. Der Transaktionsbetrag, der resultierende Saldo auf dem Zielkonto und der Schritt waren die nächstgrößten Indikatoren. Im Dataset stellt der „Schritt“ eine Zeiteinheit dar (1 Schritt entspricht 1 Stunde). Attributionswerte können auch negativ sein.
Der „Näherungsfehler“, der über den Visualisierungen angezeigt wird, gibt an, wie zuverlässig die Erklärung ist. Wenn der Fehler über 5% liegt, können Sie sich in der Regel nicht auf die Attributionen der Funktion verlassen. Denken Sie daran, dass Ihre Erklärungen nur so gut sind wie die Trainingsdaten und das Modell, das Sie verwendet haben. Sie können den Näherungsfehler verringern, indem Sie Ihre Trainingsdaten oder Ihr Modell verbessern oder eine andere Modell-Baseline verwenden.
Sie können diesen Fehler möglicherweise auch verringern, indem Sie die Anzahl der Schritte in Ihrer Erklärungsmethode erhöhen. Sie können dies im SDK ändern, indem Sie Ihrer Erklärungskonfiguration einen path_count-Parameter hinzufügen (der Standardwert ist 10, wenn Sie ihn nicht angeben):
local_model = explainable_ai_sdk.load_model_from_local_path(
model_dir,
explainable_ai_sdk.SampledShapleyConfig(path_count=20)
)
Mit Explainable AI können Sie noch viel mehr mit diesem Modell machen. Hier sind ein paar Ideen:
- Viele Beispiele an unser Modell senden und die Attributionswerte mitteln, um zu sehen, ob bestimmte Features insgesamt wichtiger sind. Wir könnten diese Informationen nutzen, um unser Modell zu verbessern und möglicherweise unwichtige Features zu entfernen.
- Falsch positive Ergebnisse finden, die von unserem Modell als betrügerisch gekennzeichnet werden, aber keine betrügerischen Transaktionen sind, und die entsprechenden Attributionswerte untersuchen
- Eine andere Baseline verwenden und sehen, wie sich das auf die Attributionswerte auswirkt
🎉 Das wars! 🎉
Sie haben gelernt, wie Sie unausgeglichene Daten berücksichtigen, ein TensorFlow-Modell zum Erkennen betrügerischer Transaktionen trainieren und mit dem Explainable AI SDK sehen, auf welche Funktionen sich Ihr Modell am meisten stützt, um einzelne Vorhersagen zu treffen. Sie können hier aufhören, wenn Sie möchten. Die Verwendung des SDK in einem Notebook soll den Modellentwicklungsprozess vereinfachen, indem Sie vor der Bereitstellung eines Modells auf Erläuterungen zugreifen können. Wenn Sie ein Modell erstellt haben, mit dem Sie zufrieden sind, möchten Sie es wahrscheinlich bereitstellen, um Vorhersagen im großen Maßstab zu erhalten. Wenn das auf dich zutrifft, fahre 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: Gespeichertes Modellverzeichnis in einen Cloud Storage-Bucket kopieren
Mit den SDK-Schritten, die wir zuvor ausgeführt haben, haben Sie alles, was Sie zum Bereitstellen Ihres Modells in AI Platform benötigen. Zur Vorbereitung auf die Bereitstellung müssen Sie Ihre SavedModel-Assets und Erklärungsmetadaten in einem Cloud Storage-Bucket ablegen, auf den der Explainable AI-Dienst zugreifen kann.
Dazu definieren wir einige Umgebungsvariablen. Geben Sie 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 wir einen Storage-Bucket erstellen, in dem die exportierten TensorFlow-Modell-Assets gespeichert werden. Wir verweisen AI Platform auf diesen Bucket, wenn wir das Modell bereitstellen.
Führen Sie diesen 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 werden:
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 die erste Version dieses Modells mit gcloud bereitstellen. Die Bereitstellung der Version dauert etwa 5–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
Mit dem Flag origin übergeben wir den Cloud Storage-Speicherort unseres gespeicherten Modells und der Metadatendatei. Für tabellarische Modelle sind derzeit zwei verschiedene Explainable AI-Methoden verfügbar. Hier verwenden wir Sampled Shapley. Der Parameter num-paths gibt die Anzahl der Pfade an, die für jedes Eingabe-Feature gezogen werden. Je komplexer das Modell ist, desto mehr Approximationsschritte sind in der Regel erforderlich, um eine angemessene Konvergenz zu erreichen.
Führen Sie den folgenden gcloud-Befehl aus, um zu prüfen, ob Ihr 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
Im Hinblick auf die Erklärbarkeit konzentrieren wir uns hauptsächlich auf die Fälle, in denen unser Modell Betrug vorhersagt. Wir senden fünf Testbeispiele an unser Modell, die alle betrügerische Transaktionen sind.
Wir verwenden die Google Cloud CLI, um Vorhersagen abzurufen. Führen Sie den folgenden Code aus, um die Indexe aller Betrugsbeispiele aus unserem Testsatz 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 im Format, das unser Modell erwartet, 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
Im Antwort-JSON sehen Sie die Attributionswerte für jedes Feature in diesen Beispielen. Der example_score-Schlüssel 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 weiterhin verwenden möchten, empfehlen wir, es auszuschalten, wenn Sie es nicht verwenden. Wählen Sie in der Notebooks-Benutzeroberfläche 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 Notebook-Instanz, anstatt sie zu beenden.
Rufen Sie in der Cloud Console über das Navigationsmenü „Storage“ auf und löschen Sie die beiden Buckets, die Sie zum Speichern Ihrer Modell-Assets erstellt haben.