1. खास जानकारी
इस लैब में, वित्तीय डेटा के आधार पर तैयार किए गए XGBoost मॉडल का विश्लेषण करने के लिए, क्या होगा-अगर टूल का इस्तेमाल किया जाएगा. मॉडल का विश्लेषण करने के बाद, उसे Cloud के नए Vertex AI में डिप्लॉय कर दिया जाएगा.
आपने क्या सीखा
आपको, इनके बारे में जानकारी मिलेगी:
- होस्ट की गई नोटबुक में मौजूद सार्वजनिक मॉर्गेज डेटासेट पर, XGBoost मॉडल को ट्रेनिंग दें
- व्हाट-इफ़ टूल का इस्तेमाल करके इस मॉडल का विश्लेषण करें
- Vertex AI में XGBoost मॉडल को डिप्लॉय करें
Google Cloud पर इस लैब को चलाने की कुल लागत करीब $1 है.
2. Vertex AI के बारे में जानकारी
यह लैब, Google Cloud पर उपलब्ध एआई (AI) प्रॉडक्ट के सबसे नए वर्शन का इस्तेमाल करती है. Vertex AI, Google Cloud के सभी मशीन लर्निंग प्लैटफ़ॉर्म को आसानी से डेवलप करने के लिए इंटिग्रेट करता है. पहले, AutoML और कस्टम मॉडल की मदद से ट्रेन किए गए मॉडल अलग-अलग सेवाओं से ऐक्सेस किए जा सकते थे. नई सेवा में, एक एपीआई से नए प्रॉडक्ट और इन दोनों का इस्तेमाल किया जा सकता है. आपके पास मौजूदा प्रोजेक्ट को Vertex AI पर माइग्रेट करने का विकल्प भी है. अगर आपकी कोई शिकायत है, तो कृपया सहायता पेज पर जाएं.
Vertex AI में कई तरह के प्रॉडक्ट शामिल हैं, जो मशीन लर्निंग के वर्कफ़्लो को मैनेज करने में मदद करते हैं. यह लैब, यहां हाइलाइट किए गए प्रॉडक्ट पर फ़ोकस करेगा: अनुमान और Notebook.
3. एक क्विक XGBoost प्राइमर
XGBoost एक मशीन लर्निंग फ़्रेमवर्क है. यह अनुमानित मॉडल बनाने के लिए डिसीज़न ट्री और ग्रेडिएंट बूस्टिंग का इस्तेमाल करता है. यह किसी ट्री के अलग-अलग लीफ़ नोड से जुड़े स्कोर के आधार पर, कई डिसिज़न ट्री को इकट्ठा करके काम करता है.
नीचे दिया गया डायग्राम, डिसिज़न ट्री के आसान मॉडल का विज़ुअलाइज़ेशन है. इससे यह आकलन किया जाता है कि मौसम के पूर्वानुमान के हिसाब से खेल का गेम खेला जाना चाहिए या नहीं:
हम इस मॉडल के लिए XGBoost का इस्तेमाल क्यों कर रहे हैं? पारंपरिक न्यूरल नेटवर्क को इमेज और टेक्स्ट जैसे बिना स्ट्रक्चर वाले डेटा पर सबसे अच्छा परफ़ॉर्म करने के लिए दिखाया गया है. हालांकि, डिसिज़न ट्री अक्सर स्ट्रक्चर्ड डेटा पर बहुत अच्छा परफ़ॉर्म करते हैं. जैसे, मॉर्गेज डेटासेट, जिसका इस्तेमाल हम इस कोडलैब में करेंगे.
4. अपना एनवायरमेंट सेट अप करें
इस कोडलैब को चलाने के लिए, आपके पास Google Cloud Platform का ऐसा प्रोजेक्ट होना चाहिए जिसमें बिलिंग की सुविधा चालू हो. प्रोजेक्ट बनाने के लिए, यहां दिए गए निर्देशों का पालन करें.
पहला चरण: Compute Engine API चालू करना
Compute Engine पर जाएं और अगर यह पहले से चालू नहीं है, तो चालू करें को चुनें. आपको अपना notebook इंस्टेंस बनाने के लिए इसकी ज़रूरत होगी.
दूसरा चरण: Vertex AI API को चालू करना
अपने Cloud Console के Vertex सेक्शन पर जाएं और Vertex AI API को चालू करें पर क्लिक करें.
तीसरा चरण: Notebooks इंस्टेंस बनाना
अपने Cloud Console के Vertex सेक्शन में, Notebooks पर क्लिक करें:
इसके बाद, नया इंस्टेंस चुनें. इसके बाद, बिना जीपीयू के TensorFlow Enterprise 2.3 इंस्टेंस टाइप चुनें:
डिफ़ॉल्ट विकल्पों का इस्तेमाल करें और फिर बनाएं पर क्लिक करें. इंस्टेंस बनाने के बाद, JupyterLab खोलें को चुनें.
चौथा चरण: XGBoost को इंस्टॉल करें
आपका JupyterLab इंस्टेंस खुल जाने के बाद, आपको XGBoost पैकेज जोड़ना होगा.
ऐसा करने के लिए, लॉन्चर से Terminal चुनें:
इसके बाद, Vertex AI के साथ काम करने वाले XGBoost के नए वर्शन को इंस्टॉल करने के लिए, नीचे दिया गया तरीका अपनाएं:
pip3 install xgboost==1.2
इसके पूरा होने के बाद, लॉन्चर से 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
5. डेटा डाउनलोड और प्रोसेस करें
हम XGBoost मॉडल को ट्रेनिंग देने के लिए, ffiec.gov से मिले मॉर्गेज डेटासेट का इस्तेमाल करेंगे. हमने मूल डेटासेट की कुछ प्री-प्रोसेसिंग की है. साथ ही, इसका एक छोटा वर्शन बनाया है, जिसका इस्तेमाल करके आप मॉडल को ट्रेनिंग दे सकते हैं. मॉडल यह अनुमान लगाएगा कि किसी क़र्ज़ के लिए आवेदन को स्वीकार किया जाएगा या नहीं.
पहला चरण: पहले से प्रोसेस किया गया डेटासेट डाउनलोड करना
हमने आपके लिए Google Cloud Storage में डेटासेट का एक वर्शन उपलब्ध कराया है. आप अपनी Jupyter notebook में नीचे दिया गया gsutil निर्देश चलाकर इसे डाउनलोड कर सकते हैं:
!gsutil cp 'gs://mortgage_dataset_files/mortgage-small.csv' .
दूसरा चरण: 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 बनाएंगे और उसे ऊपर बताए गए डेटा टाइप में भेजेंगे. अगर मूल डेटासेट को किसी खास तरीके से ऑर्डर किया गया हो, तो हमारे डेटा को शफ़ल करना ज़रूरी है. ऐसा करने के लिए हम 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.values,labels
x_train,x_test,y_train,y_test = train_test_split(x,y)
अब आप अपना मॉडल बनाने और उसे ट्रेनिंग देने के लिए तैयार हैं!
6. 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')
7. अपने मॉडल की व्याख्या करने के लिए व्हाट-इफ़ टूल का इस्तेमाल करें
पहला चरण: क्या होगा अगर टूल विज़ुअलाइज़ेशन बनाना
क्या होगा-अगर टूल को अपने लोकल मॉडल से कनेक्ट करने के लिए, आपको इसे जांच के उदाहरणों के सबसेट में पास करना होगा. साथ ही, आपको उन उदाहरणों के लिए सटीक जानकारी देनी होगी. चलिए, अपने टेस्ट उदाहरणों के 500 सैंपल के साथ उनके ग्राउंड ट्रुथ लेबल के साथ एक Numpy कलेक्शन बनाते हैं:
num_wit_examples = 500
test_examples = np.hstack((x_test[:num_wit_examples],y_test[:num_wit_examples].reshape(-1,1)))
'क्या होगा' टूल को इंस्टैंशिएट करना WitConfigBuilder ऑब्जेक्ट बनाने और उसे उस मॉडल को पास करने जितना आसान है जिसका हम विश्लेषण करना चाहते हैं.
व्हाट-इफ़ टूल को अपने मॉडल में हर क्लास के लिए स्कोर की सूची चाहिए (इस मामले में 2), इसलिए हम व्हाट-इफ़ टूल के साथ XGBoost के predict_proba तरीके का इस्तेमाल करेंगे:
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)
ध्यान दें कि विज़ुअलाइज़ेशन को लोड होने में एक मिनट लगेगा. इसके लोड होने पर, आपको यह जानकारी दिखेगी:
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. मॉडल को Vertex AI में डिप्लॉय करें
हमारा मॉडल स्थानीय स्तर पर काम कर रहा है, लेकिन यह अच्छा होगा अगर हम कहीं से भी इस पर पूर्वानुमान लगा सकें (न कि केवल इस नोटबुक!). इस चरण में, हम इसे क्लाउड पर डिप्लॉय करेंगे.
पहला चरण: हमारे मॉडल के लिए 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
दूसरा चरण: मॉडल फ़ाइल को Cloud Storage में कॉपी करना
इसके बाद, हम अपनी XGBoost सेव की गई मॉडल फ़ाइल को Cloud Storage में कॉपी कर देंगे. निम्न gsutil आदेश चलाएं:
!gsutil cp ./model.bst $MODEL_BUCKET
फ़ाइल कॉपी हो जाने की पुष्टि करने के लिए, अपने Cloud Console के स्टोरेज ब्राउज़र पर जाएं:
तीसरा चरण: मॉडल बनाना और एंडपॉइंट पर डिप्लॉय करना
हम मॉडल को क्लाउड पर डिप्लॉय करने के लिए करीब-करीब तैयार हैं! Vertex AI में, एक मॉडल में एक से ज़्यादा एंडपॉइंट हो सकते हैं. हम पहले कोई मॉडल बनाएंगे. इसके बाद, हम उस मॉडल में एक एंडपॉइंट बनाएंगे और उसे डिप्लॉय करेंगे.
सबसे पहले, अपना मॉडल बनाने के लिए, gcloud सीएलआई का इस्तेमाल करें:
!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 मिनट लगेंगे. एंडपॉइंट के डिप्लॉयमेंट के दौरान, अपने कंसोल के मॉडल सेक्शन पर जाएं. अपने मॉडल पर क्लिक करें और आपको अपने अभियान का परिनियोजन देखना चाहिए:
डिप्लॉयमेंट पूरा हो जाने के बाद, आपको लोडिंग स्पिनर के जगह पर हरे रंग का सही का निशान दिखेगा.
चौथा चरण: डिप्लॉय किए गए मॉडल की जांच करना
यह पक्का करने के लिए कि डिप्लॉय किया गया आपका मॉडल काम कर रहा है या नहीं, 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 का इस्तेमाल जारी रखना है, तो हमारा सुझाव है कि इस्तेमाल में न होने पर इसे बंद कर दें. अपने Cloud Console में Notebook के यूज़र इंटरफ़ेस (यूआई) से, नोटबुक चुनें और फिर बंद करें चुनें:
यदि आप इस लैब में बनाए गए सभी संसाधनों को हटाना चाहते हैं, तो इसे रोकने के बजाय बस नोटबुक इंस्टेंस को हटाएं.
डिप्लॉय किए गए एंडपॉइंट को मिटाने के लिए, अपने Vertex कंसोल के एंडपॉइंट सेक्शन पर जाएं और 'मिटाएं' आइकॉन पर क्लिक करें:
अपने Cloud Console में नेविगेशन मेन्यू का इस्तेमाल करके, स्टोरेज बकेट मिटाने के लिए स्टोरेज पर जाएं. इसके बाद, अपनी बकेट चुनें और मिटाएं पर क्लिक करें:
