S10L02 – Implementación de Árbol de Decisión – 1 característica

html
Dominando la Regresión con Árboles de Decisión con Scikit-Learn: Una Guía Integral

En el panorama en constante evolución del aprendizaje automático, los árboles de decisión destacan como modelos versátiles e intuitivos para tareas de clasificación y regresión. Ya seas un entusiasta de la ciencia de datos o un profesional experimentado, comprender cómo implementar y optimizar los árboles de decisión es esencial. En esta guía, profundizaremos en la regresión con árboles de decisión utilizando Scikit-Learn, aprovechando ejemplos prácticos y conjuntos de datos del mundo real para solidificar tu comprensión.

Tabla de Contenidos

	Introducción a los Árboles de Decisión
	Comprendiendo la Estructura del Árbol de Decisión
	Implementando la Regresión con Árboles de Decisión en Python
	Ajuste de Hiperparámetros: El Rol de Max Depth
	Visualizando Árboles de Decisión
	Evaluando el Rendimiento del Modelo
	Desafíos y Limitaciones
	Conclusión
	Lecturas Adicionales




Introducción a los Árboles de Decisión

Los árboles de decisión son un componente fundamental del aprendizaje automático, apreciados por su simplicidad e interpretabilidad. Imita los procesos de toma de decisiones humanas, descomponiendo decisiones complejas en una serie de elecciones más simples y binarias. Esto los hace particularmente útiles para tareas de clasificación (categorización de datos) y regresión (predicción de valores continuos).

¿Por Qué Usar Árboles de Decisión?


	Interpretabilidad: Fácil de visualizar y entender.
	No Paramétrico: Sin suposiciones sobre la distribución de los datos.
	Versatilidad: Aplicable a diversos tipos de datos y problemas.


Sin embargo, como todos los modelos, los árboles de decisión vienen con su propio conjunto de desafíos, como el sobreajuste y la complejidad computacional, que exploraremos más adelante en esta guía.

Comprendiendo la Estructura del Árbol de Decisión

En el corazón de un árbol de decisión se encuentra su estructura, que comprende nodos y ramas:


	Nodo Raíz: El nodo más alto que representa todo el conjunto de datos.
	Nodos Internos: Representan puntos de decisión basados en valores de características.
	Nodos Hoja: Representan la salida final o la predicción.


Conceptos Clave


	Profundidad del Árbol: La ruta más larga desde la raíz hasta un nodo hoja. La profundidad de un árbol puede impactar significativamente su rendimiento.
	Max Depth: Un hiperparámetro que limita la profundidad del árbol para prevenir el sobreajuste.
	Subajuste y Sobreajuste:
		
			Subajuste: Cuando el modelo es demasiado simple (por ejemplo, max depth establecido demasiado bajo), no logra capturar los patrones subyacentes.
			Sobreajuste: Cuando el modelo es demasiado complejo (por ejemplo, max depth establecido demasiado alto), captura ruido en los datos de entrenamiento, reduciendo su capacidad de generalización.
		
	


Implementando la Regresión con Árboles de Decisión en Python

Vamos a través de un ejemplo práctico utilizando DecisionTreeRegressor de Scikit-Learn. Usaremos el conjunto de datos "Ingreso per cápita de Canadá" para predecir el ingreso en función del año.

Paso 1: Importación de Bibliotecas





		
		
			
			
Java
			
			import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeRegressor
from sklearn.metrics import r2_score

sns.set()
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeRegressor
from sklearn.metrics import r2_score
 
sns.set()
					
				
			
		



Paso 2: Cargando el Conjunto de Datos





		
		
			
			
Java
			
			# Fuente del Conjunto de Datos: https://www.kaggle.com/gurdit559/canada-per-capita-income-single-variable-data-set
data = pd.read_csv('canada_per_capita_income.csv')
X = data.iloc[:, :-1]
Y = data.iloc[:, -1]
			
				
					
				
					1
2
3
4
				
						# Fuente del Conjunto de Datos: https://www.kaggle.com/gurdit559/canada-per-capita-income-single-variable-data-set
data = pd.read_csv('canada_per_capita_income.csv')
X = data.iloc[:, :-1]
Y = data.iloc[:, -1]
					
				
			
		



Paso 3: Análisis Exploratorio de Datos





		
		
			
			
Java
			
			print(data.head())

# Visualizando los Datos
sns.scatterplot(data=data, x='per capita income (US$)', y='year')
plt.show()
			
				
					
				
					1
2
3
4
5
				
						print(data.head())
 
# Visualizando los Datos
sns.scatterplot(data=data, x='per capita income (US$)', y='year')
plt.show()
					
				
			
		



Salida:




		
		
			
			
Java
			
			   year  per capita income (US$)
0  1970              3399.299037
1  1971              3768.297935
2  1972              4251.175484
3  1973              4804.463248
4  1974              5576.514583
			
				
					
				
					1
2
3
4
5
6
				
						   year  per capita income (US$)
0  1970              3399.299037
1  1971              3768.297935
2  1972              4251.175484
3  1973              4804.463248
4  1974              5576.514583
					
				
			
		




Paso 4: Dividiendo los Datos





		
		
			
			
Java
			
			X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.20, random_state=1)
			
				
					
				
					1
				
						X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.20, random_state=1)
					
				
			
		



Paso 5: Construyendo y Entrenando el Modelo





		
		
			
			
Java
			
			model = DecisionTreeRegressor()
model.fit(X_train, y_train)
			
				
					
				
					1
2
				
						model = DecisionTreeRegressor()
model.fit(X_train, y_train)
					
				
			
		



Paso 6: Realizando Predicciones





		
		
			
			
Java
			
			y_pred = model.predict(X_test)
print(y_pred)
			
				
					
				
					1
2
				
						y_pred = model.predict(X_test)
print(y_pred)
					
				
			
		



Salida:




		
		
			
			
Java
			
			[15875.58673  17266.09769  37446.48609  25719.14715   3768.297935
 5576.514583 16622.67187  18601.39724  41039.8936   16369.31725 ]
			
				
					
				
					1
2
				
						[15875.58673  17266.09769  37446.48609  25719.14715   3768.297935
 5576.514583 16622.67187  18601.39724  41039.8936   16369.31725 ]
					
				
			
		



Ajuste de Hiperparámetros: El Rol de Max Depth

Uno de los hiperparámetros clave en los árboles de decisión es max_depth, que controla la profundidad máxima del árbol.

Impacto de Max Depth


	Profundidad Máxima Baja (por ejemplo, 1):
		
			Ventajas: Simplicidad, menor riesgo de sobreajuste.
			Desventajas: Potencial subajuste, bajo rendimiento en datos complejos.
			Ejemplo: Establecer max_depth=1 podría resultar en que el modelo solo considere si el fin de semana determina jugar al bádminton, ignorando otros factores como el clima.
		
	
	Profundidad Máxima Alta (por ejemplo, 25):
		
			Ventajas: Capacidad para capturar patrones complejos.
			Desventajas: Mayor riesgo de sobreajuste, tiempos de entrenamiento más largos.
			Ejemplo: Un max_depth de 25 puede llevar al modelo a volverse excesivamente complejo, capturando ruido en lugar de la distribución subyacente.
		
	


Encontrando la Profundidad Máxima Óptima

La profundidad máxima óptima equilibra el sesgo y la varianza, asegurando que el modelo se generalice bien a datos no vistos. Técnicas como la validación cruzada pueden ayudar a determinar el mejor valor.





		
		
			
			
Java
			
			# Ejemplo: Estableciendo max_depth a 10
model = DecisionTreeRegressor(max_depth=10)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print(r2_score(y_test, y_pred))
			
				
					
				
					1
2
3
4
5
				
						# Ejemplo: Estableciendo max_depth a 10
model = DecisionTreeRegressor(max_depth=10)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print(r2_score(y_test, y_pred))
					
				
			
		



Salida:




		
		
			
			
Java
			
			0.9283605684543206
			
				
					
				
					1
				
						0.9283605684543206
					
				
			
		



