machine-learning - 使用 scikit-learn(或任何其他 python 框架)的不同类型回归器的集合

Question

我正在尝试解决回归任务。我发现 3 个模型适用于不同的数据子集:LassoLARS、SVR 和 Gradient Tree Boosting。我注意到，当我使用所有这 3 个模型进行预测，然后制作“真实输出”和 3 个模型的输出的表格时，我发现每次至少有一个模型非常接近真实输出，尽管另外 2 个模型可能比较远。

当我计算最小可能误差时(如果我从每个测试示例的“最佳”预测器中进行预测)，我得到的误差比任何模型单独的误差都要小得多。所以我考虑尝试将这 3 个不同模型的预测结合到某种集合中。问题是，如何正确地做到这一点？我的所有 3 个模型都是使用 scikit-learn 构建和调整的，它是否提供了某种可用于将模型打包到集成中的方法？这里的问题是，我不想仅仅对所有三个模型的预测进行平均，我想通过加权来实现这一点，其中权重应该根据特定示例的属性来确定。

即使 scikit-learn 没有提供这样的功能，如果有人知道如何解决这个任务 - 计算出数据中每个示例的每个模型的权重，那就太好了。我认为这可能是通过在所有这 3 个模型之上构建的单独回归器来完成的，它将尝试为 3 个模型中的每一个模型输出最佳权重，但我不确定这是否是最好的方法。

Answer 1

这是一个众所周知的有趣(而且通常很痛苦!)的分层预测问题。在训练数据上训练多个预测器，然后在它们上训练更高的预测器，再次使用训练数据的问题与偏差方差分解有关。

假设您有两个预测变量，一个本质上是另一个的过度拟合版本，那么前者在训练集上会比后者更好。组合预测器会毫无理由地偏向前者，只是因为它无法区分过度拟合和真正的高质量预测。

处理此问题的已知方法是，根据不适合该行的模型，为训练数据中的每一行、每个预测变量准备该行的预测。例如，对于过度拟合版本，平均而言，这不会为该行产生良好的结果。然后，组合预测器将能够更好地评估用于组合较低级别预测器的公平模型。

Shahar Azulay 和我编写了一个 Transformer 阶段来处理这个问题:

class Stacker(object):
    """
    A transformer applying fitting a predictor `pred` to data in a way
        that will allow a higher-up predictor to build a model utilizing both this 
        and other predictors correctly.

    The fit_transform(self, x, y) of this class will create a column matrix, whose 
        each row contains the prediction of `pred` fitted on other rows than this one. 
        This allows a higher-level predictor to correctly fit a model on this, and other
        column matrices obtained from other lower-level predictors.

    The fit(self, x, y) and transform(self, x_) methods, will fit `pred` on all 
        of `x`, and transform the output of `x_` (which is either `x` or not) using the fitted 
        `pred`.

    Arguments:    
        pred: A lower-level predictor to stack.

        cv_fn: Function taking `x`, and returning a cross-validation object. In `fit_transform`
            th train and test indices of the object will be iterated over. For each iteration, `pred` will
            be fitted to the `x` and `y` with rows corresponding to the
            train indices, and the test indices of the output will be obtained
            by predicting on the corresponding indices of `x`.
    """
    def __init__(self, pred, cv_fn=lambda x: sklearn.cross_validation.LeaveOneOut(x.shape[0])):
        self._pred, self._cv_fn  = pred, cv_fn

    def fit_transform(self, x, y):
        x_trans = self._train_transform(x, y)

        self.fit(x, y)

        return x_trans

    def fit(self, x, y):
        """
        Same signature as any sklearn transformer.
        """
        self._pred.fit(x, y)

        return self

    def transform(self, x):
        """
        Same signature as any sklearn transformer.
        """
        return self._test_transform(x)

    def _train_transform(self, x, y):
        x_trans = np.nan * np.ones((x.shape[0], 1))

        all_te = set()
        for tr, te in self._cv_fn(x):
            all_te = all_te | set(te)
            x_trans[te, 0] = self._pred.fit(x[tr, :], y[tr]).predict(x[te, :]) 
        if all_te != set(range(x.shape[0])):
            warnings.warn('Not all indices covered by Stacker', sklearn.exceptions.FitFailedWarning)

        return x_trans

    def _test_transform(self, x):
        return self._pred.predict(x)

<小时/>

这是 @MaximHaytovich 的答案中描述的设置改进的示例。

首先，一些设置:

    from sklearn import linear_model
    from sklearn import cross_validation
    from sklearn import ensemble
    from sklearn import metrics

    y = np.random.randn(100)
    x0 = (y + 0.1 * np.random.randn(100)).reshape((100, 1)) 
    x1 = (y + 0.1 * np.random.randn(100)).reshape((100, 1)) 
    x = np.zeros((100, 2)) 

请注意，x0 和 x1 只是 y 的嘈杂版本。我们将使用前 80 行进行训练，最后 20 行进行测试。

这是两个预测​​器:高方差梯度增强器和线性预测器:

    g = ensemble.GradientBoostingRegressor()
    l = linear_model.LinearRegression()

以下是答案中建议的方法:

    g.fit(x0[: 80, :], y[: 80])
    l.fit(x1[: 80, :], y[: 80])

    x[:, 0] = g.predict(x0)
    x[:, 1] = l.predict(x1)

    >>> metrics.r2_score(
        y[80: ],
        linear_model.LinearRegression().fit(x[: 80, :], y[: 80]).predict(x[80: , :]))
    0.940017788444

现在，使用堆叠:

    x[: 80, 0] = Stacker(g).fit_transform(x0[: 80, :], y[: 80])[:, 0]
    x[: 80, 1] = Stacker(l).fit_transform(x1[: 80, :], y[: 80])[:, 0]

    u = linear_model.LinearRegression().fit(x[: 80, :], y[: 80])

    x[80: , 0] = Stacker(g).fit(x0[: 80, :], y[: 80]).transform(x0[80:, :])
    x[80: , 1] = Stacker(l).fit(x1[: 80, :], y[: 80]).transform(x1[80:, :])

    >>> metrics.r2_score(
        y[80: ],
        u.predict(x[80:, :]))
    0.992196564279

堆叠预测效果更好。它意识到梯度增强器并不是那么好。