web-dev-qa-db-ja.com

Rのxgboost：xgb.cvが最適なパラメーターをxgb.trainに渡す方法

Rでxgboostパッケージを調査し、いくつかのデモとチュートリアルを試しましたが、これでも混乱します。_xgb.cv_を使用して相互検証を行った後、最適なパラメーターはどのように渡されますか_xgb.train_？または、_max.depth_の出力に基づいて、理想的なパラメーター（nround、_xgb.cv_など）を計算する必要がありますか？

_param <- list("objective" = "multi:softprob",
              "eval_metric" = "mlogloss",
              "num_class" = 12)
cv.nround <- 11
cv.nfold <- 5
mdcv <-xgb.cv(data=dtrain,params = param,nthread=6,nfold = cv.nfold,nrounds = cv.nround,verbose = T)

md <-xgb.train(data=dtrain,params = param,nround = 80,watchlist = list(train=dtrain,test=dtest),nthread=6)
_
rmachine-learningpredictionxgboost
30
snowneji

_xgb.cv_を誤解したように見えますが、これはパラメーター検索関数ではありません。 k倍のクロス検証を行います。

コードでは、paramの値は変更されません。

RのXGBoostで最適なパラメーターを見つけるには、いくつかの方法があります。これらは2つの方法です。

（1）mlrパッケージを使用、 http://mlr-org.github.io/mlr-tutorial/release/html/

KaggleのプルデンシャルチャレンジにはXGBoost + mlr サンプルコード があります。

しかし、そのコードは回帰用であり、分類用ではありません。私が知る限り、mloglossパッケージにはmlrメトリックがまだないので、mlogloss測定を最初からコーディングする必要があります。 CMIIW。

（2）2番目の方法、パラメーターを手動で設定してから繰り返します、例、

_param <- list(objective = "multi:softprob",
      eval_metric = "mlogloss",
      num_class = 12,
      max_depth = 8,
      eta = 0.05,
      gamma = 0.01, 
      subsample = 0.9,
      colsample_bytree = 0.8, 
      min_child_weight = 4,
      max_delta_step = 1
      )
cv.nround = 1000
cv.nfold = 5
mdcv <- xgb.cv(data=dtrain, params = param, nthread=6, 
                nfold=cv.nfold, nrounds=cv.nround,
                verbose = T)
_

次に、最適な（最小の）mloglossを見つけます。

_min_logloss = min(mdcv[, test.mlogloss.mean])
min_logloss_index = which.min(mdcv[, test.mlogloss.mean])
_

_min_logloss_はmloglossの最小値であり、_min_logloss_index_はインデックス（ラウンド）です。

上記のプロセスを数回繰り返す必要があり、そのたびにパラメーターを手動で変更します（mlrは繰り返しを行います）。最後に、最高のグローバル最小値_min_logloss_を取得します。

注：100回または200回の繰り返しのループで行うことができ、各繰り返しに対してパラメーター値をランダムに設定します。この方法では、変数またはファイルに最適な_[parameters_list, min_logloss, min_logloss_index]_を保存する必要があります。

注：reproducible結果に対してset.seed()でランダムシードを設定する方が良い異なるランダムシードは異なる結果をもたらします。そのため、変数またはファイルに_[parameters_list, min_logloss, min_logloss_index, seednumber]_を保存する必要があります。

最後に、3回の反復/繰り返しで3つの結果が得られたとします。

_min_logloss = 2.1457, min_logloss_index = 840
min_logloss = 2.2293, min_logloss_index = 920
min_logloss = 1.9745, min_logloss_index = 780
_

次に、3番目のパラメーターを使用する必要があります（グローバル最小値_min_logloss_ of _1.9745_）。最適なインデックス（ラウンド）は_780_です。

最適なパラメータを取得したら、それをトレーニングで使用し、

_# best_param is global best param with minimum min_logloss
# best_min_logloss_index is the global minimum logloss index
nround = 780
md <- xgb.train(data=dtrain, params=best_param, nrounds=nround, nthread=6)
_

クロス検証を行ったため、トレーニングでwatchlistは必要ないと思います。ただし、watchlistを引き続き使用する場合は問題ありません。

_xgb.cv_で早期停止を使用することもできます。

_mdcv <- xgb.cv(data=dtrain, params=param, nthread=6, 
                nfold=cv.nfold, nrounds=cv.nround,
                verbose = T, early.stop.round=8, maximize=FALSE)
