बूस्टिंग के लिए सापेक्ष चर महत्व

मैं इस बात की व्याख्या कर रहा हूं कि कैसे ग्रेडिएंट बूस्टेड पेड़ों में सापेक्ष परिवर्तनीय महत्व की गणना की जाती है जो सामान्य रूप से सामान्य / सरल नहीं है:

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

और इससे कम सार है:

$\hat{I_{j}^2}(T)=\sum\limits_{t=1}^{J-1} \hat{i_{t}^2} 1(v_{t}=j)$

जहाँ योग -mminal नोड ट्री नॉनटर्मिनल नोड्स के ऊपर है , नोड साथ जुड़े विभाजन , और स्क्वेयर एरर में समान रूप से सुधार है। विभाजन के परिणामस्वरूप, , जहां क्रमशः बाईं और दाईं बेटी प्रतिक्रिया का अर्थ है, और भार के संगत योग हैं। $t$ $J$ $T$ $v_{t}$ $t$ $\hat{i_{t}^2}$ $i^2(R_{l},R_{r})=\frac{w_{l}w_{r}}{w_{l}+w_{r}}(\bar{y_{l}}-\bar{y_{r}})^2$ $\bar{y_{l}}, \bar{y_{r}}$ $w_{l}, w_{r}$ [ फ्रीडमैन 2001, लालची समारोह सन्निकटन: एक ढाल बूस्टिंग मशीन ]

अंत में, मुझे सांख्यिकीय लर्निंग (हेस्टी एट अल। 2008) के तत्वों को यहां बहुत उपयोगी पढ़ने के लिए नहीं मिला, क्योंकि संबंधित खंड (10.13.1 पृष्ठ 367) ऊपर दिए गए दूसरे संदर्भ के समान है (जिसे समझाया जा सकता है) इस तथ्य से कि फ्राइडमैन पुस्तक के सह-लेखक हैं)।

पुनश्च: मैं जानता हूँ कि रिश्तेदार चर महत्व उपायों द्वारा दिया जाता है summary.gbm जीबीएम आर पैकेज में। मैंने स्रोत कोड का पता लगाने की कोशिश की, लेकिन मुझे पता नहीं चल पाया कि वास्तविक गणना कहां होती है।

ब्राउनी अंक: मैं सोच रहा हूं कि इन भूखंडों को आर में कैसे लाया जाए ।

— एंटोनी
स्रोत

मैंने अभी-अभी लिंक किए गए प्रश्न के बारे में एक नया उत्तर जोड़ा कि कैसे वर्ग महत्व चर को प्लॉट करने में मददगार हो सकता है जो कि stackoverflow.com/a/51952918/3277050

— 1724 पर '21

मैं स्केलेर कोड का उपयोग करूँगा , क्योंकि यह आमतौर पर Rकोड की तुलना में बहुत अधिक क्लीनर है ।

यहां ग्रेडिएंटबॉस्टिंगक्लासीफायर के फीचर_इम्पोर्टेंस प्रॉपर्टी का कार्यान्वयन (मैंने वैचारिक सामान के रास्ते में आने वाली कोड की कुछ पंक्तियों को हटा दिया)

def feature_importances_(self):
    total_sum = np.zeros((self.n_features, ), dtype=np.float64)
    for stage in self.estimators_:
        stage_sum = sum(tree.feature_importances_
                        for tree in stage) / len(stage)
        total_sum += stage_sum

    importances = total_sum / len(self.estimators_)
    return importances

यह समझना बहुत आसान है। self.estimators_बूस्टर में अलग-अलग पेड़ों से युक्त एक सरणी है, इसलिए लूप के लिए अलग-अलग पेड़ों पर चलना है। वहाँ के साथ एक hickup है

stage_sum = sum(tree.feature_importances_
                for tree in stage) / len(stage)

यह गैर-द्विआधारी प्रतिक्रिया मामले का ध्यान रख रहा है। यहां हम एक-बनाम-सभी तरीके से प्रत्येक चरण में कई पेड़ों को फिट करते हैं। बाइनरी केस पर ध्यान केंद्रित करने के लिए इसकी सबसे सरल अवधारणा है, जहां योग का एक सारांश है, और यह बस है tree.feature_importances_। तो बाइनरी केस में, हम यह सब फिर से लिख सकते हैं

def feature_importances_(self):
    total_sum = np.zeros((self.n_features, ), dtype=np.float64)
    for tree in self.estimators_:
        total_sum += tree.feature_importances_ 
    importances = total_sum / len(self.estimators_)
    return importances

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

एक पेड़ की महत्वपूर्ण गणना को साइथन स्तर पर लागू किया गया है , लेकिन यह अभी भी अनुसरण करने योग्य है। यहाँ कोड का एक साफ किया गया संस्करण है

cpdef compute_feature_importances(self, normalize=True):
    """Computes the importance of each feature (aka variable)."""

    while node != end_node:
        if node.left_child != _TREE_LEAF:
            # ... and node.right_child != _TREE_LEAF:
            left = &nodes[node.left_child]
            right = &nodes[node.right_child]

            importance_data[node.feature] += (
                node.weighted_n_node_samples * node.impurity -
                left.weighted_n_node_samples * left.impurity -
                right.weighted_n_node_samples * right.impurity)
        node += 1

    importances /= nodes[0].weighted_n_node_samples

    return importances

यह बहुत आसान है। पेड़ के नोड्स के माध्यम से Iterate। जब तक आप एक पत्ती नोड पर नहीं होते हैं, तब तक इस नोड पर विभाजन से नोड शुद्धता में भारित कमी की गणना करें, और इसे उस विशेषता के लिए विशेषता दें जिस पर विभाजित किया गया था

importance_data[node.feature] += (
    node.weighted_n_node_samples * node.impurity -
    left.weighted_n_node_samples * left.impurity -
    right.weighted_n_node_samples * right.impurity)

फिर, जब किया जाता है, तो इसे डेटा के कुल वजन से विभाजित करें (ज्यादातर मामलों में, टिप्पणियों की संख्या)

importances /= nodes[0].weighted_n_node_samples

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

ग्रेडिएंट बूस्टिंग के संदर्भ में, ये पेड़ हमेशा रिग्रेशन ट्री होते हैं (स्क्वैयर एरर को लालच से कम करके) नुकसान फंक्शन के ग्रेडिएंट में फिट होते हैं।

— मैथ्यू ड्र्यू
स्रोत

इस बहुत विस्तृत जवाब के लिए बहुत बहुत धन्यवाद। मुझे स्वीकार करने से पहले मुझे कुछ समय सावधानी से गुजरने दें।

— एंटोनी

जबकि ऐसा लगता है कि विभिन्न अशुद्धता मानदंडों का उपयोग किया जा सकता है, गिनी सूचकांक फ्राइडमैन द्वारा उपयोग की जाने वाली कसौटी नहीं थी। जैसा कि मेरे प्रश्न और आपके तीसरे लिंक की लाइन 878 में उल्लेख किया गया है , फ्रीडमैन ने सुधार स्कोर के साथ माध्य चुकता त्रुटि अशुद्धता मानदंड का उपयोग किया । यदि आप अपने उत्तर के इस खंड को अपडेट कर सकते हैं, तो यह बहुत अच्छा होगा। और हाँ, आप सही हैं, ऐसा लगता है कि वजन वास्तव में टिप्पणियों की संख्या है।

— एंटोनी

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

— एंटोनी

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

— काफी समय बाद Nerdy

आप लोग प्रतिगमन पेड़ों के बारे में सही हैं।

— मैथ्यू ड्र्यू