Utwórz model wykrywania oszustw w Cloud AI Platform za pomocą TensorFlow Enterprise i BigQuery

1. Przegląd

W tym module bezpośrednio pozyskasz zbiór danych BigQuery i wytrenujesz model wykrywania oszustw za pomocą TensorFlow Enterprise na platformie AI Google Cloud.

Czego się nauczysz

Poznasz takie zagadnienia jak:

• Analizowanie danych w BigQuery
• Pozyskiwanie danych za pomocą łącznika BigQuery w TensorFlow Enterprise
• Tworzenie modelu deep learning do wykrywania oszustw za pomocą niezrównoważonego zbioru danych

2. Analizowanie danych w BigQuery

Aby wykonać to ćwiczenie, musisz mieć projekt w Google Cloud Platform z włączonymi płatnościami. Aby utworzyć projekt, postępuj zgodnie z instrukcjami.

Krok 1. Uzyskaj dostęp do publicznego zbioru danych BigQuery

Aby uzyskać dostęp do publicznych zbiorów danych BigQuery w konsoli Google Cloud, kliknij ten link.

W drzewie zasobów w lewym dolnym rogu zobaczysz listę zbiorów danych. Przeglądaj dostępne zbiory danych, aż znajdziesz ml-datasets, a następnie wybierz w nim tabelę ulb-fraud-detection:

Klikaj poszczególne karty, aby dowiedzieć się więcej o zbiorze danych:

• Karta Schemat zawiera opis typów danych.
• Na karcie Szczegóły znajdziesz informację,że jest to niezrównoważony zbiór danych zawierający 284 407 transakcji, z których 492 to transakcje oszukańcze.
• Na karcie Podgląd wyświetlają się rekordy ze zbioru danych.

Krok 2. Wyślij zapytanie do tabeli

Na karcie szczegółów znajdziesz te informacje o danych:

• Czas to liczba sekund między pierwszą transakcją w zbiorze danych a czasem wybranej transakcji.
• Kolumny V1–V28 zostały przekształcone za pomocą techniki redukcji wymiarowości o nazwie PCA, która anonimizuje dane.
• Kwota to kwota transakcji.

Przyjrzyjmy się bliżej temu, co robi. W tym celu kliknij Utwórz zapytanie do tabeli, aby wysłać zapytanie:

Zaktualizuj instrukcję, aby dodać znak *, który umożliwi wyświetlenie wszystkich kolumn, a następnie kliknij Uruchom.

SELECT * FROM `bigquery-public-data.ml_datasets.ulb_fraud_detection` LIMIT 1000

Krok 3. Analiza danych