_

このコードでは、mlogloss値が8ステップで減少しない場合、_xgb.cv_は停止します。時間を節約できます。最小のmloglossが予想されるため、maximizeをFALSEに設定する必要があります。

以下に、100回の反復ループとランダムに選択されたパラメーターを含むサンプルコードを示します。

_best_param = list()
best_seednumber = 1234
best_logloss = Inf
best_logloss_index = 0

for (iter in 1:100) {
    param <- list(objective = "multi:softprob",
          eval_metric = "mlogloss",
          num_class = 12,
          max_depth = sample(6:10, 1),
          eta = runif(1, .01, .3),
          gamma = runif(1, 0.0, 0.2), 
          subsample = runif(1, .6, .9),
          colsample_bytree = runif(1, .5, .8), 
          min_child_weight = sample(1:40, 1),
          max_delta_step = sample(1:10, 1)
          )
    cv.nround = 1000
    cv.nfold = 5
    seed.number = sample.int(10000, 1)[[1]]
    set.seed(seed.number)
    mdcv <- xgb.cv(data=dtrain, params = param, nthread=6, 
                    nfold=cv.nfold, nrounds=cv.nround,
                    verbose = T, early.stop.round=8, maximize=FALSE)

    min_logloss = min(mdcv[, test.mlogloss.mean])
    min_logloss_index = which.min(mdcv[, test.mlogloss.mean])

    if (min_logloss < best_logloss) {
        best_logloss = min_logloss
        best_logloss_index = min_logloss_index
        best_seednumber = seed.number
        best_param = param
    }
}

nround = best_logloss_index
set.seed(best_seednumber)
md <- xgb.train(data=dtrain, params=best_param, nrounds=nround, nthread=6)
_

このコードを使用すると、ランダム検証を行うたびにクロス検証を100回実行できます。次に、最適なパラメーターセットを取得します。これは、最小の_min_logloss_を使用した反復です。

小さすぎる（停止が早すぎる）ことがわかった場合は、_early.stop.round_の値を増やします。また、データの特性に基づいて、ランダムパラメーター値の制限を変更する必要があります。

そして、100回または200回の繰り返しで、verboseをFALSEに変更したいと思います。

サイドノート：これはランダムな方法の例であり、調整することができます。より良い方法のためのベイズ最適化による。 XGBoostのPythonバージョン）がある場合、XGBoostの優れたハイパーパラメータースクリプトがあります。 https://github.com/mpearmain/BayesBoost 最適なパラメーターセットを検索ベイジアン最適化を使用します。

編集： Kaggleフォーラム に、Kaggleマスターの "Davut Polat"が投稿した3番目の手動メソッドを追加します。

編集：Pythonおよびsklearnを知っている場合、xgboost.XGBClassifierまたはxgboost.XGBRegressorとともに GridSearchCV を使用することもできます。

71
silo

これはsiloからの良い質問であり、素晴らしい返信です。私のようなxgboostが初めての人にとってはとても助かりました。ありがとうございました。ランダム化して境界と比較する方法は非常に刺激的です。使いやすく、知っておくと良い。現在、2018年には若干の修正が必要です。たとえば、early.stop.roundはearly_stopping_rounds。出力mdcvの編成はわずかに異なります。

  min_rmse_index  <-  mdcv$best_iteration
  min_rmse <-  mdcv$evaluation_log[min_rmse_index]$test_rmse_mean

また、アプリケーション（線形、ロジスティックなど）、objective、eval_metricおよびパラメータはそれに応じて調整されます。

回帰を実行している人の便宜のために、ここにコードのわずかに調整されたバージョンがあります（ほとんどは上記と同じです）。

library(xgboost)
# Matrix for xgb: dtrain and dtest, "label" is the dependent variable
dtrain <- xgb.DMatrix(X_train, label = Y_train)
dtest <- xgb.DMatrix(X_test, label = Y_test)

best_param <- list()
best_seednumber <- 1234
best_rmse <- Inf
best_rmse_index <- 0

