Bosques Aleatorios Regresión – Práctica con Python

En esta entrada explicaremos la parte práctica del algoritmo de Bosques Aleatorio Regresión, en donde desarrollaremos un modelo para predecir el precio de las casas en Boston de acuerdo al número de habitaciones que cuenta la vivienda.

A su vez, te recomiendo que, si no haz visto la información anterior referente a la teoría y cómo implementar este algoritmo utilizando la librería Scikit Learn te vayas a verlos porque son las bases para entender lo que se explicará en este.

El dataset que vamos a utilizar para realizar la práctica será el de Boston Housing o las casas de Boston, que es el mismo que hemos desarrollado con los anteriores algoritmos por lo que no profundizaremos en cómo importar los datos y realizar el respectivo preprocesamiento, acá solamente nos enfocaremos en cómo implementar el algoritmo de Bosques Aleatorios Regresión, en caso de que quieras obtener más información del preprocesamiento del dataset te recomiendo que las publicaciones anteriores en donde tienes una explicación muy completa al respecto.

Aclarado esto podemos empezar con el desarrollo del modelo. Lo primero que debemos hacer es separar los datos en “x” y “y”, en este caso estas variables las definiremos como X_bar que será igual a los datos ubicados en la columna 6 del dataset, y y_adr correspondiente a la columna de target.

#Seleccionamos solamente la columna 6 del dataset
X_bar = boston.data[:, np.newaxis, 5]

#Defino los datos correspondientes a las etiquetas
y_bar = boston.target

Definido esto veamos estos datos graficados para tener una visión con lo que estamos trabajando, para ello utilizamos la librería Matplotlib, que ya hemos explicado su uso con anterioridad.

#Graficamos los datos correspondientes
plt.scatter(X_bar, y_bar)
plt.show()

Bosques-Aleatorios-Regresión-Práctica-1

Para construir el modelo debemos separar nuevamente los datos, pero esta vez en datos de entrenamiento y en datos de prueba, para esto utilizamos la instrucción train_test_split la cual nos ahorra bastante el trabajo.

from sklearn.model_selection import train_test_split

#Separo los datos de "train" en entrenamiento y prueba para probar los algoritmos
X_train, X_test, y_train, y_test = train_test_split(X_bar, y_bar, test_size=0.2)

El siguiente paso que debemos hacer es importar el modulo de Scikit Learn para trabajar con el algoritmo de Bosques Aleatorios Regresión.

from sklearn.ensemble import RandomForestRegressor

Con esta simple línea de código ya podemos empezar a utilizar este algoritmo por lo que lo definimos en nuestro programa bar será igual a RadomForestRegressor, y acá empezamos a definir los parámetros respectivos de este algoritmo.

#Defino el algoritmo a utilizar
bar = RandomForestRegressor(n_estimators = 300, max_depth = 8)

El primero de ellos es n_estimators que será el estimado de árboles, en este caso vamos a colocar 300, este número lo podrás variar por tu cuenta para que puedas verificar el comportamiento del algoritmo, si mejora o no los resultados obtenidos.

El siguiente parámetro que vamos a definir es el de max_depth, que será igual a 8, de igual forma te recomiendo que modifique este valor para que puedas observar el comportamiento de los resultados.

El resto de parámetros los dejaremos con sus valores por defecto, en caso de que quieras definirlos por tu cuenta lo puedes hacer sin ningún problema.

Cada uno de estos parámetros fueron explicados en el anterior video porque lo que si tienes alguna duda te recomiendo que lo revises para que puedas entender mejor esto.

Realizado todo esto ya podemos entrenar el modelo utilizando el algoritmo con los parámetros definidos y con los datos de entrenamiento definidos anteriormente.

#Entreno el modelo
bar.fit(X_train, y_train)

Seguidamente utilizamos la instrucción predict() para realizar la predicción utilizando los datos de prueba, acá lo que queremos hacer es probar que tan bien funciona el modelo que hemos desarrollado.

#Realizo una predicción
Y_pred = bar.predict(X_test)

