Obtenha importâncias de recursos para florestas aleatórias com Python e Scikit-Learn

Republicado por Platão

seguidores: 0

Introdução

A Floresta Aleatória algoritmo é um algoritmo de aprendizado supervisionado baseado em árvore que usa um conjunto de predições de muitas árvores de decisão, seja para classificar um ponto de dados ou determinar seu valor aproximado. Isso significa que pode ser usado para classificação ou regressão.

Quando aplicada para classificação, a classe do ponto de dados é escolhida com base na classe que foi mais votada pelas árvores; e quando aplicado para regressão, o valor do ponto de dados é a média de todos os valores produzidos pelas árvores.

Uma coisa importante a lembrar ao usar Random Forests é que o número de árvores é um hiperparâmetro e será definido antes de executar o modelo.

Ao trabalhar com ciência de dados, uma das razões pelas quais um modelo Random Forest foi escolhido para um projeto específico pode ter a ver com a capacidade de olhar para árvores em conjunto e entender porque uma classificação foi feita, ou porque um valor foi dado - isso é chamado explicabilidade.

Considerando algoritmos baseados em árvores, tentar explicar um modelo pode ser feito de várias maneiras, exibindo e olhando para cada árvore (pode ser difícil se o modelo tiver 200 árvores ou mais), usando Valores de Shapley (ou SHAP), olhando para as características que foram mais levadas em consideração pelo modelo, usando LIME para investigar as relações entre a entrada e a saída do modelo, etc. Geralmente, uma combinação de todos os métodos é empregada.

Neste guia rápido, vamos nos concentrar em criar um gráfico das características que foram consideradas importantes para o modelo tomar uma decisão ao classificar os pinguins. Isso é conhecido como investigar o importância do recurso, e pode ser transmitido a outros membros da equipe (técnicos e não técnicos) para oferecer uma visão de como as decisões são tomadas.

Para fazer isso, vamos importar as bibliotecas necessárias, carregar o conjunto de dados Palmer Penguins, dividir os dados, criar o modelo, obter as importâncias dos recursos e usar o Seaborn para plotá-los! Não vamos nos aprofundar muito nos dados, EDA ou no próprio modelo – esses são os tópicos do guia dedicado.

Observação: Você pode baixar o conjunto de dados em GitHub ou diretamente do código.

Importando Bibliotecas

Vamos começar importando algumas bibliotecas que usaremos:


import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier


raw_data_url = "https://gist.githubusercontent.com/cassiasamp/197b4e070f5f4da890ca4d226d088d1f/raw/38c9d4906ed121481b4dc201fa2004f2b3d0065f/penguins.csv"
df = pd.read_csv(raw_data_url)

Dividindo os Dados

Vamos dividir os dados para treinamento e teste:


df = df.dropna().drop("rowid", axis=1)


y = df["species"]
X = df[["bill_length_mm", "bill_depth_mm", "flipper_length_mm"]]


X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)

Obtendo as Importâncias dos Recursos

Por fim, podemos treinar um modelo e exportar as importâncias dos recursos com:


rf = RandomForestClassifier()


rf.fit(X_train, y_train)


rf.feature_importances_

Isso resulta em:

array([0.41267633, 0.30107056, 0.28625311])

Esses são os valores dos recursos, para ver os nomes dos recursos, execute:


rf.feature_names_in_

Isso resulta no nome correspondente de cada recurso:

array(['bill_length_mm', 'bill_depth_mm', 'flipper_length_mm'],
      dtype=object)

Isso significa que a característica mais importante para decidir as classes de pinguins para este modelo em particular foi a bill_length_mm!

A importância é relativa à medida de quão bem os dados estão sendo separados em cada nó dividido – neste caso, a medida é dada pelo Índice Gini – o valor gini é então ponderado por quantas linhas foram divididas ao usar o bill_length_mm recurso e calculou a média das 100 árvores do conjunto. O resultado dessas etapas é responsável por 0.41267633, ou mais de 40% neste caso.

Visualizando a importância do recurso

Uma forma comum de representar valores de importância é usando chats de bar. Vamos primeiro criar um dataframe com os nomes dos recursos e suas importâncias correspondentes e, em seguida, visualizá-los usando o Seaborn's barplot():


importances_df = pd.DataFrame({"feature_names" : rf.feature_names_in_, 
                               "importances" : rf.feature_importances_})
                             

g = sns.barplot(x=importances_df["feature_names"], 
                y=importances_df["importances"])
g.set_title("Feature importances", fontsize=14);

Conselho: Uma boa prática ao apresentar informações é ordenar os valores em ordem crescente ou decrescente. Neste caso, os dados já estão ordenados, sendo o primeiro valor o primeiro que queremos saber. Quando este não for o caso, você pode solicitar o dataframe com sort_values. Isso pode ser feito em qualquer coluna em ordem crescente ou decrescente: importances_df.sort_values(by="importances", ascending=False).

Ao olhar para este primeiro gráfico, é mais difícil interpretar o valor da importância de cada recurso. É óbvio que o comprimento da cédula é maior que as outras duas barras, mas não exatamente que o bill_depth_mm é equivalente a 0.30107056e que o flipper_length_mm é 0.28625311. Assim, este primeiro gráfico pode ser melhorado exibindo o valor de cada barra. Isso pode ser feito acessando Seaborn's containers objeto. Ele armazena as informações de cada barra e passa os valores como rótulos de barras:

Confira nosso guia prático e prático para aprender Git, com práticas recomendadas, padrões aceitos pelo setor e folha de dicas incluída. Pare de pesquisar comandos Git no Google e realmente aprender -lo!

g = sns.barplot(data=importances_df, 
                x="importances", 
                y="feature_names")
g.set_title("Feature importances", fontsize=14)
for value in g.containers:
    g.bar_label(value)