Question

我正在尝试解决回归任务。我发现有3个模型可以很好地处理不同的数据子集：LassoLARS，SVR和Gradient Tree Boosting。我注意到，当我使用所有这3个模型进行预测时，然后制作一个“真正输出”的表格。我的3个模型的输出我看到每次至少有一个模型真的接近真实输出，但其他两个模型可能相对较远。

当我计算最小可能的错误时（如果我从每个测试示例的最佳＆＃39;预测器中获取预测），我得到的错误远小于任何模型的错误。所以我想到尝试将这3种不同模型的预测结合到某种集合中。问题是，如何正确地做到这一点？我的所有3个模型都是使用scikit-learn构建和调整的，它是否提供某种方法可用于将模型打包到整体中？这里的问题是我不想只是对所有三个模型进行平均预测，我想用加权来做这个，加权应该根据具体例子的属性确定。

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

Answer 1

这是分层预测的一个有趣的（通常是痛苦的！）问题。在列车数据上训练多个预测器，然后再次使用列车数据训练更高预测值的问题与偏差 - 方差分解有关。

假设您有两个预测变量，一个基本上是另一个的过度拟合版本，那么前者将出现在火车上，而不是后者。结合预测器将有利于前者没有真正的原因，只是因为它无法区分过度拟合和真正的高质量预测。

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

Shahar Azulay＆amp;我写了一个变换器阶段来解决这个问题：

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

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

Answer 2

好的，花了一些时间在谷歌搜索＆＃39;堆积＆＃39; （正如之前提到的@andreas）我发现即使使用scikit-learn也可以在python中进行加权。请考虑以下内容：

我训练了一组回归模型（如SVR，LassoLars和GradientBoostingRegressor所述）。然后我将所有这些数据运行在训练数据上（用于训练这3个回归量中的每一个的相同数据）。我得到了每个算法的例子的预测，并将这3个结果保存到pandas数据框中，其中列有“预测的SVR”，“预测的LASSO＆＃39;和＆＃39;预测的GBR＆＃39;我将最后一栏添加到这个数据区域中，我称之为“预测”和＃39;这是一个真实的预测值。

然后我只是对这个新数据帧进行线性回归：

#df - dataframe with results of 3 regressors and true output
from sklearn linear_model
stacker= linear_model.LinearRegression()
stacker.fit(df[['predictedSVR', 'predictedLASSO', 'predictedGBR']], df['predicted'])

因此，当我想对新示例做出预测时，我会分别运行我的3个回归量中的每一个然后执行：

stacker.predict()

我的3个回归量的输出。得到一个结果。

这里的问题是我找到了回归量的最佳权重，平均而言，我将尝试进行预测的每个例子的权重都相同。

Answer 3

你所描述的被称为“堆叠”，但尚未在scikit-learn中实现，但我认为贡献是受欢迎的。只有平均值的合奏很快就会出现：https://github.com/scikit-learn/scikit-learn/pull/4161

Answer 4

迟到的回复，但我想为这种叠加回归方法添加一个实用点（我在工作中经常使用它）。

您可能希望为堆栈器选择允许positive = True的算法（例如，ElasticNet）。我发现，当你有一个相对较强的模型时，无约束的LinearRegression（）模型通常会将较大的正系数拟合到较弱的模型，而负系数则较弱。

除非您确实认为您的较弱模型具有负面预测能力，否则这不是一个有用的结果。非常类似于在常规回归模型的特征之间具有高多重共线性。导致各种边缘效应。

此评论最重要地适用于嘈杂的数据情况。如果您的目标是获得0.9-0.95-0.99的RSQ，那么您可能想要抛弃负面加权的模型。

使用scikit-learn（或任何其他python框架）的不同种类的回归量的集合

4 个答案: