Menjelaskan model deteksi penipuan dengan Cloud AI Platform

1. Ringkasan

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

Yang Anda pelajari

Anda akan mempelajari cara:

• Menangani set data yang tidak seimbang
• Membangun dan mengevaluasi model deteksi penipuan dengan tf.keras di AI Platform Notebooks
• Gunakan Explainable AI SDK dari dalam notebook untuk memahami alasan model mengklasifikasikan transaksi sebagai penipuan
• Men-deploy model ke AI Platform dengan penjelasan, serta mendapatkan prediksi dan penjelasan pada model yang di-deploy

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

2. Mengapa deteksi 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 dalam hal machine learning:

• Set data yang sangat tidak seimbang: karena anomali, ya, anomali, jumlahnya tidak banyak. ML berfungsi paling baik jika set data seimbang, sehingga semuanya bisa menjadi rumit jika pencilan membentuk kurang dari 1% data Anda.
• Perlu menjelaskan hasil: jika Anda mencari aktivitas penipuan, kemungkinan besar Anda ingin mengetahui alasan sistem menandai sesuatu sebagai penipuan, bukan hanya mempercayainya. Alat penjelasan dapat membantu mengatasi 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 Model AI Platform di Konsol Cloud Anda, lalu klik Aktifkan 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: Buat instance AI Platform Notebooks

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

Gunakan opsi default, lalu klik Buat. 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 dibuat secara sintetis ini dari Kaggle untuk melatih model kita. Set data asli mencakup 6,3 juta baris, dengan 8 ribu di antaranya adalah transaksi penipuan - hanya 0,1% dari seluruh set data.

Mengapa kami menggunakan set data sintetis? Set data keuangan sulit didapatkan, khususnya untuk deteksi penipuan. Data ini sering kali berisi PII, dan oleh karena itu perlu dianonimkan sepenuhnya (termasuk nama fitur). Dengan set data sintetis, kita tidak perlu mengkhawatirkan kedua hal tersebut. Set data PaySim dari Kaggle ini didasarkan pada banyak riset yang sedang berlangsung di bidang ini.*

Langkah 1: Download set data Kaggle dan baca dengan Pandas

Kami telah menyediakan set data 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 set data sebagai Pandas DataFrame 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: Mempertimbangkan data yang tidak seimbang

Seperti yang disebutkan di atas, saat ini set data berisi 99,9% contoh tidak curang. Jika kita melatih model pada data apa adanya, kemungkinan model akan mencapai akurasi 99,9% dengan menebak bahwa setiap transaksi bukanlah transaksi penipuan hanya karena 99,9% data adalah kasus non-penipuan.

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

Untuk mengurangi sampel set data, kita akan mengambil semua ~8 ribu contoh penipuan dan sampel acak ~31 ribu kasus non-penipuan. Dengan demikian, set data yang dihasilkan akan memiliki 25% kasus penipuan, dibandingkan dengan 0,1% yang kita miliki sebelumnya.

Pertama, pisahkan data menjadi dua DataFrame, satu untuk penipuan dan satu untuk non-penipuan (kita akan menggunakannya nanti dalam codelab saat men-deploy model):

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

Kemudian, ambil sampel acak kasus non-penipuan. Kita menggunakan 0,005% karena hal ini akan memberi kita pembagian 25/75 untuk transaksi penipuan / non-penipuan. Dengan begitu, Anda dapat menggabungkan kembali data dan mengacaknya. Untuk menyederhanakan, kita juga akan menghapus beberapa kolom yang tidak akan kita gunakan 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 memiliki set data yang jauh lebih seimbang. Namun, jika kita melihat model kita mencapai akurasi sekitar 75%, kemungkinan besar model tersebut menebak "non-penipuan" dalam setiap kasus.

Langkah 3: Membagi data menjadi set pelatihan dan pengujian

Hal terakhir yang harus dilakukan sebelum membangun model adalah membagi 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: A financial mobile money simulator for fraud detection". Dalam: The 28th European Modeling and Simulation Symposium-EMSS, Larnaca, Cyprus. 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 dokumentasi TensorFlow. Pertama, kita akan menormalisasi data, lalu membuat dan melatih model, menggunakan parameter class_weight untuk memperhitungkan ketidakseimbangan data yang tersisa.

Langkah 1: Menormalisasi data

