lgb.train.R 8.47 KB
Newer Older
Guolin Ke's avatar
Guolin Ke committed
1
#' Main training logic for LightGBM
2
#' 
Guolin Ke's avatar
Guolin Ke committed
3
4
5
#' @param params List of parameters
#' @param data a \code{lgb.Dataset} object, used for training
#' @param nrounds number of training rounds
6
#' @param valids a list of \code{lgb.Dataset} objects, used for validation
7
8
9
10
11
12
13
14
#' @param obj objective function, can be character or custom objective function. Examples include 
#'        \code{regression}, \code{regression_l1}, \code{huber},
#'        \code{binary}, \code{lambdarank}, \code{multiclass}, \code{multiclass}
#' @param boosting boosting type. \code{gbdt}, \code{dart}
#' @param num_leaves number of leaves in one tree. defaults to 127
#' @param max_depth Limit the max depth for tree model. This is used to deal with overfit when #data is small. 
#'        Tree still grow by leaf-wise.
#' @param num_threads Number of threads for LightGBM. For the best speed, set this to the number of real CPU cores, not the number of threads (most CPU using hyper-threading to generate 2 threads per CPU core).
15
#' @param eval evaluation function, can be (a list of) character or custom eval function
16
17
18
#' @param verbose verbosity for output, if <= 0, also will disable the print of evalutaion during training
#' @param record Boolean, TRUE will record iteration message to \code{booster$record_evals} 
#' @param eval_freq evalutaion output frequency, only effect when verbose > 0
19
#' @param init_model path of model file of \code{lgb.Booster} object, will continue training from this model
Guolin Ke's avatar
Guolin Ke committed
20
#' @param colnames feature names, if not null, will use this to overwrite the names in dataset
21
22
23
#' @param categorical_feature list of str or int
#'        type int represents index,
#'        type str represents feature names
Guolin Ke's avatar
Guolin Ke committed
24
25
26
27
28
29
30
31
32
#' @param early_stopping_rounds int
#'        Activates early stopping.
#'        Requires at least one validation data and one metric
#'        If there's more than one, will check all of them
#'        Returns the model with (best_iter + early_stopping_rounds)
#'        If early stopping occurs, the model will have 'best_iter' field
#' @param callbacks list of callback functions
#'        List of callback functions that are applied at each iteration.
#' @param ... other parameters, see parameters.md for more informations
33
#' 
34
#' @return a trained booster model \code{lgb.Booster}.
35
#' 
Guolin Ke's avatar
Guolin Ke committed
36
#' @examples
37
#' \dontrun{
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#' library(lightgbm)
#' 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)
#' model <- lgb.train(params,
#'                    dtrain,
#'                    100,
#'                    valids,
#'                    min_data = 1,
#'                    learning_rate = 1,
#'                    early_stopping_rounds = 10)
54
#' }
55
#' 
Guolin Ke's avatar
Guolin Ke committed
56
#' @rdname lgb.train
57
#' 
Guolin Ke's avatar
Guolin Ke committed
58
#' @export
59
60
61
62
63
64
65
66
67
68
69
70
lgb.train <- function(params = list(),
                      data,
                      nrounds = 10,
                      valids = list(),
                      obj = NULL,
                      eval = NULL,
                      verbose = 1,
                      record = TRUE,
                      eval_freq = 1L,
                      init_model = NULL,
                      colnames = NULL,
                      categorical_feature = NULL,
71
                      early_stopping_rounds = NULL,
72
73
74
75
                      callbacks = list(),
                      ...) {
  
  # Setup temporary variables
76
  additional_params <- list(...)
77
  params <- append(params, additional_params)
Guolin Ke's avatar
Guolin Ke committed
78
  params$verbose <- verbose
79
80
81
82
83
84
  params <- lgb.check.obj(params, obj)
  params <- lgb.check.eval(params, eval)
  fobj <- NULL
  feval <- NULL
  
  # Check for objective (function or not)
85
  if (is.function(params$objective)) {
86
    fobj <- params$objective
Guolin Ke's avatar
Guolin Ke committed
87
88
    params$objective <- "NONE"
  }
89
90
91
92
93
94
95
  
  # Check for loss (function or not)
  if (is.function(eval)) {
    feval <- eval
  }
  
  # Check for parameters
Guolin Ke's avatar
Guolin Ke committed
96
  lgb.check.params(params)
97
98
  
  # Init predictor to empty
Guolin Ke's avatar
Guolin Ke committed
99
  predictor <- NULL
100
101
  
  # Check for boosting from a trained model
102
  if (is.character(init_model)) {
Guolin Ke's avatar
Guolin Ke committed
103
    predictor <- Predictor$new(init_model)
104
  } else if (lgb.is.Booster(init_model)) {
Guolin Ke's avatar
Guolin Ke committed
105
106
    predictor <- init_model$to_predictor()
  }
107
108
  
  # Set the iteration to start from / end to (and check for boosting from a trained model, again)
Guolin Ke's avatar
Guolin Ke committed
109
  begin_iteration <- 1
110
  if (!is.null(predictor)) {
Guolin Ke's avatar
Guolin Ke committed
111
112
113
    begin_iteration <- predictor$current_iter() + 1
  }
  end_iteration <- begin_iteration + nrounds - 1
114
115
  
  # Check for training dataset type correctness
116
  if (!lgb.is.Dataset(data)) {
Guolin Ke's avatar
Guolin Ke committed
117
118
    stop("lgb.train: data only accepts lgb.Dataset object")
  }
119
120
  
  # Check for validation dataset type correctness
Guolin Ke's avatar
Guolin Ke committed
121
  if (length(valids) > 0) {
122
123
124
125
    
    # One or more validation dataset
    
    # Check for list as input and type correctness by object
126
127
128
    if (!is.list(valids) || !all(sapply(valids, lgb.is.Dataset))) {
      stop("lgb.train: valids must be a list of lgb.Dataset elements")
    }
129
130
    
    # Attempt to get names
Guolin Ke's avatar
Guolin Ke committed
131
    evnames <- names(valids)
132
133
    
    # Check for names existance
134
135
136
    if (is.null(evnames) || !all(nzchar(evnames))) {
      stop("lgb.train: each element of the valids must have a name tag")
    }
Guolin Ke's avatar
Guolin Ke committed
137
  }
138
139
  
  # Update parameters with parsed parameters
Guolin Ke's avatar
Guolin Ke committed
140
  data$update_params(params)
141
142
  
  # Create the predictor set
Guolin Ke's avatar
Guolin Ke committed
143
  data$.__enclos_env__$private$set_predictor(predictor)
144
145
146
147
148
149
150
151
152
153
154
155
  
  # Write column names
  if (!is.null(colnames)) {
    data$set_colnames(colnames)
  }
  
  # Write categorical features
  if (!is.null(categorical_feature)) {
    data$set_categorical_feature(categorical_feature)
  }
  
  # Construct datasets, if needed
156
157
158
159
  if (data$remodel == TRUE) {
    data <- data$clone(deep = FALSE)
    data$construct()
  }
Guolin Ke's avatar
Guolin Ke committed
160
  vaild_contain_train <- FALSE
161
162
163
164
  train_data_name <- "train"
  reduced_valid_sets <- list()
  
  # Parse validation datasets
165
  if (length(valids) > 0) {
166
167
    
    # Loop through all validation datasets using name
Guolin Ke's avatar
Guolin Ke committed
168
    for (key in names(valids)) {
169
170
      
      # Use names to get validation datasets
Guolin Ke's avatar
Guolin Ke committed
171
      valid_data <- valids[[key]]
172
173
      
      # Check for duplicate train/validation dataset
174
      if (identical(data, valid_data)) {
Guolin Ke's avatar
Guolin Ke committed
175
        vaild_contain_train <- TRUE
176
        train_data_name <- key
Guolin Ke's avatar
Guolin Ke committed
177
178
        next
      }
179
180
      
      # Update parameters, data
Guolin Ke's avatar
Guolin Ke committed
181
182
183
      valid_data$update_params(params)
      valid_data$set_reference(data)
      reduced_valid_sets[[key]] <- valid_data
184
      
Guolin Ke's avatar
Guolin Ke committed
185
    }
186
    
Guolin Ke's avatar
Guolin Ke committed
187
  }
188
189
  
  # Add printing log callback
190
  if (verbose > 0 & eval_freq > 0) {
Guolin Ke's avatar
Guolin Ke committed
191
192
    callbacks <- add.cb(callbacks, cb.print.evaluation(eval_freq))
  }
193
194
  
  # Add evaluation log callback
195
  if (record & length(valids) > 0) {
Guolin Ke's avatar
Guolin Ke committed
196
197
    callbacks <- add.cb(callbacks, cb.record.evaluation())
  }
198
199
  
  # Add early stopping callback
Guolin Ke's avatar
Guolin Ke committed
200
  if (!is.null(early_stopping_rounds)) {
201
202
    if (early_stopping_rounds > 0) {
      callbacks <- add.cb(callbacks, cb.early.stop(early_stopping_rounds, verbose = verbose))
Guolin Ke's avatar
Guolin Ke committed
203
204
    }
  }
205
206
  
  # "Categorize" callbacks
Guolin Ke's avatar
Guolin Ke committed
207
  cb <- categorize.callbacks(callbacks)
208
209
  
  # Construct booster with datasets
210
211
  booster <- Booster$new(params = params, train_set = data)
  if (vaild_contain_train) { booster$set_train_data_name(train_data_name) }
Guolin Ke's avatar
Guolin Ke committed
212
213
214
  for (key in names(reduced_valid_sets)) {
    booster$add_valid(reduced_valid_sets[[key]], key)
  }
215
216
217
218
  
  # Callback env
  env <- CB_ENV$new()
  env$model <- booster
Guolin Ke's avatar
Guolin Ke committed
219
  env$begin_iteration <- begin_iteration
220
  env$end_iteration <- end_iteration
Guolin Ke's avatar
Guolin Ke committed
221

222
  # Start training model using number of iterations to start and end with
223
  for (i in seq(from = begin_iteration, to = end_iteration)) {
224
225
    
    # Overwrite iteration in environment
Guolin Ke's avatar
Guolin Ke committed
226
227
    env$iteration <- i
    env$eval_list <- list()
228
229
230
231
232
233
234
    
    # Loop through "pre_iter" element
    for (f in cb$pre_iter) {
      f(env)
    }
    
    # Update one boosting iteration
235
    booster$update(fobj = fobj)
236
237
    
    # Prepare collection of evaluation results
Guolin Ke's avatar
Guolin Ke committed
238
    eval_list <- list()
239
240
    
    # Collection: Has validation dataset?
241
    if (length(valids) > 0) {
242
243
      
      # Validation has training dataset?
244
245
      if (vaild_contain_train) {
        eval_list <- append(eval_list, booster$eval_train(feval = feval))
Guolin Ke's avatar
Guolin Ke committed
246
      }
247
248
      
      # Has no validation dataset
249
      eval_list <- append(eval_list, booster$eval_valid(feval = feval))
Guolin Ke's avatar
Guolin Ke committed
250
    }
251
252
    
    # Write evaluation result in environment
Guolin Ke's avatar
Guolin Ke committed
253
    env$eval_list <- eval_list
254
255
256
257
258
259
260
    
    # Loop through env
    for (f in cb$post_iter) {
      f(env)
    }
    
    # Check for early stopping and break if needed
261
    if (env$met_early_stop) break
262
    
Guolin Ke's avatar
Guolin Ke committed
263
  }
264
265
266
267
  
  # Return booster
  return(booster)
  
Guolin Ke's avatar
Guolin Ke committed
268
}