Tutorial ScikitLearn: Regresión con algoritmos de conjunto

Introducción a los algoritmos de conjunto para regresión

Los algoritmos de conjunto (ensemble methods) son técnicas que combinan múltiples modelos básicos para mejorar la capacidad predictiva y la robustez de los modelos de regresión. Estos métodos buscan reducir el sesgo y la varianza de las predicciones al aprovechar las fortalezas de diversos modelos y compensar sus debilidades individuales.

En el contexto de regresión, los algoritmos de conjunto permiten obtener estimaciones más precisas al combinar los resultados de varios modelos base, como árboles de decisión o regresiones lineales. Algunas de las técnicas más comunes en los algoritmos de conjunto son:

• Bagging (Bootstrap Aggregating): Consiste en entrenar múltiples modelos en subconjuntos diferentes de los datos de entrenamiento, seleccionados mediante muestreo con reemplazo. Las predicciones finales se obtienen promediando las predicciones individuales de cada modelo.
• Boosting: Esta técnica entrena secuencialmente una serie de modelos, donde cada modelo intenta corregir los errores de los modelos anteriores. Al final, las predicciones se combinan de manera ponderada para obtener el resultado final.
• Stacking: Combina modelos de diferentes tipos entrenándolos en conjunto y utilizando un modelo meta (meta-learner) que aprende a combinar las predicciones de los modelos base.

Los algoritmos de conjunto son especialmente útiles cuando los modelos individuales son inestables o tienen un alto nivel de variabilidad en sus predicciones. Al combinar múltiples modelos, se consigue reducir la varianza y mejorar la generalización del modelo a nuevos datos.

En Scikit Learn, se proporciona una amplia gama de algoritmos de conjunto para regresión, que permiten implementar estas técnicas de manera eficiente y sencilla. Algunos de los algoritmos más utilizados son:

• RandomForestRegressor: Utiliza el enfoque de bagging con árboles de decisión, creando un "bosque aleatorio" de múltiples árboles y promediando sus predicciones.
• AdaBoostRegressor: Aplica el método de boosting, entrenando secuencialmente modelos que intentan corregir los errores de los anteriores mediante la asignación de pesos a las observaciones.
• GradientBoostingRegressor: Implementa una versión más avanzada de boosting que utiliza gradientes para minimizar la función de pérdida, mejorando iterativamente el modelo.

Estos algoritmos son altamente escalables y pueden manejar conjuntos de datos grandes y complejos. Además, permiten ajustar numerosos hiperparámetros para optimizar su rendimiento en diferentes escenarios.

A continuación, se muestra un ejemplo básico de cómo utilizar un algoritmo de conjunto para regresión en Scikit Learn:

from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import train_test_split

# Supongamos que X y y son nuestras variables predictoras y objetivo, respectivamente
X_entrenamiento, X_prueba, y_entrenamiento, y_prueba = train_test_split(X, y, test_size=0.2, random_state=42)

# Creamos y entrenamos el modelo de bosque aleatorio
modelo = RandomForestRegressor(n_estimators=100, random_state=42)
modelo.fit(X_entrenamiento, y_entrenamiento)

# Realizamos predicciones
predicciones = modelo.predict(X_prueba)

En este ejemplo, se divide el conjunto de datos en entrenamiento y prueba, se crea una instancia de RandomForestRegressor y se entrena el modelo con los datos de entrenamiento. Finalmente, se obtienen las predicciones sobre el conjunto de prueba.

Es importante destacar que los algoritmos de conjunto suelen requerir más recursos computacionales que los modelos individuales, debido a que entrenan múltiples modelos simultánea o secuencialmente. Sin embargo, el beneficio en la precisión y la estabilidad de las predicciones suele compensar este aumento en el costo computacional.

Los algoritmos de conjunto también ofrecen mecanismos para evaluar la importancia de las variables, lo que puede ser útil para interpretar el modelo y entender qué características influyen más en las predicciones.

RandomForestRegressor

El RandomForestRegressor es un estimador de Scikit Learn que implementa un método de aprendizaje de conjunto utilizando el algoritmo de bosques aleatorios. Este modelo es una extensión del bagging que introduce la aleatoriedad al seleccionar subconjuntos de características al construir cada árbol, lo que mejora la diversidad entre los árboles y reduce la correlación entre ellos.

Al entrenar un RandomForestRegressor, se construye un conjunto de árboles de decisión independientes, cada uno entrenado con una muestra distinta del conjunto de datos de entrenamiento mediante muestreo con reemplazo (bootstrap). Además, en cada nodo, el algoritmo considera aleatoriamente un subconjunto de características para determinar la mejor división, lo que introduce variabilidad adicional y mejora la generalización del modelo.

Para utilizar RandomForestRegressor, es necesario importar el estimador desde el módulo sklearn.ensemble y ajustar el modelo a los datos de entrenamiento. A continuación se muestra un ejemplo práctico:

from sklearn.ensemble import RandomForestRegressor

# Supongamos que disponemos de X_entrenamiento e y_entrenamiento
modelo = RandomForestRegressor(n_estimators=100, random_state=42)
modelo.fit(X_entrenamiento, y_entrenamiento)

# Realizamos predicciones sobre nuevos datos
predicciones = modelo.predict(X_prueba)

En este ejemplo, se crea una instancia de RandomForestRegressor con 100 árboles (n_estimators=100) y se establece una semilla para garantizar la reproducibilidad. Luego, se ajusta el modelo con los datos de entrenamiento y se realizan predicciones sobre un conjunto de prueba.

El RandomForestRegressor ofrece diversos hiperparámetros que permiten ajustar su rendimiento. Algunos de los más importantes son:

• n_estimators: número de árboles en el bosque. Un valor mayor puede mejorar la precisión pero aumenta el tiempo de computación.
• max_depth: profundidad máxima de los árboles. Limitar la profundidad puede reducir el sobreajuste.
• min_samples_split: número mínimo de muestras requeridas para dividir un nodo. Valores más altos conducen a árboles más simples.
• max_features: número de características a considerar al buscar la mejor división. Puede ser un entero, un flotante, 'auto' o 'sqrt'. Controla la aleatoriedad en la selección de características.

Un aspecto destacado del RandomForestRegressor es su capacidad para estimar la importancia de las características. Esto se puede obtener mediante el atributo feature_importances_ del modelo entrenado, lo que permite identificar qué variables tienen mayor influencia en las predicciones.

import pandas as pd

importancias = modelo.feature_importances_
caracteristicas = X_entrenamiento.columns
df_importancias = pd.DataFrame({'Característica': caracteristicas, 'Importancia': importancias})
df_importancias = df_importancias.sort_values('Importancia', ascending=False)

print(df_importancias)

Este código genera un dataframe ordenado con las características y su importancia relativa, facilitando la interpretación del modelo.

Además, el RandomForestRegressor tiene la opción de activar el cálculo del Out-of-Bag Score (OOB Score), que es una estimación del error de generalización obtenido a partir de las muestras no usadas durante el muestreo bootstrap. Para activarlo, se debe configurar el parámetro oob_score=True al crear el modelo:

modelo = RandomForestRegressor(n_estimators=100, oob_score=True, random_state=42)
modelo.fit(X_entrenamiento, y_entrenamiento)

print(f'R^2 Out-of-Bag: {modelo.oob_score_}')

Este método proporciona una forma eficiente de validar el modelo sin necesidad de una validación cruzada explícita.

Es importante tener en cuenta que el RandomForestRegressor, al ser un conjunto de múltiples árboles, puede ser computacionalmente intensivo, especialmente con un gran número de árboles o características. Sin embargo, Scikit Learn permite paralelizar el entrenamiento y la predicción mediante el parámetro n_jobs, que especifica el número de procesadores a utilizar:

# Utiliza todos los núcleos disponibles
modelo = RandomForestRegressor(n_estimators=100, n_jobs=-1, random_state=42)
modelo.fit(X_entrenamiento, y_entrenamiento)

El RandomForestRegressor es robusto frente a datos faltantes y valores atípicos, ya que los árboles de decisión individuales son poco sensibles a ellos. No obstante, es buena práctica realizar un preprocesamiento adecuado de los datos para obtener mejores resultados.

AdaBoostRegressor

El AdaBoostRegressor es un estimador de Scikit Learn que implementa el algoritmo de Boosting Adaptativo para regresión. Este método crea un conjunto de modelos débiles que, combinados, producen un potente modelo predictivo. A diferencia de otros algoritmos de conjunto, AdaBoostRegressor ajusta secuencialmente los modelos, prestando mayor atención a las observaciones en las que los modelos anteriores tuvieron mayor error.

El funcionamiento del AdaBoostRegressor se basa en asignar pesos a cada observación del conjunto de entrenamiento. Inicialmente, todos los pesos son iguales. En cada iteración, se entrena un modelo base, generalmente un árbol de decisión de profundidad limitada, y se evalúa su error. Las observaciones que fueron predichas incorrectamente reciben un peso mayor en el siguiente modelo, permitiendo que el algoritmo se centre en los casos más difíciles.

Para utilizar el AdaBoostRegressor en Scikit Learn, es necesario importar el estimador desde el módulo sklearn.ensemble y ajustar el modelo a los datos de entrenamiento. A continuación se muestra un ejemplo práctico:

from sklearn.ensemble import AdaBoostRegressor
from sklearn.tree import DecisionTreeRegressor

# Supongamos que disponemos de X_entrenamiento e y_entrenamiento
modelo_base = DecisionTreeRegressor(max_depth=4, random_state=42)
modelo = AdaBoostRegressor(base_estimator=modelo_base, n_estimators=50, learning_rate=1.0, random_state=42)
modelo.fit(X_entrenamiento, y_entrenamiento)

# Realizamos predicciones sobre nuevos datos
predicciones = modelo.predict(X_prueba)

En este ejemplo, se crea un modelo base que es un árbol de decisión de profundidad máxima 4. El AdaBoostRegressor utiliza este modelo base para construir un conjunto de 50 estimadores (n_estimators=50) y un learning_rate de 1.0, que controla la contribución de cada modelo adicional.

El AdaBoostRegressor ofrece varios hiperparámetros para ajustar su rendimiento:

• base_estimator: el estimador base a utilizar. Por defecto es un DecisionTreeRegressor con profundidad máxima de 3. Es común utilizar modelos sencillos como árboles de decisión poco profundos para mantener la naturaleza de modelos débiles.
• n_estimators: número máximo de estimadores a entrenar. Un valor mayor puede mejorar la capacidad del modelo para ajustarse a los datos, pero también aumenta el riesgo de sobreajuste.
• learning_rate: tasa de aprendizaje que reduce la contribución de cada modelo. Un valor más bajo requiere un número mayor de estimadores para lograr un buen rendimiento.
• loss: función de pérdida a utilizar. En regresión, las opciones son 'linear', 'square' y 'exponential'. Controla cómo se penalizan los errores.

Un aspecto importante es que el modelo base debe ser capaz de ajustarse bien a los datos con los pesos actualizados. Por ello, los árboles de decisión son una elección común debido a su flexibilidad y capacidad para manejar datos complejos.

El entrenamiento secuencial del AdaBoostRegressor permite que cada estimador aprenda de los errores de los anteriores. Esto puede resultar en un modelo con alta precisión, pero también aumenta el tiempo de entrenamiento. Es crucial encontrar un balance adecuado entre el número de estimadores y la tasa de aprendizaje.

