1. ภาพรวม
ในแล็บนี้ คุณจะได้ใช้เครื่องมือแบบจำลองตามสมมติฐานเพื่อวิเคราะห์โมเดล XGBoost ที่ฝึกด้วยข้อมูลทางการเงิน หลังจากวิเคราะห์โมเดลแล้ว คุณจะทำให้ใช้งานได้ใน Vertex AI ใหม่ของ Cloud
สิ่งที่คุณจะได้เรียนรู้
โดยคุณจะได้เรียนรู้วิธีต่อไปนี้
- ฝึกโมเดล XGBoost ในชุดข้อมูลการจำนองสาธารณะใน Notebook ที่โฮสต์
- วิเคราะห์โมเดลโดยใช้ What-If Tool
- ติดตั้งใช้งานโมเดล XGBoost ใน Vertex AI
ค่าใช้จ่ายทั้งหมดในการเรียกใช้ Lab นี้ใน Google Cloud อยู่ที่ประมาณ $1
2. ข้อมูลเบื้องต้นเกี่ยวกับ Vertex AI
แล็บนี้ใช้ผลิตภัณฑ์ AI ใหม่ล่าสุดที่พร้อมให้บริการใน Google Cloud Vertex AI ผสานรวมข้อเสนอ ML ใน Google Cloud เข้ากับประสบการณ์การพัฒนาที่ราบรื่น ก่อนหน้านี้ โมเดลที่ฝึกด้วย AutoML และโมเดลที่กำหนดเองจะเข้าถึงได้ผ่านบริการแยกต่างหาก ข้อเสนอใหม่นี้จะรวมทั้ง 2 อย่างไว้ใน API เดียว พร้อมกับผลิตภัณฑ์ใหม่อื่นๆ นอกจากนี้ คุณยังย้ายข้อมูลโปรเจ็กต์ที่มีอยู่ไปยัง Vertex AI ได้ด้วย หากมีข้อเสนอแนะ โปรดดูหน้าการสนับสนุน
Vertex AI มีผลิตภัณฑ์มากมายที่แตกต่างกันเพื่อรองรับเวิร์กโฟลว์ ML แบบครบวงจร ห้องทดลองนี้จะมุ่งเน้นที่ผลิตภัณฑ์ที่ไฮไลต์ไว้ด้านล่าง ได้แก่ การคาดการณ์และ Notebook
3. ข้อมูลเบื้องต้นเกี่ยวกับ XGBoost
XGBoost เป็นเฟรมเวิร์กแมชชีนเลิร์นนิงที่ใช้ต้นไม้ตัดสินใจและการเพิ่มประสิทธิภาพแบบไล่ระดับเพื่อสร้างโมเดลการคาดการณ์ โดยจะทำงานด้วยการรวมต้นไม้ตัดสินใจหลายต้นเข้าด้วยกันตามคะแนนที่เชื่อมโยงกับโหนดใบต่างๆ ในต้นไม้
แผนภาพด้านล่างคือภาพของโมเดลต้นไม้ตัดสินใจแบบง่ายๆ ที่ประเมินว่าควรเล่นเกมกีฬาหรือไม่โดยอิงตามพยากรณ์อากาศ
เหตุผลที่เราใช้ XGBoost สำหรับโมเดลนี้ แม้ว่าโครงข่ายประสาทเทียมแบบดั้งเดิมจะทำงานได้ดีที่สุดกับข้อมูลที่ไม่มีโครงสร้าง เช่น รูปภาพและข้อความ แต่ต้นไม้ตัดสินใจมักจะทำงานได้ดีมากกับข้อมูลที่มีโครงสร้าง เช่น ชุดข้อมูลการจำนองที่เราจะใช้ใน Codelab นี้
4. ตั้งค่าสภาพแวดล้อม
คุณจะต้องมีโปรเจ็กต์ Google Cloud Platform ที่เปิดใช้การเรียกเก็บเงินเพื่อเรียกใช้ Codelab นี้ หากต้องการสร้างโปรเจ็กต์ ให้ทำตามวิธีการที่นี่
ขั้นตอนที่ 1: เปิดใช้ Compute Engine API
ไปที่ Compute Engine แล้วเลือกเปิดใช้หากยังไม่ได้เปิดใช้ คุณจะต้องใช้ข้อมูลนี้เพื่อสร้างอินสแตนซ์ Notebook
ขั้นตอนที่ 2: เปิดใช้ Vertex AI API
ไปที่ส่วน Vertex ของ Cloud Console แล้วคลิกเปิดใช้ Vertex AI API
ขั้นตอนที่ 3: สร้างอินสแตนซ์ Notebooks
จากส่วน Vertex ของ Cloud Console ให้คลิก Notebook ดังนี้
จากนั้นเลือกอินสแตนซ์ใหม่ จากนั้นเลือกประเภทอินสแตนซ์ TensorFlow Enterprise 2.3 ที่ไม่มี GPU ดังนี้
ใช้ตัวเลือกเริ่มต้น แล้วคลิกสร้าง เมื่อสร้างอินสแตนซ์แล้ว ให้เลือกเปิด JupyterLab
ขั้นตอนที่ 4: ติดตั้ง XGBoost
เมื่ออินสแตนซ์ JupyterLab เปิดขึ้นแล้ว คุณจะต้องเพิ่มแพ็กเกจ XGBoost
โดยเลือก Terminal จาก Launcher ดังนี้
จากนั้นเรียกใช้คำสั่งต่อไปนี้เพื่อติดตั้ง XGBoost เวอร์ชันล่าสุดที่ Vertex AI รองรับ
pip3 install xgboost==1.2
หลังจากขั้นตอนนี้เสร็จสมบูรณ์แล้ว ให้เปิดอินสแตนซ์ Notebook ของ Python 3 จากตัวเรียกใช้ คุณพร้อมที่จะเริ่มต้นใน Notebook แล้ว
ขั้นตอนที่ 5: นำเข้าแพ็กเกจ Python
ในเซลล์แรกของ Notebook ให้เพิ่มการนำเข้าต่อไปนี้และเรียกใช้เซลล์ คุณดำเนินการได้โดยกดปุ่มลูกศรขวาในเมนูด้านบนหรือกด 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. ดาวน์โหลดและประมวลผลข้อมูล
เราจะใช้ชุดข้อมูลการจำนองจาก ffiec.gov เพื่อฝึกโมเดล XGBoost เราได้ทำการประมวลผลล่วงหน้าในชุดข้อมูลต้นฉบับและสร้างเวอร์ชันที่เล็กลงเพื่อให้คุณใช้ฝึกโมเดล โมเดลจะคาดการณ์ว่าการสมัครขอสินเชื่อที่อยู่อาศัยหนึ่งๆ จะได้รับอนุมัติหรือไม่
ขั้นตอนที่ 1: ดาวน์โหลดชุดข้อมูลที่ประมวลผลล่วงหน้า
เราได้จัดทำชุดข้อมูลเวอร์ชันหนึ่งให้คุณใช้งานใน Google Cloud Storage แล้ว คุณดาวน์โหลดได้โดยเรียกใช้gsutilคำสั่งต่อไปนี้ใน Jupyter Notebook
!gsutil cp 'gs://mortgage_dataset_files/mortgage-small.csv' .
ขั้นตอนที่ 2: อ่านชุดข้อมูลด้วย Pandas
ก่อนที่จะสร้าง Pandas DataFrame เราจะสร้าง dict ของประเภทข้อมูลของแต่ละคอลัมน์เพื่อให้ Pandas อ่านชุดข้อมูลได้อย่างถูกต้อง
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
})
จากนั้นเราจะสร้าง DataFrame โดยส่งประเภทข้อมูลที่เราระบุไว้ข้างต้น การสับเปลี่ยนข้อมูลเป็นสิ่งสำคัญในกรณีที่ชุดข้อมูลต้นฉบับมีการจัดเรียงในลักษณะที่เฉพาะเจาะจง เราใช้ยูทิลิตี sklearn ที่ชื่อ shuffle เพื่อดำเนินการนี้ ซึ่งเราได้นำเข้าในเซลล์แรกแล้ว
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() ช่วยให้เราดูตัวอย่าง 5 แถวแรกของชุดข้อมูลใน Pandas ได้ คุณควรเห็นผลลัพธ์คล้ายกับด้านล่างนี้หลังจากเรียกใช้เซลล์ด้านบน
ฟีเจอร์เหล่านี้คือฟีเจอร์ที่เราจะใช้ในการฝึกโมเดล หากเลื่อนไปจนสุด คุณจะเห็นคอลัมน์สุดท้าย approved ซึ่งเป็นสิ่งที่เราคาดการณ์ ค่า 1 แสดงว่าแอปพลิเคชันนั้นๆ ได้รับอนุมัติ และ 0 แสดงว่าแอปพลิเคชันนั้นๆ ถูกปฏิเสธ
หากต้องการดูการกระจายค่าที่อนุมัติ / ปฏิเสธในชุดข้อมูลและสร้างอาร์เรย์ Numpy ของป้ายกำกับ ให้เรียกใช้คำสั่งต่อไปนี้
# Class labels - 0: denied, 1: approved
print(data['approved'].value_counts())
labels = data['approved'].values
data = data.drop(columns=['approved'])
ประมาณ 66% ของชุดข้อมูลมีแอปพลิเคชันที่ได้รับอนุมัติ
ขั้นตอนที่ 3: สร้างคอลัมน์ดัมมี่สำหรับค่าหมวดหมู่
ชุดข้อมูลนี้มีทั้งค่าเชิงหมวดหมู่และค่าตัวเลข แต่ XGBoost กำหนดให้ฟีเจอร์ทั้งหมดต้องเป็นตัวเลข แทนที่จะแสดงค่าเชิงหมวดหมู่โดยใช้การเข้ารหัสแบบ One-hot สำหรับโมเดล XGBoost เราจะใช้ประโยชน์จากฟังก์ชัน get_dummies ของ Pandas
get_dummies จะใช้คอลัมน์ที่มีค่าที่เป็นไปได้หลายค่าและแปลงเป็นชุดคอลัมน์ที่มีเฉพาะ 0 และ 1 เช่น หากเรามีคอลัมน์ "color" ที่มีค่าที่เป็นไปได้คือ "blue" และ "red" get_dummies จะเปลี่ยนคอลัมน์นี้เป็น 2 คอลัมน์ชื่อ "color_blue" และ "color_red" ที่มีค่าบูลีนทั้งหมดเป็น 0 และ 1
หากต้องการสร้างคอลัมน์จำลองสำหรับฟีเจอร์เชิงหมวดหมู่ ให้เรียกใช้โค้ดต่อไปนี้
dummy_columns = list(data.dtypes[data.dtypes == 'category'].index)
data = pd.get_dummies(data, columns=dummy_columns)
data.head()
เมื่อแสดงตัวอย่างข้อมูลในครั้งนี้ คุณจะเห็นฟีเจอร์เดียว (เช่น purchaser_type ในภาพด้านล่าง) แยกเป็นหลายคอลัมน์ ดังนี้
ขั้นตอนที่ 4: แบ่งข้อมูลออกเป็นชุดการฝึกและชุดการทดสอบ
แนวคิดสำคัญในแมชชีนเลิร์นนิงคือการแยกข้อมูลออกเป็นชุดฝึกและชุดทดสอบ เราจะนำข้อมูลส่วนใหญ่ไปใช้ฝึกโมเดล และจะเก็บข้อมูลที่เหลือไว้เพื่อทดสอบโมเดลกับข้อมูลที่ไม่เคยเห็นมาก่อน
เพิ่มโค้ดต่อไปนี้ลงใน Notebook ซึ่งใช้ฟังก์ชัน train_test_split ของ Scikit-learn เพื่อแยกข้อมูล
x,y = data.values,labels
x_train,x_test,y_train,y_test = train_test_split(x,y)
ตอนนี้คุณก็พร้อมสร้างและฝึกโมเดลแล้ว
6. สร้าง ฝึก และประเมินโมเดล XGBoost
ขั้นตอนที่ 1: กำหนดและฝึกโมเดล XGBoost
การสร้างโมเดลใน XGBoost นั้นง่ายนิดเดียว เราจะใช้คลาส XGBClassifier เพื่อสร้างโมเดล และเพียงแค่ต้องส่งพารามิเตอร์ objective ที่ถูกต้องสำหรับงานการจัดประเภทที่เฉพาะเจาะจง ในกรณีนี้ เราใช้ reg:logistic เนื่องจากเรามีปัญหาการจัดประเภทแบบไบนารี และต้องการให้โมเดลแสดงค่าเดียวในช่วง (0,1): 0 สำหรับไม่อนุมัติ และ 1 สำหรับอนุมัติ
โค้ดต่อไปนี้จะสร้างโมเดล XGBoost
model = xgb.XGBClassifier(
objective='reg:logistic'
)
คุณฝึกโมเดลได้ด้วยโค้ดเพียงบรรทัดเดียว โดยเรียกใช้เมธอด fit() และส่งข้อมูลฝึกฝนและป้ายกำกับไปยังเมธอดนั้น
model.fit(x_train, y_train)
ขั้นตอนที่ 2: ประเมินความแม่นยำของโมเดล
ตอนนี้เราสามารถใช้โมเดลที่ฝึกแล้วเพื่อสร้างการคาดการณ์ในข้อมูลทดสอบด้วยฟังก์ชัน predict() ได้แล้ว
จากนั้นเราจะใช้ฟังก์ชัน accuracy_score() ของ Scikit-learn เพื่อคำนวณความแม่นยำของโมเดลตามประสิทธิภาพของโมเดลในข้อมูลทดสอบ เราจะส่งค่าความจริงพื้นฐานพร้อมกับค่าที่โมเดลคาดการณ์ไว้สำหรับแต่ละตัวอย่างในชุดทดสอบ
y_pred = model.predict(x_test)
acc = accuracy_score(y_test, y_pred.round())
print(acc, '\n')
คุณควรเห็นความแม่นยำประมาณ 87% แต่ความแม่นยำของคุณจะแตกต่างกันเล็กน้อยเนื่องจากแมชชีนเลิร์นนิงมีองค์ประกอบของความสุ่มอยู่เสมอ
ขั้นตอนที่ 3: บันทึกโมเดล
หากต้องการทำให้โมเดลใช้งานได้ ให้เรียกใช้โค้ดต่อไปนี้เพื่อบันทึกโมเดลลงในไฟล์ในเครื่อง
model.save_model('model.bst')
7. ใช้เครื่องมือวิเคราะห์สถานการณ์สมมติเพื่อตีความโมเดล
ขั้นตอนที่ 1: สร้างภาพเครื่องมือวิเคราะห์สถานการณ์สมมติ
หากต้องการเชื่อมต่อเครื่องมือ What-if กับโมเดลในเครื่อง คุณต้องส่งตัวอย่างการทดสอบบางส่วนพร้อมกับค่าความจริงพื้นฐานสำหรับตัวอย่างเหล่านั้น มาสร้างอาร์เรย์ Numpy ของตัวอย่างทดสอบ 500 รายการพร้อมกับป้ายกำกับความจริงพื้นฐานกัน
num_wit_examples = 500
test_examples = np.hstack((x_test[:num_wit_examples],y_test[:num_wit_examples].reshape(-1,1)))
การเริ่มต้นใช้เครื่องมือ What-if นั้นง่ายเพียงแค่สร้างออบเจ็กต์ WitConfigBuilder แล้วส่งโมเดลที่เราต้องการวิเคราะห์ไปให้
เนื่องจากเครื่องมือ What-If Tool คาดหวังรายการคะแนนสำหรับแต่ละคลาสในโมเดล (ในกรณีนี้คือ 2) เราจะใช้วิธี predict_proba ของ XGBoost กับเครื่องมือ 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)
โปรดทราบว่าระบบจะใช้เวลา 1 นาทีในการโหลดการแสดงข้อมูลผ่านภาพ เมื่อโหลดแล้ว คุณควรเห็นสิ่งต่อไปนี้
แกน Y แสดงการคาดการณ์ของโมเดล โดย 1 คือการคาดการณ์ที่มีค่าความเชื่อมั่นสูง approved และ 0 คือการคาดการณ์ที่มีค่าความเชื่อมั่นสูง denied แกน x คือการกระจายของจุดข้อมูลที่โหลดทั้งหมด
ขั้นตอนที่ 2: สำรวจจุดข้อมูลแต่ละจุด
มุมมองเริ่มต้นในเครื่องมือ What-if คือแท็บเอดิเตอร์จุดข้อมูล ในส่วนนี้ คุณสามารถคลิกจุดข้อมูลแต่ละจุดเพื่อดูฟีเจอร์ เปลี่ยนค่าฟีเจอร์ และดูว่าการเปลี่ยนแปลงดังกล่าวส่งผลต่อการคาดการณ์ของโมเดลในจุดข้อมูลแต่ละจุดอย่างไร
ในตัวอย่างด้านล่าง เราเลือกจุดข้อมูลที่ใกล้กับเกณฑ์ .5 ใบสมัครขอสินเชื่อที่อยู่อาศัยที่เชื่อมโยงกับจุดข้อมูลนี้มาจาก CFPB เราเปลี่ยนฟีเจอร์นั้นเป็น 0 และเปลี่ยนค่าของ agency_code_Department of Housing and Urban Development (HUD) เป็น 1 เพื่อดูว่าจะเกิดอะไรขึ้นกับการคาดการณ์ของโมเดลหากเงินกู้นี้มาจาก HUD แทน
ดังที่เห็นในส่วนด้านซ้ายล่างของเครื่องมือ What-if การเปลี่ยนฟีเจอร์นี้ทำให้approvedการคาดการณ์ของโมเดลลดลงอย่างมากถึง 32% ซึ่งอาจบ่งชี้ว่าเอเจนซีที่ให้กู้เงินมีผลกระทบอย่างมากต่อเอาต์พุตของโมเดล แต่เราจะต้องทำการวิเคราะห์เพิ่มเติมเพื่อให้แน่ใจ
ที่ด้านซ้ายล่างของ UI เรายังเห็นค่าข้อมูลที่เป็นความจริงสำหรับจุดข้อมูลแต่ละจุดและเปรียบเทียบกับค่าที่โมเดลคาดการณ์ได้ด้วย
ขั้นตอนที่ 3: การวิเคราะห์แบบ Counterfactual
จากนั้นคลิกจุดข้อมูลใดก็ได้ แล้วเลื่อนแถบเลื่อนแสดงจุดข้อมูลแบบจำลองที่ใกล้ที่สุดไปทางขวา
การเลือกตัวเลือกนี้จะแสดงจุดข้อมูลที่มีค่าฟีเจอร์ที่คล้ายกันมากที่สุดกับค่าเดิมที่คุณเลือก แต่มีการคาดการณ์ตรงกันข้าม จากนั้นคุณจะเลื่อนดูค่าฟีเจอร์เพื่อดูว่าจุดข้อมูล 2 จุดแตกต่างกันตรงไหน (ความแตกต่างจะไฮไลต์เป็นสีเขียวและตัวหนา)
ขั้นตอนที่ 4: ดูแผนภาพการพึ่งพาบางส่วน
หากต้องการดูว่าฟีเจอร์แต่ละรายการส่งผลต่อการคาดการณ์ของโมเดลโดยรวมอย่างไร ให้เลือกช่องพล็อตการขึ้นอยู่บางส่วน และตรวจสอบว่าได้เลือกพล็อตการขึ้นอยู่บางส่วนทั่วโลกแล้ว
เราจะเห็นว่าสินเชื่อที่มาจาก HUD มีแนวโน้มที่จะถูกปฏิเสธสูงกว่าเล็กน้อย กราฟมีรูปร่างเช่นนี้เนื่องจากรหัสเอเจนซีเป็นฟีเจอร์บูลีน ค่าจึงเป็นได้เพียง 0 หรือ 1 เท่านั้น
applicant_income_thousands เป็นฟีเจอร์เชิงตัวเลข และในแผนภาพการพึ่งพาบางส่วน เราจะเห็นว่ารายได้ที่สูงขึ้นจะเพิ่มโอกาสที่แอปพลิเคชันจะได้รับการอนุมัติเล็กน้อย แต่จะเพิ่มขึ้นไม่เกินประมาณ 200,000 ดอลลาร์สหรัฐ หลังจาก $200, 000 ฟีเจอร์นี้จะไม่มีผลต่อการคาดการณ์ของโมเดล
ขั้นตอนที่ 5: สำรวจประสิทธิภาพและความเป็นธรรมโดยรวม
จากนั้นไปที่แท็บประสิทธิภาพและความเป็นธรรม ซึ่งจะแสดงสถิติประสิทธิภาพโดยรวมเกี่ยวกับผลลัพธ์ของโมเดลในชุดข้อมูลที่ระบุ รวมถึงเมทริกซ์ความสับสน เส้นโค้ง PR และเส้นโค้ง ROC
เลือก mortgage_status เป็นฟีเจอร์ความจริงพื้นฐานเพื่อดูเมทริกซ์ความสับสน
เมทริกซ์ความสับสนนี้แสดงการคาดการณ์ที่ถูกต้องและไม่ถูกต้องของโมเดลเป็นเปอร์เซ็นต์ของทั้งหมด หากคุณรวมช่อง Actual Yes / Predicted Yes และ Actual No / Predicted No เข้าด้วยกัน ค่าที่ได้ควรมีความแม่นยำเท่ากับโมเดลของคุณ (ในกรณีนี้คือประมาณ 87% แม้ว่าโมเดลของคุณอาจแตกต่างกันเล็กน้อยเนื่องจากมีการสุ่มในการฝึกโมเดล ML)
นอกจากนี้ คุณยังทดสอบแถบเลื่อนเกณฑ์ โดยการเพิ่มและลดคะแนนการจัดประเภทเชิงบวกที่โมเดลต้องส่งคืนก่อนที่จะตัดสินใจคาดการณ์ว่าapprovedสำหรับเงินกู้ และดูว่าการดำเนินการดังกล่าวจะเปลี่ยนแปลงความแม่นยำ ผลบวกลวง และผลลบลวงอย่างไร ในกรณีนี้ ความแม่นยำจะสูงสุดที่เกณฑ์ .55
จากนั้นทางด้านซ้าย ให้เลือก loan_purpose_Home_purchase ในเมนูแบบเลื่อนลงแบ่งตาม
ตอนนี้คุณจะเห็นประสิทธิภาพใน 2 ข้อมูลย่อย ได้แก่ สไลซ์ "0" จะแสดงเมื่อเงินกู้ไม่ได้ใช้ซื้อบ้าน และสไลซ์ "1" จะแสดงเมื่อเงินกู้ใช้ซื้อบ้าน ดูอัตราความแม่นยำ อัตราผลบวกลวง และอัตราผลลบลวงระหว่าง 2 กลุ่มย่อยเพื่อดูความแตกต่างของประสิทธิภาพ
หากขยายแถวเพื่อดูเมทริกซ์ความสับสน คุณจะเห็นว่าโมเดลคาดการณ์ว่า "อนุมัติ" สำหรับใบสมัครขอสินเชื่อเพื่อซื้อบ้านประมาณ 70% และมีเพียง 46% ของสินเชื่อที่ไม่ได้ใช้ซื้อบ้าน (เปอร์เซ็นต์ที่แน่นอนจะแตกต่างกันไปตามโมเดล)
หากเลือกความเท่าเทียมกันทางประชากรจากปุ่มตัวเลือกทางด้านซ้าย ระบบจะปรับเกณฑ์ทั้ง 2 รายการเพื่อให้โมเดลคาดการณ์ approved สำหรับผู้สมัครที่มีเปอร์เซ็นต์คล้ายกันในทั้ง 2 กลุ่ม การดำเนินการนี้ส่งผลต่อความแม่นยำ ผลบวกลวง และผลลบลวงของแต่ละกลุ่มย่อยอย่างไร
ขั้นตอนที่ 6: สำรวจการเผยแพร่ฟีเจอร์
สุดท้าย ให้ไปที่แท็บฟีเจอร์ในเครื่องมือ What-if ซึ่งจะแสดงการกระจายค่าสำหรับแต่ละฟีเจอร์ในชุดข้อมูล
คุณใช้แท็บนี้เพื่อให้แน่ใจว่าชุดข้อมูลมีความสมดุล ตัวอย่างเช่น ดูเหมือนว่ามีเงินกู้เพียงไม่กี่รายการในชุดข้อมูลที่มาจาก Farm Service Agency เราอาจพิจารณาเพิ่มเงินกู้จากหน่วยงานดังกล่าวหากมีข้อมูล เพื่อปรับปรุงความแม่นยำของโมเดล
เราอธิบายรายละเอียดไอเดียการสำรวจเครื่องมือ What-if เพียงบางส่วนไว้ที่นี่ คุณสามารถลองใช้เครื่องมือนี้ต่อไปได้เลย ยังมีอีกหลายส่วนให้สำรวจ
8. ทำให้โมเดลใช้งานได้ใน Vertex AI
เรามีโมเดลที่ทำงานในเครื่อง แต่คงจะดีถ้าเราสามารถทำการคาดการณ์ในโมเดลได้จากทุกที่ (ไม่ใช่แค่ใน Notebook นี้) ในขั้นตอนนี้ เราจะทำให้ใช้งานได้ในระบบคลาวด์
ขั้นตอนที่ 1: สร้าง Bucket ของ Cloud Storage สำหรับโมเดล
ก่อนอื่นเรามากำหนดตัวแปรสภาพแวดล้อมบางอย่างที่จะใช้ตลอดทั้ง Codelab ที่เหลือกัน กรอกค่าด้านล่างด้วยชื่อโปรเจ็กต์ Google Cloud, ชื่อของ Bucket ใน Cloud Storage ที่คุณต้องการสร้าง (ต้องไม่ซ้ำกันทั่วโลก) และชื่อเวอร์ชันสำหรับโมเดลเวอร์ชันแรก
# 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'
ตอนนี้เราพร้อมที่จะสร้างที่เก็บข้อมูลเพื่อจัดเก็บไฟล์โมเดล XGBoost แล้ว เราจะชี้ Vertex AI ไปยังไฟล์นี้เมื่อเราทำให้ใช้งานได้
เรียกใช้gsutil คำสั่งนี้จากภายใน Notebook เพื่อสร้างที่เก็บข้อมูลระดับภูมิภาค
!gsutil mb -l us-central1 $MODEL_BUCKET
ขั้นตอนที่ 2: คัดลอกไฟล์โมเดลไปยัง Cloud Storage
จากนั้นเราจะคัดลอกไฟล์โมเดลที่บันทึกไว้ของ XGBoost ไปยัง Cloud Storage เรียกใช้คำสั่ง gsutil ต่อไปนี้
!gsutil cp ./model.bst $MODEL_BUCKET
ไปที่เบราว์เซอร์พื้นที่เก็บข้อมูลใน Cloud Console เพื่อยืนยันว่าระบบได้คัดลอกไฟล์แล้ว
ขั้นตอนที่ 3: สร้างโมเดลและนำไปใช้งานที่ปลายทาง
เราพร้อมที่จะทำให้โมเดลใช้งานได้ในระบบคลาวด์แล้ว ใน Vertex AI โมเดลสามารถมีปลายทางได้หลายรายการ ก่อนอื่นเราจะสร้างโมเดล จากนั้นจะสร้างปลายทางภายในโมเดลนั้นและทำการติดตั้งใช้งาน
ก่อนอื่น ให้ใช้ gcloud CLI เพื่อสร้างโมเดล
!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
พารามิเตอร์ artifact-uri จะชี้ไปยังตำแหน่งที่เก็บข้อมูลที่คุณบันทึกโมเดล XGBoost พารามิเตอร์ container-image-uri จะบอก Vertex AI ว่าจะใช้คอนเทนเนอร์ที่สร้างไว้ล่วงหน้าใดในการแสดงผล เมื่อคำสั่งนี้เสร็จสมบูรณ์ ให้ไปที่ส่วนโมเดลของคอนโซล Vertex เพื่อรับรหัสของโมเดลใหม่ คุณดูได้ที่นี่
คัดลอกรหัสนั้นและบันทึกลงในตัวแปร
MODEL_ID = "your_model_id"
ตอนนี้ถึงเวลาสร้างปลายทางภายในโมเดลนี้แล้ว ซึ่งทำได้โดยใช้คำสั่ง gcloud นี้
!gcloud beta ai endpoints create \
--display-name=xgb_mortgage_v1 \
--region=us-central1
เมื่อเสร็จแล้ว คุณควรเห็นตำแหน่งของปลายทางที่บันทึกไว้ในเอาต์พุตของ Notebook มองหาบรรทัดที่ระบุว่าสร้างปลายทางด้วยเส้นทางที่มีลักษณะดังนี้ projects/project_ID/locations/us-central1/endpoints/endpoint_ID. จากนั้นแทนที่ค่าด้านล่างด้วยรหัสของปลายทางที่สร้างไว้ข้างต้น
ENDPOINT_ID = "your_endpoint_id"
หากต้องการทําให้ปลายทางใช้งานได้ ให้เรียกใช้คําสั่ง gcloud ด้านล่าง
!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
การทำให้ปลายทางใช้งานได้จะใช้เวลาประมาณ 5-10 นาที ขณะที่ระบบกำลังทำให้ปลายทางใช้งานได้ ให้ไปที่ส่วนโมเดลของคอนโซล คลิกโมเดลของคุณ แล้วคุณจะเห็นว่าระบบกำลังทำให้ปลายทางใช้งานได้
เมื่อการทำให้ใช้งานได้เสร็จสมบูรณ์ คุณจะเห็นเครื่องหมายถูกสีเขียวตรงที่ไอคอนหมุนแสดงการโหลด
ขั้นตอนที่ 4: ทดสอบโมเดลที่ใช้งานจริง
หากต้องการตรวจสอบว่าโมเดลที่ใช้งานได้ทำงานอยู่ ให้ทดสอบโดยใช้ gcloud เพื่อทำการคาดการณ์ ก่อนอื่น ให้บันทึกไฟล์ JSON ที่มีตัวอย่างจากชุดทดสอบของเรา
%%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]
]
}
ทดสอบโมเดลโดยเรียกใช้คำสั่ง gcloud นี้
!gcloud beta ai endpoints predict $ENDPOINT_ID \
--json-request=predictions.json \
--region=us-central1
คุณควรเห็นการคาดการณ์ของโมเดลในเอาต์พุต ตัวอย่างนี้ได้รับการอนุมัติแล้ว คุณจึงควรเห็นค่าที่ใกล้เคียงกับ 1
9. ล้างข้อมูล
หากต้องการใช้ Notebook นี้ต่อไป ขอแนะนำให้ปิดเมื่อไม่ได้ใช้งาน จาก UI ของ Notebook ใน Cloud Console ให้เลือก Notebook แล้วเลือกหยุด
หากต้องการลบทรัพยากรทั้งหมดที่คุณสร้างไว้ใน Lab นี้ ให้ลบอินสแตนซ์ Notebook แทนการหยุด
หากต้องการลบปลายทางที่คุณทำให้ใช้งานได้ ให้ไปที่ส่วนปลายทางของคอนโซล Vertex แล้วคลิกไอคอนลบ
หากต้องการลบ Storage Bucket ให้ใช้เมนูการนำทางใน Cloud Console ไปที่ Storage เลือก Bucket แล้วคลิกลบ
