lgb.train.R 12 KB
Newer Older
James Lamb's avatar
James Lamb committed
1
#' @name lgb.train
2
#' @title Main training logic for LightGBM
James Lamb's avatar
James Lamb committed
3
4
#' @description Logic to train with LightGBM
#' @inheritParams lgb_shared_params
5
#' @param valids a list of \code{lgb.Dataset} objects, used for validation
6
#' @param record Boolean, TRUE will record iteration message to \code{booster$record_evals}
Guolin Ke's avatar
Guolin Ke committed
7
#' @param colnames feature names, if not null, will use this to overwrite the names in dataset
8
#' @param categorical_feature list of str or int
9
10
11
12
13
14
#'                            type int represents index,
#'                            type str represents feature names
#' @param callbacks List of callback functions that are applied at each iteration.
#' @param reset_data Boolean, setting it to TRUE (not the default value) will transform the
#'                   booster model into a predictor model which frees up memory and the
#'                   original datasets
James Lamb's avatar
James Lamb committed
15
16
#' @param ... other parameters, see Parameters.rst for more information. A few key parameters:
#'            \itemize{
17
18
19
#'                \item{\code{boosting}: Boosting type. \code{"gbdt"}, \code{"rf"}, \code{"dart"} or \code{"goss"}.}
#'                \item{\code{num_leaves}: Maximum number of leaves in one tree.}
#'                \item{\code{max_depth}: Limit the max depth for tree model. This is used to deal with
James Lamb's avatar
James Lamb committed
20
#'                                 overfit when #data is small. Tree still grow by leaf-wise.}
21
#'                \item{\code{num_threads}: Number of threads for LightGBM. For the best speed, set this to
22
#'                                   the number of real CPU cores, not the number of threads (most
James Lamb's avatar
James Lamb committed
23
24
#'                                   CPU using hyper-threading to generate 2 threads per CPU core).}
#'            }
25
#' @inheritSection lgb_shared_params Early Stopping
26
#' @return a trained booster model \code{lgb.Booster}.
27
#'
Guolin Ke's avatar
Guolin Ke committed
28
#' @examples
29
#' \donttest{
30
31
32
33
34
35
36
37
#' data(agaricus.train, package = "lightgbm")
#' train <- agaricus.train
#' dtrain <- lgb.Dataset(train$data, label = train$label)
#' data(agaricus.test, package = "lightgbm")
#' test <- agaricus.test
#' dtest <- lgb.Dataset.create.valid(dtrain, test$data, label = test$label)
#' params <- list(objective = "regression", metric = "l2")
#' valids <- list(test = dtest)
38
39
40
#' model <- lgb.train(
#'   params = params
#'   , data = dtrain
41
#'   , nrounds = 5L
42
#'   , valids = valids
43
44
#'   , min_data = 1L
#'   , learning_rate = 1.0
45
#'   , early_stopping_rounds = 3L
46
#' )
47
#' }
Guolin Ke's avatar
Guolin Ke committed
48
#' @export
49
50
lgb.train <- function(params = list(),
                      data,
51
                      nrounds = 10L,
52
53
54
                      valids = list(),
                      obj = NULL,
                      eval = NULL,
55
                      verbose = 1L,
56
57
58
59
60
                      record = TRUE,
                      eval_freq = 1L,
                      init_model = NULL,
                      colnames = NULL,
                      categorical_feature = NULL,
61
                      early_stopping_rounds = NULL,
62
                      callbacks = list(),
63
                      reset_data = FALSE,
64
                      ...) {
65

66
67
68
69
70
71
72
73
  # validate inputs early to avoid unnecessary computation
  if (nrounds <= 0L) {
    stop("nrounds should be greater than zero")
  }
  if (!lgb.is.Dataset(data)) {
    stop("lgb.train: data must be an lgb.Dataset instance")
  }
  if (length(valids) > 0L) {
74
    if (!identical(class(valids), "list") || !all(vapply(valids, lgb.is.Dataset, logical(1L)))) {
75
76
77
78
79
80
81
82
      stop("lgb.train: valids must be a list of lgb.Dataset elements")
    }
    evnames <- names(valids)
    if (is.null(evnames) || !all(nzchar(evnames))) {
      stop("lgb.train: each element of valids must have a name")
    }
  }

83
  # Setup temporary variables
84
  additional_params <- list(...)
85
  params <- append(params, additional_params)
Guolin Ke's avatar
Guolin Ke committed
86
  params$verbose <- verbose
87
88
  params <- lgb.check.obj(params = params, obj = obj)
  params <- lgb.check.eval(params = params, eval = eval)
89
  fobj <- NULL
90
  eval_functions <- list(NULL)
91

92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
  # set some parameters, resolving the way they were passed in with other parameters
  # in `params`.
  # this ensures that the model stored with Booster$save() correctly represents
  # what was passed in
  params <- lgb.check.wrapper_param(
    main_param_name = "num_iterations"
    , params = params
    , alternative_kwarg_value = nrounds
  )
  params <- lgb.check.wrapper_param(
    main_param_name = "early_stopping_round"
    , params = params
    , alternative_kwarg_value = early_stopping_rounds
  )
  early_stopping_rounds <- params[["early_stopping_round"]]

108
  # Check for objective (function or not)
109
  if (is.function(params$objective)) {
110
    fobj <- params$objective
Guolin Ke's avatar
Guolin Ke committed
111
112
    params$objective <- "NONE"
  }
113

114
  # If eval is a single function, store it as a 1-element list
115
  # (for backwards compatibility). If it is a list of functions, store
116
117
  # all of them. This makes it possible to pass any mix of strings like "auc"
  # and custom functions to eval
118
  if (is.function(eval)) {
119
120
121
122
123
124
125
    eval_functions <- list(eval)
  }
  if (methods::is(eval, "list")) {
    eval_functions <- Filter(
      f = is.function
      , x = eval
    )
126
  }
127

128
  # Init predictor to empty
Guolin Ke's avatar
Guolin Ke committed
129
  predictor <- NULL
130

131
  # Check for boosting from a trained model
132
  if (is.character(init_model)) {
Guolin Ke's avatar
Guolin Ke committed
133
    predictor <- Predictor$new(init_model)
134
  } else if (lgb.is.Booster(init_model)) {
Guolin Ke's avatar
Guolin Ke committed
135
136
    predictor <- init_model$to_predictor()
  }
137

138
  # Set the iteration to start from / end to (and check for boosting from a trained model, again)
139
  begin_iteration <- 1L
140
  if (!is.null(predictor)) {
141
    begin_iteration <- predictor$current_iter() + 1L
Guolin Ke's avatar
Guolin Ke committed
142
  }
143
  end_iteration <- begin_iteration + params[["num_iterations"]] - 1L
144

145
146
147
148
  # Construct datasets, if needed
  data$update_params(params = params)
  data$construct()

149
150
151
152
153
154
  # Check interaction constraints
  cnames <- NULL
  if (!is.null(colnames)) {
    cnames <- colnames
  } else if (!is.null(data$get_colnames())) {
    cnames <- data$get_colnames()
155
  }
156
  params[["interaction_constraints"]] <- lgb.check_interaction_constraints(params, cnames)
157

158
  # Update parameters with parsed parameters
Guolin Ke's avatar
Guolin Ke committed
159
  data$update_params(params)
160

161
  # Create the predictor set
Guolin Ke's avatar
Guolin Ke committed
162
  data$.__enclos_env__$private$set_predictor(predictor)
163

164
165
166
167
  # Write column names
  if (!is.null(colnames)) {
    data$set_colnames(colnames)
  }
168

169
170
171
172
  # Write categorical features
  if (!is.null(categorical_feature)) {
    data$set_categorical_feature(categorical_feature)
  }
173

174
  valid_contain_train <- FALSE
175
176
  train_data_name <- "train"
  reduced_valid_sets <- list()
177

178
  # Parse validation datasets
179
  if (length(valids) > 0L) {
180

181
    # Loop through all validation datasets using name
Guolin Ke's avatar
Guolin Ke committed
182
    for (key in names(valids)) {
183

184
      # Use names to get validation datasets
Guolin Ke's avatar
Guolin Ke committed
185
      valid_data <- valids[[key]]
186

187
      # Check for duplicate train/validation dataset
188
      if (identical(data, valid_data)) {
189
        valid_contain_train <- TRUE
190
        train_data_name <- key
Guolin Ke's avatar
Guolin Ke committed
191
192
        next
      }
193

194
      # Update parameters, data
Guolin Ke's avatar
Guolin Ke committed
195
196
197
      valid_data$update_params(params)
      valid_data$set_reference(data)
      reduced_valid_sets[[key]] <- valid_data
198

Guolin Ke's avatar
Guolin Ke committed
199
    }
200

Guolin Ke's avatar
Guolin Ke committed
201
  }
202

203
  # Add printing log callback
204
  if (verbose > 0L && eval_freq > 0L) {
Guolin Ke's avatar
Guolin Ke committed
205
206
    callbacks <- add.cb(callbacks, cb.print.evaluation(eval_freq))
  }
207

208
  # Add evaluation log callback
209
  if (record && length(valids) > 0L) {
Guolin Ke's avatar
Guolin Ke committed
210
211
    callbacks <- add.cb(callbacks, cb.record.evaluation())
  }
212

213
  # Did user pass parameters that indicate they want to use early stopping?
214
  using_early_stopping <- !is.null(early_stopping_rounds) && early_stopping_rounds > 0L
215
216
217
218
219

  boosting_param_names <- .PARAMETER_ALIASES()[["boosting"]]
  using_dart <- any(
    sapply(
      X = boosting_param_names
220
221
      , FUN = function(param) {
        identical(params[[param]], "dart")
222
      }
223
224
225
226
    )
  )

  # Cannot use early stopping with 'dart' boosting
227
  if (using_dart) {
228
    warning("Early stopping is not available in 'dart' mode.")
229
    using_early_stopping <- FALSE
230
231
232

    # Remove the cb.early.stop() function if it was passed in to callbacks
    callbacks <- Filter(
233
      f = function(cb_func) {
234
235
236
237
238
239
240
        !identical(attr(cb_func, "name"), "cb.early.stop")
      }
      , x = callbacks
    )
  }

  # If user supplied early_stopping_rounds, add the early stopping callback
241
  if (using_early_stopping) {
242
    callbacks <- add.cb(
243
244
      cb_list = callbacks
      , cb = cb.early.stop(
245
        stopping_rounds = early_stopping_rounds
246
        , first_metric_only = isTRUE(params[["first_metric_only"]])
247
248
249
        , verbose = verbose
      )
    )
Guolin Ke's avatar
Guolin Ke committed
250
  }
251

252
  cb <- categorize.callbacks(cb_list = callbacks)
253

254
  # Construct booster with datasets
255
  booster <- Booster$new(params = params, train_set = data)
256
  if (valid_contain_train) {
257
    booster$set_train_data_name(name = train_data_name)
258
  }
259

Guolin Ke's avatar
Guolin Ke committed
260
  for (key in names(reduced_valid_sets)) {
261
    booster$add_valid(data = reduced_valid_sets[[key]], name = key)
Guolin Ke's avatar
Guolin Ke committed
262
  }
263

264
265
266
  # Callback env
  env <- CB_ENV$new()
  env$model <- booster
Guolin Ke's avatar
Guolin Ke committed
267
  env$begin_iteration <- begin_iteration
268
  env$end_iteration <- end_iteration
269

270
  # Start training model using number of iterations to start and end with
271
  for (i in seq.int(from = begin_iteration, to = end_iteration)) {
272

273
    # Overwrite iteration in environment
Guolin Ke's avatar
Guolin Ke committed
274
275
    env$iteration <- i
    env$eval_list <- list()
276

277
278
279
280
    # Loop through "pre_iter" element
    for (f in cb$pre_iter) {
      f(env)
    }
281

282
    # Update one boosting iteration
283
    booster$update(fobj = fobj)
284

285
    # Prepare collection of evaluation results
Guolin Ke's avatar
Guolin Ke committed
286
    eval_list <- list()
287

288
    # Collection: Has validation dataset?
289
    if (length(valids) > 0L) {
290

291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
      # Get evaluation results with passed-in functions
      for (eval_function in eval_functions) {

        # Validation has training dataset?
        if (valid_contain_train) {
          eval_list <- append(eval_list, booster$eval_train(feval = eval_function))
        }

        eval_list <- append(eval_list, booster$eval_valid(feval = eval_function))
      }

      # Calling booster$eval_valid() will get
      # evaluation results with the metrics in params$metric by calling LGBM_BoosterGetEval_R",
      # so need to be sure that gets called, which it wouldn't be above if no functions
      # were passed in
      if (length(eval_functions) == 0L) {
        if (valid_contain_train) {
          eval_list <- append(eval_list, booster$eval_train(feval = eval_function))
        }
        eval_list <- append(eval_list, booster$eval_valid(feval = eval_function))
Guolin Ke's avatar
Guolin Ke committed
311
      }
312

Guolin Ke's avatar
Guolin Ke committed
313
    }
314

315
    # Write evaluation result in environment
Guolin Ke's avatar
Guolin Ke committed
316
    env$eval_list <- eval_list
317

318
319
320
321
    # Loop through env
    for (f in cb$post_iter) {
      f(env)
    }
322

323
    # Check for early stopping and break if needed
324
    if (env$met_early_stop) break
325

Guolin Ke's avatar
Guolin Ke committed
326
  }
327

328
329
330
331
  # check if any valids were given other than the training data
  non_train_valid_names <- names(valids)[!(names(valids) == train_data_name)]
  first_valid_name <- non_train_valid_names[1L]

332
333
  # When early stopping is not activated, we compute the best iteration / score ourselves by
  # selecting the first metric and the first dataset
334
  if (record && length(non_train_valid_names) > 0L && is.na(env$best_score)) {
335
336
337

    # when using a custom eval function, the metric name is returned from the
    # function, so figure it out from record_evals
338
    if (!is.null(eval_functions[1L])) {
339
340
341
342
343
      first_metric <- names(booster$record_evals[[first_valid_name]])[1L]
    } else {
      first_metric <- booster$.__enclos_env__$private$eval_names[1L]
    }

344
345
346
    .find_best <- which.min
    if (isTRUE(env$eval_list[[1L]]$higher_better[1L])) {
      .find_best <- which.max
347
    }
348
349
350
351
352
353
354
355
    booster$best_iter <- unname(
      .find_best(
        unlist(
          booster$record_evals[[first_valid_name]][[first_metric]][[.EVAL_KEY()]]
        )
      )
    )
    booster$best_score <- booster$record_evals[[first_valid_name]][[first_metric]][[.EVAL_KEY()]][[booster$best_iter]]
356
  }
357

358
359
  # Check for booster model conversion to predictor model
  if (reset_data) {
360

361
    # Store temporarily model data elsewhere
362
363
364
365
366
    booster_old <- list(
      best_iter = booster$best_iter
      , best_score = booster$best_score
      , record_evals = booster$record_evals
    )
367

368
369
370
371
372
    # Reload model
    booster <- lgb.load(model_str = booster$save_model_to_string())
    booster$best_iter <- booster_old$best_iter
    booster$best_score <- booster_old$best_score
    booster$record_evals <- booster_old$record_evals
373

374
  }
375

376
  return(booster)
377

Guolin Ke's avatar
Guolin Ke committed
378
}