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 AI Platform Google Cloud.

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: Akses set data publik BigQuery

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

Pada {i>Resources Tree<i} di sudut kiri bawah, Anda akan melihat daftar {i>dataset<i}. Jelajahi set data yang tersedia hingga Anda menemukan ml-datasets, lalu pilih tabel ulb-fraud-detection di dalamnya:

Klik di sekitar setiap tab untuk mengetahui lebih lanjut tentang {i>dataset<i}:

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

Langkah 2: Buat Kueri Tabel

Tab {i>detail<i} memberi tahu kita tentang data tersebut:

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

Mari kita pelajari lebih lanjut dengan mengklik Query Table untuk menjalankan kueri:

Perbarui pernyataan untuk menambahkan * untuk 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 data berkorelasi 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 kisaran dari -1 (berkorelasi negatif) hingga 1 (berkorelasi positif), dengan 0 adalah independen.

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

Kami tidak melihat banyak korelasi dengan Waktu. Korelasi yang sedikit negatif mungkin memberi tahu kita bahwa ada lebih sedikit transaksi penipuan dari waktu ke waktu dalam {i>dataset<i}.

Jumlah memiliki korelasi yang lebih rendah, yang menunjukkan bahwa transaksi yang menipu kemungkinan besar terjadi dalam jumlah transaksi yang lebih tinggi.

Langkah 4: Hitung nilai rata-rata untuk penskalaan fitur

Normalisasi nilai fitur dapat membantu jaringan neural untuk dikonvergensi lebih cepat. Skema umum adalah memusatkan nilai sekitar 0 dengan deviasi standar 1. Kueri berikut akan mengambil nilai rata-rata. Tidak perlu menyimpan hasil, karena kita akan memiliki cuplikan kode untuk itu nanti.

Anda juga akan melihat bahwa kueri menyertakan klausa WHERE yang menarik. Kami akan menjelaskan hal itu di bagian berikutnya, saat kami 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

Menggunakan 3 set data saat membangun model machine learning adalah praktik yang umum:

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

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

Kita akan menempatkan setiap {i>dataset<i} ke dalam tabelnya sendiri di BigQuery. Langkah pertama adalah membuat "set data" BigQuery - yang merupakan penampung untuk tabel terkait. Setelah memilih project, pilih Create Dataset.

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

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

Di Query editor, jalankan kueri untuk menghasilkan 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 dalam tabel BigQuery.

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

Klausa WHERE pertama kali membagi data dengan menghitung {i>hash<i} pada beberapa kolom. Kemudian, ia memilih baris di mana sisa {i>hash<i} ketika dibagi 10 berada di bawah 80, memberi kita 80%.

Sekarang, mari 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 yang disebut ulb_fraud_detection_val.

Menguji

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 yang disebut ulb_fraud_detection_test.

3. Menyiapkan lingkungan Notebook Anda

Setelah membahas pengantar data singkat, 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 tersebut jika saat ini dinonaktifkan.

Langkah 2: Membuat instance AI Platform Notebooks

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

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

Kemudian, buat notebook Python 3 dari JupyterLab:

4. Menyerap kumpulan 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 bantuan

Sekarang, mari kita tentukan beberapa fungsi. read_session() membaca data dari tabel BigQuery. extract_labels() adalah fungsi bantuan untuk memisahkan kolom label dari yang lain, sehingga set data tersebut dalam format yang diharapkan oleh keras.model_fit() di kemudian hari.

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: Serap data

Terakhir, mari kita 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: Melakukan prapemrosesan data

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

Seperti pembahasan sebelumnya, kita juga akan mengatur data ke pusat di sekitar nol sehingga jaringan dikonvergensi lebih cepat. Kami telah menghitung sebelumnya rata-rata setiap fitur yang akan digunakan dalam penghitungan 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 untuk membuat model. Kita akan memasukkan kolom yang baru saja kita buat 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 (menghasilkan data baru di kelas minoritas) dan undersampling (mengurangi data di kelas mayoritas).

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

Kita akan menggunakan 3 epoch (meneruskan data) di lab ini agar pelatihan lebih cepat. Dalam skenario dunia nyata, kita ingin menjalankannya cukup lama sampai pada titik di mana perhentian mengalami 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 evaluasi() dapat diterapkan untuk menguji data yang belum pernah dilihat model tersebut untuk memberikan penilaian objektif. Untungnya, kita telah menyisihkan data pengujian hanya untuk hal itu.

model.evaluate(test_data)

Langkah 5: Eksplorasi

Di lab ini, kita telah mendemonstrasikan cara menyerap set data besar dari BigQuery secara langsung ke model TensorFlow Keras. Kita juga telah mengikuti semua langkah pembuatan model. Akhirnya, kita belajar sedikit tentang cara menangani masalah klasifikasi yang tidak seimbang.

Jangan ragu untuk terus bermain-main dengan arsitektur dan pendekatan yang berbeda terhadap {i>dataset<i} yang tidak seimbang, untuk melihat apakah Anda dapat meningkatkan akurasinya!

6. Pembersihan

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

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

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