set.seed(123)
for (iter in 1:100) {
  param <- list(objective = "reg:linear",
                eval_metric = "rmse",
                max_depth = sample(6:10, 1),
                eta = runif(1, .01, .3), # Learning rate, default: 0.3
                subsample = runif(1, .6, .9),
                colsample_bytree = runif(1, .5, .8), 
                min_child_weight = sample(1:40, 1),
                max_delta_step = sample(1:10, 1)
  )
  cv.nround <-  1000
  cv.nfold <-  5 # 5-fold cross-validation
  seed.number  <-  sample.int(10000, 1) # set seed for the cv
  set.seed(seed.number)
  mdcv <- xgb.cv(data = dtrain, params = param,  
                 nfold = cv.nfold, nrounds = cv.nround,
                 verbose = F, early_stopping_rounds = 8, maximize = FALSE)

  min_rmse_index  <-  mdcv$best_iteration
  min_rmse <-  mdcv$evaluation_log[min_rmse_index]$test_rmse_mean

  if (min_rmse < best_rmse) {
    best_rmse <- min_rmse
    best_rmse_index <- min_rmse_index
    best_seednumber <- seed.number
    best_param <- param
  }
}

# The best index (min_rmse_index) is the best "nround" in the model
nround = best_rmse_index
set.seed(best_seednumber)
xg_mod <- xgboost(data = dtest, params = best_param, nround = nround, verbose = F)

# Check error in testing data
yhat_xg <- predict(xg_mod, dtest)
(MSE_xgb <- mean((yhat_xg - Y_test)^2))
3
Yang Liu

サイロの答えは非常に役立つことがわかりました。彼のランダム研究のアプローチに加えて、ベイジアン最適化を使用して、ハイパーパラメーター検索のプロセスを促進することができます。 rBayesianOptimizationライブラリ 。以下は、rbayesianoptimizationライブラリを使用した私のコードです。

cv_folds <- KFold(dataFTR$isPreIctalTrain, nfolds = 5, stratified = FALSE, seed = seedNum)
xgb_cv_bayes <- function(nround,max.depth, min_child_weight, subsample,eta,gamma,colsample_bytree,max_delta_step) {
param<-list(booster = "gbtree",
            max_depth = max.depth,
            min_child_weight = min_child_weight,
            eta=eta,gamma=gamma,
            subsample = subsample, colsample_bytree = colsample_bytree,
            max_delta_step=max_delta_step,
            lambda = 1, alpha = 0,
            objective = "binary:logistic",
            eval_metric = "auc")
cv <- xgb.cv(params = param, data = dtrain, folds = cv_folds,nrounds = 1000,early_stopping_rounds = 10, maximize = TRUE, verbose = verbose)

list(Score = cv$evaluation_log$test_auc_mean[cv$best_iteration],
     Pred=cv$best_iteration)
# we don't need cross-validation prediction and we need the number of rounds.
# a workaround is to pass the number of rounds(best_iteration) to the Pred, which is a default parameter in the rbayesianoptimization library.
}
OPT_Res <- BayesianOptimization(xgb_cv_bayes,
                              bounds = list(max.depth =c(3L, 10L),min_child_weight = c(1L, 40L),
                                            subsample = c(0.6, 0.9),
                                            eta=c(0.01,0.3),gamma = c(0.0, 0.2),
                                            colsample_bytree=c(0.5,0.8),max_delta_step=c(1L,10L)),
                              init_grid_dt = NULL, init_points = 10, n_iter = 10,
                              acq = "ucb", kappa = 2.576, eps = 0.0,
                              verbose = verbose)
best_param <- list(
booster = "gbtree",
eval.metric = "auc",
objective = "binary:logistic",
max_depth = OPT_Res$Best_Par["max.depth"],
eta = OPT_Res$Best_Par["eta"],
gamma = OPT_Res$Best_Par["gamma"],
subsample = OPT_Res$Best_Par["subsample"],
colsample_bytree = OPT_Res$Best_Par["colsample_bytree"],
min_child_weight = OPT_Res$Best_Par["min_child_weight"],
max_delta_step = OPT_Res$Best_Par["max_delta_step"])
# number of rounds should be tuned using CV
#https://www.hackerearth.com/practice/machine-learning/machine-learning-algorithms/beginners-tutorial-on-xgboost-parameter-tuning-r/tutorial/
# However, nrounds can not be directly derivied from the bayesianoptimization function
# Here, OPT_Res$Pred, which was supposed to be used for cross-validation, is used to record the number of rounds
nrounds=OPT_Res$Pred[[which.max(OPT_Res$History$Value)]]
xgb_model <- xgb.train (params = best_param, data = dtrain, nrounds = nrounds)
1
Penning Yu