RandomForestClassifier में फ़ीचर_इमपोर्ट कैसे निर्धारित किए जाते हैं?


125

मेरे पास डेटा इनपुट के रूप में समय-श्रृंखला के साथ एक वर्गीकरण कार्य है, जहां प्रत्येक विशेषता (n = 23) समय में एक विशिष्ट बिंदु का प्रतिनिधित्व करती है। पूर्ण वर्गीकरण परिणाम के अलावा, मैं यह पता लगाना चाहूंगा कि कौन सी विशेषताएँ / तिथियां परिणाम में किस सीमा तक योगदान करती हैं। इसलिए मैं सिर्फ इसका उपयोग कर रहा हूं feature_importances_, जो मेरे लिए अच्छा है।

हालांकि, मैं जानना चाहूंगा कि उनकी गणना कैसे की जा रही है और कौन से माप / एल्गोरिदम का उपयोग किया जाता है। दुर्भाग्य से मुझे इस विषय पर कोई दस्तावेज नहीं मिला।


10
वाह तीन कोर देव एक एसओ धागे में। यह किसी तरह का रिकॉर्ड होगा ^ ^
एंड्रियास म्यूएलर

जवाबों:


158

वास्तव में सुविधा "आयात" प्राप्त करने के कई तरीके हैं। जैसा कि अक्सर होता है, इस शब्द का क्या अर्थ है, इस बारे में कोई सख्त सहमति नहीं है।

