Algoritmo de bosque aleatorio con Python y Scikit-Learn

Random forest es un tipo de algoritmo de aprendizaje automático supervisado basado en el aprendizaje conjunto. El aprendizaje conjunto es un tipo de aprendizaje en el que se unen dife...

Random forest es un tipo de algoritmo de aprendizaje automático supervisado basado en aprendizaje conjunto. El aprendizaje conjunto es un tipo de aprendizaje en el que se unen diferentes tipos de algoritmos o el mismo algoritmo varias veces para formar un modelo de predicción más potente. El algoritmo bosque aleatorio combina varios algoritmos del mismo tipo, es decir, árboles de decisión múltiple, lo que da como resultado un bosque de árboles, de ahí el nombre "Random Bosque". El algoritmo de bosque aleatorio se puede utilizar tanto para tareas de regresión como de clasificación.

Cómo funciona el algoritmo de bosque aleatorio

Los siguientes son los pasos básicos involucrados en la realización del algoritmo de bosque aleatorio:

  1. Elija N registros aleatorios del conjunto de datos.
  2. Construya un árbol de decisión basado en estos N registros.
  3. Elija la cantidad de árboles que desea en su algoritmo y repita los pasos 1 y 2.
  4. En caso de un problema de regresión, para un nuevo registro, cada árbol en el bosque predice un valor para Y (salida). El valor final se puede calcular tomando el promedio de todos los valores pronosticados por todos los árboles en el bosque. O, en caso de un problema de clasificación, cada árbol del bosque predice la categoría a la que pertenece el nuevo registro. Finalmente, el nuevo registro se asigna a la categoría que obtiene el voto mayoritario.

Ventajas de usar Random Forest

Como con cualquier algoritmo, hay ventajas y desventajas al usarlo. En las próximas dos secciones, veremos los pros y los contras de usar bosques aleatorios para clasificación y regresión.

  1. El algoritmo de bosque aleatorio no está sesgado, ya que hay varios árboles y cada árbol se entrena en un subconjunto de datos. Básicamente, el algoritmo de bosque aleatorio se basa en el poder de "la multitud"; por lo tanto, se reduce el sesgo general del algoritmo.
  2. Este algoritmo es muy estable. Incluso si se introduce un nuevo punto de datos en el conjunto de datos, el algoritmo general no se ve muy afectado, ya que los nuevos datos pueden afectar a un árbol, pero es muy difícil que afecte a todos los árboles.
  3. El algoritmo de bosque aleatorio funciona bien cuando tiene características categóricas y numéricas.
  4. El algoritmo de bosque aleatorio también funciona bien cuando a los datos les faltan valores o no se han escalado bien (aunque hemos realizado escalado de características en este artículo solo con fines de demostración).

Desventajas de usar Random Forest

  1. Una gran desventaja de los bosques aleatorios radica en su complejidad. Requerían muchos más recursos computacionales, debido a la gran cantidad de árboles de decisión unidos.
  2. Debido a su complejidad, requieren mucho más tiempo de entrenamiento que otros algoritmos comparables.

