Bootstrap Aggregation (Bagging) की व्याख्या
शिक्षार्थी हाथ से bootstrap नमूना तैयार करेंगे, प्रत्येक नमूने पर वर्गीकार प्रशिक्षित करेंगे और समझेंगे कि विविध मॉडलों का औसत विचरण को क्यों घटाता है।
Bootstrap Aggregation (Bagging) की व्याख्या, CoddyKit पर Machine Learning Academy का एक निःशुल्क पाठ है। यह 4 में से 1वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Machine Learning Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Machine Learning Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
बूटस्ट्रैप एग्रीगेशन क्या है?
बूटस्ट्रैप एग्रीगेशन, जिसे आमतौर पर Bagging कहा जाता है, एक एन्सेम्बल तकनीक है जो प्रशिक्षण डेटा के अलग-अलग यादृच्छिक उपसमुच्चयों पर कई मॉडल प्रशिक्षित करती है और उनके अनुमानों को जोड़ती है। बूटस्ट्रैप शब्द सांख्यिकी से आया है और इसका अर्थ है आपके डेटा से पुनर्स्थापन के साथ नमूना लेना। कई विविध मॉडलों के परिणामों का औसत या मतदान करके, बैगिंग पक्षपात बढ़ाए बिना अंतिम अनुमान के विचरण को काफी कम कर देती है।
पुनर्स्थापन के साथ नमूना लेना समझें
पुनर्स्थापन के साथ नमूना लेने का अर्थ है कि प्रत्येक बूटस्ट्रैप नमूना पूरे डेटासेट से स्वतंत्र रूप से चुना जाता है — एक ही पंक्ति एक नमूने में कई बार आ सकती है, जबकि अन्य पंक्तियाँ पूरी तरह बाहर रह सकती हैं। N उदाहरणों वाले डेटासेट के लिए, प्रत्येक बूटस्ट्रैप नमूने में भी N पंक्तियाँ होती हैं। औसतन, किसी भी बूटस्ट्रैप नमूने में लगभग 63.2% अद्वितीय उदाहरण दिखाई देते हैं, और शेष लगभग 37% उदाहरण आउट-ऑफ-बैग समुच्चय बनाते हैं, जिनका उपयोग सत्यापन के लिए किया जा सकता है।
import numpy as np
np.random.seed(42)
data = np.arange(10) # [0, 1, 2, ..., 9]
bootstrap_sample = np.random.choice(data, size=len(data), replace=True)
print('Original:', data)
print('Bootstrap sample:', bootstrap_sample)विविधता विचरण को क्यों कम करती है
मान लीजिए कि आपके पास n स्वतंत्र मॉडल हैं और प्रत्येक का विचरण σ² है। यदि आप उनके अनुमानों का औसत निकालते हैं, तो औसत का विचरण σ²/n होगा — अधिक मॉडल जोड़ने पर यह घटता जाता है। व्यवहार में, बूटस्ट्रैप नमूनों पर प्रशिक्षित मॉडल सहसंबद्ध होते हैं (वे एक ही प्रशिक्षण वितरण साझा करते हैं), इसलिए कमी आंशिक होती है, फिर भी महत्वपूर्ण रहती है। मुख्य बात यह है कि औसत निकालने से पक्षपात बढ़ाए बिना विचरण कम होता है, जिससे सामान्यीकरण बेहतर होता है।
हाथ से Bagging लागू करना
आप अनुमानकों की एक सूची बनाकर बैगिंग को मैन्युअल रूप से लागू कर सकते हैं। हर अनुमानक को अलग बूटस्ट्रैप नमूने पर प्रशिक्षित करें और फिर उनके आउटपुट का औसत निकालें। इससे ठीक-ठीक पता चलता है कि BaggingClassifier पर्दे के पीछे क्या करता है। मैन्युअल संस्करण को समझने से समस्याओं का निदान करना और इस तकनीक को कस्टम मॉडलों तक विस्तारित करना आसान हो जाता है।
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
import numpy as np
X, y = load_iris(return_X_y=True)
n_estimators = 10
models = []
for _ in range(n_estimators):
idx = np.random.choice(len(X), size=len(X), replace=True)
X_boot, y_boot = X[idx], y[idx]
tree = DecisionTreeClassifier()
tree.fit(X_boot, y_boot)
models.append(tree)
# Predict by majority vote
predictions = np.array([m.predict(X) for m in models])
ensemble_pred = [np.bincount(col).argmax() for col in predictions.T]
print('Ensemble accuracy:', np.mean(ensemble_pred == y))scikit-learn BaggingClassifier
scikit-learn ऐसा BaggingClassifier प्रदान करता है जो किसी भी आधार अनुमानक को अपने भीतर समाहित करता है और बूटस्ट्रैप नमूना लेने तथा एकत्रीकरण को स्वचालित करता है। आप n_estimators (मॉडलों की संख्या), max_samples (प्रति मॉडल प्रशिक्षण नमूनों का अंश या पूर्ण संख्या) और max_features (उपयोग की जाने वाली विशेषताओं की संख्या) नियंत्रित कर सकते हैं। oob_score=True सेट करने पर प्रत्येक अनुमानक के आउट-ऑफ-बैग उदाहरणों का उपयोग करके बिना अतिरिक्त लागत के सत्यापन स्कोर निकाला जाता है।
from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
bag = BaggingClassifier(
estimator=DecisionTreeClassifier(),
n_estimators=100,
oob_score=True,
random_state=42
)
bag.fit(X_train, y_train)
print('OOB score:', bag.oob_score_)
print('Test accuracy:', bag.score(X_test, y_test))प्रतिगमन के लिए Bagging
बैगिंग केवल वर्गीकरण तक सीमित नहीं है। BaggingRegressor इसी विचार को लागू करता है: बूटस्ट्रैप नमूनों पर कई प्रतिगमन मॉडल प्रशिक्षित करें और उनके संख्यात्मक अनुमानों का औसत निकालें। यह विशेष रूप से तब उपयोगी होता है जब आधार शिक्षार्थी उच्च-विचरण वाला मॉडल हो, जैसे बिना छँटे हुए निर्णय-वृक्ष। एक अकेला वृक्ष शोर को याद कर लेता है; कई वृक्षों का औसत उस शोर को समतल कर देता है और कुल परीक्षण RMSE को काफी कम करता है।
from sklearn.ensemble import BaggingRegressor
from sklearn.tree import DecisionTreeRegressor
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import cross_val_score
import numpy as np
X, y = fetch_california_housing(return_X_y=True)
single_tree = DecisionTreeRegressor(random_state=42)
bag_reg = BaggingRegressor(estimator=DecisionTreeRegressor(), n_estimators=100, random_state=42)
single_rmse = np.sqrt(-cross_val_score(single_tree, X, y, scoring='neg_mean_squared_error', cv=3).mean())
bag_rmse = np.sqrt(-cross_val_score(bag_reg, X, y, scoring='neg_mean_squared_error', cv=3).mean())
print(f'Single tree RMSE: {single_rmse:.4f}')
print(f'Bagged tree RMSE: {bag_rmse:.4f}')आउट-ऑफ-बैग अंश
चूँकि लगभग 37% प्रशिक्षण उदाहरण प्रत्येक बूटस्ट्रैप नमूने से बाहर रह जाते हैं, इसलिए किसी अतिरिक्त डेटा-विभाजन के बिना उन उदाहरणों को संबंधित अनुमानक के लिए सत्यापन समुच्चय के रूप में उपयोग किया जा सकता है। OOB स्कोर की गणना प्रत्येक प्रशिक्षण बिंदु का अनुमान केवल उन अनुमानकों से लगाकर की जाती है, जिन्होंने प्रशिक्षण के दौरान उस बिंदु को नहीं देखा था। इससे सामान्यीकरण प्रदर्शन का लगभग निष्पक्ष अनुमान मिलता है, जो लीव-वन-आउट क्रॉस-वैलिडेशन के समान है, लेकिन इसकी गणना बहुत कम लागत में होती है।
प्रदर्शन पर n_estimators का प्रभाव
बैगिंग एन्सेम्बल में अधिक एस्टिमेटर जोड़ने से लगभग हमेशा परीक्षण प्रदर्शन बेहतर होता है (या अधिक-से-अधिक उसमें कोई गिरावट नहीं आती)। न्यूरल नेटवर्क की गहराई के विपरीत, अधिक ट्री जोड़ने पर ओवरफिटिंग का कोई दंड नहीं लगता — बायस स्थिर रहता है, जबकि वेरिएंस घटता रहता है। व्यवहार में, कुछ सौ एस्टिमेटर के बाद प्रदर्शन एक स्तर पर स्थिर हो जाता है। मुख्य समझौता गणना समय का है: n_estimators को दोगुना करने पर प्रशिक्षण समय भी दोगुना हो जाता है। हमेशा जाँचें कि अतिरिक्त लागत के बदले मिलने वाला सीमांत लाभ उचित है या नहीं।
from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import cross_val_score
import numpy as np
X, y = load_breast_cancer(return_X_y=True)
for n in [1, 10, 50, 200]:
bag = BaggingClassifier(estimator=DecisionTreeClassifier(), n_estimators=n, random_state=42)
score = cross_val_score(bag, X, y, cv=5).mean()
print(f'n_estimators={n:4d}: CV accuracy={score:.4f}')बैगिंग बनाम एकल जटिल मॉडल
एकल जटिल मॉडल (गहरी ट्री, उच्च-डिग्री बहुपद) कम बायस लेकिन अधिक वेरिएंस प्राप्त करता है — यह प्रशिक्षण डेटा पर अच्छी तरह फिट होता है, लेकिन अनदेखे डेटा पर बहुत अधिक बदलता रहता है। बैगिंग ऐसे कई मॉडलों के परिणामों का औसत लेकर उस वेरिएंस को नियंत्रित करती है। संयुक्त पूर्वानुमान कहीं अधिक स्थिर होता है। इसी कारण बैगिंग तब सबसे अच्छा काम करती है, जब आधार लर्नर में अधिक वेरिएंस और कम बायस हो। पहले से ही अंडरफिट हो रहे सरल मॉडल (जैसे रैखिक प्रतिगमन) पर बैगिंग लागू करने से बहुत कम लाभ मिलता है, क्योंकि उसका वेरिएंस पहले ही कम था।
समांतरता: बैगिंग स्वाभाविक रूप से समांतर है
बैगिंग एन्सेम्बल में प्रत्येक एस्टिमेटर को स्वतंत्र रूप से प्रशिक्षित किया जाता है और उनके बीच डेटा-निर्भरताएँ नहीं होतीं। इसलिए बैगिंग स्वाभाविक रूप से समांतर है — सभी एस्टिमेटर को कई CPU कोर पर एक साथ प्रशिक्षित किया जा सकता है। scikit-learn इसे n_jobs=-1 पैरामीटर के माध्यम से उपलब्ध कराता है, जो सभी उपलब्ध कोर का उपयोग करता है। यह XGBoost जैसी बूस्टिंग विधियों से बिल्कुल अलग है, जहाँ प्रत्येक मॉडल पिछले मॉडल पर निर्भर करता है और प्रशिक्षण मूलतः क्रमिक होता है।
from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_breast_cancer
import time
X, y = load_breast_cancer(return_X_y=True)
bag_serial = BaggingClassifier(n_estimators=200, n_jobs=1, random_state=42)
bag_parallel = BaggingClassifier(n_estimators=200, n_jobs=-1, random_state=42)
start = time.time(); bag_serial.fit(X, y); print('Serial:', round(time.time()-start, 2), 's')
start = time.time(); bag_parallel.fit(X, y); print('Parallel:', round(time.time()-start, 2), 's')सीमाएँ और वे स्थितियाँ जब बैगिंग विफल होती है
बैगिंग की कुछ महत्वपूर्ण सीमाएँ हैं। पहली, एस्टिमेटर की संख्या के साथ गणना और मेमोरी का उपयोग रैखिक रूप से बढ़ता है। दूसरी, यह बायस में कोई सुधार नहीं करती — यदि आपका आधार मॉडल बहुत सरल है, तो कई सरल मॉडलों की बैगिंग से बना एन्सेम्बल भी सरल ही रहेगा। तीसरी, बैगिंग मॉडल को समझना कठिन बनाती है — आपके पास वह एकल निर्णय ट्री नहीं रहती, जिसे आप किसी हितधारक को दिखा सकें। अंत में, यदि प्रत्येक विभाजन पर सभी फीचर का उपयोग किया जाए, तो केवल बैगिंग ट्री के बीच सहसंबंध कम नहीं करती। यहीं रैंडम फ़ॉरेस्ट फीचर के उप-नमूने लेने की अतिरिक्त तरकीब जोड़ता है।
त्वरित जाँच
इस पाठ में बताए गए बूटस्ट्रैप एग्रीगेशन के सिद्धांतों की अपनी समझ जाँचें।
पाठ का पुनरावलोकन
इस पाठ में आपने सीखा: बूटस्ट्रैप एग्रीगेशन प्रतिस्थापन सहित यादृच्छिक पुनः-नमूनों पर कई मॉडल प्रशिक्षित करता है, पूर्वानुमानों का औसत लेने से बायस बढ़ाए बिना वेरिएंस घटता है, और आउट-ऑफ़-बैग उदाहरण प्रत्येक एस्टिमेटर के लिए निःशुल्क सत्यापन उपलब्ध कराते हैं। अगले पाठ में हम ट्री के बीच सहसंबंध को और कम करने के लिए रैंडम फ़ॉरेस्ट की फीचर उप-नमूना तकनीक देखेंगे।
एआई शिक्षक के साथ Python सीखें — निःशुल्क
अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।
- पाठ्यक्रम
- 30
- पाठ
- 120
अक्सर पूछे जाने वाले प्रश्न
क्या “Bootstrap Aggregation (Bagging) की व्याख्या” पाठ निःशुल्क है?
हाँ—“Bootstrap Aggregation (Bagging) की व्याख्या” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Machine Learning Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Machine Learning Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
“Bootstrap Aggregation (Bagging) की व्याख्या” में मैं क्या सीखूँगा?
शिक्षार्थी हाथ से bootstrap नमूना तैयार करेंगे, प्रत्येक नमूने पर वर्गीकार प्रशिक्षित करेंगे और समझेंगे कि विविध मॉडलों का औसत विचरण को क्यों घटाता है। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Machine Learning Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।
क्या Machine Learning Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?
पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Machine Learning Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 1वाँ पाठ है।
“Bootstrap Aggregation (Bagging) की व्याख्या” पाठ पूरा करने में कितना समय लगता है?
CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।
क्या मैं इस Machine Learning Academy पाठ में कोड लिख और चला सकता हूँ?
हाँ। हर Machine Learning Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।
इस पाठ्यक्रम के सभी पाठ
- Bootstrap Aggregation (Bagging) की व्याख्या
- यादृच्छिक फ़ीचर चयन: Random Forest की युक्ति
- Out-of-Bag त्रुटि: फ़ॉरेस्ट के भीतर निःशुल्क सत्यापन
- Voting Ensemble: Hard Vote बनाम Soft Vote