Python में XGBoost का उपयोग: ट्यूटोरियल

XGBoost इंस्टॉलेशन

आप XGBoost को किसी भी अन्य लाइब्रेरी की तरह pip के जरिए इंस्टॉल कर सकते हैं। यह इंस्टॉलेशन विधि आपकी मशीन के NVIDIA GPU के लिए भी सपोर्ट शामिल करेगी। यदि आप केवल CPU संस्करण इंस्टॉल करना चाहते हैं, तो आप conda-forge का उपयोग कर सकते हैं:

$ pip install --user xgboost

# CPU only

$ conda install -c conda-forge py-xgboost-cpu

# Use NVIDIA GPU

$ conda install -c conda-forge py-xgboost-gpuसंचालित द्वारा

अपने बेस एनवायरनमेंट को प्रदूषित होने से बचाने के लिए XGBoost को वर्चुअल एनवायरनमेंट में इंस्टॉल करना अनुशंसित है।

हम सलाह देते हैं कि आप ट्यूटोरियल के उदाहरणों को GPU-सक्षम मशीन पर चलाएँ। यदि आपके पास नहीं है, तो आप DataLab या Google Colab जैसे विकल्प देख सकते हैं।

यदि आप Colab का उपयोग करते हैं, तो उसमें XGBoost का पुराना संस्करण इंस्टॉल होता है, इसलिए नवीनतम संस्करण पाने के लिए आपको pip install --upgrade xgboost चलाना चाहिए।

डेटा लोड करना और एक्सप्लोर करना

हम पूरे ट्यूटोरियल में Diamonds डेटासेट के साथ काम करेंगे। यह Seaborn लाइब्रेरी में बिल्ट-इन है, या वैकल्पिक रूप से आप इसे Kaggle से डाउनलोड भी कर सकते हैं। इसमें संख्यात्मक और श्रेणीबद्ध फीचर्स का अच्छा संयोजन है और 50k से अधिक ऑब्जर्वेशंस हैं, जिनसे हम XGBoost के सभी फायदे आसानी से दिखा सकते हैं।

import seaborn as sns

import pandas as pd

import numpy as np

import matplotlib.pyplot as plt

import warnings


warnings.filterwarnings("ignore")


diamonds = sns.load_dataset("diamonds")

diamonds.head()संचालित द्वारा

>>> diamonds.shape
(53940, 10)संचालित द्वारा

किसी सामान्य वास्तविक-विश्व प्रोजेक्ट में, आप डेटासेट को एक्सप्लोर करने और उसके फीचर्स को विज़ुअलाइज़ करने में अधिक समय देना चाहेंगे। लेकिन चूंकि यह डेटा Seaborn में बिल्ट-इन आता है, यह अपेक्षाकृत साफ है।

तो, हम केवल संख्यात्मक और श्रेणीबद्ध फीचर्स के 5-संख्या सारांश पर नज़र डालेंगे और आगे बढ़ेंगे। आप कुछ समय निकालकर डेटासेट से परिचित हो सकते हैं।

diamonds.describe()संचालित द्वारा

diamonds.describe(exclude=np.number)संचालित द्वारा

XGBoost DMatrix कैसे बनाएं

एक्सप्लोरेशन के बाद, किसी भी प्रोजेक्ट में पहला कदम मशीन लर्निंग समस्या को फ्रेम करना और डेटासेट के आधार पर फीचर और टारगेट एरेज़ निकालना होता है।

इस ट्यूटोरियल में, हम पहले उनके भौतिक माप के आधार पर डायमंड की कीमतों की भविष्यवाणी करने की कोशिश करेंगे, इसलिए हमारा टारगेट price कॉलम होगा।

तो, हम फीचर्स को X और टारगेट को y में अलग कर रहे हैं:

from sklearn.model_selection import train_test_split

# Extract feature and target arrays
X, y = diamonds.drop('price', axis=1), diamonds[['price']]संचालित द्वारा

डेटासेट में तीन श्रेणीबद्ध कॉलम हैं। सामान्यतः, आप उन्हें ऑर्डिनल या वन-हॉट एनकोडिंग से एनकोड करेंगे, लेकिन XGBoost में कैटेगॉरिकल्स को आंतरिक रूप से संभालने की क्षमता होती है।

इस फीचर को सक्षम करने का तरीका यह है कि कैटेगॉरिकल कॉलम्स को Pandas के category डेटा टाइप में कास्ट किया जाए (डिफ़ॉल्ट रूप से, उन्हें टेक्स्ट कॉलम माना जाता है):

# Extract text features
cats = X.select_dtypes(exclude=np.number).columns.tolist()

# Convert to Pandas category
for col in cats:
   X[col] = X[col].astype('category')संचालित द्वारा

अब, जब आप dtypes एट्रिब्यूट प्रिंट करेंगे, तो आप देखेंगे कि हमारे पास तीन category फीचर्स हैं:

>>> X.dtypes
carat       float64
cut        category
color      category
clarity    category
depth       float64
table       float64
x           float64
y           float64
z           float64
dtype: objectसंचालित द्वारा

आइए डेटा को train और test सेट्स में विभाजित करते हैं (0.25 टेस्ट साइज):

# Split the data
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=1)संचालित द्वारा

अब, महत्वपूर्ण हिस्सा: XGBoost अपने डेटासेट्स को स्टोर करने के लिए DMatrix नामक एक क्लास के साथ आता है। यह मेमोरी और स्पीड के लिए अत्यधिक अनुकूलित क्लास है। यही कारण है कि नेटिव XGBoost API के लिए डेटासेट्स को इस फॉर्मेट में बदलना आवश्यक है:

import xgboost as xgb

# Create regression matrices
dtrain_reg = xgb.DMatrix(X_train, y_train, enable_categorical=True)
dtest_reg = xgb.DMatrix(X_test, y_test, enable_categorical=True)संचालित द्वारा

यह क्लास ट्रेनिंग फीचर्स और लेबल्स दोनों को स्वीकार करती है। Pandas की category कॉलम्स के स्वचालित एनकोडिंग को सक्षम करने के लिए, हम enable_categorical को True पर सेट करते हैं।

नोट:

हम XGBoost के Scikit-learn API की बजाय नेटिव API के साथ क्यों जा रहे हैं? शुरुआत में Sklearn API का उपयोग करना अधिक सुविधाजनक लग सकता है, लेकिन आगे चलकर आपको अहसास होगा कि XGBoost के नेटिव API में कुछ बेहतरीन फीचर्स हैं जो Sklearn API सपोर्ट नहीं करता। इसलिए शुरू से ही इसकी आदत डालना बेहतर है। हालांकि, अंत में एक सेक्शन है जहाँ हम दिखाते हैं कि कैसे आप मॉडल ट्रेन करने के बाद भी एक ही लाइन के कोड से APIs के बीच स्विच कर सकते हैं।

Python XGBoost रिग्रेशन

DMatrices बनाने के बाद, आपको objective पैरामीटर के लिए एक मान चुनना चाहिए। यह XGBoost को बताता है कि आप कौन सी मशीन लर्निंग समस्या हल करने की कोशिश कर रहे हैं और उसे हल करने के लिए किन मेट्रिक्स या लॉस फंक्शंस का उपयोग करना है।

उदाहरण के लिए, डायमंड की कीमतों की भविष्यवाणी करना एक रिग्रेशन समस्या है, जिसके लिए आप आम reg:squarederror ऑब्जेक्टिव का उपयोग कर सकते हैं। आमतौर पर, ऑब्जेक्टिव के नाम में उस समस्या के लिए लॉस फंक्शन का नाम भी होता है। रिग्रेशन के लिए, Root Mean Squared Error सामान्य है, जो वास्तविक और अनुमानित मानों के बीच अंतर के वर्गों के योग के वर्गमूल को न्यूनतम करता है। NumPy में मेट्रिक इस तरह दिखेगी:

import numpy as np

mse = np.mean((actual - predicted) ** 2)
rmse = np.sqrt(mse)संचालित द्वारा

हम क्लासिफिकेशन ऑब्जेक्टिव्स को ट्यूटोरियल में आगे सीखेंगे।

