1. Ringkasan
Di lab ini, Anda akan menggunakan Alat What-if untuk menganalisis model XGBoost yang dilatih pada data keuangan. Setelah menganalisis model, Anda akan men-deploynya ke Vertex AI baru di Cloud.
Yang Anda pelajari
Anda akan mempelajari cara:
- Latih model XGBoost pada {i>dataset<i} hipotek publik di notebook yang dihosting
- Menganalisis model menggunakan What-if Tool
- Men-deploy model XGBoost ke Vertex AI
Total biaya untuk menjalankan lab ini di Google Cloud adalah sekitar $1.
2. Pengantar Vertex AI
Lab ini menggunakan penawaran produk AI terbaru yang tersedia di Google Cloud. Vertex AI mengintegrasikan penawaran ML di Google Cloud ke dalam pengalaman pengembangan yang lancar. Sebelumnya, model yang dilatih dengan AutoML dan model kustom dapat diakses melalui layanan terpisah. Penawaran baru ini menggabungkan kedua model ini menjadi satu API, beserta produk baru lainnya. Anda juga dapat memigrasikan project yang sudah ada ke Vertex AI. Jika Anda memiliki masukan, harap lihat halaman dukungan.
Vertex AI mencakup banyak produk yang berbeda untuk mendukung alur kerja ML secara menyeluruh. Lab ini akan berfokus pada produk yang disorot di bawah: Prediksi dan Notebooks.
3. Penjelasan singkat XGBoost
XGBoost adalah framework machine learning yang menggunakan hierarki keputusan dan peningkatan gradien untuk membangun model prediktif. Model ini bekerja dengan menggabungkan beberapa pohon keputusan secara bersamaan berdasarkan skor yang terkait dengan node daun yang berbeda dalam pohon.
Diagram di bawah adalah visualisasi model pohon keputusan sederhana yang mengevaluasi apakah pertandingan olahraga harus dimainkan berdasarkan perkiraan cuaca:
Mengapa kita menggunakan XGBoost untuk model ini? Meskipun jaringan neural tradisional telah terbukti berperforma terbaik pada data tidak terstruktur seperti gambar dan teks, hierarki keputusan sering kali berperforma sangat baik pada data terstruktur seperti set data hipotek yang akan kita gunakan dalam codelab ini.
4. 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 Compute Engine API
Buka Compute Engine dan pilih Aktifkan jika belum diaktifkan. Anda akan memerlukan ini untuk membuat instance notebook.
Langkah 2: Aktifkan Vertex AI API
Buka bagian Vertex di Konsol Cloud Anda, lalu klik Enable Vertex AI API.
Langkah 3: Buat instance Notebooks
Dari bagian Vertex di Cloud Console Anda, klik Notebook:
Dari sana, pilih Instance Baru. Kemudian, pilih jenis instance TensorFlow Enterprise 2.3 tanpa GPU:
Gunakan opsi default, lalu klik Create. Setelah instance dibuat, pilih Buka JupyterLab.
Langkah 4: Instal XGBoost
Setelah instance JupyterLab terbuka, Anda harus menambahkan paket XGBoost.
Untuk melakukannya, pilih Terminal dari peluncur:
Kemudian, jalankan perintah berikut untuk menginstal XGBoost versi terbaru yang didukung oleh Vertex AI:
pip3 install xgboost==1.2
Setelah selesai, buka instance Notebook Python 3 dari peluncur. Anda siap untuk memulai di notebook.
Langkah 5: Impor paket Python
Di sel pertama notebook, tambahkan impor berikut dan jalankan sel. Anda dapat menjalankannya dengan menekan tombol panah kanan di menu atas atau menekan command-enter:
import pandas as pd
import xgboost as xgb
import numpy as np
import collections
import witwidget
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.utils import shuffle
from witwidget.notebook.visualization import WitWidget, WitConfigBuilder
5. Mendownload dan memproses data
Kita akan menggunakan set data hipotek dari ffiec.gov untuk melatih model XGBoost. Kami telah melakukan beberapa prapemrosesan pada set data asli dan membuat versi yang lebih kecil untuk Anda gunakan guna melatih model. Model ini akan memprediksi apakah permohonan hipotek tertentu akan disetujui atau tidak.
Langkah 1: Download set data yang telah diproses sebelumnya
Kami telah menyediakan versi set data untuk Anda di Google Cloud Storage. Anda dapat mendownloadnya dengan menjalankan perintah gsutil berikut di notebook Jupyter:
!gsutil cp 'gs://mortgage_dataset_files/mortgage-small.csv' .
Langkah 2: Baca {i>dataset<i} dengan Pandas
Sebelum membuat Pandas DataFrame, kita akan membuat dict dari setiap jenis data kolom agar Pandas membaca set data kita dengan benar:
COLUMN_NAMES = collections.OrderedDict({
'as_of_year': np.int16,
'agency_code': 'category',
'loan_type': 'category',
'property_type': 'category',
'loan_purpose': 'category',
'occupancy': np.int8,
'loan_amt_thousands': np.float64,
'preapproval': 'category',
'county_code': np.float64,
'applicant_income_thousands': np.float64,
'purchaser_type': 'category',
'hoepa_status': 'category',
'lien_status': 'category',
'population': np.float64,
'ffiec_median_fam_income': np.float64,
'tract_to_msa_income_pct': np.float64,
'num_owner_occupied_units': np.float64,
'num_1_to_4_family_units': np.float64,
'approved': np.int8
})
Selanjutnya, kita akan membuat DataFrame, dengan meneruskan jenis data yang telah ditentukan di atas. Penting untuk mengacak data jika {i>dataset<i} asli diurutkan dengan cara tertentu. Kita menggunakan utilitas sklearn yang disebut shuffle untuk melakukannya, yang kita impor di sel pertama:
data = pd.read_csv(
'mortgage-small.csv',
index_col=False,
dtype=COLUMN_NAMES
)
data = data.dropna()
data = shuffle(data, random_state=2)
data.head()
data.head() memungkinkan kita melihat pratinjau lima baris pertama set data di Pandas. Anda akan melihat tampilan seperti ini setelah menjalankan sel di atas:
Ini adalah fitur yang akan kita gunakan untuk melatih model. Jika men-scroll hingga bagian akhir, Anda akan melihat kolom terakhir approved, yang merupakan hal yang kami prediksi. Nilai 1 menunjukkan bahwa aplikasi tertentu disetujui, dan 0 menunjukkan bahwa aplikasi ditolak.
Untuk melihat distribusi nilai yang disetujui / ditolak dalam set data dan membuat array numpy label, jalankan kode berikut:
# Class labels - 0: denied, 1: approved
print(data['approved'].value_counts())
labels = data['approved'].values
data = data.drop(columns=['approved'])
Sekitar 66% dari set data berisi aplikasi yang disetujui.
Langkah 3: Membuat kolom dummy untuk nilai kategoris
{i>Dataset<i} ini berisi campuran nilai kategorikal dan numerik, tetapi XGBoost mengharuskan semua fitur berupa numerik. Daripada merepresentasikan nilai kategoris menggunakan encoding one-hot, untuk model XGBoost, kita akan memanfaatkan fungsi get_dummies Pandas.
get_dummies mengambil kolom dengan beberapa kemungkinan nilai dan mengubahnya menjadi serangkaian kolom yang masing-masing hanya berisi 0 dan 1. Misalnya, jika kita memiliki kolom "color" dengan kemungkinan nilai "blue" dan "red", get_dummies akan mengubahnya menjadi 2 kolom yang disebut "color_blue" dan "color_red" dengan semua nilai boolean 0 dan 1.
Untuk membuat kolom dummy bagi fitur kategoris, jalankan kode berikut:
dummy_columns = list(data.dtypes[data.dtypes == 'category'].index)
data = pd.get_dummies(data, columns=dummy_columns)
data.head()
Saat melihat pratinjau data kali ini, Anda akan melihat satu fitur (seperti purchaser_type yang digambarkan di bawah) yang dibagi menjadi beberapa kolom:
Langkah 4: Membagi data menjadi set pelatihan dan pengujian
Konsep penting dalam machine learning adalah pemisahan pelatihan / pengujian. Kita akan mengambil sebagian besar data dan menggunakannya untuk melatih model, dan kita akan menyisihkan sisanya untuk menguji model pada data yang belum pernah dilihat sebelumnya.
Tambahkan kode berikut ke notebook Anda, yang menggunakan fungsi Scikit-learn train_test_split untuk memisahkan data:
x,y = data.values,labels
x_train,x_test,y_train,y_test = train_test_split(x,y)
Sekarang Anda siap untuk mem-build dan melatih model.
6. Membangun, melatih, dan mengevaluasi model XGBoost
Langkah 1: Menentukan dan melatih model XGBoost
Membuat model di XGBoost itu mudah. Kita akan menggunakan class XGBClassifier untuk membuat model, dan hanya perlu meneruskan parameter objective yang tepat untuk tugas klasifikasi tertentu. Dalam hal ini, kita menggunakan reg:logistic karena kita memiliki masalah klasifikasi biner dan ingin model menghasilkan satu nilai dalam rentang (0,1): 0 untuk tidak disetujui dan 1 untuk disetujui.
Kode berikut akan membuat model XGBoost:
model = xgb.XGBClassifier(
objective='reg:logistic'
)
Anda dapat melatih model dengan satu baris kode, memanggil metode fit() serta meneruskan data dan label pelatihan.
model.fit(x_train, y_train)
Langkah 2: Evaluasi akurasi model Anda
Sekarang kita dapat menggunakan model terlatih untuk membuat prediksi pada data pengujian dengan fungsi predict().
Kemudian, kita akan menggunakan fungsi accuracy_score() Scikit-learn untuk menghitung akurasi model berdasarkan performanya pada data pengujian. Kita akan meneruskan nilai kebenaran dasar beserta nilai prediksi model untuk setiap contoh dalam set pengujian:
y_pred = model.predict(x_test)
acc = accuracy_score(y_test, y_pred.round())
print(acc, '\n')
Akurasi biasanya sekitar 87%, tetapi akurasi Anda akan sedikit berbeda karena selalu ada elemen keacakan dalam machine learning.
Langkah 3: Simpan model Anda
Untuk men-deploy model, jalankan kode berikut untuk menyimpannya ke file lokal:
model.save_model('model.bst')
7. Menggunakan Alat What-if untuk menafsirkan model Anda
Langkah 1: Buat visualisasi Alat Perbandingan
Untuk menghubungkan Alat Perbandingan ke model lokal, Anda harus meneruskan subkumpulan contoh pengujian beserta nilai kebenaran nyata untuk contoh tersebut. Mari kita buat array Numpy yang berisi 500 contoh pengujian bersama dengan label kebenaran dasar:
num_wit_examples = 500
test_examples = np.hstack((x_test[:num_wit_examples],y_test[:num_wit_examples].reshape(-1,1)))
Membuat instance Alat Perbandingan semudah membuat objek WitConfigBuilder dan meneruskan model yang ingin dianalisis.
Karena What-If Tool mengharapkan daftar skor untuk setiap class dalam model kita (dalam hal ini 2), kita akan menggunakan metode predict_proba XGBoost dengan What-If Tool:
config_builder = (WitConfigBuilder(test_examples.tolist(), data.columns.tolist() + ['mortgage_status'])
.set_custom_predict_fn(model.predict_proba)
.set_target_feature('mortgage_status')
.set_label_vocab(['denied', 'approved']))
WitWidget(config_builder, height=800)
Perhatikan bahwa diperlukan waktu beberapa menit untuk memuat visualisasi. Saat dimuat, Anda akan melihat hal berikut:
Sumbu y menunjukkan prediksi model, dengan 1 sebagai prediksi approved dengan keyakinan tinggi, dan 0 sebagai prediksi denied dengan keyakinan tinggi. Sumbu x hanyalah penyebaran semua titik data yang dimuat.
Langkah 2: Pelajari setiap titik data
Tampilan default di What-If Tool adalah tab Editor titik data. Di sini, Anda dapat mengklik setiap titik data untuk melihat fiturnya, mengubah nilai fitur, dan melihat pengaruh perubahan tersebut terhadap prediksi model pada setiap titik data.
Pada contoh di bawah, kami memilih titik data yang mendekati nilai minimum 0,5. Permohonan hipotek yang terkait dengan titik data khusus ini berasal dari CFPB. Kami mengubah fitur tersebut menjadi 0 dan juga mengubah nilai agency_code_Department of Housing and Urban Development (HUD) menjadi 1 untuk melihat apa yang akan terjadi pada prediksi model jika pinjaman ini berasal dari HUD:
Seperti yang dapat kita lihat di bagian kiri bawah What-If Tool, mengubah fitur ini akan menurunkan prediksi approved model secara signifikan sebesar 32%. Hal ini dapat menunjukkan bahwa agensi asal pinjaman memiliki dampak yang kuat terhadap output model, tetapi kita perlu melakukan lebih banyak analisis untuk memastikannya.
Di bagian kiri bawah UI, kita juga dapat melihat nilai kebenaran dasar untuk setiap titik data dan membandingkannya dengan prediksi model:
Langkah 3: Analisis kontrafaktual
Selanjutnya, klik titik data mana pun dan geser penggeser Tampilkan titik data counterfactual terdekat ke kanan:
Memilih opsi ini akan menampilkan titik data yang memiliki nilai fitur paling mirip dengan nilai fitur asli yang Anda pilih, tetapi prediksi sebaliknya. Kemudian, Anda dapat men-scroll nilai fitur untuk melihat perbedaan antara kedua titik data (perbedaan ditandai dengan warna hijau dan tebal).
Langkah 4: Lihat plot dependensi parsial
Untuk melihat pengaruh setiap fitur terhadap prediksi model secara keseluruhan, centang kotak Partial dependence plots dan pastikan Global partial dependence plots dipilih:
Di sini kita dapat melihat bahwa pinjaman yang berasal dari HUD memiliki kemungkinan sedikit lebih tinggi untuk ditolak. Bentuk grafik ini karena kode agensi adalah fitur boolean, sehingga nilainya hanya boleh 0 atau 1.
applicant_income_thousands adalah fitur numerik, dan dalam plot dependensi parsial kita dapat melihat bahwa pendapatan yang lebih tinggi sedikit meningkatkan kemungkinan permohonan disetujui, tetapi hanya sekitar $200 ribu. Setelah $200 ribu, fitur ini tidak memengaruhi prediksi model.
Langkah 5: Pelajari performa dan keadilan secara keseluruhan
Selanjutnya, buka tab Performa & Keadilan. Hal ini menunjukkan statistik performa keseluruhan pada hasil model pada set data yang disediakan, termasuk matriks konflik, kurva PR, dan kurva ROC.
Pilih mortgage_status sebagai Fitur Ground Truth untuk melihat matriks konfusi:
Matriks konfusi ini menunjukkan prediksi model kita yang benar dan salah sebagai persentase dari total. Jika Anda menjumlahkan kotak Ya / Prediksi Ya Aktual dan Tidak Aktual / Tidak Aktual, jumlah ini akan menghasilkan akurasi yang sama dengan model Anda (dalam kasus ini sekitar 87%, meskipun model Anda mungkin sedikit berbeda karena ada elemen keacakan dalam melatih model ML).
Anda juga dapat bereksperimen dengan penggeser nilai minimum, menaikkan dan menurunkan skor klasifikasi positif yang harus ditampilkan model sebelum memutuskan untuk memprediksi approved untuk pinjaman, dan melihat pengaruhnya terhadap akurasi, positif palsu, dan negatif palsu. Dalam hal ini, akurasi tertinggi berada di sekitar nilai minimum .55.
Selanjutnya, di dropdown Slice by sebelah kiri, pilih loan_purpose_Home_purchase:
Sekarang Anda akan melihat performa pada dua subset data: slice "0" menunjukkan saat pinjaman bukan untuk pembelian rumah, dan slice "1" menunjukkan saat pinjaman untuk pembelian rumah. Periksa akurasi, positif palsu, dan tingkat negatif palsu antara kedua slice untuk mencari perbedaan performa.
Jika meluaskan baris untuk melihat matriks kebingungan, Anda dapat melihat bahwa model memprediksi "disetujui" untuk ~70% permohonan pinjaman untuk pembelian rumah dan hanya 46% pinjaman yang bukan untuk pembelian rumah (persentase pastinya akan bervariasi pada model Anda):
Jika Anda memilih Paritas demografi dari tombol pilihan di sebelah kiri, kedua nilai minimum akan disesuaikan sehingga model memprediksi approved untuk persentase pelamar yang serupa di kedua bagian. Apa pengaruhnya terhadap akurasi, positif palsu, dan negatif palsu untuk setiap slice?
Langkah 6: Pelajari distribusi fitur
Terakhir, buka tab Fitur di What-if Tool. Langkah ini menunjukkan distribusi nilai untuk setiap fitur dalam set data Anda:
Anda dapat menggunakan tab ini untuk memastikan set data Anda seimbang. Misalnya, tampaknya pinjaman dalam {i>dataset<i} yang berasal dari Badan Layanan Pertanian sangat sedikit. Untuk meningkatkan akurasi model, kami dapat mempertimbangkan untuk menambahkan lebih banyak pinjaman dari agensi tersebut jika datanya tersedia.
Kami telah menjelaskan hanya beberapa ide eksplorasi Alat Perbandingan di sini. Jangan ragu untuk terus mencoba alat ini, ada banyak area lainnya untuk dijelajahi!
8. Men-deploy model ke Vertex AI
Model kita sudah berfungsi secara lokal, tetapi akan lebih baik jika kita dapat membuat prediksi dari mana saja (bukan hanya notebook ini). Pada langkah ini, kita akan men-deploy-nya ke cloud.
Langkah 1: Buat bucket Cloud Storage untuk model kita
Pertama-tama, mari kita tentukan beberapa variabel lingkungan yang akan kita gunakan di seluruh codelab ini. Isi nilai di bawah dengan nama project Google Cloud Anda, nama bucket cloud storage yang ingin Anda buat (harus unik secara global), dan nama versi untuk versi pertama model Anda:
# Update the variables below to your own Google Cloud project ID and GCS bucket name. You can leave the model name we've specified below:
GCP_PROJECT = 'your-gcp-project'
MODEL_BUCKET = 'gs://storage_bucket_name'
MODEL_NAME = 'xgb_mortgage'
Sekarang kita siap membuat bucket penyimpanan untuk menyimpan file model XGBoost. Kita akan mengarahkan Vertex AI ke file ini saat men-deploy.
Jalankan perintah gsutil ini dari dalam notebook Anda untuk membuat bucket penyimpanan regional:
!gsutil mb -l us-central1 $MODEL_BUCKET
Langkah 2: Salin file model ke Cloud Storage
Selanjutnya, kita akan menyalin file model XGBoost yang disimpan ke Cloud Storage. Jalankan perintah gsutil berikut:
!gsutil cp ./model.bst $MODEL_BUCKET
Buka browser penyimpanan di Cloud Console untuk mengonfirmasi bahwa file telah disalin:
Langkah 3: Membuat model dan men-deploy ke endpoint
Kita hampir siap untuk men-deploy model ke cloud. Di Vertex AI, model dapat menyimpan beberapa endpoint. Pertama-tama, kita akan membuat model, lalu membuat endpoint dalam model tersebut dan men-deploy-nya.
Pertama, gunakan CLI gcloud untuk membuat model:
!gcloud beta ai models upload \
--display-name=$MODEL_NAME \
--artifact-uri=$MODEL_BUCKET \
--container-image-uri=us-docker.pkg.dev/cloud-aiplatform/prediction/xgboost-cpu.1-2:latest \
--region=us-central1
Parameter artifact-uri akan mengarah ke lokasi Penyimpanan tempat Anda menyimpan model XGBoost. Parameter container-image-uri memberi tahu Vertex AI container bawaan mana yang akan digunakan untuk penayangan. Setelah perintah ini selesai, buka bagian model di konsol Vertex untuk mendapatkan ID model baru Anda. Anda dapat menemukannya di sini:
Salin ID tersebut dan simpan ke variabel:
MODEL_ID = "your_model_id"
Sekarang saatnya membuat endpoint dalam model ini. Kita dapat melakukannya dengan perintah gcloud ini:
!gcloud beta ai endpoints create \
--display-name=xgb_mortgage_v1 \
--region=us-central1
Setelah selesai, Anda akan melihat lokasi endpoint yang dicatat dalam output notebook kita. Cari baris yang menyatakan bahwa endpoint dibuat dengan jalur yang terlihat seperti berikut: projects/project_ID/locations/us-central1/endpoints/endpoint_ID. Kemudian, ganti nilai di bawah dengan ID endpoint yang Anda buat di atas:
ENDPOINT_ID = "your_endpoint_id"
Untuk men-deploy endpoint, jalankan perintah gcloud di bawah:
!gcloud beta ai endpoints deploy-model $ENDPOINT_ID \
--region=us-central1 \
--model=$MODEL_ID \
--display-name=xgb_mortgage_v1 \
--machine-type=n1-standard-2 \
--traffic-split=0=100
Proses deploy endpoint akan memerlukan waktu sekitar 5-10 menit. Saat endpoint Anda di-deploy, buka bagian model di konsol. Klik pada model Anda dan Anda akan melihat endpiont men-deploy:
Jika deployment berhasil diselesaikan, Anda akan melihat tanda centang hijau di tempat indikator lingkaran berputar.
Langkah 4: Uji model yang di-deploy
Untuk memastikan model yang di-deploy berfungsi, uji menggunakan gcloud untuk membuat prediksi. Pertama, simpan file JSON dengan contoh dari set pengujian kita:
%%writefile predictions.json
{
"instances": [
[2016.0, 1.0, 346.0, 27.0, 211.0, 4530.0, 86700.0, 132.13, 1289.0, 1408.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0]
]
}
Uji model Anda dengan menjalankan perintah gcloud ini:
!gcloud beta ai endpoints predict $ENDPOINT_ID \
--json-request=predictions.json \
--region=us-central1
Anda akan melihat prediksi model di output. Contoh khusus ini telah disetujui, sehingga Anda akan melihat nilai yang mendekati 1.
9. Pembersihan
Jika ingin terus menggunakan notebook ini, sebaiknya nonaktifkan saat tidak digunakan. Dari UI Notebook di Cloud Console, pilih notebook, lalu pilih Stop:
Jika Anda ingin menghapus semua resource yang telah dibuat di lab ini, cukup hapus instance notebook, bukan menghentikannya.
Untuk menghapus endpoint yang di-deploy, buka bagian Endpoint di konsol Vertex dan klik ikon hapus:
Untuk menghapus Bucket Penyimpanan menggunakan menu Navigasi di Cloud Console, jelajahi Penyimpanan, pilih bucket Anda, lalu klik Hapus:
