1. ภาพรวม
ในแล็บนี้ คุณจะได้ใช้ What-If Tool เพื่อวิเคราะห์โมเดล XGBoost ที่ฝึกด้วยข้อมูลทางการเงินและติดตั้งใช้งานใน Cloud AI Platform
สิ่งที่คุณจะได้เรียนรู้
โดยคุณจะได้เรียนรู้วิธีต่อไปนี้
- ฝึกโมเดล XGBoost ในชุดข้อมูลการจำนองสาธารณะใน AI Platform Notebooks
- ทำให้โมเดล XGBoost ใช้งานได้ใน AI Platform
- วิเคราะห์โมเดลโดยใช้ What-If Tool
ค่าใช้จ่ายทั้งหมดในการเรียกใช้ Lab นี้ใน Google Cloud อยู่ที่ประมาณ $1
2. ข้อมูลเบื้องต้นเกี่ยวกับ XGBoost
XGBoost เป็นเฟรมเวิร์กแมชชีนเลิร์นนิงที่ใช้ต้นไม้ตัดสินใจและการเพิ่มประสิทธิภาพแบบไล่ระดับเพื่อสร้างโมเดลการคาดการณ์ โดยจะทำงานด้วยการรวมต้นไม้ตัดสินใจหลายต้นเข้าด้วยกันตามคะแนนที่เชื่อมโยงกับโหนดใบต่างๆ ในต้นไม้
แผนภาพด้านล่างคือภาพของโมเดลต้นไม้ตัดสินใจแบบง่ายๆ ที่ประเมินว่าควรเล่นเกมกีฬาหรือไม่โดยอิงตามพยากรณ์อากาศ
เหตุผลที่เราใช้ XGBoost สำหรับโมเดลนี้ แม้ว่าโครงข่ายประสาทเทียมแบบดั้งเดิมจะทำงานได้ดีที่สุดกับข้อมูลที่ไม่มีโครงสร้าง เช่น รูปภาพและข้อความ แต่ต้นไม้ตัดสินใจมักจะทำงานได้ดีมากกับข้อมูลที่มีโครงสร้าง เช่น ชุดข้อมูลการจำนองที่เราจะใช้ใน Codelab นี้
3. ตั้งค่าสภาพแวดล้อม
คุณจะต้องมีโปรเจ็กต์ Google Cloud Platform ที่เปิดใช้การเรียกเก็บเงินเพื่อเรียกใช้ Codelab นี้ หากต้องการสร้างโปรเจ็กต์ ให้ทำตามวิธีการที่นี่
ขั้นตอนที่ 1: เปิดใช้ Cloud AI Platform Models API
ไปที่ส่วนโมเดล AI Platform ใน Cloud Console แล้วคลิกเปิดใช้หากยังไม่ได้เปิดใช้
ขั้นตอนที่ 2: เปิดใช้ Compute Engine API
ไปที่ Compute Engine แล้วเลือกเปิดใช้หากยังไม่ได้เปิดใช้ คุณจะต้องใช้ข้อมูลนี้เพื่อสร้างอินสแตนซ์ Notebook
ขั้นตอนที่ 3: สร้างอินสแตนซ์ Notebooks ของ AI Platform
ไปที่ส่วน AI Platform Notebooks ใน Cloud Console แล้วคลิกอินสแตนซ์ใหม่ จากนั้นเลือกประเภทอินสแตนซ์ TF Enterprise 2.x ล่าสุดที่ไม่มี GPU
ใช้ตัวเลือกเริ่มต้น แล้วคลิกสร้าง เมื่อสร้างอินสแตนซ์แล้ว ให้เลือกเปิด JupyterLab
ขั้นตอนที่ 4: ติดตั้ง XGBoost
เมื่ออินสแตนซ์ JupyterLab เปิดขึ้นแล้ว คุณจะต้องเพิ่มแพ็กเกจ XGBoost
โดยเลือก Terminal จาก Launcher ดังนี้
จากนั้นเรียกใช้คำสั่งต่อไปนี้เพื่อติดตั้ง XGBoost เวอร์ชันล่าสุดที่ Cloud AI Platform รองรับ
pip3 install xgboost==0.90
หลังจากขั้นตอนนี้เสร็จสมบูรณ์แล้ว ให้เปิดอินสแตนซ์ 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
4. ดาวน์โหลดและประมวลผลข้อมูล
เราจะใช้ชุดข้อมูลการจำนองจาก ffiec.gov เพื่อฝึกโมเดล XGBoost เราได้ทำการประมวลผลล่วงหน้าในชุดข้อมูลต้นฉบับและสร้างเวอร์ชันที่เล็กลงเพื่อให้คุณใช้ฝึกโมเดล โมเดลจะคาดการณ์ว่าการสมัครขอสินเชื่อที่อยู่อาศัยหนึ่งๆ จะได้รับอนุมัติหรือไม่
ขั้นตอนที่ 1: ดาวน์โหลดชุดข้อมูลที่ประมวลผลล่วงหน้า
เราได้จัดทำชุดข้อมูลเวอร์ชันหนึ่งให้คุณใช้งานใน Google Cloud Storage แล้ว คุณดาวน์โหลดได้โดยเรียกใช้gsutilคำสั่งต่อไปนี้ใน Jupyter Notebook
!gsutil cp 'gs://mortgage_dataset_files/mortgage-small.csv' .
ขั้นตอนที่ 2: อ่านชุดข้อมูลด้วย Pandas
ก่อนสร้าง Pandas DataFrame เราจะสร้างพจนานุกรมของประเภทข้อมูลของแต่ละคอลัมน์เพื่อให้ 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,labels
x_train,x_test,y_train,y_test = train_test_split(x,y)
ตอนนี้คุณก็พร้อมสร้างและฝึกโมเดลแล้ว
5. สร้าง ฝึก และประเมินโมเดล 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')
6. ทำให้โมเดลใช้งานได้ใน Cloud AI Platform
เรามีโมเดลที่ทำงานในเครื่อง แต่คงจะดีถ้าเราสามารถทำการคาดการณ์ในโมเดลได้จากทุกที่ (ไม่ใช่แค่ใน Notebook นี้) ในขั้นตอนนี้ เราจะทำให้ใช้งานได้ในระบบคลาวด์
ขั้นตอนที่ 1: สร้าง Bucket ของ Cloud Storage สำหรับโมเดล
ก่อนอื่นเรามากำหนดตัวแปรสภาพแวดล้อมบางอย่างที่จะใช้ตลอดทั้ง Codelab ที่เหลือกัน กรอกค่าด้านล่างด้วยชื่อโปรเจ็กต์ Google Cloud, ชื่อของ Bucket ใน Cloud Storage ที่คุณต้องการสร้าง (ต้องไม่ซ้ำกันทั่วโลก) และชื่อเวอร์ชันสำหรับโมเดลเวอร์ชันแรก
# Update these to your own GCP project, model, and version names
GCP_PROJECT = 'your-gcp-project'
MODEL_BUCKET = 'gs://storage_bucket_name'
VERSION_NAME = 'v1'
MODEL_NAME = 'xgb_mortgage'
ตอนนี้เราพร้อมที่จะสร้างที่เก็บข้อมูลเพื่อจัดเก็บไฟล์โมเดล XGBoost แล้ว เราจะชี้ Cloud AI Platform ไปยังไฟล์นี้เมื่อทำการติดตั้งใช้งาน
เรียกใช้คำสั่ง gsutil นี้จากภายใน Notebook เพื่อสร้าง Bucket
!gsutil mb $MODEL_BUCKET
ขั้นตอนที่ 2: คัดลอกไฟล์โมเดลไปยัง Cloud Storage
จากนั้นเราจะคัดลอกไฟล์โมเดลที่บันทึกไว้ของ XGBoost ไปยัง Cloud Storage เรียกใช้คำสั่ง gsutil ต่อไปนี้
!gsutil cp ./model.bst $MODEL_BUCKET
ไปที่เบราว์เซอร์พื้นที่เก็บข้อมูลใน Cloud Console เพื่อยืนยันว่าระบบได้คัดลอกไฟล์แล้ว
ขั้นตอนที่ 3: สร้างและนำโมเดลไปใช้งาน
เราพร้อมที่จะติดตั้งใช้งานโมเดลแล้ว ai-platform คำสั่ง gcloud ต่อไปนี้จะสร้างโมเดลใหม่ในโปรเจ็กต์ เราจะเรียกฟีเจอร์นี้ว่า xgb_mortgage
!gcloud ai-platform models create $MODEL_NAME --region='global'
ตอนนี้ก็ถึงเวลาที่จะทำให้โมเดลใช้งานได้แล้ว ซึ่งทำได้โดยใช้คำสั่ง gcloud นี้
!gcloud ai-platform versions create $VERSION_NAME \
--model=$MODEL_NAME \
--framework='XGBOOST' \
--runtime-version=2.1 \
--origin=$MODEL_BUCKET \
--python-version=3.7 \
--project=$GCP_PROJECT \
--region='global'
ขณะที่การดำเนินการนี้ทำงานอยู่ ให้ตรวจสอบส่วนโมเดลของคอนโซล AI Platform คุณควรเห็นการติดตั้งใช้งานเวอร์ชันใหม่ที่นั่น
เมื่อการติดตั้งใช้งานเสร็จสมบูรณ์ คุณจะเห็นเครื่องหมายถูกสีเขียวตรงที่วงกลมหมุนกำลังโหลดอยู่ โดยการติดตั้งใช้งานจะใช้เวลา 2-3 นาที
ขั้นตอนที่ 4: ทดสอบโมเดลที่ใช้งานจริง
หากต้องการตรวจสอบว่าโมเดลที่ใช้งานได้ทำงานอยู่ ให้ทดสอบโดยใช้ gcloud เพื่อทำการคาดการณ์ ก่อนอื่น ให้บันทึกไฟล์ JSON ที่มีตัวอย่างแรกจากชุดทดสอบของเรา
%%writefile predictions.json
[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]
ทดสอบโมเดลโดยเรียกใช้โค้ดนี้
prediction = !gcloud ai-platform predict --model=xgb_mortgage --region='global' --json-instances=predictions.json --version=$VERSION_NAME --verbosity=none
print(prediction)
คุณควรเห็นการคาดการณ์ของโมเดลในเอาต์พุต ตัวอย่างนี้ได้รับการอนุมัติแล้ว คุณจึงควรเห็นค่าที่ใกล้เคียงกับ 1
7. ใช้เครื่องมือวิเคราะห์สถานการณ์สมมติเพื่อตีความโมเดล
ขั้นตอนที่ 1: สร้างภาพเครื่องมือวิเคราะห์สถานการณ์สมมติ
หากต้องการเชื่อมต่อ What-if Tool กับโมเดล AI Platform คุณต้องส่งตัวอย่างการทดสอบบางส่วนพร้อมกับค่าความจริงพื้นฐานสำหรับตัวอย่างเหล่านั้น มาสร้างอาร์เรย์ Numpy ของตัวอย่างทดสอบ 500 รายการพร้อมกับป้ายกำกับความจริงพื้นฐานกัน
num_wit_examples = 500
test_examples = np.hstack((x_test[:num_wit_examples].values,y_test[:num_wit_examples].reshape(-1,1)))
การเริ่มต้นใช้งาน What-If Tool นั้นง่ายเพียงแค่สร้างออบเจ็กต์ WitConfigBuilder แล้วส่งโมเดล AI Platform ที่เราต้องการวิเคราะห์ไปยังออบเจ็กต์นั้น
เราใช้พารามิเตอร์ adjust_prediction ที่ไม่บังคับที่นี่เนื่องจากเครื่องมือ What-if คาดหวังรายการคะแนนสำหรับแต่ละคลาสในโมเดลของเรา (ในกรณีนี้คือ 2) เนื่องจากโมเดลของเราแสดงผลค่าเดียวจาก 0 ถึง 1 เท่านั้น เราจึงแปลงค่าเป็นรูปแบบที่ถูกต้องในฟังก์ชันนี้
def adjust_prediction(pred):
return [1 - pred, pred]
config_builder = (WitConfigBuilder(test_examples.tolist(), data.columns.tolist() + ['mortgage_status'])
.set_ai_platform_model(GCP_PROJECT, MODEL_NAME, VERSION_NAME, adjust_prediction=adjust_prediction)
.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%)
นอกจากนี้ คุณยังทดสอบแถบเลื่อนเกณฑ์ โดยการเพิ่มและลดคะแนนการจัดประเภทเชิงบวกที่โมเดลต้องส่งคืนก่อนที่จะตัดสินใจคาดการณ์ว่าapprovedสำหรับเงินกู้ และดูว่าการดำเนินการดังกล่าวจะเปลี่ยนแปลงความแม่นยำ ผลบวกลวง และผลลบลวงอย่างไร ในกรณีนี้ ความแม่นยำจะสูงสุดที่เกณฑ์ .55
จากนั้นทางด้านซ้าย ให้เลือก loan_purpose_Home_purchase ในเมนูแบบเลื่อนลงแบ่งตาม
ตอนนี้คุณจะเห็นประสิทธิภาพใน 2 ข้อมูลย่อย ได้แก่ สไลซ์ "0" จะแสดงเมื่อเงินกู้ไม่ได้ใช้ซื้อบ้าน และสไลซ์ "1" จะแสดงเมื่อเงินกู้ใช้ซื้อบ้าน ดูอัตราความแม่นยำ อัตราผลบวกลวง และอัตราผลลบลวงระหว่าง 2 กลุ่มย่อยเพื่อดูความแตกต่างของประสิทธิภาพ
หากขยายแถวเพื่อดูเมทริกซ์ความสับสน คุณจะเห็นว่าโมเดลคาดการณ์ว่า "อนุมัติ" สำหรับใบสมัครขอสินเชื่อเพื่อซื้อบ้านประมาณ 70% และมีเพียง 46% ของสินเชื่อที่ไม่ได้ใช้ซื้อบ้าน (เปอร์เซ็นต์ที่แน่นอนจะแตกต่างกันไปตามโมเดล)
หากเลือกความเท่าเทียมกันทางประชากรจากปุ่มตัวเลือกทางด้านซ้าย ระบบจะปรับเกณฑ์ทั้ง 2 รายการเพื่อให้โมเดลคาดการณ์ approved สำหรับผู้สมัครที่มีเปอร์เซ็นต์คล้ายกันในทั้ง 2 กลุ่ม การดำเนินการนี้ส่งผลต่อความแม่นยำ ผลบวกลวง และผลลบลวงของแต่ละกลุ่มย่อยอย่างไร
ขั้นตอนที่ 6: สำรวจการเผยแพร่ฟีเจอร์
สุดท้าย ให้ไปที่แท็บฟีเจอร์ในเครื่องมือ What-if ซึ่งจะแสดงการกระจายค่าสำหรับแต่ละฟีเจอร์ในชุดข้อมูล
คุณใช้แท็บนี้เพื่อให้แน่ใจว่าชุดข้อมูลมีความสมดุล เช่น ดูเหมือนว่ามีเงินกู้เพียงไม่กี่รายการในชุดข้อมูลที่มาจาก Farm Service Agency เราอาจพิจารณาเพิ่มเงินกู้จากหน่วยงานดังกล่าวหากมีข้อมูล เพื่อปรับปรุงความแม่นยำของโมเดล
เราอธิบายรายละเอียดไอเดียการสำรวจเครื่องมือ What-if เพียงบางส่วนไว้ที่นี่ คุณสามารถลองใช้เครื่องมือนี้ต่อไปได้เลย ยังมีอีกหลายส่วนให้สำรวจ
8. ล้างข้อมูล
หากต้องการใช้ Notebook นี้ต่อไป ขอแนะนำให้ปิดเมื่อไม่ได้ใช้งาน จาก UI ของ Notebook ใน Cloud Console ให้เลือก Notebook แล้วเลือกหยุด
หากต้องการลบทรัพยากรทั้งหมดที่คุณสร้างไว้ใน Lab นี้ ให้ลบอินสแตนซ์ Notebook แทนการหยุด
ใช้เมนูการนำทางใน Cloud Console เพื่อไปที่ Storage แล้วลบทั้ง 2 Bucket ที่คุณสร้างขึ้นเพื่อจัดเก็บชิ้นงานโมเดล