1. Übersicht
In diesem Lab nehmen Sie direkt ein BigQuery-Dataset auf und trainieren ein Betrugserkennungsmodell 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 erstellen, um Betrug mit einem unausgewogenen Dataset zu erkennen
2. Daten in BigQuery analysieren
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: Auf das öffentliche BigQuery-Dataset zugreifen
Folgen Sie diesem Link, um in der Google Cloud Console auf öffentliche BigQuery-Datasets zuzugreifen.
Im Ressourcenbaum links unten sehen Sie eine Liste mit Datasets. Navigieren Sie durch die verfügbaren Datasets, bis Sie ml-datasets finden, und wählen Sie dann die darin enthaltene Tabelle ulb-fraud-detection aus:
Klicken Sie auf die einzelnen Tabs, um mehr über das Dataset zu erfahren:
- Auf dem Tab Schema werden die Datentypen beschrieben.
- Auf dem Tab Details wird erklärt,dass es sich um ein unausgeglichenes Dataset mit 284.407 Transaktionen handelt, von denen 492 betrügerisch sind.
- Auf dem Tab Preview (Vorschau) werden Datensätze aus dem Dataset angezeigt.
Schritt 2: Tabelle abfragen
Auf der Registerkarte „Details“ finden wir folgende Informationen zu den Daten:
- Zeit ist die Anzahl von Sekunden zwischen der ersten Transaktion im Dataset und dem Zeitpunkt der ausgewählten Transaktion.
- V1-V28 sind Spalten, die über ein Verfahren zur Dimensionalitätsreduzierung namens PCA transformiert wurden, das die Daten anonymisiert hat.
- Betrag ist der Transaktionsbetrag.
Klicken Sie auf Tabelle abfragen, um eine Abfrage auszuführen:
Fügen Sie der Anweisung ein * hinzu, um alle Spalten anzusehen, 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 Zielvariable Klasse 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 liefert einen Bereich von -1 (negativ korreliert) bis 1 (positiv korreliert), wobei 0 unabhängig ist.
Beachten Sie, dass V1 und V2 leicht mit unserer Zielvariablen korrelieren (etwa -0,1 bzw. 0,1).
Es besteht nur wenig Zusammenhang mit der Zeit. Eine leicht negative Korrelation könnte uns darauf hinweisen, dass im Laufe der Zeit weniger betrügerische Transaktionen im Dataset enthalten sind.
Der Betrag weist noch eine geringere Korrelation auf, was darauf hindeutet, dass betrügerische Transaktionen bei höheren Transaktionsbeträgen sehr geringfügig höher sind.
Schritt 4: Mittelwerte für die Feature-Skalierung berechnen
Die Normalisierung von Featurewerten kann dazu beitragen, dass ein neuronales Netzwerk schneller konvergiert. Ein gängiges Schema besteht darin, Werte um 0 mit einer Standardabweichung von 1 zu zentrieren. Die folgende Abfrage ruft die Mittelwerte ab. Das Speichern des Ergebnisses ist nicht erforderlich, da wir später ein Code-Snippet dafür haben.
Sie werden auch feststellen, dass die Abfrage eine interessante WHERE-Klausel enthält. Dies wird im nächsten Abschnitt beschrieben, wenn wir uns damit befassen, wie die Daten zwischen Trainings- und Test-Datasets 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 üblicherweise drei Datasets verwendet:
- Training: Wird zum Erstellen des Modells durch iteratives Anpassen von Parametern verwendet
- Validierung: Wird während des Trainings anhand unabhängiger Daten geprüft, um zu beurteilen, ob das Modell überanpassungsfähig ist.
- Test: Wird nach Erstellung des Modells verwendet, um die Genauigkeit zu bewerten.
In diesem Codelab verwenden wir eine Trainings-/Validierungs-/Testaufteilung gemäß 80/10/10.
Wir fügen jedes Dataset in eine eigene Tabelle in BigQuery ein. Im ersten Schritt erstellen Sie ein BigQuery-Dataset – ein Container für zusammengehörige Tabellen. Wählen Sie bei ausgewähltem Projekt Dataset erstellen aus.
Erstellen Sie dann ein Dataset mit dem Namen tfe_codelab, das die Trainings-, Validierungs- und Testtabellen enthält.
Jetzt führen wir drei Abfragen zum Trainieren, Testen und Validieren 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 soeben erstellten Dataset tfe_codelab den Namen ulb_fraud_detection_train und speichern Sie die Daten.
Die WHERE-Klausel teilt die Daten zuerst durch Berechnung eines Hashwerts für einige Spalten auf. Dann werden Zeilen ausgewählt, in denen der Rest des Hashwerts, wenn er durch 10 geteilt wird, unter 80 liegt, was 80 % ergibt.
Jetzt wiederholen wir den Vorgang für Validierungs- und Test-Datasets mit ähnlichen Abfragen, bei 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.
Testen
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 nun eine kurze Einführung in die Daten erhalten haben, können wir nun unsere Modellentwicklungsumgebung einrichten.
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 die API, falls sie derzeit deaktiviert ist.
Schritt 2: 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 neuesten Instanztyp TensorFlow Enterprise 1.x ohne GPUs aus:
Verwenden Sie die Standardoptionen und klicken Sie dann auf Erstellen. Nachdem die Instanz erstellt wurde, wählen Sie JupyterLab öffnen aus:
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 ihn ausführen, indem Sie im oberen Menü den Rechtspfeil oder Befehlstaste + 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 das Projekt. Ändern Sie GCP_PROJECT_ID in die tatsächliche Projekt-ID, die Sie verwenden. Führen Sie neue Zellen aus, während 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
Lassen Sie uns nun einige Funktionen definieren. read_session() liest Daten aus einer BigQuery-Tabelle. extract_labels() ist eine Hilfsfunktion, die die Labelspalte vom Rest trennt, damit das Dataset 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
Zum Schluss erstellen wir jedes Dataset und drucken dann den ersten Batch aus dem Trainings-Dataset. Beachten Sie, dass BATCH_SIZE von 32 definiert wurde. Das ist ein wichtiger Parameter, der 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
Als Nächstes erstellen wir Featurespalten für jedes Feature im Dataset. In diesem bestimmten Dataset haben alle Spalten den Typ numeric_column, aber es gibt eine Reihe anderer Spaltentypen (z.B. categorical_column).
Wie bereits besprochen, werden die Daten auch so normiert, dass sie in der Mitte um null liegen, damit das Netzwerk schneller konvergiert. Wir haben die Mittelwerte der einzelnen Funktionen, die bei dieser Berechnung verwendet werden sollen, im Voraus 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 soeben erstellten Spalten werden in das Netzwerk eingespeist. Dann kompilieren wir das Modell. Wir verwenden den AUC-Messwert „Precision/Recall“, der bei unausgeglichenen Datasets nützlich ist.
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 eine Reihe von Techniken, um mit unausgewogenen Daten umzugehen, darunter Oversampling (Erzeugung neuer Daten in der Minderheitsklasse) und Unterstichproben (Reduzierung der Daten in der Mehrheitsklasse).
In diesem Codelab verwenden wir ein Verfahren, mit dem der Verlust bei falscher Klassifizierung der Minderheitenklasse übergewichtet wird. Wir geben einen class_weight-Parameter an, wenn Training und Gewicht auf „1“ gesetzt sind (Betrug) höher, da er weitaus seltener ist.
In diesem Lab verwenden wir 3 Epochen (durchlaufen die Daten), damit das Training schneller geht. In der Praxis sollte das Dataset so lange ausgeführt werden, bis die Genauigkeit des Validierungs-Datasets 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 das Modell noch nie gesehen hat, um eine objektive Bewertung zu ermöglichen. Glücklicherweise haben wir dafür Testdaten zurückgehalten.
model.evaluate(test_data)
Schritt 5: Erkundung
In diesem Lab haben Sie gelernt, wie Sie ein großes Dataset aus BigQuery direkt in ein TensorFlow Keras-Modell aufnehmen. Wir haben auch alle Schritte zum Erstellen eines Modells behandelt. Schließlich haben wir etwas über den Umgang mit unausgewogenen Klassifizierungsproblemen gelernt.
Sie können gerne weiter mit verschiedenen Architekturen und Ansätzen für das unausgeglichene Dataset experimentieren, um zu sehen, ob Sie die Genauigkeit verbessern können!
6. 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 die Notebookinstanz einfach, 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.