Para evaluar el rendimiento del modelo, se pueden utilizar métricas como el error cuadrático medio o el coeficiente de determinación R². A continuación se muestra cómo calcular el R² en el conjunto de prueba:

from sklearn.metrics import r2_score

r2 = r2_score(y_prueba, predicciones)
print(f'R² en el conjunto de prueba: {r2:.4f}')

La interpretabilidad del AdaBoostRegressor puede ser un reto, ya que combina múltiples modelos. Sin embargo, es posible extraer la importancia de las características utilizando los atributos de los estimadores base. Por ejemplo, se puede obtener la importancia promedio de cada característica:

import numpy as np

importancias = np.mean([
    árbol.feature_importances_ for árbol in modelo.estimators_
], axis=0)

características = X_entrenamiento.columns
df_importancias = pd.DataFrame({'Característica': características, 'Importancia': importancias})
df_importancias = df_importancias.sort_values('Importancia', ascending=False)

print(df_importancias)

Este código calcula las importancias de las características promediando las importancias de cada árbol en el conjunto. Esto ayuda a identificar qué variables son más relevantes para el modelo.

El AdaBoostRegressor es sensible al ruido y a los valores atípicos en el conjunto de datos. Debido a que el algoritmo da mayor peso a las observaciones difíciles, el ruido puede afectar significativamente el modelo. Es recomendable realizar un preprocesamiento cuidadoso, incluyendo la detección y tratamiento de valores atípicos.

Algunas prácticas recomendadas al utilizar AdaBoostRegressor incluyen:

• Ajustar el parámetro max_depth del modelo base para prevenir el sobreajuste. Modelos base demasiado complejos pueden llevar a un modelo final menos generalizable.
• Experimentar con diferentes valores de n_estimators y learning_rate. Una tasa de aprendizaje más baja con un mayor número de estimadores puede mejorar el rendimiento.
• Evaluar el modelo utilizando validación cruzada para obtener una estimación más fiable de su capacidad de generalización.

En cuanto a la paralelización, el AdaBoostRegressor es menos paralelizable que otros métodos como RandomForestRegressor, debido a su naturaleza secuencial. Sin embargo, algunas operaciones internas pueden beneficiarse del paralelismo, aunque el impacto es menor.

Finalmente, el AdaBoostRegressor es adecuado para problemas en los que se requiere un modelo con alta precisión y se dispone de tiempo suficiente para el entrenamiento. Es una herramienta potente cuando se aplica correctamente y con un entendimiento adecuado de sus características.

GradientBoostingRegressor

El GradientBoostingRegressor es un estimador de Scikit Learn que implementa el algoritmo de Gradient Boosting para tareas de regresión. Este método construye un modelo predictivo potente combinando múltiples modelos débiles, generalmente árboles de decisión, entrenados secuencialmente para corregir los errores de los modelos anteriores. A través de la optimización de una función de pérdida mediante gradientes, el algoritmo mejora iterativamente el rendimiento del modelo.

En contraste con el AdaBoostRegressor, que ajusta los errores al recalibrar los pesos de las observaciones, el GradientBoostingRegressor optimiza directamente la función de pérdida utilizando métodos de descenso de gradiente. Esto permite una mayor flexibilidad en la elección de la función de pérdida y puede resultar en modelos más precisos y robustos.

El GradientBoostingRegressor soporta diversas funciones de pérdida, incluyendo la pérdida cuadrática, la pérdida absoluta y la pérdida Huber. Esta flexibilidad permite adaptar el modelo a diferentes tipos de problemas y distribuciones de datos. Además, el algoritmo es capaz de manejar datos con patrones complejos debido a la naturaleza aditiva de los modelos débiles.

Para utilizar el GradientBoostingRegressor en Scikit Learn, es necesario importarlo desde el módulo sklearn.ensemble y ajustarlo a los datos de entrenamiento. A continuación se muestra un ejemplo práctico:

