xgboost dans R: comment xgb.cv transmet les paramètres optimaux à xgb.train

J'ai été d'explorer la xgboost paquet dans R et est passé par plusieurs démos ainsi que des tutoriels mais cela me confond: après l'utilisation de xgb.cv de faire de la validation croisée, comment fonctionne l'optimisation des paramètres se passait à xgb.train? Ou dois-je calculer les paramètres idéal (comme nroundmax.depth) basé sur la sortie de 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)

source d'informationauteur snowneji

  1. 50

    Dirait que vous vous êtes mal compris xgb.cvil n'est pas un paramètre de la fonction de recherche. Il ne k-plis de la validation croisée, rien de plus.

    Dans votre code, il ne change pas la valeur de param.

    Pour trouver les meilleurs paramètres de R XGBoost, il existe quelques méthodes. Ces 2 méthodes,

    (1) l'Utilisation mlr paquet, http://mlr-org.github.io/mlr-tutorial/release/html/

    Il y a un XGBoost + mlr exemple de code dans le Kaggle Prudentielle de défi,

    Mais que le code est pour la régression, pas de classement. Autant que je sache, il n'y a pas de mlogloss métrique encore dans mlr package, vous devez le code de la mlogloss de mesure à partir de zéro par vous-même. CMIIW.

    (2) Deuxième méthode, en réglant manuellement les paramètres, puis répéter, par exemple, 

    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)

    Ensuite, vous y trouverez le meilleur (minimum) mlogloss, 

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

    min_logloss est la valeur minimum de mlogloss, tandis que min_logloss_index est l'index (rond).

    Vous devez répéter le processus ci-dessus à plusieurs reprises, chaque fois de modifier les paramètres manuellement (mlr ne le répétez l'opération pour vous). Jusqu'à ce que finalement vous recevez le meilleur minimum global min_logloss.

    Remarque: Vous pouvez le faire dans une boucle de 100 ou 200 itérations, dans lequel, pour chaque itération, vous définissez les paramètres de la valeur au hasard. De cette façon, vous devez enregistrer le meilleur [parameters_list, min_logloss, min_logloss_index] dans des variables ou dans un fichier.

    Remarque: mieux définir aléatoire par set.seed() pour reproductible résultat. Aléatoire différent, les rendements en graines résultat différent. Ainsi, vous devez vous enregistrer [parameters_list, min_logloss, min_logloss_index, seednumber] dans les variables ou d'un fichier.

    Dire que, finalement, vous obtenez 3 résultats en 3 itérations/répétitions: 

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

    Ensuite, vous devez utiliser la troisième paramètres (il a un minimum global min_logloss de 1.9745). Votre meilleur indice (nrounds) est 780.

    Une fois que vous obtenez le meilleur des paramètres, de l'utiliser dans la formation, 

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

    Je ne pense pas que vous avez besoin watchlist dans la formation, parce que vous avez fait de la validation croisée. Mais si vous voulez continuer à utiliser watchlistil est juste correct.

    Même mieux, vous pouvez utiliser dès le début de s'arrêter dans 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)

    Avec ce code, lorsque mlogloss valeur ne diminue pas en 8 étapes, le xgb.cv va s'arrêter. Vous pouvez gagner du temps. Vous devez définir maximize à FALSEparce que vous vous attendez minimum mlogloss.

    Voici un exemple de code, avec 100 itérations de la boucle, et au hasard des paramètres choisis. 

    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)

    Avec ce code, vous exécutez la validation croisée 100 fois, chaque fois avec des paramètres aléatoires. Ensuite, vous obtenez le meilleur jeu de paramètres, qui est dans l'itération avec un minimum de min_logloss.

    Augmentation de la valeur de early.stop.round dans le cas où vous trouvez que c'est trop petit (trop tôt, l'arrêt). Vous devez également modifier le paramètre aléatoire de la valeur limite en fonction de vos caractéristiques de données.

    Et, pour 100 ou 200 itérations, je pense que vous souhaitez modifier verbose à FALSE.

    Note de côté: Qui est un exemple de méthode aléatoire, vous pouvez l'ajuster par exemple par Bayésien d'optimisation pour une meilleure méthode. Si vous avez une version de Python de XGBoost, il y a une bonne hyper-paramètre de script pour XGBoost, https://github.com/mpearmain/BayesBoost à la recherche de meilleures paramètres définis à l'aide de Bayésienne d'optimisation.

    Edit: je veux ajouter un 3ème méthode manuelle, publiée par "Davut Polat" un Kaggle maître, dans la Kaggle forum.

    Edit: Si vous connaissez Python et sklearn, vous pouvez également utiliser GridSearchCV avec xgboost.XGBClassifier ou xgboost.XGBRegressor

  2. 1

    C'est une bonne question et une grande réponse de silo avec beaucoup de détails! Je l'ai trouvé très utile pour quelqu'un de nouveau à xgboost comme moi. Je vous remercie. La méthode aléatoire et par rapport à la limite est très inspirant. Bon à utiliser et bon à savoir. Maintenant, en 2018, d'une légère réviser sont nécessaires, par exemple, early.stop.round devrait être early_stopping_rounds. La sortie mdcv est organisé de façon légèrement différente:

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

    Et dépend de l'application (linéaire, logistique,etc...), le objectiveeval_metric et les paramètres doivent être ajustés en conséquence.

    Pour la commodité de n'importe qui qui est en cours d'exécution d'une régression, ici, c'est le peu modifié la version de code (la plupart sont les mêmes que ci-dessus). 

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