使用堆叠组合预测器#
堆叠是一种混合估计器的方法。在这种策略中，一些估计器在一些训练数据上单独拟合，而最终的估计器则使用这些基本估计器的堆叠预测进行训练。
在本例中，我们将说明将不同的回归器堆叠在一起并使用最终的线性惩罚回归器来输出预测的用例。我们将每个单独回归器的性能与堆叠策略进行比较。堆叠略微提高了整体性能。
# Authors: Guillaume Lemaitre <[email protected]>
# Maria Telenczuk <https://github.com/maikia>
# License: BSD 3 clause
下载数据集#
我们将使用 Ames Housing 数据集，该数据集最初由 Dean De Cock 收集，并在用于 Kaggle 挑战赛后变得更加出名。它是美国爱荷华州艾姆斯市 1460 套住宅房屋的集合，每套房屋都由 80 个特征描述。我们将使用它来预测房屋的最终对数价格。在本例中，我们将仅使用使用 GradientBoostingRegressor() 选择的 20 个最有趣的特征，并限制条目数量（此处我们不会详细介绍如何选择最有趣的特征）。
Ames 房屋数据集未随 scikit-learn 一起提供，因此我们将从 OpenML 获取它。
import numpy as np
from sklearn.datasets import fetch_openml
from sklearn.utils import shuffle
def load_ames_housing():
df = fetch_openml(name="house_prices", as_frame=True)
X = df.data
y = df.target
features = [
"YrSold",
"HeatingQC",
"Street",
"YearRemodAdd",
"Heating",
"MasVnrType",
"BsmtUnfSF",
"Foundation",
"MasVnrArea",
"MSSubClass",
"ExterQual",
"Condition2",
"GarageCars",
"GarageType",
"OverallQual",
"TotalBsmtSF",
"BsmtFinSF1",
"HouseStyle",
"MiscFeature",
"MoSold",
]
X = X.loc[:, features]
X, y = shuffle(X, y, random_state=0)
X = X.iloc[:600]
y = y.iloc[:600]
return X, np.log(y)
X, y = load_ames_housing()
创建管道以预处理数据#
在我们使用 Ames 数据集之前，我们仍然需要做一些预处理。首先，我们将选择数据集的分类列和数值列来构建管道的第一个步骤。
from sklearn.compose import make_column_selector
cat_selector = make_column_selector(dtype_include=object)
num_selector = make_column_selector(dtype_include=np.number)
cat_selector(X)
['HeatingQC', 'Street', 'Heating', 'MasVnrType', 'Foundation', 'ExterQual', 'Condition2', 'GarageType', 'HouseStyle', 'MiscFeature']
num_selector(X)
['YrSold', 'YearRemodAdd', 'BsmtUnfSF', 'MasVnrArea', 'MSSubClass', 'GarageCars', 'OverallQual', 'TotalBsmtSF', 'BsmtFinSF1', 'MoSold']
然后，我们需要设计预处理管道，这取决于最终的回归器。如果最终的回归器是线性模型，则需要对类别进行独热编码。如果最终的回归器是基于树的模型，则序数编码器就足够了。此外，线性模型需要对数值进行标准化，而基于树的模型可以按原样处理原始数值数据。但是，这两种模型都需要一个插补器来处理缺失值。
我们将首先设计基于树的模型所需的管道。
from sklearn.compose import make_column_transformer
from sklearn.impute import SimpleImputer
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import OrdinalEncoder
cat_tree_processor = OrdinalEncoder(
handle_unknown="use_encoded_value",
unknown_value=-1,
encoded_missing_value=-2,
)
num_tree_processor = SimpleImputer(strategy="mean", add_indicator=True)
tree_preprocessor = make_column_transformer(
(num_tree_processor, num_selector), (cat_tree_processor, cat_selector)
)
tree_preprocessor
然后，我们现在将定义最终回归器是线性模型时使用的预处理器。
from sklearn.preprocessing import OneHotEncoder, StandardScaler
cat_linear_processor = OneHotEncoder(handle_unknown="ignore")
num_linear_processor = make_pipeline(
StandardScaler(), SimpleImputer(strategy="mean", add_indicator=True)
)
linear_preprocessor = make_column_transformer(
(num_linear_processor, num_selector), (cat_linear_processor, cat_selector)
)
linear_preprocessor
单个数据集上的预测器堆栈#
找到在给定数据集上表现最佳的模型有时很乏味。堆叠提供了一种替代方案，它可以组合多个学习器的输出，而无需专门选择模型。堆叠的性能通常接近最佳模型，有时甚至可以优于每个单独模型的预测性能。
在这里，我们组合了 3 个学习器（线性和非线性），并使用岭回归器将它们的输出组合在一起。
注意
虽然我们将使用我们在上一节中为 3 个学习器编写的处理器创建新的管道，但最终的估计器
RidgeCV()不需要对数据进行预处理，因为它将从 3 个学习器中获取已经预处理过的输出。
from sklearn.linear_model import LassoCV
lasso_pipeline = make_pipeline(linear_preprocessor, LassoCV())
lasso_pipeline
from sklearn.ensemble import RandomForestRegressor
rf_pipeline = make_pipeline(tree_preprocessor, RandomForestRegressor(random_state=42))
rf_pipeline
from sklearn.ensemble import HistGradientBoostingRegressor
gbdt_pipeline = make_pipeline(
tree_preprocessor, HistGradientBoostingRegressor(random_state=0)
)
gbdt_pipeline
from sklearn.ensemble import StackingRegressor
from sklearn.linear_model import RidgeCV
estimators = [
("Random Forest", rf_pipeline),
("Lasso", lasso_pipeline),
("Gradient Boosting", gbdt_pipeline),
]
stacking_regressor = StackingRegressor(estimators=estimators, final_estimator=RidgeCV())
stacking_regressor
测量和绘制结果#
现在我们可以使用 Ames Housing 数据集进行预测。我们检查每个单独预测器的性能以及回归器堆栈的性能。
import time
import matplotlib.pyplot as plt
from sklearn.metrics import PredictionErrorDisplay
from sklearn.model_selection import cross_val_predict, cross_validate
fig, axs = plt.subplots(2, 2, figsize=(9, 7))
axs = np.ravel(axs)
for ax, (name, est) in zip(
axs, estimators + [("Stacking Regressor", stacking_regressor)]
):
scorers = {"R2": "r2", "MAE": "neg_mean_absolute_error"}
start_time = time.time()
scores = cross_validate(
est, X, y, scoring=list(scorers.values()), n_jobs=-1, verbose=0
)
elapsed_time = time.time() - start_time
y_pred = cross_val_predict(est, X, y, n_jobs=-1, verbose=0)
scores = {
key: (
f"{np.abs(np.mean(scores[f'test_{value}'])):.2f} +- "
f"{np.std(scores[f'test_{value}']):.2f}"
)
for key, value in scorers.items()
}
display = PredictionErrorDisplay.from_predictions(
y_true=y,
y_pred=y_pred,
kind="actual_vs_predicted",
ax=ax,
scatter_kwargs={"alpha": 0.2, "color": "tab:blue"},
line_kwargs={"color": "tab:red"},
)
ax.set_title(f"{name}\nEvaluation in {elapsed_time:.2f} seconds")
for name, score in scores.items():
ax.plot([], [], " ", label=f"{name}: {score}")
ax.legend(loc="upper left")
plt.suptitle("Single predictors versus stacked predictors")
plt.tight_layout()
plt.subplots_adjust(top=0.9)
plt.show()
堆叠回归器将结合不同回归器的优势。但是，我们也看到训练堆叠回归器的计算成本要高得多。
脚本总运行时间：（0 分钟 24.795 秒）
相关示例