from sklearn.ensemble import GradientBoostingRegressor

# Supongamos que disponemos de X_entrenamiento e y_entrenamiento
modelo = GradientBoostingRegressor(n_estimators=100, learning_rate=0.1, max_depth=3, random_state=42)
modelo.fit(X_entrenamiento, y_entrenamiento)

# Realizamos predicciones sobre nuevos datos
predicciones = modelo.predict(X_prueba)

En este ejemplo, se crea una instancia de GradientBoostingRegressor con 100 árboles (n_estimators=100), una tasa de aprendizaje (learning_rate=0.1) de 0.1 y una profundidad máxima de los árboles base de 3 (max_depth=3). El parámetro random_state garantiza la reproducibilidad de los resultados.

El GradientBoostingRegressor ofrece múltiples hiperparámetros que permiten ajustar su rendimiento y controlar el sobreajuste. Algunos de los más relevantes son:

• n_estimators: número de estimadores o etapas de refuerzo. Valores más altos pueden mejorar el rendimiento pero aumentan el riesgo de sobreajuste y el tiempo de cómputo.
• learning_rate: controla la contribución de cada árbol al modelo final. Una tasa de aprendizaje más baja requiere más estimadores para obtener un rendimiento similar.
• max_depth: profundidad máxima de los árboles individuales. Limitar la profundidad ayuda a mejorar la generalización y a reducir el sobreajuste.
• subsample: fracción de muestras utilizadas para entrenar cada árbol, aplicando muestreo sin reemplazo. Valores menores que 1.0 introducen aleatoriedad y pueden reducir la varianza del modelo.
• loss: función de pérdida a minimizar. Por defecto es 'squared_error' para regresión. En Scikit Learn se admiten funciones como 'absolute_error' y 'huber'.

El GradientBoostingRegressor también soporta técnicas como el early stopping para evitar el sobreajuste. Esto se logra mediante el uso del parámetro validation_fraction para especificar la fracción de datos de entrenamiento a utilizar como conjunto de validación, y n_iter_no_change para detener el entrenamiento si no hay mejora en la función de pérdida durante cierto número de iteraciones.

Por ejemplo, para utilizar early stopping, se puede configurar el modelo de la siguiente manera:

modelo = GradientBoostingRegressor(
    n_estimators=1000,
    learning_rate=0.01,
    max_depth=3,
    validation_fraction=0.1,
    n_iter_no_change=10,
    random_state=42
)
modelo.fit(X_entrenamiento, y_entrenamiento)

En este código, el entrenamiento se detendrá si la función de pérdida no mejora en el conjunto de validación después de 10 iteraciones.

El GradientBoostingRegressor proporciona métricas para evaluar la importancia de las características, lo que facilita la interpretación del modelo. La importancia de cada característica se puede obtener a través del atributo feature_importances_ del modelo entrenado:

import pandas as pd

importancias = modelo.feature_importances_
características = X_entrenamiento.columns
df_importancias = pd.DataFrame({'Característica': características, 'Importancia': importancias})
df_importancias = df_importancias.sort_values('Importancia', ascending=False)

print(df_importancias)

Es importante tener en cuenta que el GradientBoostingRegressor puede ser computacionalmente intensivo, especialmente con un gran número de estimadores y características. Para mejorar la eficiencia, Scikit Learn ofrece el HistGradientBoostingRegressor, una implementación más rápida y escalable del algoritmo Gradient Boosting basada en histogramas.

El HistGradientBoostingRegressor utiliza histogramas para acelerar el entrenamiento y reducir el uso de memoria, siendo particularmente eficiente en conjuntos de datos grandes. Además, soporta valores faltantes (NaN) de manera nativa, sin necesidad de imputación previa.

Para utilizar el HistGradientBoostingRegressor, se puede importar desde el módulo sklearn.ensemble:

from sklearn.ensemble import HistGradientBoostingRegressor

modelo = HistGradientBoostingRegressor(max_iter=100, learning_rate=0.1, max_depth=None, random_state=42)
modelo.fit(X_entrenamiento, y_entrenamiento)

Al emplear el GradientBoostingRegressor, es recomendable ajustar cuidadosamente los hiperparámetros mediante técnicas como la búsqueda en cuadrícula o búsqueda aleatoria con validación cruzada. Esto permite encontrar la combinación óptima de parámetros que maximiza el rendimiento del modelo en datos no vistos.

Por ejemplo:

from sklearn.model_selection import GridSearchCV

parametros = {
    'n_estimators': [100, 200],
    'learning_rate': [0.01, 0.1],
    'max_depth': [3, 5],
    'subsample': [0.8, 1.0]
}

grid_search = GridSearchCV(
    estimator=GradientBoostingRegressor(random_state=42),
    param_grid=parametros,
    cv=5,
    scoring='neg_mean_squared_error',
    n_jobs=-1
)

grid_search.fit(X_entrenamiento, y_entrenamiento)

print(f"Mejores parámetros: {grid_search.best_params_}")

Este enfoque permite optimizar el modelo y mejorar su precisión en tareas de regresión.

Interpretabilidad de los algoritmos de conjuntos en Scikit Learn

La interpretabilidad de los modelos es esencial para comprender cómo las variables de entrada influyen en las predicciones. En los algoritmos de conjuntos para regresión de Scikit Learn, existe una variedad de técnicas que permiten desentrañar el funcionamiento interno de modelos como RandomForestRegressor, AdaBoostRegressor y GradientBoostingRegressor.

Una herramienta común para evaluar la importancia de las características es el atributo feature_importances_, disponible en estos estimadores. Este atributo indica la contribución de cada variable en la reducción de la impureza a lo largo de los árboles del conjunto, proporcionando una medida cuantitativa de su relevancia en el modelo.

Por ejemplo, después de entrenar un modelo con RandomForestRegressor, es posible visualizar la importancia de las variables de la siguiente manera:

import pandas as pd
import matplotlib.pyplot as plt

# Supongamos que 'modelo' es nuestro RandomForestRegressor ya entrenado
importancias = modelo.feature_importances_
características = X_entrenamiento.columns

df_importancias = pd.DataFrame({'Características': características, 'Importancia': importancias})
df_importancias = df_importancias.sort_values('Importancia', ascending=False)

# Gráfico de barras de las importancias
plt.figure(figsize=(10,6))
plt.bar(df_importancias['Características'], df_importancias['Importancia'])
plt.xlabel('Características')
plt.ylabel('Importancia')
plt.title('Importancia de las características según RandomForestRegressor')
plt.xticks(rotation=90)
plt.show()

Este gráfico permite identificar cuáles son las características más influyentes en las predicciones del modelo. Sin embargo, es importante considerar que estas importancias pueden estar sesgadas hacia variables con más niveles o con mayor variabilidad, por lo que conviene complementarlas con otras técnicas.

La importancia por permutación es una alternativa que evalúa la disminución del rendimiento del modelo al permutar aleatoriamente los valores de una característica. En Scikit Learn, se puede emplear la función permutation_importance para calcularla:

from sklearn.inspection import permutation_importance

resultado = permutation_importance(modelo, X_prueba, y_prueba, n_repeats=10, random_state=42)

importancias_perm = resultado.importances_mean
df_importancias_perm = pd.DataFrame({'Características': características, 'Importancia': importancias_perm})
df_importancias_perm = df_importancias_perm.sort_values('Importancia', ascending=False)

print(df_importancias_perm)

La importancia por permutación ofrece una medida más robusta de la relevancia de cada variable, ya que no depende de cómo se construyeron los árboles, sino del impacto real en las predicciones al alterar la información.

Otra técnica poderosa para interpretar modelos de conjuntos es el uso de valores SHAP (Shapley Additive Explanations). Los valores SHAP cuantifican la contribución individual de cada característica a la predicción en una instancia específica. Aunque Scikit Learn no incorpora SHAP directamente, se puede utilizar la librería SHAP para integrarla con los modelos entrenados:

import shap

# Crear un objeto Explainer para el modelo
explainer = shap.TreeExplainer(modelo)
# Calcular los valores SHAP para el conjunto de prueba
shap_values = explainer.shap_values(X_prueba)

# Visualizar un resumen de las importancias
shap.summary_plot(shap_values, X_prueba, plot_type='bar')

Los valores SHAP permiten desglosar cada predicción en la suma de las contribuciones de las características, facilitando una interpretación detallada y consistente con la teoría de juegos. Además, proporcionan visualizaciones que ayudan a entender las interacciones y efectos no lineales.

Los gráficos de dependencia parcial son otra herramienta útil para analizar cómo una o dos características afectan las predicciones promedio del modelo. Utilizando la función PartialDependenceDisplay.from_estimator, es posible generar estas visualizaciones:

from sklearn.inspection import PartialDependenceDisplay

features = ['característica1', 'característica2']  # Reemplazar con los nombres concretos
PartialDependenceDisplay.from_estimator(modelo, X_entrenamiento, features)
plt.show()

Estos gráficos ilustran la relación entre las características seleccionadas y la variable objetivo, manteniendo constantes las demás variables. Son especialmente útiles para detectar tendencias y efectos marginales en el modelo.

En modelos complejos como el GradientBoostingRegressor, donde las interacciones entre variables pueden ser intrincadas, combinar varias técnicas de interpretación es recomendable. Los valores SHAP, la importancia por permutación y los gráficos de dependencia parcial pueden ofrecer perspectivas complementarias sobre el funcionamiento del modelo.

Es relevante mencionar que la interpretación global del modelo no siempre es suficiente. En casos donde se requiere explicar predicciones específicas, técnicas como Local Interpretable Model-agnostic Explanations (LIME) pueden ser aplicadas. Aunque LIME no está integrado en Scikit Learn, puede utilizarse en conjunto para obtener explicaciones locales:

import lime
from lime.lime_tabular import LimeTabularExplainer

explainer = LimeTabularExplainer(
    training_data=np.array(X_entrenamiento),
    feature_names=X_entrenamiento.columns,
    mode='regression'
)

# Explicar una predicción individual
explicación = explainer.explain_instance(
    data_row=X_prueba.iloc[0],
    predict_fn=modelo.predict
)

explicación.show_in_notebook(show_table=True)

La utilización de técnicas de interpretabilidad local es esencial cuando se requiere justificar decisiones individuales, especialmente en sectores regulados o sensibles.

Adicionalmente, es posible acceder y analizar los árboles individuales en modelos como RandomForestRegressor a través del atributo estimators_. Esto permite explorar cómo funcionan los estimadores base:

# Acceder al primer árbol del bosque
árbol = modelo.estimators_[0]

# Visualizar el árbol utilizando export_text
from sklearn.tree import export_text

estructura_árbol = export_text(árbol, feature_names=list(características))
print(estructura_árbol)

Aunque examinar los árboles individuales puede proporcionar información detallada, es habitual que en modelos de conjuntos el número de estimadores sea elevado, lo que dificulta su análisis exhaustivo.

Es importante destacar que la complejidad inherente a los algoritmos de conjuntos puede reducir la transparencia comparada con modelos más simples. Por ello, la combinación de distintas técnicas de interpretación es clave para obtener una comprensión completa y confiable del modelo.

Finalmente, al interpretar modelos, es esencial considerar el contexto y el dominio de aplicación. La interpretación debe alinearse con los conocimientos y expectativas de los expertos en el campo, garantizando que las conclusiones sean coherentes y útiles para la toma de decisiones.