Comparación de Bosque Aleatorio y Gradiente de Histograma con Mejora

Introducción

En este laboratorio, compararemos el rendimiento de dos modelos de ensemble populares, Random Forest (RF) y Histogram Gradient Boosting (HGBT), para un conjunto de datos de regresión en términos de puntuación y tiempo de cálculo. Variaremos los parámetros que controlan el número de árboles según cada estimador y graficaremos los resultados para visualizar el equilibrio entre el tiempo de cálculo transcurrido y la puntuación promedio de prueba.

Consejos sobre la VM

Una vez que se haya completado la inicialización de la VM, haga clic en la esquina superior izquierda para cambiar a la pestaña Cuaderno y acceder a Jupyter Notebook para practicar.

A veces, es posible que tenga que esperar unos segundos a que Jupyter Notebook termine de cargarse. La validación de operaciones no se puede automatizar debido a las limitaciones de Jupyter Notebook.

Si tiene problemas durante el aprendizaje, no dude en preguntar a Labby. Deje comentarios después de la sesión y resolveremos rápidamente el problema para usted.

Skills Graph

Cargar el conjunto de datos

Cargaremos el conjunto de datos de viviendas de California utilizando la función fetch_california_housing de scikit-learn. Este conjunto de datos consta de 20,640 muestras y 8 características.

from sklearn.datasets import fetch_california_housing

X, y = fetch_california_housing(return_X_y=True, as_frame=True)
n_samples, n_features = X.shape

print(f"El conjunto de datos consta de {n_samples} muestras y {n_features} características")

Definir modelos y grillas de parámetros

Definiremos dos modelos, Random Forest y Histogram Gradient Boosting, con sus respectivas grillas de parámetros utilizando las clases RandomForestRegressor, HistGradientBoostingRegressor y GridSearchCV de scikit-learn. También estableceremos el número de núcleos físicos de la máquina host para utilizar en el procesamiento paralelo.

import joblib
import pandas as pd
from sklearn.ensemble import HistGradientBoostingRegressor, RandomForestRegressor
from sklearn.model_selection import GridSearchCV, KFold

N_CORES = joblib.cpu_count(only_physical_cores=True)

models = {
    "Random Forest": RandomForestRegressor(
        min_samples_leaf=5, random_state=0, n_jobs=N_CORES
    ),
    "Hist Gradient Boosting": HistGradientBoostingRegressor(
        max_leaf_nodes=15, random_state=0, early_stopping=False
    ),
}

param_grids = {
    "Random Forest": {"n_estimators": [10, 20, 50, 100]},
    "Hist Gradient Boosting": {"max_iter": [10, 20, 50, 100, 300, 500]},
}

cv = KFold(n_splits=4, shuffle=True, random_state=0)

results = []

for name, model in models.items():
    grid_search = GridSearchCV(
        estimator=model,
        param_grid=param_grids[name],
        return_train_score=True,
        cv=cv,
    ).fit(X, y)

    result = {"model": name, "cv_results": pd.DataFrame(grid_search.cv_results_)}
    results.append(result)

Calcular puntuaciones y tiempos de cálculo

Calcularemos los tiempos de ajuste y puntuación promedio para cada combinación de hiperparámetros utilizando el atributo cv_results_ del objeto GridSearchCV. Luego graficaremos los resultados utilizando plotly.express.scatter y plotly.express.line para visualizar el equilibrio entre el tiempo de cálculo transcurrido y la puntuación promedio de prueba.

import plotly.express as px
import plotly.colors as colors
from plotly.subplots import make_subplots

fig = make_subplots(
    rows=1,
    cols=2,
    shared_yaxes=True,
    subplot_titles=["Tiempo de entrenamiento vs puntuación", "Tiempo de predicción vs puntuación"],
)
model_names = [result["model"] for result in results]
colors_list = colors.qualitative.Plotly * (
    len(model_names) // len(colors.qualitative.Plotly) + 1
)

for idx, result in enumerate(results):
    cv_results = result["cv_results"].round(3)
    model_name = result["model"]
    param_name = list(param_grids[model_name].keys())[0]
    cv_results[param_name] = cv_results["param_" + param_name]
    cv_results["model"] = model_name

    scatter_fig = px.scatter(
        cv_results,
        x="mean_fit_time",
        y="mean_test_score",
        error_x="std_fit_time",
        error_y="std_test_score",
        hover_data=param_name,
        color="model",
    )
    line_fig = px.line(
        cv_results,
        x="mean_fit_time",
        y="mean_test_score",
    )

    scatter_trace = scatter_fig["data"][0]
    line_trace = line_fig["data"][0]
    scatter_trace.update(marker=dict(color=colors_list[idx]))
    line_trace.update(line=dict(color=colors_list[idx]))
    fig.add_trace(scatter_trace, row=1, col=1)
    fig.add_trace(line_trace, row=1, col=1)

    scatter_fig = px.scatter(
        cv_results,
        x="mean_score_time",
        y="mean_test_score",
        error_x="std_score_time",
        error_y="std_test_score",
        hover_data=param_name,
    )
    line_fig = px.line(
        cv_results,
        x="mean_score_time",
        y="mean_test_score",
    )

    scatter_trace = scatter_fig["data"][0]
    line_trace = line_fig["data"][0]
    scatter_trace.update(marker=dict(color=colors_list[idx]))
    line_trace.update(line=dict(color=colors_list[idx]))
    fig.add_trace(scatter_trace, row=1, col=2)
    fig.add_trace(line_trace, row=1, col=2)

fig.update_layout(
    xaxis=dict(title="Tiempo de entrenamiento (s) - menor es mejor"),
    yaxis=dict(title="Puntuación R2 de prueba - mayor es mejor"),
    xaxis2=dict(title="Tiempo de predicción (s) - menor es mejor"),
    legend=dict(x=0.72, y=0.05, traceorder="normal", borderwidth=1),
    title=dict(x=0.5, text="Equilibrio velocidad-puntuación de los conjuntos de árboles"),
)

Interpretar los resultados

Podemos observar que tanto los modelos HGBT como RF mejoran al aumentar el número de árboles en el ensemble. Sin embargo, las puntuaciones alcanzan un punto límite en el que agregar nuevos árboles solo hace que el ajuste y la puntuación sean más lentos. El modelo RF alcanza dicho punto límite más temprano y nunca puede alcanzar la puntuación de prueba del mayor modelo HGBDT. Los modelos HGBT dominan uniformemente a los modelos RF en el "equilibrio entre puntuación de prueba y velocidad de entrenamiento" y el "equilibrio entre puntuación de prueba y velocidad de predicción" también puede ser más favorable a HGBT. HGBT casi siempre ofrece un equilibrio más favorable entre velocidad y precisión que RF, ya sea con los hiperparámetros predeterminados o incluyendo el costo del ajuste de hiperparámetros.

Resumen

En este laboratorio, comparamos el rendimiento de dos modelos de ensemble populares, Random Forest y Histogram Gradient Boosting, para un conjunto de datos de regresión en términos de puntuación y tiempo de cálculo. Variamos los parámetros que controlan el número de árboles de acuerdo con cada estimador y graficamos los resultados para visualizar el equilibrio entre el tiempo de cálculo transcurrido y la puntuación promedio de prueba. Observamos que los modelos HGBT dominan uniformemente a los modelos RF en el "equilibrio entre puntuación de prueba y velocidad de entrenamiento" y el "equilibrio entre puntuación de prueba y velocidad de predicción" también puede ser más favorable a HGBT. HGBT casi siempre ofrece un equilibrio más favorable entre velocidad y precisión que RF, ya sea con los hiperparámetros predeterminados o incluyendo el costo del ajuste de hiperparámetros.