Comment sont feature_importances dans RandomForestClassifier déterminé?

Il y a en effet plusieurs façons d'obtenir la fonctionnalité "importances". Comme souvent, il n'existe pas de consensus strict sur ce que ce mot signifie.

Dans scikit-learn, nous mettons en œuvre l'importance comme décrit dans [1] (souvent cité, mais, malheureusement, rarement lu...). Il est parfois appelé "coefficient de gini importance" ou "diminution moyenne de l'impureté" et est définie comme la diminution totale du nœud de l'impureté (pondérée par la probabilité de parvenir à ce nœud (qui est évaluée en fonction de la proportion d'échantillons d'atteindre ce nœud)) en moyenne sur tous les arbres de l'ensemble.

Dans la littérature ou dans certains autres packages, vous pouvez également trouver disposent d'importances mis en œuvre comme la "réduction moyenne de la précision". Fondamentalement, l'idée est de mesurer la diminution de la précision sur LES données lorsque vous permuter aléatoirement les valeurs de cette fonction. Si la diminution est faible, alors la fonction n'est pas importante, et vice-versa.

(À noter que les deux algorithmes sont disponibles dans la randomForest package R.)

[1]: Breiman, Friedman, "Classification and regression trees", 1984.

C'est le ratio entre le nombre d'échantillons acheminés vers un nœud de décision impliquant la fonction dans un des arbres de l'ensemble, le nombre total d'échantillons dans l'ensemble de la formation.

Caractéristiques qui sont impliqués dans le haut niveau des nœuds des arbres de décision ont tendance à voir plus d'exemples sont donc susceptibles d'avoir plus d'importance.

Modifier: cette description n'est que partiellement correcte: Gilles et Pierre réponses sont la bonne réponse.

Laissez-moi essayer de répondre à la question.
code:

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

decision_tree parcelle:

entrez la description de l'image ici

Nous pouvons obtenir compute_feature_importance:[0. ,0.01333333,0.06405596,0.92261071]

Vérifier le code source:

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

Essayer de calculer la fonction de l'importance:

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)))

Nous obtenons feature_importance: np.tableau([0,1.332,6.418,92.30]).

Après avoir normalisé, nous pouvons obtenir la matrice de ([0., 0.01331334, 0.06414793, 0.92253873]),ce sont les mêmes que clf.feature_importances_.

Attention, toutes les classes sont censés avoir un poids.