स्किटिट-लर्न में, हम महत्व को लागू करते हैं जैसा कि [1] में वर्णित है (अक्सर उद्धृत किया जाता है, लेकिन दुर्भाग्य से शायद ही कभी पढ़ा जाता है ...)। इसे कभी-कभी "गिनी महत्व" या "मतलब घटती अशुद्धता" कहा जाता है और इसे नोड अशुद्धता में कुल कमी के रूप में परिभाषित किया जाता है (उस नोड तक पहुंचने की संभावना से भारित (जो उस नोड तक पहुंचने वाले नमूनों के अनुपात से अनुमानित है) पहनावे के पेड़।

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

(ध्यान दें कि दोनों एल्गोरिदम बेतरतीब आर पैकेज में उपलब्ध हैं।)

[१]: ब्रीमन, फ्रीडमैन, "वर्गीकरण और प्रतिगमन पेड़", १ ९ iman४।


48
यह बहुत अच्छा हो सकता है अगर इस जवाब को महत्वपूर्ण विशेषताओं / उदाहरण के प्रलेखन में उल्लेख किया गया था। कुछ समय के लिए इसे
खोजा गया

2
ऐसा लगता है कि महत्व स्कोर सापेक्ष मूल्य में है? उदाहरण के लिए, सभी विशेषताओं के महत्त्वपूर्ण अंकों का योग हमेशा 1 होता है (उदाहरण यहाँ देखें scikit-learn.org/stable/auto_examples/ensemble/… )
RNA

5
@RNA: हां, डिफ़ॉल्ट रूप से चर आयात को सामान्य रूप से स्किकिट-लर्न में सामान्यीकृत किया जाता है, जैसे कि वे किसी एक को देते हैं। आप इसे अलग-अलग आधार अनुमानकों और कॉलिंग पर पा सकते हैं tree_.compute_feature_importances(normalize=False)
गाइल्स लूप्पे

2
@GillesLouppe क्या आप प्रत्येक पेड़ में निर्णय पेड़ के रजिस्टरों के जंगल के लिए MSE में कमी को मापने के लिए बैग के नमूनों का उपयोग करते हैं? या पेड़ पर इस्तेमाल किए गए सभी प्रशिक्षण डेटा?
कोक

1
दो उपयोगी संसाधन। (1) blog.datadive.net/… Ando Saabas द्वारा एक ब्लॉग दोनों का मतलब "अशुद्धता कम करना" है और गिल्स द्वारा बताई गई "सटीकता में कमी" भी है। (२) गाइल्स लूपे की थीसिस को डाउनलोड करें और पढ़ें।
मार्क तीज

54

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

  1. आप feature_importancesआकार के साथ सभी शून्य की एक सरणी को इनिशियलाइज़ करते हैं n_features

  2. आप पेड़ को पार करते हैं: प्रत्येक आंतरिक नोड के लिए जो सुविधा पर विभाजित होता है, iआप उस नोड की त्रुटि में कमी की गणना करते हैं जो नोड में रूट किए गए नमूनों की संख्या से गुणा करते हैं और इस मात्रा को जोड़ते हैं feature_importances[i]

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

यह महत्वपूर्ण है कि ये मान एक विशिष्ट डेटासेट (त्रुटि में कमी और नमूने की संख्या दोनों विशिष्ट हैं) के सापेक्ष हैं इस प्रकार इन मूल्यों की तुलना विभिन्न डेटासेट के बीच नहीं की जा सकती है।

जहाँ तक मुझे पता है कि निर्णय पेड़ों में फीचर महत्व मूल्यों की गणना करने के लिए वैकल्पिक तरीके हैं। उपरोक्त विधि का संक्षिप्त विवरण ट्रेवर हस्ती, रॉबर्ट टिब्शिरानी और जेरोम फ्रीडमैन द्वारा "एलिमेंट ऑफ़ स्टैटिस्टिकल लर्निंग" में पाया जा सकता है।


12

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

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

संपादित करें : यह विवरण केवल आंशिक रूप से सही है: गिल्स और पीटर के उत्तर सही उत्तर हैं।


1
क्या आपको पता है कि सटीक विधि के बारे में कुछ कागज / दस्तावेज हैं? जैसे। ब्रेइमन, 2001. यह बहुत अच्छा होगा यदि मेरे पास कुछ उचित दस्तावेज हैं, जो मैं कार्यप्रणाली के लिए उद्धृत कर सकता हूं।
user2244670

@ वोग्रेसल यह बहुत अच्छा होगा यदि आप "वेटिंग" के स्पष्टीकरण के रूप में स्पष्ट रूप से अपनी प्रतिक्रिया को चिह्नित कर सकते हैं। अकेले वेटिंग सुविधा के महत्व को निर्धारित नहीं करता है। "अशुद्धता मेट्रिक" ("गिन्नी-महत्व" या RSS) वज़न के साथ संयुक्त, पेड़ों पर औसतन समग्र विशेषता महत्व निर्धारित करता है। दुर्भाग्यवश, scikit-learn पर यहाँ प्रलेखन: scikit-learn.org/stable/modules/… अशुद्धता मीट्रिक के रूप में सही और गलत तरीके से "गहराई" का उल्लेख नहीं है।
एरियल

11

जैसा कि @GillesLouppe ने ऊपर बताया, वर्तमान में स्किकिट-लर्न वर्तमान में फीचर इंपोर्टेंस के लिए "औसत कमी अशुद्धता" मीट्रिक को लागू करता है। मैं व्यक्तिगत रूप से दूसरे मीट्रिक को थोड़ा और दिलचस्प लगता हूं, जहां आप अपनी प्रत्येक सुविधाओं के मूल्यों को एक-एक करके यादृच्छिक रूप से अनुमति देते हैं और देखते हैं कि आपका आउट-ऑफ-बैग प्रदर्शन कितना खराब है।

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

यदि आप रुचि रखते हैं, तो मैंने एक छोटा पैकेज लिखा है जो क्रमपरिवर्तन महत्व मीट्रिक को लागू करता है और इसका उपयोग स्किकिट-रैंडम फॉरेस्ट क्लास के उदाहरण से मूल्यों की गणना करने के लिए किया जा सकता है:

https://github.com/pjh2011/rf_perm_feat_import

संपादित करें: यह पायथन 2.7 के लिए काम करता है, 3 नहीं


हाय @Peter जब मैं आपके कोड का उपयोग करता हूं तो मुझे यह त्रुटि मिलती है: NameError: नाम 'xrange' परिभाषित नहीं है।
०६:५० बजे ६६:

हाय @ अजरक। क्षमा करें, मैं पैकेज लिखने के लिए नया हूं, इसलिए मुझे ध्यान देना चाहिए कि मैंने इसे पायथन 2.7 के लिए लिखा है। एक्सरेंज डी (x) को आज़माएं: इसे चलाने से पहले iter (रेंज (x)) लौटें
पीटर

2

प्रश्न का उत्तर देने का प्रयास करता हूं। कोड:

iris = datasets.load_iris()  
X = iris.data  
y = iris.target  
clf = DecisionTreeClassifier()  
clf.fit(X, y)  

निर्णय_ट्री प्लॉट:
यहां छवि विवरण दर्ज करें
हम प्राप्त कर सकते हैं compute_feature_importance: [0। , 0.01333333,0.0640559696.92261071]
स्रोत कोड की जाँच करें:

cpdef compute_feature_importances(self, normalize=True):
    """Computes the importance of each feature (aka variable)."""
    cdef Node* left
    cdef Node* right
    cdef Node* nodes = self.nodes
    cdef Node* node = nodes
    cdef Node* end_node = node + self.node_count

    cdef double normalizer = 0.

    cdef np.ndarray[np.float64_t, ndim=1] importances
    importances = np.zeros((self.n_features,))
    cdef DOUBLE_t* importance_data = <DOUBLE_t*>importances.data

    with nogil:
        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

    if normalize:
        normalizer = np.sum(importances)

        if normalizer > 0.0:
            # Avoid dividing by zero (e.g., when root is pure)
            importances /= normalizer

    return importances

फ़ीचर महत्व की गणना करने का प्रयास करें:

print("sepal length (cm)",0)
print("sepal width (cm)",(3*0.444-(0+0)))
print("petal length (cm)",(54* 0.168 - (48*0.041+6*0.444)) +(46*0.043 -(0+3*0.444)) + (3*0.444-(0+0)))
print("petal width (cm)",(150* 0.667 - (0+100*0.5)) +(100*0.5-(54*0.168+46*0.043))+(6*0.444 -(0+3*0.444)) + (48*0.041-(0+0)))

हमें feature_importance: np.array ([0,1.332,6.418,92.30]) मिलता है।
सामान्यीकृत होने के बाद, हम सरणी प्राप्त कर सकते हैं ([0., 0.01331334, 0.06414793, 0.92253873]), यह समान है clf.feature_importances_
सावधान रहें सभी वर्गों का वजन एक होना चाहिए।


1

इस विषय पर scikit-learn के प्रलेखन के संदर्भ की तलाश करने वालों के लिए या @GillesLeppe द्वारा उत्तर के संदर्भ में:

RandomForestClassifier में, estimators_विशेषता DecisionTreeClassifier की सूची है (जैसा कि प्रलेखन में उल्लेख किया गया है )। feature_importances_रैंडमफॉरस्टेस्ट क्लासीफायर के लिए गणना करने के लिए, स्किकिट-लर्न के सोर्स कोड में , यह सभी अनुमानक (सभी डिसिजनट्रीक्लासीफेरर) की एंब्रायडरी में एवरेज हैfeature_importances_

DecisionTreeClassifer के दस्तावेज़ीकरण में , यह उल्लेख किया गया है कि "किसी विशेषता का महत्व (सामान्यीकृत) उस सुविधा द्वारा लाई गई कसौटी की कुल कमी के रूप में गणना की जाती है। इसे जिनी महत्व [1] के रूप में भी जाना जाता है।"

यहाँ चर और गिन्नी महत्व के बारे में अधिक जानकारी के लिए एक सीधा लिंक दिया गया है, जैसा कि नीचे दी गई scikit-learn के संदर्भ द्वारा दिया गया है।

[१] एल। ब्रेमेन, और ए। कटलर, "रैंडम फ़ॉरेस्ट्स", http://www.stat.berkeley.edu/~breiman/RandomForests/cc_home.htm

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.