BigQuery udostępnia wiele funkcji statystycznych. Przyjrzyjmy się, jak dane są powiązane ze zmienną docelową Class.

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`

Korelacja przyjmuje wartości od -1 (skorelowane ujemnie) do 1 (skorelowane dodatnio), a 0 oznacza niezależność.

Zauważ, że zmienne V1 i V2 są lekko skorelowane z naszą zmienną docelową (odpowiednio około -0,1 i 0,1).

Nie widzimy dużej korelacji z czasem. Niewielka ujemna korelacja może wskazywać, że z czasem w zbiorze danych jest coraz mniej nieuczciwych transakcji.

Kwota ma jeszcze mniejszą korelację, co oznacza, że transakcje oszukańcze są nieznacznie bardziej prawdopodobne w przypadku wyższych kwot transakcji.

Krok 4. Oblicz średnie wartości na potrzeby skalowania cech

Normalizacja wartości cech może przyspieszyć zbieżność sieci neuronowej. Często stosuje się schemat, w którym wartości są wyśrodkowane wokół 0, a odchylenie standardowe wynosi 1. To zapytanie zwróci wartości średnie. Zapisywanie wyniku nie jest wymagane, ponieważ później będziemy mieć fragment kodu.

Zauważysz też, że zapytanie zawiera ciekawą klauzulę WHERE. Opiszemy to w następnej sekcji, w której omówimy, jak podzielić dane na zbiory do trenowania i testowania.

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

Krok 5. Dzielenie danych

Podczas tworzenia modelu uczenia maszynowego zwykle używa się 3 zbiorów danych:

• Trenowanie: używane do tworzenia modelu przez iteracyjne dostosowywanie parametrów.
• Walidacja: służy do oceny, czy model nie jest nadmiernie dopasowany, poprzez weryfikację na niezależnych danych podczas procesu trenowania.
• Test: używany po utworzeniu modelu do oceny dokładności.

W tym ćwiczeniu użyjemy podziału na zbiory trenowania, walidacji i testowania w proporcjach 80/10/10.

Każdy zbiór danych umieścimy w osobnej tabeli w BigQuery. Pierwszym krokiem jest utworzenie „zbioru danych” BigQuery, czyli kontenera na powiązane tabele. Wybierz projekt, a następnie kliknij Utwórz zbiór danych.

Następnie utwórz zbiór danych o nazwie tfe_codelab, który będzie zawierać tabele trenowania, walidacji i testowania.

Teraz uruchomimy 3 zapytania dotyczące trenowania, testowania i walidacji oraz zapiszemy dane w nowym zbiorze danych tfe_codelab.

W edytorze zapytań uruchom zapytanie, aby wygenerować dane treningowe:

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

Po zakończeniu zapytania zapisz wyniki w tabeli BigQuery.

W utworzonym przez Ciebie zbiorze danych tfe_codelab nadaj tabeli nazwę ulb_fraud_detection_train i zapisz dane.

Klauzula WHERE najpierw dzieli dane, obliczając funkcję skrótu w przypadku kilku kolumn. Następnie wybiera wiersze, w których reszta z dzielenia haszu przez 10 jest mniejsza niż 80, co daje nam 80%.

Powtórzmy teraz ten sam proces dla zbiorów weryfikacyjnych i testowych z podobnymi zapytaniami, które wybierają po 10% danych.

Weryfikacja

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

Zapisz wyniki tego zapytania w tabeli o nazwie 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

Zapisz wyniki tego zapytania w tabeli o nazwie ulb_fraud_detection_test.

3. Konfigurowanie środowiska notatnika

Po krótkim wprowadzeniu do danych skonfigurujmy teraz środowisko programistyczne modelu.

Krok 1. Włącz interfejsy API

Oprogramowanie sprzęgające BigQuery korzysta z interfejsu BigQuery Storage API. Wyszukaj w konsoli BigQuery Storage API i włącz go, jeśli jest wyłączony.

Krok 2. Utwórz instancję notatników AI Platform

Otwórz sekcję AI Platform Notebooks w Cloud Console i kliknij Nowa instancja. Następnie wybierz najnowszą wersję instancji TensorFlow Enterprise 1.x bez procesorów graficznych:

Użyj opcji domyślnych, a następnie kliknij Utwórz. Po utworzeniu instancji wybierz Otwórz JupyterLab:

Następnie utwórz notatnik Python 3 w JupyterLab:

4. Pozyskiwanie rekordów z BigQuery

Krok 1. Zaimportuj pakiety Pythona

W pozostałej części tego laboratorium wykonaj wszystkie fragmenty kodu z notatnika Jupyter.

W pierwszej komórce notatnika dodaj te instrukcje importu i uruchom komórkę. Możesz go uruchomić, naciskając przycisk strzałki w prawo w menu u góry lub naciskając Command-Enter:

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

Krok 2. Zdefiniuj stałe

Następnie zdefiniujmy kilka stałych, które będą używane w projekcie. Zastąp GCP_PROJECT_ID identyfikatorem projektu, którego używasz. Uruchamiaj nowe komórki w miarę ich tworzenia.

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]

Krok 3. Zdefiniuj funkcje pomocnicze

Teraz zdefiniujmy kilka funkcji. Funkcja read_session() odczytuje dane z tabeli BigQuery. Funkcja extract_labels() to funkcja pomocnicza, która oddziela kolumnę etykiet od reszty, dzięki czemu zbiór danych ma format oczekiwany przez funkcję keras.model_fit().

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)

Krok 4. Przetwarzanie danych

Na koniec utwórzmy poszczególne zbiory danych, a potem wydrukujmy pierwszą partię z treningowego zbioru danych. Zwróć uwagę, że zdefiniowaliśmy BATCH_SIZE jako 32. To ważny parametr, który wpływa na szybkość i dokładność trenowania.

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. Tworzenie modelu

Krok 1. Wstępne przetwarzanie danych

Utwórzmy kolumny funkcji dla każdej funkcji w zbiorze danych. W tym zbiorze danych wszystkie kolumny są typu numeric_column, ale istnieje wiele innych typów kolumn (np. categorical_column).

Jak wspomnieliśmy wcześniej, znormalizujemy też dane, aby były skupione wokół zera, co przyspieszy konwergencję sieci. W tym celu wstępnie obliczyliśmy średnie wartości poszczególnych funkcji.

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

Krok 2. Tworzenie modelu

Teraz możemy utworzyć model. Utworzone kolumny przekażemy do sieci. Następnie skompilujemy model. Dodajemy wskaźnik AUC precyzji/czułości, który jest przydatny w przypadku niezrównoważonych zbiorów danych.

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')])

Krok 3. Trenowanie modelu

Istnieje wiele technik radzenia sobie z niezrównoważonymi danymi, w tym nadpróbkowanie (generowanie nowych danych w klasie mniejszościowej) i podpróbkowanie (zmniejszanie liczby danych w klasie większościowej).

Na potrzeby tego laboratorium użyjemy techniki, która nadaje większą wagę stratom w przypadku błędnej klasyfikacji klasy mniejszościowej. Podczas trenowania określimy parametr class_weight i przypiszemy większą wagę „1” (oszustwo), ponieważ występuje ono znacznie rzadziej.

W tym module użyjemy 3 epok (przejść przez dane), aby przyspieszyć trenowanie. W rzeczywistości chcemy uruchamiać go tak długo, aż przestaniemy obserwować wzrost dokładności zbioru walidacyjnego.

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)

Krok 4. Ocena modelu

Funkcję evaluate() można zastosować do danych testowych, których model nigdy nie widział, aby uzyskać obiektywną ocenę. Na szczęście mamy dane testowe, które są do tego przeznaczone.

model.evaluate(test_data)

Krok 5. Eksploracja

W tym module pokazaliśmy, jak pozyskiwać duży zbiór danych z BigQuery bezpośrednio do modelu TensorFlow Keras. Omówiliśmy też wszystkie etapy tworzenia modelu. Na koniec dowiedzieliśmy się, jak radzić sobie z problemami klasyfikacji niezrównoważonej.

Możesz dalej eksperymentować z różnymi architekturami i podejściami do niezrównoważonego zbioru danych, aby sprawdzić, czy uda Ci się zwiększyć dokładność.

6. Czyszczenie

Jeśli chcesz nadal korzystać z tego notebooka, zalecamy wyłączanie go, gdy nie jest używany. W interfejsie Notebooks w konsoli Cloud wybierz notatnik, a następnie kliknij Zatrzymaj:

Jeśli chcesz usunąć wszystkie zasoby utworzone w tym module, po prostu usuń instancję notatnika zamiast ją zatrzymywać.

W menu nawigacyjnym w konsoli Cloud otwórz Storage i usuń oba utworzone zasobniki do przechowywania zasobów modelu.