Como são determinadas as feature_importances no RandomForestClassifier?

Eu tenho uma tarefa de classificação com uma série temporal como entrada de dados, em que cada atributo (n = 23) representa um ponto específico no tempo. Além do resultado absoluto da classificação, gostaria de descobrir quais atributos / datas contribuem para o resultado em que extensão. Portanto, estou apenas usando o feature_importances_, que funciona bem para mim.

No entanto, gostaria de saber como eles estão sendo calculados e qual medida / algoritmo é usado. Infelizmente não consegui encontrar nenhuma documentação sobre este tópico.

De fato, existem várias maneiras de obter "importâncias" do recurso. Com frequência, não existe um consenso estrito sobre o que essa palavra significa.

No scikit-learn, implementamos a importância conforme descrito em [1] (frequentemente citado, mas infelizmente raramente lido ...). Às vezes é chamada de "importância gini" ou "impureza decrescente média" e é definida como a diminuição total na impureza do nó (ponderada pela probabilidade de atingir esse nó (que é aproximada pela proporção de amostras que atingem esse nó)), calculada a média de todos árvores do conjunto.

Na literatura ou em alguns outros pacotes, você também pode encontrar importâncias de recursos implementadas como a "precisão média de diminuição". Basicamente, a idéia é medir a diminuição na precisão dos dados OOB quando você permuta aleatoriamente os valores para esse recurso. Se a redução for baixa, o recurso não será importante e vice-versa.

(Observe que os dois algoritmos estão disponíveis no pacote randomForest R.)

[1]: Breiman, Friedman, "Árvores de classificação e regressão", 1984.

A maneira usual de calcular os valores de importância do recurso de uma única árvore é a seguinte:

1. você inicializa uma matriz feature_importances de todos os zeros com tamanho n_features.

2. você percorre a árvore: para cada nó interno que se divide em um recurso, icalcula a redução de erro desse nó multiplicada pelo número de amostras que foram roteadas para o nó e inclui essa quantidade em feature_importances[i].

A redução do erro depende do critério de impureza que você usa (por exemplo, Gini, Entropy, MSE, ...). É a impureza do conjunto de exemplos que é roteado para o nó interno menos a soma das impurezas das duas partições criadas pela divisão.

É importante que esses valores sejam relativos a um conjunto de dados específico (tanto a redução de erros quanto o número de amostras são específicos do conjunto de dados), portanto, esses valores não podem ser comparados entre diferentes conjuntos de dados.

Até onde eu sei, existem maneiras alternativas de calcular os valores de importância dos recursos nas árvores de decisão. Uma breve descrição do método acima pode ser encontrada em "Elements of Statistical Learning", de Trevor Hastie, Robert Tibshirani e Jerome Friedman.

É a proporção entre o número de amostras roteadas para um nó de decisão que envolve esse recurso em qualquer uma das árvores do conjunto sobre o número total de amostras no conjunto de treinamento.

Os recursos envolvidos nos nós de nível superior das árvores de decisão tendem a ver mais amostras, portanto, provavelmente terão mais importância.

Editar : esta descrição está apenas parcialmente correta: as respostas de Gilles e Peter são a resposta correta.

Como o @GillesLouppe apontou acima, o scikit-learn atualmente implementa a métrica "média de redução da impureza" para importâncias de recursos. Pessoalmente, acho a segunda métrica um pouco mais interessante, onde você permuta aleatoriamente os valores de cada um dos seus recursos, um por um, e vê o quão pior é o desempenho imediato.

Como o que você procura após a importância do recurso é o quanto cada recurso contribui para o desempenho preditivo do seu modelo geral, a segunda métrica fornece uma medida direta disso, enquanto a "redução média da impureza" é apenas um bom proxy.

Se você estiver interessado, escrevi um pequeno pacote que implementa a métrica Importância da Permutação e pode ser usado para calcular os valores de uma instância de uma classe de floresta aleatória scikit-learn:

https://github.com/pjh2011/rf_perm_feat_import

Edit: Isso funciona para Python 2.7, não 3

Deixe-me tentar responder à pergunta. código:

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

plotagem decision_tree:
insira a descrição da imagem aqui
Podemos obter compute_feature_importance: [0. , 0.01333333,0.06405596,0.92261071]
Verifique o código-fonte:

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

Tente calcular a importância do recurso:

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

Temos a feature_importance: np.array ([0,1.332,6.418,92.30]).
Depois da normalização, podemos obter o array ([0., 0.01331334, 0.06414793, 0.92253873]), é o mesmo que clf.feature_importances_.
Tenha cuidado para que todas as classes tenham o peso um.

Para quem procura uma referência à documentação do scikit-learn sobre este tópico ou uma referência à resposta de @GillesLouppe:

Em RandomForestClassifier, estimators_attribute é uma lista de DecisionTreeClassifier (conforme mencionado na documentação ). Para calcular o valor feature_importances_para o RandomForestClassifier, no código-fonte do scikit -learn , ele calcula a média de todos os feature_importances_atributos do estimador (todos os DecisionTreeClassifer) no conjunto.

Na documentação do DecisionTreeClassifer , é mencionado que "A importância de um recurso é calculada como a redução total (normalizada) do critério trazido por esse recurso. Também é conhecida como a importância de Gini [1]".

Aqui está um link direto para obter mais informações sobre variáveis ​​e importância do Gini, conforme fornecido pela referência do scikit-learn abaixo.

[1] L. Breiman e A. Cutler, “Random Forests”, http://www.stat.berkeley.edu/~breiman/RandomForests/cc_home.htm