A lo largo del resto de este artículo, veremos cómo se puede usar [Biblioteca Scikit-Learn] (http://scikit-learn.org/stable/index.html) de Python para implementar el algoritmo de bosque aleatorio para resolver la regresión, así como clasificación, problemas.

Parte 1: uso de Random Forest para la regresión

En esta sección, estudiaremos cómo se pueden usar bosques aleatorios para resolver problemas de regresión usando Scikit-Learn. En la siguiente sección resolveremos el problema de clasificación a través de bosques aleatorios.

Definición del problema {#definición del problema}

El problema aquí es predecir el consumo de gasolina (en millones de galones) en 48 de los estados de EE. UU. con base en el impuesto a la gasolina (en centavos), el ingreso per cápita (dólares), las carreteras pavimentadas (en millas) y la proporción de población con el licencia de conducir.

Solución

Para resolver este problema de regresión, utilizaremos el algoritmo de bosque aleatorio a través de la biblioteca Scikit-Learn Python. Seguiremos la canalización tradicional de aprendizaje automático para resolver este problema. Sigue estos pasos:

1. Importar bibliotecas

Ejecute el siguiente código para importar las bibliotecas necesarias:

1
2
import pandas as pd
import numpy as np
2. Importación de conjunto de datos

El conjunto de datos para este problema está disponible en:

https://drive.google.com/file/d/1mVmGNx6cbfvRHC_DvF12ZL3wGLSHD9f_/ver

Por el bien de este tutorial, el conjunto de datos se ha descargado en la carpeta "Datasets" de la unidad "D". Deberá cambiar la ruta del archivo de acuerdo con su propia configuración.

Ejecute el siguiente comando para importar el conjunto de datos:

1
dataset = pd.read_csv('D:\Datasets\petrol_consumption.csv')

Para obtener una vista de alto nivel de cómo se ve el conjunto de datos, ejecute el siguiente comando:

1
dataset.head()
  Petrol_tax   Average_income   Paved_Highways   Population_Driver_license(%)   Petrol_Consumption

0 9.0 3571 1976 0.525 541 1 9.0 4092 1250 0.572 524 2 9,0 3865 1586 0,580 561 3 7.5 4870 2351 0.529 414 4 8,0 4399 431 0,544 410

Podemos ver que los valores en nuestro conjunto de datos no están muy bien escalados. Los reduciremos antes de entrenar el algoritmo.

3. Preparación de datos para el entrenamiento

En este apartado se realizarán dos tareas. La primera tarea es dividir los datos en conjuntos de 'atributos' y 'etiquetas'. Los datos resultantes se dividen luego en conjuntos de entrenamiento y prueba.

El siguiente script divide los datos en atributos y etiquetas:

1
2
X = dataset.iloc[:, 0:4].values
y = dataset.iloc[:, 4].values

Finalmente, dividamos los datos en conjuntos de entrenamiento y prueba:

1
2
3
from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
4. Escalado de características

Sabemos que nuestro conjunto de datos aún no es un valor escalado, por ejemplo, el campo Average_Income tiene valores en el rango de miles, mientras que Petrol_tax tiene valores en el rango de decenas. Por lo tanto, sería beneficioso escalar nuestros datos (aunque, como se mencionó anteriormente, este paso no es tan importante para el algoritmo de bosques aleatorios). Para ello, utilizaremos la clase StandardScaler de Scikit-Learn. Ejecute el siguiente código para hacerlo:

1
2
3
4
5
6
# Feature Scaling
from sklearn.preprocessing import StandardScaler

sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)
5. Entrenamiento del algoritmo

Ahora que hemos escalado nuestro conjunto de datos, es hora de entrenar nuestro algoritmo de bosque aleatorio para resolver este problema de regresión. Ejecuta el siguiente código:

1
2
3
4
5
from sklearn.ensemble import RandomForestRegressor

regressor = RandomForestRegressor(n_estimators=20, random_state=0)
regressor.fit(X_train, y_train)
y_pred = regressor.predict(X_test)

La clase RandomForestRegressor de la biblioteca sklearn.ensemble se usa para resolver problemas de regresión a través de un bosque aleatorio. El parámetro más importante de la clase RandomForestRegressor es el parámetro n_estimators. Este parámetro define el número de árboles en el bosque aleatorio. Comenzaremos con n_estimator=20 para ver cómo funciona nuestro algoritmo. Puede encontrar detalles de todos los parámetros de RandomForestRegressor aquí.

6. Evaluación del algoritmo

El último y último paso para resolver un problema de aprendizaje automático es evaluar el rendimiento del algoritmo. Para los problemas de regresión, las métricas utilizadas para evaluar un algoritmo son el error absoluto medio, el error cuadrático medio y el error cuadrático medio. Ejecute el siguiente código para encontrar estos valores:

1
2
3
4
5
from sklearn import metrics

print('Mean Absolute Error:', metrics.mean_absolute_error(y_test, y_pred))
print('Mean Squared Error:', metrics.mean_squared_error(y_test, y_pred))
print('Root Mean Squared Error:', np.sqrt(metrics.mean_squared_error(y_test, y_pred)))

La salida se verá algo como esto:

1
2
3
Mean Absolute Error: 51.765
Mean Squared Error: 4216.16675
Root Mean Squared Error: 64.932016371

Con 20 árboles, el error cuadrático medio es 64,93, que es superior al 10 por ciento del consumo medio de gasolina, es decir, 576,77. Esto puede indicar, entre otras cosas, que no hemos utilizado suficientes estimadores (árboles).

Si el número de estimadores se cambia a 200, los resultados son los siguientes:

1
2
3
Mean Absolute Error: 47.9825
Mean Squared Error: 3469.7007375
Root Mean Squared Error: 58.9041657058

El siguiente gráfico muestra la disminución del valor del error cuadrático medio (RMSE) con respecto al número de estimadores. Aquí, el eje X contiene el número de estimadores mientras que el eje Y contiene el valor del error cuadrático medio.

RMSE vs number of estimators{.img-responsive}

Puede ver que los valores de error disminuyen con el aumento en el número de estimadores. Después de 200, la tasa de disminución del error disminuye, por lo que 200 es un buen número para n_estimadores. Puede jugar con la cantidad de árboles y otros parámetros para ver si puede obtener mejores resultados por su cuenta.

Parte 2: uso de Random Forest para la clasificación

Definición del problema {#definición del problema}

La tarea aquí es predecir si un billete de banco es auténtico o no en función de cuatro atributos, es decir, la variación de la imagen transformada en wavelet, la asimetría, la entropía y la curtosis de la imagen.

Solución

Este es un problema de clasificación binaria y usaremos un clasificador de bosque aleatorio para resolver este problema. Los pasos seguidos para resolver este problema serán similares a los pasos realizados para la regresión.

1. Importar bibliotecas
1
2
import pandas as pd
import numpy as np
2. Importación de conjunto de datos

El conjunto de datos se puede descargar desde el siguiente enlace:

https://drive.google.com/file/d/13nw-uRXPY8XIZQxKRNZ3yYlho-CYm_Qt/view

La información detallada sobre los datos está disponible en el siguiente enlace:

https://archive.ics.uci.edu/ml/datasets/banknote+authentication

El siguiente código importa el conjunto de datos:

1
dataset = pd.read_csv("D:/Datasets/bill_authentication.csv")

Para obtener una vista de alto nivel del conjunto de datos, ejecute el siguiente comando:

1
dataset.head()
  Variance   Skewness   Curtosis   Entropy    Class

0 3,62160 8,6661 -2,8073 -0,44699 0 1 4,54590 8,1674 -2,4586 -1,46210 0 2 3,86600 -2,6383 1,9242 0,10645 0 3 3,45660 9,5228 -4,0112 -3,59440 0 4 0,32924 -4,4552 4,5718 -0,98880 0

Como fue el caso con el conjunto de datos de regresión, los valores en este conjunto de datos no están muy bien escalados. El conjunto de datos se escalará antes de entrenar el algoritmo.

3. Preparación de datos para el entrenamiento

El siguiente código divide los datos en atributos y etiquetas:

1
2
X = dataset.iloc[:, 0:4].values
y = dataset.iloc[:, 4].values

El siguiente código divide los datos en conjuntos de entrenamiento y prueba:

1
2
3
from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
4. Escalado de características

Al igual que antes, el escalado de características funciona de la misma manera:

1
2
3
4
5
6
# Feature Scaling
from sklearn.preprocessing import StandardScaler

sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)
5. Entrenamiento del algoritmo

Y nuevamente, ahora que hemos escalado nuestro conjunto de datos, podemos entrenar nuestros bosques aleatorios para resolver este problema de clasificación. Para hacerlo, ejecute el siguiente código:

1
2
3
4
5
from sklearn.ensemble import RandomForestRegressor

regressor = RandomForestRegressor(n_estimators=20, random_state=0)
regressor.fit(X_train, y_train)
y_pred = regressor.predict(X_test)

En caso de regresión, usamos la clase RandomForestRegressor de la biblioteca sklearn.ensemble. Para la clasificación, utilizaremos la clase RandomForestClassifier de la biblioteca sklearn.ensemble. La clase RandomForestClassifier también toma n_estimators como parámetro. Como antes, este parámetro define el número de árboles en nuestro bosque aleatorio. Comenzaremos con 20 árboles nuevamente. Puede encontrar detalles de todos los parámetros de RandomForestClassifier aquí.

6. Evaluación del algoritmo

Para problemas de clasificación, las métricas utilizadas para evaluar un algoritmo son precisión, matriz de confusión, recuperación de precisión y valores F1. Ejecute el siguiente script para encontrar estos valores:

1
2
3
4
5
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score

print(confusion_matrix(y_test,y_pred))
print(classification_report(y_test,y_pred))
print(accuracy_score(y_test, y_pred))

La salida se verá algo como esto:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
[[155    2]
    1  117]]
              precision   recall   f1-score   support

           0       0.99     0.99       0.99       157
           1       0.98     0.99       0.99       118

 avg / total       0.99     0.99       0.99       275

0.989090909091

La precisión alcanzada por nuestro clasificador de bosque aleatorio con 20 árboles es del 98,90 %. A diferencia de antes, cambiar la cantidad de estimadores para este problema no mejoró significativamente los resultados, como se muestra en el siguiente gráfico. Aquí, el eje X contiene el número de estimadores, mientras que el eje Y muestra la precisión.

Accuracy vs number of estimators{.img-responsive}

98,90% es una precisión bastante buena, por lo que no tiene mucho sentido aumentar nuestro número de estimadores de todos modos. Podemos ver que aumentar el número de estimadores no mejoró aún más la precisión.

Para mejorar la precisión, le sugiero que juegue con otros parámetros de la clase RandomForestClassifier y vea si puede mejorar nuestros resultados.

Yendo más lejos: proyecto de extremo a extremo portátil

¿Tu naturaleza inquisitiva te hace querer ir más allá? Recomendamos consultar nuestro Proyecto guiado: ["Predicción práctica del precio de la vivienda: aprendizaje automático en Python"](https://wikihtp.com/courses/hands-on-house- precio-predicción-aprendizaje-máquina-en-python/#cta){target="_blank"}.

[](https://wikihtp.com/ cursos/predicción-de-precio-de-la-casa-práctica-aprendizaje-de-máquina-en-python/#cta)

En este proyecto guiado, aprenderá a crear potentes modelos tradicionales de aprendizaje automático, así como modelos de aprendizaje profundo, utilizar Ensemble Learning y capacitar a los meta-aprendices para predecir los precios de la vivienda a partir de una bolsa de modelos Scikit-Learn y Keras.

Con Keras, la API de aprendizaje profundo creada sobre Tensorflow, experimentaremos con arquitecturas, crearemos un conjunto de modelos apilados y entrenaremos una red neuronal meta-aprendizaje (modelo de nivel 1) para calcular el precio de un casa.

El aprendizaje profundo es sorprendente, pero antes de recurrir a él, se recomienda intentar resolver el problema con técnicas más simples, como los algoritmos de aprendizaje superficial. Nuestro rendimiento de referencia se basará en un algoritmo de Regresión de bosque aleatorio. Además, exploraremos la creación de conjuntos de modelos a través de Scikit-Learn a través de técnicas como embalaje y votación.

Este es un proyecto integral y, como todos los proyectos de aprendizaje automático, comenzaremos con Análisis exploratorio de datos, seguido de Preprocesamiento de datos y, finalmente, Creación de modelos superficiales y Aprendizaje profundo para ajustarse a los datos que hemos explorado y limpiado previamente.