Tutorial ScikitLearn: Regresión con árboles DecisionTreeRegressor

Introducción teórica a los árboles de decisión para regresión

Los árboles de decisión son modelos de aprendizaje supervisado utilizados tanto para tareas de clasificación como de regresión. En el caso de la regresión, el objetivo de un árbol de decisión es predecir un valor continuo basado en las características de entrada. El modelo divide recursivamente el espacio de datos en subregiones más pequeñas, ajustando una predicción constante (promedio de los valores en esa región) en cada nodo hoja.

En lugar de categorías, como ocurre en clasificación, los nodos hoja en un árbol de regresión contienen valores numéricos. Cada nodo interno del árbol realiza una prueba sobre una característica, dividiendo el conjunto de datos en dos grupos de acuerdo con un umbral. Este proceso de división se conoce como particionamiento recursivo binario y se optimiza minimizando un criterio de error, como el error cuadrático medio (MSE).

Proceso de crecimiento del árbol:

• Selección de divisiones: El modelo elige, en cada nodo, la característica y el umbral que minimizan el error dentro de las subregiones resultantes.
• Parada del crecimiento: Para evitar el sobreajuste, el crecimiento del árbol se detiene según condiciones predefinidas, como alcanzar un número máximo de niveles (profundidad) o un número mínimo de muestras por nodo.
• Promedio en nodos hoja: En cada hoja, el valor predicho corresponde al promedio de los valores objetivo de las muestras presentes en esa hoja.

Los árboles de decisión para regresión tienen ventajas clave, como su capacidad para capturar relaciones no lineales entre las variables y su interpretabilidad. Sin embargo, presentan limitaciones como el riesgo de sobreajuste y la inestabilidad ante cambios en los datos de entrenamiento.

DecisionTreeRegressor

En Scikit Learn, la clase DecisionTreeRegressor implementa árboles de decisión para tareas de regresión. Es un modelo basado en nodos jerárquicos donde cada nodo interno divide el espacio de datos en dos subgrupos basándose en un umbral, y cada nodo hoja representa un valor continuo predicho. Este enfoque permite modelar relaciones complejas entre las características de entrada y el valor objetivo, capturando tanto patrones lineales como no lineales en los datos.

El DecisionTreeRegressor funciona dividiendo los datos en segmentos que minimizan la variación dentro de cada grupo. En cada nodo hoja, el modelo asigna el valor promedio de las observaciones presentes en ese nodo como la predicción para cualquier nueva muestra que caiga en ese grupo.

Ventajas del modelo:

• Capacidad para capturar relaciones no lineales entre las variables.
• Interpretabilidad a través de visualizaciones y reglas de decisión claras.
• Adaptabilidad a datos heterogéneos (puede manejar tanto variables categóricas como numéricas).

Ejemplo de uso:

from sklearn.tree import DecisionTreeRegressor

# Crear una instancia del modelo
arbol_regresor = DecisionTreeRegressor()

# Ajustar el modelo a los datos de entrenamiento
arbol_regresor.fit(X_train, y_train)

# Predecir valores para datos nuevos
y_pred = arbol_regresor.predict(X_test)

En este ejemplo:

• X_train representa las características de entrenamiento, es decir, las variables independientes que el modelo utilizará para aprender las relaciones.
• y_train contiene los valores objetivo continuos (la variable dependiente).
• X_test representa las nuevas observaciones para las cuales se quieren realizar predicciones.

El DecisionTreeRegressor también ofrece varios atributos y métodos útiles que permiten analizar el modelo y evaluar su rendimiento:

1. feature_importances_: Este atributo permite identificar las variables más relevantes para las decisiones del árbol. Es útil para entender qué variables tienen un mayor impacto en las predicciones.

import pandas as pd

# Obtener la importancia de las características
importancias = pd.DataFrame({
    'Característica': X_train.columns,
    'Importancia': arbol_regresor.feature_importances_
}).sort_values(by='Importancia', ascending=False)

print(importancias)

2.   Visualización del árbol: Utilizando plot_tree o herramientas como Graphviz, es posible generar diagramas que muestran las reglas de división del árbol, facilitando la interpretación del modelo.

3.   Predicción para muestras individuales: Se puede rastrear cómo el modelo toma decisiones para un dato específico mediante el camino de nodos que recorre en el árbol.

4.   Evaluación del rendimiento: Métricas como el error cuadrático medio (MSE) o el coeficiente de determinación (R²) permiten medir la precisión del modelo en conjunto de prueba.

from sklearn.metrics import mean_squared_error, r2_score

mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

print(f"MSE: {mse}")
print(f"R²: {r2}")

El DecisionTreeRegressor es una herramienta poderosa, especialmente cuando se ajusta correctamente mediante la selección de hiperparámetros apropiados, como la profundidad máxima del árbol o el número mínimo de muestras por nodo hoja. Esto asegura un balance entre un modelo lo suficientemente complejo para capturar los patrones en los datos y suficientemente simple para generalizar bien en datos nuevos.

Parámetros de DecisionTreeRegressor

El DecisionTreeRegressor ofrece varios hiperparámetros que controlan el crecimiento y el comportamiento del modelo. La configuración adecuada de estos hiperparámetros es esencial para mejorar el rendimiento y evitar problemas como el sobreajuste.

• criterion: Define la función para medir la calidad de una división.
  • Valores disponibles: squared_error (default, minimiza el error cuadrático medio), friedman_mse (optimización basada en el gradiente), y absolute_error (minimiza el error absoluto).
• splitter: Estrategia para elegir la división en cada nodo.
  • Valores posibles: best (elige la mejor división) y random (elige una división aleatoria dentro de un subconjunto).
• max_depth: Límite para la profundidad del árbol.
  • Controla el número máximo de niveles en el árbol. Limitarlo ayuda a prevenir el sobreajuste.
• min_samples_split: Número mínimo de muestras necesarias para dividir un nodo interno.
  • Por defecto: 2. Valores mayores reducen la complejidad del modelo.
• min_samples_leaf: Número mínimo de muestras que debe tener un nodo hoja.
  • Previene nodos hoja demasiado pequeños y mejora la generalización.
• max_features: Límite en el número de características evaluadas para la mejor división.
  • Valores comunes: auto, sqrt, log2 o un valor entero/específico.
• random_state: Controla la aleatoriedad del modelo para asegurar reproducibilidad.
• ccp_alpha: Parámetro de poda basado en coste-complejidad.
  • Ayuda a simplificar el árbol eliminando ramas que no contribuyen significativamente.

Ejemplo de configuración avanzada:

regresor = DecisionTreeRegressor(
    criterion='squared_error',
    splitter='best',
    max_depth=10,
    min_samples_leaf=5,
    max_features='sqrt',
    random_state=42,
    ccp_alpha=0.01
)

Interpretabilidad de los árboles de decisión para regresión en Scikit Learn

La interpretabilidad es una de las fortalezas principales de los árboles de decisión. En tareas de regresión, los árboles dividen el espacio de datos en subregiones donde se predice un valor constante (el promedio de los valores objetivo en esa región). Esto permite rastrear cómo el modelo toma decisiones basadas en las características.

Visualización del árbol

Scikit Learn proporciona la función plot_tree para visualizar la estructura de un árbol entrenado.

from sklearn.tree import plot_tree
import matplotlib.pyplot as plt

# Visualizar el árbol
plt.figure(figsize=(15, 10))
plot_tree(regresor, feature_names=X_train.columns, filled=True)
plt.show()

Ejemplo: Predicción de precios de casas

Consideremos un dataset de propiedades inmobiliarias donde queremos predecir el precio de las viviendas basado en características como el número de habitaciones, superficie y ubicación. El dataset de este ejemplo puede descargarse desde Kaggle.

Paso 1: Entrenamiento del modelo

regresor.fit(X_train, y_train)

Paso 2: Visualizar las divisiones

Cada nodo del árbol muestra las reglas de división, el valor promedio predicho y el número de muestras en el nodo. Para visualizar el árbol:

from sklearn.tree import plot_tree
import matplotlib.pyplot as plt

plt.figure(figsize=(15, 10))
plot_tree(regresor, feature_names=X_train.columns, filled=True)
plt.show()

Paso 3: Evaluar la importancia de las características

Identificar qué variables tienen mayor impacto en el modelo:

import pandas as pd

importancias = pd.DataFrame({
    'Característica': X_train.columns,
    'Importancia': regresor.feature_importances_
}).sort_values(by='Importancia', ascending=False)

print(importancias)

Paso 4: Evaluación del modelo

Calcular métricas como el error cuadrático medio (MSE) y el coeficiente de determinación (R²):

from sklearn.metrics import mean_squared_error, r2_score

y_pred = regresor.predict(X_test)

mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

print(f"MSE: {mse}")
print(f"R²: {r2}")

Paso 5: Interpretación de los resultados

Por ejemplo, el modelo puede predecir que viviendas con más de 100 m² y menos de 2 baños tienen un precio promedio de 300,000 €. Cada nodo hoja representa un grupo de propiedades con características similares y su precio promedio.

Código completo:

import pandas as pd
from sklearn.tree import DecisionTreeRegressor, plot_tree
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score
import matplotlib.pyplot as plt

# Cargar el dataset desde un archivo local
data = pd.read_csv("./idealista_madrid.csv")

# Preprocesamiento de datos
# Selección de características relevantes
X = data[['rooms', 'sqft', 'baths', 'typology']]
y = data['price']

# Codificar variables categóricas
X = pd.get_dummies(X, columns=['typology'], drop_first=True)

# Dividir en conjuntos de entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Crear y entrenar el modelo
regresor = DecisionTreeRegressor(max_depth=5, random_state=42, ccp_alpha=0.01)
regresor.fit(X_train, y_train)

# Visualización del árbol
plt.figure(figsize=(15, 10))
plot_tree(regresor, feature_names=X_train.columns, filled=True)
plt.show()

# Importancia de características
importancias = pd.DataFrame({
    'Característica': X_train.columns,
    'Importancia': regresor.feature_importances_
}).sort_values(by='Importancia', ascending=False)

print(importancias)

# Evaluación del modelo
y_pred = regresor.predict(X_test)

mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

print(f"MSE: {mse}")
print(f"R²: {r2}")

Este código incluye la carga, preprocesamiento, entrenamiento y evaluación de un modelo de regresión basado en árboles de decisión utilizando datos inmobiliarios. Con las herramientas de visualización y análisis, es posible interpretar y mejorar el modelo.

Con estas herramientas, es posible explicar las decisiones del modelo y validar si se alinean con el conocimiento del dominio o los datos disponibles. Además, las visualizaciones y análisis ayudan a identificar posibles mejoras en el modelo, como la selección de características más relevantes o el ajuste de hiperparámetros.

Ejemplo

Sobre el dataset mpg para predecir el consumo de combustible de un coche:

import pandas as pd
import seaborn as sns
from sklearn.tree import DecisionTreeRegressor
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_absolute_error, mean_absolute_percentage_error, root_mean_squared_error, r2_score
from sklearn.tree import export_text
import matplotlib.pyplot as plt
from sklearn import tree

df = sns.load_dataset('mpg')

features = ['weight', 'cylinders']
X = df[features]
y = df['mpg']

X_train, X_test, y_train, y_test = train_test_split(X, y,test_size=0.2,random_state=42)

model = DecisionTreeRegressor(max_depth=2)
model.fit(X_train, y_train)

y_pred = model.predict(X_test)

mae = mean_absolute_error(y_test, y_pred)
rmse = root_mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)
mape = mean_absolute_percentage_error(y_test, y_pred)

print(f"R^2: {r2:.2f}")
print(f"MAE: {mae:.2f}")
print(f"RMSE: {rmse:.2f}")
print(f"MAPE: {mape:.2f}")

tree_regression_rules = export_text(model, feature_names=features)
print(tree_regression_rules)

plt.figure(figsize=(10,6))
tree.plot_tree(model,
               feature_names=features,
               filled=True)
plt.show()
# El árbol ordena los valores únicos de la variable, genera candidatos a puntos de corte entre 
# valores contiguos, y prueba cada uno para ver cuál produce la mejor 
# partición en ese paso. Así, encuentra el mejor umbral sin tener que examinar literalmente cada valor posible en el rango continuo.