Menjelaskan model deteksi penipuan dengan Cloud AI Platform

1. Ringkasan

Di lab ini, Anda akan menggunakan AI Platform Notebooks untuk membuat dan melatih model guna mengidentifikasi transaksi penipuan, serta memahami prediksi model dengan Explainable AI SDK. Deteksi penipuan adalah jenis deteksi anomali khusus jasa keuangan, dan menghadirkan beberapa tantangan menarik untuk model ML: set data yang tidak seimbang serta kebutuhan untuk menjelaskan hasil model.

Yang Anda pelajari

Anda akan mempelajari cara:

• Menangani set data yang tidak seimbang
• Membuat dan mengevaluasi model deteksi penipuan dengan tf.keras di AI Platform Notebooks
• Gunakan Explainable AI SDK dari dalam notebook untuk memahami mengapa model tersebut mengklasifikasikan transaksi sebagai menipu
• Deploy model ke AI Platform dengan penjelasan, dan dapatkan prediksi serta penjelasan tentang model yang di-deploy

Total biaya untuk menjalankan lab ini di Google Cloud adalah sekitar $1.

2. Mengapa mendeteksi penipuan?

Deteksi anomali dapat menjadi kandidat yang baik untuk machine learning karena sering kali sulit untuk menulis serangkaian pernyataan berbasis aturan untuk mengidentifikasi pencilan dalam data. Deteksi penipuan adalah jenis deteksi anomali, dan menghadirkan dua tantangan menarik terkait machine learning:

• Set data yang sangat tidak seimbang: karena anomali merupakan anomali, tidak banyak. ML berfungsi paling baik saat set data diseimbangkan, sehingga segala sesuatunya bisa menjadi rumit ketika pencilan hanya mengisi kurang dari 1% data Anda.
• Perlu menjelaskan hasilnya: jika Anda mencari aktivitas penipuan, kemungkinan besar Anda ingin mengetahui alasan sistem menandai sesuatu sebagai penipuan, dan bukan hanya mengakuinya. Alat penjelasan dapat membantu menangani hal ini.

3. Menyiapkan lingkungan Anda

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

Langkah 1: Aktifkan Cloud AI Platform Models API

Buka bagian AI Platform Models di Cloud Console Anda, lalu klik Enable jika belum diaktifkan.

Langkah 2: Aktifkan Compute Engine API

Buka Compute Engine dan pilih Aktifkan jika belum diaktifkan. Anda akan memerlukan ini untuk membuat instance notebook.

Langkah 3: Membuat instance AI Platform Notebooks

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

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

Saat Anda membuka instance, pilih notebook Python 3 dari peluncur:

Langkah 4: Impor paket Python

Buat sel baru dan impor library yang akan kita gunakan dalam codelab ini:

import itertools
import numpy as np
import pandas as pd
import tensorflow as tf
import json
import matplotlib as mpl
import matplotlib.pyplot as plt
import explainable_ai_sdk

from sklearn.utils import shuffle
from sklearn.metrics import confusion_matrix
from sklearn.preprocessing import StandardScaler
from tensorflow import keras
from explainable_ai_sdk.metadata.tf.v2 import SavedModelMetadataBuilder

4. Mendownload dan memproses data

Kita akan menggunakan set data yang dihasilkan secara sintetis dari Kaggle untuk melatih model kita. Dataset asli mencakup 6,3 juta baris, 8k di antaranya adalah transaksi penipuan - hanya 0,1% dari seluruh dataset!

Mengapa kami menggunakan set data sintetis? Set data keuangan sulit diperoleh, khususnya untuk mendeteksi penipuan. ID ini sering kali berisi PII, dan akibatnya harus dianonimkan sepenuhnya (termasuk nama fitur). Dengan set data sintetis, kita tidak perlu mengkhawatirkan hal-hal tersebut. Set data PaySim dari Kaggle ini didasarkan pada banyak penelitian yang sedang berlangsung di lapangan.*

Langkah 1: Download set data Kaggle dan baca bersama Pandas

Kami telah menyediakan {i>dataset<i} Kaggle untuk Anda di Google Cloud Storage. Anda dapat mendownloadnya dengan menjalankan perintah gsutil berikut di notebook Jupyter:

!gsutil cp gs://financial_fraud_detection/fraud_data_kaggle.csv .

Selanjutnya, mari kita baca {i>dataset<i} sebagai DataFrame Pandas dan lihat pratinjaunya:

data = pd.read_csv('fraud_data_kaggle.csv')
data = data.drop(columns=['type'])
data.head()

Anda akan melihat sesuatu seperti ini di pratinjau:

Langkah 2: Memperhitungkan data yang tidak seimbang

Seperti yang disebutkan di atas, saat ini {i>dataset<i} berisi 99,9% contoh bukan penipuan. Jika kita melatih model pada data sebagaimana adanya, kemungkinan model akan mencapai akurasi 99,9% dengan menebak setiap transaksi bukan merupakan transaksi yang bersifat menipu hanya karena 99,9% data tersebut bukan kasus penipuan.

Ada beberapa pendekatan yang berbeda untuk menangani data yang tidak seimbang. Di sini, kita akan menggunakan teknik yang disebut downsampling. Downsampling berarti hanya menggunakan sebagian kecil dari kelas mayoritas dalam pelatihan. Dalam hal ini, "bukan penipuan" adalah kelas mayoritas karena mencakup 99,9% dari data.

Untuk mengurangi sampel set data, kita akan mengambil semua ~8 ribu contoh penipuan dan sampel acak dari ~31 ribu kasus non-penipuan. Dengan cara ini, {i>dataset<i} yang dihasilkan akan memiliki 25% kasus penipuan, dibandingkan dengan 0,1% yang kita miliki sebelumnya.

Pertama, bagi data menjadi dua DataFrame, satu untuk penipuan dan satu untuk bukan untuk penipuan (kita akan menggunakannya nanti di codelab saat kita men-deploy model):

fraud = data[data['isFraud'] == 1]
not_fraud = data[data['isFraud'] == 0]

Kemudian, ambil sampel acak dari kasus non-penipuan. Kami menggunakan 0,005% karena ini akan memberi kami pembagian 25/75 dari transaksi penipuan / non-penipuan. Dengan demikian, Anda dapat menyatukan kembali data dan mengocoknya. Untuk menyederhanakannya, kita juga akan menghapus beberapa kolom yang tidak akan digunakan untuk pelatihan:

# Take a random sample of non fraud rows
not_fraud_sample = not_fraud.sample(random_state=2, frac=.005)

# Put it back together and shuffle
df = pd.concat([not_fraud_sample,fraud])
df = shuffle(df, random_state=2)

# Remove a few columns (isFraud is the label column we'll use, not isFlaggedFraud)
df = df.drop(columns=['nameOrig', 'nameDest', 'isFlaggedFraud'])

# Preview the updated dataset
df.head()

Sekarang kita punya {i>dataset<i} yang jauh lebih seimbang. Namun, jika kita melihat akurasi model kita sekitar ~75%, ada kemungkinan besar bahwa model kita menduga "non-penipuan" dalam setiap kasus.

Langkah 3: Bagi data ke dalam set pelatihan dan pengujian

Hal terakhir yang harus dilakukan sebelum membangun model adalah memisahkan data. Kita akan menggunakan pembagian pelatihan-pengujian 80/20:

train_test_split = int(len(df) * .8)

train_set = df[:train_test_split]
test_set = df[train_test_split:]

train_labels = train_set.pop('isFraud')
test_labels = test_set.pop('isFraud')

*E. A. Lopez-Rojas , A. Elmir, dan S. Axelsson. "PaySim: Simulator uang seluler keuangan untuk mendeteksi penipuan". In: Simposium Pemodelan dan Simulasi Eropa ke-28-EMSS, Larnaca, Siprus. 2016

5. Membangun, melatih, dan mengevaluasi model tf.keras

Kita akan membangun menggunakan tf.keras API TensorFlow. Kode model di bagian ini dibuat berdasarkan tutorial ini dari dokumen TensorFlow. Pertama, kita akan menormalkan data, lalu membuat dan melatih model menggunakan parameter class_weight untuk memperhitungkan ketidakseimbangan data yang tersisa.

Langkah 1: Menormalkan data

Saat melatih model pada data numerik, data perlu dinormalisasi, terutama jika setiap kolom berada dalam rentang yang berbeda. Ini bisa membantu mencegah kehilangan meledak selama pelatihan. Kita dapat menormalisasi data dengan hal berikut:

scaler = StandardScaler()
train_set = scaler.fit_transform(train_set) # Only normalize on the train set
test_set = scaler.transform(test_set)

# clip() ensures all values fall within the range [-5,5]
# useful if any outliers remain after normalizing
train_set = np.clip(train_set, -5, 5)
test_set = np.clip(test_set, -5, 5)

Kemudian, mari kita lihat pratinjau data yang telah dinormalisasi:

train_set

Langkah 2: Menentukan bobot class

Saat melakukan downsampling pada data, kita masih ingin mempertahankan sebagian transaksi yang tidak menipu agar tidak kehilangan informasi tentang transaksi tersebut, itulah sebabnya kami tidak membuat data seimbang sepenuhnya. Karena set data masih tidak seimbang dan kita sangat peduli untuk mengidentifikasi transaksi yang menipu dengan benar, kita ingin model memberi lebih banyak bobot pada contoh yang menipu dalam set data.

Parameter Keras class_weight memungkinkan kita menentukan dengan tepat berapa bobot yang ingin kita berikan contoh dari setiap class, berdasarkan seberapa sering mereka terjadi dalam set data:

weight_for_non_fraud = 1.0 / df['isFraud'].value_counts()[0]
weight_for_fraud = 1.0 / df['isFraud'].value_counts()[1]

class_weight = {0: weight_for_non_fraud, 1: weight_for_fraud}

Kita akan menggunakan variabel ini saat melatih model pada langkah berikutnya.

Langkah 3: Latih dan evaluasi model

Kita akan membangun model menggunakan Keras Sequential Model API, yang memungkinkan kita menentukan model sebagai stack lapisan. Ada sejumlah metrik yang akan kita lacak saat berlatih, yang akan membantu kita memahami performa model di setiap class dalam set data.

METRICS = [
      keras.metrics.TruePositives(name='tp'),
      keras.metrics.FalsePositives(name='fp'),
      keras.metrics.TrueNegatives(name='tn'),
      keras.metrics.FalseNegatives(name='fn'), 
      keras.metrics.BinaryAccuracy(name='accuracy'),
      keras.metrics.Precision(name='precision'),
      keras.metrics.Recall(name='recall'),
      keras.metrics.AUC(name='auc'),
]

def make_model(metrics = METRICS):
  model = keras.Sequential([
      keras.layers.Dense(
          16, activation='relu',
          input_shape=(train_set.shape[-1],)),
      keras.layers.Dropout(0.5),
      keras.layers.Dense(1, activation='sigmoid'),
  ])

  model.compile(
      optimizer=keras.optimizers.Adam(lr=1e-3),
      loss=keras.losses.BinaryCrossentropy(),
      metrics=metrics)

  return model

Kemudian, kita akan mendefinisikan beberapa variabel global untuk digunakan selama pelatihan bersama dengan beberapa parameter penghentian awal.

EPOCHS = 100
BATCH_SIZE = 512

early_stopping = tf.keras.callbacks.EarlyStopping(
    monitor='val_auc', 
    verbose=1,
    patience=10,
    mode='max',
    restore_best_weights=True)

Terakhir, kita akan memanggil fungsi yang telah kita tentukan di atas untuk membuat model:

model = make_model()
model.summary()

Kita dapat melatih model dengan metode fit(), dengan meneruskan parameter yang ditentukan di atas:

results = model.fit(
    train_set,
    train_labels,
    batch_size=BATCH_SIZE,
    epochs=EPOCHS,
    callbacks = [early_stopping],
    validation_data=(test_set, test_labels),
    class_weight=class_weight)

Diperlukan waktu beberapa menit untuk menjalankan pelatihan.

Langkah 4: Visualisasikan metrik model

Setelah memiliki model terlatih, mari kita lihat performa model dengan memetakan berbagai metrik selama epoch pelatihan:

mpl.rcParams['figure.figsize'] = (12, 10)
colors = plt.rcParams['axes.prop_cycle'].by_key()['color']

def plot_metrics(history):
  metrics =  ['loss', 'auc', 'precision', 'recall']
  for n, metric in enumerate(metrics):
    name = metric.replace("_"," ").capitalize()
    plt.subplot(2,2,n+1)
    plt.plot(history.epoch,  history.history[metric], color=colors[0], label='Train')
    plt.plot(history.epoch, history.history['val_'+metric],
             color=colors[0], linestyle="--", label='Val')
    plt.xlabel('Epoch')
    plt.ylabel(name)
    if metric == 'loss':
      plt.ylim([0, plt.ylim()[1]])
    elif metric == 'auc':
      plt.ylim([0.8,1])
    else:
      plt.ylim([0,1])

    plt.legend()

plot_metrics(results)

Grafik Anda akan terlihat seperti berikut (tetapi tidak akan sama persis):

Langkah 5: Cetak matriks konfusi

Matriks konfusi adalah cara yang bagus untuk memvisualisasikan performa model di seluruh set data pengujian. Untuk setiap class, laporan akan menunjukkan persentase contoh pengujian yang diprediksi model kita dengan benar dan salah. Scikit Learn memiliki beberapa kegunaan untuk membuat dan memetakan matriks konflik, yang akan kita gunakan di sini.

Di awal notebook, kami mengimpor utilitas confusion_matrix. Untuk menggunakannya, pertama-tama kita akan membuat daftar prediksi model. Di sini kita akan membulatkan nilai yang dikembalikan dari model sehingga daftar ini cocok dengan daftar label kebenaran dasar:

predicted = model.predict(test_set)

y_pred = []

for i in predicted.tolist():
  y_pred.append(int(round(i[0])))

Sekarang kita siap untuk memasukkannya ke metode confusion_matrix, bersama dengan label kebenaran dasar:

cm = confusion_matrix(test_labels.values, y_pred)
print(cm)

Ini menunjukkan kepada kita angka absolut dari prediksi model kita yang benar dan salah di set pengujian. Angka di kiri atas menunjukkan jumlah contoh dari pengujian yang ditetapkan model kami dengan benar sebagai tidak palsu. Angka di kanan bawah menunjukkan jumlah data yang diprediksi dengan benar sebagai penipuan (kami sangat peduli dengan angka ini). Anda dapat melihat bahwa fungsi ini memprediksi sebagian besar sampel dengan benar untuk setiap class.

Agar lebih mudah divisualisasikan, kami telah menyesuaikan fungsi plot_confusion_matrix dari dokumen Scikit Learn. Tentukan fungsi tersebut di sini:

def plot_confusion_matrix(cm, classes,
                          normalize=False,
                          title='Confusion matrix',
                          cmap=plt.cm.Blues):
    """
    This function prints and plots the confusion matrix.
    Normalization can be applied by setting `normalize=True`.
    """
    plt.imshow(cm, interpolation='nearest', cmap=cmap)
    plt.title(title)
    plt.colorbar()
    tick_marks = np.arange(len(classes))
    plt.xticks(tick_marks, classes, rotation=45)
    plt.yticks(tick_marks, classes)

    if normalize:
        cm = np.round(cm.astype('float') / cm.sum(axis=1)[:, np.newaxis], 3)

    thresh = cm.max() / 2.
    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
        plt.text(j, i, cm[i, j],
                 horizontalalignment="center",
                 color="white" if cm[i, j] > thresh else "black")

    plt.tight_layout()
    plt.ylabel('True label')
    plt.xlabel('Predicted label')

Dan buat plot dengan meneruskan data dari model kita. Di sini kita menyetel normalize ke True sehingga matriks konflik menampilkan jumlah prediksi yang benar dan salah dalam bentuk persentase:

classes = ['not fraud', 'fraud']
plot_confusion_matrix(cm, classes, normalize=True)

Anda akan melihat sesuatu seperti ini (angka persisnya akan bervariasi):

Di sini terlihat bahwa model kami memprediksi sekitar 85% dari 1.594 transaksi penipuan dari set pengujian kami dengan benar. Perlu diperhatikan bahwa fokus di lab ini bukan pada kualitas model. Jika Anda men-deploy model deteksi penipuan dalam produksi, Anda mungkin menginginkan akurasi yang lebih tinggi dari 85% pada kelas penipuan. Tujuan lab ini adalah untuk memperkenalkan alat kepada Anda seputar menjelaskan model yang dilatih pada set data yang tidak seimbang.

Selanjutnya, kita akan menggunakan Explainable AI SDK untuk memahami fitur mana yang diandalkan model kami untuk membuat prediksi ini.

6. Menggunakan Explainable AI SDK

Explainable AI SDK menyediakan metode utilitas untuk mendapatkan penjelasan tentang model Anda. Alat ini sudah terinstal di instance Tensorflow AI Platform Notebook. Perlu diperhatikan bahwa kita telah mengimpornya di notebook di awal lab. Dengan SDK, kita bisa mendapatkan atribusi fitur dari model dalam instance notebook, yang berarti kita tidak perlu men-deploy model ke cloud untuk menggunakannya.

