1. खास जानकारी
इस लैब में, आपको What-if टूल का इस्तेमाल करके, वित्तीय डेटा पर ट्रेन किए गए XGBoost मॉडल का विश्लेषण करना होगा. मॉडल का विश्लेषण करने के बाद, आपको उसे Cloud के नए Vertex AI पर डिप्लॉय करना होगा.
आपको क्या सीखने को मिलेगा
आपको, इनके बारे में जानकारी मिलेगी:
- होस्ट की गई नोटबुक में, सार्वजनिक मॉर्गेज डेटासेट पर XGBoost मॉडल को ट्रेन करना
- व्हाट-इफ़ टूल का इस्तेमाल करके मॉडल का विश्लेषण करना
- Vertex AI में XGBoost मॉडल को डिप्लॉय करना
Google Cloud पर इस लैब को चलाने की कुल लागत एक डॉलर है.
2. Vertex AI के बारे में जानकारी
यह लैब, Google Cloud पर उपलब्ध एआई प्रॉडक्ट के सबसे नए वर्शन का इस्तेमाल करता है. Vertex AI, Google Cloud के सभी मशीन लर्निंग प्लैटफ़ॉर्म को आसानी से डेवलप करने के लिए इंटिग्रेट करता है. पहले, AutoML की मदद से ट्रेन किए गए मॉडल और कस्टम मॉडल को अलग-अलग सेवाओं से ऐक्सेस किया जा सकता था. नई सुविधा में, दोनों को एक ही एपीआई में जोड़ा गया है. साथ ही, इसमें अन्य नए प्रॉडक्ट भी शामिल हैं. आपके पास मौजूदा प्रोजेक्ट को Vertex AI पर माइग्रेट करने का विकल्प भी है. अगर आपका कोई सुझाव, शिकायत या राय है, तो कृपया सहायता पेज पर जाएं.
Vertex AI में कई अलग-अलग प्रॉडक्ट शामिल हैं, ताकि एंड-टू-एंड एमएल वर्कफ़्लो को बेहतर बनाया जा सके. इस लैब में, नीचे हाइलाइट किए गए प्रॉडक्ट पर फ़ोकस किया जाएगा: अनुमान और नोटबुक.
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 सेक्शन में, नोटबुक पर क्लिक करें:
इसके बाद, नया इंस्टेंस चुनें. इसके बाद, GPU के बिना TensorFlow Enterprise 2.3 इंस्टेंस टाइप चुनें:
डिफ़ॉल्ट विकल्पों का इस्तेमाल करें. इसके बाद, बनाएं पर क्लिक करें. इंस्टेंस बन जाने के बाद, JupyterLab खोलें को चुनें.
चौथा चरण: XGBoost इंस्टॉल करना
आपका JupyterLab इंस्टेंस खुल जाने के बाद, आपको XGBoost पैकेज जोड़ना होगा.
इसके लिए, लॉन्चर से Terminal चुनें:
इसके बाद, Vertex AI के साथ काम करने वाले XGBoost का नया वर्शन इंस्टॉल करने के लिए, यह तरीका अपनाएं:
pip3 install xgboost==1.2
इसके पूरा होने के बाद, लॉन्चर से Python 3 नोटबुक इंस्टेंस खोलें. अब आपके पास नोटबुक में काम शुरू करने का विकल्प है!
पांचवां चरण: 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 नोटबुक में यह 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 वैल्यू से पता चलता है कि उसे अस्वीकार कर दिया गया है.
डेटासेट में स्वीकार की गई / अस्वीकार की गई वैल्यू का डिस्ट्रिब्यूशन देखने और लेबल का numpy ऐरे बनाने के लिए, यह तरीका अपनाएं:
# 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. अपने मॉडल को समझने के लिए, 'अगर ऐसा होता है, तो' टूल का इस्तेमाल करना
पहला चरण: 'क्या-क्या हो सकता है' टूल का विज़ुअलाइज़ेशन बनाना
What-if टूल को अपने लोकल मॉडल से कनेक्ट करने के लिए, आपको टेस्ट के उदाहरणों का सबसेट और उन उदाहरणों के लिए असल वैल्यू देनी होगी. आइए, अपने 500 टेस्ट उदाहरणों के साथ-साथ उनके ग्राउंड ट्रूथ लेबल का Numpy ऐरे बनाते हैं:
num_wit_examples = 500
test_examples = np.hstack((x_test[:num_wit_examples],y_test[:num_wit_examples].reshape(-1,1)))
'अगर ऐसा होता है, तो क्या होगा' टूल को इंस्टैंशिएट करना उतना ही आसान है जितना कि WitConfigBuilder ऑब्जेक्ट बनाना और उसे वह मॉडल पास करना जिसका विश्लेषण करना है.
'क्या-क्या हो सकता है' टूल को हमारे मॉडल में हर क्लास (इस मामले में दो) के लिए स्कोर की सूची चाहिए. इसलिए, हम 'क्या-क्या हो सकता है' टूल के साथ 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,00,000 डॉलर तक बढ़ती है. 2,00,000 डॉलर के बाद, इस सुविधा का असर मॉडल के अनुमान पर नहीं पड़ता.
पांचवां चरण: परफ़ॉर्मेंस और निष्पक्षता के बारे में ज़्यादा जानें
इसके बाद, परफ़ॉर्मेंस और निष्पक्षता टैब पर जाएं. यह दिए गए डेटासेट पर मॉडल के नतीजों की परफ़ॉर्मेंस के आंकड़े दिखाता है. इसमें, कॉन्फ़्यूज़न मैट्रिक्स, पीआर कर्व, और आरओसी कर्व शामिल हैं.
कन्फ़्यूज़न मैट्रिक देखने के लिए, ग्राउंड ट्रूथ फ़ीचर के तौर पर 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 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 पैरामीटर, उस स्टोरेज लोकेशन की जानकारी देगा जहां आपने 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 मिनट लगेंगे. एंडपॉइंट डिप्लॉय होने के दौरान, अपने कंसोल के मॉडल सेक्शन पर जाएं. अपने मॉडल पर क्लिक करें और आपको अपने अभियान का परिनियोजन देखना चाहिए:
डिप्लॉय हो जाने के बाद, आपको जहां लोडिंग स्पिनर दिख रहा था वहां हरे रंग का सही का निशान दिखेगा.
चौथा चरण: डिप्लॉय किए गए मॉडल की जांच करना
यह पक्का करने के लिए कि डिप्लॉय किया गया मॉडल काम कर रहा है या नहीं, 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 में नोटबुक यूज़र इंटरफ़ेस (यूआई) से, नोटबुक चुनें. इसके बाद, रोकें को चुनें:
अगर आपको इस लैब में बनाए गए सभी संसाधन मिटाने हैं, तो नोटबुक इंस्टेंस को बंद करने के बजाय उसे मिटाएं.
डिप्लॉय किए गए एंडपॉइंट को मिटाने के लिए, अपने Vertex कंसोल के 'एंडपॉइंट' सेक्शन पर जाएं और मिटाएं आइकॉन पर क्लिक करें:
स्टोरेज बकेट मिटाने के लिए, अपने Cloud Console में नेविगेशन मेन्यू का इस्तेमाल करके, स्टोरेज पर जाएं. इसके बाद, अपनी बकेट चुनें और 'मिटाएं' पर क्लिक करें:
