A continuación aprenderás cómo implementar el algoritmo de Árboles de Decisión 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 Árboles de Decisión 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.

Empecemos con la explicación del proyecto.

machine learning según expertos

Árboles de Decisión Regresión con Scikit Learn

aprende fácilmente inteligencia artificial - newsletter

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 Árboles de Decisión Regresión.

Al igual que con los vectores de soporte, Scikit Learn cuenta con un módulo en donde se incluye todo lo referente al algoritmo de Árboles de Decisión, por lo que para implementarlo deberás primero definir este módulo sklearn.tree. Posteriormente deberás importar la clase que en este caso será DecisionTreeRegressor.

Arboles-de-Decisión-Regresión-Scikit-Learn-1

Realizado esto ya podemos construir un modelo utilizando este algoritmo, igual que en los anteriores casos deberás crear los parámetros “X” y “y” y llamar al método fit() para realizar el entrenamiento y posteriormente la instrucción predict() para realizar una predicción.

Arboles-de-Decisión-Regresión-Scikit-Learn-2

estadísticas en machine learning

Implementación de Árboles de Decisión Regresión con Scikit Learn

A continuación están las configuraciones que ofrece el algoritmo DecisionTreeRegressor para mejorar el modelo a construir. Recuerda que toda esta información la puedes obtener con más detalle en la página web de esta instrucción, acá solamente voy a explicar la configuración más importante y la que debes considerar al momento de configurar el modelo.

Arboles-de-Decisión-Regresión-Scikit-Learn-3

Comencemos con “criterion”, te acuerdas cuando te explique en la teoría de este algoritmo que las divisiones que se le hace a los datos para crear las ramas del árbol no se hacía al azar sino que se aplicaba la suma de cuadrados residual pero que acá era computacionalmente muy costosa, bueno Scikit Learn utiliza la media del error cuadrado o “mse” por sus siglas en inglés para implementar la separación de los datos.

Por defecto se utiliza está y es la única disponible. Para la versión de Scikit Learn 0.18 se cuenta adicionalmente con el criterio de error absoluto promedio (MAE), pero puedes trabajar con la media del error cuadrado sin ningún problema.

La siguiente configuración que tenemos es “splitter”, que es la estrategia utilizada para la división en cada nodo, en esta caso se cuenta con dos opciones “best” que sería la mejor división, y “random” que elige de manera aleatoria la separación. Por defecto se encuentra seleccionada la opción “best” que por supuesto es la mejor opción.

Otro parámetro que puedes modificar es “max_depth”, que se refiere la profundidad máxima del árbol. Te acuerdas que cuando explicamos en la teoría te hable que para evitar el sobreajuste a los datos lo mejor es podar el árbol, bueno precisamente acá podrás seleccionar la profundidad del mismo. Si no se coloca ningún valor entonces 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. Si hacemos esto es muy probable que el algoritmo caiga en sobreajuste, por lo que mi recomendación acá es variar el valor y ver el que mejor se adapte.

Con estos parámetros puedes desarrollar un buen modelo utilizando el algoritmo de Árbol de Decisión Regresión. Este algoritmo cuenta con otros parámetros que pueden ser modificados pero a medida que ganes más experiencia en el desarrollo de proyectos de Machine Learning podrás implementarlos en tus proyectos.

por qué programar es tan dificil

Precisión de Regresión Lineal con Scikit Learn

Realizado todo esto solamente falta evaluar el rendimiento del algoritmo, este paso es particularmente importante para comparar qué tan bien funcionan diferentes algoritmos en un conjunto de datos particular. Para este caso utilizamos la instrucción “score” junto con los datos de pruebas, la misma nos devuelve la estadística R al cuadrado.

machine learning según expertos

Resumen de comandos Scikit Learn

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

Arboles-de-Decisión-Regresión-Scikit-Learn-4

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

Por que python para machine Learning

Definición del proyecto

En esta práctica del algoritmo de Árboles de Decisión 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, el tiempo que ha tenido ocupada y la distancia que se encuentra la misma de los centros de trabajos de Boston, siendo varias características que se tomarán en cuenta para diseñar nuestro modelo.

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.

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)
				
			

Regresión-Lineal-simple-practica-2

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)
				
			

Regresión-Lineal-simple-practica-3

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

Por que python para machine Learning

Procesamiento de los datos

Para este ejemplo vamos a implementar un predictor de Árboles de Decisión Regresión. Los datos que se utilizarán para el análisis serán los correspondientes al número de habitaciones que cuenta la vivienda, estos datos se encuentran ubicados en la columna número 6 de nuestro dataset, por lo que debemos definir esta columna a la variable “X”, en este caso vamos a utilizar “X_adr” para representar el algoritmo que estamos utilizando, Árboles de Decisión Regresión.

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

Seguidamente definimos los datos de “y” o “y_p”, para este ejemplo, los cuales serán igual a la columna de target de nuestro dataset.

				
					#Definimos los datos correspondientes a las etiquetas
y_p = boston.target

				
			

Definidas ambas variables podemos graficarlas utilizando la instrucción scatter. Como podemos observar los datos no se encuentran distribuidos de manera lineal sobre en la parte inferior izquierda por lo que perfectamente podemos utilizar el algoritmo de Regresión Polinomial.

				
					#Graficamos los datos correspondientes
plt.scatter(X_p, y_p)
plt.show()
				
			

Regresión-lineal-practica

Ahora separamos los datos de entrenamiento y prueba, para ello importamos train_test_split de la librería scikit learn y lo implementamos a nuestros datos “X_p” y “y_p”.

				
					from sklearn.model_selection import train_test_split

#Separo los datos de "train" en entrenamiento y prueba para probar los algoritmos
X_train_p, X_test_p, y_train_p, y_test_p = train_test_split(X_p, y_p, test_size=0.2)
				
			

En este punto tenemos los datos “X” y “y” 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. Lo primero que hacemos es importar el algoritmo, por lo que definimos from sklearn.tree, importamos DecisionTreeRegressor, con esto ya podemos empezar a utilizar todas las instrucciones contenida en esta librería.

				
					from sklearn.tree import DecisionTreeRegressor
				
			

Por lo cual definimos el algoritmo indicando adr será igual a DecisionTreeRegressor y procedemos a realizar la configuración respectiva al mismo.

				
					#Definimos el algoritmo a utilizar
adr = DecisionTreeRegressor(max_depth = 5)
				
			

De acuerdo a lo visto anteriormente, tanto en la teoría como en la descripción de este algoritmo en Scikit Learn, esta instrucción cuenta con varias configuraciones que pueden ser modificadas, pero acá la que mas no interesa es max_depth ya que queremos evitar un sobreajuste en el modelo por lo que debemos detener que el árbol sea muy profundo. Este valor lo puedes modificar, para nuestro ejemplo vamos a utilizar max_depth igual a 5.

Definido esto, ahora si podemos entrenar el algoritmo utilizando la instrucción fit y los datos de entrenamiento.

				
					#Entrenamos el modelo
adr.fit(X_train, y_train)
				
			

Seguidamente realizamos una predicción utilizando los datos de prueba.

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

Realizado todo esto comparemos los valores obtenidos en nuestra predicción con los valores reales, para ver que tal es el comportamiento de nuestro modelo.

Arboles-de-Decisión-Regresión-Practica-2

importancia de las matemáticas en machine learning

Análisis de los resultados

Como puedes observar en el recuadro anterior tenemos los datos reales mientras que en este otro están los datos obtenidos de nuestra predicción implementando el modelo. Si observamos con detenimiento estos datos nos podemos dar cuenta que en ciertos momentos los datos reales son muy parecidos con los datos que se han calculados mientras que en otros casos los datos son totalmente distintos.

Visualicemos los datos de entrenamiento junto con el modelo, para ello vamos a requerir hacer un pequeño truco para que de esta forma el modelo se grafique de manera adecuada.

				
					#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, adr.predict(X_grid), color='red', linewidth=3)
				
			

Lo primero que vamos hacer es utilizar la instrucción arange para espaciar de manera uniforme los datos, el intervalo a utilizar será el valor mínimo y máximo de los datos de prueba y los pasos para el espaciado será de 0.1.

Una vez realizado esto, procedemos a utilizar la instrucción reshape para darle una nueva forma a la matriz de los datos y de esta forma puedan ser graficados.

Finalizado esto ya podemos graficar los datos pero ahora deberemos utilizar los datos X_grid y su respectiva predicción.

Arboles-de-Decisión-Regresión-Practica-3

Como podemos observar acá el modelo no es una línea recta como la habiamos visto en los anteriores algoritmos, acá podemos observar que el modelo cuenta con subidas y bajadas.

Pero ahora veamos que tal es la precisión del mismo utilizando la instrucción score. El resultado obtenido acá es de 0,669.

				
					print('DATOS DEL MODELO ÁRBOLES DE DECISIÓN REGRESION')
print()

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

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.

por qué programar es tan dificil

Programa completo

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

				
					"""
Árboles de Decisión Regresión
"""

########## 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 ÁRBOLES DE DECISIÓN REGRESIÓN ##########

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

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

#Graficamos los datos correspondientes
plt.scatter(X_adr, y_adr)
plt.show()

########## IMPLEMENTACIÓN DE ÁRBOLES DE DECISIÓN 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_adr, y_adr, test_size=0.2)

from sklearn.tree import DecisionTreeRegressor

#Defino el algoritmo a utilizar
adr = DecisionTreeRegressor(max_depth = 5)

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

#Realizo una predicción
Y_pred = adr.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, adr.predict(X_grid), color='red', linewidth=3)
plt.show()

print('DATOS DEL MODELO ÁRBOLES DE DECISIÓN REGRESION')
print()

print('Precisión del modelo:')
print(adr.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 “Árboles de Decisión Regresión – Práctica con Python”

Deja un comentario

Tu dirección de correo electrónico no será publicada.