Membangun model Deteksi Penipuan di Cloud AI Platform dengan TensorFlow Enterprise dan BigQuery

1. Ringkasan

Di lab ini, Anda akan langsung menyerap set data BigQuery dan melatih model deteksi penipuan dengan TensorFlow Enterprise di Google Cloud AI Platform.

Yang Anda pelajari

Anda akan mempelajari cara:

• Menganalisis data di BigQuery
• Menyerap data menggunakan konektor BigQuery di TensorFlow Enterprise
• Membangun model deep learning untuk mendeteksi penipuan dengan set data yang tidak seimbang

2. Menganalisis data di BigQuery

Anda memerlukan project Google Cloud Platform dengan penagihan yang diaktifkan untuk menjalankan codelab ini. Untuk membuat project, ikuti petunjuk di sini.

Langkah 1: Mengakses set data publik BigQuery

Ikuti link ini untuk mengakses set data publik BigQuery di konsol Google Cloud.

Di Pohon Resource di pojok kiri bawah, Anda akan melihat daftar set data. Jelajahi set data yang tersedia hingga Anda menemukan ml-datasets, lalu pilih tabel ulb-fraud-detection di dalamnya:

Klik setiap tab untuk mengetahui lebih lanjut tentang set data:

• Tab Skema menjelaskan jenis data.
• Tab Detail menjelaskan bahwa ini adalah set data yang tidak seimbang dengan 284.407 transaksi, yang 492 di antaranya adalah transaksi penipuan.
• Tab Preview menampilkan data dari set data.

Langkah 2: Kueri Tabel

Tab detail memberi tahu kita tentang data ini:

• Waktu adalah jumlah detik antara transaksi pertama dalam set data dan waktu transaksi yang dipilih.
• V1-V28 adalah kolom yang telah diubah melalui teknik reduksi dimensi yang disebut PCA yang telah menganonimkan data.
• Jumlah adalah jumlah transaksi.

Mari kita pelajari lebih lanjut dengan mengklik Tabel Kueri untuk menjalankan kueri:

Perbarui pernyataan untuk menambahkan * guna melihat semua kolom, lalu klik Run.

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

Langkah 3: Analisis Data

BigQuery menyediakan sejumlah fungsi statistik. Mari kita lihat bagaimana korelasi data dengan variabel target 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`

Korelasi akan memberikan rentang dari -1 (berkorelasi negatif) hingga 1 (berkorelasi positif), dengan 0 berarti independen.

Perhatikan bahwa V1 dan V2 memiliki sedikit korelasi dengan variabel target kita (masing-masing sekitar -0,1 dan 0,1).

Kami tidak melihat banyak korelasi dengan Waktu. Korelasi negatif yang sedikit mungkin menunjukkan bahwa ada lebih sedikit transaksi penipuan seiring waktu dalam set data.

Jumlah memiliki korelasi yang lebih rendah, yang menunjukkan bahwa transaksi penipuan sedikit lebih mungkin terjadi pada jumlah transaksi yang lebih tinggi.

Langkah 4: Hitung nilai rata-rata untuk penskalaan fitur

Menormalisasi nilai fitur dapat membantu jaringan saraf berkonvergensi lebih cepat. Skema umum adalah memusatkan nilai di sekitar 0 dengan simpangan baku 1. Kueri berikut akan mengambil nilai rata-rata. Penyimpanan hasil tidak diperlukan, karena kita akan memiliki cuplikan kode untuk itu nanti.

Anda juga akan melihat bahwa kueri menyertakan klausa WHERE yang menarik. Kita akan menjelaskannya di bagian berikutnya, saat kita membahas cara membagi data antara set pelatihan dan pengujian.

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

Langkah 5: Memisahkan data

Praktik umumnya adalah menggunakan 3 set data saat membangun model machine learning:

• Pelatihan: digunakan untuk membangun model dengan menyesuaikan parameter secara berulang
• Validasi: digunakan untuk menilai apakah model mengalami overfitting dengan melakukan verifikasi pada data independen selama proses pelatihan
• Pengujian: digunakan setelah model dibuat untuk menilai akurasi

Dalam codelab ini, kita akan menggunakan pemisahan data pelatihan/validasi/pengujian 80/10/10.

Kita akan menempatkan setiap set data ke dalam tabelnya sendiri di BigQuery. Langkah pertama adalah membuat "set data" BigQuery - yang merupakan penampung untuk tabel terkait. Setelah project Anda dipilih, pilih Buat Set Data.

Kemudian, buat set data bernama tfe_codelab untuk berisi tabel pelatihan, validasi, dan pengujian.

Sekarang, kita akan menjalankan 3 kueri untuk pelatihan, pengujian, dan validasi, lalu menyimpan data dalam set data tfe_codelab yang baru.

Di Editor kueri, jalankan kueri untuk membuat data pelatihan:

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

Setelah kueri selesai, simpan hasilnya ke dalam tabel BigQuery.

Dalam set data tfe_codelab yang baru saja Anda buat, beri nama tabel ulb_fraud_detection_train dan simpan data.

Klausa WHERE pertama-tama membagi data dengan menghitung hash pada beberapa kolom. Kemudian, baris dipilih jika sisa hash saat dibagi 10 kurang dari 80, sehingga kita mendapatkan 80%.

Sekarang, ulangi proses yang sama untuk set validasi dan pengujian dengan kueri serupa yang masing-masing memilih 10% data.

Validasi

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

Simpan hasil kueri ini ke dalam tabel bernama ulb_fraud_detection_val.

Uji

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

Simpan hasil kueri ini ke dalam tabel bernama ulb_fraud_detection_test.

3. Menyiapkan lingkungan Notebook Anda

Setelah mempelajari pengantar singkat tentang data, sekarang mari kita siapkan lingkungan pengembangan model.

Langkah 1: Aktifkan API

Konektor BigQuery menggunakan BigQuery Storage API. Telusuri BigQuery Storage API di konsol dan aktifkan API jika saat ini dinonaktifkan.

Langkah 2: Buat instance AI Platform Notebooks

Buka bagian AI Platform Notebooks di Cloud Console Anda, lalu klik Instance Baru. Kemudian, pilih jenis instance TensorFlow Enterprise 1.x terbaru tanpa GPU:

Gunakan opsi default, lalu klik Buat. Setelah instance dibuat, pilih Open JupyterLab:

Kemudian, buat notebook Python 3 dari JupyterLab:

4. Menyerap data dari BigQuery

Langkah 1: Impor paket Python

Untuk sisa codelab ini, jalankan semua cuplikan kode dari notebook Jupyter Anda.

Di sel pertama notebook Anda, tambahkan impor berikut dan jalankan sel. Anda dapat menjalankannya dengan menekan tombol panah kanan di menu atas atau menekan 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()

Langkah 2: Tentukan konstanta

Selanjutnya, mari kita tentukan beberapa konstanta untuk digunakan dalam project. Ubah GCP_PROJECT_ID ke project ID sebenarnya yang Anda gunakan. Lanjutkan dan jalankan sel baru saat Anda membuatnya.

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]

Langkah 3: Tentukan fungsi pembantu

Sekarang, mari kita tentukan beberapa fungsi. read_session() membaca data dari tabel BigQuery. extract_labels() adalah fungsi pembantu untuk memisahkan kolom label dari kolom lainnya, sehingga set data berada dalam format yang diharapkan oleh keras.model_fit() nanti.

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)

Langkah 4: Muat data

Terakhir, buat setiap set data, lalu cetak batch pertama dari set data pelatihan. Perhatikan bahwa kita telah menentukan BATCH_SIZE sebesar 32. Ini adalah parameter penting yang akan memengaruhi kecepatan dan akurasi pelatihan.

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. Buat model

Langkah 1: Lakukan pra-pemrosesan data

Mari kita buat kolom fitur untuk setiap fitur dalam set data. Dalam set data ini, semua kolom berjenis numeric_column, tetapi ada sejumlah jenis kolom lainnya (misalnya, categorical_column).

Seperti yang telah kita bahas sebelumnya, kita juga akan menormalkan data agar berpusat di sekitar nol sehingga jaringan dapat berkonvergensi lebih cepat. Kami telah menghitung rata-rata setiap fitur untuk digunakan dalam perhitungan ini.

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

Langkah 2: Bangun model

Sekarang kita siap membuat model. Kita akan memasukkan kolom yang baru dibuat ke dalam jaringan. Kemudian, kita akan mengompilasi model. Kami menyertakan metrik AUC Presisi/Perolehan, yang berguna untuk set data yang tidak seimbang.

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

Langkah 3: Latih model

Ada sejumlah teknik untuk menangani data yang tidak seimbang, termasuk oversampling (membuat data baru dalam kelas minoritas) dan undersampling (mengurangi data dalam kelas mayoritas).

Untuk tujuan codelab ini, mari kita gunakan teknik yang memberikan bobot lebih besar pada kerugian saat salah mengklasifikasikan kelas minoritas. Kita akan menentukan parameter class_weight saat melatih dan memberi bobot "1" (penipuan) lebih tinggi, karena lebih jarang terjadi.

Kita akan menggunakan 3 epoch (melewati data) di lab ini agar pelatihan lebih cepat. Dalam skenario dunia nyata, kita ingin menjalankannya cukup lama hingga tidak lagi melihat peningkatan akurasi set validasi.

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)

Langkah 4: Evaluasi model

Fungsi evaluate() dapat diterapkan ke data pengujian yang belum pernah dilihat model untuk memberikan penilaian yang objektif. Untungnya, kita telah menyiapkan data pengujian untuk tujuan tersebut.

model.evaluate(test_data)

Langkah 5: Eksplorasi

Di lab ini, kami telah mendemonstrasikan cara menyerap set data besar dari BigQuery langsung ke model TensorFlow Keras. Kami juga telah membahas semua langkah membangun model. Terakhir, kita mempelajari sedikit cara menangani masalah klasifikasi yang tidak seimbang.

Jangan ragu untuk terus bereksperimen dengan berbagai arsitektur dan pendekatan untuk set data yang tidak seimbang, untuk melihat apakah Anda dapat meningkatkan akurasinya.

6. Pembersihan

Jika Anda ingin terus menggunakan notebook ini, sebaiknya matikan notebook saat tidak digunakan. Dari UI Notebook di Konsol Cloud Anda, pilih notebook, lalu pilih Stop:

Jika Anda ingin menghapus semua resource yang telah dibuat di lab ini, cukup Hapus instance notebook, bukan menghentikannya.

Menggunakan menu Navigasi di Konsol Cloud, jelajahi Penyimpanan dan hapus kedua bucket yang Anda buat untuk menyimpan aset model.