Para ello comparemos los datos de “y” reales y los que predijo nuestro modelo. Como podemos observar existe una pequeña diferencia unos con otros, pero aún así no es tanto como hemos podido observar con otros algoritmos.

Bosques-Aleatorios-Regresión-Práctica-2-1

Grafiquemos estos datos, para ello utilizaremos el mismo truco que hicimos en el video de la práctica de Árboles de Decisión en donde adecuamos los datos para que se vean mucho mejor en nuestra grafica, para entender mejor esto te recomiendo que vayas a ese video.

Acá las líneas de código son exactamente igual a las de allá por lo que grafiquemos los datos.

#Graficamos los datos de prueba junto con la predicción
X_grid = np.arange(min(X_test), max(X_test), 0.1)
X_grid = X_grid.reshape((len(X_grid), 1))
plt.scatter(X_test, y_test)
plt.plot(X_grid, bar.predict(X_grid), color='red', linewidth=3)
plt.show()

Bosques-Aleatorios-Regresión-Práctica-3

Como podemos observar el comportamiento de la línea roja es muy parecida a las de los Árboles de Decisión, acá se tiene altos y bajos y no es una línea recta como la hemos visto en otros algoritmos.

Evaluemos entonces la precisión del algoritmo utilizando la instrucción “score”, el resultado obtenido es de 0,793, el cual es bastante aceptable.

print('DATOS DEL MODELO BOSQUES ALEATORIOS REGRESION')
print()

print('Precisión del modelo:')
print(bar.score(X_train, y_train))

Bosques-Aleatorios-Regresión-Práctica-4

Te aconsejo a que hagas modificaciones a la configuración del algoritmo para que veas el comportamiento del modelo y ver si existe mejora en el mismo o no. De esta forma puedes practicar tus conocimientos en Machine Learning.

El programa completo de este ejercicio se encuentra a continuación:

"""
Bosques Aleatorios Regresión

@author: ligdigonzalez
"""

########## LIBRERÍAS A UTILIZAR ##########

#Se importan la librerias a utilizar
import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets

########## PREPARAR LA DATA ##########

#Importamos los datos de la misma librería de scikit-learn
boston = datasets.load_boston()
print(boston)
print()

########## ENTENDIMIENTO DE LA DATA ##########

#Verifico la información contenida en el dataset
print('Información en el dataset:')
print(boston.keys())
print()

#Verifico las características del dataset
print('Características del dataset:')
print(boston.DESCR)

#Verifico la cantidad de datos que hay en los dataset
print('Cantidad de datos:')
print(boston.data.shape)
print()

#Verifico la información de las columnas
print('Nombres columnas:')
print(boston.feature_names)

########## PREPARAR LA DATA BOSQUES ALEATORIOS REGRESIÓN ##########

#Seleccionamos solamente la columna 6 del dataset
X_bar = boston.data[:, np.newaxis, 5]

#Defino los datos correspondientes a las etiquetas
y_bar = boston.target

#Graficamos los datos correspondientes
plt.scatter(X_bar, y_bar)
plt.show()

########## IMPLEMENTACIÓN DE BOSQUES ALEATORIOS REGRESIÓN ##########

from sklearn.model_selection import train_test_split

#Separo los datos de "train" en entrenamiento y prueba para probar los algoritmos
X_train, X_test, y_train, y_test = train_test_split(X_bar, y_bar, test_size=0.2)

from sklearn.ensemble import RandomForestRegressor

#Defino el algoritmo a utilizar
bar = RandomForestRegressor(n_estimators = 300, max_depth = 8)

#Entreno el modelo
bar.fit(X_train, y_train)

#Realizo una predicción
Y_pred = bar.predict(X_test)

#Graficamos los datos de prueba junto con la predicción
X_grid = np.arange(min(X_test), max(X_test), 0.1)
X_grid = X_grid.reshape((len(X_grid), 1))
plt.scatter(X_test, y_test)
plt.plot(X_grid, bar.predict(X_grid), color='red', linewidth=3)
plt.show()
#
print('DATOS DEL MODELO BOSQUES ALEATORIOS REGRESION')
print()

print('Precisión del modelo:')
print(bar.score(X_train, y_train))

 

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *