1. ภาพรวม
ในห้องทดลองนี้ คุณจะได้ใช้เครื่องมือ What-if เพื่อวิเคราะห์โมเดล XGBoost ที่ได้รับการฝึกเกี่ยวกับข้อมูลทางการเงินและติดตั้งใช้งานบน Cloud AI Platform
สิ่งที่ได้เรียนรู้
โดยคุณจะได้เรียนรู้วิธีต่อไปนี้
- ฝึกโมเดล XGBoost บนชุดข้อมูลการจำนองสาธารณะใน AI Platform Notebooks
- ทำให้โมเดล XGBoost ใช้งานได้กับ AI Platform
- วิเคราะห์โมเดลโดยใช้เครื่องมือ What-if
ค่าใช้จ่ายรวมในการเรียกใช้ห้องทดลองนี้บน 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 แล้วเลือกเปิดใช้ หากยังไม่ได้เปิดใช้ ซึ่งคุณจะต้องใช้ในการสร้างอินสแตนซ์สมุดบันทึก
ขั้นตอนที่ 3: สร้างอินสแตนซ์ AI Platform Notebooks
ไปที่ส่วน AI Platform Notebooks ของ Cloud Console แล้วคลิกอินสแตนซ์ใหม่ จากนั้นเลือกอินสแตนซ์ประเภท TF Enterprise 2.x ล่าสุดไม่มี GPU ดังนี้
ใช้ตัวเลือกเริ่มต้นแล้วคลิกสร้าง เมื่อสร้างอินสแตนซ์แล้ว ให้เลือก Open JupyterLab:
ขั้นตอนที่ 4: ติดตั้ง XGBoost
เมื่ออินสแตนซ์ JupyterLab เปิดขึ้น คุณจะต้องเพิ่มแพ็กเกจ XGBoost
ในการดำเนินการ ให้เลือกเทอร์มินัลจาก Launcher
จากนั้นเรียกใช้รายการต่อไปนี้เพื่อติดตั้ง XGBoost เวอร์ชันล่าสุดที่ Cloud AI Platform รองรับ
pip3 install xgboost==0.90
หลังจากขั้นตอนนี้เสร็จสมบูรณ์แล้ว ให้เปิดอินสแตนซ์สมุดบันทึก 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
4. ดาวน์โหลดและประมวลผลข้อมูล
เราจะใช้ชุดข้อมูลการจำนองจาก ffiec.gov เพื่อฝึกโมเดล XGBoost เราได้ประมวลผลชุดข้อมูลต้นฉบับบางส่วนแล้วและสร้างเวอร์ชันที่เล็กลงเพื่อให้คุณใช้ในการฝึกโมเดล โมเดลนี้จะคาดการณ์ว่าใบสมัครจำนองหนึ่งๆ จะได้รับอนุมัติหรือไม่
ขั้นตอนที่ 1: ดาวน์โหลดชุดข้อมูลที่ประมวลผลล่วงหน้า
เราได้สร้างชุดข้อมูลเวอร์ชันที่พร้อมให้คุณใช้งานใน Google Cloud Storage คุณจะดาวน์โหลดได้โดยเรียกใช้คำสั่ง gsutil ต่อไปนี้ในสมุดบันทึก Jupyter
!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 กำหนดให้ฟีเจอร์ทั้งหมดเป็นตัวเลข แทนที่จะแสดงค่าเชิงหมวดหมู่โดยใช้การเข้ารหัสแบบฮอตเดียว สำหรับโมเดล XGBoost ของเรา เราจะใช้ประโยชน์จากฟังก์ชัน get_dummies ของ Pandas
get_dummies จะนำคอลัมน์ที่มีค่าที่เป็นไปได้หลายค่ามาแปลงเป็นชุดคอลัมน์ซึ่งแต่ละคอลัมน์มีเพียง 0 และ 1 เท่านั้น ตัวอย่างเช่น หากเรามีคอลัมน์ "color" ด้วยค่าที่เป็นไปได้เป็น "blue" และ "สีแดง" 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 train_test_split เพื่อแบ่งข้อมูลของเรา
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
เราให้โมเดลของเราทำงานในเครื่อง แต่คงจะดีหากเราสามารถคาดการณ์จากที่ใดก็ได้ (ไม่ใช่แค่ในสมุดบันทึกนี้) ในขั้นตอนนี้ เราจะทำให้ใช้งานได้บนระบบคลาวด์
ขั้นตอนที่ 1: สร้างที่เก็บข้อมูล Cloud Storage สำหรับโมเดลของเรา
เรามากำหนดตัวแปรสภาพแวดล้อมบางส่วนที่เราจะใช้ใน Codelab ที่เหลือก่อนกัน กรอกค่าด้านล่างด้วยชื่อโปรเจ็กต์ Google Cloud, ชื่อที่เก็บข้อมูล 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 นี้จากภายในสมุดบันทึกเพื่อสร้างที่เก็บข้อมูล
!gsutil mb $MODEL_BUCKET
ขั้นตอนที่ 2: คัดลอกไฟล์โมเดลไปยัง Cloud Storage
ถัดไป เราจะคัดลอกไฟล์โมเดลที่บันทึกไว้ของ XGBoost ไปยัง Cloud Storage เรียกใช้คำสั่ง gsutil ต่อไปนี้
!gsutil cp ./model.bst $MODEL_BUCKET
ไปที่เบราว์เซอร์พื้นที่เก็บข้อมูลใน Cloud Console เพื่อตรวจสอบว่าได้คัดลอกไฟล์แล้ว โดยทำดังนี้
ขั้นตอนที่ 3: สร้างและทำให้โมเดลใช้งานได้
เราใกล้พร้อมที่จะทำให้โมเดลใช้งานได้แล้ว คำสั่ง gcloud ของ ai-platform ต่อไปนี้จะสร้างโมเดลใหม่ในโปรเจ็กต์ของคุณ เราจะเรียกสิ่งนี้ว่า 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
หากต้องการเชื่อมต่อเครื่องมือ What-if กับโมเดล 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 นั้นง่ายเพียงแค่สร้างออบเจ็กต์ 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)
โปรดทราบว่าระบบจะใช้เวลาสักครู่ในการโหลดการแสดงข้อมูลผ่านภาพ เมื่อโหลดเสร็จ คุณจะเห็นสิ่งต่อไปนี้
แกน Y แสดงการคาดการณ์ของโมเดลให้กับเรา โดย 1 เป็นการคาดการณ์ approved ที่มีความเชื่อมั่นสูง และ 0 เป็นการคาดการณ์ denied ที่มีความเชื่อมั่นสูง แกน x เป็นเพียงการกระจายของจุดข้อมูลที่โหลดทั้งหมด
ขั้นตอนที่ 2: สำรวจจุดข้อมูลแต่ละจุด
มุมมองเริ่มต้นในเครื่องมือ What-if คือแท็บตัวแก้ไข Datapoint ในส่วนนี้ คุณสามารถคลิกที่จุดข้อมูลแต่ละจุดเพื่อดูคุณลักษณะ เปลี่ยนค่าคุณลักษณะ และดูว่าการเปลี่ยนแปลงนั้นส่งผลต่อการคาดการณ์ของโมเดลอย่างไรต่อจุดข้อมูลแต่ละจุด
ในตัวอย่างด้านล่าง เราเลือกจุดข้อมูลที่ใกล้เคียงกับเกณฑ์ .5 การยื่นขอสินเชื่อที่เกี่ยวข้องกับจุดข้อมูลเฉพาะนี้มาจาก CFPB เราเปลี่ยนฟีเจอร์นั้นเป็น 0 และเปลี่ยนค่าของ agency_code_Department of Housing and Urban Development (HUD) เป็น 1 เพื่อดูว่าจะเกิดอะไรขึ้นกับการคาดการณ์ของโมเดลหากสินเชื่อนี้มาจาก HUD แทน
อย่างที่เราเห็นในส่วนด้านล่างซ้ายของเครื่องมือ What-if การเปลี่ยนแปลงฟีเจอร์นี้ทำให้การคาดการณ์ approved ของโมเดลลดลงอย่างมาก 32% กรณีนี้อาจบ่งชี้ว่าเอเจนซีที่เป็นต้นกำเนิดการกู้ยืมมีผลกระทบอย่างมากต่อผลลัพธ์ของโมเดล แต่เราต้องทำการวิเคราะห์เพิ่มเติมเพื่อความแน่ใจ
ในส่วนซ้ายล่างของ UI เรายังสามารถดูค่าข้อมูลจากการสังเกตการณ์โดยตรงสำหรับแต่ละจุดข้อมูลและเปรียบเทียบกับการคาดการณ์ของโมเดลได้
ขั้นตอนที่ 3: การวิเคราะห์สิ่งที่ตรงข้ามกับความจริง
จากนั้นคลิกจุดข้อมูลใดก็ได้ แล้วเลื่อนแถบเลื่อนแสดงจุดข้อมูลเท็จที่ใกล้ที่สุดไปทางขวา
การเลือกตัวเลือกนี้จะแสดงจุดข้อมูลที่มีค่าฟีเจอร์ที่คล้ายกันมากที่สุดกับค่าเดิมที่คุณเลือกไว้ แต่การคาดการณ์กลับตรงกันข้าม จากนั้น คุณสามารถเลื่อนดูค่าคุณลักษณะเพื่อดูว่าจุดข้อมูล 2 จุดต่างกันตรงไหน (ความแตกต่างจะมีการไฮไลต์ด้วยสีเขียวและตัวหนา)
ขั้นตอนที่ 4: ดูพล็อตทรัพยากร Dependency บางส่วน
หากต้องการดูว่าแต่ละฟีเจอร์ส่งผลอย่างไรต่อการคาดการณ์ของโมเดลโดยรวม ให้เลือกช่องพล็อตทรัพยากร Dependency บางส่วน และตรวจสอบว่าได้เลือกพล็อตทรัพยากร Dependency ทั้งหมดแบบส่วนกลางแล้วดังนี้
จากตัวอย่างนี้จะเห็นได้ว่าสินเชื่อที่มาจาก HUD มีแนวโน้มที่จะถูกปฏิเสธสูงกว่าเล็กน้อย กราฟเป็นรูปร่างนี้เนื่องจากรหัสเอเจนซีเป็นฟีเจอร์แบบบูลีน ดังนั้นค่าจึงต้องเป็น 0 หรือ 1 พอดี
applicant_income_thousands เป็นฟีเจอร์เชิงตัวเลข และในกราฟ Dependency บางส่วนนั้น เราจะเห็นว่ารายได้ที่สูงขึ้นจะเพิ่มแนวโน้มที่ใบสมัครจะได้รับการอนุมัติได้เล็กน้อย แต่จะไม่เกินประมาณ $200,000 เท่านั้น ฟีเจอร์นี้จะไม่มีผลต่อการคาดการณ์ของโมเดลหลังจาก $200, 000
ขั้นตอนที่ 5: สำรวจประสิทธิภาพโดยรวมและความยุติธรรม
จากนั้น ให้ไปที่ประสิทธิภาพและ ความยุติธรรม ซึ่งจะแสดงสถิติประสิทธิภาพโดยรวมเกี่ยวกับผลลัพธ์ของโมเดลในชุดข้อมูลที่มีให้ ได้แก่ เมทริกซ์ความสับสน เส้นโค้ง PR และเส้นโค้ง ROC
เลือก mortgage_status เป็นฟีเจอร์ข้อมูลจากการสังเกตการณ์โดยตรงเพื่อดูเมทริกซ์ความสับสน
เมทริกซ์ความสับสนนี้แสดงการคาดคะเนที่ถูกต้องและไม่ถูกต้องของโมเดลเป็นเปอร์เซ็นต์ของผลรวม หากคุณเพิ่มกำลังสองใช่ จริง / ใช่ ที่คาดการณ์ และไม่ใช่จริง / ไม่ที่คาดการณ์ ค่าดังกล่าวควรจะบวกความแม่นยำเท่ากับโมเดลของคุณ (ประมาณ 87%)
นอกจากนี้คุณยังสามารถทดสอบกับแถบเลื่อนเกณฑ์ เพิ่มและลดคะแนนการจัดประเภทเชิงบวกที่โมเดลจะต้องส่งคืนก่อนที่จะตัดสินใจคาดการณ์ approved สำหรับสินเชื่อ และดูวิธีที่การเปลี่ยนแปลงดังกล่าวเปลี่ยนแปลงความแม่นยำ ผลบวกลวง และผลลบลวง ในกรณีนี้ ความแม่นยำสูงสุดอยู่ที่ประมาณ .55
ถัดไป จากเมนูแบบเลื่อนลงแบ่งตามด้านซ้าย ให้เลือก loan_purpose_Home_purchase
ตอนนี้ คุณจะเห็นประสิทธิภาพของข้อมูลชุดย่อย 2 ชุด ได้แก่ "0" สไลซ์จะแสดงเมื่อสินเชื่อไม่ได้มีไว้สำหรับการซื้อบ้าน และ "1" Slice มีไว้สำหรับการกู้ซื้อบ้าน ตรวจสอบความแม่นยำ ผลบวกลวง และอัตราผลลบลวงระหว่าง 2 ส่วนเพื่อหาความแตกต่างในประสิทธิภาพ
หากคุณขยายแถวเพื่อดูเมทริกซ์ความสับสน คุณจะเห็นว่าโมเดลคาดการณ์ "อนุมัติแล้ว" สำหรับการสมัครสินเชื่อซื้อบ้านราว 70% และสินเชื่อเพียง 46% ที่ไม่ได้มีการซื้อบ้าน (เปอร์เซ็นต์ที่แน่นอนจะแตกต่างไปตามรุ่นของคุณ)
หากคุณเลือกความเท่าเทียมกันของข้อมูลประชากรจากปุ่มตัวเลือกทางด้านซ้าย ระบบจะปรับเกณฑ์ทั้ง 2 รายการเพื่อให้โมเดลคาดการณ์ approved สำหรับเปอร์เซ็นต์ผู้สมัครที่ใกล้เคียงกันในทั้ง 2 ส่วน การดำเนินการนี้ส่งผลต่อความแม่นยำ ผลบวกลวง และผลลบลวงสำหรับแต่ละชิ้นส่วนอย่างไร
ขั้นตอนที่ 6: สำรวจการเผยแพร่ฟีเจอร์
สุดท้าย ให้ไปที่แท็บฟีเจอร์ในเครื่องมือ "ถ้าหาก" แสดงการกระจายค่าของแต่ละฟีเจอร์ในชุดข้อมูลดังนี้
คุณใช้แท็บนี้ได้เพื่อให้ชุดข้อมูลมีความสมดุล เช่น ดูเหมือนว่าเงินกู้ในชุดข้อมูลนั้นมาจากหน่วยงานบริการฟาร์มเพียงเล็กน้อย เพื่อปรับปรุงความแม่นยำของโมเดล เราอาจพิจารณาเพิ่มสินเชื่อจากหน่วยงานดังกล่าว หากมีข้อมูล
เราได้อธิบายแนวคิดการสำรวจเครื่องมือแบบ What-if บางส่วนไว้ที่นี่ ลองใช้เครื่องมือกันต่อได้เลย ยังมีพื้นที่ให้คุณสำรวจอีกมากมาย
8. ล้างข้อมูล
หากต้องการใช้สมุดบันทึกนี้ต่อไป ขอแนะนำให้ปิดสมุดบันทึกเมื่อไม่ได้ใช้งาน จาก UI ของสมุดบันทึกใน Cloud Console ให้เลือกสมุดบันทึก แล้วเลือกหยุด
หากต้องการลบทรัพยากรทั้งหมดที่คุณสร้างไว้ในห้องทดลองนี้ เพียงลบอินสแตนซ์สมุดบันทึกแทนที่จะหยุด
ใช้เมนูการนำทางใน Cloud Console เพื่อเรียกดูพื้นที่เก็บข้อมูล แล้วลบที่เก็บข้อมูลทั้ง 2 รายการที่คุณสร้างขึ้นเพื่อจัดเก็บเนื้อหาโมเดล