Saat melatih model pada data numerik, penting untuk menormalisasi data, terutama jika setiap kolom berada dalam rentang yang berbeda. Hal ini dapat membantu mencegah kerugian akibat ledakan selama pelatihan. Kita dapat menormalisasi data dengan cara 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 dinormalisasi:

train_set

Langkah 2: Tentukan bobot kelas

Saat melakukan downsampling data, kami tetap ingin menyimpan subset transaksi non-penipuan agar tidak kehilangan informasi tentang transaksi tersebut. Itulah sebabnya kami tidak membuat data menjadi seimbang sempurna. Karena set data masih tidak seimbang dan kami paling peduli untuk mengidentifikasi transaksi penipuan dengan benar, kami ingin model kami memberikan bobot yang lebih besar pada contoh penipuan dalam set data kami.

Parameter class_weight Keras memungkinkan kita menentukan secara tepat bobot yang ingin kita berikan pada contoh dari setiap class, berdasarkan seberapa sering contoh tersebut muncul 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 di langkah berikutnya.

Langkah 3: Latih dan evaluasi model

Kita akan membangun model menggunakan Keras Sequential Model API, yang memungkinkan kita menentukan model sebagai tumpukan lapisan. Ada sejumlah metrik yang akan kita lacak saat melakukan pelatihan, yang akan membantu kita memahami performa model pada setiap kelas 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 menentukan 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 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)

Pelatihan akan memerlukan waktu beberapa menit untuk dijalankan.

Langkah 4: Visualisasikan metrik model

Setelah memiliki model terlatih, mari kita lihat performa model dengan memetakan berbagai metrik di seluruh 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 baik untuk memvisualisasikan performa model kita di seluruh set data pengujian. Untuk setiap class, persentase contoh pengujian yang diprediksi dengan benar dan salah oleh model akan ditampilkan. Scikit Learn memiliki beberapa utilitas untuk membuat dan memetakan matriks kebingungan, yang akan kita gunakan di sini.

Di awal notebook, kita mengimpor utilitas confusion_matrix. Untuk menggunakannya, kita akan membuat daftar prediksi model terlebih dahulu. Di sini, kita akan membulatkan nilai yang ditampilkan 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 memasukkan ini ke dalam metode confusion_matrix, bersama dengan label kebenaran dasar kita:

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

Hal ini menunjukkan kepada kita angka absolut prediksi model yang benar dan salah pada set pengujian. Angka di kiri atas menunjukkan jumlah contoh dari set pengujian yang diprediksi dengan benar oleh model kita sebagai tidak curang. Angka di kanan bawah menunjukkan jumlah yang diprediksi dengan benar sebagai penipuan (kami paling memperhatikan angka ini). Anda dapat melihat bahwa model memprediksi sebagian besar sampel dengan benar untuk setiap class.

Untuk mempermudah visualisasi, kami telah mengadaptasi 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')

Kemudian, buat plot dengan meneruskan data dari model kita. Kita menetapkan normalize ke True di sini sehingga matriks konfusi menampilkan jumlah prediksi yang benar dan salah sebagai persentase:

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

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

Di sini kita dapat melihat bahwa model kita memprediksi sekitar 85% dari 1.594 transaksi penipuan dari set pengujian kita dengan benar. Perhatikan bahwa fokus dalam 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 memperkenalkan alat bantu di sekitar penjelasan model yang dilatih pada set data tidak seimbang.

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

6. Menggunakan Explainable AI SDK

Explainable AI SDK menyediakan metode utilitas untuk mendapatkan penjelasan tentang model Anda. Library ini sudah diinstal sebelumnya di instance Notebook AI Platform Tensorflow – perhatikan bahwa kita 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 SavedModel Tensorflow, lalu mengarahkan SDK ke aset model tersimpan kita untuk mendapatkan penjelasan.

Langkah 1: Ekspor model terlatih

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

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

Jika Anda memuat ulang tampilan folder di sidebar kiri notebook, Anda akan melihat direktori baru bernama fraud_model/ yang 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() menampilkan metadata yang disimpulkan SDK dari model Anda, seperti nama input:

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

Keterjelasan membantu kita menjawab pertanyaan: "Mengapa model kita menganggap ini adalah penipuan?"

Langkah 3: Menentukan dasar model kita

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

