Los algoritmos basados en árboles son métodos populares de aprendizaje automático que se utilizan para resolver problemas de aprendizaje supervisado. Estos algoritmos son flexibles y pueden resolver cualquier tipo de problema (clasificación o regresión).

Los algoritmos basados en árboles tienden a usar la media para características continuas o el modo para características categóricas cuando hacen predicciones sobre muestras de entrenamiento en las regiones a las que pertenecen. También producen predicciones con alta precisión , estabilidad y facilidad de interpretación .

Ejemplos de algoritmos basados en árboles

Existen diferentes algoritmos basados en árboles que puede utilizar, como

Árboles de decisión
Bosque aleatorio
Aumento de gradiente
Embolsado (agregación Bootstrap)

Por lo tanto, todos los científicos de datos deberían aprender estos algoritmos y usarlos en sus proyectos de aprendizaje automático.

En este artículo, aprenderá más sobre el algoritmo de bosque aleatorio. Después de completar este artículo, debe dominar el uso del algoritmo de bosque aleatorio para resolver y crear modelos predictivos para problemas de clasificación con scikit-learn.

¿Qué es Random Forest?

El bosque aleatorio es uno de los algoritmos de aprendizaje supervisado basados en árboles más populares. También es el más flexible y fácil de usar.

El algoritmo se puede utilizar para resolver problemas de clasificación y regresión. El bosque aleatorio tiende a combinar cientos deárboles de decisióny luego entrena cada árbol de decisión en una muestra diferente de las observaciones.

Las predicciones finales del bosque aleatorio se realizan promediando las predicciones de cada árbol individual.

Los beneficios de los bosques aleatorios son numerosos. Los árboles de decisión individuales tienden a sobreajustarse a los datos de entrenamiento, pero el bosque aleatorio puede mitigar ese problema al promediar los resultados de predicción de diferentes árboles. Esto le da a los bosques aleatorios una mayor precisión predictiva que un solo árbol de decisión.

El algoritmo de bosque aleatorio también puede ayudarlo a encontrar características que son importantes en su conjunto de datos. Se encuentra en la base del algoritmo de Boruta, que selecciona características importantes en un conjunto de datos.

El bosque aleatorio se ha utilizado en una variedad de aplicaciones, por ejemplo, para proporcionar recomendaciones de diferentes productos a los clientes en el comercio electrónico.

En medicina, se puede utilizar un algoritmo de bosque aleatorio para identificar la enfermedad del paciente mediante el análisis de la historia clínica del paciente.

También en el sector bancario, se puede utilizar para determinar fácilmente si el cliente es fraudulento o legítimo.

¿Cómo funciona el algoritmo Random Forest?

El algoritmo de bosque aleatorio funciona completando los siguientes pasos:

Paso 1 : el algoritmo selecciona muestras aleatorias del conjunto de datos proporcionado.

Paso 2: El algoritmo creará un árbol de decisiones para cada muestra seleccionada. Entonces obtendrá un resultado de predicción de cada árbol de decisión creado.

Paso 3: A continuación, se realizará la votación para cada resultado previsto. Para un problema de clasificación, usará el modo , y para un problema de regresión, usará la media .

Paso 4 : Y finalmente, el algoritmo seleccionará el resultado de predicción más votado como predicción final.

Bosque aleatorio en la práctica

Ahora que conoce los entresijos del algoritmo de bosque aleatorio, creemos un clasificador de bosque aleatorio.

Construiremos un clasificador forestal aleatorio utilizando el conjunto de datos de diabetes de los indios Pima. El conjunto de datos de diabetes de los indios Pima implica predecir la aparición de la diabetes dentro de los 5 años según los detalles médicos proporcionados. Este es un problema de clasificación binaria.

Nuestra tarea es analizar y crear un modelo en el conjunto de datos de diabetes de los indios Pima para predecir si un paciente en particular tiene riesgo de desarrollar diabetes, dados otros factores independientes.

Comenzaremos importando paquetes importantes que usaremos para cargar el conjunto de datos y crear un clasificador de bosque aleatorio. Usaremos la biblioteca scikit-learn para cargar y usar el algoritmo de bosque aleatorio.

# import important packages import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns %matplotlib inline from sklearn.model_selection import train_test_split from sklearn.ensemble import RandomForestClassifier from sklearn.metrics import accuracy_score from sklearn.preprocessing import StandardScaler, MinMaxScaler import pandas_profiling from matplotlib import rcParams import warnings warnings.filterwarnings("ignore") # figure size in inches rcParams["figure.figsize"] = 10, 6 np.random.seed(42)

Conjunto de datos

Luego, cargue el conjunto de datos desde el directorio de datos:

# Load dataset data = pd.read_csv("../data/pima_indians_diabetes.csv")

Ahora podemos observar la muestra del conjunto de datos.

 # show sample of the dataset data.sample(5)

Como puede ver, en nuestro conjunto de datos tenemos diferentes características con valores numéricos.

