ग्रेडिएंट बूस्टिंग के लिए अनुमानकों की संख्या कैसे चुनें

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

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

ग्रेडिएंट बूस्टिंग अनुमानक बनाते समय, आपको यह हाइपरपैरामीटर मिलेगा n_estimator=100 परिणाम प्राप्त करने के लिए 100 पेड़ों का डिफ़ॉल्ट मान बनाया जाना है। कई बार, हम इसे केवल डिफ़ॉल्ट पर सेट करते हैं या आवश्यकतानुसार बढ़ा सकते हैं, यहां तक ​​कि ग्रिड खोज तकनीकों का उपयोग करके भी।

इस पोस्ट में, हम अपने मॉडल को प्रशिक्षित करने के लिए एकल नंबर तक पहुंचने का एक आसान तरीका ढूंढेंगे।

इस क्लास का उपयोग करके ग्रेडिएंट बूस्टिंग को स्किकिट-लर्न से लोड किया जा सकता है from sklearn.ensemble import GradientBoostingRegressor. ग्रेडिएंट बूस्टिंग एल्गोरिदम का उपयोग या तो वर्गीकरण के लिए या रिग्रेशन मॉडल के लिए किया जा सकता है। यह एक वृक्ष आधारित अनुमानक है - जिसका अर्थ है कि यह कई निर्णय वृक्षों से बना है।

का परिणाम है पेड़ 1 त्रुटियाँ उत्पन्न करेगा. उन त्रुटियों का उपयोग किया जाएगा और इनपुट के लिए पेड़ 2. एक बार फिर, पिछले मॉडल की त्रुटियों का उपयोग किया जाएगा और अगले के इनपुट तक, जब तक यह नहीं पहुंच जाता n_estimators मूल्य.

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

आइए देखें कि अब यह कैसे करना है।

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

आइए एक डेटासेट चुनकर शुरुआत करें। हम उपयोग करेंगे कार दुर्घटनाएं डेटासेट, सीबॉर्न लाइब्रेरी का मूल निवासी (इसलिए बीडीएस लाइसेंस के तहत एक खुला डेटा)।

# डेटासेट
डीएफ = एसएनएस.लोड_डेटासेट('कार_क्रैश')

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

सहसंबंधों को शीघ्रता से देखना।

#सहसंबंध
df.corr().style.background_gradient(cmap='coolwarm')

ठीक है, कोई बड़ी बहुसंरेखता नहीं। हम देख सकते हैं कि ins_premium और ins_losses के साथ बहुत अच्छी तरह से सहसंबद्ध नहीं है total , इसलिए हम उन पर मॉडल में विचार नहीं करेंगे।

यदि हम गायब डेटा की जाँच करें, तो कोई भी नहीं है

# गुम
df.isnull ()। योग ()
0

बढ़िया, तो चलिए अब डेटा को विभाजित करते हैं।

# एक्स और वाई
X = df.drop(['ins_premium', 'ins_losses', 'abbrev', 'total'], axis=1)
y = df['कुल']# ट्रेन परीक्षण
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, रैंडम_स्टेट=22)

हम डेटा को स्केल करने और उसे मॉडल करने के लिए एक पाइपलाइन बना सकते हैं (इस डेटा को स्केल करना वास्तव में बहुत आवश्यक नहीं है, क्योंकि वे पहले से ही दहाई के आधार पर एक ही पैमाने पर हैं). इसके बाद, हम डेटा को मॉडल में फिट करते हैं और परिणामों की भविष्यवाणी करते हैं।

मैं 500 अनुमानकों का उपयोग कर रहा हूं learning_rate 0.3 की.

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

चरण = [('स्केल', स्टैंडर्डस्केलर()),
('GBR', GradientBoostingRegressor(n_estimator=500, learn_rate=0.03)) ]# उदाहरण पाइपलाइन और फिट
पाइप = पाइपलाइन(चरण).फिट(X_train, y_train)# भविष्यवाणी करना
प्रीड्स = पाइप.भविष्यवाणी(X_test)

अब, मूल्यांकन कर रहे हैं.

#भविष्यवाणियों का आरएमएसई
प्रिंट(f'RMSE: { राउंड(np.sqrt(mean_squared_error(y_test, preds)),1 )}')[आउट]: आरएमएसई: 1.1# वास्तविक Y मानों का माध्य
प्रिंट(f'डेटा y मतलब: {राउंड( y.mean(),1 )}')[बाहर]: डेटा y का अर्थ है: 15.8

अच्छा। हमारा आरएमएसई माध्य का लगभग 6.9% है। तो हम औसतन इतने से पीछे हैं।

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

जैसा कि मैंने कहा, हमें वास्तव में इस डेटा को स्केल करने की ज़रूरत नहीं है क्योंकि यह पहले से ही उसी अनुपात में है। तो आइए मॉडल को फिट करें।

#आदर्श
gbr = GradientBoostingRegressor(n_estimator=500, learn_rate=0.3).fit(X_train, y_train)

अब यह अच्छी चीज़ है. ग्रेडिएंट बूस्टिंग में एक विधि है जो हमें 1 से 500 तक प्रशिक्षित प्रत्येक अनुमानक की भविष्यवाणियों को दोहराने की अनुमति देती है। इसलिए, हम एक लूप बनाएंगे जो 500 अनुमानकों से होकर गुजरता है gbr मॉडल, विधि का उपयोग करके परिणामों की भविष्यवाणी करता है staged_predict(), माध्य वर्ग त्रुटि की गणना करता है और परिणाम को सूची में संग्रहीत करता है errors.

# सर्वोत्तम संख्या के लिए लूप करें
त्रुटियाँ = [gbr.stged_predict(X_test) में पूर्वानुमेय के लिए माध्य_वर्ग_त्रुटि(y_test, preds)]# अनुमानकर्ताओं की इष्टतम संख्या
इष्टतम_नम_अनुमानक = np.argmin(त्रुटियाँ) + 1

इसके बाद, हम परिणाम की योजना बना सकते हैं।

#कथानक
g=sns.lineplot(x=रेंज(500), y=त्रुटियाँ)
g.set_title(f'{best_n_estimator} पर अनुमानकर्ताओं की सर्वोत्तम संख्या', आकार=15);

हम देखते हैं कि सबसे कम त्रुटि दर 34 अनुमानकों के साथ है। तो, आइए अपने मॉडल को 34 अनुमानकों के साथ फिर से प्रशिक्षित करें और पाइपलाइन के साथ प्रशिक्षित मॉडल के परिणाम से तुलना करें।

# फिर से प्रशिक्षित करें
gbr = GradientBoostingRegressor(n_estimator=34, learn_rate=0.3).fit(X_train, y_train)#भविष्यवाणियाँ
preds2 = gbr.predict(X_test)

मूल्यांकन कर रहा है...

#भविष्यवाणियों का आरएमएसई
प्रिंट(f'RMSE: { राउंड(np.sqrt(mean_squared_error(y_test, preds2)),1 )}')
[आउट]: आरएमएसई: 1.0# डेटा Y का मतलब है
प्रिंट(f'डेटा y मतलब: {राउंड( y.mean(),1 )}')[बाहर]: डेटा y का अर्थ है: 15.8

हम अब 6.9% से घटकर 6.3% छूट पर आ गए हैं। लगभग। 9% बेहतर. आइए कुछ भविष्यवाणियों पर नजर डालें।

दिलचस्प परिणाम. दूसरे मॉडल की कुछ भविष्यवाणियाँ पहले वाले से बेहतर हैं।

हमने सीखा कि ए को संशोधित करने के लिए अनुमानकों की सर्वोत्तम संख्या कैसे निर्धारित की जाए GradientBoostingRegressor स्किकिट-लर्न से। यह एक हाइपरपैरामीटर है जो इस तरह के पहनावा मॉडल में अंतर ला सकता है, जो अनुमानकों को क्रम में प्रशिक्षित करता है।

कभी-कभी, कुछ पुनरावृत्तियों के बाद, मॉडल ओवरफिट होना शुरू हो सकता है, इस प्रकार यह भिन्नता को बहुत अधिक बढ़ाना शुरू कर देगा, जिससे भविष्यवाणियां प्रभावित होंगी।

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

यहाँ है GitHub में पूरा कोड.

अगर आपको यह सामग्री पसंद आई तो मेरे ब्लॉग का अनुसरण करें।

मुझे खोजें लिंक्डइन.

यह अभ्यास संदर्भ में ऑरेलीन गेरोन की उत्कृष्ट पाठ्य पुस्तक पर आधारित था।

ग्रेडिएंट बूस्टिंग के लिए अनुमानकों की संख्या कैसे चुनें स्रोत से पुनर्प्रकाशित https://towardsdatascience.com/how-to-choose-the-number-of-estimator-for-gradient-boosting-8d06920ab891?source=rss—-7f60cf5620c9— 4 https://towardsdatascience.com/feed के माध्यम से

<!–

->