लॉस फंक्शन और परफॉर्मेंस मेट्रिक के बीच अंतर पर एक टिप्पणी: लॉस फंक्शन का उपयोग मशीन लर्निंग मॉडल्स द्वारा वास्तविक (ग्राउंड ट्रुथ) मानों और मॉडल प्रेडिक्शंस के बीच अंतर को न्यूनतम करने के लिए किया जाता है। दूसरी ओर, मशीन लर्निंग इंजीनियर मेट्रिक (या मेट्रिक्स) का चयन ग्राउंड ट्रुथ और मॉडल प्रेडिक्शंस के बीच समानता मापने के लिए करते हैं।

संक्षेप में, लॉस फंक्शन को न्यूनतम करना चाहिए जबकि मेट्रिक को अधिकतम करना चाहिए। ट्रेनिंग के दौरान लॉस फंक्शन मॉडल को बताता है कि कहाँ सुधार करना है। इवैल्युएशन के दौरान मेट्रिक का उपयोग समग्र प्रदर्शन मापने के लिए किया जाता है।

ट्रेनिंग

चुना गया ऑब्जेक्टिव फंक्शन और XGBoost के अन्य हाइपरपैरामीटर्स एक डिक्शनरी में निर्दिष्ट किए जाने चाहिए, जिसे परंपरागत रूप से params कहा जाता है:

# Define hyperparameters
params = {"objective": "reg:squarederror", "tree_method": "gpu_hist"}संचालित द्वारा

इस शुरुआती params में, हम tree_method को gpu_hist पर सेट कर रहे हैं, जो GPU त्वरकता सक्षम करता है। यदि आपके पास GPU नहीं है, तो आप इस पैरामीटर को छोड़ सकते हैं या hist पर सेट कर सकते हैं।

अब, हम num_boost_round नामक एक और पैरामीटर सेट करते हैं, जिसका अर्थ है बूस्टिंग राउंड्स की संख्या। आंतरिक रूप से, XGBoost लॉस फंक्शन RMSE को छोटे-छोटे इन्क्रीमेंटल राउंड्स में न्यूनतम करता है (इस पर आगे और)। यह पैरामीटर उन राउंड्स की संख्या निर्दिष्ट करता है।

आदर्श राउंड्स की संख्या हाइपरपैरामीटर ट्यूनिंग के जरिए पाई जाती है। फिलहाल, हम इसे 100 पर सेट कर देंगे:

# Define hyperparameters
params = {"objective": "reg:squarederror", "tree_method": "gpu_hist"}

n = 100
model = xgb.train(
   params=params,
   dtrain=dtrain_reg,
   num_boost_round=n,
)संचालित द्वारा

जब XGBoost GPU पर चलता है, तो यह बेहद तेज़ होता है। यदि आपको ऊपर दिए गए कोड से कोई त्रुटि नहीं मिली, तो ट्रेनिंग सफल रही!

इवैल्युएशन

बूस्टिंग राउंड्स के दौरान, मॉडल ऑब्जेक्ट ने ट्रेनिंग सेट के सभी पैटर्न सीख लिए हैं जो वह सीख सकता था। अब, हमें अनदेखे डेटा पर इसका प्रदर्शन मापना चाहिए। यहीं पर हमारा dtest_reg DMatrix काम आता है:

from sklearn.metrics import mean_squared_error

preds = model.predict(dtest_reg)संचालित द्वारा

इस प्रक्रिया को मॉडल इवैल्युएशन (या इन्फ्रेंस) कहते हैं। एक बार जब आप predict से प्रेडिक्शंस जनरेट कर लेते हैं, तो आप उन्हें Sklearn के mean_squared_error फंक्शन में y_test के साथ तुलना के लिए पास करते हैं:

rmse = mean_squared_error(y_test, preds, squared=False)

print(f"RMSE of the base model: {rmse:.3f}")
RMSE of the base model: 543.203संचालित द्वारा

हमें ~543$ का बेस स्कोर मिला है, जो डिफ़ॉल्ट पैरामीटर्स वाले बेस मॉडल का प्रदर्शन था। इसे बेहतर करने के दो तरीके हैं—क्रॉस-वैलिडेशन और हाइपरपैरामीटर ट्यूनिंग करना। लेकिन उससे पहले, XGBoost मॉडलों का मूल्यांकन करने का एक तेज़ तरीका देखते हैं।

ट्रेनिंग के दौरान वैलिडेशन सेट्स का उपयोग

मशीन लर्निंग मॉडल को ट्रेन करना अंतरिक्ष में रॉकेट लॉन्च करने जैसा है। आप लॉन्च तक मॉडल के बारे में सब कुछ नियंत्रित कर सकते हैं, पर एक बार लॉन्च हो जाने के बाद, आप केवल खड़े होकर उसके पूरा होने का इंतजार कर सकते हैं।

लेकिन हमारी मौजूदा ट्रेनिंग प्रक्रिया की समस्या यह है कि हम यह भी नहीं देख सकते कि मॉडल कहाँ जा रहा है। इसे हल करने के लिए, हम इवैल्युएशन एरेज़ का उपयोग करेंगे जो हमें बूस्टिंग राउंड्स के दौरान क्रमिक सुधार के साथ मॉडल का प्रदर्शन दिखाने देते हैं।

पहले, पैरामीटर्स फिर से सेट करते हैं:

params = {"objective": "reg:squarederror", "tree_method": "gpu_hist"}
n = 100संचालित द्वारा

इसके बाद, हम दो ट्यूपल्स की एक लिस्ट बनाते हैं, जिनमें दो-दो एलिमेंट होते हैं। पहला एलिमेंट वह एरे है जिस पर मॉडल को इवैल्युएट करना है, और दूसरा एलिमेंट उस एरे का नाम है।

evals = [(dtrain_reg, "train"), (dtest_reg, "validation")]संचालित द्वारा

जब हम इस एरे को xgb.train के evals पैरामीटर में पास करते हैं, तो हमें हर बूस्टिंग राउंड के बाद मॉडल का प्रदर्शन दिखाई देगा:

evals = [(dtrain_reg, "train"), (dtest_reg, "validation")]

model = xgb.train(
   params=params,
   dtrain=dtrain_reg,
   num_boost_round=n,
   evals=evals,
)संचालित द्वारा

आपको नीचे दिए गए आउटपुट जैसा परिणाम मिलना चाहिए (यहाँ 10 पंक्तियों तक संक्षिप्त)। आप देख सकते हैं कि मॉडल स्कोर को ~3931$ से घटाकर मात्र 543$ तक लाता है।

सबसे अच्छी बात यह है कि हम अपने ट्रेनिंग और वैलिडेशन सेट्स—दोनों पर मॉडल का प्रदर्शन देख सकते हैं। आमतौर पर, ट्रेनिंग लॉस वैलिडेशन से कम होगा क्योंकि मॉडल ने ट्रेनिंग डेटा पहले ही देख लिया है।

[0] train-rmse:3985.18329 validation-rmse:3930.52457

[1] train-rmse:2849.72257 validation-rmse:2813.20828
[2] train-rmse:2059.86648 validation-rmse:2036.66330
[3] train-rmse:1519.32314 validation-rmse:1510.02762
[4] train-rmse:1153.68171 validation-rmse:1153.91223
...
[95] train-rmse:381.93902 validation-rmse:543.56526
[96] train-rmse:380.97024 validation-rmse:543.51413
[97] train-rmse:380.75330 validation-rmse:543.36855
[98] train-rmse:379.65918 validation-rmse:543.42558
[99] train-rmse:378.30590 validation-rmse:543.20278संचालित द्वारा

वास्तविक-विश्व प्रोजेक्ट्स में, आप आम तौर पर हजारों बूस्टिंग राउंड्स के लिए ट्रेन करते हैं, जिसका मतलब है उतनी ही पंक्तियों का आउटपुट। इन्हें कम करने के लिए, आप verbose_eval पैरामीटर का उपयोग कर सकते हैं, जो XGBoost को हर vebose_eval राउंड्स पर परफॉर्मेंस अपडेट प्रिंट करने के लिए बाध्य करता है:

params = {"objective": "reg:squarederror", "tree_method": "gpu_hist"}
n = 100

evals = [(dtest_reg, "validation"), (dtrain_reg, "train")]


