1. Übersicht
In diesem Lab nehmen Sie ein BigQuery-Dataset direkt auf und trainieren ein Modell zur Betrugserkennung mit TensorFlow Enterprise auf der Google Cloud AI Platform.
Lerninhalte
Die folgenden Themen werden behandelt:
- Daten in BigQuery analysieren
- Daten mit dem BigQuery-Connector in TensorFlow Enterprise aufnehmen
- Deep-Learning-Modell zum Erkennen von Betrug mit einem unausgewogenen Dataset erstellen
2. Daten in BigQuery analysieren
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: Auf das öffentliche BigQuery-Dataset zugreifen
Über diesen Link können Sie in der Google Cloud Console auf öffentliche BigQuery-Datasets zugreifen.
Im Ressourcenbaum unten links sehen Sie eine Liste von Datasets. Suchen Sie in den verfügbaren Datasets nach ml-datasets und wählen Sie dann die Tabelle ulb-fraud-detection aus:
Klicken Sie auf die einzelnen Tabs, um mehr über den Datensatz zu erfahren:
- Auf dem Tab Schema werden die Datentypen beschrieben.
- Auf dem Tab Details wird erläutert,dass es sich um einen unausgewogenen Datensatz mit 284.407 Transaktionen handelt, von denen 492 betrügerisch sind.
- Auf dem Tab Vorschau werden Datensätze aus dem Dataset angezeigt.
Schritt 2: Tabelle abfragen
Auf dem Tab „Details“ finden wir folgende Informationen zu den Daten:
- Zeit ist die Anzahl der Sekunden zwischen der ersten Transaktion im Dataset und der Zeit der ausgewählten Transaktion.
- V1–V28 sind Spalten, die mithilfe einer Dimensionsreduktionstechnik namens PCA transformiert wurden, wodurch die Daten anonymisiert wurden.
- Betrag ist der Transaktionsbetrag.
Klicken Sie auf Tabelle abfragen, um eine Abfrage auszuführen:
Aktualisieren Sie die Anweisung, um ein Sternchen (*) hinzuzufügen, damit alle Spalten angezeigt werden, und klicken Sie auf Ausführen.
SELECT * FROM `bigquery-public-data.ml_datasets.ulb_fraud_detection` LIMIT 1000
Schritt 3: Daten analysieren
BigQuery bietet eine Reihe von statistischen Funktionen. Sehen wir uns an, wie die Daten mit der Zielvariablen Class korrelieren.
SELECT CORR(Time,Class) as TimeCorr, CORR(V1,Class) as V1Corr, CORR(V2,Class) as V2Corr, CORR(Amount,Class) as AmountCorr FROM `bigquery-public-data.ml_datasets.ulb_fraud_detection`
Die Korrelation reicht von -1 (negativ korreliert) bis 1 (positiv korreliert). Bei 0 sind die Variablen unabhängig.
V1 und V2 weisen eine geringe Korrelation mit unserer Zielvariablen auf (etwa -0,1 bzw. 0,1).
Wir sehen keine große Korrelation mit Zeit. Eine leicht negative Korrelation könnte darauf hindeuten, dass im Laufe der Zeit weniger betrügerische Transaktionen im Datensatz vorhanden sind.
Der Betrag weist eine noch geringere Korrelation auf, was darauf hindeutet, dass betrügerische Transaktionen bei höheren Transaktionsbeträgen nur sehr geringfügig wahrscheinlicher sind.
Schritt 4: Mittelwerte für die Merkmalskalierung berechnen
Durch die Normalisierung von Feature-Werten kann ein neuronales Netzwerk schneller konvergieren. Ein gängiges Verfahren besteht darin, Werte mit einer Standardabweichung von 1 um 0 zu zentrieren. Mit der folgenden Abfrage werden die Mittelwerte abgerufen. Das Ergebnis muss nicht gespeichert werden, da wir später ein Code-Snippet dafür haben.
Die Abfrage enthält auch eine interessante WHERE-Klausel. Das wird im nächsten Abschnitt beschrieben, in dem es darum geht, wie die Daten in Trainings- und Testsets aufgeteilt werden.
SELECT
AVG(Time), AVG(V1), AVG(V2), AVG(V3), AVG(V4), AVG(V5), AVG(V6), AVG(V7), AVG(V8),
AVG(V9), AVG(V10),AVG(V11), AVG(V12), AVG(V13), AVG(V14), AVG(V15), AVG(V16),
AVG(V17), AVG(V18), AVG(V19), AVG(V20), AVG(V21), AVG(V22), AVG(V23), AVG(V24),
AVG(V25), AVG(V26), AVG(V27),AVG(V28), AVG(Amount)
FROM
`bigquery-public-data.ml_datasets.ulb_fraud_detection`
WHERE
MOD(ABS(FARM_FINGERPRINT(CONCAT(SAFE_CAST(Time AS STRING),
SAFE_CAST(Amount AS STRING)))),10) < 8
Schritt 5: Daten aufteilen
Beim Erstellen eines Modells für maschinelles Lernen werden in der Regel 3 Datasets verwendet:
- Training: Wird verwendet, um das Modell durch iteratives Anpassen von Parametern zu erstellen.
- Validierung: Wird verwendet, um zu prüfen, ob das Modell überangepasst ist. Dazu werden während des Trainingsprozesses unabhängige Daten verwendet.
- Test: Wird nach der Erstellung des Modells verwendet, um die Genauigkeit zu bewerten.
In diesem Codelab verwenden wir eine 80/10/10-Aufteilung für Training, Validierung und Tests.
Jedes Dataset wird in einer eigenen Tabelle in BigQuery gespeichert. Im ersten Schritt erstellen Sie ein BigQuery-Dataset, das als Container für zugehörige Tabellen dient. Wählen Sie Dataset erstellen aus, während Ihr Projekt ausgewählt ist.
Erstellen Sie dann ein Dataset mit dem Namen tfe_codelab, das die Trainings-, Validierungs- und Testtabellen enthält.
Nun führen wir drei Abfragen für Training, Test und Validierung aus und speichern die Daten im neuen Dataset tfe_codelab.
Führen Sie im Abfrageeditor eine Abfrage aus, um die Trainingsdaten zu generieren:
SELECT *
FROM `bigquery-public-data.ml_datasets.ulb_fraud_detection`
WHERE MOD(ABS(FARM_FINGERPRINT(CONCAT(SAFE_CAST(Time AS STRING),SAFE_CAST(Amount AS STRING)))),10) < 8
Wenn die Abfrage abgeschlossen ist, speichern Sie die Ergebnisse in einer BigQuery-Tabelle.
Geben Sie der Tabelle im Dataset tfe_codelab, das Sie gerade erstellt haben, den Namen ulb_fraud_detection_train und speichern Sie die Daten.
In der WHERE-Klausel werden die Daten zuerst aufgeteilt, indem ein Hash für einige Spalten berechnet wird. Anschließend werden Zeilen ausgewählt, in denen der Rest des Hashs bei Division durch 10 unter 80 liegt. Das entspricht 80%.
Wiederholen Sie nun denselben Vorgang für Validierungs- und Testsets mit ähnlichen Abfragen, mit denen jeweils 10% der Daten ausgewählt werden.
Validation
SELECT *
FROM `bigquery-public-data.ml_datasets.ulb_fraud_detection`
WHERE MOD(ABS(FARM_FINGERPRINT(CONCAT(SAFE_CAST(Time AS STRING),SAFE_CAST(Amount AS STRING)))),10) = 8
Speichern Sie die Ergebnisse dieser Abfrage in einer Tabelle mit dem Namen ulb_fraud_detection_val.
Test
SELECT *
FROM `bigquery-public-data.ml_datasets.ulb_fraud_detection`
WHERE MOD(ABS(FARM_FINGERPRINT(CONCAT(SAFE_CAST(Time AS STRING),SAFE_CAST(Amount AS STRING)))),10) = 9
Speichern Sie die Ergebnisse dieser Abfrage in einer Tabelle mit dem Namen ulb_fraud_detection_test.
3. Notebook-Umgebung einrichten
Nachdem wir uns die Daten kurz angesehen haben, richten wir nun unsere Umgebung für die Modellentwicklung ein.
Schritt 1: APIs aktivieren
Der BigQuery-Connector verwendet die BigQuery Storage API. Suchen Sie in der Konsole nach der BigQuery Storage API und aktivieren Sie sie, falls sie derzeit deaktiviert ist.
Schritt 2: 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 aktuellen Instanztyp TensorFlow Enterprise 1.x ohne GPUs aus:
Übernehmen Sie die Standardoptionen und klicken Sie auf Erstellen. Nachdem die Instanz erstellt wurde, klicken Sie auf JupyterLab öffnen:
Erstellen Sie dann ein Python 3-Notebook in JupyterLab:
4. Datensätze aus BigQuery aufnehmen
Schritt 1: Python-Pakete importieren
Fügen Sie in der ersten Zelle Ihres Notebooks die folgenden Importe hinzu und führen Sie die Zelle aus. Sie können es ausführen, indem Sie im oberen Menü auf die Rechtspfeiltaste oder auf die Tastenkombination „Befehl + Eingabetaste“ drücken:
import tensorflow as tf
import tensorflow.keras as keras
import tensorflow.keras.layers as layers
from tensorflow_io.bigquery import BigQueryClient
import functools
tf.enable_eager_execution()
Schritt 2: Konstanten definieren
Als Nächstes definieren wir einige Konstanten für die Verwendung im Projekt. Ersetzen Sie GCP_PROJECT_ID durch die tatsächliche Projekt-ID, die Sie verwenden. Führen Sie neue Zellen aus, sobald Sie sie erstellen.
GCP_PROJECT_ID = '<YOUR_PROJECT_ID>'
DATASET_GCP_PROJECT_ID = GCP_PROJECT_ID # A copy of the data is saved in the user project
DATASET_ID = 'tfe_codelab'
TRAIN_TABLE_ID = 'ulb_fraud_detection_train'
VAL_TABLE_ID = 'ulb_fraud_detection_val'
TEST_TABLE_ID = 'ulb_fraud_detection_test'
FEATURES = ['Time','V1','V2','V3','V4','V5','V6','V7','V8','V9','V10','V11','V12','V13','V14','V15','V16','V17','V18','V19','V20','V21','V22','V23','V24','V25','V26','V27','V28','Amount']
LABEL='Class'
DTYPES=[tf.float64] * len(FEATURES) + [tf.int64]
Schritt 3: Hilfsfunktionen definieren
Definieren wir nun einige Funktionen. Mit read_session() werden Daten aus einer BigQuery-Tabelle gelesen. extract_labels() ist eine Hilfsfunktion, mit der die Labelspalte vom Rest getrennt wird, sodass das Dataset später das von keras.model_fit() erwartete Format hat.
client = BigQueryClient()
def read_session(TABLE_ID):
return client.read_session(
"projects/" + GCP_PROJECT_ID, DATASET_GCP_PROJECT_ID, TABLE_ID, DATASET_ID,
FEATURES + [LABEL], DTYPES, requested_streams=2
)
def extract_labels(input_dict):
features = dict(input_dict)
label = tf.cast(features.pop(LABEL), tf.float64)
return (features, label)
Schritt 4: Daten aufnehmen
Erstellen wir nun die einzelnen Datasets und geben dann den ersten Batch aus dem Trainingsdataset aus. Wir haben eine BATCH_SIZE von 32 definiert. Dieser Parameter ist wichtig, da er sich auf die Geschwindigkeit und Genauigkeit des Trainings auswirkt.
BATCH_SIZE = 32
raw_train_data = read_session(TRAIN_TABLE_ID).parallel_read_rows().map(extract_labels).batch(BATCH_SIZE)
raw_val_data = read_session(VAL_TABLE_ID).parallel_read_rows().map(extract_labels).batch(BATCH_SIZE)
raw_test_data = read_session(TEST_TABLE_ID).parallel_read_rows().map(extract_labels).batch(BATCH_SIZE)
next(iter(raw_train_data)) # Print first batch
5. Modell erstellen
Schritt 1: Daten vorverarbeiten
Erstellen wir Feature-Spalten für jedes Feature im Dataset. In diesem Dataset sind alle Spalten vom Typ numeric_column, es gibt aber auch eine Reihe anderer Spaltentypen,z.B. „categorical_column“.
Wie bereits erwähnt, werden wir die Daten auch normieren, sodass sie um null zentriert sind. Dadurch konvergiert das Netzwerk schneller. Wir haben die Mittelwerte der einzelnen Funktionen für diese Berechnung vorab berechnet.
MEANS = [94816.7387536405, 0.0011219465482001268, -0.0021445914636999603, -0.002317402958335562,
-0.002525792169927835, -0.002136576923287782, -3.7586818983702984, 8.135919975738768E-4,
-0.0015535579268265718, 0.001436137140461279, -0.0012193712736681508, -4.5364970422902533E-4,
-4.6175444671576083E-4, 9.92177789685366E-4, 0.002366229151475428, 6.710217226762278E-4,
0.0010325807119864225, 2.557260815835395E-4, -2.0804190062322664E-4, -5.057391100818653E-4,
-3.452114767842334E-6, 1.0145936326270006E-4, 3.839214074518535E-4, 2.2061197469126577E-4,
-1.5601580596677608E-4, -8.235017846415852E-4, -7.298316615408554E-4, -6.898459943652376E-5,
4.724125688297753E-5, 88.73235686453587]
def norm_data(mean, data):
data = tf.cast(data, tf.float32) * 1/(2*mean)
return tf.reshape(data, [-1, 1])
numeric_columns = []
for i, feature in enumerate(FEATURES):
num_col = tf.feature_column.numeric_column(feature, normalizer_fn=functools.partial(norm_data, MEANS[i]))
numeric_columns.append(num_col)
numeric_columns
Schritt 2: Modell erstellen
Jetzt können wir ein Modell erstellen. Die Spalten, die wir gerade erstellt haben, werden in das Netzwerk eingespeist. Dann kompilieren wir das Modell. Wir fügen die Precision/Recall-AUC-Messwerte ein, die für unausgewogene Datasets nützlich sind.
model = keras.Sequential([
tf.keras.layers.DenseFeatures(numeric_columns),
layers.Dense(64, activation='relu'),
layers.Dense(64, activation='relu'),
layers.Dense(1, activation='sigmoid')
])
model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy', tf.keras.metrics.AUC(curve='PR')])
Schritt 3: Modell trainieren
Es gibt verschiedene Verfahren zum Umgang mit unausgewogenen Daten, darunter Oversampling (Generieren neuer Daten in der Minderheitenklasse) und Undersampling (Reduzieren der Daten in der Mehrheitsklasse).
In diesem Codelab verwenden wir eine Technik, bei der der Verlust bei einer Falschklassifizierung der Minderheitsklasse übergewichtet wird. Wir geben beim Training einen „class_weight“-Parameter an und gewichten „1“ (Betrug) höher, da er viel seltener vorkommt.
In diesem Lab verwenden wir drei Epochen (Durchläufe durch die Daten), damit das Training schneller geht. In der Praxis würden wir den Vorgang so lange ausführen, bis die Genauigkeit des Validierungssets nicht mehr steigt.
CLASS_WEIGHT = {
0: 1,
1: 100
}
EPOCHS = 3
train_data = raw_train_data.shuffle(10000)
val_data = raw_val_data
test_data = raw_test_data
model.fit(train_data, validation_data=val_data, class_weight=CLASS_WEIGHT, epochs=EPOCHS)
Schritt 4: Modell bewerten
Die Funktion „evaluate()“ kann auf Testdaten angewendet werden, die dem Modell noch nie präsentiert wurden, um eine objektive Bewertung zu ermöglichen. Glücklicherweise haben wir Testdaten genau für diesen Zweck reserviert.
model.evaluate(test_data)
Schritt 5: Untersuchung
In diesem Lab haben wir gezeigt, wie Sie ein großes Dataset aus BigQuery direkt in ein TensorFlow Keras-Modell aufnehmen. Außerdem haben wir alle Schritte zum Erstellen eines Modells durchlaufen. Zuletzt haben wir etwas darüber gelernt, wie wir mit unausgewogenen Klassifizierungsproblemen umgehen.
Sie können ruhig mit verschiedenen Architekturen und Ansätzen für den unausgewogenen Datensatz experimentieren, um zu sehen, ob Sie die Genauigkeit verbessern können.
6. 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.