Obtenga la importancia de las funciones para los bosques aleatorios con Python y Scikit-Learn

Introducción

El Bosque al azar El algoritmo es un algoritmo de aprendizaje supervisado basado en árboles que utiliza un conjunto de predicciones de muchos árboles de decisión, ya sea para clasificar un punto de datos o determinar su valor aproximado. Esto significa que puede usarse para clasificación o regresión.

Cuando se solicita la clasificación, la clase del punto de datos se elige en función de la clase que fue más votada por los árboles; y cuando se aplica para la regresión, el valor del punto de datos es el promedio de todos los valores generados por los árboles.

Una cosa importante que debe recordar al usar Random Forests es que la cantidad de árboles es un hiperparámetro y se definirá antes de ejecutar el modelo.

Cuando se trabaja en ciencia de datos, una de las razones por las que se eligió un modelo Random Forest para un proyecto específico podría tener que ver con la capacidad de observar árboles ensamblados y comprender porque se hizo una clasificación, o porque se le dio un valor – esto se llama explicabilidad.

Teniendo en cuenta los algoritmos basados ​​en árboles, intentar explicar un modelo se puede hacer de varias maneras, mostrando y mirando cada árbol (puede ser difícil si el modelo tiene 200 árboles o más), usando Valores Shapley (o SHAP), observando las características que más se tuvieron en cuenta en el modelo, utilizando LIME para investigar las relaciones entre la entrada y la salida del modelo, etc. Por lo general, se emplea una combinación de todos los métodos.

En esta guía rápida, nos centraremos en crear un cuadro de las características que se consideraron importantes para que el modelo tomara una decisión al clasificar a los pingüinos. Esto se conoce como investigar el importancia de la característica, y se puede transmitir a otros miembros del equipo (técnicos y no técnicos) para ofrecer una idea de cómo se toman las decisiones.

Para hacer esto, importemos las bibliotecas necesarias, carguemos el conjunto de datos de Palmer Penguins, dividamos los datos, creemos el modelo, obtengamos las características importantes y usemos Seaborn para trazarlas. No profundizaremos mucho en los datos, EDA o el modelo en sí; esos son el tema de la guía dedicada.

Nota: Puede descargar el conjunto de datos desde GitHub o directamente desde el código.

Importando Bibliotecas

Comencemos importando algunas 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)

División de datos

Dividamos los datos para entrenamiento y prueba:

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)

Obtención de la importancia de las características

Finalmente, podemos entrenar un modelo y exportar las características importantes con:

rf = RandomForestClassifier()


rf.fit(X_train, y_train)


rf.feature_importances_

Esto produce:

array([0.41267633, 0.30107056, 0.28625311])

Esos son los valores de las funciones, para ver los nombres de las funciones, ejecute:

rf.feature_names_in_

Esto da como resultado el nombre correspondiente de cada función:

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

Esto significa que la característica más importante para decidir las clases de peguin para este modelo en particular fue la bill_length_mm!

La importancia es relativa a la medida de qué tan bien se están separando los datos en cada división de nodo; en este caso, la medida está dada por el Índice de Gini – el valor de Gini se pondera luego por cuántas filas se han dividido al usar el bill_length_mm característica y promediado sobre los 100 árboles en el conjunto. El resultado de esos pasos explica 0.41267633, o más del 40% en este caso.

Visualización de la importancia de las funciones

Una forma común de representar valores de importancia es usar chats de barra. Primero vamos a crear un marco de datos con los nombres de las características y sus correspondientes importancias, y luego visualízalos usando Seaborn. 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);                          

Consejo: Una buena práctica al presentar información es ordenar los valores en orden ascendente o descendente. En este caso, los datos ya están ordenados, siendo el primer valor el primero que queremos saber. Cuando este no es el caso, puede ordenar el marco de datos con sort_values. Esto se puede hacer en cualquier columna en orden ascendente o descendente: importances_df.sort_values(by="importances", ascending=False).

Al mirar este primer gráfico, es más difícil interpretar el valor de la importancia de cada característica. Es obvio que la longitud del billete es mayor que las otras dos barras, pero no exactamente que el bill_depth_mm es equivalente a 0.30107056y que el flipper_length_mm es 0.28625311. Entonces, este primer gráfico se puede mejorar mostrando el valor de cada barra. Esto se puede hacer accediendo a Seaborn's containers objeto. Almacena la información de cada barra y pasa los valores como etiquetas de barra:

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)

Ahora, podemos ver cada valor de importancia claramente, o casi claramente, porque bill_length_mm el valor se corta con una línea vertical que forma parte del borde exterior del gráfico. Los bordes se utilizan para delimitar un área como una forma de centrar más la atención en ella, pero en este caso, no es necesario delimitar, porque solo hay un gráfico. Eliminemos el borde y mejoremos la legibilidad de los números:

g = sns.barplot(data=importances_df, 
                x="importances", 
                y="feature_names")
                

sns.despine(bottom=True, left=True)
g.set_title("Feature importances", fontsize=14)
for value in g.containers:
    g.bar_label(value)

El gráfico parece más fácil de leer, pero las marcas en el eje X parecen estar flotando y ya tenemos los valores junto con las barras, por lo que podemos eliminar el xticks:

g = sns.barplot(data=importances_df, 
                x="importances", 
                y="feature_names")
sns.despine(bottom=True, left=True)


g.set(xticks=[])
g.set_title("Feature importances", fontsize=14)
for value in g.containers:
    g.bar_label(value)

Observe cómo después de quitar las marcas, las etiquetas Y y X son un poco difíciles de leer. La etiqueta Y, feature_names, es vertical y en el eje X, solo hay importances. Dado que el título ya indica que el gráfico es de Importancia de las características, también podemos eliminar las etiquetas de los ejes:

g = sns.barplot(data=importances_df, 
                x="importances", 
                y="feature_names")
sns.despine(bottom=True, left=True)
g.set_title("Feature importances", fontsize=14)
g.set(xticks=[])


g.set(xlabel=None)
g.set(ylabel=None)
for value in g.containers:
    g.bar_label(value)

Puede ver cómo este gráfico es más limpio, fácil de leer y comprender al compararlo con el primero. Todavía hay algunas cosas que podemos hacer. Observe que los números están muy cerca de las barras, sería más fácil de leer si hubiera un poco más de espacio entre ellos.

Otro elemento en esta trama son los colores, cuando se usan colores contrastantes transmite una idea de separación, por el contrario, cuando se usan colores similares comunican una idea de unidad, o partes de un todo. Dado que todas las características son parte de los pingüinos, podemos usar colores que distingan cada barra manteniendo la unidad:

g = sns.barplot(data=importances_df, 
                x="importances", 
                y="feature_names",
                
                
                palette="mako")
sns.despine(bottom=True, left=True)
g.set_title("Feature importances", fontsize=14)
g.set(xticks=[])
g.set(xlabel=None)
g.set(ylabel=None)
for value in g.containers:
    g.bar_label(value, 
                padding=2) 

Si desea que los resultados sean aún más directos, puede cambiar el título y agregar la conclusión. Lo que sí se sabe es que la longitud del billete se consideraba la característica más importante según los criterios que hemos discutido anteriormente. Esta puede ser la primera información para alguien que mira la trama, podríamos decir que la longitud del pico del pingüino fue la característica más importante para la clasificación de especies en el modelo base Random Forest (RF) :

g = sns.barplot(data=importances_df, 
                x="importances", 
                y="feature_names", 
                palette="mako")
sns.despine(bottom=True, left=True)
g.set_title("The penguin's bill length was the most important feature for species classification (RF base model)", fontsize=14)
g.set(xticks=[])
g.set(xlabel=None)
g.set(ylabel=None)
for value in g.containers:
    g.bar_label(value, padding=2)

Este es el resultado final de la tabla de importancia de las funciones:

Conclusión

En esta guía, creamos un clasificador de bosque aleatorio e inspeccionamos las características importantes que se usaron para entrenar el modelo en un intento de explicar lo que un modelo ha aprendido y lo que afecta su razonamiento.