model = xgb.train(
   params=params,
   dtrain=dtrain_reg,
   num_boost_round=n,
   evals=evals,
   verbose_eval=10 # Every ten rounds
)

[OUT]: 

[0] train-rmse:3985.18329 validation-rmse:3930.52457
[10] train-rmse:550.08330 validation-rmse:590.15023
[20] train-rmse:488.51248 validation-rmse:551.73431
[30] train-rmse:463.13288 validation-rmse:547.87843
[40] train-rmse:447.69788 validation-rmse:546.57096
[50] train-rmse:432.91655 validation-rmse:546.22557
[60] train-rmse:421.24046 validation-rmse:546.28601
[70] train-rmse:408.64125 validation-rmse:546.78238
[80] train-rmse:396.41125 validation-rmse:544.69846
[90] train-rmse:386.87996 validation-rmse:543.82192
[99] train-rmse:378.30590 validation-rmse:543.20278संचालित द्वारा

XGBoost अर्ली स्टॉपिंग

अब तक, आपको समझ में आ गया होगा कि बूस्टिंग राउंड्स कितने महत्वपूर्ण हैं। सामान्यतः, जितने अधिक राउंड्स होंगे, XGBoost लॉस को उतना ही कम करने की कोशिश करेगा। लेकिन इसका मतलब यह नहीं कि लॉस हमेशा नीचे ही जाएगा। आइए 5000 बूस्टिंग राउंड्स के साथ 500 की वर्बोसिटी पर कोशिश करते हैं:

params = {"objective": "reg:squarederror", "tree_method": "gpu_hist"}
n = 5000

evals = [(dtest_reg, "validation"), (dtrain_reg, "train")]


model = xgb.train(
   params=params,
   dtrain=dtrain_reg,
   num_boost_round=n,
   evals=evals,
   verbose_eval=250
)

[OUT]:

[0] train-rmse:3985.18329 validation-rmse:3930.52457
[500] train-rmse:195.89184 validation-rmse:555.90367
[1000] train-rmse:122.10746 validation-rmse:563.44888
[1500] train-rmse:84.18238 validation-rmse:567.16974
[2000] train-rmse:61.66682 validation-rmse:569.52584
[2500] train-rmse:46.34923 validation-rmse:571.07632
[3000] train-rmse:37.04591 validation-rmse:571.76912
[3500] train-rmse:29.43356 validation-rmse:572.43196
[4000] train-rmse:24.00607 validation-rmse:572.81287
[4500] train-rmse:20.45021 validation-rmse:572.89062
[4999] train-rmse:17.44305 validation-rmse:573.13200
संचालित द्वारा

हमें राउंड 500 से पहले ही सबसे कम लॉस मिल जाता है। उसके बाद, भले ही ट्रेनिंग लॉस नीचे जाता रहता है, लेकिन वैलिडेशन लॉस (जो हमारे लिए मायने रखता है) बढ़ता जाता है।

जब अनावश्यक रूप से अधिक बूस्टिंग राउंड्स दिए जाते हैं, तो XGBoost ओवरफिट होने लगता है और डेटासेट को याद करने लगता है। इससे वैलिडेशन परफॉर्मेंस गिरती है क्योंकि मॉडल जनरलाइज़ करने के बजाय याद करने लगता है।

याद रखें, हमें सुनहरा मध्य चाहिए: ऐसा मॉडल जिसने ट्रेनिंग में बस उतने पैटर्न सीखे हों कि वह वैलिडेशन सेट पर सर्वोच्च प्रदर्शन दे। तो फिर परफेक्ट बूस्टिंग राउंड्स की संख्या कैसे खोजें?

हम अर्ली स्टॉपिंग नामक तकनीक का उपयोग करेंगे। अर्ली स्टॉपिंग XGBoost को वैलिडेशन लॉस पर नज़र रखने के लिए मजबूर करता है, और यदि यह निर्दिष्ट राउंड्स की संख्या तक बेहतर नहीं होता, तो ट्रेनिंग अपने आप रुक जाती है।

इसका मतलब है कि जब तक हम अर्ली स्टॉपिंग राउंड्स की एक उचित संख्या सेट करते हैं, तब तक हम बूस्टिंग राउंड्स की संख्या अधिक रख सकते हैं।

उदाहरण के लिए, चलिए 10000 बूस्टिंग राउंड्स इस्तेमाल करते हैं और early_stopping_rounds पैरामीटर को 50 पर सेट करते हैं। इस तरह, यदि 50 लगातार राउंड्स तक वैलिडेशन लॉस में सुधार नहीं होता, तो XGBoost ट्रेनिंग अपने आप रोक देगा।

n = 10000


model = xgb.train(
   params=params,
   dtrain=dtrain_reg,
   num_boost_round=n,
   evals=evals,
   verbose_eval=50,
   # Activate early stopping
   early_stopping_rounds=50
)

[OUT]: 

[0] train-rmse:3985.18329 validation-rmse:3930.52457
[50] train-rmse:432.91655 validation-rmse:546.22557
[100] train-rmse:377.66173 validation-rmse:542.92457
[150] train-rmse:334.27548 validation-rmse:542.79733
[167] train-rmse:321.04059 validation-rmse:543.35679संचालित द्वारा

जैसा कि आप देख सकते हैं, 167वें राउंड के बाद ट्रेनिंग रुक गई क्योंकि उससे पहले 50 राउंड्स तक लॉस में सुधार नहीं हुआ।

XGBoost क्रॉस-वैलिडेशन

ट्यूटोरियल की शुरुआत में, हमने डेटासेट का 25% हिस्सा टेस्टिंग के लिए अलग रखा था। टेस्ट सेट हमें प्रोडक्शन में मॉडल की स्थितियों का सिमुलेशन करने देता है, जहाँ उसे अनदेखे डेटा के लिए प्रेडिक्शंस जनरेट करने होते हैं।

लेकिन केवल एक टेस्ट सेट प्रोडक्शन में मॉडल के प्रदर्शन को सटीकता से मापने के लिए पर्याप्त नहीं होगा। उदाहरण के लिए, यदि हम केवल एक ट्रेनिंग और एक टेस्ट सेट का उपयोग करके हाइपरपैरामीटर ट्यूनिंग करते हैं, तो टेस्ट सेट के बारे में कुछ जानकारी फिर भी “लीक” हो जाएगी। कैसे?

क्योंकि हम टेस्ट सेट पर मॉडल के वैलिडेशन परफॉर्मेंस की तुलना करके हाइपरपैरामीटर का सबसे अच्छा मान खोजने की कोशिश करते हैं, तो हम ऐसे मॉडल पर पहुँचेंगे जो केवल उसी विशेष टेस्ट सेट पर अच्छा प्रदर्शन करने के लिए कॉन्फ़िगर होगा। इसके बजाय, हमें ऐसा मॉडल चाहिए जो हर जगह अच्छा प्रदर्शन करे—किसी भी टेस्ट सेट पर जो हम उसे दें।

एक संभावित उपाय डेटा को तीन सेट्स में विभाजित करना है। मॉडल पहले सेट पर ट्रेन होता है, दूसरे सेट का उपयोग इवैल्युएशन और हाइपरपैरामीटर ट्यूनिंग के लिए होता है, और तीसरे पर प्रोडक्शन से पहले अंतिम टेस्ट होता है।

लेकिन जब डेटा सीमित हो, तो तीन सेट्स में बाँटने से ट्रेनिंग सेट छोटा हो जाता है, जिससे मॉडल का प्रदर्शन प्रभावित होता है।

इन सभी समस्याओं का समाधान क्रॉस-वैलिडेशन है। क्रॉस-वैलिडेशन में, हमारे पास अभी भी दो सेट होते हैं: ट्रेनिंग और टेस्टिंग।

जबकि टेस्ट सेट अलग रहता है, हम ट्रेनिंग सेट को 3, 5, 7, या k हिस्सों/फोल्ड्स में बाँटते हैं। फिर, हम मॉडल को k बार ट्रेन करते हैं। हर बार, हम k-1 हिस्सों को ट्रेनिंग के लिए और अंतिम kवें हिस्से को वैलिडेशन के लिए उपयोग करते हैं। इस प्रक्रिया को k-fold क्रॉस-वैलिडेशन कहा जाता है:

Source: https://scikit-learn.org/stable/modules/cross_validation.html

ऊपर 5-फोल्ड क्रॉस-वैलिडेशन का दृश्य चित्रण है। सभी फोल्ड्स पूरे होने के बाद, हम स्कोर का औसत लेकर मॉडल का अंतिम, सबसे यथार्थवादी प्रदर्शन पा सकते हैं।

आइए इस प्रक्रिया को XGB की cv फंक्शन का उपयोग करके कोड में करें:

params = {"objective": "reg:squarederror", "tree_method": "gpu_hist"}
n = 1000

results = xgb.cv(
   params, dtrain_reg,
   num_boost_round=n,
   nfold=5,
   early_stopping_rounds=20
)संचालित द्वारा

train फंक्शन से एकमात्र अंतर nfold पैरामीटर जोड़ना है, जिससे स्प्लिट्स की संख्या निर्दिष्ट होती है। results ऑब्जेक्ट अब प्रत्येक फोल्ड के परिणामों वाला एक DataFrame है:

results.head()संचालित द्वारा

इसमें बूस्टिंग राउंड्स की संख्या के बराबर पंक्तियाँ होती हैं। प्रत्येक पंक्ति उस राउंड के सभी स्प्लिट्स का औसत है। इसलिए, सर्वश्रेष्ठ स्कोर खोजने के लिए, हम test-rmse-mean कॉलम का न्यूनतम मान लेते हैं:

best_rmse = results['test-rmse-mean'].min()

best_rmse
550.8959336674216संचालित द्वारा

ध्यान दें कि क्रॉस-वैलिडेशन की यह विधि मॉडल के वास्तविक प्रदर्शन को देखने के लिए उपयोग की जाती है। एक बार इसके स्कोर से संतुष्ट होने पर, आपको डिप्लॉयमेंट से पहले इसे पूर्ण डेटा पर पुनः ट्रेन करना चाहिए।

XGBoost क्लासिफिकेशन

XGBoost क्लासिफायर बनाना उतना ही आसान है जितना कि ऑब्जेक्टिव फंक्शन बदलना; बाकी सब कुछ वैसा ही रह सकता है।

दो सबसे लोकप्रिय क्लासिफिकेशन ऑब्जेक्टिव्स हैं:

• binary:logistic - बाइनरी क्लासिफिकेशन (टारगेट में केवल दो क्लास होते हैं, जैसे बिल्ली या कुत्ता)
• multi:softprob - मल्टी-क्लास क्लासिफिकेशन (टारगेट में दो से अधिक क्लास, जैसे सेब/संतरा/केला)

XGBoost में बाइनरी और मल्टी-क्लास क्लासिफिकेशन करना लगभग एक जैसा है, इसलिए हम बाद वाले के साथ चलेंगे। पहले कार्य के लिए डेटा तैयार करते हैं।

हम कीमत और भौतिक मापों के आधार पर डायमंड की कट क्वालिटी की भविष्यवाणी करना चाहते हैं। इसलिए, हम फीचर/टारगेट एरेज़ उसी के अनुसार बनाएँगे:

from sklearn.preprocessing import OrdinalEncoder

X, y = diamonds.drop("cut", axis=1), diamonds[['cut']]

# Encode y to numeric
y_encoded = OrdinalEncoder().fit_transform(y)

# Extract text features
cats = X.select_dtypes(exclude=np.number).columns.tolist()

# Convert to pd.Categorical
for col in cats:
   X[col] = X[col].astype('category')

# Split the data
X_train, X_test, y_train, y_test = train_test_split(X, y_encoded, random_state=1, stratify=y_encoded)संचालित द्वारा

एकमात्र अंतर यह है कि XGBoost टारगेट में केवल संख्याएँ स्वीकार करता है, इसलिए हम Sklearn के OrdinalEncoder से टारगेट में टेक्स्ट क्लासेस को एनकोड कर रहे हैं।

अब, हम DMatrices बनाते हैं…