Di bagian ini, kita akan mengekspor model yang baru saja kita latih sebagai TensorflowSavedModel, lalu mengarahkan SDK ke aset model tersimpan untuk mendapatkan penjelasan.

Langkah 1: Ekspor model yang telah dilatih

Pertama, mari simpan model ke dalam direktori di instance notebook:

model_dir = 'fraud_model'
tf.saved_model.save(model, model_dir)

Jika memuat ulang tampilan folder di sidebar kiri notebook, Anda akan melihat direktori baru bernama fraud_model/ dibuat.

Langkah 2: Dapatkan metadata penjelasan dengan SDK

Selanjutnya, kita akan mengarahkan Explainable AI SDK ke direktori tersebut. Tindakan ini akan menghasilkan metadata yang diperlukan untuk mendapatkan penjelasan model. Metode get_metadata() menunjukkan metadata yang disimpulkan SDK dari model Anda, seperti nama input:

model_builder = SavedModelMetadataBuilder(model_dir)
metadata = model_builder.get_metadata()
print(metadata)

Kemampuan penjelasan membantu menjawab pertanyaan: "Mengapa model kami menganggap ini penipuan?"

Langkah 3: Menentukan dasar pengukuran model

Untuk data tabulasi, layanan Explainable AI bekerja dengan menampilkan nilai atribusi untuk setiap fitur. Nilai ini menunjukkan seberapa besar pengaruh fitur tertentu terhadap prediksi. Misalnya jumlah transaksi tertentu yang menyebabkan model kita meningkatkan prediksi probabilitas penipuannya sebesar 0,2%. Anda mungkin berpikir "0,2% relatif terhadap apa?". Itu membawa kita ke konsep dasar pengukuran.

Dasar pengukuran model kami pada dasarnya adalah perbandingannya. Kita memilih nilai dasar pengukuran untuk setiap fitur dalam model, dan prediksi dasar pengukuran menjadi nilai yang diprediksi model kami saat fitur ditetapkan pada dasar pengukuran tersebut.

Memilih dasar pengukuran bergantung pada tugas prediksi yang diselesaikan. Untuk fitur numerik, penggunaan nilai median dari setiap fitur dalam set data adalah sebagai dasar pengukuran. Namun, dalam kasus deteksi penipuan, ini tidak persis seperti yang kita inginkan. Kami harus menjelaskan kasus-kasus saat model kami melabeli transaksi sebagai bersifat menipu. Artinya, kasus dasar yang ingin kita bandingkan adalah transaksi yang bukan penipuan.

Untuk memperhitungkan hal ini, kita akan menggunakan nilai median transaksi yang bukan penipuan dalam set data sebagai dasar pengukuran. Kita bisa mendapatkan median dengan menggunakan DataFrame not_fraud_sample yang kita ekstrak di atas, dan menskalakannya agar sesuai dengan input yang diharapkan dari model:

not_fraud_sample = not_fraud_sample.drop(columns=['nameOrig', 'nameDest', 'isFlaggedFraud', 'isFraud'])

baseline = scaler.transform(not_fraud_sample.values)
baseline = np.clip(baseline, -5, 5)
baseline_values = np.median(baseline, axis=0)

Perhatikan bahwa kita tidak perlu menentukan dasar pengukuran. Jika tidak, SDK akan menggunakan 0 sebagai dasar pengukuran untuk setiap nilai input yang diharapkan oleh model kita. Dalam kasus penggunaan deteksi penipuan, sebaiknya tentukan dasar pengukuran, yang akan kami lakukan di bawah ini:

input_name = list(metadata['inputs'])[0]
model_builder.set_numeric_metadata(input_name, input_baselines=[baseline_values.tolist()], index_feature_mapping=df.columns.tolist()[:6])
model_builder.save_metadata(model_dir)

Menjalankan metode save_metadata() di atas akan membuat file dalam direktori model kita yang disebut explanation_metadata.json. Di notebook Anda, buka direktori penipuan_model/ untuk mengonfirmasi bahwa file tersebut telah dibuat. Ini berisi metadata yang akan digunakan SDK untuk menghasilkan atribusi fitur.

Langkah 4: Mendapatkan penjelasan model

Sekarang kita siap untuk mendapatkan atribusi fitur pada masing-masing contoh. Untuk melakukannya, pertama-tama kita akan membuat referensi lokal ke model kita menggunakan SDK:

local_model = explainable_ai_sdk.load_model_from_local_path(
    model_dir, 
    explainable_ai_sdk.SampledShapleyConfig()
)

Selanjutnya, mari kita dapatkan prediksi dan penjelasan tentang model kita dari contoh transaksi yang seharusnya diklasifikasikan sebagai penipu:

fraud_example = [0.722,0.139,-0.114,-0.258,-0.271,-0.305]
response = local_model.explain([{input_name: fraud_example}])
response[0].visualize_attributions()

Menjalankan kueri ini akan membuat visualisasi yang terlihat seperti berikut:

Dalam contoh ini, saldo awal akun sebelum transaksi terjadi adalah indikator penipuan terbesar, yang mendorong prediksi model kami naik dari dasar pengukuran lebih dari 0,5. Jumlah transaksi, saldo yang dihasilkan di akun tujuan, dan langkah adalah indikator terbesar berikutnya. Dalam {i>dataset<i}, “langkah” mewakili satuan waktu (1 langkah adalah 1 jam). Nilai atribusi juga bisa negatif.

"Error perkiraan" yang dicetak di atas visualisasi memungkinkan Anda mengetahui seberapa banyak Anda dapat memercayai penjelasannya. Umumnya, jika error melebihi 5% berarti Anda mungkin tidak dapat mengandalkan atribusi fitur. Ingat bahwa penjelasan Anda hanya akan bagus jika model dan data pelatihan yang Anda gunakan. Meningkatkan kualitas data pelatihan, model, atau mencoba dasar pengukuran model yang berbeda dapat mengurangi error perkiraan.

Anda juga dapat mengurangi error ini dengan menambah jumlah langkah yang digunakan dalam metode penjelasan Anda. Anda dapat mengubahnya dengan SDK dengan menambahkan parameter path_count ke konfigurasi penjelasan (default-nya adalah 10 jika Anda tidak menentukan):

local_model = explainable_ai_sdk.load_model_from_local_path(
    model_dir, 
    explainable_ai_sdk.SampledShapleyConfig(path_count=20)
)

Masih banyak lagi yang dapat Anda lakukan dengan Explainable AI pada model ini. Beberapa idenya antara lain:

• Mengirimkan banyak contoh ke model kami dan menghitung rata-rata nilai atribusi untuk melihat apakah fitur tertentu lebih penting secara keseluruhan. Kita dapat menggunakan ini untuk meningkatkan kualitas model, dan berpotensi menghapus fitur yang tidak penting
• Menemukan positif palsu yang ditandai oleh model kami sebagai penipuan, tetapi merupakan transaksi yang bukan penipuan, dan memeriksa nilai atribusinya
• Gunakan dasar pengukuran yang berbeda dan lihat pengaruhnya terhadap nilai atribusi

🎉 Selamat! 🎉

Anda telah mempelajari cara memperhitungkan data tidak seimbang, melatih model TensorFlow untuk mendeteksi transaksi penipuan, dan menggunakan Explainable AI SDK untuk melihat fitur mana yang paling diandalkan model Anda untuk membuat prediksi individual. Anda dapat berhenti di sini jika mau. Menggunakan SDK dalam notebook dimaksudkan untuk menyederhanakan proses pengembangan model dengan memberi Anda akses ke penjelasan sebelum men-deploy model. Kemungkinannya adalah setelah Anda membangun model yang Anda sukai, Anda ingin men-deploy-nya untuk mendapatkan prediksi dalam skala besar. Jika demikian, lanjutkan ke langkah opsional berikutnya. Jika sudah selesai, lanjutkan ke langkah Pembersihan.

7. Opsional: Men-deploy model ke AI Platform Prediction

Pada langkah ini, Anda akan mempelajari cara men-deploy model ke AI Platform Prediction.

Langkah 1: Salin direktori model yang Anda simpan ke Bucket Cloud Storage.

Dengan langkah-langkah SDK yang kami jalankan sebelumnya, Anda memiliki semua yang diperlukan untuk men-deploy model ke AI Platform. Untuk mempersiapkan deployment, Anda harus menempatkan aset dan metadata penjelasan model Tersimpan Anda di Bucket Cloud Storage yang dapat dibaca oleh layanan Explainable AI.