Una puntuación R² de aproximadamente 0.92 indica un ajuste fuerte, pero es esencial validar esto con diferentes profundidades y validación cruzada.

Visualizando Árboles de Decisión

La visualización ayuda a comprender cómo el árbol de decisión realiza predicciones.

Visualizando el Modelo


	Importancia de las Características: Determina qué características considera más el árbol.
		



		
		
			
			
Java
			
			feature_importances = model.feature_importances_
print(feature_importances)
			
				
					
				
					1
2
				
						feature_importances = model.feature_importances_
print(feature_importances)
					
				
			
		


	
	Estructura del Árbol: Muestra la estructura del árbol usando plot_tree de Scikit-Learn.
		



		
		
			
			
Java
			
			from sklearn import tree

plt.figure(figsize=(12,8))
tree.plot_tree(model, filled=True, feature_names=X.columns, rounded=True)
plt.show()
			
				
					
				
					1
2
3
4
5
				
						from sklearn import tree
 
plt.figure(figsize=(12,8))
tree.plot_tree(model, filled=True, feature_names=X.columns, rounded=True)
plt.show()
					
				
			
		


	




Asignación Práctica


	Visualizar el Modelo: Usa plot_tree para visualizar cómo se realizan las divisiones de decisión.
	Mostrar el Árbol de Decisión Directamente: Interpreta el árbol para entender las decisiones de las características.
	Explorar Más: Visita el Ejemplo de Regresión con Árboles de Decisión de Scikit-Learn para una comprensión más profunda.


Evaluando el Rendimiento del Modelo

Evaluar el rendimiento del modelo es crucial para garantizar su fiabilidad.





		
		
			
			
Java
			
			from sklearn.metrics import r2_score

r2 = r2_score(y_test, y_pred)
print(f"R² Score: {r2:.2f}")
			
				
					
				
					1
2
3
4
				
						from sklearn.metrics import r2_score
 
r2 = r2_score(y_test, y_pred)
print(f"R² Score: {r2:.2f}")
					
				
			
		



Salida:




		
		
			
			
Java
			
			R² Score: 0.93
			
				
					
				
					1
				
						R² Score: 0.93
					
				
			
		



Una puntuación R² cercana a 1 indica que el modelo explica una alta proporción de la varianza en la variable objetivo.

Desafíos y Limitaciones

Si bien los árboles de decisión son potentes, vienen con ciertas desventajas:


	Sobreajuste: Los árboles profundos pueden capturar ruido, reduciendo la capacidad de generalización.
	Complejidad Temporal: El tiempo de entrenamiento aumenta con el tamaño del conjunto de datos y la dimensionalidad de las características.
	Complejidad Espacial: Almacenar árboles grandes puede consumir una memoria significativa.
	Sesgo con Datos Categóricos: Los árboles de decisión pueden tener dificultades con variables categóricas de alta cardinalidad.


Abordando las Limitaciones


	Podado: Limitar la profundidad del árbol y eliminar ramas que tienen poco poder para predecir las variables objetivo.
	Métodos de Ensemble: Técnicas como Random Forests o Gradient Boosting pueden mitigar el sobreajuste y mejorar el rendimiento.
	Ingeniería de Características: Reducir la dimensionalidad de las características y codificar variables categóricas de manera efectiva.


Conclusión

La regresión con árboles de decisión es una técnica fundamental en el aprendizaje automático, que ofrece simplicidad e interpretabilidad. Al comprender su estructura, optimizar hiperparámetros como max_depth, y abordar sus limitaciones, puedes aprovechar todo su potencial. Ya sea que estés prediciendo niveles de ingresos, precios de viviendas u cualquier variable continua, los árboles de decisión proporcionan un punto de partida robusto.

Lecturas Adicionales


	Documentación de Árboles de Decisión de Scikit-Learn
	Comprendiendo el Sesgo y la Varianza
	Métodos de Ensemble en el Aprendizaje Automático




Abraza el poder de los árboles de decisión en tu conjunto de herramientas de ciencia de datos y continúa explorando temas avanzados para elevar tus modelos a nuevas alturas.