# Create classification matrices
dtrain_clf = xgb.DMatrix(X_train, y_train, enable_categorical=True)
dtest_clf = xgb.DMatrix(X_test, y_test, enable_categorical=True)संचालित द्वारा

…और ऑब्जेक्टिव को multi:softprob पर सेट करते हैं। इस ऑब्जेक्टिव में हमें क्लासेस की संख्या भी सेट करनी होती है:

params = {"objective": "multi:softprob", "tree_method": "gpu_hist", "num_class": 5}
n = 1000

results = xgb.cv(
   params, dtrain_clf,
   num_boost_round=n,
   nfold=5,
   metrics=["mlogloss", "auc", "merror"],
)संचालित द्वारा

क्रॉस-वैलिडेशन के दौरान, हम XGBoost से तीन क्लासिफिकेशन मेट्रिक्स पर नज़र रखने के लिए कह रहे हैं जो अलग-अलग दृष्टिकोणों से मॉडल का प्रदर्शन रिपोर्ट करते हैं। यहाँ परिणाम है:

results.keys()

Index(['train-mlogloss-mean', 'train-mlogloss-std', 'train-auc-mean',

      'train-auc-std', 'train-merror-mean', 'train-merror-std',

      'test-mlogloss-mean', 'test-mlogloss-std', 'test-auc-mean',

      'test-auc-std', 'test-merror-mean', 'test-merror-std'],

     dtype='object')संचालित द्वारा

सर्वश्रेष्ठ AUC स्कोर देखने के लिए, हम test-auc-mean कॉलम का अधिकतम मान लेते हैं:

>>> results['test-auc-mean'].max()
0.9402233623451636संचालित द्वारा

डिफ़ॉल्ट कॉन्फ़िगरेशन ने भी हमें 94% का प्रदर्शन दिया, जो शानदार है।

XGBoost नेटिव बनाम XGBoost Sklearn

अब तक हम नेटिव XGBoost API का उपयोग कर रहे थे, लेकिन इसका Sklearn API भी काफी लोकप्रिय है।

Sklearn एक विशाल फ्रेमवर्क है जिसमें कई मशीन लर्निंग एल्गोरिदम और यूटिलिटीज हैं, और इसका API सिंटैक्स लगभग सभी को पसंद है। इसलिए, XGBoost भी XGBClassifier और XGBRegressor क्लासेस प्रदान करता है ताकि वे Sklearn इकोसिस्टम में एकीकृत हो सकें (हालाँकि कुछ कार्यक्षमता की कीमत पर)।

यदि आप संभव हो तो केवल Scikit-learn API का उपयोग करना चाहते हैं और अतिरिक्त कार्यक्षमता की ज़रूरत पड़ने पर ही नेटिव पर स्विच करना चाहते हैं, तो इसका एक तरीका है।

XGBoost क्लासिफायर या रिग्रेसर को ट्रेन करने के बाद, आप इसे get_booster मेथड का उपयोग करके कन्वर्ट कर सकते हैं:

import xgboost as xgb

# Train a model using the scikit-learn API
xgb_classifier = xgb.XGBClassifier(n_estimators=100, objective='binary:logistic', tree_method='hist', eta=0.1, max_depth=3, enable_categorical=True)
xgb_classifier.fit(X_train, y_train)

# Convert the model to a native API model
model = xgb_classifier.get_booster()संचालित द्वारा

मॉडल ऑब्जेक्ट बिल्कुल उसी तरह व्यवहार करेगा जैसा हमने पूरे ट्यूटोरियल में देखा।

निष्कर्ष

हमने इस XGBoost ट्यूटोरियल में कई महत्वपूर्ण विषयों को कवर किया है, लेकिन सीखने के लिए अभी भी बहुत कुछ बाकी है।

आप XGBoost पैरामीटर्स पेज देख सकते हैं, जो सिखाता है कि अपने मॉडलों से अधिकतम प्रदर्शन निकालने के लिए पैरामीटर्स को कैसे कॉन्फ़िगर करें।

यदि आप लाइब्रेरी सीखने के लिए एक व्यापक, ऑल-इन-वन संसाधन ढूँढ रहे हैं, तो हमारा Extreme Gradient Boosting With XGBoost कोर्स देखें।