Untuk melakukannya, kita akan menentukan beberapa variabel lingkungan. Isi nilai di bawah ini dengan nama project Google Cloud Anda dan nama bucket yang ingin Anda buat (harus unik secara global).

# Update these to your own GCP project and model
GCP_PROJECT = 'your-gcp-project'
MODEL_BUCKET = 'gs://storage_bucket_name'

Sekarang kita siap membuat bucket penyimpanan untuk menyimpan aset model TensorFlow yang diekspor. Kita akan mengarahkan AI Platform di bucket ini saat kita men-deploy model.

Jalankan perintah gsutil ini dari dalam notebook Anda untuk membuat bucket:

!gsutil mb -l 'us-central1' $MODEL_BUCKET

Kemudian, salin direktori model lokal Anda ke bucket tersebut:

!gsutil -m cp -r ./$model_dir/* $MODEL_BUCKET/explanations

Langkah 2: Deploy model

Selanjutnya, kita akan menentukan beberapa variabel yang akan digunakan dalam perintah deployment:

MODEL = 'fraud_detection'
VERSION = 'v1'
model_path = MODEL_BUCKET + '/explanations'

Kita dapat membuat model dengan perintah gcloud berikut:

!gcloud ai-platform models create $MODEL --region=us-central1

Sekarang kita siap men-deploy versi pertama model ini dengan gcloud. Versi ini memerlukan waktu ~5-10 menit untuk di-deploy:

!gcloud beta ai-platform versions create $VERSION \
--model $MODEL \
--origin $model_path \
--runtime-version 2.1 \
--framework TENSORFLOW \
--python-version 3.7 \
--machine-type n1-standard-4 \
--explanation-method 'sampled-shapley' \
--num-paths 10 \
--region=us-central1

Dalam flag origin, kita meneruskan lokasi Cloud Storage dari file metadata dan model tersimpan. Explainable AI saat ini memiliki dua metode penjelasan berbeda yang tersedia untuk model tabulasi. Di sini kita menggunakan Sampled Shapley. Parameter num-paths menunjukkan jumlah jalur yang diambil sampelnya untuk setiap fitur input. Umumnya, makin kompleks model, makin besar pula langkah perkiraan yang diperlukan untuk mencapai konvergensi yang wajar.

Catatan: Untuk mempelajari lebih lanjut metode penjelasan yang tersedia dan alasan kami menggunakan Sampled Shapley di sini, baca laporan resmi ini yang ditulis oleh tim Explainable AI.

Untuk mengonfirmasi bahwa model Anda telah di-deploy dengan benar, jalankan perintah gcloud berikut:

!gcloud ai-platform versions describe $VERSION --model $MODEL --region=us-central1

Statusnya harus READY.

Langkah 3: Mendapatkan prediksi dan penjelasan tentang model yang di-deploy

Untuk tujuan penjelasan, kami sangat fokus untuk menjelaskan kasus ketika model kami memprediksi penipuan. Kami akan mengirimkan 5 contoh pengujian yang semuanya merupakan transaksi penipuan ke model kami.

Kita akan menggunakan Google Cloud CLI untuk mendapatkan prediksi. Jalankan kode berikut untuk mendapatkan indeks semua contoh penipuan dari set pengujian kami:

fraud_indices = []

for i,val in enumerate(test_labels):
    if val == 1:
        fraud_indices.append(i)

Selanjutnya, kita akan menyimpan 5 contoh dalam format yang diharapkan oleh model kita, dan menulisnya ke file:

num_test_examples = 5

instances = []
for i in range(num_test_examples):
    ex = test_set[fraud_indices[i]]
    instances.append({input_name: ex.tolist()})

with open('prediction.json', 'a') as outputfile:
    json.dump({"instances": instances}, outputfile)

Kita dapat mengirimkan lima contoh berikut ke model menggunakan gcloud:

!gcloud beta ai-platform explain \
--model=$MODEL \
--version=$VERSION \
--region='us-central1' \
--json-request=prediction.json

Dalam JSON respons, Anda akan melihat nilai atribusi untuk setiap fitur di seluruh contoh ini. Kunci example_score untuk setiap contoh mencakup prediksi model - dalam hal ini persentase kemungkinan bahwa transaksi tertentu adalah penipuan.

8. 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 dibuat 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.