Vergleich von Random Forest und Histogram Gradient Boosting

Einführung

In diesem Lab werden wir die Leistung zweier populärer Ensemble-Modelle, Random Forest (RF) und Histogram Gradient Boosting (HGBT), für einen Regressionsdatensatz in Bezug auf die Score- und Rechenzeit vergleichen. Wir werden die Parameter variieren, die die Anzahl der Bäume je Schätzer steuern, und die Ergebnisse grafisch darstellen, um das Kompromissverhältnis zwischen der vergangenen Rechenzeit und dem mittleren Testscore zu visualisieren.

Tipps für die VM

Nachdem der VM-Start abgeschlossen ist, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu öffnen.

Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund der Einschränkungen von Jupyter Notebook nicht automatisiert werden.

Wenn Sie bei der Lernphase Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback, und wir werden das Problem für Sie prompt beheben.

Datensatz laden

Wir werden den Kalifornien-Hauspreis-Datensatz mit der Funktion fetch_california_housing aus scikit-learn laden. Dieser Datensatz besteht aus 20.640 Proben und 8 Merkmalen.

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"Der Datensatz besteht aus {n_samples} Proben und {n_features} Merkmalen")

Modelle und Parameter-Gitter definieren

Wir werden zwei Modelle, Random Forest und Histogram Gradient Boosting, mit ihren entsprechenden Parameter-Gittern mithilfe der Klassen RandomForestRegressor, HistGradientBoostingRegressor und GridSearchCV aus scikit-learn definieren. Wir werden auch die Anzahl der physischen Kerne auf dem Hostcomputer festlegen, die für die parallele Verarbeitung verwendet werden sollen.

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)

Bewertungen und Rechenzeiten berechnen

Wir werden die durchschnittlichen Anpassungs- und Bewertungszeiten für jede Kombination von Hyperparametern mithilfe der cv_results_-Eigenschaft des GridSearchCV-Objekts berechnen. Anschließend werden wir die Ergebnisse mit plotly.express.scatter und plotly.express.line visualisieren, um das Kompromissverhältnis zwischen der vergangenen Rechenzeit und dem mittleren Testscore darzustellen.

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=["Train time vs score", "Predict time 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="Train time (s) - lower is better"),
    yaxis=dict(title="Test R2 score - higher is better"),
    xaxis2=dict(title="Predict time (s) - lower is better"),
    legend=dict(x=0.72, y=0.05, traceorder="normal", borderwidth=1),
    title=dict(x=0.5, text="Speed-score trade-off of tree-based ensembles"),
)

Ergebnisse interpretieren

Wir können beobachten, dass sowohl die HGBT- als auch die RF-Modelle sich verbessern, wenn die Anzahl der Bäume im Ensemble erhöht wird. Allerdings erreichen die Scores ein Plateau, wo das Hinzufügen neuer Bäume nur die Anpassung und die Bewertung langsamer macht. Das RF-Modell erreicht dieses Plateau früher und kann nie den Testscore des größten HGBDT-Modells erreichen. HGBT-Modelle dominieren die RF-Modelle einheitlich im "Kompromiss zwischen Testscore und Trainingsgeschwindigkeit" und der "Kompromiss zwischen Testscore und Vorhersagegeschwindigkeit" kann auch günstiger für HGBT sein. HGBT bietet fast immer einen günstigeren Kompromiss zwischen Geschwindigkeit und Genauigkeit als RF, entweder mit den standardmäßigen Hyperparametern oder unter Berücksichtigung der Kosten der Hyperparameteroptimierung.

Zusammenfassung

In diesem Lab haben wir die Leistung zweier populärer Ensemble-Modelle, Random Forest und Histogram Gradient Boosting, für einen Regressionsdatensatz in Bezug auf Score und Rechenzeit verglichen. Wir haben die Parameter variiert, die die Anzahl der Bäume je nach Schätzer steuern, und die Ergebnisse geplottet, um das Kompromissverhältnis zwischen der vergangenen Rechenzeit und dem mittleren Testscore zu visualisieren. Wir haben beobachtet, dass HGBT-Modelle die RF-Modelle einheitlich in der "Testscore-Gegenüber-Trainingsgeschwindigkeit-Kompromissanalyse" dominieren und der "Testscore-Gegenüber-Vorhersagegeschwindigkeit-Kompromiss" auch günstiger für HGBT sein kann. HGBT bietet fast immer einen günstigeren Geschwindigkeit-Genauigkeit-Kompromiss als RF, entweder mit den standardmäßigen Hyperparametern oder unter Berücksichtigung der Kosten der Hyperparameteroptimierung.