xgboost in R: wie funktioniert xgb.cv pass die optimalen Parameter in xgb.Zug

Sieht aus wie Sie falsch verstanden xgb.cv ist es kein parameter der Suche-Funktion. Es tut k-folds cross-validation, nichts mehr.

In Ihrem code, es ändert nicht den Wert der param.

Zu finden, die besten Parameter in R XGBoost, gibt es einige Methoden. Dies sind die 2 Methoden,

(1) Verwenden Sie mlr - Paket, http://mlr-org.github.io/mlr-tutorial/release/html/

Es ist ein XGBoost + mlr Beispielcode in der Kaggle - Prudential Herausforderung,

Aber, dass code für die regression, nicht-Klassifizierung. Soweit ich weiß, gibt es keine mlogloss Metrik noch in mlr - Paket, so müssen Sie den code, der mlogloss Messung von Grund auf selbst. CMIIW.

(2) eine Zweite Methode, durch die manuelle Einstellung der Parameter wiederholen Sie die Schritte, Beispiel,

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)

Dann finden Sie Sie die besten (minimum) mlogloss,

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

min_logloss ist der minimale Wert von mlogloss, während min_logloss_index ist der index (Runde).

Müssen Sie wiederholen Sie den obigen Vorgang mehrere Male, jedes mal ändern Sie die Parameter manuell (mlr funktioniert das wiederholen für Sie). Bis schließlich Sie bekommen die besten globalen minimum min_logloss.

Hinweis: Sie es tun können, in einer Schleife von 100 oder 200 Iterationen, in denen für jede iteration legen Sie den Parameter-Wert zufällig. Dieser Weg, müssen Sie speichern Sie die besten [parameters_list, min_logloss, min_logloss_index] in Variablen oder in einer Datei.

Hinweis: besser, zufällige Streuung von set.seed() für reproduzierbare Ergebnis. Verschiedene zufällige Streuung ergibt anderes Ergebnis. So speichern Sie [parameters_list, min_logloss, min_logloss_index, seednumber] in der Variablen oder Datei.

Sagen, dass schließlich Sie bekommen 3 Ergebnisse in 3 Iterationen/Wiederholungen:

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

Dann müssen Sie den Dritten Parameter (es hat Globale minimum min_logloss von 1.9745). Ihre beste index (nrounds)780.

Einmal erzielen Sie die besten Parameter, verwenden Sie es in der Ausbildung,

# 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)

Ich glaube nicht, dass Sie brauchen watchlist im training, weil Sie getan haben, die cross-Validierung. Aber wenn Sie weiterhin verwenden möchten watchlist ist es nur okay.

Sogar noch besser, Sie verwenden können, frühzeitig zu stoppen in 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)

Mit diesem code, wenn mlogloss Wert nicht gesunken ist in 8 Schritte, die xgb.cv zu stoppen. Sie können Zeit sparen. Sie müssen maximize zu FALSEweil Sie erwarten, dass mindestens mlogloss.

Hier ist ein Beispiel code, mit 100 Iterationen der Schleife, und zufällig gewählte Parameter.

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)

Mit diesem code, den Sie ausführen Kreuzvalidierung 100 mal, jedes mal mit zufälligen Parametern. Dann bekommen Sie den besten Parametersatz, der in der iteration mit mindestens min_logloss.

Erhöhen Sie den Wert von early.stop.round im Falle Sie feststellen, dass es zu klein (zu früh beendet). Sie müssen auch die zufälligen Werte der parameter' limit auf der Grundlage der Daten Merkmale.

Und für 100 oder 200 Iterationen, ich denke Sie ändern möchten verbose auf FALSE.

Seite Hinweis:das Beispiel von random-Methode, können Sie es z.B. durch Bayes-Optimierung für die bessere Methode. Wenn Sie Python-version XGBoost, es ist eine gute hyperparameter Skript für XGBoost, https://github.com/mpearmain/BayesBoostum die Suche für die besten Parameter einer Bayes ' schen Optimierung.

Edit: ich möchte hinzufügen 3. die manuelle Methode, geschrieben von "Davut Polat" Kaggle master, in der Kaggle forum.

Edit: Wenn du weißt, Python und sklearn, können Sie auch GridSearchCV zusammen mit xgboost.XGBClassifier oder xgboost.XGBRegressor

InformationsquelleAutor der Antwort silo