StackingRegressor：一个用于回归的简单堆叠实现

用于堆叠回归的集成学习元回归器

from mlxtend.regressor import StackingRegressor

概述

堆叠回归是一种集成学习技术，通过元回归器组合多个回归模型。首先在完整的训练集上训练各个回归模型；然后，基于集成中各个回归模型的输出（即元特征）拟合元回归器。

参考文献

• Breiman, Leo. "堆叠回归。" Machine learning 24.1 (1996): 49-64.

示例 1 - 简单堆叠回归

from mlxtend.regressor import StackingRegressor
from mlxtend.data import boston_housing_data
from sklearn.linear_model import LinearRegression
from sklearn.linear_model import Ridge
from sklearn.svm import SVR
import matplotlib.pyplot as plt
import numpy as np
import warnings

warnings.simplefilter('ignore')

# Generating a sample dataset
np.random.seed(1)
X = np.sort(5 * np.random.rand(40, 1), axis=0)
y = np.sin(X).ravel()
y[::5] += 3 * (0.5 - np.random.rand(8))

# Initializing models

lr = LinearRegression()
svr_lin = SVR(kernel='linear')
ridge = Ridge(random_state=1)
svr_rbf = SVR(kernel='rbf')

stregr = StackingRegressor(regressors=[svr_lin, lr, ridge], 
                           meta_regressor=svr_rbf)

# Training the stacking classifier

stregr.fit(X, y)
stregr.predict(X)

# Evaluate and visualize the fit

print("Mean Squared Error: %.4f"
      % np.mean((stregr.predict(X) - y) ** 2))
print('Variance Score: %.4f' % stregr.score(X, y))

with plt.style.context(('seaborn-whitegrid')):
    plt.scatter(X, y, c='lightgray')
    plt.plot(X, stregr.predict(X), c='darkgreen', lw=2)

plt.show()

Mean Squared Error: 0.1846
Variance Score: 0.7329

stregr

StackingRegressor(meta_regressor=SVR(),
                  regressors=[SVR(kernel='linear'), LinearRegression(),
                              Ridge(random_state=1)])

示例 2 - 堆叠回归与GridSearch

在这个第二个示例中，我们演示了 StackingCVRegressor 如何与 GridSearchCV 结合使用。堆叠仍然允许调整基础模型和元模型的超参数！

例如，我们可以使用 estimator.get_params().keys() 获取可调参数的完整列表。

from sklearn.model_selection import GridSearchCV
from sklearn.linear_model import Lasso

# Initializing models

lr = LinearRegression()
svr_lin = SVR(kernel='linear')
ridge = Ridge(random_state=1)
lasso = Lasso(random_state=1)
svr_rbf = SVR(kernel='rbf')
regressors = [svr_lin, lr, ridge, lasso]
stregr = StackingRegressor(regressors=regressors, 
                           meta_regressor=svr_rbf)

params = {'lasso__alpha': [0.1, 1.0, 10.0],
          'ridge__alpha': [0.1, 1.0, 10.0],
          'svr__C': [0.1, 1.0, 10.0],
          'meta_regressor__C': [0.1, 1.0, 10.0, 100.0],
          'meta_regressor__gamma': [0.1, 1.0, 10.0]}

grid = GridSearchCV(estimator=stregr, 
                    param_grid=params, 
                    cv=5,
                    refit=True)
grid.fit(X, y)

print("Best: %f using %s" % (grid.best_score_, grid.best_params_))

Best: -0.082717 using {'lasso__alpha': 0.1, 'meta_regressor__C': 1.0, 'meta_regressor__gamma': 1.0, 'ridge__alpha': 0.1, 'svr__C': 10.0}

cv_keys = ('mean_test_score', 'std_test_score', 'params')

for r, _ in enumerate(grid.cv_results_['mean_test_score']):
    print("%0.3f +/- %0.2f %r"
          % (grid.cv_results_[cv_keys[0]][r],
             grid.cv_results_[cv_keys[1]][r] / 2.0,
             grid.cv_results_[cv_keys[2]][r]))
    if r > 10:
        break
print('...')

print('Best parameters: %s' % grid.best_params_)
print('Accuracy: %.2f' % grid.best_score_)

-9.810 +/- 6.86 {'lasso__alpha': 0.1, 'meta_regressor__C': 0.1, 'meta_regressor__gamma': 0.1, 'ridge__alpha': 0.1, 'svr__C': 0.1}
-9.591 +/- 6.67 {'lasso__alpha': 0.1, 'meta_regressor__C': 0.1, 'meta_regressor__gamma': 0.1, 'ridge__alpha': 0.1, 'svr__C': 1.0}
-9.591 +/- 6.67 {'lasso__alpha': 0.1, 'meta_regressor__C': 0.1, 'meta_regressor__gamma': 0.1, 'ridge__alpha': 0.1, 'svr__C': 10.0}
-9.819 +/- 6.87 {'lasso__alpha': 0.1, 'meta_regressor__C': 0.1, 'meta_regressor__gamma': 0.1, 'ridge__alpha': 1.0, 'svr__C': 0.1}
-9.600 +/- 6.68 {'lasso__alpha': 0.1, 'meta_regressor__C': 0.1, 'meta_regressor__gamma': 0.1, 'ridge__alpha': 1.0, 'svr__C': 1.0}
-9.600 +/- 6.68 {'lasso__alpha': 0.1, 'meta_regressor__C': 0.1, 'meta_regressor__gamma': 0.1, 'ridge__alpha': 1.0, 'svr__C': 10.0}
-9.878 +/- 6.91 {'lasso__alpha': 0.1, 'meta_regressor__C': 0.1, 'meta_regressor__gamma': 0.1, 'ridge__alpha': 10.0, 'svr__C': 0.1}
-9.665 +/- 6.71 {'lasso__alpha': 0.1, 'meta_regressor__C': 0.1, 'meta_regressor__gamma': 0.1, 'ridge__alpha': 10.0, 'svr__C': 1.0}
-9.665 +/- 6.71 {'lasso__alpha': 0.1, 'meta_regressor__C': 0.1, 'meta_regressor__gamma': 0.1, 'ridge__alpha': 10.0, 'svr__C': 10.0}
-4.839 +/- 3.98 {'lasso__alpha': 0.1, 'meta_regressor__C': 0.1, 'meta_regressor__gamma': 1.0, 'ridge__alpha': 0.1, 'svr__C': 0.1}
-3.986 +/- 3.16 {'lasso__alpha': 0.1, 'meta_regressor__C': 0.1, 'meta_regressor__gamma': 1.0, 'ridge__alpha': 0.1, 'svr__C': 1.0}
-3.986 +/- 3.16 {'lasso__alpha': 0.1, 'meta_regressor__C': 0.1, 'meta_regressor__gamma': 1.0, 'ridge__alpha': 0.1, 'svr__C': 10.0}
...
Best parameters: {'lasso__alpha': 0.1, 'meta_regressor__C': 1.0, 'meta_regressor__gamma': 1.0, 'ridge__alpha': 0.1, 'svr__C': 10.0}
Accuracy: -0.08

# Evaluate and visualize the fit
print("Mean Squared Error: %.4f"
      % np.mean((grid.predict(X) - y) ** 2))
print('Variance Score: %.4f' % grid.score(X, y))

with plt.style.context(('seaborn-whitegrid')):
    plt.scatter(X, y, c='lightgray')
    plt.plot(X, grid.predict(X), c='darkgreen', lw=2)

plt.show()

Mean Squared Error: 0.1845
Variance Score: 0.7330

注意

StackingCVRegressor 也支持对 regressors 甚至单个基础回归器进行网格搜索。当存在混合层级超参数时，GridSearchCV 将尝试按自上而下的顺序替换超参数，即 regressors -> 单个基础回归器 -> 回归器超参数。例如，给定一个超参数网格，例如

params = {'randomforestregressor__n_estimators': [1, 100],
'regressors': [(regr1, regr1, regr1), (regr2, regr3)]}

它首先将使用 (regr1, regr2, regr3) 或 (regr2, regr3) 中的实例设置。然后它将根据 'randomforestregressor__n_estimators': [1, 100] 替换匹配回归器的 'n_estimators' 设置。

API

StackingRegressor(regressors, meta_regressor, verbose=0, use_features_in_secondary=False, store_train_meta_features=False, refit=True, multi_output=False)

一个用于scikit-learn回归器的堆叠回归器。

参数

• regressors : 数组类型, 形状 = [n_regressors]

  回归器列表。在 StackingRegressor 上调用 fit 方法将拟合这些原始回归器的克隆，这些克隆将存储在类属性 self.regr_ 中。

• meta_regressor : 对象

  将在回归器集成上拟合的元回归器

• verbose : int, 可选 (默认=0)

  控制构建过程的详细程度。- verbose=0 (默认): 不打印任何信息 - verbose=1: 打印正在拟合的回归器的编号和名称 - verbose=2: 打印正在拟合的回归器参数信息 - verbose>2: 将底层回归器的 verbose 参数更改为 self.verbose - 2

• use_features_in_secondary : 布尔值 (默认: False)

  如果为 True，元回归器将同时在原始回归器的预测值和原始数据集上进行训练。如果为 False，元回归器将仅在原始回归器的预测值上进行训练。

• store_train_meta_features : 布尔值 (默认: False)

  如果为 True，则用于拟合元回归器的训练数据计算出的元特征将存储在 self.train_meta_features_ 数组中，可在调用 fit 后访问。

属性

• regr_ : list, 形状=[n_regressors]

  已拟合的回归器（原始回归器的克隆）

• meta_regr_ : 估计器

  已拟合的元回归器（原始元估计器的克隆）

• coef_ : 数组类型, 形状 = [n_features]

  已拟合元估计器的模型系数

• intercept_ : float

  已拟合元估计器的截距

• train_meta_features : numpy 数组,

  形状 = [n_samples, len(self.regressors)] 训练数据的元特征，其中 n_samples 是训练数据中的样本数，len(self.regressors) 是回归器的数量。

• refit : 布尔值 (默认: True)

  如果为 True (默认)，则为堆叠回归克隆回归器，否则使用原始回归器，原始回归器将在调用 fit 方法时在数据集上重新拟合。如果使用的估计器支持 scikit-learn 的 fit/predict API 接口但不兼容 scikit-learn 的 clone 函数，则建议将 refit 设置为 False。

示例

使用示例请参阅 https://mlxtend.cn/mlxtend/user_guide/regressor/StackingRegressor/

方法

---

fit(X, y, sample_weight=None)

从训练数据中学习每个回归器的权重系数。

参数

• X : {数组类型, 稀疏矩阵}, 形状 = [n_samples, n_features]

  训练向量，其中 n_samples 是样本数，n_features 是特征数。

• y : numpy 数组, 形状 = [n_samples] 或 [n_samples, n_targets]

  目标值。只有当 self.multi_output 为 True 时才支持多个目标。

• sample_weight : 数组类型, 形状 = [n_samples], 可选

  样本权重作为 sample_weights 传递给回归器列表中的每个回归器以及元回归器。如果某些回归器在 fit() 方法中不支持 sample_weight，则会引发错误。

返回

• self : 对象

---

fit_transform(X, y=None, \*\*fit_params)

拟合数据，然后进行转换。

Fits transformer to `X` and `y` with optional parameters `fit_params`
and returns a transformed version of `X`.

参数

• X : 形状为 (n_samples, n_features) 的数组类型

  输入样本。

• y : 形状为 (n_samples,) 或 (n_samples, n_outputs) 的数组类型, 默认=None

  目标值 (无监督转换时为 None)。

• \*\*fit_params : dict

  额外的拟合参数。

返回

• X_new : 形状为 (n_samples, n_features_new) 的 ndarray 数组

  转换后的数组。

---

get_params(deep=True)

返回估计器参数名称，用于支持 GridSearch。

---

predict(X)

预测 X 的目标值。

参数

• X : {数组类型, 稀疏矩阵}, 形状 = [n_samples, n_features]

  训练向量，其中 n_samples 是样本数，n_features 是特征数。

返回

• y_target : 数组类型, 形状 = [n_samples] 或 [n_samples, n_targets]

  预测的目标值。

---

predict_meta_features(X)

获取测试数据的元特征。

参数

• X : numpy 数组, 形状 = [n_samples, n_features]

  测试向量，其中 n_samples 是样本数，n_features 是特征数。

返回

• meta-features : numpy 数组, 形状 = [n_samples, len(self.regressors)]

  测试数据的元特征，其中 n_samples 是测试数据中的样本数，len(self.regressors) 是回归器的数量。如果 self.multi_output 为 True，则列数为 len(self.regressors) * n_targets

---

score(X, y, sample_weight=None)

返回预测的决定系数 :math:`R^2`。

The coefficient :math:`R^2` is defined as :math:`(1 - \frac{u}{v})`,
where :math:`u` is the residual sum of squares ``((y_true - y_pred)

** 2).sum()，而 :math:`v` 是总平方和((y_true - y_true.mean()) \*\* 2).sum()``。最佳可能分数是 1.0，它可以

为负数（因为模型可能任意差）。一个

始终预测 y 期望值而忽略输入特征的常数模型将获得 0.0 的 :math:`R^2` 分数。

参数

• X : 形状为 (n_samples, n_features) 的数组类型

  测试样本。对于某些估计器，这可能是一个预先计算好的核矩阵或通用对象列表，其形状为 (n_samples, n_samples_fitted)，其中 n_samples_fitted 是用于估计器拟合的样本数。

• y : 形状为 (n_samples,) 或 (n_samples, n_outputs) 的数组类型

  X 的真实值。

• sample_weight : 形状为 (n_samples,) 的数组类型, 默认=None

  样本权重。

返回

• score : float

  self.predict(X) 相对于 y 的 :math:`R^2`。

注意

在回归器上调用 score 时使用的 :math:`R^2` 分数从 0.23 版本开始使用 multioutput='uniform_average'，以保持与 :func:~sklearn.metrics.r2_score 的默认值一致。这会影响所有多输出回归器（除了 :class:~sklearn.multioutput.MultiOutputRegressor）的 score 方法。

---

set_params(\*\*params)

设置此估计器的参数。

Valid parameter keys can be listed with ``get_params()``.

返回

self

属性

---

coef_

无

---

intercept_

无

---

named_regressors

无

ython