1. खास जानकारी
इस लैब में, क्या होगा-अगर टूल का इस्तेमाल करके, वित्तीय डेटा के हिसाब से तैयार किए गए XGBoost मॉडल का विश्लेषण किया जाएगा. यह मॉडल Cloud AI Platform पर डिप्लॉय किया जाएगा.
आपने क्या सीखा
आपको, इनके बारे में जानकारी मिलेगी:
- AI Platform Notebooks के सार्वजनिक मॉर्गेज डेटासेट पर XGBoost मॉडल को ट्रेनिंग दें
- XGBoost मॉडल को AI Platform पर डिप्लॉय करें
- व्हाट-इफ़ टूल का इस्तेमाल करके इस मॉडल का विश्लेषण करें
Google Cloud पर इस लैब को चलाने की कुल लागत करीब $1 है.
2. एक क्विक XGBoost प्राइमर
XGBoost एक मशीन लर्निंग फ़्रेमवर्क है. यह अनुमानित मॉडल बनाने के लिए डिसीज़न ट्री और ग्रेडिएंट बूस्टिंग का इस्तेमाल करता है. यह किसी ट्री के अलग-अलग लीफ़ नोड से जुड़े स्कोर के आधार पर, कई डिसिज़न ट्री को इकट्ठा करके काम करता है.
नीचे दिया गया डायग्राम, डिसिज़न ट्री के आसान मॉडल का विज़ुअलाइज़ेशन है. इससे यह आकलन किया जाता है कि मौसम के पूर्वानुमान के हिसाब से खेल का गेम खेला जाना चाहिए या नहीं:
हम इस मॉडल के लिए XGBoost का इस्तेमाल क्यों कर रहे हैं? पारंपरिक न्यूरल नेटवर्क को इमेज और टेक्स्ट जैसे बिना स्ट्रक्चर वाले डेटा पर सबसे अच्छा परफ़ॉर्म करने के लिए दिखाया गया है. हालांकि, डिसिज़न ट्री अक्सर स्ट्रक्चर्ड डेटा पर बहुत अच्छा परफ़ॉर्म करते हैं. जैसे, मॉर्गेज डेटासेट, जिसका इस्तेमाल हम इस कोडलैब में करेंगे.
3. अपना एनवायरमेंट सेट अप करें
इस कोडलैब को चलाने के लिए, आपके पास Google Cloud Platform का ऐसा प्रोजेक्ट होना चाहिए जिसमें बिलिंग की सुविधा चालू हो. प्रोजेक्ट बनाने के लिए, यहां दिए गए निर्देशों का पालन करें.
पहला चरण: Cloud AI Platform मॉडल API को चालू करना
अपने Cloud Console के एआई प्लैटफ़ॉर्म मॉडल सेक्शन पर जाएं और अगर यह पहले से चालू नहीं है, तो 'चालू करें' पर क्लिक करें.
दूसरा चरण: Compute Engine API चालू करना
Compute Engine पर जाएं और अगर यह पहले से चालू नहीं है, तो चालू करें को चुनें. आपको अपना notebook इंस्टेंस बनाने के लिए इसकी ज़रूरत होगी.
तीसरा चरण: AI Platform Notebooks का इंस्टेंस बनाना
अपने Cloud Console के AI Platform Notebooks सेक्शन पर जाएं और नया इंस्टेंस पर क्लिक करें. इसके बाद, बिना जीपीयू के नया TF Enterprise 2.x इंस्टेंस टाइप चुनें:
डिफ़ॉल्ट विकल्पों का इस्तेमाल करें और फिर बनाएं पर क्लिक करें. इंस्टेंस बनाने के बाद, JupyterLab खोलें को चुनें:
चौथा चरण: XGBoost को इंस्टॉल करें
आपका JupyterLab इंस्टेंस खुल जाने के बाद, आपको XGBoost पैकेज जोड़ना होगा.
ऐसा करने के लिए, लॉन्चर से Terminal चुनें:
इसके बाद, Cloud AI Platform के साथ काम करने वाले XGBoost के नए वर्शन को इंस्टॉल करने के लिए, नीचे दिया गया तरीका अपनाएं:
pip3 install xgboost==0.90
इसके पूरा होने के बाद, लॉन्चर से Python 3 Notebook का इंस्टेंस खोलें. आप अपनी नोटबुक में शुरू करने के लिए तैयार हैं!
पांचवां चरण: 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. डेटा डाउनलोड और प्रोसेस करें
हम XGBoost मॉडल को ट्रेनिंग देने के लिए, ffiec.gov से मिले मॉर्गेज डेटासेट का इस्तेमाल करेंगे. हमने मूल डेटासेट की कुछ प्री-प्रोसेसिंग की है. साथ ही, इसका एक छोटा वर्शन बनाया है, जिसका इस्तेमाल करके आप मॉडल को ट्रेनिंग दे सकते हैं. मॉडल यह अनुमान लगाएगा कि किसी क़र्ज़ के लिए आवेदन को स्वीकार किया जाएगा या नहीं.
पहला चरण: पहले से प्रोसेस किया गया डेटासेट डाउनलोड करना
हमने आपके लिए Google Cloud Storage में डेटासेट का एक वर्शन उपलब्ध कराया है. आप अपनी Jupyter notebook में नीचे दिया गया gsutil निर्देश चलाकर इसे डाउनलोड कर सकते हैं:
!gsutil cp 'gs://mortgage_dataset_files/mortgage-small.csv' .
दूसरा चरण: 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 बनाएंगे और उसे ऊपर बताए गए डेटा टाइप में भेजेंगे. अगर मूल डेटासेट को किसी खास तरीके से ऑर्डर किया गया हो, तो हमारे डेटा को शफ़ल करना ज़रूरी है. ऐसा करने के लिए हम shuffle नाम की एक sklearn यूटिलिटी का इस्तेमाल करते हैं, जिसे हमने पहले सेल में इंपोर्ट किया था:
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() की मदद से, हम Pandas में अपने डेटासेट की पहली पांच पंक्तियों की झलक देख सकते हैं. ऊपर दिए गए सेल को चलाने के बाद, आपको कुछ ऐसा दिखेगा:
हम अपने मॉडल को ट्रेनिंग देने के लिए, इन सुविधाओं का इस्तेमाल करेंगे. अगर आप आखिर तक स्क्रोल करते हैं, तो आपको आखिरी कॉलम approved दिखेगा. हम इसका अनुमान लगा रहे हैं. 1 मान बताता है कि कोई खास ऐप्लिकेशन स्वीकार किया गया था. वहीं, 0 बताता है कि उसे अस्वीकार किया गया था.
डेटासेट में स्वीकार / अस्वीकार की गई वैल्यू का डिस्ट्रिब्यूशन देखने और लेबल की बिना नंबर वाली अरे बनाने के लिए, यह तरीका अपनाएं:
# Class labels - 0: denied, 1: approved
print(data['approved'].value_counts())
labels = data['approved'].values
data = data.drop(columns=['approved'])
डेटासेट के करीब 66% में ऐसे ऐप्लिकेशन हैं जिन्हें मंज़ूरी मिल चुकी है.
तीसरा चरण: कैटगरीकल वैल्यू के लिए डमी कॉलम बनाना
इस डेटासेट में कैटगरी और संख्या वाली वैल्यू, दोनों शामिल हैं. हालांकि, XGBoost के लिए यह ज़रूरी है कि सभी सुविधाएं अंकों में हों. वन-हॉट एन्कोडिंग का इस्तेमाल करके कैटगरी के हिसाब से वैल्यू दिखाने के बजाय, हम अपने XGBoost मॉडल के लिए Pandas के get_dummies फ़ंक्शन का इस्तेमाल करेंगे.
get_dummies कई संभावित वैल्यू वाले कॉलम को लेता है और उसे कॉलम की सीरीज़ में बदलता है. हर कॉलम में सिर्फ़ 0 और 1 का निशान होता है. उदाहरण के लिए, अगर हमारे कॉलम में "रंग" था "नीले" की संभावित वैल्यू और "लाल" get_dummies इसे "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), कई कॉलम में बंटी हुई है:
चौथा चरण: डेटा को ट्रेन और टेस्ट सेट में बांटना
मशीन लर्निंग में एक अहम कॉन्सेप्ट है, ट्रेनिंग / टेस्ट स्प्लिट. हम अपने मॉडल को ट्रेनिंग देने के लिए, ज़्यादातर डेटा का इस्तेमाल करेंगे. इसके बाद, बाकी बचे डेटा को हम अपने मॉडल को टेस्ट करने के लिए अलग कर देंगे. ऐसा हम पहले कभी नहीं देखे गए डेटा पर करेंगे.
अपनी नोटबुक में यह कोड जोड़ें, जो हमारे डेटा को बांटने के लिए, Scikit Learn फ़ंक्शन train_test_split का इस्तेमाल करता है:
x,y = data,labels
x_train,x_test,y_train,y_test = train_test_split(x,y)
अब आप अपना मॉडल बनाने और उसे ट्रेनिंग देने के लिए तैयार हैं!
5. XGBoost मॉडल बनाएं, ट्रेनिंग दें, और उसका आकलन करें
पहला चरण: 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() फ़ंक्शन की मदद से, टेस्ट डेटा के लिए अनुमान जनरेट करने के लिए, ट्रेन किए गए मॉडल का इस्तेमाल कर सकते हैं.
इसके बाद, हम हमारे टेस्ट डेटा पर परफ़ॉर्मेंस के आधार पर, हमारे मॉडल का सटीक आकलन करने के लिए, Scikit Learn के accuracy_score फ़ंक्शन का इस्तेमाल करेंगे. हम इसे अपने टेस्ट सेट में मौजूद हर उदाहरण के लिए, मॉडल की अनुमानित वैल्यू के साथ-साथ सटीक डेटा भेजेंगे:
y_pred = model.predict(x_test)
acc = accuracy_score(y_test, y_pred.round())
print(acc, '\n')
आपको 87% के आस-पास सटीक नतीजे दिखेंगे. हालांकि, आपके नतीजे थोड़े अलग होंगे, क्योंकि मशीन लर्निंग में हमेशा एक ही चीज़ होती है.
तीसरा चरण: मॉडल सेव करना
मॉडल को डिप्लॉय करने के लिए, नीचे दिए गए कोड को चलाकर उसे किसी लोकल फ़ाइल में सेव करें:
model.save_model('model.bst')
6. Cloud AI Platform पर मॉडल को डिप्लॉय करें
हमारा मॉडल स्थानीय तौर पर काम कर रहा है, लेकिन यह अच्छा होगा अगर हम कहीं से भी इस पर अनुमान लगा सकें (न कि सिर्फ़ इस नोटबुक!). इस चरण में, हम इसे क्लाउड पर डिप्लॉय करेंगे.
पहला चरण: हमारे मॉडल के लिए Cloud Storage बकेट बनाना
आइए, सबसे पहले कुछ ऐसे एनवायरमेंट वैरिएबल तय करते हैं जिनका इस्तेमाल हम कोडलैब के बाकी हिस्से में करेंगे. नीचे दी गई वैल्यू में अपने Google Cloud प्रोजेक्ट का नाम, उस क्लाउड स्टोरेज बकेट का नाम जिसे आपको बनाना है (दुनिया भर में अलग-अलग होना चाहिए) और अपने मॉडल के पहले वर्शन के वर्शन का नाम डालें:
# 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
दूसरा चरण: मॉडल फ़ाइल को Cloud Storage में कॉपी करना
इसके बाद, हम अपनी XGBoost के सेव किए गए मॉडल की फ़ाइल को Cloud Storage में कॉपी कर देंगे. निम्न gsutil आदेश चलाएं:
!gsutil cp ./model.bst $MODEL_BUCKET
फ़ाइल कॉपी हो जाने की पुष्टि करने के लिए, अपने Cloud Console के स्टोरेज ब्राउज़र पर जाएं:
तीसरा चरण: मॉडल बनाना और डिप्लॉय करना
हम मॉडल को डिप्लॉय करने के लिए करीब-करीब तैयार हैं! यहां दिया गया 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 कंसोल का मॉडल सेक्शन देखें. आपको अपना नया वर्शन वहां डिप्लॉयमेंट में दिखेगा:
डिप्लॉयमेंट पूरा हो जाने के बाद, आपको लोडिंग स्पिनर के जगह पर हरे रंग का सही का निशान दिखेगा. डिप्लॉयमेंट में दो से तीन मिनट लगने चाहिए.
चौथा चरण: डिप्लॉय किए गए मॉडल की जांच करना
यह पक्का करने के लिए कि डिप्लॉय किया गया आपका मॉडल काम कर रहा है या नहीं, 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. अपने मॉडल की व्याख्या करने के लिए व्हाट-इफ़ टूल का इस्तेमाल करें
पहला चरण: क्या होगा अगर टूल विज़ुअलाइज़ेशन बनाना
क्या-क्या होगा अगर टूल को अपने AI Platform मॉडल से कनेक्ट करने के लिए, आपको इसे टेस्ट के उदाहरणों का एक सबसेट पास करना होगा. साथ ही, उन उदाहरणों के लिए सटीक जानकारी देनी होगी. चलिए, अपने टेस्ट उदाहरणों के 500 सैंपल के साथ उनके ग्राउंड ट्रुथ लेबल के साथ एक Numpy कलेक्शन बनाते हैं:
num_wit_examples = 500
test_examples = np.hstack((x_test[:num_wit_examples].values,y_test[:num_wit_examples].reshape(-1,1)))
'क्या होगा' टूल को इंस्टैंशिएट करना उतना ही आसान है जितना कि 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-ऐक्सिस, लोड किए गए सभी डेटा पॉइंट का सिर्फ़ उदाहरण होता है.
दूसरा चरण: अलग-अलग डेटा पॉइंट एक्सप्लोर करना
'क्या-क्या करें' टूल का डिफ़ॉल्ट व्यू, डेटापॉइंट एडिटर टैब है. यहां किसी भी डेटा पॉइंट पर क्लिक करके, उसकी सुविधाओं को देखा जा सकता है और उसकी वैल्यू में बदलाव किया जा सकता है. साथ ही, यह भी जाना जा सकता है कि यह बदलाव किसी डेटा पॉइंट पर मॉडल के अनुमान पर किस तरह असर डालता है.
नीचे दिए गए उदाहरण में, हमने .5 थ्रेशोल्ड के करीब का डेटा पॉइंट चुना है. इस खास डेटा पॉइंट से जुड़ा मॉर्गेज ऐप्लिकेशन, CFPB से मिला है. हमने उस सुविधा को 0 में बदल दिया. साथ ही, agency_code_Department of Housing and Urban Development (HUD) की वैल्यू को भी बदलकर 1 कर दिया, ताकि यह देखा जा सके कि अगर इसके बजाय HUD से क़र्ज़ लिया जाता है, तो मॉडल के अनुमान का क्या होगा:
जैसा कि 'क्या-क्या करें' टूल के सबसे नीचे बाएं सेक्शन में देखा जा सकता है कि इस सुविधा में बदलाव करने से, मॉडल के approved अनुमान में 32% की कमी आई. इससे यह पता चलता है कि जिस एजेंसी से क़र्ज़ लिया गया है उसका मॉडल के आउटपुट पर बहुत ज़्यादा असर पड़ा है. हालांकि, यह पक्का करने के लिए हमें ज़्यादा विश्लेषण करना होगा.
यूज़र इंटरफ़ेस (यूआई) के नीचे बाएं हिस्से में, हम हर डेटा पॉइंट का ज़मीनी हकीकत देख सकते हैं और मॉडल के अनुमान से उसकी तुलना कर सकते हैं:
तीसरा चरण: काउंटरफ़ैक्चुअल विश्लेषण
इसके बाद, किसी भी डेटापॉइंट पर क्लिक करें और नज़दीकी काउंटरफ़ैक्चुअल डेटापॉइंट दिखाएं स्लाइडर को दाईं ओर ले जाएं:
इसे चुनने पर, आपको वह डेटा पॉइंट दिखेगा जिसमें आपकी चुनी गई ओरिजनल वैल्यू से सबसे मिलती-जुलती सुविधा की वैल्यू हैं, लेकिन उसका अनुमान इससे बिलकुल मिलता-जुलता है. इसके बाद, सुविधा की वैल्यू को स्क्रोल करके देखा जा सकता है कि दोनों डेटा पॉइंट में कहां फ़र्क़ है (ये अंतर हरे और बोल्ड में हाइलाइट किए गए हैं).
चौथा चरण: पार्शियल डिपेंडेंसी प्लॉट देखें
यह देखने के लिए कि हर सुविधा, मॉडल के अनुमानों पर कैसे असर डालती है, पार्शियल डिपेंडेंसी प्लॉट बॉक्स पर सही का निशान लगाएं. साथ ही, पक्का करें कि ग्लोबल पार्शियल डिपेंडेंसी प्लॉट को चुना गया हो:
यहां देखा जा सकता है कि HUD से मिलने वाले क़र्ज़ के अस्वीकार होने की संभावना थोड़ी ज़्यादा होती है. ग्राफ़ यह आकार है, क्योंकि एजेंसी कोड एक बूलियन फ़ीचर है, इसलिए मान सिर्फ़ 0 या 1 हो सकते हैं.
applicant_income_thousands अंकों वाली सुविधा है. कुछ हद तक निर्भर होने पर, हम देख सकते हैं कि ज़्यादा आय होने से आवेदन स्वीकार होने की संभावना थोड़ी बढ़ जाती है. हालांकि, यह सिर्फ़ 2 लाख डॉलर तक होती है. दो लाख डॉलर के बाद, मॉडल के अनुमान पर इस सुविधा का कोई असर नहीं पड़ता.
पांचवां चरण: परफ़ॉर्मेंस और निष्पक्षता के बारे में जानें
इसके बाद, परफ़ॉर्मेंस और निष्पक्षता टैब. यह दिए गए डेटासेट पर, मॉडल के नतीजों की परफ़ॉर्मेंस के सभी आंकड़े दिखाता है. इनमें भ्रम की स्थिति बताने वाले मैट्रिक्स, पीआर कर्व, और आरओसी कर्व शामिल हैं.
भ्रम की स्थिति का मैट्रिक्स देखने के लिए, mortgage_status को ग्राउंड ट्रुथ फ़ीचर के तौर पर चुनें:
भ्रम की स्थिति दिखाने वाला यह मैट्रिक्स हमारे मॉडल के सही और गलत अनुमानों को कुल के प्रतिशत के रूप में दिखाता है. अगर असल हां / अनुमानित हां और असल नहीं / अनुमानित नहीं वाले स्क्वेयर जोड़े जाते हैं, तो इसमें आपके मॉडल जैसी ही सटीक जानकारी (करीब 87%) जोड़नी चाहिए.
थ्रेशोल्ड स्लाइडर के साथ एक्सपेरिमेंट करके, क़र्ज़ के लिए approved का अनुमान लगाने से पहले, मॉडल को दिए जाने वाले पॉज़िटिव क्लासिफ़िकेशन स्कोर को बढ़ाया या घटाया जा सकता है. इसके अलावा, यह भी देखा जा सकता है कि इससे सटीक, फ़ॉल्स पॉज़िटिव, और फ़ॉल्स नेगेटिव पर क्या असर पड़ता है. इस मामले में, सटीक होने की वैल्यू .55 के थ्रेशोल्ड के आस-पास होती है.
इसके बाद, बाईं ओर इसके हिसाब से बांटें ड्रॉपडाउन में loan_purpose_Home_purchase चुनें:
अब आपको अपने डेटा के दो सबसेट पर परफ़ॉर्मेंस दिखेगी: "0" स्लाइस से पता चलता है कि क़र्ज़, घर खरीदने के लिए नहीं है और "1" स्लाइस का मतलब है कि क़र्ज़ घर की खरीदारी के लिए है. परफ़ॉर्मेंस में अंतर का पता लगाने के लिए, दो स्लाइस के बीच सटीक, फ़ॉल्स पॉज़िटिव, और फ़ॉल्स नेगेटिव रेट की जांच करें.
अगर भ्रम की स्थिति बताने वाले आव्यूहों को देखने के लिए पंक्तियों को बड़ा किया जाता है, तो देख सकते हैं कि मॉडल का अनुमान "स्वीकार किया गया" है घर से की जाने वाली खरीदारी के लिए ~70% लोन के आवेदन और सिर्फ़ 46% लोन के लिए जो होम खरीदारी के लिए नहीं हैं (आपके मॉडल के हिसाब से सटीक प्रतिशत अलग-अलग होंगे):
बाईं ओर दिए गए रेडियो बटन से डेमोग्राफ़िक समानता चुनने पर, दोनों थ्रेशोल्ड में बदलाव किया जाएगा. इससे यह मॉडल, दोनों स्लाइस में मौजूद आवेदकों के एक जैसे प्रतिशत के लिए, approved का अनुमान लगाएगा. यह हर स्लाइस के सटीक, फ़ॉल्स पॉज़िटिव, और फ़ॉल्स नेगेटिव के लिए क्या करता है?
छठा चरण: सुविधाओं की उपलब्धता के बारे में जानना
आखिर में, 'क्या-क्या करें' टूल में सुविधाएं टैब पर जाएं. इससे आपको अपने डेटासेट में हर सुविधा के लिए वैल्यू का डिस्ट्रिब्यूशन दिखता है:
इस टैब का इस्तेमाल करके यह देखा जा सकता है कि आपका डेटासेट सही है या नहीं. उदाहरण के लिए, डेटासेट में बहुत कम क़र्ज़, फ़ार्म सर्विस एजेंसी से लिए गए हैं. मॉडल को ज़्यादा सटीक बनाने के लिए, डेटा उपलब्ध होने पर हम उस एजेंसी के अन्य क़र्ज़ शामिल करने पर विचार कर सकते हैं.
हमने यहां कुछ ऐसे टूल एक्सप्लोरेशन के आइडिया के बारे में बताया है जो बेहतर हैं. टूल का इस्तेमाल करते रहें. यहां एक्सप्लोर करने के लिए और भी कई विकल्प हैं!
8. साफ़-सफ़ाई सेवा
अगर आपको इस notebook का इस्तेमाल जारी रखना है, तो हमारा सुझाव है कि इस्तेमाल में न होने पर इसे बंद कर दें. अपने Cloud Console में Notebook के यूज़र इंटरफ़ेस (यूआई) से, नोटबुक चुनें और फिर बंद करें चुनें:
यदि आप इस लैब में बनाए गए सभी संसाधनों को हटाना चाहते हैं, तो इसे रोकने के बजाय बस नोटबुक इंस्टेंस को हटाएं.
अपने Cloud Console में नेविगेशन मेन्यू का इस्तेमाल करके, 'स्टोरेज' पर जाएं और अपने मॉडल ऐसेट को स्टोर करने के लिए बनाए गए दोनों बकेट मिटाएं.