Entendamos la lista de características que tenemos en este conjunto de datos.

# show columns data.columns

En este conjunto de datos, hay 8 características de entrada y 1 característica de salida / destino. Se cree que los valores que faltan están codificados con valores cero. El significado de los nombres de las variables es el siguiente (desde la primera hasta la última característica):

Número de embarazos.
Concentración de glucosa en plasma a 2 horas en una prueba de tolerancia a la glucosa oral.
Presión arterial diastólica (mm Hg).
Espesor del pliegue cutáneo del tríceps (mm).
Insulina sérica de 2 horas (mu U / ml).
Índice de masa corporal (peso en kg / (altura en m) ^ 2).
Función del pedigrí de la diabetes.
Años de edad).
Variable de clase (0 o 1).

Luego, dividimos el conjunto de datos en características independientes y características de destino. Nuestra característica de destino para este conjunto de datos se llama clase.

# split data into input and taget variable(s) X = data.drop("class", axis=1) y = data["class"]

Procesamiento previo del conjunto de datos

Before we create a model we need to standardize our independent features by using the standardScaler method from scikit-learn.

# standardize the dataset scaler = StandardScaler() X_scaled = scaler.fit_transform(X)

You can learn more on how and why to standardize your data from this article by clicking here.

Splitting the dataset into Training and Test data

We now split our processed dataset into training and test data. The test data will be 10% of the entire processed dataset.

# split into train and test set X_train, X_test, y_train, y_test = train_test_split( X_scaled, y, stratify=y, test_size=0.10, random_state=42 )

Building the Random Forest Classifier

Now is time to create our random forest classifier and then train it on the train set. We will also pass the number of trees (100) in the forest we want to use through theparameter called n_estimators.

# create the classifier classifier = RandomForestClassifier(n_estimators=100) # Train the model using the training sets classifier.fit(X_train, y_train)

The above output shows different parameter values of the random forest classifier used during the training process on the train data.

After training we can perform prediction on the test data.

# predictin on the test set y_pred = classifier.predict(X_test)

Then we check the accuracy using actual and predicted values from the test data.

# Calculate Model Accuracy print("Accuracy:", accuracy_score(y_test, y_pred))

Accuracy: 0.8051948051948052

Our accuracy is around 80.5% which is good. But we can always make it better.

Identify Important Features

As I said before, we can also check the important features by using the feature_importances_ variable from the random forest algorithm in scikit-learn.

# check Important features feature_importances_df = pd.DataFrame( {"feature": list(X.columns), "importance": classifier.feature_importances_} ).sort_values("importance", ascending=False) # Display feature_importances_df

The figure above shows the relative importance of features and their contribution to the model. We can also visualize these features and their scores using the seaborn and matplotlib libraries.

# visualize important featuers # Creating a bar plot sns.barplot(x=feature_importances_df.feature, y=feature_importances_df.importance) # Add labels to your plt.xlabel("Feature Importance Score") plt.ylabel("Features") plt.title("Visualizing Important Features") plt.xticks( rotation=45, horizontalalignment="right", fontweight="light", fontsize="x-large" ) plt.show()

From the figure above, you can see the triceps_skinfold_thickness feature has low importance and does not contribute much to the prediction.

This means that we can remove this feature and train our random forest classifier again and then see if it can improve its performance on the test data.

# load data with selected features X = data.drop(["class", "triceps_skinfold_thickness"], axis=1) y = data["class"] # standardize the dataset scaler = StandardScaler() X_scaled = scaler.fit_transform(X) # split into train and test set X_train, X_test, y_train, y_test = train_test_split( X_scaled, y, stratify=y, test_size=0.10, random_state=42 )

We will train the random forest algorithm with the selected processed features from our dataset, perform predictions, and then find the accuracy of the model.

# Create a Random Classifier clf = RandomForestClassifier(n_estimators=100) # Train the model using the training sets clf.fit(X_train, y_train) # prediction on test set y_pred = clf.predict(X_test) # Calculate Model Accuracy, print("Accuracy:", accuracy_score(y_test, y_pred))

Accuracy: 0.8181818181818182

Now the model accuracy has increased from 80.5% to 81.8% after we removed the least important feature called triceps_skinfold_thickness.

This suggests that it is very important to check important features and see if you can remove the least important features to increase your model's performance.

Wrapping up

Tree-based algorithms are really important for every data scientist to learn. In this article, you've learned the basics of tree-based algorithms and how to create a classification model by using the random forest algorithm.

I also recommend you try other types of tree-based algorithms such as the Extra-trees algorithm.

You can download the dataset and notebook used in this article here: //github.com/Davisy/Random-Forest-classification-Tutorial

Congratulations, you have made it to the end of this article!

If you learned something new or enjoyed reading this article, please share it so that others can see it. Until then, see you in the next post! I can also be reached on Twitter @Davis_McDavid

Ejemplos de algoritmos basados ​​en árboles