Question

我想在scikit-learnns early-stopping - 方法中使用GridSearchCV - 选项。此SO中显示了一个示例 - thread：

import xgboost as xgb
from sklearn.model_selection import GridSearchCV

trainX= [[1], [2], [3], [4], [5]]
trainY = [1, 2, 3, 4, 5]

testX = trainX 
testY = trainY

param_grid = {"subsample" : [0.5, 0.8],
              "n_estimators" : [600]}

fit_params = {"early_stopping_rounds":1,
             "eval_set" : [[testX, testY]]}


model = xgb.XGBRegressor()
gridsearch = GridSearchCV(estimator  = xgb.XGBRegressor(), 
                          param_grid=param_grid,
                          fit_params=fit_params,                          
                          verbose=1,                          
                          cv=2)
gridsearch.fit(trainX,trainY)

但是，我想将验证设置用作交叉验证过程的保留集。有没有办法在GridSearchCV中指定它？

Answer 1

对于xgboost的当前实现（指版本0.6和0.7），这是不可能的。请注意原生 xgboost

之间的区别

    xgboost.train(params, dtrain, num_boost_round=10, evals=(), obj=None, 
feval=None, maximize=False, early_stopping_rounds=None, evals_result=None, 
verbose_eval=True, xgb_model=None, callbacks=None, learning_rates=None)

或

xgboost.cv(params, dtrain, num_boost_round=10, nfold=3, stratified=False, 
folds=None, metrics=(), obj=None, feval=None, maximize=False, 
early_stopping_rounds=None, fpreproc=None, as_pandas=True, verbose_eval=None, 
show_stdv=True, seed=0, callbacks=None, shuffle=True)

和 sklearn界面：

    class xgboost.XGBRegressor(max_depth=3, learning_rate=0.1, 
n_estimators=100, silent=True, objective='reg:linear', booster='gbtree', 
n_jobs=1, nthread=None, gamma=0, min_child_weight=1, max_delta_step=0, 
subsample=1, colsample_bytree=1, colsample_bylevel=1, reg_alpha=0, 
reg_lambda=1, scale_pos_weight=1, base_score=0.5, random_state=0, seed=None, 
missing=None, **kwargs)

正如您所看到的那样，xgboost.XGBRegressor没有早期停止这样的事情。请注意，sklearn接口是唯一可以与GridSearchCV结合使用的接口，它需要一个带有.fit（）,. predict（）等的正确的sklearn估计器。

您可以将early_stopping_rounds和eval_set作为额外的fit_params传递给GridSearchCV，这实际上可行。但是，GridSearchCV不会更改不同折叠之间的fit_params，因此您最终会在所有折叠中使用相同的eval_set，这可能不是CV的意思。

model=xgb.XGBClassifier()
clf = GridSearchCV(model, parameters,
                         fit_params={'early_stopping_rounds':20,\
                         'eval_set':[(X,y)]},cv=kfold)

经过一些调整后，我找到了最安全的方法来集成early_stopping_rounds和sklearn API，以实现一个自我的早期停止机制。如果GridSearchCV n_rounds作为参数进行调整，则可以执行此操作。然后，您可以通过增加mean_validation_score来查看不同模型的n_rounds。然后你可以定义一个早期停止的自定义启发式;你会注意到默认的那个不是最佳的，所以说。

我认为这也是一种更好的方法，然后为此目的使用单个拆分保留。

Answer 2

回到我构建课程的日子里，包装“HyperOpt”以满足我的需求。

我会尝试为您快速减少它，以便您可以使用它。这里是代码，最后有一些注释，以帮助您解决问题：

import numpy as np
from hyperopt import fmin, tpe, hp, STATUS_OK, Trials
import xgboost as xgb
max_float_digits = 4


def rounded(val):
    return '{:.{}f}'.format(val, max_float_digits)


class HyperOptTuner(object):
    """
    Tune my parameters!
    """
    def __init__(self, dtrain, dvalid, early_stopping=200, max_evals=200):
        self.counter = 0
        self.dtrain = dtrain
        self.dvalid = dvalid
        self.early_stopping = early_stopping
        self.max_evals = max_evals
        self.tuned_params = None


    def score(self, params):
        self.counter += 1
        # Edit params
        print("Iteration {}/{}".format(self.counter, self.max_evals))
        num_round = int(params['n_estimators'])
        del params['n_estimators']

        watchlist = [(self.dtrain, 'train'), (self.dvalid, 'eval')]
        model = xgb.train(params, self.dtrain, num_round, evals=watchlist, early_stopping_rounds=self.early_stopping,
                          verbose_eval=False)
        n_epoach = model.best_ntree_limit
        score = model.best_score
        params['n_estimators'] = n_epoach
        params = dict([(key, rounded(params[key]))
                       if type(params[key]) == float
                       else (key, params[key])
                       for key in params])

        print "Trained with: "
        print params
        print "\tScore {0}\n".format(score)
        return {'loss': 1 - score, 'status': STATUS_OK, 'params': params}

    def optimize(self, trials):
        space = {
            'n_estimators': 2000,  # hp.quniform('n_estimators', 10, 1000, 10),
            'eta': hp.quniform('eta', 0.025, 0.3, 0.025),
            'max_depth': hp.choice('max_depth', np.arange(1, 9, dtype=int)),
            'min_child_weight': hp.choice('min_child_weight', np.arange(1, 10, dtype=int)),
            'subsample': hp.quniform('subsample', 0.3, 1, 0.05),
            'gamma': hp.quniform('gamma', 0.1, 20, 0.1),
            'colsample_bytree': hp.quniform('colsample_bytree', 0.5, 1, 0.25),
            'eval_metric': 'map',
            'objective': 'rank:pairwise',
            'silent': 1
        }

        fmin(self.score, space, algo=tpe.suggest, trials=trials, max_evals=self.max_evals),

        min_loss = 1
        min_params = {}
        for trial in trials.trials:
            tmp_loss, tmp_params = trial['result']['loss'], trial['result']['params']
            if tmp_loss < min_loss:
                min_loss, min_params = tmp_loss, tmp_params

        print("Winning params:")
        print(min_params)
        print "\tScore: {}".format(1-min_loss)
        self.tuned_params = min_params

    def tune(self):
        print "Tuning...\n"
        # Trials object where the history of search will be stored
        trials = Trials()
        self.optimize(trials)

所以我使用了一个类，主要用于定义参数并保存结果以便进一步使用。有2个电源功能。

optimize（）来定义我们的“搜索空间”，计算出来最小化误差的最佳参数（请注意你是 MINIMIZING 错误）并保存找到的最佳参数。还添加了一些打印件，以帮助您遵循该过程。
得分（）以使用特定计算模型的得分来自“搜索空间”的HyperParams。它使用early_stopping作为在类中定义。因为我不需要使用十字架验证我使用过xgb.train（），但您可以将其更改为xgb.cv（）它确实支持early_stopping_rounds。还添加了打印到那里帮助您遵循流程。得分返回1 - 得分（因为我已经计算MAP是一个需要增加的评估，所以如果你计算像RMSE这样的错误，只是按原样返回得分。）

这是你在使用dtrain和dtest矩阵后从代码中激活它的方法：

# dtrain is a training set of type DMatrix
# dtest is a testing set of type DMatrix
tuner = HyperOptTuner(dtrain=dtrain, dvalid=dtest, early_stopping=200, max_evals=400)
tuner.tune()

max_evals是“搜索网格”的大小

请遵循以下指南，如果您遇到问题请与我们联系。

使用GridSearchCV提前停止 - 使用保留的CV集进行验证

2 个答案: