Bosques Aleatorios Regresión – Práctica con Python

A continuación aprenderás cómo implementar el algoritmo de Bosques Aleatorios Regresión utilizando la librería de Python Scikit Learn, tomando en cuenta cada uno de los parámetros que debes considerar para ajustar y mejorar tus resultados. 

Posteriormente desarrollaremos un proyecto de Machine Learning enfocándonos en el algoritmo de Bosques Aleatorios Regresión . Cada una de las explicaciones dadas acá será paso a paso para que puedas entender con detalle cada uno de los métodos explicados acá y que los puedas implementar en tus propios proyectos.

machine learning según expertos

Bosques Aleatorios Regresión con Scikit Learn

Si aún no lo sabes, Scikit Learn es una de las más grandes librerías de Machine Learning con la que cuenta Python, pero no solamente eso, es de las más utilizadas al momento de crear los modelos implementando los algoritmos de Machine Learning, por estas razones es muy importante que aprendas a trabajar con ella si apenas te estás iniciando.

Veamos cómo se puede utilizar esta librería para implementar el algoritmo de Bosques Aleatorios Regresión.

Este algoritmo se encuentra dentro de los métodos de ensamblado de Machine Learning, por lo que deberemos primeramente importar el módulo sklearn.ensemble y posteriormente especificar RandomForestRegressor para poder implementar este algoritmo. Si te fijas todos los algoritmos que caen dentro de la categoría de métodos de ensamblado se encuentran dentro de este módulo en Scikit Learn, por lo que cada vez que vayas a utilizar alguno de ellos deberás importar este módulo y posteriormente definir el método a utilizar.

https://flic.kr/p/2dgaZh

Bosques-Aleatorios-Regresión-Scikit-Learn-4

Realizado esto ya podemos implementar este algoritmo en nuestro programa. Igual que los anteriores algoritmos, con esta instrucción se deberá definir las variables “x” y “y” para implementar la instrucción fit() para entrenar el modelo y predict() para realizar una predicción.

Bosques-Aleatorios-Regresión-Scikit-Learn-5

Toda la información para implementar esta librería la pueden encontrar directamente en la página web, por lo que si tenemos alguna duda en la implementación de las instrucciones solamente tenemos que leer esta información.

estadísticas en machine learning

Implementación de Vectores de Soporte Regresión con Scikit Learn

Enfoquémonos a verificar las características que podemos modificar dentro del algoritmo de Bosques Aleatorios, recuerda que si quieres obtener información adicional al respecto siempre puedes dirigirte a la página de la librería en donde obtendrás una información más completa.

Comencemos con n_estimators, en donde indicamos el número de árboles que tendrá el bosque. Recuerda que un mayor número de árboles aumenta el rendimiento y hace que las predicciones sean más estables, pero también vuelve lento el cálculo. En caso de que no lo modifiquemos, este valor es de 10, por defecto.

Bosques-Aleatorios-Regresión-Scikit-Learn-7

El siguiente parámetro es criterion, esto fue explicado en el algoritmo de Árboles de Decisión, y acá aplica la misma explicación. Scikit Learn utiliza la media del error cuadrado o “mse” por sus siglas en inglés para implementar la separación de los datos para los Árboles de Decisión a construir, si quieres profundizar más sobre este tema, te recomiendo que revises la información de los Árboles de Decisión.

Bosques-Aleatorios-Regresión-Scikit-Learn-8

Otro parámetro que viene también relacionado a los Árboles de Decisión es max_depth, que se refiere a la profundidad del árbol, si no se especifica este valor el algoritmo selecciona de manera automática los nodos de manera que los expande hasta que todas las hojas estén puras o hasta que todas las hojas contienen menos datos.

Bosques-Aleatorios-Regresión-Scikit-Learn-9

El siguiente parámetro que explicaremos es el de max_features, en este se define el número máximo de características que el Bosque Aleatorio puede probar en un árbol individual. Scikit Learn ofrece varias opciones como utilizar todas las características, o solamente una fracción de ellas, e inclusive puedes definir utilizar la raíz cuadrada del número de características. A nivel práctica puedes probar con varios de estos valores para ver con cual obtienes un mejor resultado.

Bosques-Aleatorios-Regresión-Scikit-Learn-10

Estas son solo algunas de los parámetros que puedes modificar en el algoritmo de Bosques Aleatorios, existen otros que puedes revisar en la página oficial, pero estos son los más importantes.

por qué programar es tan dificil

Precisión de Regresión Lineal con Scikit Learn

Una vez realizada la configuración del algoritmo, haber entrenado el modelo y a su realizado una predicción ahora debemos verificar la precisión del mismo, para ello utilizamos la instrucción “score”, esta es la misma instrucción que hemos utilizado con los otros algoritmos y devuelve la estadística al cuadrado.

machine learning según expertos

Resumen de comandos Scikit Learn

En resumen, los comandos a utilizar para implementar un algoritmo de Bosques Aleatorios Regresión serían los siguientes:

bosques regresión 1

Sabiendo cómo implementar el algoritmo de Bosques Aleatorios Regresión con la librería de Scikit Learn, ha llegado el momento de desarrollar un proyecto práctico.

inteligencia artificial con aprendeIA

Definición del proyecto

En esta práctica del algoritmo de Bosques Aleatorios Regresión, se desarrollará un modelo para predecir el precio de las casas en Boston de acuerdo al número de habitaciones que cuenta la vivienda.

Para este análisis vamos a utilizar el dataset disponible en la librería scikit-learn correspondiente al Boston Housing o las casas de BostonSi no lo sabías dentro de la librería sckit-learn se dispone de varios conjuntos de datos, muy básicos, con los que puedes practicar tus conocimientos de Machine Learning, no son muchos, pero cubre los principales tipos de algoritmos como regresión y clasificación.

El algoritmo específico que se utilizará será Bosques Aleatorios Regresión.

usos de la inteligencia artificial en la vida cotidiana

Obtener los de datos

El primer paso que daremos será el de importar las librerías que vamos utilizar, en especial las necesarias para importar los datos que utilizaremos.

En este caso vamos a importar de sklearn el datasets, que es donde se guardan todos los conjuntos de datos que dispone esta librería y a su vez importamos de una vez linear_model.

				
					#Se importan la librerias a utilizar
from sklearn import datasets, linear_model
				
			

Seguidamente importamos los datos, para ello utilizamos la instrucción datasets.load_boston().

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

Tenemos mucha información dentro de esta variable lo que se nos hace difícil entender la información, por lo tanto, ahora procedemos a entender la data.

aprender a programar para machine Learning 1

Entender los datos

Para entender los datos que estaremos utilizando el proyecto nos vamos a valor de varias instrucciones propias de Python y así verificar la información contenida en el conjunto de datos que acabamos de importar. Para este fin utilizamos la instrucción keys.

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

Regresión-Lineal-simple-practica-1

Como puedes observar el conjunto de datos cuenta con la siguiente información: primeramente, la data, seguidamente target que sería la columna con las etiquetas o respuestas, posteriormente tenemos feature_names que serían los nombres de cada una de las columnas de la data y finalmente tenemos DESCR que sería la descripción total del dataset.

Sabiendo ya esto podemos ahora utilizar estos nombres para entender mejor los datos, lo primero que vamos a hacer es utilizar DESCR para ver las características del dataset.

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

Como puedes leer en la descripción este dataset cuenta con 506 datos y 13 atributos, la columna 14 es el target y es la media del valor de las viviendas.

Seguidamente tenemos la descripción del significado de cada una de las columnas o atributos de los datos. De igual forma, nos indica un dato importante para nuestro análisis y es que indica que no existe ningún valor perdido, en consecuencia, nuestros datos están completos por lo que no es necesario realizar mucho preprocesamiento a los datos.

Ahora utilizaremos la instrucción shape para determinar la cantidad de datos contamos, aunque este es un paso de más ya que esta información nos la había dado previamente la descripción del dataset, pero de todas formas lo hacemos.

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

https://flic.kr/p/2eBkSXY

Como ya nos lo visto anteriormente este conjunto de datos cuenta con 506 muestras y 13 columnas.

Finalmente veamos las etiquetas de cada columna para ello utilizamos feature_names.

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

https://flic.kr/p/2eBkTsA

Sabiendo toda esta información entonces procedemos a preparar los datos que vamos a utilizar para crear el modelo.

inteligencia artificial con aprendeIA

Procesamiento de los datos

Lo primero que debemos hacer es separar los datos en “X” y “y”, a estas variables las vamos a llamar X_svr y y_svr, la primera será igual a la columna 6 del dataset que previamente procesamos, por su parte y_svr será igual a la columna de target.
				
					#Seleccionamos solamente la columna 6 del dataset
X_svr = boston.data[:, np.newaxis, 5]

#Definimos los datos correspondientes a las etiquetas
y_svr = boston.target
				
			
Grafiquemos estos datos para observar con más detalle los datos que estaremos manejando.
				
					#Graficamos los datos correspondientes
plt.scatter(X_svr, y_svr)
plt.show()
				
			

maquina-de-vectores-de-soporte-regresión-práctica-con-python

Como podemos observar estos datos tienen un comportamiento lineal, por lo que acá implementaremos el algoritmo de Vectores de Soporte Regresión, con un kernel línea, de la misma forma que lo explicamos en la teoría.

Procedemos ahora a separar los datos en entrenamiento y prueba, para ello utilizamos la instrucción train_test_split.

				
					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_svr, y_svr, test_size=0.2)

				
			

Con esto ya tenemos nuestros datos divididos en datos de entrenamiento y prueba.

Qué son las Redes Neuronales Artificiales

Desarrollo del algoritmo

Con los datos separados en entrenamiento y prueba ha llegado el momento de construir el modelo de Machine Learning, por lo que el siguiente paso que debemos hacer es importar el módulo 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.

				
					#Definimos 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.

				
					#Entrenamos 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.

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

Para ello comparemos los datos de “y” reales y los que predijo nuestro modelo.

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

inteligencia artificial con aprendeia

Análisis de los resultados

Como puedes observar en el recuadro anterior existe una pequeña diferencia unos con otros, pero aún así no es tanto como hemos podido observar con otros algoritmos.

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.

por qué programar es tan dificil

Programa completo

A continuación se encuentra el código completo:

				
					"""
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))
				
			

Si te llamo la atención todo este contenido y te animaste a empezar a estudiar Inteligencia Artificial, he desarrollado un curso que te ayudará, de igual forma a iniciar tu camino dentro de está tecnología. Este curso te sentará las bases y te dará más claridad para poder seleccionar el enfoque o área que más te interese sobre la Inteligencia Artificial, de igual forma te ayudará tener más claridad en muchos conceptos que seguramente en estos momentos te parece confusos. Este curso es ideal si apenas estás empezando. Si quieres más información puedes ingresar a este enlace.

2 comentarios en “Bosques Aleatorios Regresión – Práctica con Python”

Deja un comentario

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