1. ภาพรวม
ในชั้นเรียนนี้ คุณจะใช้เครื่องมือ "What-if" เพื่อวิเคราะห์โมเดล XGBoost ที่ผ่านการฝึกอบรมด้วยข้อมูลทางการเงิน หลังจากวิเคราะห์โมเดลแล้ว คุณจะทำให้โมเดลใช้งานได้กับ Vertex AI ใหม่ของ Cloud
สิ่งที่ได้เรียนรู้
โดยคุณจะได้เรียนรู้วิธีต่อไปนี้
- ฝึกโมเดล XGBoost ในชุดข้อมูลการจํานองสาธารณะในโน้ตบุ๊กที่โฮสต์
- วิเคราะห์โมเดลโดยใช้เครื่องมือ "What-If"
- ทำให้โมเดล XGBoost ใช้งานได้กับ Vertex AI
ต้นทุนทั้งหมดในการใช้งานห้องทดลองนี้ใน Google Cloud อยู่ที่ประมาณ $1
2. ข้อมูลเบื้องต้นเกี่ยวกับ Vertex AI
ห้องทดลองนี้ใช้ข้อเสนอผลิตภัณฑ์ AI ใหม่ล่าสุดที่มีให้บริการใน Google Cloud Vertex AI ผสานรวมข้อเสนอ ML ทั่วทั้ง Google Cloud เข้าด้วยกันเพื่อมอบประสบการณ์การพัฒนาที่ราบรื่น ก่อนหน้านี้ โมเดลที่ฝึกด้วย AutoML และโมเดลที่กำหนดเองจะเข้าถึงได้ผ่านบริการแยกต่างหาก ข้อเสนอใหม่นี้รวมทั้ง 2 รายการไว้ใน API เดียว พร้อมกับผลิตภัณฑ์ใหม่อื่นๆ นอกจากนี้ คุณยังย้ายข้อมูลโปรเจ็กต์ที่มีอยู่ไปยัง Vertex AI ได้ด้วย หากมีความคิดเห็น โปรดดูหน้าการสนับสนุน
Vertex AI มีผลิตภัณฑ์ต่างๆ มากมายเพื่อรองรับเวิร์กโฟลว์ ML แบบครบวงจร ห้องทดลองนี้จะมุ่งเน้นที่ผลิตภัณฑ์ที่ไฮไลต์ไว้ด้านล่าง ได้แก่ การคาดการณ์และโน้ตบุ๊ก
3. ข้อมูลเบื้องต้นเกี่ยวกับ XGBoost
XGBoost เป็นเฟรมเวิร์กแมชชีนเลิร์นนิงที่ใช้แผนผังการตัดสินใจและการเพิ่มประสิทธิภาพด้วย Gradient เพื่อสร้างโมเดลการคาดการณ์ ซึ่งทำงานโดยการรวมต้นไม้การตัดสินใจหลายต้นเข้าด้วยกัน โดยอิงตามคะแนนที่เกี่ยวข้องกับโหนดใบไม้ต่างๆ ในต้นไม้
แผนภาพด้านล่างคือภาพของโมเดลต้นไม้การตัดสินใจแบบง่ายที่ประเมินว่าควรจัดการแข่งขันกีฬาหรือไม่โดยอิงตามการพยากรณ์อากาศ
เหตุใดเราจึงใช้ XGBoost สําหรับโมเดลนี้ แม้ว่าระบบประสาทเทียมแบบดั้งเดิมจะมีประสิทธิภาพดีที่สุดกับข้อมูลที่ไม่มีโครงสร้าง เช่น รูปภาพและข้อความ แต่แผนภูมิการตัดสินใจมักจะมีประสิทธิภาพดีมากกับข้อมูลที่มีโครงสร้าง เช่น ชุดข้อมูลการจำนองที่เราจะใช้ในโค้ดแล็บนี้
4. ตั้งค่าสภาพแวดล้อม
คุณต้องมีโปรเจ็กต์ Google Cloud Platform ที่เปิดใช้การเรียกเก็บเงินเพื่อเรียกใช้โค้ดแล็บนี้ หากต้องการสร้างโปรเจ็กต์ ให้ทำตามวิธีการที่นี่
ขั้นตอนที่ 1: เปิดใช้ Compute Engine API
ไปที่ Compute Engine แล้วเลือกเปิดใช้ หากยังไม่ได้เปิดใช้ คุณต้องใช้ข้อมูลนี้เพื่อสร้างอินสแตนซ์สมุดบันทึก
ขั้นตอนที่ 2: เปิดใช้ Vertex AI API
ไปที่ส่วน Vertex ของ Cloud Console แล้วคลิกเปิดใช้ Vertex AI API
ขั้นตอนที่ 3: สร้างอินสแตนซ์สมุดบันทึก
จากส่วน Vertex ของ Cloud Console ให้คลิกสมุดบันทึกโดยทำดังนี้
จากนั้นเลือกอินสแตนซ์ใหม่ จากนั้นเลือกประเภทอินสแตนซ์ TensorFlow Enterprise 2.3 ที่ไม่มี GPU
ใช้ตัวเลือกเริ่มต้น แล้วคลิกสร้าง เมื่อสร้างอินสแตนซ์แล้ว ให้เลือก Open JupyterLab
ขั้นตอนที่ 4: ติดตั้ง XGBoost
เมื่ออินสแตนซ์ JupyterLab เปิดขึ้นแล้ว คุณจะต้องเพิ่มแพ็กเกจ XGBoost
โดยเลือกเทอร์มินัลจากตัวเปิดแอป
จากนั้นเรียกใช้คำสั่งต่อไปนี้เพื่อติดตั้ง XGBoost เวอร์ชันล่าสุดที่ Vertex AI รองรับ
pip3 install xgboost==1.2
หลังจากขั้นตอนนี้เสร็จสมบูรณ์แล้ว ให้เปิดอินสแตนซ์สมุดบันทึก Python 3 จาก Launcher คุณพร้อมที่จะเริ่มต้นใช้งานโน้ตบุ๊กแล้ว
ขั้นตอนที่ 5: นําเข้าแพ็กเกจ Python
ในเซลล์แรกของโน้ตบุ๊ก ให้เพิ่มการนําเข้าต่อไปนี้แล้วเรียกใช้เซลล์ โดยกดปุ่มลูกศรขวาในเมนูด้านบนหรือกด 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 กำหนดให้ฟีเจอร์ทั้งหมดต้องเป็นตัวเลข เราจะใช้ประโยชน์จากฟังก์ชัน get_dummies ของ Pandas สำหรับโมเดล XGBoost แทนการนำเสนอค่าเชิงหมวดหมู่โดยใช้การเข้ารหัสแบบฮอตเวิร์ก
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: การแยกข้อมูลออกเป็นชุดการฝึกและชุดทดสอบ
แนวคิดที่สําคัญในแมชชีนเลิร์นนิงคือการแยกชุดข้อมูลที่ใช้ฝึก / ชุดข้อมูลที่ใช้ทดสอบ เราจะนำข้อมูลส่วนใหญ่ไปใช้ฝึกโมเดล และเก็บข้อมูลที่เหลือไว้เพื่อทดสอบโมเดลกับข้อมูลที่ไม่เคยเห็นมาก่อน
เพิ่มโค้ดต่อไปนี้ลงในโน้ตบุ๊ค ซึ่งใช้ฟังก์ชัน Scikit-learn train_test_split เพื่อแยกข้อมูล
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. ใช้เครื่องมือ "What-if" เพื่อตีความโมเดล
ขั้นตอนที่ 1: สร้างการแสดงภาพเครื่องมือ "What-if"
หากต้องการเชื่อมต่อเครื่องมือ "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" ต้องการรายการคะแนนสำหรับแต่ละคลาสในโมเดล (ในกรณีนี้ 2 คลาส) เราจะใช้เมธอด predict_proba ของ XGBoost กับเครื่องมือ "What-If" ดังนี้
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" คือแท็บเครื่องมือแก้ไขจุดข้อมูล ในส่วนนี้ คุณสามารถคลิกจุดข้อมูลแต่ละจุดเพื่อดูฟีเจอร์ เปลี่ยนค่าฟีเจอร์ และดูว่าการเปลี่ยนแปลงดังกล่าวส่งผลต่อการคาดการณ์ของโมเดลในจุดข้อมูลแต่ละจุดอย่างไร
ในตัวอย่างนี้ เราเลือกจุดข้อมูลที่ใกล้เคียงกับเกณฑ์ 0.5 การสมัครขอสินเชื่อที่อยู่อาศัยที่เชื่อมโยงกับจุดข้อมูลนี้มาจาก CFPB เราเปลี่ยนฟีเจอร์นั้นเป็น 0 และเปลี่ยนค่า agency_code_Department of Housing and Urban Development (HUD) เป็น 1 ด้วยเพื่อดูว่าจะเกิดอะไรขึ้นกับการคาดการณ์ของโมเดลหากสินเชื่อนี้มาจาก HUD แทน
ดังที่เห็นในส่วนด้านซ้ายล่างของเครื่องมือ "What-if" การเปลี่ยนแปลงฟีเจอร์นี้ทำให้การคาดการณ์ approved ของโมเดลลดลง 32% อย่างมีนัยสำคัญ กรณีนี้อาจบ่งชี้ว่าเอเจนซีที่เป็นต้นกำเนิดการกู้ยืมมีผลกระทบอย่างมากต่อผลลัพธ์ของโมเดล แต่เราต้องทำการวิเคราะห์เพิ่มเติมเพื่อความแน่ใจ
ในส่วนด้านซ้ายล่างของ UI เราจะเห็นค่าข้อมูลจากการสังเกตการณ์โดยตรงสำหรับจุดข้อมูลแต่ละจุดและเปรียบเทียบกับค่าที่คาดการณ์ของโมเดลได้ด้วย
ขั้นตอนที่ 3: การวิเคราะห์แบบเทียบกับกลุ่มควบคุม
ถัดไป ให้คลิกจุดข้อมูลใดก็ได้ แล้วเลื่อนแถบเลื่อนแสดงจุดข้อมูลสมมติที่ใกล้ที่สุดไปทางขวา
การเลือกตัวเลือกนี้จะแสดงจุดข้อมูลที่มีค่าองค์ประกอบที่คล้ายกันที่สุดกับจุดข้อมูลเดิมที่คุณเลือก แต่มีการคาดการณ์ตรงข้าม จากนั้นเลื่อนดูค่าของฟีเจอร์เพื่อดูจุดที่จุดข้อมูล 2 จุดแตกต่างกัน (ระบบจะไฮไลต์ความแตกต่างเป็นสีเขียวและตัวหนา)
ขั้นตอนที่ 4: ดูผังความเกี่ยวข้องบางส่วน
หากต้องการดูว่าฟีเจอร์แต่ละรายการส่งผลต่อการคาดการณ์โดยรวมของโมเดลอย่างไร ให้เลือกช่องผังความเกี่ยวข้องบางส่วน และตรวจสอบว่าได้เลือกผังความเกี่ยวข้องบางส่วนส่วนกลางแล้ว
จากข้อมูลนี้ เราพบว่าสินเชื่อที่มาจาก HUD มีแนวโน้มที่จะถูกปฏิเสธมากกว่าเล็กน้อย กราฟเป็นรูปนี้เนื่องจากรหัสเอเจนซีเป็นฟีเจอร์บูลีน ค่าจึงต้องเป็น 0 หรือ 1 เท่านั้น
applicant_income_thousands เป็นฟีเจอร์ตัวเลข และในผังความเกี่ยวข้องบางส่วน เราเห็นว่ารายได้ที่สูงขึ้นจะเพิ่มโอกาสที่ใบสมัครจะได้รับอนุมัติเล็กน้อย แต่ไม่เกินประมาณ $200,000 หลังจาก 200, 000 บาท ฟีเจอร์นี้จะไม่ส่งผลต่อการคาดการณ์ของโมเดล
ขั้นตอนที่ 5: สํารวจประสิทธิภาพโดยรวมและความยุติธรรม
จากนั้นไปที่แท็บประสิทธิภาพและความเป็นธรรม ข้อมูลนี้แสดงสถิติประสิทธิภาพโดยรวมเกี่ยวกับผลลัพธ์ของโมเดลในชุดข้อมูลที่ให้ไว้ ซึ่งรวมถึงตารางความสับสน เส้นโค้ง PR และเส้นโค้ง ROC
เลือก mortgage_status เป็นฟีเจอร์ Ground Truth เพื่อดูตารางความสับสน
เมทริกซ์ความสับสนนี้แสดงการคาดการณ์ที่ถูกต้องและไม่ถูกต้องของโมเดลเป็นเปอร์เซ็นต์ของทั้งหมด หากบวกสี่เหลี่ยมจัตุรัสจริงเป็น "ใช่" / คาดการณ์เป็น "ใช่" และจริงเป็น "ไม่" / คาดการณ์เป็น "ไม่" ผลที่ได้ควรมีความแม่นยำเท่ากับโมเดลของคุณ (ในกรณีนี้ประมาณ 87% แต่โมเดลของคุณอาจแตกต่างกันเล็กน้อยเนื่องจากมีองค์ประกอบของความสุ่มในการฝึกโมเดล ML)
นอกจากนี้คุณยังสามารถทดสอบกับแถบเลื่อนเกณฑ์ เพิ่มและลดคะแนนการจัดประเภทเชิงบวกที่โมเดลจะต้องส่งคืนก่อนที่จะตัดสินใจคาดการณ์ approved สำหรับสินเชื่อ รวมถึงดูว่าการเปลี่ยนแปลงดังกล่าวเปลี่ยนแปลงความแม่นยำ ผลบวกลวง และผลลบลวงอย่างไร ในกรณีนี้ ความแม่นยำจะสูงสุดเมื่อเกณฑ์อยู่ที่ประมาณ .55
ถัดไป จากเมนูแบบเลื่อนลงแบ่งตามด้านซ้าย ให้เลือก loan_purpose_Home_purchase
ตอนนี้คุณจะเห็นประสิทธิภาพของข้อมูล 2 ชุด ได้แก่ ส่วนแบ่ง "0" แสดงเมื่อสินเชื่อไม่ได้มีไว้สำหรับการซื้อบ้าน และส่วนแบ่ง "1" มีไว้สำหรับการกู้ยืมสำหรับการซื้อบ้าน ตรวจสอบความแม่นยำ อัตราผลบวกลวง และอัตราผลลบลวงระหว่างกลุ่มย่อย 2 กลุ่มเพื่อหาความแตกต่างของประสิทธิภาพ
หากขยายแถวเพื่อดูที่ตารางความสับสน คุณจะเห็นได้ว่าโมเดลคาดการณ์ว่า "อนุมัติ" สำหรับการสมัครขอสินเชื่อเพื่อซื้อบ้านประมาณ 70% และสินเชื่อที่ไม่ใช่เพื่อซื้อบ้านเพียง 46% (เปอร์เซ็นต์ที่แน่นอนจะแตกต่างกันไปตามโมเดล)
หากเลือกความเท่าเทียมด้านข้อมูลประชากรจากปุ่มตัวเลือกทางด้านซ้าย ระบบจะปรับเกณฑ์ทั้ง 2 รายการเพื่อให้โมเดลคาดการณ์ approved สำหรับผู้สมัครในทั้ง 2 กลุ่มในเปอร์เซ็นต์ที่คล้ายกัน การดำเนินการนี้ส่งผลต่อความแม่นยำ ผลบวกลวง และผลลบลวงของแต่ละกลุ่มอย่างไร
ขั้นตอนที่ 6: สำรวจการเผยแพร่ฟีเจอร์
สุดท้าย ให้ไปที่แท็บฟีเจอร์ในเครื่องมือ "ถ้าหาก" ซึ่งจะแสดงการแจกแจงค่าของฟีเจอร์แต่ละรายการในชุดข้อมูล
คุณใช้แท็บนี้เพื่อตรวจสอบว่าชุดข้อมูลมีความสมดุลได้ เช่น ดูเหมือนว่าสินเชื่อในชุดข้อมูลมีเพียงไม่กี่รายการที่มาจาก Farm Service Agency เราอาจพิจารณาเพิ่มการกู้ยืมจากเอเจนซีดังกล่าวหากมีข้อมูล เพื่อปรับปรุงความแม่นยำของโมเดล
เราได้อธิบายไอเดียการสำรวจเครื่องมือ "What-if" เพียงไม่กี่ข้อที่นี่ ลองใช้เครื่องมือกันต่อได้เลย ยังมีพื้นที่ให้คุณสำรวจอีกมากมาย
8. ติดตั้งใช้งานโมเดลใน Vertex AI
เรามีโมเดลที่ทำงานในเครื่อง แต่คงจะดีหากเราสามารถคาดการณ์จากโมเดลได้จากทุกที่ (ไม่ใช่แค่ในโน้ตบุ๊คนี้) ในขั้นตอนนี้ เราจะทำให้โมเดลใช้งานได้บนระบบคลาวด์
ขั้นตอนที่ 1: สร้างที่เก็บข้อมูล Cloud Storage สำหรับโมเดลของเรา
ก่อนอื่นมากำหนดตัวแปรสภาพแวดล้อมบางส่วนที่เราจะใช้ตลอดทั้งโค้ดแล็บกัน กรอกค่าด้านล่างด้วยชื่อโปรเจ็กต์ Google Cloud, ชื่อที่เก็บข้อมูลระบบคลาวด์ที่ต้องการสร้าง (ต้องเป็นชื่อที่ไม่ซ้ำกันทั่วโลก) และชื่อเวอร์ชันสำหรับโมเดลเวอร์ชันแรก
# 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 นี้จากภายในสมุดบันทึกเพื่อสร้างที่เก็บข้อมูลของพื้นที่เก็บข้อมูลระดับภูมิภาค
!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 จะชี้ไปยังตำแหน่งใน Storage ที่คุณบันทึกโมเดล 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
เมื่อดำเนินการเสร็จแล้ว คุณควรเห็นตำแหน่งของอุปกรณ์ปลายทางที่บันทึกไว้ในเอาต์พุตของโน้ตบุ๊ค มองหาบรรทัดที่ระบุว่าสร้างปลายทางด้วยเส้นทางที่มีลักษณะดังนี้ 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. ล้างข้อมูล
หากต้องการใช้สมุดบันทึกนี้ต่อไป ขอแนะนำให้คุณปิดสมุดบันทึกเมื่อไม่ได้ใช้งาน จาก UI ของโน้ตบุ๊กใน Cloud Console ให้เลือกโน้ตบุ๊ก แล้วเลือกหยุด
หากต้องการลบทรัพยากรทั้งหมดที่สร้างไว้ในห้องทดลองนี้ ให้ลบอินสแตนซ์โน้ตบุ๊กแทนการหยุด
หากต้องการลบอุปกรณ์ปลายทางที่ติดตั้งใช้งาน ให้ไปที่ส่วน "อุปกรณ์ปลายทาง" ของคอนโซล Vertex แล้วคลิกไอคอนลบ
หากต้องการลบที่เก็บข้อมูลของพื้นที่เก็บข้อมูล โดยใช้เมนูการนำทางใน Cloud Console จากนั้นเรียกดูพื้นที่เก็บข้อมูล เลือกที่เก็บข้อมูล แล้วคลิกลบ:
