Comparer Random Forest et Histogramme Gradient Boosting

Introduction

Dans ce laboratoire, nous comparerons les performances de deux modèles d'ensemble populaires, Random Forest (RF) et Histogram Gradient Boosting (HGBT), pour un ensemble de données de régression en termes de score et de temps de calcul. Nous allons modifier les paramètres qui contrôlent le nombre d'arbres selon chaque estimateur et tracer les résultats pour visualiser le compromis entre le temps de calcul écoulé et la moyenne du score de test.

Conseils sur la VM

Une fois le démarrage de la VM terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Notebook pour accéder à Jupyter Notebook pour la pratique.

Parfois, vous devrez peut-être attendre quelques secondes pour que Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations de Jupyter Notebook.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez votre feedback après la session, et nous réglerons rapidement le problème pour vous.

Skills Graph

Charger l'ensemble de données

Nous allons charger l'ensemble de données sur le logement en Californie à l'aide de la fonction fetch_california_housing de scikit-learn. Cet ensemble de données est composé de 20 640 échantillons et de 8 caractéristiques.

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"L'ensemble de données est composé de {n_samples} échantillons et {n_features} caractéristiques")

Définir les modèles et les grilles de paramètres

Nous allons définir deux modèles, Random Forest et Histogram Gradient Boosting, avec leurs grilles de paramètres correspondantes à l'aide des classes RandomForestRegressor, HistGradientBoostingRegressor et GridSearchCV de scikit-learn. Nous allons également définir le nombre de coeurs physiques de la machine hôte à utiliser pour le traitement parallèle.

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)

Calculer les scores et les temps de calcul

Nous allons calculer les temps moyens d'ajustement et de scoring pour chaque combinaison d'hyperparamètres en utilisant l'attribut cv_results_ de l'objet GridSearchCV. Nous tracerons ensuite les résultats à l'aide de plotly.express.scatter et plotly.express.line pour visualiser le compromis entre le temps de calcul écoulé et la moyenne du score de test.

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=["Temps d'entraînement vs score", "Temps de prédiction vs score"],
)
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="Temps d'entraînement (s) - moins élevé est meilleur"),
    yaxis=dict(title="Score R2 de test - plus élevé est meilleur"),
    xaxis2=dict(title="Temps de prédiction (s) - moins élevé est meilleur"),
    legend=dict(x=0.72, y=0.05, traceorder="normal", borderwidth=1),
    title=dict(x=0.5, text="Compromis vitesse - score des ensembles basés sur des arbres"),
)

Interpréter les résultats

On peut observer que les modèles HGBT et RF s'améliorent tous les deux en augmentant le nombre d'arbres dans l'ensemble. Cependant, les scores atteignent un plateau où ajouter de nouveaux arbres ne fait que ralentir l'ajustement et le scoring. Le modèle RF atteint ce plateau plus tôt et ne peut jamais atteindre le score de test du plus grand modèle HGBDT. Les modèles HGBT dominent uniformément les modèles RF dans le "compromis score de test vs vitesse d'entraînement" et le "compromis score de test vs vitesse de prédiction" peut également être plus favorable aux HGBT. L'HGBT offre presque toujours un compromis vitesse - précision plus favorable que le RF, que ce soit avec les hyper-paramètres par défaut ou en incluant le coût d'ajustement des hyper-paramètres.

Sommaire

Dans ce laboratoire, nous avons comparé les performances de deux modèles d'ensemble populaires, Random Forest et Histogram Gradient Boosting, pour un ensemble de données de régression en termes de score et de temps de calcul. Nous avons fait varier les paramètres qui contrôlent le nombre d'arbres selon chaque estimateur et avons tracé les résultats pour visualiser le compromis entre le temps de calcul écoulé et la moyenne du score de test. Nous avons observé que les modèles HGBT dominent uniformément les modèles RF dans le "compromis score de test vs vitesse d'entraînement" et que le "compromis score de test vs vitesse de prédiction" peut également être plus favorable aux HGBT. L'HGBT offre presque toujours un compromis vitesse - précision plus favorable que le RF, que ce soit avec les hyper-paramètres par défaut ou en incluant le coût d'ajustement des hyper-paramètres.