Dasar untuk model kami pada dasarnya adalah apa yang dibandingkan dengan model tersebut. Kami memilih nilai dasar untuk setiap fitur dalam model, dan prediksi dasar kemudian menjadi nilai yang diprediksi model saat fitur ditetapkan pada nilai dasar.

Memilih dasar bergantung pada tugas prediksi yang Anda selesaikan. Untuk fitur numerik, biasanya nilai median setiap fitur dalam set data Anda digunakan sebagai dasar pengukuran. Namun, dalam kasus deteksi penipuan, hal ini tidak persis seperti yang kita inginkan. Kami paling tertarik untuk menjelaskan kasus saat model kami melabeli transaksi sebagai penipuan. Artinya, kasus dasar yang ingin kita bandingkan adalah transaksi yang tidak curang.

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

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 untuk setiap nilai input yang diharapkan model kita. Dalam kasus penggunaan deteksi penipuan, sebaiknya tentukan tolok ukur, yang akan kita lakukan di bawah:

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 di direktori model kita yang bernama explanation_metadata.json. Di notebook Anda, buka direktori fraud_model/ untuk mengonfirmasi bahwa file telah dibuat. Objek ini berisi metadata yang akan digunakan SDK untuk menghasilkan atribusi fitur.

Langkah 4: Mendapatkan penjelasan model

Sekarang kita siap mendapatkan atribusi fitur pada setiap contoh. Untuk melakukannya, kita akan membuat referensi lokal ke model kita terlebih dahulu 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 pada model kita dari contoh transaksi yang harus diklasifikasikan sebagai penipuan:

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 kode 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 dari dasar lebih dari 0,5. Jumlah transaksi, saldo akhir di akun tujuan, dan langkah adalah indikator terbesar berikutnya. Dalam set data, "langkah" mewakili satuan waktu (1 langkah adalah 1 jam). Nilai atribusi juga dapat negatif.

"Kesalahan perkiraan" yang dicetak di atas visualisasi memberi tahu Anda seberapa besar Anda dapat memercayai penjelasan tersebut. Umumnya, error di atas 5% berarti Anda mungkin tidak dapat mengandalkan atribusi fitur. Ingatlah bahwa kualitas penjelasan Anda bergantung pada kualitas data pelatihan dan model yang Anda gunakan. Meningkatkan kualitas data pelatihan, model, atau mencoba dasar model yang berbeda dapat mengurangi error perkiraan.

Anda juga dapat mengurangi error ini dengan meningkatkan jumlah langkah yang digunakan dalam metode penjelasan Anda. Anda dapat mengubahnya dengan SDK dengan menambahkan parameter path_count ke konfigurasi penjelasan (defaultnya adalah 10 jika Anda tidak menentukannya):

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

Ada banyak hal lain yang dapat Anda lakukan dengan Explainable AI pada model ini. Beberapa ide karakter tersebut mencakup:

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

🎉 Selamat! 🎉

Anda telah mempelajari cara memperhitungkan data yang 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. Penggunaan SDK dalam notebook dimaksudkan untuk menyederhanakan proses pengembangan model dengan memberi Anda akses ke penjelasan sebelum Anda men-deploy model. Kemungkinan besar setelah membuat model yang Anda inginkan, Anda ingin men-deploy-nya untuk mendapatkan prediksi dalam skala besar. Jika Anda merasa seperti itu, lanjutkan ke langkah berikutnya yang bersifat opsional. 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 tersimpan Anda ke Bucket Cloud Storage.

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

Untuk melakukannya, kita akan menentukan beberapa variabel lingkungan. Isi nilai di bawah 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 ke bucket ini saat 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 dalam 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. Deployment versi akan memerlukan waktu sekitar 5-10 menit:

!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

Di tanda origin, kita meneruskan lokasi Cloud Storage dari model tersimpan dan file metadata. 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. Secara umum, makin kompleks modelnya, makin banyak langkah aproksimasi yang diperlukan untuk mencapai konvergensi yang wajar.

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

Untuk mengonfirmasi bahwa model Anda 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 pada model yang di-deploy

Untuk tujuan kemampuan penjelasan, kami paling tertarik untuk menjelaskan kasus saat model kami memprediksi penipuan. Kami akan mengirimkan 5 contoh pengujian ke model kami yang semuanya merupakan transaksi penipuan.

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

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 model kita, dan menuliskannya 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 ini 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 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.