}}\preformatted{ Note that the format of the model being saved is determined by the file
- extension specified here (see \link{xgb.save} for details about how it works).
-
- It can contain a \code{\link[base]{sprintf}} formatting specifier
- to include the integer iteration number in the file name.
- E.g., with \code{save_name} = 'xgboost_\%04d.ubj',
- the file saved at iteration 50 would be named "xgboost_0050.ubj".
-}\if{html}{\out{
}}}
-}
-\description{
-Callback closure for saving a model file.
-}
-\details{
-This callback function allows to save an xgb-model file, either periodically after each \code{save_period}'s or at the end.
-
-Callback function expects the following values to be set in its calling frame:
-\code{bst},
-\code{iteration},
-\code{begin_iteration},
-\code{end_iteration}.
-}
-\seealso{
-\link{xgb.save}
-
-\code{\link{callbacks}}
-}
diff --git a/R-package/man/predict.xgb.Booster.Rd b/R-package/man/predict.xgb.Booster.Rd
index 95e7a51fd..88a2f203e 100644
--- a/R-package/man/predict.xgb.Booster.Rd
+++ b/R-package/man/predict.xgb.Booster.Rd
@@ -18,25 +18,47 @@
iterationrange = NULL,
strict_shape = FALSE,
validate_features = FALSE,
+ base_margin = NULL,
...
)
}
\arguments{
\item{object}{Object of class \code{xgb.Booster}.}
-\item{newdata}{Takes \code{matrix}, \code{dgCMatrix}, \code{dgRMatrix}, \code{dsparseVector},
+\item{newdata}{Takes \code{data.frame}, \code{matrix}, \code{dgCMatrix}, \code{dgRMatrix}, \code{dsparseVector},
local data file, or \code{xgb.DMatrix}.
-For single-row predictions on sparse data, it is recommended to use the CSR format.
-If passing a sparse vector, it will take it as a row vector.}
-\item{missing}{Only used when input is a dense matrix. Pick a float value that represents
-missing values in data (e.g., 0 or some other extreme value).}
+\if{html}{\out{}}\preformatted{ For single-row predictions on sparse data, it's recommended to use CSR format. If passing
+ a sparse vector, it will take it as a row vector.
+
+ Note that, for repeated predictions on the same data, one might want to create a DMatrix to
+ pass here instead of passing R types like matrices or data frames, as predictions will be
+ faster on DMatrix.
+
+ If `newdata` is a `data.frame`, be aware that:\\itemize\{
+ \\item Columns will be converted to numeric if they aren't already, which could potentially make
+ the operation slower than in an equivalent `matrix` object.
+ \\item The order of the columns must match with that of the data from which the model was fitted
+ (i.e. columns will not be referenced by their names, just by their order in the data).
+ \\item If the model was fitted to data with categorical columns, these columns must be of
+ `factor` type here, and must use the same encoding (i.e. have the same levels).
+ \\item If `newdata` contains any `factor` columns, they will be converted to base-0
+ encoding (same as during DMatrix creation) - hence, one should not pass a `factor`
+ under a column which during training had a different type.
+ \}
+}\if{html}{\out{
}}}
+
+\item{missing}{Float value that represents missing values in data (e.g., 0 or some other extreme value).
+
+\if{html}{\out{}}\preformatted{ This parameter is not used when `newdata` is an `xgb.DMatrix` - in such cases, should pass
+ this as an argument to the DMatrix constructor instead.
+}\if{html}{\out{
}}}
\item{outputmargin}{Whether the prediction should be returned in the form of original untransformed
sum of predictions from boosting iterations' results. E.g., setting \code{outputmargin=TRUE} for
logistic regression would return log-odds instead of probabilities.}
-\item{predleaf}{Whether to predict pre-tree leaf indices.}
+\item{predleaf}{Whether to predict per-tree leaf indices.}
\item{predcontrib}{Whether to return feature contributions to individual predictions (see Details).}
@@ -48,7 +70,7 @@ logistic regression would return log-odds instead of probabilities.}
prediction outputs per case. No effect if \code{predleaf}, \code{predcontrib},
or \code{predinteraction} is \code{TRUE}.}
-\item{training}{Whether the predictions are used for training. For dart booster,
+\item{training}{Whether the prediction result is used for training. For dart booster,
training predicting will perform dropout.}
\item{iterationrange}{Sequence of rounds/iterations from the model to use for prediction, specified by passing
@@ -84,6 +106,13 @@ match (only applicable when both \code{object} and \code{newdata} have feature n
recommended to disable it for performance-sensitive applications.
}\if{html}{\out{}}}
+\item{base_margin}{Base margin used for boosting from existing model.
+
+\if{html}{\out{}}\preformatted{ Note that, if `newdata` is an `xgb.DMatrix` object, this argument will
+ be ignored as it needs to be added to the DMatrix instead (e.g. by passing it as
+ an argument in its constructor, or by calling \link{setinfo.xgb.DMatrix}).
+}\if{html}{\out{
}}}
+
\item{...}{Not used.}
}
\value{
@@ -115,7 +144,7 @@ When \code{strict_shape = TRUE}, the output is always an array:
}
}
\description{
-Predicted values based on either xgboost model or model handle object.
+Predict values on data based on xgboost model.
}
\details{
Note that \code{iterationrange} would currently do nothing for predictions from "gblinear",
diff --git a/R-package/man/xgb.Callback.Rd b/R-package/man/xgb.Callback.Rd
new file mode 100644
index 000000000..b4edcd978
--- /dev/null
+++ b/R-package/man/xgb.Callback.Rd
@@ -0,0 +1,248 @@
+% Generated by roxygen2: do not edit by hand
+% Please edit documentation in R/callbacks.R
+\name{xgb.Callback}
+\alias{xgb.Callback}
+\title{XGBoost Callback Constructor}
+\usage{
+xgb.Callback(
+ cb_name = "custom_callback",
+ env = new.env(),
+ f_before_training = function(env, model, data, evals, begin_iteration, end_iteration)
+ NULL,
+ f_before_iter = function(env, model, data, evals, iteration) NULL,
+ f_after_iter = function(env, model, data, evals, iteration, iter_feval) NULL,
+ f_after_training = function(env, model, data, evals, iteration, final_feval,
+ prev_cb_res) NULL
+)
+}
+\arguments{
+\item{cb_name}{Name for the callback.
+
+If the callback produces some non-NULL result (from executing the function passed under
+\code{f_after_training}), that result will be added as an R attribute to the resulting booster
+(or as a named element in the result of CV), with the attribute name specified here.
+
+Names of callbacks must be unique - i.e. there cannot be two callbacks with the same name.}
+
+\item{env}{An environment object that will be passed to the different functions in the callback.
+Note that this environment will not be shared with other callbacks.}
+
+\item{f_before_training}{A function that will be executed before the training has started.
+
+If passing \code{NULL} for this or for the other function inputs, then no function will be executed.
+
+If passing a function, it will be called with parameters supplied as non-named arguments
+matching the function signatures that are shown in the default value for each function argument.}
+
+\item{f_before_iter}{A function that will be executed before each boosting round.
+
+This function can signal whether the training should be finalized or not, by outputting
+a value that evaluates to \code{TRUE} - i.e. if the output from the function provided here at
+a given round is \code{TRUE}, then training will be stopped before the current iteration happens.
+
+Return values of \code{NULL} will be interpreted as \code{FALSE}.}
+
+\item{f_after_iter}{A function that will be executed after each boosting round.
+
+This function can signal whether the training should be finalized or not, by outputting
+a value that evaluates to \code{TRUE} - i.e. if the output from the function provided here at
+a given round is \code{TRUE}, then training will be stopped at that round.
+
+Return values of \code{NULL} will be interpreted as \code{FALSE}.}
+
+\item{f_after_training}{A function that will be executed after training is finished.
+
+This function can optionally output something non-NULL, which will become part of the R
+attributes of the booster (assuming one passes \code{keep_extra_attributes=TRUE} to \link{xgb.train})
+under the name supplied for parameter \code{cb_name} imn the case of \link{xgb.train}; or a part
+of the named elements in the result of \link{xgb.cv}.}
+}
+\value{
+An \code{xgb.Callback} object, which can be passed to \link{xgb.train} or \link{xgb.cv}.
+}
+\description{
+Constructor for defining the structure of callback functions that can be executed
+at different stages of model training (before / after training, before / after each boosting
+iteration).
+}
+\details{
+Arguments that will be passed to the supplied functions are as follows:\itemize{
+
+\item env The same environment that is passed under argument \code{env}.
+
+It may be modified by the functions in order to e.g. keep tracking of what happens
+across iterations or similar.
+
+This environment is only used by the functions supplied to the callback, and will
+not be kept after the model fitting function terminates (see parameter \code{f_after_training}).
+
+\item model The booster object when using \link{xgb.train}, or the folds when using
+\link{xgb.cv}.
+
+For \link{xgb.cv}, folds are a list with a structure as follows:\itemize{
+\item \code{dtrain}: The training data for the fold (as an \code{xgb.DMatrix} object).
+\item \code{bst}: Rhe \code{xgb.Booster} object for the fold.
+\item \code{evals}: A list containing two DMatrices, with names \code{train} and \code{test}
+(\code{test} is the held-out data for the fold).
+\item \code{index}: The indices of the hold-out data for that fold (base-1 indexing),
+from which the \code{test} entry in \code{evals} was obtained.
+}
+
+This object should \bold{not} be in-place modified in ways that conflict with the
+training (e.g. resetting the parameters for a training update in a way that resets
+the number of rounds to zero in order to overwrite rounds).
+
+Note that any R attributes that are assigned to the booster during the callback functions,
+will not be kept thereafter as the booster object variable is not re-assigned during
+training. It is however possible to set C-level attributes of the booster through
+\link{xgb.attr} or \link{xgb.attributes}, which should remain available for the rest
+of the iterations and after the training is done.
+
+For keeping variables across iterations, it's recommended to use \code{env} instead.
+\item data The data to which the model is being fit, as an \code{xgb.DMatrix} object.
+
+Note that, for \link{xgb.cv}, this will be the full data, while data for the specific
+folds can be found in the \code{model} object.
+
+\item evals The evaluation data, as passed under argument \code{evals} to
+\link{xgb.train}.
+
+For \link{xgb.cv}, this will always be \code{NULL}.
+
+\item begin_iteration Index of the first boosting iteration that will be executed
+(base-1 indexing).
+
+This will typically be '1', but when using training continuation, depending on the
+parameters for updates, boosting rounds will be continued from where the previous
+model ended, in which case this will be larger than 1.
+
+\item end_iteration Index of the last boostign iteration that will be executed
+(base-1 indexing, inclusive of this end).
+
+It should match with argument \code{nrounds} passed to \link{xgb.train} or \link{xgb.cv}.
+
+Note that boosting might be interrupted before reaching this last iteration, for
+example by using the early stopping callback \link{xgb.cb.early.stop}.
+
+\item iteration Index of the iteration number that is being executed (first iteration
+will be the same as parameter \code{begin_iteration}, then next one will add +1, and so on).
+
+\item iter_feval Evaluation metrics for \code{evals} that were supplied, either
+determined by the objective, or by parameter \code{feval}.
+
+For \link{xgb.train}, this will be a named vector with one entry per element in
+\code{evals}, where the names are determined as 'evals name' + '-' + 'metric name' - for
+example, if \code{evals} contains an entry named "tr" and the metric is "rmse",
+this will be a one-element vector with name "tr-rmse".
+
+For \link{xgb.cv}, this will be a 2d matrix with dimensions \verb{[length(evals), nfolds]},
+where the row names will follow the same naming logic as the one-dimensional vector
+that is passed in \link{xgb.train}.
+
+Note that, internally, the built-in callbacks such as \link{xgb.cb.print.evaluation} summarize
+this table by calculating the row-wise means and standard deviations.
+
+\item final_feval The evaluation results after the last boosting round is executed
+(same format as \code{iter_feval}, and will be the exact same input as passed under
+\code{iter_feval} to the last round that is executed during model fitting).
+
+\item prev_cb_res Result from a previous run of a callback sharing the same name
+(as given by parameter \code{cb_name}) when conducting training continuation, if there
+was any in the booster R attributes.
+
+Some times, one might want to append the new results to the previous one, and this will
+be done automatically by the built-in callbacks such as \link{xgb.cb.evaluation.log},
+which will append the new rows to the previous table.
+
+If no such previous callback result is available (which it never will when fitting
+a model from start instead of updating an existing model), this will be \code{NULL}.
+
+For \link{xgb.cv}, which doesn't support training continuation, this will always be \code{NULL}.
+}
+
+The following names (\code{cb_name} values) are reserved for internal callbacks:\itemize{
+\item print_evaluation
+\item evaluation_log
+\item reset_parameters
+\item early_stop
+\item save_model
+\item cv_predict
+\item gblinear_history
+}
+
+The following names are reserved for other non-callback attributes:\itemize{
+\item names
+\item class
+\item call
+\item params
+\item niter
+\item nfeatures
+\item folds
+}
+
+When using the built-in early stopping callback (\link{xgb.cb.early.stop}), said callback
+will always be executed before the others, as it sets some booster C-level attributes
+that other callbacks might also use. Otherwise, the order of execution will match with
+the order in which the callbacks are passed to the model fitting function.
+}
+\examples{
+# Example constructing a custom callback that calculates
+# squared error on the training data (no separate test set),
+# and outputs the per-iteration results.
+ssq_callback <- xgb.Callback(
+ cb_name = "ssq",
+ f_before_training = function(env, model, data, evals,
+ begin_iteration, end_iteration) {
+ # A vector to keep track of a number at each iteration
+ env$logs <- rep(NA_real_, end_iteration - begin_iteration + 1)
+ },
+ f_after_iter = function(env, model, data, evals, iteration, iter_feval) {
+ # This calculates the sum of squared errors on the training data.
+ # Note that this can be better done by passing an 'evals' entry,
+ # but this demonstrates a way in which callbacks can be structured.
+ pred <- predict(model, data)
+ err <- pred - getinfo(data, "label")
+ sq_err <- sum(err^2)
+ env$logs[iteration] <- sq_err
+ cat(
+ sprintf(
+ "Squared error at iteration \%d: \%.2f\n",
+ iteration, sq_err
+ )
+ )
+
+ # A return value of 'TRUE' here would signal to finalize the training
+ return(FALSE)
+ },
+ f_after_training = function(env, model, data, evals, iteration,
+ final_feval, prev_cb_res) {
+ return(env$logs)
+ }
+)
+
+data(mtcars)
+y <- mtcars$mpg
+x <- as.matrix(mtcars[, -1])
+dm <- xgb.DMatrix(x, label = y, nthread = 1)
+model <- xgb.train(
+ data = dm,
+ params = list(objective = "reg:squarederror", nthread = 1),
+ nrounds = 5,
+ callbacks = list(ssq_callback),
+ keep_extra_attributes = TRUE
+)
+
+# Result from 'f_after_iter' will be available as an attribute
+attributes(model)$ssq
+}
+\seealso{
+Built-in callbacks:\itemize{
+\item \link{xgb.cb.print.evaluation}
+\item \link{xgb.cb.evaluation.log}
+\item \link{xgb.cb.reset.parameters}
+\item \link{xgb.cb.early.stop}
+\item \link{xgb.cb.save.model}
+\item \link{xgb.cb.cv.predict}
+\item \link{xgb.cb.gblinear.history}
+}
+}
diff --git a/R-package/man/xgb.DMatrix.Rd b/R-package/man/xgb.DMatrix.Rd
index d18270733..5f764ed45 100644
--- a/R-package/man/xgb.DMatrix.Rd
+++ b/R-package/man/xgb.DMatrix.Rd
@@ -19,7 +19,8 @@ xgb.DMatrix(
qid = NULL,
label_lower_bound = NULL,
label_upper_bound = NULL,
- feature_weights = NULL
+ feature_weights = NULL,
+ data_split_mode = "row"
)
xgb.QuantileDMatrix(
@@ -60,10 +61,27 @@ Other column types are not supported.
'xgb.QuantileDMatrix'.
\item Single-row CSR matrices, as class \code{dsparseVector} from package \code{Matrix}, which is interpreted
as a single row (only when making predictions from a fitted model).
-\item Text files in SVMLight / LibSVM formats, passed as a path to the file. These are \bold{not}
-supported for xgb.QuantileDMatrix'.
-\item Binary files generated by \link{xgb.DMatrix.save}, passed as a path to the file. These are
-\bold{not} supported for xgb.QuantileDMatrix'.
+\item Text files in a supported format, passed as a \code{character} variable containing the URI path to
+the file, with an optional format specifier.
+
+These are \bold{not} supported for \code{xgb.QuantileDMatrix}. Supported formats are:\itemize{
+\item XGBoost's own binary format for DMatrices, as produced by \link{xgb.DMatrix.save}.
+\item SVMLight (a.k.a. LibSVM) format for CSR matrices. This format can be signaled by suffix
+\code{?format=libsvm} at the end of the file path. It will be the default format if not
+otherwise specified.
+\item CSV files (comma-separated values). This format can be specified by adding suffix
+\code{?format=csv} at the end ofthe file path. It will \bold{not} be auto-deduced from file extensions.
+}
+
+Be aware that the format of the file will not be auto-deduced - for example, if a file is named 'file.csv',
+it will not look at the extension or file contents to determine that it is a comma-separated value.
+Instead, the format must be specified following the URI format, so the input to \code{data} should be passed
+like this: \code{"file.csv?format=csv"} (or \code{"file.csv?format=csv&label_column=0"} if the first column
+corresponds to the labels).
+
+For more information about passing text files as input, see the articles
+\href{https://xgboost.readthedocs.io/en/stable/tutorials/input_format.html}{Text Input Format of DMatrix} and
+\href{https://xgboost.readthedocs.io/en/stable/python/python_intro.html#python-data-interface}{Data Interface}.
}}
\item{label}{Label of the training data. For classification problems, should be passed encoded as
@@ -129,6 +147,14 @@ not be saved, so make sure that \code{factor} columns passed to \code{predict} h
\item{feature_weights}{Set feature weights for column sampling.}
+\item{data_split_mode}{When passing a URI (as R \code{character}) as input, this signals
+whether to split by row or column. Allowed values are \code{"row"} and \code{"col"}.
+
+In distributed mode, the file is split accordingly; otherwise this is only an indicator on
+how the file was split beforehand. Default to row.
+
+This is not used when \code{data} is not a URI.}
+
\item{ref}{The training dataset that provides quantile information, needed when creating
validation/test dataset with \code{xgb.QuantileDMatrix}. Supplying the training DMatrix
as a reference means that the same quantisation applied to the training data is
diff --git a/R-package/man/xgb.DMatrix.save.Rd b/R-package/man/xgb.DMatrix.save.Rd
index d5c0563b3..51643274d 100644
--- a/R-package/man/xgb.DMatrix.save.Rd
+++ b/R-package/man/xgb.DMatrix.save.Rd
@@ -15,6 +15,7 @@ xgb.DMatrix.save(dmatrix, fname)
Save xgb.DMatrix object to binary file
}
\examples{
+\dontshow{RhpcBLASctl::omp_set_num_threads(1)}
data(agaricus.train, package='xgboost')
dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label, nthread = 2))
fname <- file.path(tempdir(), "xgb.DMatrix.data")
diff --git a/R-package/man/cb.cv.predict.Rd b/R-package/man/xgb.cb.cv.predict.Rd
similarity index 53%
rename from R-package/man/cb.cv.predict.Rd
rename to R-package/man/xgb.cb.cv.predict.Rd
index 4cabac1c9..d2d9a084b 100644
--- a/R-package/man/cb.cv.predict.Rd
+++ b/R-package/man/xgb.cb.cv.predict.Rd
@@ -1,16 +1,27 @@
% Generated by roxygen2: do not edit by hand
% Please edit documentation in R/callbacks.R
-\name{cb.cv.predict}
-\alias{cb.cv.predict}
-\title{Callback closure for returning cross-validation based predictions.}
+\name{xgb.cb.cv.predict}
+\alias{xgb.cb.cv.predict}
+\title{Callback for returning cross-validation based predictions.}
\usage{
-cb.cv.predict(save_models = FALSE)
+xgb.cb.cv.predict(save_models = FALSE, outputmargin = FALSE)
}
\arguments{
-\item{save_models}{a flag for whether to save the folds' models.}
+\item{save_models}{A flag for whether to save the folds' models.}
+
+\item{outputmargin}{Whether to save margin predictions (same effect as passing this
+parameter to \link{predict.xgb.Booster}).}
}
\value{
-Predictions are returned inside of the \code{pred} element, which is either a vector or a matrix,
+An \code{xgb.Callback} object, which can be passed to \link{xgb.cv},
+but \bold{not} to \link{xgb.train}.
+}
+\description{
+This callback function saves predictions for all of the test folds,
+and also allows to save the folds' models.
+}
+\details{
+Predictions are saved inside of the \code{pred} element, which is either a vector or a matrix,
depending on the number of prediction outputs per data row. The order of predictions corresponds
to the order of rows in the original dataset. Note that when a custom \code{folds} list is
provided in \code{xgb.cv}, the predictions would only be returned properly when this list is a
@@ -19,23 +30,3 @@ meaningful when user-provided folds have overlapping indices as in, e.g., random
When some of the indices in the training dataset are not included into user-provided \code{folds},
their prediction value would be \code{NA}.
}
-\description{
-Callback closure for returning cross-validation based predictions.
-}
-\details{
-This callback function saves predictions for all of the test folds,
-and also allows to save the folds' models.
-
-It is a "finalizer" callback and it uses early stopping information whenever it is available,
-thus it must be run after the early stopping callback if the early stopping is used.
-
-Callback function expects the following values to be set in its calling frame:
-\code{bst_folds},
-\code{basket},
-\code{data},
-\code{end_iteration},
-\code{params},
-}
-\seealso{
-\code{\link{callbacks}}
-}
diff --git a/R-package/man/xgb.cb.early.stop.Rd b/R-package/man/xgb.cb.early.stop.Rd
new file mode 100644
index 000000000..2a70f4943
--- /dev/null
+++ b/R-package/man/xgb.cb.early.stop.Rd
@@ -0,0 +1,55 @@
+% Generated by roxygen2: do not edit by hand
+% Please edit documentation in R/callbacks.R
+\name{xgb.cb.early.stop}
+\alias{xgb.cb.early.stop}
+\title{Callback to activate early stopping}
+\usage{
+xgb.cb.early.stop(
+ stopping_rounds,
+ maximize = FALSE,
+ metric_name = NULL,
+ verbose = TRUE,
+ keep_all_iter = TRUE
+)
+}
+\arguments{
+\item{stopping_rounds}{The number of rounds with no improvement in
+the evaluation metric in order to stop the training.}
+
+\item{maximize}{Whether to maximize the evaluation metric.}
+
+\item{metric_name}{The name of an evaluation column to use as a criteria for early
+stopping. If not set, the last column would be used.
+Let's say the test data in \code{evals} was labelled as \code{dtest},
+and one wants to use the AUC in test data for early stopping regardless of where
+it is in the \code{evals}, then one of the following would need to be set:
+\code{metric_name='dtest-auc'} or \code{metric_name='dtest_auc'}.
+All dash '-' characters in metric names are considered equivalent to '_'.}
+
+\item{verbose}{Whether to print the early stopping information.}
+
+\item{keep_all_iter}{Whether to keep all of the boosting rounds that were produced
+in the resulting object. If passing \code{FALSE}, will only keep the boosting rounds
+up to the detected best iteration, discarding the ones that come after.}
+}
+\value{
+An \code{xgb.Callback} object, which can be passed to \link{xgb.train} or \link{xgb.cv}.
+}
+\description{
+This callback function determines the condition for early stopping.
+
+The following attributes are assigned to the booster's object:
+\itemize{
+\item \code{best_score} the evaluation score at the best iteration
+\item \code{best_iteration} at which boosting iteration the best score has occurred
+(0-based index for interoperability of binary models)
+}
+
+The same values are also stored as R attributes as a result of the callback, plus an additional
+attribute \code{stopped_by_max_rounds} which indicates whether an early stopping by the \code{stopping_rounds}
+condition occurred. Note that the \code{best_iteration} that is stored under R attributes will follow
+base-1 indexing, so it will be larger by '1' than the C-level 'best_iteration' that is accessed
+through \link{xgb.attr} or \link{xgb.attributes}.
+
+At least one dataset is required in \code{evals} for early stopping to work.
+}
diff --git a/R-package/man/xgb.cb.evaluation.log.Rd b/R-package/man/xgb.cb.evaluation.log.Rd
new file mode 100644
index 000000000..4cc6ef636
--- /dev/null
+++ b/R-package/man/xgb.cb.evaluation.log.Rd
@@ -0,0 +1,24 @@
+% Generated by roxygen2: do not edit by hand
+% Please edit documentation in R/callbacks.R
+\name{xgb.cb.evaluation.log}
+\alias{xgb.cb.evaluation.log}
+\title{Callback for logging the evaluation history}
+\usage{
+xgb.cb.evaluation.log()
+}
+\value{
+An \code{xgb.Callback} object, which can be passed to \link{xgb.train} or \link{xgb.cv}.
+}
+\description{
+Callback for logging the evaluation history
+}
+\details{
+This callback creates a table with per-iteration evaluation metrics (see parameters
+\code{evals} and \code{feval} in \link{xgb.train}).
+
+Note: in the column names of the final data.table, the dash '-' character is replaced with
+the underscore '_' in order to make the column names more like regular R identifiers.
+}
+\seealso{
+\link{xgb.cb.print.evaluation}
+}
diff --git a/R-package/man/cb.gblinear.history.Rd b/R-package/man/xgb.cb.gblinear.history.Rd
similarity index 63%
rename from R-package/man/cb.gblinear.history.Rd
rename to R-package/man/xgb.cb.gblinear.history.Rd
index 2a03c14db..0ebaa4685 100644
--- a/R-package/man/cb.gblinear.history.Rd
+++ b/R-package/man/xgb.cb.gblinear.history.Rd
@@ -1,37 +1,48 @@
% Generated by roxygen2: do not edit by hand
% Please edit documentation in R/callbacks.R
-\name{cb.gblinear.history}
-\alias{cb.gblinear.history}
-\title{Callback closure for collecting the model coefficients history of a gblinear booster
-during its training.}
+\name{xgb.cb.gblinear.history}
+\alias{xgb.cb.gblinear.history}
+\title{Callback for collecting coefficients history of a gblinear booster}
\usage{
-cb.gblinear.history(sparse = FALSE)
+xgb.cb.gblinear.history(sparse = FALSE)
}
\arguments{
-\item{sparse}{when set to FALSE/TRUE, a dense/sparse matrix is used to store the result.
+\item{sparse}{when set to \code{FALSE}/\code{TRUE}, a dense/sparse matrix is used to store the result.
Sparse format is useful when one expects only a subset of coefficients to be non-zero,
when using the "thrifty" feature selector with fairly small number of top features
selected per iteration.}
}
\value{
-Results are stored in the \code{coefs} element of the closure.
-The \code{\link{xgb.gblinear.history}} convenience function provides an easy
-way to access it.
-With \code{xgb.train}, it is either a dense of a sparse matrix.
-While with \code{xgb.cv}, it is a list (an element per each fold) of such
-matrices.
+An \code{xgb.Callback} object, which can be passed to \link{xgb.train} or \link{xgb.cv}.
}
\description{
-Callback closure for collecting the model coefficients history of a gblinear booster
-during its training.
+Callback for collecting coefficients history of a gblinear booster
}
\details{
To keep things fast and simple, gblinear booster does not internally store the history of linear
model coefficients at each boosting iteration. This callback provides a workaround for storing
the coefficients' path, by extracting them after each training iteration.
-Callback function expects the following values to be set in its calling frame:
-\code{bst} (or \code{bst_folds}).
+This callback will construct a matrix where rows are boosting iterations and columns are
+feature coefficients (same order as when calling \link{coef.xgb.Booster}, with the intercept
+corresponding to the first column).
+
+When there is more than one coefficient per feature (e.g. multi-class classification),
+the result will be reshaped into a vector where coefficients are arranged first by features and
+then by class (e.g. first 1 through N coefficients will be for the first class, then
+coefficients N+1 through 2N for the second class, and so on).
+
+If the result has only one coefficient per feature in the data, then the resulting matrix
+will have column names matching with the feature names, otherwise (when there's more than
+one coefficient per feature) the names will be composed as 'column name' + ':' + 'class index'
+(so e.g. column 'c1' for class '0' will be named 'c1:0').
+
+With \code{xgb.train}, the output is either a dense or a sparse matrix.
+With with \code{xgb.cv}, it is a list (one element per each fold) of such
+matrices.
+
+Function \link{xgb.gblinear.history} function provides an easy way to retrieve the
+outputs from this callback.
}
\examples{
#### Binary classification:
@@ -52,7 +63,7 @@ param <- list(booster = "gblinear", objective = "reg:logistic", eval_metric = "a
# rate does not break the convergence, but allows us to illustrate the typical pattern of
# "stochastic explosion" behaviour of this lock-free algorithm at early boosting iterations.
bst <- xgb.train(param, dtrain, list(tr=dtrain), nrounds = 200, eta = 1.,
- callbacks = list(cb.gblinear.history()))
+ callbacks = list(xgb.cb.gblinear.history()))
# Extract the coefficients' path and plot them vs boosting iteration number:
coef_path <- xgb.gblinear.history(bst)
matplot(coef_path, type = 'l')
@@ -61,7 +72,7 @@ matplot(coef_path, type = 'l')
# Will try the classical componentwise boosting which selects a single best feature per round:
bst <- xgb.train(param, dtrain, list(tr=dtrain), nrounds = 200, eta = 0.8,
updater = 'coord_descent', feature_selector = 'thrifty', top_k = 1,
- callbacks = list(cb.gblinear.history()))
+ callbacks = list(xgb.cb.gblinear.history()))
matplot(xgb.gblinear.history(bst), type = 'l')
# Componentwise boosting is known to have similar effect to Lasso regularization.
# Try experimenting with various values of top_k, eta, nrounds,
@@ -69,7 +80,7 @@ matplot(xgb.gblinear.history(bst), type = 'l')
# For xgb.cv:
bst <- xgb.cv(param, dtrain, nfold = 5, nrounds = 100, eta = 0.8,
- callbacks = list(cb.gblinear.history()))
+ callbacks = list(xgb.cb.gblinear.history()))
# coefficients in the CV fold #3
matplot(xgb.gblinear.history(bst)[[3]], type = 'l')
@@ -82,7 +93,7 @@ param <- list(booster = "gblinear", objective = "multi:softprob", num_class = 3,
# For the default linear updater 'shotgun' it sometimes is helpful
# to use smaller eta to reduce instability
bst <- xgb.train(param, dtrain, list(tr=dtrain), nrounds = 50, eta = 0.5,
- callbacks = list(cb.gblinear.history()))
+ callbacks = list(xgb.cb.gblinear.history()))
# Will plot the coefficient paths separately for each class:
matplot(xgb.gblinear.history(bst, class_index = 0), type = 'l')
matplot(xgb.gblinear.history(bst, class_index = 1), type = 'l')
@@ -90,11 +101,11 @@ matplot(xgb.gblinear.history(bst, class_index = 2), type = 'l')
# CV:
bst <- xgb.cv(param, dtrain, nfold = 5, nrounds = 70, eta = 0.5,
- callbacks = list(cb.gblinear.history(FALSE)))
+ callbacks = list(xgb.cb.gblinear.history(FALSE)))
# 1st fold of 1st class
matplot(xgb.gblinear.history(bst, class_index = 0)[[1]], type = 'l')
}
\seealso{
-\code{\link{callbacks}}, \code{\link{xgb.gblinear.history}}.
+\link{xgb.gblinear.history}, \link{coef.xgb.Booster}.
}
diff --git a/R-package/man/xgb.cb.print.evaluation.Rd b/R-package/man/xgb.cb.print.evaluation.Rd
new file mode 100644
index 000000000..c4f2e6991
--- /dev/null
+++ b/R-package/man/xgb.cb.print.evaluation.Rd
@@ -0,0 +1,25 @@
+% Generated by roxygen2: do not edit by hand
+% Please edit documentation in R/callbacks.R
+\name{xgb.cb.print.evaluation}
+\alias{xgb.cb.print.evaluation}
+\title{Callback for printing the result of evaluation}
+\usage{
+xgb.cb.print.evaluation(period = 1, showsd = TRUE)
+}
+\arguments{
+\item{period}{results would be printed every number of periods}
+
+\item{showsd}{whether standard deviations should be printed (when available)}
+}
+\value{
+An \code{xgb.Callback} object, which can be passed to \link{xgb.train} or \link{xgb.cv}.
+}
+\description{
+The callback function prints the result of evaluation at every \code{period} iterations.
+The initial and the last iteration's evaluations are always printed.
+
+Does not leave any attribute in the booster (see \link{xgb.cb.evaluation.log} for that).
+}
+\seealso{
+\link{xgb.Callback}
+}
diff --git a/R-package/man/cb.reset.parameters.Rd b/R-package/man/xgb.cb.reset.parameters.Rd
similarity index 57%
rename from R-package/man/cb.reset.parameters.Rd
rename to R-package/man/xgb.cb.reset.parameters.Rd
index ee0a5d1bd..c7e863817 100644
--- a/R-package/man/cb.reset.parameters.Rd
+++ b/R-package/man/xgb.cb.reset.parameters.Rd
@@ -1,10 +1,10 @@
% Generated by roxygen2: do not edit by hand
% Please edit documentation in R/callbacks.R
-\name{cb.reset.parameters}
-\alias{cb.reset.parameters}
-\title{Callback closure for resetting the booster's parameters at each iteration.}
+\name{xgb.cb.reset.parameters}
+\alias{xgb.cb.reset.parameters}
+\title{Callback for resetting the booster's parameters at each iteration.}
\usage{
-cb.reset.parameters(new_params)
+xgb.cb.reset.parameters(new_params)
}
\arguments{
\item{new_params}{a list where each element corresponds to a parameter that needs to be reset.
@@ -14,23 +14,16 @@ or a function of two parameters \code{learning_rates(iteration, nrounds)}
which returns a new parameter value by using the current iteration number
and the total number of boosting rounds.}
}
+\value{
+An \code{xgb.Callback} object, which can be passed to \link{xgb.train} or \link{xgb.cv}.
+}
\description{
-Callback closure for resetting the booster's parameters at each iteration.
+Callback for resetting the booster's parameters at each iteration.
}
\details{
-This is a "pre-iteration" callback function used to reset booster's parameters
-at the beginning of each iteration.
-
Note that when training is resumed from some previous model, and a function is used to
reset a parameter value, the \code{nrounds} argument in this function would be the
the number of boosting rounds in the current training.
-Callback function expects the following values to be set in its calling frame:
-\code{bst} or \code{bst_folds},
-\code{iteration},
-\code{begin_iteration},
-\code{end_iteration}.
-}
-\seealso{
-\code{\link{callbacks}}
+Does not leave any attribute in the booster.
}
diff --git a/R-package/man/xgb.cb.save.model.Rd b/R-package/man/xgb.cb.save.model.Rd
new file mode 100644
index 000000000..8ddba2f1a
--- /dev/null
+++ b/R-package/man/xgb.cb.save.model.Rd
@@ -0,0 +1,28 @@
+% Generated by roxygen2: do not edit by hand
+% Please edit documentation in R/callbacks.R
+\name{xgb.cb.save.model}
+\alias{xgb.cb.save.model}
+\title{Callback for saving a model file.}
+\usage{
+xgb.cb.save.model(save_period = 0, save_name = "xgboost.ubj")
+}
+\arguments{
+\item{save_period}{Save the model to disk after every
+\code{save_period} iterations; 0 means save the model at the end.}
+
+\item{save_name}{The name or path for the saved model file.
+It can contain a \code{\link[base]{sprintf}} formatting specifier
+to include the integer iteration number in the file name.
+E.g., with \code{save_name} = 'xgboost_\%04d.model',
+the file saved at iteration 50 would be named "xgboost_0050.model".}
+}
+\value{
+An \code{xgb.Callback} object, which can be passed to \link{xgb.train},
+but \bold{not} to \link{xgb.cv}.
+}
+\description{
+This callback function allows to save an xgb-model file, either periodically
+after each \code{save_period}'s or at the end.
+
+Does not leave any attribute in the booster.
+}
diff --git a/R-package/man/xgb.create.features.Rd b/R-package/man/xgb.create.features.Rd
index 68b561997..995c27459 100644
--- a/R-package/man/xgb.create.features.Rd
+++ b/R-package/man/xgb.create.features.Rd
@@ -82,7 +82,6 @@ new.dtrain <- xgb.DMatrix(
new.dtest <- xgb.DMatrix(
data = new.features.test, label = agaricus.test$label, nthread = 2
)
-watchlist <- list(train = new.dtrain)
bst <- xgb.train(params = param, data = new.dtrain, nrounds = nrounds, nthread = 2)
# Model accuracy with new features
diff --git a/R-package/man/xgb.cv.Rd b/R-package/man/xgb.cv.Rd
index 9f6103a52..778b4540a 100644
--- a/R-package/man/xgb.cv.Rd
+++ b/R-package/man/xgb.cv.Rd
@@ -59,7 +59,7 @@ that NA values should be considered as 'missing' by the algorithm.
Sometimes, 0 or other extreme value might be used to represent missing values.}
\item{prediction}{A logical value indicating whether to return the test fold predictions
-from each CV model. This parameter engages the \code{\link{cb.cv.predict}} callback.}
+from each CV model. This parameter engages the \code{\link{xgb.cb.cv.predict}} callback.}
\item{showsd}{\code{boolean}, whether to show standard deviation of cross validation}
@@ -98,20 +98,20 @@ the \code{nfold} and \code{stratified} parameters are ignored.}
\item{print_every_n}{Print each n-th iteration evaluation messages when \code{verbose>0}.
Default is 1 which means all messages are printed. This parameter is passed to the
-\code{\link{cb.print.evaluation}} callback.}
+\code{\link{xgb.cb.print.evaluation}} callback.}
\item{early_stopping_rounds}{If \code{NULL}, the early stopping function is not triggered.
If set to an integer \code{k}, training with a validation set will stop if the performance
doesn't improve for \code{k} rounds.
-Setting this parameter engages the \code{\link{cb.early.stop}} callback.}
+Setting this parameter engages the \code{\link{xgb.cb.early.stop}} callback.}
\item{maximize}{If \code{feval} and \code{early_stopping_rounds} are set,
then this parameter must be set as well.
When it is \code{TRUE}, it means the larger the evaluation score the better.
-This parameter is passed to the \code{\link{cb.early.stop}} callback.}
+This parameter is passed to the \code{\link{xgb.cb.early.stop}} callback.}
\item{callbacks}{a list of callback functions to perform various task during boosting.
-See \code{\link{callbacks}}. Some of the callbacks are automatically created depending on the
+See \code{\link{xgb.Callback}}. Some of the callbacks are automatically created depending on the
parameters' values. User can provide either existing or their own callback methods in order
to customize the training process.}
@@ -122,24 +122,24 @@ An object of class \code{xgb.cv.synchronous} with the following elements:
\itemize{
\item \code{call} a function call.
\item \code{params} parameters that were passed to the xgboost library. Note that it does not
-capture parameters changed by the \code{\link{cb.reset.parameters}} callback.
-\item \code{callbacks} callback functions that were either automatically assigned or
-explicitly passed.
+capture parameters changed by the \code{\link{xgb.cb.reset.parameters}} callback.
\item \code{evaluation_log} evaluation history stored as a \code{data.table} with the
first column corresponding to iteration number and the rest corresponding to the
CV-based evaluation means and standard deviations for the training and test CV-sets.
-It is created by the \code{\link{cb.evaluation.log}} callback.
+It is created by the \code{\link{xgb.cb.evaluation.log}} callback.
\item \code{niter} number of boosting iterations.
\item \code{nfeatures} number of features in training data.
\item \code{folds} the list of CV folds' indices - either those passed through the \code{folds}
parameter or randomly generated.
\item \code{best_iteration} iteration number with the best evaluation metric value
(only available with early stopping).
-\item \code{pred} CV prediction values available when \code{prediction} is set.
-It is either vector or matrix (see \code{\link{cb.cv.predict}}).
-\item \code{models} a list of the CV folds' models. It is only available with the explicit
-setting of the \code{cb.cv.predict(save_models = TRUE)} callback.
}
+
+Plus other potential elements that are the result of callbacks, such as a list \code{cv_predict} with
+a sub-element \code{pred} when passing \code{prediction = TRUE}, which is added by the \link{xgb.cb.cv.predict}
+callback (note that one can also pass it manually under \code{callbacks} with different settings,
+such as saving also the models created during cross validation); or a list \code{early_stop} which
+will contain elements such as \code{best_iteration} when using the early stopping callback (\link{xgb.cb.early.stop}).
}
\description{
The cross validation function of xgboost
diff --git a/R-package/man/xgb.dump.Rd b/R-package/man/xgb.dump.Rd
index 2cdb6b16a..6f97f6924 100644
--- a/R-package/man/xgb.dump.Rd
+++ b/R-package/man/xgb.dump.Rd
@@ -44,6 +44,7 @@ as a \code{character} vector. Otherwise it will return \code{TRUE}.
Dump an xgboost model in text format.
}
\examples{
+\dontshow{RhpcBLASctl::omp_set_num_threads(1)}
data(agaricus.train, package='xgboost')
data(agaricus.test, package='xgboost')
train <- agaricus.train
diff --git a/R-package/man/xgb.gblinear.history.Rd b/R-package/man/xgb.gblinear.history.Rd
index 103be16f1..25aef7163 100644
--- a/R-package/man/xgb.gblinear.history.Rd
+++ b/R-package/man/xgb.gblinear.history.Rd
@@ -8,7 +8,7 @@ xgb.gblinear.history(model, class_index = NULL)
}
\arguments{
\item{model}{either an \code{xgb.Booster} or a result of \code{xgb.cv()}, trained
-using the \code{cb.gblinear.history()} callback, but \bold{not} a booster
+using the \link{xgb.cb.gblinear.history} callback, but \bold{not} a booster
loaded from \link{xgb.load} or \link{xgb.load.raw}.}
\item{class_index}{zero-based class index to extract the coefficients for only that
@@ -16,23 +16,31 @@ specific class in a multinomial multiclass model. When it is NULL, all the
coefficients are returned. Has no effect in non-multiclass models.}
}
\value{
-For an \code{xgb.train} result, a matrix (either dense or sparse) with the columns
-corresponding to iteration's coefficients (in the order as \code{xgb.dump()} would
-return) and the rows corresponding to boosting iterations.
+For an \link{xgb.train} result, a matrix (either dense or sparse) with the columns
+corresponding to iteration's coefficients and the rows corresponding to boosting iterations.
-For an \code{xgb.cv} result, a list of such matrices is returned with the elements
+For an \link{xgb.cv} result, a list of such matrices is returned with the elements
corresponding to CV folds.
+
+When there is more than one coefficient per feature (e.g. multi-class classification)
+and \code{class_index} is not provided,
+the result will be reshaped into a vector where coefficients are arranged first by features and
+then by class (e.g. first 1 through N coefficients will be for the first class, then
+coefficients N+1 through 2N for the second class, and so on).
}
\description{
A helper function to extract the matrix of linear coefficients' history
-from a gblinear model created while using the \code{cb.gblinear.history()}
-callback.
+from a gblinear model created while using the \link{xgb.cb.gblinear.history}
+callback (which must be added manually as by default it's not used).
}
\details{
Note that this is an R-specific function that relies on R attributes that
are not saved when using xgboost's own serialization functions like \link{xgb.load}
or \link{xgb.load.raw}.
-In order for a serialized model to be accepted by tgis function, one must use R
+In order for a serialized model to be accepted by this function, one must use R
serializers such as \link{saveRDS}.
}
+\seealso{
+\link{xgb.cb.gblinear.history}, \link{coef.xgb.Booster}.
+}
diff --git a/R-package/man/xgb.load.Rd b/R-package/man/xgb.load.Rd
index 1a6873171..e18a900e3 100644
--- a/R-package/man/xgb.load.Rd
+++ b/R-package/man/xgb.load.Rd
@@ -17,7 +17,7 @@ Load xgboost model from the binary model file.
}
\details{
The input file is expected to contain a model saved in an xgboost model format
-using either \code{\link{xgb.save}} or \code{\link{cb.save.model}} in R, or using some
+using either \code{\link{xgb.save}} or \code{\link{xgb.cb.save.model}} in R, or using some
appropriate methods from other xgboost interfaces. E.g., a model trained in Python and
saved from there in xgboost format, could be loaded from R.
@@ -25,6 +25,7 @@ Note: a model saved as an R-object, has to be loaded using corresponding R-metho
not \code{xgb.load}.
}
\examples{
+\dontshow{RhpcBLASctl::omp_set_num_threads(1)}
data(agaricus.train, package='xgboost')
data(agaricus.test, package='xgboost')
diff --git a/R-package/man/xgb.save.Rd b/R-package/man/xgb.save.Rd
index 0db80a120..bcfbd0bb4 100644
--- a/R-package/man/xgb.save.Rd
+++ b/R-package/man/xgb.save.Rd
@@ -41,6 +41,7 @@ how to persist models in a future-proof way, i.e. to make the model accessible i
releases of XGBoost.
}
\examples{
+\dontshow{RhpcBLASctl::omp_set_num_threads(1)}
data(agaricus.train, package='xgboost')
data(agaricus.test, package='xgboost')
diff --git a/R-package/man/xgb.save.raw.Rd b/R-package/man/xgb.save.raw.Rd
index 15400bb14..6cdafd3d9 100644
--- a/R-package/man/xgb.save.raw.Rd
+++ b/R-package/man/xgb.save.raw.Rd
@@ -21,6 +21,7 @@ xgb.save.raw(model, raw_format = "ubj")
Save xgboost model from xgboost or xgb.train
}
\examples{
+\dontshow{RhpcBLASctl::omp_set_num_threads(1)}
data(agaricus.train, package='xgboost')
data(agaricus.test, package='xgboost')
diff --git a/R-package/man/xgb.train.Rd b/R-package/man/xgb.train.Rd
index 0421b9c4a..21c8dbe16 100644
--- a/R-package/man/xgb.train.Rd
+++ b/R-package/man/xgb.train.Rd
@@ -9,7 +9,7 @@ xgb.train(
params = list(),
data,
nrounds,
- watchlist = list(),
+ evals = list(),
obj = NULL,
feval = NULL,
verbose = 1,
@@ -158,13 +158,13 @@ List is provided in detail section.}
\item{nrounds}{max number of boosting iterations.}
-\item{watchlist}{named list of xgb.DMatrix datasets to use for evaluating model performance.
+\item{evals}{Named list of \code{xgb.DMatrix} datasets to use for evaluating model performance.
Metrics specified in either \code{eval_metric} or \code{feval} will be computed for each
of these datasets during each boosting iteration, and stored in the end as a field named
\code{evaluation_log} in the resulting object. When either \code{verbose>=1} or
-\code{\link{cb.print.evaluation}} callback is engaged, the performance results are continuously
+\code{\link{xgb.cb.print.evaluation}} callback is engaged, the performance results are continuously
printed out during the training.
-E.g., specifying \code{watchlist=list(validation1=mat1, validation2=mat2)} allows to track
+E.g., specifying \code{evals=list(validation1=mat1, validation2=mat2)} allows to track
the performance of each round's model on mat1 and mat2.}
\item{obj}{customized objective function. Returns gradient and second order
@@ -177,24 +177,24 @@ prediction and dtrain.}
\item{verbose}{If 0, xgboost will stay silent. If 1, it will print information about performance.
If 2, some additional information will be printed out.
Note that setting \code{verbose > 0} automatically engages the
-\code{cb.print.evaluation(period=1)} callback function.}
+\code{xgb.cb.print.evaluation(period=1)} callback function.}
\item{print_every_n}{Print each n-th iteration evaluation messages when \code{verbose>0}.
Default is 1 which means all messages are printed. This parameter is passed to the
-\code{\link{cb.print.evaluation}} callback.}
+\code{\link{xgb.cb.print.evaluation}} callback.}
\item{early_stopping_rounds}{If \code{NULL}, the early stopping function is not triggered.
If set to an integer \code{k}, training with a validation set will stop if the performance
doesn't improve for \code{k} rounds.
-Setting this parameter engages the \code{\link{cb.early.stop}} callback.}
+Setting this parameter engages the \code{\link{xgb.cb.early.stop}} callback.}
\item{maximize}{If \code{feval} and \code{early_stopping_rounds} are set,
then this parameter must be set as well.
When it is \code{TRUE}, it means the larger the evaluation score the better.
-This parameter is passed to the \code{\link{cb.early.stop}} callback.}
+This parameter is passed to the \code{\link{xgb.cb.early.stop}} callback.}
\item{save_period}{when it is non-NULL, model is saved to disk after every \code{save_period} rounds,
-0 means save at the end. The saving is handled by the \code{\link{cb.save.model}} callback.}
+0 means save at the end. The saving is handled by the \code{\link{xgb.cb.save.model}} callback.}
\item{save_name}{the name or path for periodically saved model file.}
@@ -203,12 +203,13 @@ Could be either an object of class \code{xgb.Booster}, or its raw data, or the n
file with a previously saved model.}
\item{callbacks}{a list of callback functions to perform various task during boosting.
-See \code{\link{callbacks}}. Some of the callbacks are automatically created depending on the
+See \code{\link{xgb.Callback}}. Some of the callbacks are automatically created depending on the
parameters' values. User can provide either existing or their own callback methods in order
to customize the training process.
-\if{html}{\out{}}\preformatted{ Note that some callbacks might try to set an evaluation log - be aware that these evaluation logs
- are kept as R attributes, and thus do not get saved when using non-R serializaters like
+\if{html}{\out{
}}\preformatted{ Note that some callbacks might try to leave attributes in the resulting model object,
+ such as an evaluation log (a `data.table` object) - be aware that these objects are kept
+ as R attributes, and thus do not get saved when using XGBoost's own serializaters like
\link{xgb.save} (but are kept when using R serializers like \link{saveRDS}).
}\if{html}{\out{
}}}
@@ -233,7 +234,7 @@ The \code{xgboost} function is a simpler wrapper for \code{xgb.train}.
\details{
These are the training functions for \code{xgboost}.
-The \code{xgb.train} interface supports advanced features such as \code{watchlist},
+The \code{xgb.train} interface supports advanced features such as \code{evals},
customized objective and evaluation metric functions, therefore it is more flexible
than the \code{xgboost} interface.
@@ -241,6 +242,11 @@ Parallelization is automatically enabled if \code{OpenMP} is present.
Number of threads can also be manually specified via the \code{nthread}
parameter.
+While in other interfaces, the default random seed defaults to zero, in R, if a parameter \code{seed}
+is not manually supplied, it will generate a random seed through R's own random number generator,
+whose seed in turn is controllable through \code{set.seed}. If \code{seed} is passed, it will override the
+RNG from R.
+
The evaluation metric is chosen automatically by XGBoost (according to the objective)
when the \code{eval_metric} parameter is not provided.
User may set one or several \code{eval_metric} parameters.
@@ -264,18 +270,19 @@ Different threshold (e.g., 0.) could be specified as "error@0."
The following callbacks are automatically created when certain parameters are set:
\itemize{
-\item \code{cb.print.evaluation} is turned on when \code{verbose > 0};
+\item \code{xgb.cb.print.evaluation} is turned on when \code{verbose > 0};
and the \code{print_every_n} parameter is passed to it.
-\item \code{cb.evaluation.log} is on when \code{watchlist} is present.
-\item \code{cb.early.stop}: when \code{early_stopping_rounds} is set.
-\item \code{cb.save.model}: when \code{save_period > 0} is set.
+\item \code{xgb.cb.evaluation.log} is on when \code{evals} is present.
+\item \code{xgb.cb.early.stop}: when \code{early_stopping_rounds} is set.
+\item \code{xgb.cb.save.model}: when \code{save_period > 0} is set.
}
Note that objects of type \code{xgb.Booster} as returned by this function behave a bit differently
from typical R objects (it's an 'altrep' list class), and it makes a separation between
internal booster attributes (restricted to jsonifyable data), accessed through \link{xgb.attr}
and shared between interfaces through serialization functions like \link{xgb.save}; and
-R-specific attributes, accessed through \link{attributes} and \link{attr}, which are otherwise
+R-specific attributes (typically the result from a callback), accessed through \link{attributes}
+and \link{attr}, which are otherwise
only used in the R interface, only kept when using R's serializers like \link{saveRDS}, and
not anyhow used by functions like \link{predict.xgb.Booster}.
@@ -300,12 +307,12 @@ dtrain <- with(
dtest <- with(
agaricus.test, xgb.DMatrix(data, label = label, nthread = nthread)
)
-watchlist <- list(train = dtrain, eval = dtest)
+evals <- list(train = dtrain, eval = dtest)
## A simple xgb.train example:
param <- list(max_depth = 2, eta = 1, nthread = nthread,
objective = "binary:logistic", eval_metric = "auc")
-bst <- xgb.train(param, dtrain, nrounds = 2, watchlist, verbose = 0)
+bst <- xgb.train(param, dtrain, nrounds = 2, evals = evals, verbose = 0)
## An xgb.train example where custom objective and evaluation metric are
## used:
@@ -326,15 +333,15 @@ evalerror <- function(preds, dtrain) {
# as 'objective' and 'eval_metric' parameters in the params list:
param <- list(max_depth = 2, eta = 1, nthread = nthread,
objective = logregobj, eval_metric = evalerror)
-bst <- xgb.train(param, dtrain, nrounds = 2, watchlist, verbose = 0)
+bst <- xgb.train(param, dtrain, nrounds = 2, evals = evals, verbose = 0)
# or through the ... arguments:
param <- list(max_depth = 2, eta = 1, nthread = nthread)
-bst <- xgb.train(param, dtrain, nrounds = 2, watchlist, verbose = 0,
+bst <- xgb.train(param, dtrain, nrounds = 2, evals = evals, verbose = 0,
objective = logregobj, eval_metric = evalerror)
# or as dedicated 'obj' and 'feval' parameters of xgb.train:
-bst <- xgb.train(param, dtrain, nrounds = 2, watchlist,
+bst <- xgb.train(param, dtrain, nrounds = 2, evals = evals,
obj = logregobj, feval = evalerror)
@@ -342,11 +349,11 @@ bst <- xgb.train(param, dtrain, nrounds = 2, watchlist,
param <- list(max_depth = 2, eta = 1, nthread = nthread,
objective = "binary:logistic", eval_metric = "auc")
my_etas <- list(eta = c(0.5, 0.1))
-bst <- xgb.train(param, dtrain, nrounds = 2, watchlist, verbose = 0,
- callbacks = list(cb.reset.parameters(my_etas)))
+bst <- xgb.train(param, dtrain, nrounds = 2, evals = evals, verbose = 0,
+ callbacks = list(xgb.cb.reset.parameters(my_etas)))
## Early stopping:
-bst <- xgb.train(param, dtrain, nrounds = 25, watchlist,
+bst <- xgb.train(param, dtrain, nrounds = 25, evals = evals,
early_stopping_rounds = 3)
## An 'xgboost' interface example:
@@ -361,7 +368,7 @@ Tianqi Chen and Carlos Guestrin, "XGBoost: A Scalable Tree Boosting System",
22nd SIGKDD Conference on Knowledge Discovery and Data Mining, 2016, \url{https://arxiv.org/abs/1603.02754}
}
\seealso{
-\code{\link{callbacks}},
+\code{\link{xgb.Callback}},
\code{\link{predict.xgb.Booster}},
\code{\link{xgb.cv}}
}
diff --git a/R-package/man/xgbConfig.Rd b/R-package/man/xgbConfig.Rd
index 94b220c77..164c62ef4 100644
--- a/R-package/man/xgbConfig.Rd
+++ b/R-package/man/xgbConfig.Rd
@@ -25,6 +25,15 @@ values of one or more global-scope parameters. Use \code{xgb.get.config} to fetc
values of all global-scope parameters (listed in
\url{https://xgboost.readthedocs.io/en/stable/parameter.html}).
}
+\details{
+Note that serialization-related functions might use a globally-configured number of threads,
+which is managed by the system's OpenMP (OMP) configuration instead. Typically, XGBoost methods
+accept an \code{nthreads} parameter, but some methods like \code{readRDS} might get executed before such
+parameter can be supplied.
+
+The number of OMP threads can in turn be configured for example through an environment variable
+\code{OMP_NUM_THREADS} (needs to be set before R is started), or through \code{RhpcBLASctl::omp_set_num_threads}.
+}
\examples{
# Set verbosity level to silent (0)
xgb.set.config(verbosity = 0)
diff --git a/R-package/src/Makevars.in b/R-package/src/Makevars.in
index dd13983f5..0f4b3ac6f 100644
--- a/R-package/src/Makevars.in
+++ b/R-package/src/Makevars.in
@@ -104,6 +104,7 @@ OBJECTS= \
$(PKGROOT)/src/collective/broadcast.o \
$(PKGROOT)/src/collective/comm.o \
$(PKGROOT)/src/collective/coll.o \
+ $(PKGROOT)/src/collective/communicator-inl.o \
$(PKGROOT)/src/collective/tracker.o \
$(PKGROOT)/src/collective/communicator.o \
$(PKGROOT)/src/collective/in_memory_communicator.o \
diff --git a/R-package/src/Makevars.win b/R-package/src/Makevars.win
index 46a862711..0c2084de9 100644
--- a/R-package/src/Makevars.win
+++ b/R-package/src/Makevars.win
@@ -104,6 +104,7 @@ OBJECTS= \
$(PKGROOT)/src/collective/broadcast.o \
$(PKGROOT)/src/collective/comm.o \
$(PKGROOT)/src/collective/coll.o \
+ $(PKGROOT)/src/collective/communicator-inl.o \
$(PKGROOT)/src/collective/tracker.o \
$(PKGROOT)/src/collective/communicator.o \
$(PKGROOT)/src/collective/in_memory_communicator.o \
diff --git a/R-package/src/init.c b/R-package/src/init.c
index a9f3f3e38..c869871c6 100644
--- a/R-package/src/init.c
+++ b/R-package/src/init.c
@@ -37,6 +37,9 @@ extern SEXP XGBoosterLoadJsonConfig_R(SEXP handle, SEXP value);
extern SEXP XGBoosterSerializeToBuffer_R(SEXP handle);
extern SEXP XGBoosterUnserializeFromBuffer_R(SEXP handle, SEXP raw);
extern SEXP XGBoosterPredictFromDMatrix_R(SEXP, SEXP, SEXP);
+extern SEXP XGBoosterPredictFromDense_R(SEXP, SEXP, SEXP, SEXP, SEXP);
+extern SEXP XGBoosterPredictFromCSR_R(SEXP, SEXP, SEXP, SEXP, SEXP);
+extern SEXP XGBoosterPredictFromColumnar_R(SEXP, SEXP, SEXP, SEXP, SEXP);
extern SEXP XGBoosterSaveModel_R(SEXP, SEXP);
extern SEXP XGBoosterSetAttr_R(SEXP, SEXP, SEXP);
extern SEXP XGBoosterSetParam_R(SEXP, SEXP, SEXP);
@@ -46,7 +49,7 @@ extern SEXP XGSetArrayDimInplace_R(SEXP, SEXP);
extern SEXP XGSetArrayDimNamesInplace_R(SEXP, SEXP);
extern SEXP XGDMatrixCreateFromCSC_R(SEXP, SEXP, SEXP, SEXP, SEXP, SEXP);
extern SEXP XGDMatrixCreateFromCSR_R(SEXP, SEXP, SEXP, SEXP, SEXP, SEXP);
-extern SEXP XGDMatrixCreateFromFile_R(SEXP, SEXP);
+extern SEXP XGDMatrixCreateFromURI_R(SEXP, SEXP, SEXP);
extern SEXP XGDMatrixCreateFromMat_R(SEXP, SEXP, SEXP);
extern SEXP XGDMatrixGetFloatInfo_R(SEXP, SEXP);
extern SEXP XGDMatrixGetUIntInfo_R(SEXP, SEXP);
@@ -73,6 +76,7 @@ extern SEXP XGBSetGlobalConfig_R(SEXP);
extern SEXP XGBGetGlobalConfig_R(void);
extern SEXP XGBoosterFeatureScore_R(SEXP, SEXP);
extern SEXP XGBoosterSlice_R(SEXP, SEXP, SEXP, SEXP);
+extern SEXP XGBoosterSliceAndReplace_R(SEXP, SEXP, SEXP, SEXP);
static const R_CallMethodDef CallEntries[] = {
{"XGDuplicate_R", (DL_FUNC) &XGDuplicate_R, 1},
@@ -96,6 +100,9 @@ static const R_CallMethodDef CallEntries[] = {
{"XGBoosterSerializeToBuffer_R", (DL_FUNC) &XGBoosterSerializeToBuffer_R, 1},
{"XGBoosterUnserializeFromBuffer_R", (DL_FUNC) &XGBoosterUnserializeFromBuffer_R, 2},
{"XGBoosterPredictFromDMatrix_R", (DL_FUNC) &XGBoosterPredictFromDMatrix_R, 3},
+ {"XGBoosterPredictFromDense_R", (DL_FUNC) &XGBoosterPredictFromDense_R, 5},
+ {"XGBoosterPredictFromCSR_R", (DL_FUNC) &XGBoosterPredictFromCSR_R, 5},
+ {"XGBoosterPredictFromColumnar_R", (DL_FUNC) &XGBoosterPredictFromColumnar_R, 5},
{"XGBoosterSaveModel_R", (DL_FUNC) &XGBoosterSaveModel_R, 2},
{"XGBoosterSetAttr_R", (DL_FUNC) &XGBoosterSetAttr_R, 3},
{"XGBoosterSetParam_R", (DL_FUNC) &XGBoosterSetParam_R, 3},
@@ -105,7 +112,7 @@ static const R_CallMethodDef CallEntries[] = {
{"XGSetArrayDimNamesInplace_R", (DL_FUNC) &XGSetArrayDimNamesInplace_R, 2},
{"XGDMatrixCreateFromCSC_R", (DL_FUNC) &XGDMatrixCreateFromCSC_R, 6},
{"XGDMatrixCreateFromCSR_R", (DL_FUNC) &XGDMatrixCreateFromCSR_R, 6},
- {"XGDMatrixCreateFromFile_R", (DL_FUNC) &XGDMatrixCreateFromFile_R, 2},
+ {"XGDMatrixCreateFromURI_R", (DL_FUNC) &XGDMatrixCreateFromURI_R, 3},
{"XGDMatrixCreateFromMat_R", (DL_FUNC) &XGDMatrixCreateFromMat_R, 3},
{"XGDMatrixGetFloatInfo_R", (DL_FUNC) &XGDMatrixGetFloatInfo_R, 2},
{"XGDMatrixGetUIntInfo_R", (DL_FUNC) &XGDMatrixGetUIntInfo_R, 2},
@@ -132,6 +139,7 @@ static const R_CallMethodDef CallEntries[] = {
{"XGBGetGlobalConfig_R", (DL_FUNC) &XGBGetGlobalConfig_R, 0},
{"XGBoosterFeatureScore_R", (DL_FUNC) &XGBoosterFeatureScore_R, 2},
{"XGBoosterSlice_R", (DL_FUNC) &XGBoosterSlice_R, 4},
+ {"XGBoosterSliceAndReplace_R", (DL_FUNC) &XGBoosterSliceAndReplace_R, 4},
{NULL, NULL, 0}
};
diff --git a/R-package/src/xgboost_R.cc b/R-package/src/xgboost_R.cc
index c91fb94c4..2228932bd 100644
--- a/R-package/src/xgboost_R.cc
+++ b/R-package/src/xgboost_R.cc
@@ -13,6 +13,7 @@
#include
#include
#include
+#include
#include
#include
#include
@@ -207,25 +208,24 @@ SEXP SafeAllocInteger(size_t size, SEXP continuation_token) {
return xgboost::Json::Dump(jinterface);
}
-[[nodiscard]] std::string MakeJsonConfigForArray(SEXP missing, SEXP n_threads, SEXPTYPE arr_type) {
- using namespace ::xgboost; // NOLINT
- Json jconfig{Object{}};
-
- const SEXPTYPE missing_type = TYPEOF(missing);
- if (Rf_isNull(missing) || (missing_type == REALSXP && ISNAN(Rf_asReal(missing))) ||
- (missing_type == LGLSXP && Rf_asLogical(missing) == R_NaInt) ||
- (missing_type == INTSXP && Rf_asInteger(missing) == R_NaInt)) {
+void AddMissingToJson(xgboost::Json *jconfig, SEXP missing, SEXPTYPE arr_type) {
+ if (Rf_isNull(missing) || ISNAN(Rf_asReal(missing))) {
// missing is not specified
if (arr_type == REALSXP) {
- jconfig["missing"] = std::numeric_limits::quiet_NaN();
+ (*jconfig)["missing"] = std::numeric_limits::quiet_NaN();
} else {
- jconfig["missing"] = R_NaInt;
+ (*jconfig)["missing"] = R_NaInt;
}
} else {
// missing specified
- jconfig["missing"] = Rf_asReal(missing);
+ (*jconfig)["missing"] = Rf_asReal(missing);
}
+}
+[[nodiscard]] std::string MakeJsonConfigForArray(SEXP missing, SEXP n_threads, SEXPTYPE arr_type) {
+ using namespace ::xgboost; // NOLINT
+ Json jconfig{Object{}};
+ AddMissingToJson(&jconfig, missing, arr_type);
jconfig["nthread"] = Rf_asInteger(n_threads);
return Json::Dump(jconfig);
}
@@ -365,15 +365,22 @@ XGB_DLL SEXP XGBGetGlobalConfig_R() {
return mkString(json_str);
}
-XGB_DLL SEXP XGDMatrixCreateFromFile_R(SEXP fname, SEXP silent) {
- SEXP ret = PROTECT(R_MakeExternalPtr(nullptr, R_NilValue, R_NilValue));
+XGB_DLL SEXP XGDMatrixCreateFromURI_R(SEXP uri, SEXP silent, SEXP data_split_mode) {
+ SEXP ret = Rf_protect(R_MakeExternalPtr(nullptr, R_NilValue, R_NilValue));
+ SEXP uri_char = Rf_protect(Rf_asChar(uri));
+ const char *uri_ptr = CHAR(uri_char);
R_API_BEGIN();
+ xgboost::Json jconfig{xgboost::Object{}};
+ jconfig["uri"] = std::string(uri_ptr);
+ jconfig["silent"] = Rf_asLogical(silent);
+ jconfig["data_split_mode"] = Rf_asInteger(data_split_mode);
+ const std::string sconfig = xgboost::Json::Dump(jconfig);
DMatrixHandle handle;
- CHECK_CALL(XGDMatrixCreateFromFile(CHAR(asChar(fname)), asInteger(silent), &handle));
+ CHECK_CALL(XGDMatrixCreateFromURI(sconfig.c_str(), &handle));
R_SetExternalPtrAddr(ret, handle);
R_RegisterCFinalizerEx(ret, _DMatrixFinalizer, TRUE);
R_API_END();
- UNPROTECT(1);
+ Rf_unprotect(2);
return ret;
}
@@ -404,7 +411,7 @@ XGB_DLL SEXP XGDMatrixCreateFromDF_R(SEXP df, SEXP missing, SEXP n_threads) {
DMatrixHandle handle;
std::int32_t rc{0};
{
- std::string sinterface = MakeArrayInterfaceFromRDataFrame(df);
+ const std::string sinterface = MakeArrayInterfaceFromRDataFrame(df);
xgboost::Json jconfig{xgboost::Object{}};
jconfig["missing"] = asReal(missing);
jconfig["nthread"] = asInteger(n_threads);
@@ -456,7 +463,7 @@ XGB_DLL SEXP XGDMatrixCreateFromCSC_R(SEXP indptr, SEXP indices, SEXP data, SEXP
Json jconfig{Object{}};
// Construct configuration
jconfig["nthread"] = Integer{threads};
- jconfig["missing"] = xgboost::Number{asReal(missing)};
+ AddMissingToJson(&jconfig, missing, TYPEOF(data));
std::string config;
Json::Dump(jconfig, &config);
res_code = XGDMatrixCreateFromCSC(sindptr.c_str(), sindices.c_str(), sdata.c_str(), nrow,
@@ -491,7 +498,7 @@ XGB_DLL SEXP XGDMatrixCreateFromCSR_R(SEXP indptr, SEXP indices, SEXP data, SEXP
Json jconfig{Object{}};
// Construct configuration
jconfig["nthread"] = Integer{threads};
- jconfig["missing"] = xgboost::Number{asReal(missing)};
+ AddMissingToJson(&jconfig, missing, TYPEOF(data));
std::string config;
Json::Dump(jconfig, &config);
res_code = XGDMatrixCreateFromCSR(sindptr.c_str(), sindices.c_str(), sdata.c_str(), ncol,
@@ -1240,7 +1247,60 @@ XGB_DLL SEXP XGBoosterEvalOneIter_R(SEXP handle, SEXP iter, SEXP dmats, SEXP evn
return mkString(ret);
}
-XGB_DLL SEXP XGBoosterPredictFromDMatrix_R(SEXP handle, SEXP dmat, SEXP json_config) {
+namespace {
+
+struct ProxyDmatrixError : public std::exception {};
+
+struct ProxyDmatrixWrapper {
+ DMatrixHandle proxy_dmat_handle;
+
+ ProxyDmatrixWrapper() {
+ int res_code = XGProxyDMatrixCreate(&this->proxy_dmat_handle);
+ if (res_code != 0) {
+ throw ProxyDmatrixError();
+ }
+ }
+
+ ~ProxyDmatrixWrapper() {
+ if (this->proxy_dmat_handle) {
+ XGDMatrixFree(this->proxy_dmat_handle);
+ this->proxy_dmat_handle = nullptr;
+ }
+ }
+
+ DMatrixHandle get_handle() {
+ return this->proxy_dmat_handle;
+ }
+};
+
+std::unique_ptr GetProxyDMatrixWithBaseMargin(SEXP base_margin) {
+ if (Rf_isNull(base_margin)) {
+ return std::unique_ptr(nullptr);
+ }
+
+ SEXP base_margin_dim = Rf_getAttrib(base_margin, R_DimSymbol);
+ int res_code;
+ try {
+ const std::string array_str = Rf_isNull(base_margin_dim)?
+ MakeArrayInterfaceFromRVector(base_margin) : MakeArrayInterfaceFromRMat(base_margin);
+ std::unique_ptr proxy_dmat(new ProxyDmatrixWrapper());
+ res_code = XGDMatrixSetInfoFromInterface(proxy_dmat->get_handle(),
+ "base_margin",
+ array_str.c_str());
+ if (res_code != 0) {
+ throw ProxyDmatrixError();
+ }
+ return proxy_dmat;
+ } catch(ProxyDmatrixError &err) {
+ Rf_error("%s", XGBGetLastError());
+ }
+}
+
+enum class PredictionInputType {DMatrix, DenseMatrix, CSRMatrix, DataFrame};
+
+SEXP XGBoosterPredictGeneric(SEXP handle, SEXP input_data, SEXP json_config,
+ PredictionInputType input_type, SEXP missing,
+ SEXP base_margin) {
SEXP r_out_shape;
SEXP r_out_result;
SEXP r_out = PROTECT(allocVector(VECSXP, 2));
@@ -1252,9 +1312,79 @@ XGB_DLL SEXP XGBoosterPredictFromDMatrix_R(SEXP handle, SEXP dmat, SEXP json_con
bst_ulong out_dim;
bst_ulong const *out_shape;
float const *out_result;
- CHECK_CALL(XGBoosterPredictFromDMatrix(R_ExternalPtrAddr(handle),
- R_ExternalPtrAddr(dmat), c_json_config,
- &out_shape, &out_dim, &out_result));
+
+ int res_code;
+ {
+ switch (input_type) {
+ case PredictionInputType::DMatrix: {
+ res_code = XGBoosterPredictFromDMatrix(R_ExternalPtrAddr(handle),
+ R_ExternalPtrAddr(input_data), c_json_config,
+ &out_shape, &out_dim, &out_result);
+ break;
+ }
+
+ case PredictionInputType::CSRMatrix: {
+ std::unique_ptr proxy_dmat = GetProxyDMatrixWithBaseMargin(
+ base_margin);
+ DMatrixHandle proxy_dmat_handle = proxy_dmat.get()? proxy_dmat->get_handle() : nullptr;
+
+ SEXP indptr = VECTOR_ELT(input_data, 0);
+ SEXP indices = VECTOR_ELT(input_data, 1);
+ SEXP data = VECTOR_ELT(input_data, 2);
+ const int ncol_csr = Rf_asInteger(VECTOR_ELT(input_data, 3));
+ const SEXPTYPE type_data = TYPEOF(data);
+ CHECK_EQ(type_data, REALSXP);
+ std::string sindptr, sindices, sdata;
+ CreateFromSparse(indptr, indices, data, &sindptr, &sindices, &sdata);
+
+ xgboost::StringView json_str(c_json_config);
+ xgboost::Json new_json = xgboost::Json::Load(json_str);
+ AddMissingToJson(&new_json, missing, type_data);
+ const std::string new_c_json = xgboost::Json::Dump(new_json);
+
+ res_code = XGBoosterPredictFromCSR(
+ R_ExternalPtrAddr(handle), sindptr.c_str(), sindices.c_str(), sdata.c_str(),
+ ncol_csr, new_c_json.c_str(), proxy_dmat_handle, &out_shape, &out_dim, &out_result);
+ break;
+ }
+
+ case PredictionInputType::DenseMatrix: {
+ std::unique_ptr proxy_dmat = GetProxyDMatrixWithBaseMargin(
+ base_margin);
+ DMatrixHandle proxy_dmat_handle = proxy_dmat.get()? proxy_dmat->get_handle() : nullptr;
+ const std::string array_str = MakeArrayInterfaceFromRMat(input_data);
+
+ xgboost::StringView json_str(c_json_config);
+ xgboost::Json new_json = xgboost::Json::Load(json_str);
+ AddMissingToJson(&new_json, missing, TYPEOF(input_data));
+ const std::string new_c_json = xgboost::Json::Dump(new_json);
+
+ res_code = XGBoosterPredictFromDense(
+ R_ExternalPtrAddr(handle), array_str.c_str(), new_c_json.c_str(),
+ proxy_dmat_handle, &out_shape, &out_dim, &out_result);
+ break;
+ }
+
+ case PredictionInputType::DataFrame: {
+ std::unique_ptr proxy_dmat = GetProxyDMatrixWithBaseMargin(
+ base_margin);
+ DMatrixHandle proxy_dmat_handle = proxy_dmat.get()? proxy_dmat->get_handle() : nullptr;
+
+ const std::string df_str = MakeArrayInterfaceFromRDataFrame(input_data);
+
+ xgboost::StringView json_str(c_json_config);
+ xgboost::Json new_json = xgboost::Json::Load(json_str);
+ AddMissingToJson(&new_json, missing, REALSXP);
+ const std::string new_c_json = xgboost::Json::Dump(new_json);
+
+ res_code = XGBoosterPredictFromColumnar(
+ R_ExternalPtrAddr(handle), df_str.c_str(), new_c_json.c_str(),
+ proxy_dmat_handle, &out_shape, &out_dim, &out_result);
+ break;
+ }
+ }
+ }
+ CHECK_CALL(res_code);
r_out_shape = PROTECT(allocVector(INTSXP, out_dim));
size_t len = 1;
@@ -1275,6 +1405,31 @@ XGB_DLL SEXP XGBoosterPredictFromDMatrix_R(SEXP handle, SEXP dmat, SEXP json_con
return r_out;
}
+} // namespace
+
+XGB_DLL SEXP XGBoosterPredictFromDMatrix_R(SEXP handle, SEXP dmat, SEXP json_config) {
+ return XGBoosterPredictGeneric(handle, dmat, json_config,
+ PredictionInputType::DMatrix, R_NilValue, R_NilValue);
+}
+
+XGB_DLL SEXP XGBoosterPredictFromDense_R(SEXP handle, SEXP R_mat, SEXP missing,
+ SEXP json_config, SEXP base_margin) {
+ return XGBoosterPredictGeneric(handle, R_mat, json_config,
+ PredictionInputType::DenseMatrix, missing, base_margin);
+}
+
+XGB_DLL SEXP XGBoosterPredictFromCSR_R(SEXP handle, SEXP lst, SEXP missing,
+ SEXP json_config, SEXP base_margin) {
+ return XGBoosterPredictGeneric(handle, lst, json_config,
+ PredictionInputType::CSRMatrix, missing, base_margin);
+}
+
+XGB_DLL SEXP XGBoosterPredictFromColumnar_R(SEXP handle, SEXP R_df, SEXP missing,
+ SEXP json_config, SEXP base_margin) {
+ return XGBoosterPredictGeneric(handle, R_df, json_config,
+ PredictionInputType::DataFrame, missing, base_margin);
+}
+
XGB_DLL SEXP XGBoosterLoadModel_R(SEXP handle, SEXP fname) {
R_API_BEGIN();
CHECK_CALL(XGBoosterLoadModel(R_ExternalPtrAddr(handle), CHAR(asChar(fname))));
@@ -1519,3 +1674,18 @@ XGB_DLL SEXP XGBoosterSlice_R(SEXP handle, SEXP begin_layer, SEXP end_layer, SEX
Rf_unprotect(1);
return out;
}
+
+XGB_DLL SEXP XGBoosterSliceAndReplace_R(SEXP handle, SEXP begin_layer, SEXP end_layer, SEXP step) {
+ R_API_BEGIN();
+ BoosterHandle old_handle = R_ExternalPtrAddr(handle);
+ BoosterHandle new_handle = nullptr;
+ CHECK_CALL(XGBoosterSlice(old_handle,
+ Rf_asInteger(begin_layer),
+ Rf_asInteger(end_layer),
+ Rf_asInteger(step),
+ &new_handle));
+ R_SetExternalPtrAddr(handle, new_handle);
+ CHECK_CALL(XGBoosterFree(old_handle));
+ R_API_END();
+ return R_NilValue;
+}
diff --git a/R-package/src/xgboost_R.h b/R-package/src/xgboost_R.h
index d2e0ae828..cea50c146 100644
--- a/R-package/src/xgboost_R.h
+++ b/R-package/src/xgboost_R.h
@@ -53,12 +53,13 @@ XGB_DLL SEXP XGBSetGlobalConfig_R(SEXP json_str);
XGB_DLL SEXP XGBGetGlobalConfig_R();
/*!
- * \brief load a data matrix
- * \param fname name of the content
+ * \brief load a data matrix from URI
+ * \param uri URI to the source file to read data from
* \param silent whether print messages
+ * \param Data split mode (0=rows, 1=columns)
* \return a loaded data matrix
*/
-XGB_DLL SEXP XGDMatrixCreateFromFile_R(SEXP fname, SEXP silent);
+XGB_DLL SEXP XGDMatrixCreateFromURI_R(SEXP uri, SEXP silent, SEXP data_split_mode);
/*!
* \brief create matrix content from dense matrix
@@ -370,6 +371,50 @@ XGB_DLL SEXP XGBoosterEvalOneIter_R(SEXP handle, SEXP iter, SEXP dmats, SEXP evn
* \return A list containing 2 vectors, first one for shape while second one for prediction result.
*/
XGB_DLL SEXP XGBoosterPredictFromDMatrix_R(SEXP handle, SEXP dmat, SEXP json_config);
+
+/*!
+ * \brief Run prediction on R dense matrix
+ * \param handle handle
+ * \param R_mat R matrix
+ * \param missing missing value
+ * \param json_config See `XGBoosterPredictFromDense` in xgboost c_api.h. Doesn't include 'missing'
+ * \param base_margin base margin for the prediction
+ *
+ * \return A list containing 2 vectors, first one for shape while second one for prediction result.
+ */
+XGB_DLL SEXP XGBoosterPredictFromDense_R(SEXP handle, SEXP R_mat, SEXP missing,
+ SEXP json_config, SEXP base_margin);
+
+/*!
+ * \brief Run prediction on R CSR matrix
+ * \param handle handle
+ * \param lst An R list, containing, in this order:
+ * (a) 'p' array (a.k.a. indptr)
+ * (b) 'j' array (a.k.a. indices)
+ * (c) 'x' array (a.k.a. data / values)
+ * (d) number of columns
+ * \param missing missing value
+ * \param json_config See `XGBoosterPredictFromCSR` in xgboost c_api.h. Doesn't include 'missing'
+ * \param base_margin base margin for the prediction
+ *
+ * \return A list containing 2 vectors, first one for shape while second one for prediction result.
+ */
+XGB_DLL SEXP XGBoosterPredictFromCSR_R(SEXP handle, SEXP lst, SEXP missing,
+ SEXP json_config, SEXP base_margin);
+
+/*!
+ * \brief Run prediction on R data.frame
+ * \param handle handle
+ * \param R_df R data.frame
+ * \param missing missing value
+ * \param json_config See `XGBoosterPredictFromDense` in xgboost c_api.h. Doesn't include 'missing'
+ * \param base_margin base margin for the prediction
+ *
+ * \return A list containing 2 vectors, first one for shape while second one for prediction result.
+ */
+XGB_DLL SEXP XGBoosterPredictFromColumnar_R(SEXP handle, SEXP R_df, SEXP missing,
+ SEXP json_config, SEXP base_margin);
+
/*!
* \brief load model from existing file
* \param handle handle
@@ -490,4 +535,14 @@ XGB_DLL SEXP XGBoosterFeatureScore_R(SEXP handle, SEXP json_config);
*/
XGB_DLL SEXP XGBoosterSlice_R(SEXP handle, SEXP begin_layer, SEXP end_layer, SEXP step);
+/*!
+ * \brief Slice a fitted booster model (by rounds), and replace its handle with the result
+ * \param handle handle to the fitted booster
+ * \param begin_layer start of the slice
+ * \param end_later end of the slice; end_layer=0 is equivalent to end_layer=num_boost_round
+ * \param step step size of the slice
+ * \return NULL
+ */
+XGB_DLL SEXP XGBoosterSliceAndReplace_R(SEXP handle, SEXP begin_layer, SEXP end_layer, SEXP step);
+
#endif // XGBOOST_WRAPPER_R_H_ // NOLINT(*)
diff --git a/R-package/src/xgboost_custom.cc b/R-package/src/xgboost_custom.cc
index 4b05361ca..fb548c61d 100644
--- a/R-package/src/xgboost_custom.cc
+++ b/R-package/src/xgboost_custom.cc
@@ -41,16 +41,6 @@ double LogGamma(double v) {
return lgammafn(v);
}
#endif // !defined(XGBOOST_USE_CUDA)
-// customize random engine.
-void CustomGlobalRandomEngine::seed(CustomGlobalRandomEngine::result_type val) {
- // ignore the seed
-}
-// use R's PRNG to replacd
-CustomGlobalRandomEngine::result_type
-CustomGlobalRandomEngine::operator()() {
- return static_cast(
- std::floor(unif_rand() * CustomGlobalRandomEngine::max()));
-}
} // namespace common
} // namespace xgboost
diff --git a/R-package/tests/helper_scripts/install_deps.R b/R-package/tests/helper_scripts/install_deps.R
index 3ae44f6b1..7a621798a 100644
--- a/R-package/tests/helper_scripts/install_deps.R
+++ b/R-package/tests/helper_scripts/install_deps.R
@@ -20,6 +20,7 @@ pkgs <- c(
"igraph",
"float",
"titanic",
+ "RhpcBLASctl",
## imports
"Matrix",
"methods",
diff --git a/R-package/tests/testthat.R b/R-package/tests/testthat.R
index 3bb229e70..bad6c1df3 100644
--- a/R-package/tests/testthat.R
+++ b/R-package/tests/testthat.R
@@ -1,4 +1,6 @@
library(testthat)
library(xgboost)
+library(Matrix)
test_check("xgboost", reporter = ProgressReporter)
+RhpcBLASctl::omp_set_num_threads(1)
diff --git a/R-package/tests/testthat/test_basic.R b/R-package/tests/testthat/test_basic.R
index 03a8ddbe1..18a3b99e6 100644
--- a/R-package/tests/testthat/test_basic.R
+++ b/R-package/tests/testthat/test_basic.R
@@ -20,7 +20,7 @@ test_that("train and predict binary classification", {
data = xgb.DMatrix(train$data, label = train$label), max_depth = 2,
eta = 1, nthread = n_threads, nrounds = nrounds,
objective = "binary:logistic", eval_metric = "error",
- watchlist = list(train = xgb.DMatrix(train$data, label = train$label))
+ evals = list(train = xgb.DMatrix(train$data, label = train$label))
),
"train-error"
)
@@ -139,8 +139,8 @@ test_that("dart prediction works", {
pred_by_train_1 <- predict(booster_by_train, newdata = dtrain, iterationrange = c(1, nrounds))
pred_by_train_2 <- predict(booster_by_train, newdata = dtrain, training = TRUE)
- expect_true(all(matrix(pred_by_train_0, byrow = TRUE) == matrix(pred_by_xgboost_0, byrow = TRUE)))
- expect_true(all(matrix(pred_by_train_1, byrow = TRUE) == matrix(pred_by_xgboost_1, byrow = TRUE)))
+ expect_equal(pred_by_train_0, pred_by_xgboost_0, tolerance = 1e-6)
+ expect_equal(pred_by_train_1, pred_by_xgboost_1, tolerance = 1e-6)
expect_true(all(matrix(pred_by_train_2, byrow = TRUE) == matrix(pred_by_xgboost_2, byrow = TRUE)))
})
@@ -152,7 +152,7 @@ test_that("train and predict softprob", {
data = xgb.DMatrix(as.matrix(iris[, -5]), label = lb),
max_depth = 3, eta = 0.5, nthread = n_threads, nrounds = 5,
objective = "multi:softprob", num_class = 3, eval_metric = "merror",
- watchlist = list(train = xgb.DMatrix(as.matrix(iris[, -5]), label = lb))
+ evals = list(train = xgb.DMatrix(as.matrix(iris[, -5]), label = lb))
),
"train-merror"
)
@@ -203,7 +203,7 @@ test_that("train and predict softmax", {
data = xgb.DMatrix(as.matrix(iris[, -5]), label = lb),
max_depth = 3, eta = 0.5, nthread = n_threads, nrounds = 5,
objective = "multi:softmax", num_class = 3, eval_metric = "merror",
- watchlist = list(train = xgb.DMatrix(as.matrix(iris[, -5]), label = lb))
+ evals = list(train = xgb.DMatrix(as.matrix(iris[, -5]), label = lb))
),
"train-merror"
)
@@ -226,7 +226,7 @@ test_that("train and predict RF", {
nthread = n_threads,
nrounds = 1, objective = "binary:logistic", eval_metric = "error",
num_parallel_tree = 20, subsample = 0.6, colsample_bytree = 0.1,
- watchlist = list(train = xgb.DMatrix(train$data, label = lb))
+ evals = list(train = xgb.DMatrix(train$data, label = lb))
)
expect_equal(xgb.get.num.boosted.rounds(bst), 1)
@@ -250,7 +250,7 @@ test_that("train and predict RF with softprob", {
objective = "multi:softprob", eval_metric = "merror",
num_class = 3, verbose = 0,
num_parallel_tree = 4, subsample = 0.5, colsample_bytree = 0.5,
- watchlist = list(train = xgb.DMatrix(as.matrix(iris[, -5]), label = lb))
+ evals = list(train = xgb.DMatrix(as.matrix(iris[, -5]), label = lb))
)
expect_equal(xgb.get.num.boosted.rounds(bst), 15)
# predict for all iterations:
@@ -271,7 +271,7 @@ test_that("use of multiple eval metrics works", {
data = xgb.DMatrix(train$data, label = train$label), max_depth = 2,
eta = 1, nthread = n_threads, nrounds = 2, objective = "binary:logistic",
eval_metric = "error", eval_metric = "auc", eval_metric = "logloss",
- watchlist = list(train = xgb.DMatrix(train$data, label = train$label))
+ evals = list(train = xgb.DMatrix(train$data, label = train$label))
),
"train-error.*train-auc.*train-logloss"
)
@@ -283,7 +283,7 @@ test_that("use of multiple eval metrics works", {
data = xgb.DMatrix(train$data, label = train$label), max_depth = 2,
eta = 1, nthread = n_threads, nrounds = 2, objective = "binary:logistic",
eval_metric = list("error", "auc", "logloss"),
- watchlist = list(train = xgb.DMatrix(train$data, label = train$label))
+ evals = list(train = xgb.DMatrix(train$data, label = train$label))
),
"train-error.*train-auc.*train-logloss"
)
@@ -295,19 +295,19 @@ test_that("use of multiple eval metrics works", {
test_that("training continuation works", {
dtrain <- xgb.DMatrix(train$data, label = train$label, nthread = n_threads)
- watchlist <- list(train = dtrain)
+ evals <- list(train = dtrain)
param <- list(
objective = "binary:logistic", max_depth = 2, eta = 1, nthread = n_threads
)
# for the reference, use 4 iterations at once:
set.seed(11)
- bst <- xgb.train(param, dtrain, nrounds = 4, watchlist, verbose = 0)
+ bst <- xgb.train(param, dtrain, nrounds = 4, evals = evals, verbose = 0)
# first two iterations:
set.seed(11)
- bst1 <- xgb.train(param, dtrain, nrounds = 2, watchlist, verbose = 0)
+ bst1 <- xgb.train(param, dtrain, nrounds = 2, evals = evals, verbose = 0)
# continue for two more:
- bst2 <- xgb.train(param, dtrain, nrounds = 2, watchlist, verbose = 0, xgb_model = bst1)
+ bst2 <- xgb.train(param, dtrain, nrounds = 2, evals = evals, verbose = 0, xgb_model = bst1)
if (!windows_flag && !solaris_flag) {
expect_equal(xgb.save.raw(bst), xgb.save.raw(bst2))
}
@@ -315,7 +315,7 @@ test_that("training continuation works", {
expect_equal(dim(attributes(bst2)$evaluation_log), c(4, 2))
expect_equal(attributes(bst2)$evaluation_log, attributes(bst)$evaluation_log)
# test continuing from raw model data
- bst2 <- xgb.train(param, dtrain, nrounds = 2, watchlist, verbose = 0, xgb_model = xgb.save.raw(bst1))
+ bst2 <- xgb.train(param, dtrain, nrounds = 2, evals = evals, verbose = 0, xgb_model = xgb.save.raw(bst1))
if (!windows_flag && !solaris_flag) {
expect_equal(xgb.save.raw(bst), xgb.save.raw(bst2))
}
@@ -323,7 +323,7 @@ test_that("training continuation works", {
# test continuing from a model in file
fname <- file.path(tempdir(), "xgboost.json")
xgb.save(bst1, fname)
- bst2 <- xgb.train(param, dtrain, nrounds = 2, watchlist, verbose = 0, xgb_model = fname)
+ bst2 <- xgb.train(param, dtrain, nrounds = 2, evals = evals, verbose = 0, xgb_model = fname)
if (!windows_flag && !solaris_flag) {
expect_equal(xgb.save.raw(bst), xgb.save.raw(bst2))
}
@@ -348,7 +348,6 @@ test_that("xgb.cv works", {
expect_false(is.null(cv$folds) && is.list(cv$folds))
expect_length(cv$folds, 5)
expect_false(is.null(cv$params) && is.list(cv$params))
- expect_false(is.null(cv$callbacks))
expect_false(is.null(cv$call))
})
@@ -418,7 +417,7 @@ test_that("max_delta_step works", {
dtrain <- xgb.DMatrix(
agaricus.train$data, label = agaricus.train$label, nthread = n_threads
)
- watchlist <- list(train = dtrain)
+ evals <- list(train = dtrain)
param <- list(
objective = "binary:logistic", eval_metric = "logloss", max_depth = 2,
nthread = n_threads,
@@ -426,9 +425,9 @@ test_that("max_delta_step works", {
)
nrounds <- 5
# model with no restriction on max_delta_step
- bst1 <- xgb.train(param, dtrain, nrounds, watchlist, verbose = 1)
+ bst1 <- xgb.train(param, dtrain, nrounds, evals = evals, verbose = 1)
# model with restricted max_delta_step
- bst2 <- xgb.train(param, dtrain, nrounds, watchlist, verbose = 1, max_delta_step = 1)
+ bst2 <- xgb.train(param, dtrain, nrounds, evals = evals, verbose = 1, max_delta_step = 1)
# the no-restriction model is expected to have consistently lower loss during the initial iterations
expect_true(all(attributes(bst1)$evaluation_log$train_logloss < attributes(bst2)$evaluation_log$train_logloss))
expect_lt(mean(attributes(bst1)$evaluation_log$train_logloss) / mean(attributes(bst2)$evaluation_log$train_logloss), 0.8)
@@ -445,7 +444,7 @@ test_that("colsample_bytree works", {
colnames(test_x) <- paste0("Feature_", sprintf("%03d", 1:100))
dtrain <- xgb.DMatrix(train_x, label = train_y, nthread = n_threads)
dtest <- xgb.DMatrix(test_x, label = test_y, nthread = n_threads)
- watchlist <- list(train = dtrain, eval = dtest)
+ evals <- list(train = dtrain, eval = dtest)
## Use colsample_bytree = 0.01, so that roughly one out of 100 features is chosen for
## each tree
param <- list(
@@ -454,7 +453,7 @@ test_that("colsample_bytree works", {
eval_metric = "auc"
)
set.seed(2)
- bst <- xgb.train(param, dtrain, nrounds = 100, watchlist, verbose = 0)
+ bst <- xgb.train(param, dtrain, nrounds = 100, evals = evals, verbose = 0)
xgb.importance(model = bst)
# If colsample_bytree works properly, a variety of features should be used
# in the 100 trees
@@ -651,6 +650,51 @@ test_that("Can use ranking objectives with either 'qid' or 'group'", {
expect_equal(pred_qid, pred_gr)
})
+test_that("Can predict on data.frame objects", {
+ data("mtcars")
+ y <- mtcars$mpg
+ x_df <- mtcars[, -1]
+ x_mat <- as.matrix(x_df)
+ dm <- xgb.DMatrix(x_mat, label = y, nthread = n_threads)
+ model <- xgb.train(
+ params = list(
+ tree_method = "hist",
+ objective = "reg:squarederror",
+ nthread = n_threads
+ ),
+ data = dm,
+ nrounds = 5
+ )
+
+ pred_mat <- predict(model, xgb.DMatrix(x_mat), nthread = n_threads)
+ pred_df <- predict(model, x_df, nthread = n_threads)
+ expect_equal(pred_mat, pred_df)
+})
+
+test_that("'base_margin' gives the same result in DMatrix as in inplace_predict", {
+ data("mtcars")
+ y <- mtcars$mpg
+ x <- as.matrix(mtcars[, -1])
+ dm <- xgb.DMatrix(x, label = y, nthread = n_threads)
+ model <- xgb.train(
+ params = list(
+ tree_method = "hist",
+ objective = "reg:squarederror",
+ nthread = n_threads
+ ),
+ data = dm,
+ nrounds = 5
+ )
+
+ set.seed(123)
+ base_margin <- rnorm(nrow(x))
+ dm_w_base <- xgb.DMatrix(data = x, base_margin = base_margin)
+ pred_from_dm <- predict(model, dm_w_base)
+ pred_from_mat <- predict(model, x, base_margin = base_margin)
+
+ expect_equal(pred_from_dm, pred_from_mat)
+})
+
test_that("Coefficients from gblinear have the expected shape and names", {
# Single-column coefficients
data(mtcars)
@@ -778,3 +822,66 @@ test_that("DMatrix field are set to booster when training", {
expect_equal(getinfo(model_feature_types, "feature_type"), c("q", "c", "q"))
expect_equal(getinfo(model_both, "feature_type"), c("q", "c", "q"))
})
+
+test_that("Seed in params override PRNG from R", {
+ set.seed(123)
+ model1 <- xgb.train(
+ data = xgb.DMatrix(
+ agaricus.train$data,
+ label = agaricus.train$label, nthread = 1L
+ ),
+ params = list(
+ objective = "binary:logistic",
+ max_depth = 3L,
+ subsample = 0.1,
+ colsample_bytree = 0.1,
+ seed = 111L
+ ),
+ nrounds = 3L
+ )
+
+ set.seed(456)
+ model2 <- xgb.train(
+ data = xgb.DMatrix(
+ agaricus.train$data,
+ label = agaricus.train$label, nthread = 1L
+ ),
+ params = list(
+ objective = "binary:logistic",
+ max_depth = 3L,
+ subsample = 0.1,
+ colsample_bytree = 0.1,
+ seed = 111L
+ ),
+ nrounds = 3L
+ )
+
+ expect_equal(
+ xgb.save.raw(model1, raw_format = "json"),
+ xgb.save.raw(model2, raw_format = "json")
+ )
+
+ set.seed(123)
+ model3 <- xgb.train(
+ data = xgb.DMatrix(
+ agaricus.train$data,
+ label = agaricus.train$label, nthread = 1L
+ ),
+ params = list(
+ objective = "binary:logistic",
+ max_depth = 3L,
+ subsample = 0.1,
+ colsample_bytree = 0.1,
+ seed = 222L
+ ),
+ nrounds = 3L
+ )
+ expect_false(
+ isTRUE(
+ all.equal(
+ xgb.save.raw(model1, raw_format = "json"),
+ xgb.save.raw(model3, raw_format = "json")
+ )
+ )
+ )
+})
diff --git a/R-package/tests/testthat/test_callbacks.R b/R-package/tests/testthat/test_callbacks.R
index c60d0c246..913791de4 100644
--- a/R-package/tests/testthat/test_callbacks.R
+++ b/R-package/tests/testthat/test_callbacks.R
@@ -19,7 +19,7 @@ ltrain <- add.noise(train$label, 0.2)
ltest <- add.noise(test$label, 0.2)
dtrain <- xgb.DMatrix(train$data, label = ltrain, nthread = n_threads)
dtest <- xgb.DMatrix(test$data, label = ltest, nthread = n_threads)
-watchlist <- list(train = dtrain, test = dtest)
+evals <- list(train = dtrain, test = dtest)
err <- function(label, pr) sum((pr > 0.5) != label) / length(label)
@@ -28,79 +28,125 @@ param <- list(objective = "binary:logistic", eval_metric = "error",
max_depth = 2, nthread = n_threads)
-test_that("cb.print.evaluation works as expected", {
+test_that("xgb.cb.print.evaluation works as expected for xgb.train", {
+ logs1 <- capture.output({
+ model <- xgb.train(
+ data = dtrain,
+ params = list(
+ objective = "binary:logistic",
+ eval_metric = "auc",
+ max_depth = 2,
+ nthread = n_threads
+ ),
+ nrounds = 10,
+ evals = list(train = dtrain, test = dtest),
+ callbacks = list(xgb.cb.print.evaluation(period = 1))
+ )
+ })
+ expect_equal(length(logs1), 10)
+ expect_true(all(grepl("^\\[\\d{1,2}\\]\ttrain-auc:0\\.\\d+\ttest-auc:0\\.\\d+\\s*$", logs1)))
+ lapply(seq(1, 10), function(x) expect_true(grepl(paste0("^\\[", x), logs1[x])))
- bst_evaluation <- c('train-auc' = 0.9, 'test-auc' = 0.8)
- bst_evaluation_err <- NULL
- begin_iteration <- 1
- end_iteration <- 7
-
- f0 <- cb.print.evaluation(period = 0)
- f1 <- cb.print.evaluation(period = 1)
- f5 <- cb.print.evaluation(period = 5)
-
- expect_false(is.null(attr(f1, 'call')))
- expect_equal(attr(f1, 'name'), 'cb.print.evaluation')
-
- iteration <- 1
- expect_silent(f0())
- expect_output(f1(), "\\[1\\]\ttrain-auc:0.900000\ttest-auc:0.800000")
- expect_output(f5(), "\\[1\\]\ttrain-auc:0.900000\ttest-auc:0.800000")
- expect_null(f1())
-
- iteration <- 2
- expect_output(f1(), "\\[2\\]\ttrain-auc:0.900000\ttest-auc:0.800000")
- expect_silent(f5())
-
- iteration <- 7
- expect_output(f1(), "\\[7\\]\ttrain-auc:0.900000\ttest-auc:0.800000")
- expect_output(f5(), "\\[7\\]\ttrain-auc:0.900000\ttest-auc:0.800000")
-
- bst_evaluation_err <- c('train-auc' = 0.1, 'test-auc' = 0.2)
- expect_output(f1(), "\\[7\\]\ttrain-auc:0.900000±0.100000\ttest-auc:0.800000±0.200000")
+ logs2 <- capture.output({
+ model <- xgb.train(
+ data = dtrain,
+ params = list(
+ objective = "binary:logistic",
+ eval_metric = "auc",
+ max_depth = 2,
+ nthread = n_threads
+ ),
+ nrounds = 10,
+ evals = list(train = dtrain, test = dtest),
+ callbacks = list(xgb.cb.print.evaluation(period = 2))
+ )
+ })
+ expect_equal(length(logs2), 6)
+ expect_true(all(grepl("^\\[\\d{1,2}\\]\ttrain-auc:0\\.\\d+\ttest-auc:0\\.\\d+\\s*$", logs2)))
+ seq_matches <- c(seq(1, 10, 2), 10)
+ lapply(seq_along(seq_matches), function(x) expect_true(grepl(paste0("^\\[", seq_matches[x]), logs2[x])))
})
-test_that("cb.evaluation.log works as expected", {
+test_that("xgb.cb.print.evaluation works as expected for xgb.cv", {
+ logs1 <- capture.output({
+ model <- xgb.cv(
+ data = dtrain,
+ params = list(
+ objective = "binary:logistic",
+ eval_metric = "auc",
+ max_depth = 2,
+ nthread = n_threads
+ ),
+ nrounds = 10,
+ nfold = 3,
+ callbacks = list(xgb.cb.print.evaluation(period = 1, showsd = TRUE))
+ )
+ })
+ expect_equal(length(logs1), 10)
+ expect_true(all(grepl("^\\[\\d{1,2}\\]\ttrain-auc:0\\.\\d+±0\\.\\d+\ttest-auc:0\\.\\d+±0\\.\\d+\\s*$", logs1)))
+ lapply(seq(1, 10), function(x) expect_true(grepl(paste0("^\\[", x), logs1[x])))
- bst_evaluation <- c('train-auc' = 0.9, 'test-auc' = 0.8)
- bst_evaluation_err <- NULL
+ logs2 <- capture.output({
+ model <- xgb.cv(
+ data = dtrain,
+ params = list(
+ objective = "binary:logistic",
+ eval_metric = "auc",
+ max_depth = 2,
+ nthread = n_threads
+ ),
+ nrounds = 10,
+ nfold = 3,
+ callbacks = list(xgb.cb.print.evaluation(period = 2, showsd = TRUE))
+ )
+ })
+ expect_equal(length(logs2), 6)
+ expect_true(all(grepl("^\\[\\d{1,2}\\]\ttrain-auc:0\\.\\d+±0\\.\\d+\ttest-auc:0\\.\\d+±0\\.\\d+\\s*$", logs2)))
+ seq_matches <- c(seq(1, 10, 2), 10)
+ lapply(seq_along(seq_matches), function(x) expect_true(grepl(paste0("^\\[", seq_matches[x]), logs2[x])))
+})
- evaluation_log <- list()
- f <- cb.evaluation.log()
+test_that("xgb.cb.evaluation.log works as expected for xgb.train", {
+ model <- xgb.train(
+ data = dtrain,
+ params = list(
+ objective = "binary:logistic",
+ eval_metric = "auc",
+ max_depth = 2,
+ nthread = n_threads
+ ),
+ nrounds = 10,
+ verbose = FALSE,
+ evals = list(train = dtrain, test = dtest),
+ callbacks = list(xgb.cb.evaluation.log())
+ )
+ logs <- attributes(model)$evaluation_log
- expect_false(is.null(attr(f, 'call')))
- expect_equal(attr(f, 'name'), 'cb.evaluation.log')
+ expect_equal(nrow(logs), 10)
+ expect_equal(colnames(logs), c("iter", "train_auc", "test_auc"))
+})
- iteration <- 1
- expect_silent(f())
- expect_equal(evaluation_log,
- list(c(iter = 1, bst_evaluation)))
- iteration <- 2
- expect_silent(f())
- expect_equal(evaluation_log,
- list(c(iter = 1, bst_evaluation), c(iter = 2, bst_evaluation)))
- expect_silent(f(finalize = TRUE))
- expect_equal(evaluation_log,
- data.table::data.table(iter = 1:2, train_auc = c(0.9, 0.9), test_auc = c(0.8, 0.8)))
+test_that("xgb.cb.evaluation.log works as expected for xgb.cv", {
+ model <- xgb.cv(
+ data = dtrain,
+ params = list(
+ objective = "binary:logistic",
+ eval_metric = "auc",
+ max_depth = 2,
+ nthread = n_threads
+ ),
+ nrounds = 10,
+ verbose = FALSE,
+ nfold = 3,
+ callbacks = list(xgb.cb.evaluation.log())
+ )
+ logs <- model$evaluation_log
- bst_evaluation_err <- c('train-auc' = 0.1, 'test-auc' = 0.2)
- evaluation_log <- list()
- f <- cb.evaluation.log()
-
- iteration <- 1
- expect_silent(f())
- expect_equal(evaluation_log,
- list(c(iter = 1, c(bst_evaluation, bst_evaluation_err))))
- iteration <- 2
- expect_silent(f())
- expect_equal(evaluation_log,
- list(c(iter = 1, c(bst_evaluation, bst_evaluation_err)),
- c(iter = 2, c(bst_evaluation, bst_evaluation_err))))
- expect_silent(f(finalize = TRUE))
- expect_equal(evaluation_log,
- data.table::data.table(iter = 1:2,
- train_auc_mean = c(0.9, 0.9), train_auc_std = c(0.1, 0.1),
- test_auc_mean = c(0.8, 0.8), test_auc_std = c(0.2, 0.2)))
+ expect_equal(nrow(logs), 10)
+ expect_equal(
+ colnames(logs),
+ c("iter", "train_auc_mean", "train_auc_std", "test_auc_mean", "test_auc_std")
+ )
})
@@ -109,26 +155,26 @@ param <- list(objective = "binary:logistic", eval_metric = "error",
test_that("can store evaluation_log without printing", {
expect_silent(
- bst <- xgb.train(param, dtrain, nrounds = 10, watchlist, eta = 1, verbose = 0)
+ bst <- xgb.train(param, dtrain, nrounds = 10, evals = evals, eta = 1, verbose = 0)
)
expect_false(is.null(attributes(bst)$evaluation_log))
expect_false(is.null(attributes(bst)$evaluation_log$train_error))
expect_lt(attributes(bst)$evaluation_log[, min(train_error)], 0.2)
})
-test_that("cb.reset.parameters works as expected", {
+test_that("xgb.cb.reset.parameters works as expected", {
# fixed eta
set.seed(111)
- bst0 <- xgb.train(param, dtrain, nrounds = 2, watchlist, eta = 0.9, verbose = 0)
+ bst0 <- xgb.train(param, dtrain, nrounds = 2, evals = evals, eta = 0.9, verbose = 0)
expect_false(is.null(attributes(bst0)$evaluation_log))
expect_false(is.null(attributes(bst0)$evaluation_log$train_error))
# same eta but re-set as a vector parameter in the callback
set.seed(111)
my_par <- list(eta = c(0.9, 0.9))
- bst1 <- xgb.train(param, dtrain, nrounds = 2, watchlist, verbose = 0,
- callbacks = list(cb.reset.parameters(my_par)))
+ bst1 <- xgb.train(param, dtrain, nrounds = 2, evals = evals, verbose = 0,
+ callbacks = list(xgb.cb.reset.parameters(my_par)))
expect_false(is.null(attributes(bst1)$evaluation_log$train_error))
expect_equal(attributes(bst0)$evaluation_log$train_error,
attributes(bst1)$evaluation_log$train_error)
@@ -136,8 +182,8 @@ test_that("cb.reset.parameters works as expected", {
# same eta but re-set via a function in the callback
set.seed(111)
my_par <- list(eta = function(itr, itr_end) 0.9)
- bst2 <- xgb.train(param, dtrain, nrounds = 2, watchlist, verbose = 0,
- callbacks = list(cb.reset.parameters(my_par)))
+ bst2 <- xgb.train(param, dtrain, nrounds = 2, evals = evals, verbose = 0,
+ callbacks = list(xgb.cb.reset.parameters(my_par)))
expect_false(is.null(attributes(bst2)$evaluation_log$train_error))
expect_equal(attributes(bst0)$evaluation_log$train_error,
attributes(bst2)$evaluation_log$train_error)
@@ -145,39 +191,39 @@ test_that("cb.reset.parameters works as expected", {
# different eta re-set as a vector parameter in the callback
set.seed(111)
my_par <- list(eta = c(0.6, 0.5))
- bst3 <- xgb.train(param, dtrain, nrounds = 2, watchlist, verbose = 0,
- callbacks = list(cb.reset.parameters(my_par)))
+ bst3 <- xgb.train(param, dtrain, nrounds = 2, evals = evals, verbose = 0,
+ callbacks = list(xgb.cb.reset.parameters(my_par)))
expect_false(is.null(attributes(bst3)$evaluation_log$train_error))
expect_false(all(attributes(bst0)$evaluation_log$train_error == attributes(bst3)$evaluation_log$train_error))
# resetting multiple parameters at the same time runs with no error
my_par <- list(eta = c(1., 0.5), gamma = c(1, 2), max_depth = c(4, 8))
expect_error(
- bst4 <- xgb.train(param, dtrain, nrounds = 2, watchlist, verbose = 0,
- callbacks = list(cb.reset.parameters(my_par)))
+ bst4 <- xgb.train(param, dtrain, nrounds = 2, evals = evals, verbose = 0,
+ callbacks = list(xgb.cb.reset.parameters(my_par)))
, NA) # NA = no error
# CV works as well
expect_error(
bst4 <- xgb.cv(param, dtrain, nfold = 2, nrounds = 2, verbose = 0,
- callbacks = list(cb.reset.parameters(my_par)))
+ callbacks = list(xgb.cb.reset.parameters(my_par)))
, NA) # NA = no error
# expect no learning with 0 learning rate
my_par <- list(eta = c(0., 0.))
- bstX <- xgb.train(param, dtrain, nrounds = 2, watchlist, verbose = 0,
- callbacks = list(cb.reset.parameters(my_par)))
+ bstX <- xgb.train(param, dtrain, nrounds = 2, evals = evals, verbose = 0,
+ callbacks = list(xgb.cb.reset.parameters(my_par)))
expect_false(is.null(attributes(bstX)$evaluation_log$train_error))
er <- unique(attributes(bstX)$evaluation_log$train_error)
expect_length(er, 1)
expect_gt(er, 0.4)
})
-test_that("cb.save.model works as expected", {
+test_that("xgb.cb.save.model works as expected", {
files <- c('xgboost_01.json', 'xgboost_02.json', 'xgboost.json')
files <- unname(sapply(files, function(f) file.path(tempdir(), f)))
for (f in files) if (file.exists(f)) file.remove(f)
- bst <- xgb.train(param, dtrain, nrounds = 2, watchlist, eta = 1, verbose = 0,
+ bst <- xgb.train(param, dtrain, nrounds = 2, evals = evals, eta = 1, verbose = 0,
save_period = 1, save_name = file.path(tempdir(), "xgboost_%02d.json"))
expect_true(file.exists(files[1]))
expect_true(file.exists(files[2]))
@@ -193,7 +239,7 @@ test_that("cb.save.model works as expected", {
expect_equal(xgb.save.raw(bst), xgb.save.raw(b2))
# save_period = 0 saves the last iteration's model
- bst <- xgb.train(param, dtrain, nrounds = 2, watchlist, eta = 1, verbose = 0,
+ bst <- xgb.train(param, dtrain, nrounds = 2, evals = evals, eta = 1, verbose = 0,
save_period = 0, save_name = file.path(tempdir(), 'xgboost.json'))
expect_true(file.exists(files[3]))
b2 <- xgb.load(files[3])
@@ -206,7 +252,7 @@ test_that("cb.save.model works as expected", {
test_that("early stopping xgb.train works", {
set.seed(11)
expect_output(
- bst <- xgb.train(param, dtrain, nrounds = 20, watchlist, eta = 0.3,
+ bst <- xgb.train(param, dtrain, nrounds = 20, evals = evals, eta = 0.3,
early_stopping_rounds = 3, maximize = FALSE)
, "Stopping. Best iteration")
expect_false(is.null(xgb.attr(bst, "best_iteration")))
@@ -220,7 +266,7 @@ test_that("early stopping xgb.train works", {
set.seed(11)
expect_silent(
- bst0 <- xgb.train(param, dtrain, nrounds = 20, watchlist, eta = 0.3,
+ bst0 <- xgb.train(param, dtrain, nrounds = 20, evals = evals, eta = 0.3,
early_stopping_rounds = 3, maximize = FALSE, verbose = 0)
)
expect_equal(attributes(bst)$evaluation_log, attributes(bst0)$evaluation_log)
@@ -236,10 +282,10 @@ test_that("early stopping xgb.train works", {
test_that("early stopping using a specific metric works", {
set.seed(11)
expect_output(
- bst <- xgb.train(param[-2], dtrain, nrounds = 20, watchlist, eta = 0.6,
+ bst <- xgb.train(param[-2], dtrain, nrounds = 20, evals = evals, eta = 0.6,
eval_metric = "logloss", eval_metric = "auc",
- callbacks = list(cb.early.stop(stopping_rounds = 3, maximize = FALSE,
- metric_name = 'test_logloss')))
+ callbacks = list(xgb.cb.early.stop(stopping_rounds = 3, maximize = FALSE,
+ metric_name = 'test_logloss')))
, "Stopping. Best iteration")
expect_false(is.null(xgb.attr(bst, "best_iteration")))
expect_lt(xgb.attr(bst, "best_iteration"), 19)
@@ -269,7 +315,7 @@ test_that("early stopping works with titanic", {
nrounds = 100,
early_stopping_rounds = 3,
nthread = n_threads,
- watchlist = list(train = xgb.DMatrix(dtx, label = dty))
+ evals = list(train = xgb.DMatrix(dtx, label = dty))
)
expect_true(TRUE) # should not crash
@@ -281,10 +327,10 @@ test_that("early stopping xgb.cv works", {
cv <- xgb.cv(param, dtrain, nfold = 5, eta = 0.3, nrounds = 20,
early_stopping_rounds = 3, maximize = FALSE)
, "Stopping. Best iteration")
- expect_false(is.null(cv$best_iteration))
- expect_lt(cv$best_iteration, 19)
+ expect_false(is.null(cv$early_stop$best_iteration))
+ expect_lt(cv$early_stop$best_iteration, 19)
# the best error is min error:
- expect_true(cv$evaluation_log[, test_error_mean[cv$best_iteration] == min(test_error_mean)])
+ expect_true(cv$evaluation_log[, test_error_mean[cv$early_stop$best_iteration] == min(test_error_mean)])
})
test_that("prediction in xgb.cv works", {
@@ -292,19 +338,19 @@ test_that("prediction in xgb.cv works", {
nrounds <- 4
cv <- xgb.cv(param, dtrain, nfold = 5, eta = 0.5, nrounds = nrounds, prediction = TRUE, verbose = 0)
expect_false(is.null(cv$evaluation_log))
- expect_false(is.null(cv$pred))
- expect_length(cv$pred, nrow(train$data))
- err_pred <- mean(sapply(cv$folds, function(f) mean(err(ltrain[f], cv$pred[f]))))
+ expect_false(is.null(cv$cv_predict$pred))
+ expect_length(cv$cv_predict$pred, nrow(train$data))
+ err_pred <- mean(sapply(cv$folds, function(f) mean(err(ltrain[f], cv$cv_predict$pred[f]))))
err_log <- cv$evaluation_log[nrounds, test_error_mean]
expect_equal(err_pred, err_log, tolerance = 1e-6)
# save CV models
set.seed(11)
cvx <- xgb.cv(param, dtrain, nfold = 5, eta = 0.5, nrounds = nrounds, prediction = TRUE, verbose = 0,
- callbacks = list(cb.cv.predict(save_models = TRUE)))
+ callbacks = list(xgb.cb.cv.predict(save_models = TRUE)))
expect_equal(cv$evaluation_log, cvx$evaluation_log)
- expect_length(cvx$models, 5)
- expect_true(all(sapply(cvx$models, class) == 'xgb.Booster'))
+ expect_length(cvx$cv_predict$models, 5)
+ expect_true(all(sapply(cvx$cv_predict$models, class) == 'xgb.Booster'))
})
test_that("prediction in xgb.cv works for gblinear too", {
@@ -312,8 +358,8 @@ test_that("prediction in xgb.cv works for gblinear too", {
p <- list(booster = 'gblinear', objective = "reg:logistic", nthread = n_threads)
cv <- xgb.cv(p, dtrain, nfold = 5, eta = 0.5, nrounds = 2, prediction = TRUE, verbose = 0)
expect_false(is.null(cv$evaluation_log))
- expect_false(is.null(cv$pred))
- expect_length(cv$pred, nrow(train$data))
+ expect_false(is.null(cv$cv_predict$pred))
+ expect_length(cv$cv_predict$pred, nrow(train$data))
})
test_that("prediction in early-stopping xgb.cv works", {
@@ -324,14 +370,14 @@ test_that("prediction in early-stopping xgb.cv works", {
prediction = TRUE, base_score = 0.5)
, "Stopping. Best iteration")
- expect_false(is.null(cv$best_iteration))
- expect_lt(cv$best_iteration, 19)
+ expect_false(is.null(cv$early_stop$best_iteration))
+ expect_lt(cv$early_stop$best_iteration, 19)
expect_false(is.null(cv$evaluation_log))
- expect_false(is.null(cv$pred))
- expect_length(cv$pred, nrow(train$data))
+ expect_false(is.null(cv$cv_predict$pred))
+ expect_length(cv$cv_predict$pred, nrow(train$data))
- err_pred <- mean(sapply(cv$folds, function(f) mean(err(ltrain[f], cv$pred[f]))))
- err_log <- cv$evaluation_log[cv$best_iteration, test_error_mean]
+ err_pred <- mean(sapply(cv$folds, function(f) mean(err(ltrain[f], cv$cv_predict$pred[f]))))
+ err_log <- cv$evaluation_log[cv$early_stop$best_iteration, test_error_mean]
expect_equal(err_pred, err_log, tolerance = 1e-6)
err_log_last <- cv$evaluation_log[cv$niter, test_error_mean]
expect_gt(abs(err_pred - err_log_last), 1e-4)
@@ -346,9 +392,9 @@ test_that("prediction in xgb.cv for softprob works", {
subsample = 0.8, gamma = 2, verbose = 0,
prediction = TRUE, objective = "multi:softprob", num_class = 3)
, NA)
- expect_false(is.null(cv$pred))
- expect_equal(dim(cv$pred), c(nrow(iris), 3))
- expect_lt(diff(range(rowSums(cv$pred))), 1e-6)
+ expect_false(is.null(cv$cv_predict$pred))
+ expect_equal(dim(cv$cv_predict$pred), c(nrow(iris), 3))
+ expect_lt(diff(range(rowSums(cv$cv_predict$pred))), 1e-6)
})
test_that("prediction in xgb.cv works for multi-quantile", {
@@ -368,7 +414,7 @@ test_that("prediction in xgb.cv works for multi-quantile", {
prediction = TRUE,
verbose = 0
)
- expect_equal(dim(cv$pred), c(nrow(x), 5))
+ expect_equal(dim(cv$cv_predict$pred), c(nrow(x), 5))
})
test_that("prediction in xgb.cv works for multi-output", {
@@ -389,5 +435,46 @@ test_that("prediction in xgb.cv works for multi-output", {
prediction = TRUE,
verbose = 0
)
- expect_equal(dim(cv$pred), c(nrow(x), 2))
+ expect_equal(dim(cv$cv_predict$pred), c(nrow(x), 2))
+})
+
+test_that("prediction in xgb.cv works for multi-quantile", {
+ data(mtcars)
+ y <- mtcars$mpg
+ x <- as.matrix(mtcars[, -1])
+ dm <- xgb.DMatrix(x, label = y, nthread = 1)
+ cv <- xgb.cv(
+ data = dm,
+ params = list(
+ objective = "reg:quantileerror",
+ quantile_alpha = c(0.1, 0.2, 0.5, 0.8, 0.9),
+ nthread = 1
+ ),
+ nrounds = 5,
+ nfold = 3,
+ prediction = TRUE,
+ verbose = 0
+ )
+ expect_equal(dim(cv$cv_predict$pred), c(nrow(x), 5))
+})
+
+test_that("prediction in xgb.cv works for multi-output", {
+ data(mtcars)
+ y <- mtcars$mpg
+ x <- as.matrix(mtcars[, -1])
+ dm <- xgb.DMatrix(x, label = cbind(y, -y), nthread = 1)
+ cv <- xgb.cv(
+ data = dm,
+ params = list(
+ tree_method = "hist",
+ multi_strategy = "multi_output_tree",
+ objective = "reg:squarederror",
+ nthread = n_threads
+ ),
+ nrounds = 5,
+ nfold = 3,
+ prediction = TRUE,
+ verbose = 0
+ )
+ expect_equal(dim(cv$cv_predict$pred), c(nrow(x), 2))
})
diff --git a/R-package/tests/testthat/test_custom_objective.R b/R-package/tests/testthat/test_custom_objective.R
index c65031246..d3050b152 100644
--- a/R-package/tests/testthat/test_custom_objective.R
+++ b/R-package/tests/testthat/test_custom_objective.R
@@ -12,7 +12,7 @@ dtrain <- xgb.DMatrix(
dtest <- xgb.DMatrix(
agaricus.test$data, label = agaricus.test$label, nthread = n_threads
)
-watchlist <- list(eval = dtest, train = dtrain)
+evals <- list(eval = dtest, train = dtrain)
logregobj <- function(preds, dtrain) {
labels <- getinfo(dtrain, "label")
@@ -33,7 +33,7 @@ param <- list(max_depth = 2, eta = 1, nthread = n_threads,
num_round <- 2
test_that("custom objective works", {
- bst <- xgb.train(param, dtrain, num_round, watchlist)
+ bst <- xgb.train(param, dtrain, num_round, evals)
expect_equal(class(bst), "xgb.Booster")
expect_false(is.null(attributes(bst)$evaluation_log))
expect_false(is.null(attributes(bst)$evaluation_log$eval_error))
@@ -48,7 +48,7 @@ test_that("custom objective in CV works", {
})
test_that("custom objective with early stop works", {
- bst <- xgb.train(param, dtrain, 10, watchlist)
+ bst <- xgb.train(param, dtrain, 10, evals)
expect_equal(class(bst), "xgb.Booster")
train_log <- attributes(bst)$evaluation_log$train_error
expect_true(all(diff(train_log) <= 0))
@@ -66,7 +66,7 @@ test_that("custom objective using DMatrix attr works", {
return(list(grad = grad, hess = hess))
}
param$objective <- logregobjattr
- bst <- xgb.train(param, dtrain, num_round, watchlist)
+ bst <- xgb.train(param, dtrain, num_round, evals)
expect_equal(class(bst), "xgb.Booster")
})
diff --git a/R-package/tests/testthat/test_dmatrix.R b/R-package/tests/testthat/test_dmatrix.R
index 50621f241..44d1566c6 100644
--- a/R-package/tests/testthat/test_dmatrix.R
+++ b/R-package/tests/testthat/test_dmatrix.R
@@ -41,13 +41,13 @@ test_that("xgb.DMatrix: basic construction", {
params <- list(tree_method = "hist", nthread = n_threads)
bst_fd <- xgb.train(
- params, nrounds = 8, fd, watchlist = list(train = fd)
+ params, nrounds = 8, fd, evals = list(train = fd)
)
bst_dgr <- xgb.train(
- params, nrounds = 8, fdgr, watchlist = list(train = fdgr)
+ params, nrounds = 8, fdgr, evals = list(train = fdgr)
)
bst_dgc <- xgb.train(
- params, nrounds = 8, fdgc, watchlist = list(train = fdgc)
+ params, nrounds = 8, fdgc, evals = list(train = fdgc)
)
raw_fd <- xgb.save.raw(bst_fd, raw_format = "ubj")
@@ -302,6 +302,37 @@ test_that("xgb.DMatrix: Inf as missing", {
file.remove(fname_nan)
})
+test_that("xgb.DMatrix: missing in CSR", {
+ x_dense <- matrix(as.numeric(1:10), nrow = 5)
+ x_dense[2, 1] <- NA_real_
+
+ x_csr <- as(x_dense, "RsparseMatrix")
+
+ m_dense <- xgb.DMatrix(x_dense, nthread = n_threads, missing = NA_real_)
+ xgb.DMatrix.save(m_dense, "dense.dmatrix")
+
+ m_csr <- xgb.DMatrix(x_csr, nthread = n_threads, missing = NA)
+ xgb.DMatrix.save(m_csr, "csr.dmatrix")
+
+ denseconn <- file("dense.dmatrix", "rb")
+ csrconn <- file("csr.dmatrix", "rb")
+
+ expect_equal(file.size("dense.dmatrix"), file.size("csr.dmatrix"))
+
+ bytes <- file.size("dense.dmatrix")
+ densedmatrix <- readBin(denseconn, "raw", n = bytes)
+ csrmatrix <- readBin(csrconn, "raw", n = bytes)
+
+ expect_equal(length(densedmatrix), length(csrmatrix))
+ expect_equal(densedmatrix, csrmatrix)
+
+ close(denseconn)
+ close(csrconn)
+
+ file.remove("dense.dmatrix")
+ file.remove("csr.dmatrix")
+})
+
test_that("xgb.DMatrix: error on three-dimensional array", {
set.seed(123)
x <- matrix(rnorm(500), nrow = 50)
@@ -692,3 +723,20 @@ test_that("xgb.DMatrix: quantile cuts look correct", {
}
)
})
+
+test_that("xgb.DMatrix: can read CSV", {
+ txt <- paste(
+ "1,2,3",
+ "-1,3,2",
+ sep = "\n"
+ )
+ fname <- file.path(tempdir(), "data.csv")
+ writeChar(txt, fname)
+ uri <- paste0(fname, "?format=csv&label_column=0")
+ dm <- xgb.DMatrix(uri, silent = TRUE)
+ expect_equal(getinfo(dm, "label"), c(1, -1))
+ expect_equal(
+ as.matrix(xgb.get.DMatrix.data(dm)),
+ matrix(c(2, 3, 3, 2), nrow = 2, byrow = TRUE)
+ )
+})
diff --git a/R-package/tests/testthat/test_feature_weights.R b/R-package/tests/testthat/test_feature_weights.R
index 4ed78c9b6..54fec67cf 100644
--- a/R-package/tests/testthat/test_feature_weights.R
+++ b/R-package/tests/testthat/test_feature_weights.R
@@ -25,7 +25,7 @@ test_that("training with feature weights works", {
expect_lt(importance[1, Frequency], importance[9, Frequency])
}
- for (tm in c("hist", "approx", "exact")) {
+ for (tm in c("hist", "approx")) {
test(tm)
}
})
diff --git a/R-package/tests/testthat/test_glm.R b/R-package/tests/testthat/test_glm.R
index 349bcce8d..b59de8b62 100644
--- a/R-package/tests/testthat/test_glm.R
+++ b/R-package/tests/testthat/test_glm.R
@@ -14,37 +14,37 @@ test_that("gblinear works", {
param <- list(objective = "binary:logistic", eval_metric = "error", booster = "gblinear",
nthread = n_threads, eta = 0.8, alpha = 0.0001, lambda = 0.0001)
- watchlist <- list(eval = dtest, train = dtrain)
+ evals <- list(eval = dtest, train = dtrain)
n <- 5 # iterations
ERR_UL <- 0.005 # upper limit for the test set error
VERB <- 0 # chatterbox switch
param$updater <- 'shotgun'
- bst <- xgb.train(param, dtrain, n, watchlist, verbose = VERB, feature_selector = 'shuffle')
+ bst <- xgb.train(param, dtrain, n, evals, verbose = VERB, feature_selector = 'shuffle')
ypred <- predict(bst, dtest)
expect_equal(length(getinfo(dtest, 'label')), 1611)
expect_lt(attributes(bst)$evaluation_log$eval_error[n], ERR_UL)
- bst <- xgb.train(param, dtrain, n, watchlist, verbose = VERB, feature_selector = 'cyclic',
- callbacks = list(cb.gblinear.history()))
+ bst <- xgb.train(param, dtrain, n, evals, verbose = VERB, feature_selector = 'cyclic',
+ callbacks = list(xgb.cb.gblinear.history()))
expect_lt(attributes(bst)$evaluation_log$eval_error[n], ERR_UL)
h <- xgb.gblinear.history(bst)
expect_equal(dim(h), c(n, ncol(dtrain) + 1))
expect_is(h, "matrix")
param$updater <- 'coord_descent'
- bst <- xgb.train(param, dtrain, n, watchlist, verbose = VERB, feature_selector = 'cyclic')
+ bst <- xgb.train(param, dtrain, n, evals, verbose = VERB, feature_selector = 'cyclic')
expect_lt(attributes(bst)$evaluation_log$eval_error[n], ERR_UL)
- bst <- xgb.train(param, dtrain, n, watchlist, verbose = VERB, feature_selector = 'shuffle')
+ bst <- xgb.train(param, dtrain, n, evals, verbose = VERB, feature_selector = 'shuffle')
expect_lt(attributes(bst)$evaluation_log$eval_error[n], ERR_UL)
- bst <- xgb.train(param, dtrain, 2, watchlist, verbose = VERB, feature_selector = 'greedy')
+ bst <- xgb.train(param, dtrain, 2, evals, verbose = VERB, feature_selector = 'greedy')
expect_lt(attributes(bst)$evaluation_log$eval_error[2], ERR_UL)
- bst <- xgb.train(param, dtrain, n, watchlist, verbose = VERB, feature_selector = 'thrifty',
- top_k = 50, callbacks = list(cb.gblinear.history(sparse = TRUE)))
+ bst <- xgb.train(param, dtrain, n, evals, verbose = VERB, feature_selector = 'thrifty',
+ top_k = 50, callbacks = list(xgb.cb.gblinear.history(sparse = TRUE)))
expect_lt(attributes(bst)$evaluation_log$eval_error[n], ERR_UL)
h <- xgb.gblinear.history(bst)
expect_equal(dim(h), c(n, ncol(dtrain) + 1))
diff --git a/R-package/tests/testthat/test_ranking.R b/R-package/tests/testthat/test_ranking.R
index e49a32025..0e7db42da 100644
--- a/R-package/tests/testthat/test_ranking.R
+++ b/R-package/tests/testthat/test_ranking.R
@@ -15,7 +15,7 @@ test_that('Test ranking with unweighted data', {
params <- list(eta = 1, tree_method = 'exact', objective = 'rank:pairwise', max_depth = 1,
eval_metric = 'auc', eval_metric = 'aucpr', nthread = n_threads)
- bst <- xgb.train(params, dtrain, nrounds = 10, watchlist = list(train = dtrain))
+ bst <- xgb.train(params, dtrain, nrounds = 10, evals = list(train = dtrain))
# Check if the metric is monotone increasing
expect_true(all(diff(attributes(bst)$evaluation_log$train_auc) >= 0))
expect_true(all(diff(attributes(bst)$evaluation_log$train_aucpr) >= 0))
@@ -39,7 +39,7 @@ test_that('Test ranking with weighted data', {
eta = 1, tree_method = "exact", objective = "rank:pairwise", max_depth = 1,
eval_metric = "auc", eval_metric = "aucpr", nthread = n_threads
)
- bst <- xgb.train(params, dtrain, nrounds = 10, watchlist = list(train = dtrain))
+ bst <- xgb.train(params, dtrain, nrounds = 10, evals = list(train = dtrain))
# Check if the metric is monotone increasing
expect_true(all(diff(attributes(bst)$evaluation_log$train_auc) >= 0))
expect_true(all(diff(attributes(bst)$evaluation_log$train_aucpr) >= 0))
diff --git a/R-package/tests/testthat/test_update.R b/R-package/tests/testthat/test_update.R
index 3c88178e0..7fdc6eb84 100644
--- a/R-package/tests/testthat/test_update.R
+++ b/R-package/tests/testthat/test_update.R
@@ -17,7 +17,7 @@ dtest <- xgb.DMatrix(
win32_flag <- .Platform$OS.type == "windows" && .Machine$sizeof.pointer != 8
test_that("updating the model works", {
- watchlist <- list(train = dtrain, test = dtest)
+ evals <- list(train = dtrain, test = dtest)
# no-subsampling
p1 <- list(
@@ -25,19 +25,19 @@ test_that("updating the model works", {
updater = "grow_colmaker,prune"
)
set.seed(11)
- bst1 <- xgb.train(p1, dtrain, nrounds = 10, watchlist, verbose = 0)
+ bst1 <- xgb.train(p1, dtrain, nrounds = 10, evals = evals, verbose = 0)
tr1 <- xgb.model.dt.tree(model = bst1)
# with subsampling
p2 <- modifyList(p1, list(subsample = 0.1))
set.seed(11)
- bst2 <- xgb.train(p2, dtrain, nrounds = 10, watchlist, verbose = 0)
+ bst2 <- xgb.train(p2, dtrain, nrounds = 10, evals = evals, verbose = 0)
tr2 <- xgb.model.dt.tree(model = bst2)
# the same no-subsampling boosting with an extra 'refresh' updater:
p1r <- modifyList(p1, list(updater = 'grow_colmaker,prune,refresh', refresh_leaf = FALSE))
set.seed(11)
- bst1r <- xgb.train(p1r, dtrain, nrounds = 10, watchlist, verbose = 0)
+ bst1r <- xgb.train(p1r, dtrain, nrounds = 10, evals = evals, verbose = 0)
tr1r <- xgb.model.dt.tree(model = bst1r)
# all should be the same when no subsampling
expect_equal(attributes(bst1)$evaluation_log, attributes(bst1r)$evaluation_log)
@@ -53,7 +53,7 @@ test_that("updating the model works", {
# the same boosting with subsampling with an extra 'refresh' updater:
p2r <- modifyList(p2, list(updater = 'grow_colmaker,prune,refresh', refresh_leaf = FALSE))
set.seed(11)
- bst2r <- xgb.train(p2r, dtrain, nrounds = 10, watchlist, verbose = 0)
+ bst2r <- xgb.train(p2r, dtrain, nrounds = 10, evals = evals, verbose = 0)
tr2r <- xgb.model.dt.tree(model = bst2r)
# should be the same evaluation but different gains and larger cover
expect_equal(attributes(bst2)$evaluation_log, attributes(bst2r)$evaluation_log)
@@ -66,7 +66,7 @@ test_that("updating the model works", {
# process type 'update' for no-subsampling model, refreshing the tree stats AND leaves from training data:
set.seed(123)
p1u <- modifyList(p1, list(process_type = 'update', updater = 'refresh', refresh_leaf = TRUE))
- bst1u <- xgb.train(p1u, dtrain, nrounds = 10, watchlist, verbose = 0, xgb_model = bst1)
+ bst1u <- xgb.train(p1u, dtrain, nrounds = 10, evals = evals, verbose = 0, xgb_model = bst1)
tr1u <- xgb.model.dt.tree(model = bst1u)
# all should be the same when no subsampling
expect_equal(attributes(bst1)$evaluation_log, attributes(bst1u)$evaluation_log)
@@ -79,7 +79,7 @@ test_that("updating the model works", {
# same thing but with a serialized model
set.seed(123)
- bst1u <- xgb.train(p1u, dtrain, nrounds = 10, watchlist, verbose = 0, xgb_model = xgb.save.raw(bst1))
+ bst1u <- xgb.train(p1u, dtrain, nrounds = 10, evals = evals, verbose = 0, xgb_model = xgb.save.raw(bst1))
tr1u <- xgb.model.dt.tree(model = bst1u)
# all should be the same when no subsampling
expect_equal(attributes(bst1)$evaluation_log, attributes(bst1u)$evaluation_log)
@@ -87,7 +87,7 @@ test_that("updating the model works", {
# process type 'update' for model with subsampling, refreshing only the tree stats from training data:
p2u <- modifyList(p2, list(process_type = 'update', updater = 'refresh', refresh_leaf = FALSE))
- bst2u <- xgb.train(p2u, dtrain, nrounds = 10, watchlist, verbose = 0, xgb_model = bst2)
+ bst2u <- xgb.train(p2u, dtrain, nrounds = 10, evals = evals, verbose = 0, xgb_model = bst2)
tr2u <- xgb.model.dt.tree(model = bst2u)
# should be the same evaluation but different gains and larger cover
expect_equal(attributes(bst2)$evaluation_log, attributes(bst2u)$evaluation_log)
@@ -102,7 +102,7 @@ test_that("updating the model works", {
# process type 'update' for no-subsampling model, refreshing only the tree stats from TEST data:
p1ut <- modifyList(p1, list(process_type = 'update', updater = 'refresh', refresh_leaf = FALSE))
- bst1ut <- xgb.train(p1ut, dtest, nrounds = 10, watchlist, verbose = 0, xgb_model = bst1)
+ bst1ut <- xgb.train(p1ut, dtest, nrounds = 10, evals = evals, verbose = 0, xgb_model = bst1)
tr1ut <- xgb.model.dt.tree(model = bst1ut)
# should be the same evaluations but different gains and smaller cover (test data is smaller)
expect_equal(attributes(bst1)$evaluation_log, attributes(bst1ut)$evaluation_log)
@@ -115,18 +115,18 @@ test_that("updating works for multiclass & multitree", {
dtr <- xgb.DMatrix(
as.matrix(iris[, -5]), label = as.numeric(iris$Species) - 1, nthread = n_threads
)
- watchlist <- list(train = dtr)
+ evals <- list(train = dtr)
p0 <- list(max_depth = 2, eta = 0.5, nthread = n_threads, subsample = 0.6,
objective = "multi:softprob", num_class = 3, num_parallel_tree = 2,
base_score = 0)
set.seed(121)
- bst0 <- xgb.train(p0, dtr, 5, watchlist, verbose = 0)
+ bst0 <- xgb.train(p0, dtr, 5, evals = evals, verbose = 0)
tr0 <- xgb.model.dt.tree(model = bst0)
# run update process for an original model with subsampling
p0u <- modifyList(p0, list(process_type = 'update', updater = 'refresh', refresh_leaf = FALSE))
bst0u <- xgb.train(p0u, dtr, nrounds = xgb.get.num.boosted.rounds(bst0),
- watchlist, xgb_model = bst0, verbose = 0)
+ evals = evals, xgb_model = bst0, verbose = 0)
tr0u <- xgb.model.dt.tree(model = bst0u)
# should be the same evaluation but different gains and larger cover
diff --git a/R-package/vignettes/xgboostPresentation.Rmd b/R-package/vignettes/xgboostPresentation.Rmd
index efafc624d..fc49adc0f 100644
--- a/R-package/vignettes/xgboostPresentation.Rmd
+++ b/R-package/vignettes/xgboostPresentation.Rmd
@@ -341,10 +341,10 @@ One way to measure progress in learning of a model is to provide to **XGBoost**
> in some way it is similar to what we have done above with the average error. The main difference is that below it was after building the model, and now it is during the construction that we measure errors.
-For the purpose of this example, we use `watchlist` parameter. It is a list of `xgb.DMatrix`, each of them tagged with a name.
+For the purpose of this example, we use the `evals` parameter. It is a list of `xgb.DMatrix` objects, each of them tagged with a name.
-```{r watchlist, message=F, warning=F}
-watchlist <- list(train = dtrain, test = dtest)
+```{r evals, message=F, warning=F}
+evals <- list(train = dtrain, test = dtest)
bst <- xgb.train(
data = dtrain
@@ -355,7 +355,7 @@ bst <- xgb.train(
, objective = "binary:logistic"
)
, nrounds = 2
- , watchlist = watchlist
+ , evals = evals
)
```
@@ -367,7 +367,7 @@ If with your own dataset you have not such results, you should think about how y
For a better understanding of the learning progression, you may want to have some specific metric or even use multiple evaluation metrics.
-```{r watchlist2, message=F, warning=F}
+```{r evals2, message=F, warning=F}
bst <- xgb.train(
data = dtrain
, max_depth = 2
@@ -379,7 +379,7 @@ bst <- xgb.train(
, eval_metric = "logloss"
)
, nrounds = 2
- , watchlist = watchlist
+ , evals = evals
)
```
@@ -401,7 +401,7 @@ bst <- xgb.train(
, eval_metric = "logloss"
)
, nrounds = 2
- , watchlist = watchlist
+ , evals = evals
)
```
@@ -430,7 +430,7 @@ bst <- xgb.train(
, objective = "binary:logistic"
)
, nrounds = 2
- , watchlist = watchlist
+ , evals = evals
)
```
@@ -496,6 +496,9 @@ An interesting test to see how identical our saved model is to the original one
```{r loadModel, message=F, warning=F}
# load binary model to R
+# Note that the number of threads for 'xgb.load' is taken from global config,
+# can be modified like this:
+RhpcBLASctl::omp_set_num_threads(1)
bst2 <- xgb.load(fname)
xgb.parameters(bst2) <- list(nthread = 2)
pred2 <- predict(bst2, test$data)
diff --git a/doc/R-package/index.rst b/doc/R-package/index.rst
index 8a27d0174..bf9c1f8d9 100644
--- a/doc/R-package/index.rst
+++ b/doc/R-package/index.rst
@@ -34,4 +34,5 @@ Other topics
.. toctree::
:maxdepth: 2
:titlesonly:
+
Handling of indexable elements
diff --git a/doc/parameter.rst b/doc/parameter.rst
index a7d8203b0..00f0eaea6 100644
--- a/doc/parameter.rst
+++ b/doc/parameter.rst
@@ -118,7 +118,7 @@ Parameters for Tree Booster
- All ``colsample_by*`` parameters have a range of (0, 1], the default value of 1, and specify the fraction of columns to be subsampled.
- ``colsample_bytree`` is the subsample ratio of columns when constructing each tree. Subsampling occurs once for every tree constructed.
- ``colsample_bylevel`` is the subsample ratio of columns for each level. Subsampling occurs once for every new depth level reached in a tree. Columns are subsampled from the set of columns chosen for the current tree.
- - ``colsample_bynode`` is the subsample ratio of columns for each node (split). Subsampling occurs once every time a new split is evaluated. Columns are subsampled from the set of columns chosen for the current level.
+ - ``colsample_bynode`` is the subsample ratio of columns for each node (split). Subsampling occurs once every time a new split is evaluated. Columns are subsampled from the set of columns chosen for the current level. This is not supported by the exact tree method.
- ``colsample_by*`` parameters work cumulatively. For instance,
the combination ``{'colsample_bytree':0.5, 'colsample_bylevel':0.5,
'colsample_bynode':0.5}`` with 64 features will leave 8 features to choose from at
@@ -450,7 +450,7 @@ Specify the learning task and the corresponding learning objective. The objectiv
* ``seed`` [default=0]
- - Random number seed. This parameter is ignored in R package, use `set.seed()` instead.
+ - Random number seed. In the R package, if not specified, instead of defaulting to seed 'zero', will take a random seed through R's own RNG engine.
* ``seed_per_iteration`` [default= ``false``]
@@ -489,7 +489,7 @@ Parameters for learning to rank (``rank:ndcg``, ``rank:map``, ``rank:pairwise``)
These are parameters specific to learning to rank task. See :doc:`Learning to Rank ` for an in-depth explanation.
-* ``lambdarank_pair_method`` [default = ``mean``]
+* ``lambdarank_pair_method`` [default = ``topk``]
How to construct pairs for pair-wise learning.
@@ -500,7 +500,13 @@ These are parameters specific to learning to rank task. See :doc:`Learning to Ra
It specifies the number of pairs sampled for each document when pair method is ``mean``, or the truncation level for queries when the pair method is ``topk``. For example, to train with ``ndcg@6``, set ``lambdarank_num_pair_per_sample`` to :math:`6` and ``lambdarank_pair_method`` to ``topk``.
-* ``lambdarank_unbiased`` [default = ``false``]
+* ``lambdarank_normalization`` [default = ``true``]
+
+ .. versionadded:: 2.1.0
+
+ Whether to normalize the leaf value by lambda gradient. This can sometimes stagnate the training progress.
+
+* ``lambdarank_unbiased`` [default = ``false``]
Specify whether do we need to debias input click data.
diff --git a/doc/python/callbacks.rst b/doc/python/callbacks.rst
index 7cb257a81..6d8b43a11 100644
--- a/doc/python/callbacks.rst
+++ b/doc/python/callbacks.rst
@@ -36,7 +36,7 @@ inside iteration loop. You can also pass this callback function directly into X
# Specify which dataset and which metric should be used for early stopping.
early_stop = xgb.callback.EarlyStopping(rounds=early_stopping_rounds,
metric_name='CustomErr',
- data_name='Train')
+ data_name='Valid')
booster = xgb.train(
{'objective': 'binary:logistic',
diff --git a/doc/python/python_intro.rst b/doc/python/python_intro.rst
index 0d26a5253..cfdd20da0 100644
--- a/doc/python/python_intro.rst
+++ b/doc/python/python_intro.rst
@@ -63,7 +63,7 @@ The input data is stored in a :py:class:`DMatrix ` object. For
.. code-block:: python
- dtrain = xgb.DMatrix('train.svm.txt')
+ dtrain = xgb.DMatrix('train.svm.txt?format=libsvm')
dtrain.save_binary('train.buffer')
* Missing values can be replaced by a default value in the :py:class:`DMatrix ` constructor:
@@ -86,7 +86,7 @@ to number of groups.
.. code-block:: python
- dtrain = xgb.DMatrix('train.svm.txt')
+ dtrain = xgb.DMatrix('train.svm.txt?format=libsvm')
dtest = xgb.DMatrix('test.svm.buffer')
The parser in XGBoost has limited functionality. When using Python interface, it's
@@ -176,7 +176,6 @@ Support Matrix
+-------------------------+-----------+-------------------+-----------+-----------+--------------------+-------------+
| pyarrow.Table | NPA | NPA | NPA | NPA | NPA | NPA |
+-------------------------+-----------+-------------------+-----------+-----------+--------------------+-------------+
-+-------------------------+-----------+-------------------+-----------+-----------+--------------------+-------------+
| _\_array\_\_ | NPA | F | NPA | NPA | H | |
+-------------------------+-----------+-------------------+-----------+-----------+--------------------+-------------+
| Others | SciCSR | F | | F | F | |
@@ -240,7 +239,7 @@ A saved model can be loaded as follows:
.. code-block:: python
bst = xgb.Booster({'nthread': 4}) # init model
- bst.load_model('model.bin') # load data
+ bst.load_model('model.bin') # load model data
Methods including `update` and `boost` from `xgboost.Booster` are designed for
internal usage only. The wrapper function `xgboost.train` does some
diff --git a/doc/python/sklearn_estimator.rst b/doc/python/sklearn_estimator.rst
index 207b9fa30..1aaa340b1 100644
--- a/doc/python/sklearn_estimator.rst
+++ b/doc/python/sklearn_estimator.rst
@@ -62,7 +62,7 @@ stack of trees:
.. code-block:: python
early_stop = xgb.callback.EarlyStopping(
- rounds=2, metric_name='logloss', data_name='Validation_0', save_best=True
+ rounds=2, metric_name='logloss', data_name='validation_0', save_best=True
)
clf = xgb.XGBClassifier(tree_method="hist", callbacks=[early_stop])
clf.fit(X_train, y_train, eval_set=[(X_test, y_test)])
diff --git a/doc/requirements.txt b/doc/requirements.txt
index 667ef268f..ddff9be92 100644
--- a/doc/requirements.txt
+++ b/doc/requirements.txt
@@ -7,7 +7,9 @@ sh
matplotlib
graphviz
numpy
+scipy
myst-parser
+ray[train]
xgboost_ray
sphinx-gallery
pyspark
diff --git a/doc/tutorials/learning_to_rank.rst b/doc/tutorials/learning_to_rank.rst
index 015f736e0..bfc727ed7 100644
--- a/doc/tutorials/learning_to_rank.rst
+++ b/doc/tutorials/learning_to_rank.rst
@@ -48,7 +48,7 @@ Notice that the samples are sorted based on their query index in a non-decreasin
import xgboost as xgb
# Make a synthetic ranking dataset for demonstration
- seed = 1994
+ seed = 1994
X, y = make_classification(random_state=seed)
rng = np.random.default_rng(seed)
n_query_groups = 3
@@ -146,7 +146,8 @@ The consideration of effective pairs also applies to the choice of pair method (
When using the mean strategy for generating pairs, where the target metric (like ``NDCG``) is computed over the whole query list, users can specify how many pairs should be generated per each document, by setting the ``lambdarank_num_pair_per_sample``. XGBoost will randomly sample ``lambdarank_num_pair_per_sample`` pairs for each element in the query group (:math:`|pairs| = |query| \times num\_pairsample`). Often, setting it to 1 can produce reasonable results. In cases where performance is inadequate due to insufficient number of effective pairs being generated, set ``lambdarank_num_pair_per_sample`` to a higher value. As more document pairs are generated, more effective pairs will be generated as well.
-On the other hand, if you are prioritizing the top :math:`k` documents, the ``lambdarank_num_pair_per_sample`` should be set slightly higher than :math:`k` (with a few more documents) to obtain a good training result.
+On the other hand, if you are prioritizing the top :math:`k` documents, the ``lambdarank_num_pair_per_sample`` should be set slightly higher than :math:`k` (with a few more documents) to obtain a good training result. Lastly, XGBoost employs additional regularization for learning to rank objectives, which can be disabled by setting the ``lambdarank_normalization`` to ``False``.
+
**Summary** If you have large amount of training data:
diff --git a/doc/tutorials/spark_estimator.rst b/doc/tutorials/spark_estimator.rst
index 8bd1dcd97..4e608440a 100644
--- a/doc/tutorials/spark_estimator.rst
+++ b/doc/tutorials/spark_estimator.rst
@@ -28,7 +28,7 @@ We can create a ``SparkXGBRegressor`` estimator like:
.. code-block:: python
from xgboost.spark import SparkXGBRegressor
- spark_reg_estimator = SparkXGBRegressor(
+ xgb_regressor = SparkXGBRegressor(
features_col="features",
label_col="label",
num_workers=2,
@@ -61,7 +61,7 @@ type or spark array type.
.. code-block:: python
- transformed_test_spark_dataframe = xgb_regressor.predict(test_spark_dataframe)
+ transformed_test_spark_dataframe = xgb_regressor_model.transform(test_spark_dataframe)
The above snippet code returns a ``transformed_test_spark_dataframe`` that contains the input
diff --git a/doc/xgboost_doc.yml b/doc/xgboost_doc.yml
index 90b877e73..177e8758f 100644
--- a/doc/xgboost_doc.yml
+++ b/doc/xgboost_doc.yml
@@ -1,15 +1,23 @@
name: xgboost_docs
dependencies:
- - python
+ - python=3.10
- pip
- pygraphviz
- sphinx
+ - sphinx-gallery
- recommonmark
- mock
- sh
- matplotlib
+ - numpy
+ - scipy
+ - scikit-learn
+ - myst-parser
+ - pyspark
- pip:
- breathe
- sphinx_rtd_theme
- pydot-ng
- graphviz
+ - ray[train]
+ - xgboost_ray
diff --git a/include/xgboost/base.h b/include/xgboost/base.h
index 1c4b6568e..4009df59f 100644
--- a/include/xgboost/base.h
+++ b/include/xgboost/base.h
@@ -37,7 +37,7 @@
* \brief Whether to customize global PRNG.
*/
#ifndef XGBOOST_CUSTOMIZE_GLOBAL_PRNG
-#define XGBOOST_CUSTOMIZE_GLOBAL_PRNG XGBOOST_STRICT_R_MODE
+#define XGBOOST_CUSTOMIZE_GLOBAL_PRNG 0
#endif // XGBOOST_CUSTOMIZE_GLOBAL_PRNG
/*!
diff --git a/include/xgboost/collective/result.h b/include/xgboost/collective/result.h
index 507171dd4..919d3a902 100644
--- a/include/xgboost/collective/result.h
+++ b/include/xgboost/collective/result.h
@@ -1,8 +1,10 @@
/**
- * Copyright 2023, XGBoost Contributors
+ * Copyright 2023-2024, XGBoost Contributors
*/
#pragma once
+#include
+
#include // for unique_ptr
#include // for stringstream
#include // for stack
@@ -160,10 +162,16 @@ struct Result {
// We don't have monad, a simple helper would do.
template
-Result operator<<(Result&& r, Fn&& fn) {
+[[nodiscard]] Result operator<<(Result&& r, Fn&& fn) {
if (!r.OK()) {
return std::forward(r);
}
return fn();
}
+
+inline void SafeColl(Result const& rc) {
+ if (!rc.OK()) {
+ LOG(FATAL) << rc.Report();
+ }
+}
} // namespace xgboost::collective
diff --git a/include/xgboost/json.h b/include/xgboost/json.h
index a5872ec3a..77ca6a510 100644
--- a/include/xgboost/json.h
+++ b/include/xgboost/json.h
@@ -1,5 +1,5 @@
/**
- * Copyright 2019-2023 by XGBoost Contributors
+ * Copyright 2019-2024, XGBoost Contributors
*/
#ifndef XGBOOST_JSON_H_
#define XGBOOST_JSON_H_
@@ -42,7 +42,8 @@ class Value {
kBoolean,
kNull,
// typed array for ubjson
- kNumberArray,
+ kF32Array,
+ kF64Array,
kU8Array,
kI32Array,
kI64Array
@@ -173,7 +174,11 @@ class JsonTypedArray : public Value {
/**
* @brief Typed UBJSON array for 32-bit floating point.
*/
-using F32Array = JsonTypedArray;
+using F32Array = JsonTypedArray;
+/**
+ * @brief Typed UBJSON array for 64-bit floating point.
+ */
+using F64Array = JsonTypedArray;
/**
* @brief Typed UBJSON array for uint8_t.
*/
@@ -457,9 +462,9 @@ class Json {
Json& operator[](int ind) const { return (*ptr_)[ind]; }
/*! \brief Return the reference to stored Json value. */
- Value const& GetValue() const & { return *ptr_; }
- Value const& GetValue() && { return *ptr_; }
- Value& GetValue() & { return *ptr_; }
+ [[nodiscard]] Value const& GetValue() const& { return *ptr_; }
+ Value const& GetValue() && { return *ptr_; }
+ Value& GetValue() & { return *ptr_; }
bool operator==(Json const& rhs) const {
return *ptr_ == *(rhs.ptr_);
@@ -472,7 +477,7 @@ class Json {
return os;
}
- IntrusivePtr const& Ptr() const { return ptr_; }
+ [[nodiscard]] IntrusivePtr const& Ptr() const { return ptr_; }
private:
IntrusivePtr ptr_{new JsonNull};
diff --git a/include/xgboost/json_io.h b/include/xgboost/json_io.h
index 3a73d170a..ce3d25c37 100644
--- a/include/xgboost/json_io.h
+++ b/include/xgboost/json_io.h
@@ -142,6 +142,7 @@ class JsonWriter {
virtual void Visit(JsonArray const* arr);
virtual void Visit(F32Array const* arr);
+ virtual void Visit(F64Array const*) { LOG(FATAL) << "Only UBJSON format can handle f64 array."; }
virtual void Visit(U8Array const* arr);
virtual void Visit(I32Array const* arr);
virtual void Visit(I64Array const* arr);
@@ -244,7 +245,8 @@ class UBJReader : public JsonReader {
*/
class UBJWriter : public JsonWriter {
void Visit(JsonArray const* arr) override;
- void Visit(F32Array const* arr) override;
+ void Visit(F32Array const* arr) override;
+ void Visit(F64Array const* arr) override;
void Visit(U8Array const* arr) override;
void Visit(I32Array const* arr) override;
void Visit(I64Array const* arr) override;
diff --git a/include/xgboost/linalg.h b/include/xgboost/linalg.h
index 26a072e52..8f9cd3eaa 100644
--- a/include/xgboost/linalg.h
+++ b/include/xgboost/linalg.h
@@ -295,6 +295,9 @@ class TensorView {
using ShapeT = std::size_t[kDim];
using StrideT = ShapeT;
+ using element_type = T; // NOLINT
+ using value_type = std::remove_cv_t; // NOLINT
+
private:
StrideT stride_{1};
ShapeT shape_{0};
@@ -314,7 +317,7 @@ class TensorView {
}
template
- LINALG_HD size_t MakeSliceDim(size_t new_shape[D], size_t new_stride[D],
+ LINALG_HD size_t MakeSliceDim(std::size_t new_shape[D], std::size_t new_stride[D],
detail::RangeTag &&range) const {
static_assert(new_dim < D);
static_assert(old_dim < kDim);
@@ -528,9 +531,10 @@ class TensorView {
LINALG_HD auto Stride(size_t i) const { return stride_[i]; }
/**
- * \brief Number of items in the tensor.
+ * @brief Number of items in the tensor.
*/
[[nodiscard]] LINALG_HD std::size_t Size() const { return size_; }
+ [[nodiscard]] bool Empty() const { return Size() == 0; }
/**
* \brief Whether this is a contiguous array, both C and F contiguous returns true.
*/
@@ -865,7 +869,9 @@ class Tensor {
auto HostView() { return this->View(DeviceOrd::CPU()); }
auto HostView() const { return this->View(DeviceOrd::CPU()); }
- [[nodiscard]] size_t Size() const { return data_.Size(); }
+ [[nodiscard]] std::size_t Size() const { return data_.Size(); }
+ [[nodiscard]] bool Empty() const { return Size() == 0; }
+
auto Shape() const { return common::Span{shape_}; }
auto Shape(size_t i) const { return shape_[i]; }
diff --git a/include/xgboost/span.h b/include/xgboost/span.h
index b0c1a5c1e..3e1325ceb 100644
--- a/include/xgboost/span.h
+++ b/include/xgboost/span.h
@@ -738,10 +738,10 @@ class IterSpan {
return {data() + _offset, _count == dynamic_extent ? size() - _offset : _count};
}
[[nodiscard]] XGBOOST_DEVICE constexpr iterator begin() const noexcept { // NOLINT
- return {this, 0};
+ return it_;
}
[[nodiscard]] XGBOOST_DEVICE constexpr iterator end() const noexcept { // NOLINT
- return {this, size()};
+ return it_ + size();
}
};
} // namespace common
diff --git a/include/xgboost/tree_model.h b/include/xgboost/tree_model.h
index 4c475da2e..32b93c5ca 100644
--- a/include/xgboost/tree_model.h
+++ b/include/xgboost/tree_model.h
@@ -1,5 +1,5 @@
/**
- * Copyright 2014-2023 by Contributors
+ * Copyright 2014-2024, XGBoost Contributors
* \file tree_model.h
* \brief model structure for tree
* \author Tianqi Chen
@@ -688,6 +688,9 @@ class RegTree : public Model {
}
return (*this)[nidx].DefaultLeft();
}
+ [[nodiscard]] bst_node_t DefaultChild(bst_node_t nidx) const {
+ return this->DefaultLeft(nidx) ? this->LeftChild(nidx) : this->RightChild(nidx);
+ }
[[nodiscard]] bool IsRoot(bst_node_t nidx) const {
if (IsMultiTarget()) {
return nidx == kRoot;
diff --git a/jvm-packages/create_jni.py b/jvm-packages/create_jni.py
index 395bc79b0..ff7bba693 100755
--- a/jvm-packages/create_jni.py
+++ b/jvm-packages/create_jni.py
@@ -83,44 +83,59 @@ def native_build(args):
with cd(".."):
build_dir = 'build-gpu' if cli_args.use_cuda == 'ON' or cli_args.use_hip == 'ON' else 'build'
maybe_makedirs(build_dir)
+
+ if sys.platform == "linux":
+ maybe_parallel_build = " -- -j $(nproc)"
+ else:
+ maybe_parallel_build = ""
+
+ if cli_args.log_capi_invocation == "ON":
+ CONFIG["LOG_CAPI_INVOCATION"] = "ON"
+
+ if cli_args.use_cuda == "ON":
+ CONFIG["USE_CUDA"] = "ON"
+ CONFIG["USE_NCCL"] = "ON"
+ CONFIG["USE_DLOPEN_NCCL"] = "OFF"
+ elif cli_args.use_hip== 'ON':
+ CONFIG['USE_HIP'] = 'ON'
+ CONFIG['USE_RCCL'] = 'ON'
+ CONFIG["USE_DLOPEN_RCCL"] = "OFF"
+
+ args = ["-D{0}:BOOL={1}".format(k, v) for k, v in CONFIG.items()]
+
+ # if enviorment set rabit_mock
+ if os.getenv("RABIT_MOCK", None) is not None:
+ args.append("-DRABIT_MOCK:BOOL=ON")
+
+ # if enviorment set GPU_ARCH_FLAG
+ gpu_arch_flag = os.getenv("GPU_ARCH_FLAG", None)
+ if gpu_arch_flag is not None:
+ args.append("%s" % gpu_arch_flag)
+
with cd(build_dir):
- if sys.platform == "win32":
- # Force x64 build on Windows.
- maybe_generator = " -A x64"
- else:
- maybe_generator = ""
- if sys.platform == "linux":
- maybe_parallel_build = " -- -j $(nproc)"
- else:
- maybe_parallel_build = ""
-
- if cli_args.log_capi_invocation == "ON":
- CONFIG["LOG_CAPI_INVOCATION"] = "ON"
-
- if cli_args.use_cuda == "ON":
- CONFIG["USE_CUDA"] = "ON"
- CONFIG["USE_NCCL"] = "ON"
- CONFIG["USE_DLOPEN_NCCL"] = "OFF"
- elif cli_args.use_hip== 'ON':
- CONFIG['USE_HIP'] = 'ON'
- CONFIG['USE_RCCL'] = 'ON'
- CONFIG["USE_DLOPEN_RCCL"] = "OFF"
-
- args = ["-D{0}:BOOL={1}".format(k, v) for k, v in CONFIG.items()]
-
- # if enviorment set rabit_mock
- if os.getenv("RABIT_MOCK", None) is not None:
- args.append("-DRABIT_MOCK:BOOL=ON")
-
- # if enviorment set GPU_ARCH_FLAG
- gpu_arch_flag = os.getenv("GPU_ARCH_FLAG", None)
- if gpu_arch_flag is not None:
- args.append("%s" % gpu_arch_flag)
-
lib_dir = os.path.join(os.pardir, "lib")
if os.path.exists(lib_dir):
shutil.rmtree(lib_dir)
- run("cmake .. " + " ".join(args) + maybe_generator)
+
+ # Same trick as Python build, just test all possible generators.
+ if sys.platform == "win32":
+ supported_generators = (
+ "", # empty, decided by cmake
+ '-G"Visual Studio 17 2022" -A x64',
+ '-G"Visual Studio 16 2019" -A x64',
+ '-G"Visual Studio 15 2017" -A x64',
+ )
+ for generator in supported_generators:
+ try:
+ run("cmake .. " + " ".join(args + [generator]))
+ break
+ except subprocess.CalledProcessError as e:
+ print(f"Failed to build with generator: {generator}", e)
+ with cd(os.path.pardir):
+ shutil.rmtree(build_dir)
+ maybe_makedirs(build_dir)
+ else:
+ run("cmake .. " + " ".join(args))
run("cmake --build . --config Release" + maybe_parallel_build)
with cd("demo/CLI/regression"):
diff --git a/plugin/CMakeLists.txt b/plugin/CMakeLists.txt
index e575f1a41..5d20e120e 100644
--- a/plugin/CMakeLists.txt
+++ b/plugin/CMakeLists.txt
@@ -1,10 +1,7 @@
if(PLUGIN_SYCL)
set(CMAKE_CXX_COMPILER "icpx")
- add_library(plugin_sycl OBJECT
- ${xgboost_SOURCE_DIR}/plugin/sycl/objective/regression_obj.cc
- ${xgboost_SOURCE_DIR}/plugin/sycl/objective/multiclass_obj.cc
- ${xgboost_SOURCE_DIR}/plugin/sycl/device_manager.cc
- ${xgboost_SOURCE_DIR}/plugin/sycl/predictor/predictor.cc)
+ file(GLOB_RECURSE SYCL_SOURCES "sycl/*.cc")
+ add_library(plugin_sycl OBJECT ${SYCL_SOURCES})
target_include_directories(plugin_sycl
PRIVATE
${xgboost_SOURCE_DIR}/include
diff --git a/plugin/sycl/common/partition_builder.h b/plugin/sycl/common/partition_builder.h
index 37d1af241..c520ff31f 100644
--- a/plugin/sycl/common/partition_builder.h
+++ b/plugin/sycl/common/partition_builder.h
@@ -21,6 +21,9 @@
#pragma GCC diagnostic pop
#include "../data.h"
+#include "row_set.h"
+#include "../data/gradient_index.h"
+#include "../tree/expand_entry.h"
#include
@@ -28,6 +31,87 @@ namespace xgboost {
namespace sycl {
namespace common {
+// split row indexes (rid_span) to 2 parts (both stored in rid_buf) depending
+// on comparison of indexes values (idx_span) and split point (split_cond)
+// Handle dense columns
+template
+inline ::sycl::event PartitionDenseKernel(
+ ::sycl::queue* qu,
+ const GHistIndexMatrix& gmat,
+ const RowSetCollection::Elem& rid_span,
+ const size_t fid,
+ const int32_t split_cond,
+ xgboost::common::Span* rid_buf,
+ size_t* parts_size,
+ ::sycl::event event) {
+ const size_t row_stride = gmat.row_stride;
+ const BinIdxType* gradient_index = gmat.index.data();
+ const size_t* rid = rid_span.begin;
+ const size_t range_size = rid_span.Size();
+ const size_t offset = gmat.cut.Ptrs()[fid];
+
+ size_t* p_rid_buf = rid_buf->data();
+
+ return qu->submit([&](::sycl::handler& cgh) {
+ cgh.depends_on(event);
+ cgh.parallel_for<>(::sycl::range<1>(range_size), [=](::sycl::item<1> nid) {
+ const size_t id = rid[nid.get_id(0)];
+ const int32_t value = static_cast(gradient_index[id * row_stride + fid] + offset);
+ const bool is_left = value <= split_cond;
+ if (is_left) {
+ AtomicRef n_left(parts_size[0]);
+ p_rid_buf[n_left.fetch_add(1)] = id;
+ } else {
+ AtomicRef n_right(parts_size[1]);
+ p_rid_buf[range_size - n_right.fetch_add(1) - 1] = id;
+ }
+ });
+ });
+}
+
+// split row indexes (rid_span) to 2 parts (both stored in rid_buf) depending
+// on comparison of indexes values (idx_span) and split point (split_cond)
+// Handle sparce columns
+template
+inline ::sycl::event PartitionSparseKernel(::sycl::queue* qu,
+ const GHistIndexMatrix& gmat,
+ const RowSetCollection::Elem& rid_span,
+ const size_t fid,
+ const int32_t split_cond,
+ xgboost::common::Span* rid_buf,
+ size_t* parts_size,
+ ::sycl::event event) {
+ const size_t row_stride = gmat.row_stride;
+ const BinIdxType* gradient_index = gmat.index.data();
+ const size_t* rid = rid_span.begin;
+ const size_t range_size = rid_span.Size();
+ const uint32_t* cut_ptrs = gmat.cut_device.Ptrs().DataConst();
+
+ size_t* p_rid_buf = rid_buf->data();
+ return qu->submit([&](::sycl::handler& cgh) {
+ cgh.depends_on(event);
+ cgh.parallel_for<>(::sycl::range<1>(range_size), [=](::sycl::item<1> nid) {
+ const size_t id = rid[nid.get_id(0)];
+
+ const BinIdxType* gr_index_local = gradient_index + row_stride * id;
+ const int32_t fid_local = std::lower_bound(gr_index_local,
+ gr_index_local + row_stride,
+ cut_ptrs[fid]) - gr_index_local;
+ const bool is_left = (fid_local >= row_stride ||
+ gr_index_local[fid_local] >= cut_ptrs[fid + 1]) ?
+ default_left :
+ gr_index_local[fid_local] <= split_cond;
+ if (is_left) {
+ AtomicRef n_left(parts_size[0]);
+ p_rid_buf[n_left.fetch_add(1)] = id;
+ } else {
+ AtomicRef n_right(parts_size[1]);
+ p_rid_buf[range_size - n_right.fetch_add(1) - 1] = id;
+ }
+ });
+ });
+}
+
// The builder is required for samples partition to left and rights children for set of nodes
class PartitionBuilder {
public:
@@ -53,7 +137,6 @@ class PartitionBuilder {
return result_rows_[2 * nid];
}
-
size_t GetNRightElems(int nid) const {
return result_rows_[2 * nid + 1];
}
@@ -72,19 +155,97 @@ class PartitionBuilder {
return { data_.Data() + nodes_offsets_[nid], nodes_offsets_[nid + 1] - nodes_offsets_[nid] };
}
+ template
+ ::sycl::event Partition(const int32_t split_cond,
+ const GHistIndexMatrix& gmat,
+ const RowSetCollection::Elem& rid_span,
+ const xgboost::RegTree::Node& node,
+ xgboost::common::Span* rid_buf,
+ size_t* parts_size,
+ ::sycl::event event) {
+ const bst_uint fid = node.SplitIndex();
+ const bool default_left = node.DefaultLeft();
+
+ if (gmat.IsDense()) {
+ if (default_left) {
+ return PartitionDenseKernel(qu_, gmat, rid_span, fid,
+ split_cond, rid_buf, parts_size, event);
+ } else {
+ return PartitionDenseKernel(qu_, gmat, rid_span, fid,
+ split_cond, rid_buf, parts_size, event);
+ }
+ } else {
+ if (default_left) {
+ return PartitionSparseKernel(qu_, gmat, rid_span, fid,
+ split_cond, rid_buf, parts_size, event);
+ } else {
+ return PartitionSparseKernel(qu_, gmat, rid_span, fid,
+ split_cond, rid_buf, parts_size, event);
+ }
+ }
+ }
+
+ // Entry point for Partition
+ void Partition(const GHistIndexMatrix& gmat,
+ const std::vector nodes,
+ const RowSetCollection& row_set_collection,
+ const std::vector& split_conditions,
+ RegTree* p_tree,
+ ::sycl::event* general_event) {
+ nodes_events_.resize(n_nodes_);
+
+ parts_size_.ResizeAndFill(qu_, 2 * n_nodes_, 0, general_event);
+
+ for (size_t node_in_set = 0; node_in_set < n_nodes_; node_in_set++) {
+ const int32_t nid = nodes[node_in_set].nid;
+ ::sycl::event& node_event = nodes_events_[node_in_set];
+ const auto& rid_span = row_set_collection[nid];
+ if (rid_span.Size() > 0) {
+ const RegTree::Node& node = (*p_tree)[nid];
+ xgboost::common::Span rid_buf = GetData(node_in_set);
+ size_t* part_size = parts_size_.Data() + 2 * node_in_set;
+ int32_t split_condition = split_conditions[node_in_set];
+ switch (gmat.index.GetBinTypeSize()) {
+ case common::BinTypeSize::kUint8BinsTypeSize:
+ node_event = Partition(split_condition, gmat, rid_span, node,
+ &rid_buf, part_size, *general_event);
+ break;
+ case common::BinTypeSize::kUint16BinsTypeSize:
+ node_event = Partition(split_condition, gmat, rid_span, node,
+ &rid_buf, part_size, *general_event);
+ break;
+ case common::BinTypeSize::kUint32BinsTypeSize:
+ node_event = Partition(split_condition, gmat, rid_span, node,
+ &rid_buf, part_size, *general_event);
+ break;
+ default:
+ CHECK(false); // no default behavior
+ }
+ } else {
+ node_event = ::sycl::event();
+ }
+ }
+
+ *general_event = qu_->memcpy(result_rows_.data(),
+ parts_size_.DataConst(),
+ sizeof(size_t) * 2 * n_nodes_,
+ nodes_events_);
+ }
+
void MergeToArray(size_t nid,
size_t* data_result,
- ::sycl::event event) {
+ ::sycl::event* event) {
size_t n_nodes_total = GetNLeftElems(nid) + GetNRightElems(nid);
if (n_nodes_total > 0) {
const size_t* data = data_.Data() + nodes_offsets_[nid];
- qu_->memcpy(data_result, data, sizeof(size_t) * n_nodes_total, event);
+ qu_->memcpy(data_result, data, sizeof(size_t) * n_nodes_total, *event);
}
}
protected:
std::vector nodes_offsets_;
std::vector result_rows_;
+ std::vector<::sycl::event> nodes_events_;
size_t n_nodes_;
USMVector parts_size_;
diff --git a/plugin/sycl/common/row_set.h b/plugin/sycl/common/row_set.h
new file mode 100644
index 000000000..574adbf8d
--- /dev/null
+++ b/plugin/sycl/common/row_set.h
@@ -0,0 +1,123 @@
+/*!
+ * Copyright 2017-2023 XGBoost contributors
+ */
+#ifndef PLUGIN_SYCL_COMMON_ROW_SET_H_
+#define PLUGIN_SYCL_COMMON_ROW_SET_H_
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wtautological-constant-compare"
+#pragma GCC diagnostic ignored "-W#pragma-messages"
+#include
+#pragma GCC diagnostic pop
+#include
+#include
+#include
+
+#include "../data.h"
+
+#include
+
+namespace xgboost {
+namespace sycl {
+namespace common {
+
+
+/*! \brief Collection of rowsets stored on device in USM memory */
+class RowSetCollection {
+ public:
+ /*! \brief data structure to store an instance set, a subset of
+ * rows (instances) associated with a particular node in a decision
+ * tree. */
+ struct Elem {
+ const size_t* begin{nullptr};
+ const size_t* end{nullptr};
+ bst_node_t node_id{-1}; // id of node associated with this instance set; -1 means uninitialized
+ Elem()
+ = default;
+ Elem(const size_t* begin,
+ const size_t* end,
+ bst_node_t node_id = -1)
+ : begin(begin), end(end), node_id(node_id) {}
+
+
+ inline size_t Size() const {
+ return end - begin;
+ }
+ };
+
+ inline size_t Size() const {
+ return elem_of_each_node_.size();
+ }
+
+ /*! \brief return corresponding element set given the node_id */
+ inline const Elem& operator[](unsigned node_id) const {
+ const Elem& e = elem_of_each_node_[node_id];
+ CHECK(e.begin != nullptr)
+ << "access element that is not in the set";
+ return e;
+ }
+
+ /*! \brief return corresponding element set given the node_id */
+ inline Elem& operator[](unsigned node_id) {
+ Elem& e = elem_of_each_node_[node_id];
+ return e;
+ }
+
+ // clear up things
+ inline void Clear() {
+ elem_of_each_node_.clear();
+ }
+ // initialize node id 0->everything
+ inline void Init() {
+ CHECK_EQ(elem_of_each_node_.size(), 0U);
+
+ const size_t* begin = row_indices_.Begin();
+ const size_t* end = row_indices_.End();
+ elem_of_each_node_.emplace_back(Elem(begin, end, 0));
+ }
+
+ auto& Data() { return row_indices_; }
+
+ // split rowset into two
+ inline void AddSplit(unsigned node_id,
+ unsigned left_node_id,
+ unsigned right_node_id,
+ size_t n_left,
+ size_t n_right) {
+ const Elem e = elem_of_each_node_[node_id];
+ CHECK(e.begin != nullptr);
+ size_t* all_begin = row_indices_.Begin();
+ size_t* begin = all_begin + (e.begin - all_begin);
+
+
+ CHECK_EQ(n_left + n_right, e.Size());
+ CHECK_LE(begin + n_left, e.end);
+ CHECK_EQ(begin + n_left + n_right, e.end);
+
+
+ if (left_node_id >= elem_of_each_node_.size()) {
+ elem_of_each_node_.resize(left_node_id + 1, Elem(nullptr, nullptr, -1));
+ }
+ if (right_node_id >= elem_of_each_node_.size()) {
+ elem_of_each_node_.resize(right_node_id + 1, Elem(nullptr, nullptr, -1));
+ }
+
+
+ elem_of_each_node_[left_node_id] = Elem(begin, begin + n_left, left_node_id);
+ elem_of_each_node_[right_node_id] = Elem(begin + n_left, e.end, right_node_id);
+ elem_of_each_node_[node_id] = Elem(nullptr, nullptr, -1);
+ }
+
+ private:
+ // stores the row indexes in the set
+ USMVector row_indices_;
+ // vector: node_id -> elements
+ std::vector elem_of_each_node_;
+};
+
+} // namespace common
+} // namespace sycl
+} // namespace xgboost
+
+
+#endif // PLUGIN_SYCL_COMMON_ROW_SET_H_
diff --git a/plugin/sycl/data.h b/plugin/sycl/data.h
index 489fde989..f420ef470 100644
--- a/plugin/sycl/data.h
+++ b/plugin/sycl/data.h
@@ -26,8 +26,13 @@
namespace xgboost {
namespace sycl {
-enum class MemoryType { shared, on_device};
+template
+using AtomicRef = ::sycl::atomic_ref;
+enum class MemoryType { shared, on_device};
template
class USMDeleter {
@@ -166,20 +171,20 @@ class USMVector {
}
}
- ::sycl::event ResizeAndFill(::sycl::queue* qu, size_t size_new, int v) {
+ void ResizeAndFill(::sycl::queue* qu, size_t size_new, int v, ::sycl::event* event) {
if (size_new <= size_) {
size_ = size_new;
- return qu->memset(data_.get(), v, size_new * sizeof(T));
+ *event = qu->memset(data_.get(), v, size_new * sizeof(T), *event);
} else if (size_new <= capacity_) {
size_ = size_new;
- return qu->memset(data_.get(), v, size_new * sizeof(T));
+ *event = qu->memset(data_.get(), v, size_new * sizeof(T), *event);
} else {
size_t size_old = size_;
auto data_old = data_;
size_ = size_new;
capacity_ = size_new;
data_ = allocate_memory_(qu, size_);
- return qu->memset(data_.get(), v, size_new * sizeof(T));
+ *event = qu->memset(data_.get(), v, size_new * sizeof(T), *event);
}
}
@@ -206,11 +211,16 @@ class USMVector {
struct DeviceMatrix {
DMatrix* p_mat; // Pointer to the original matrix on the host
::sycl::queue qu_;
- USMVector row_ptr;
+ USMVector row_ptr;
USMVector data;
size_t total_offset;
- DeviceMatrix(::sycl::queue qu, DMatrix* dmat) : p_mat(dmat), qu_(qu) {
+ DeviceMatrix() = default;
+
+ void Init(::sycl::queue qu, DMatrix* dmat) {
+ qu_ = qu;
+ p_mat = dmat;
+
size_t num_row = 0;
size_t num_nonzero = 0;
for (auto &batch : dmat->GetBatches()) {
@@ -221,27 +231,41 @@ struct DeviceMatrix {
}
row_ptr.Resize(&qu_, num_row + 1);
+ size_t* rows = row_ptr.Data();
data.Resize(&qu_, num_nonzero);
size_t data_offset = 0;
+ ::sycl::event event;
for (auto &batch : dmat->GetBatches()) {
const auto& data_vec = batch.data.HostVector();
const auto& offset_vec = batch.offset.HostVector();
size_t batch_size = batch.Size();
if (batch_size > 0) {
- std::copy(offset_vec.data(), offset_vec.data() + batch_size,
- row_ptr.Data() + batch.base_rowid);
- if (batch.base_rowid > 0) {
- for (size_t i = 0; i < batch_size; i++)
- row_ptr[i + batch.base_rowid] += batch.base_rowid;
+ const auto base_rowid = batch.base_rowid;
+ event = qu.memcpy(row_ptr.Data() + base_rowid, offset_vec.data(),
+ sizeof(size_t) * batch_size, event);
+ if (base_rowid > 0) {
+ qu.submit([&](::sycl::handler& cgh) {
+ cgh.depends_on(event);
+ cgh.parallel_for<>(::sycl::range<1>(batch_size), [=](::sycl::id<1> pid) {
+ int row_id = pid[0];
+ rows[row_id] += base_rowid;
+ });
+ });
}
- qu.memcpy(data.Data() + data_offset,
- data_vec.data(),
- offset_vec[batch_size] * sizeof(Entry)).wait();
+ event = qu.memcpy(data.Data() + data_offset, data_vec.data(),
+ sizeof(Entry) * offset_vec[batch_size], event);
data_offset += offset_vec[batch_size];
+ qu.wait();
}
}
- row_ptr[num_row] = data_offset;
+ qu.submit([&](::sycl::handler& cgh) {
+ cgh.depends_on(event);
+ cgh.single_task<>([=] {
+ rows[num_row] = data_offset;
+ });
+ });
+ qu.wait();
total_offset = data_offset;
}
diff --git a/plugin/sycl/data/gradient_index.cc b/plugin/sycl/data/gradient_index.cc
new file mode 100644
index 000000000..49b66a710
--- /dev/null
+++ b/plugin/sycl/data/gradient_index.cc
@@ -0,0 +1,177 @@
+/*!
+ * Copyright 2017-2024 by Contributors
+ * \file gradient_index.cc
+ */
+#include
+#include
+#include
+
+#include "gradient_index.h"
+
+#include
+
+namespace xgboost {
+namespace sycl {
+namespace common {
+
+uint32_t SearchBin(const bst_float* cut_values, const uint32_t* cut_ptrs, Entry const& e) {
+ auto beg = cut_ptrs[e.index];
+ auto end = cut_ptrs[e.index + 1];
+ auto it = std::upper_bound(cut_values + beg, cut_values + end, e.fvalue);
+ uint32_t idx = it - cut_values;
+ if (idx == end) {
+ idx -= 1;
+ }
+ return idx;
+}
+
+template
+void mergeSort(BinIdxType* begin, BinIdxType* end, BinIdxType* buf) {
+ const size_t total_len = end - begin;
+ for (size_t block_len = 1; block_len < total_len; block_len <<= 1) {
+ for (size_t cur_block = 0; cur_block + block_len < total_len; cur_block += 2 * block_len) {
+ size_t start = cur_block;
+ size_t mid = start + block_len;
+ size_t finish = mid + block_len < total_len ? mid + block_len : total_len;
+ size_t left_pos = start;
+ size_t right_pos = mid;
+ size_t pos = start;
+ while (left_pos < mid || right_pos < finish) {
+ if (left_pos < mid && (right_pos == finish || begin[left_pos] < begin[right_pos])) {
+ buf[pos++] = begin[left_pos++];
+ } else {
+ buf[pos++] = begin[right_pos++];
+ }
+ }
+ for (size_t i = start; i < finish; i++) begin[i] = buf[i];
+ }
+ }
+}
+
+template
+void GHistIndexMatrix::SetIndexData(::sycl::queue qu,
+ BinIdxType* index_data,
+ const DeviceMatrix &dmat,
+ size_t nbins,
+ size_t row_stride,
+ uint32_t* offsets) {
+ if (nbins == 0) return;
+ const xgboost::Entry *data_ptr = dmat.data.DataConst();
+ const bst_row_t *offset_vec = dmat.row_ptr.DataConst();
+ const size_t num_rows = dmat.row_ptr.Size() - 1;
+ const bst_float* cut_values = cut_device.Values().DataConst();
+ const uint32_t* cut_ptrs = cut_device.Ptrs().DataConst();
+ size_t* hit_count_ptr = hit_count_buff.Data();
+
+ // Sparse case only
+ if (!offsets) {
+ // sort_buff has type uint8_t
+ sort_buff.Resize(&qu, num_rows * row_stride * sizeof(BinIdxType));
+ }
+ BinIdxType* sort_data = reinterpret_cast(sort_buff.Data());
+
+ auto event = qu.submit([&](::sycl::handler& cgh) {
+ cgh.parallel_for<>(::sycl::range<1>(num_rows), [=](::sycl::item<1> pid) {
+ const size_t i = pid.get_id(0);
+ const size_t ibegin = offset_vec[i];
+ const size_t iend = offset_vec[i + 1];
+ const size_t size = iend - ibegin;
+ const size_t start = i * row_stride;
+ for (bst_uint j = 0; j < size; ++j) {
+ uint32_t idx = SearchBin(cut_values, cut_ptrs, data_ptr[ibegin + j]);
+ index_data[start + j] = offsets ? idx - offsets[j] : idx;
+ AtomicRef hit_count_ref(hit_count_ptr[idx]);
+ hit_count_ref.fetch_add(1);
+ }
+ if (!offsets) {
+ // Sparse case only
+ mergeSort(index_data + start, index_data + start + size, sort_data + start);
+ for (bst_uint j = size; j < row_stride; ++j) {
+ index_data[start + j] = nbins;
+ }
+ }
+ });
+ });
+ qu.memcpy(hit_count.data(), hit_count_ptr, nbins * sizeof(size_t), event);
+ qu.wait();
+}
+
+void GHistIndexMatrix::ResizeIndex(size_t n_index, bool isDense) {
+ if ((max_num_bins - 1 <= static_cast(std::numeric_limits::max())) && isDense) {
+ index.SetBinTypeSize(BinTypeSize::kUint8BinsTypeSize);
+ index.Resize((sizeof(uint8_t)) * n_index);
+ } else if ((max_num_bins - 1 > static_cast(std::numeric_limits::max()) &&
+ max_num_bins - 1 <= static_cast(std::numeric_limits::max())) && isDense) {
+ index.SetBinTypeSize(BinTypeSize::kUint16BinsTypeSize);
+ index.Resize((sizeof(uint16_t)) * n_index);
+ } else {
+ index.SetBinTypeSize(BinTypeSize::kUint32BinsTypeSize);
+ index.Resize((sizeof(uint32_t)) * n_index);
+ }
+}
+
+void GHistIndexMatrix::Init(::sycl::queue qu,
+ Context const * ctx,
+ const DeviceMatrix& p_fmat_device,
+ int max_bins) {
+ nfeatures = p_fmat_device.p_mat->Info().num_col_;
+
+ cut = xgboost::common::SketchOnDMatrix(ctx, p_fmat_device.p_mat, max_bins);
+ cut_device.Init(qu, cut);
+
+ max_num_bins = max_bins;
+ const uint32_t nbins = cut.Ptrs().back();
+ this->nbins = nbins;
+ hit_count.resize(nbins, 0);
+ hit_count_buff.Resize(&qu, nbins, 0);
+
+ this->p_fmat = p_fmat_device.p_mat;
+ const bool isDense = p_fmat_device.p_mat->IsDense();
+ this->isDense_ = isDense;
+
+ index.setQueue(qu);
+
+ row_stride = 0;
+ for (const auto& batch : p_fmat_device.p_mat->GetBatches()) {
+ const auto& row_offset = batch.offset.ConstHostVector();
+ for (auto i = 1ull; i < row_offset.size(); i++) {
+ row_stride = std::max(row_stride, static_cast(row_offset[i] - row_offset[i - 1]));
+ }
+ }
+
+ const size_t n_offsets = cut_device.Ptrs().Size() - 1;
+ const size_t n_rows = p_fmat_device.row_ptr.Size() - 1;
+ const size_t n_index = n_rows * row_stride;
+ ResizeIndex(n_index, isDense);
+
+ CHECK_GT(cut_device.Values().Size(), 0U);
+
+ uint32_t* offsets = nullptr;
+ if (isDense) {
+ index.ResizeOffset(n_offsets);
+ offsets = index.Offset();
+ qu.memcpy(offsets, cut_device.Ptrs().DataConst(),
+ sizeof(uint32_t) * n_offsets).wait_and_throw();
+ }
+
+ if (isDense) {
+ BinTypeSize curent_bin_size = index.GetBinTypeSize();
+ if (curent_bin_size == BinTypeSize::kUint8BinsTypeSize) {
+ SetIndexData(qu, index.data(), p_fmat_device, nbins, row_stride, offsets);
+
+ } else if (curent_bin_size == BinTypeSize::kUint16BinsTypeSize) {
+ SetIndexData(qu, index.data(), p_fmat_device, nbins, row_stride, offsets);
+ } else {
+ CHECK_EQ(curent_bin_size, BinTypeSize::kUint32BinsTypeSize);
+ SetIndexData(qu, index.data(), p_fmat_device, nbins, row_stride, offsets);
+ }
+ /* For sparse DMatrix we have to store index of feature for each bin
+ in index field to chose right offset. So offset is nullptr and index is not reduced */
+ } else {
+ SetIndexData(qu, index.data(), p_fmat_device, nbins, row_stride, offsets);
+ }
+}
+
+} // namespace common
+} // namespace sycl
+} // namespace xgboost
diff --git a/plugin/sycl/data/gradient_index.h b/plugin/sycl/data/gradient_index.h
new file mode 100644
index 000000000..13577025c
--- /dev/null
+++ b/plugin/sycl/data/gradient_index.h
@@ -0,0 +1,216 @@
+/*!
+ * Copyright 2017-2024 by Contributors
+ * \file gradient_index.h
+ */
+#ifndef PLUGIN_SYCL_DATA_GRADIENT_INDEX_H_
+#define PLUGIN_SYCL_DATA_GRADIENT_INDEX_H_
+
+#include
+
+#include "../data.h"
+#include "../../src/common/hist_util.h"
+
+#include
+
+namespace xgboost {
+namespace sycl {
+namespace common {
+
+/*!
+ * \brief SYCL implementation of HistogramCuts stored in USM buffers to provide access from device kernels
+ */
+class HistogramCuts {
+ protected:
+ using BinIdx = uint32_t;
+
+ public:
+ HistogramCuts() {}
+
+ explicit HistogramCuts(::sycl::queue qu) {}
+
+ ~HistogramCuts() {
+ }
+
+ void Init(::sycl::queue qu, xgboost::common::HistogramCuts const& cuts) {
+ qu_ = qu;
+ cut_values_.Init(&qu_, cuts.cut_values_.HostVector());
+ cut_ptrs_.Init(&qu_, cuts.cut_ptrs_.HostVector());
+ min_vals_.Init(&qu_, cuts.min_vals_.HostVector());
+ }
+
+ // Getters for USM buffers to pass pointers into device kernels
+ const USMVector& Ptrs() const { return cut_ptrs_; }
+ const USMVector& Values() const { return cut_values_; }
+ const USMVector& MinValues() const { return min_vals_; }
+
+ private:
+ USMVector cut_values_;
+ USMVector cut_ptrs_;
+ USMVector min_vals_;
+ ::sycl::queue qu_;
+};
+
+using BinTypeSize = ::xgboost::common::BinTypeSize;
+
+/*!
+ * \brief Index data and offsets stored in USM buffers to provide access from device kernels
+ */
+struct Index {
+ Index() {
+ SetBinTypeSize(binTypeSize_);
+ }
+ Index(const Index& i) = delete;
+ Index& operator=(Index i) = delete;
+ Index(Index&& i) = delete;
+ Index& operator=(Index&& i) = delete;
+ uint32_t operator[](size_t i) const {
+ if (!offset_.Empty()) {
+ return func_(data_.DataConst(), i) + offset_[i%p_];
+ } else {
+ return func_(data_.DataConst(), i);
+ }
+ }
+ void SetBinTypeSize(BinTypeSize binTypeSize) {
+ binTypeSize_ = binTypeSize;
+ switch (binTypeSize) {
+ case BinTypeSize::kUint8BinsTypeSize:
+ func_ = &GetValueFromUint8;
+ break;
+ case BinTypeSize::kUint16BinsTypeSize:
+ func_ = &GetValueFromUint16;
+ break;
+ case BinTypeSize::kUint32BinsTypeSize:
+ func_ = &GetValueFromUint32;
+ break;
+ default:
+ CHECK(binTypeSize == BinTypeSize::kUint8BinsTypeSize ||
+ binTypeSize == BinTypeSize::kUint16BinsTypeSize ||
+ binTypeSize == BinTypeSize::kUint32BinsTypeSize);
+ }
+ }
+ BinTypeSize GetBinTypeSize() const {
+ return binTypeSize_;
+ }
+
+ template
+ T* data() {
+ return reinterpret_cast(data_.Data());
+ }
+
+ template
+ const T* data() const {
+ return reinterpret_cast(data_.DataConst());
+ }
+
+ uint32_t* Offset() {
+ return offset_.Data();
+ }
+
+ const uint32_t* Offset() const {
+ return offset_.DataConst();
+ }
+
+ size_t Size() const {
+ return data_.Size() / (binTypeSize_);
+ }
+
+ void Resize(const size_t nBytesData) {
+ data_.Resize(&qu_, nBytesData);
+ }
+
+ void ResizeOffset(const size_t nDisps) {
+ offset_.Resize(&qu_, nDisps);
+ p_ = nDisps;
+ }
+
+ uint8_t* begin() const {
+ return data_.Begin();
+ }
+
+ uint8_t* end() const {
+ return data_.End();
+ }
+
+ void setQueue(::sycl::queue qu) {
+ qu_ = qu;
+ }
+
+ private:
+ static uint32_t GetValueFromUint8(const uint8_t* t, size_t i) {
+ return reinterpret_cast(t)[i];
+ }
+ static uint32_t GetValueFromUint16(const uint8_t* t, size_t i) {
+ return reinterpret_cast(t)[i];
+ }
+ static uint32_t GetValueFromUint32(const uint8_t* t, size_t i) {
+ return reinterpret_cast(t)[i];
+ }
+
+ using Func = uint32_t (*)(const uint8_t*, size_t);
+
+ USMVector data_;
+ // size of this field is equal to number of features
+ USMVector offset_;
+ BinTypeSize binTypeSize_ {BinTypeSize::kUint8BinsTypeSize};
+ size_t p_ {1};
+ Func func_;
+
+ ::sycl::queue qu_;
+};
+
+/*!
+ * \brief Preprocessed global index matrix, in CSR format, stored in USM buffers
+ *
+ * Transform floating values to integer index in histogram
+ */
+struct GHistIndexMatrix {
+ /*! \brief row pointer to rows by element position */
+ /*! \brief The index data */
+ Index index;
+ /*! \brief hit count of each index */
+ std::vector hit_count;
+ /*! \brief buffers for calculations */
+ USMVector hit_count_buff;
+ USMVector sort_buff;
+ /*! \brief The corresponding cuts */
+ xgboost::common::HistogramCuts cut;
+ HistogramCuts cut_device;
+ DMatrix* p_fmat;
+ size_t max_num_bins;
+ size_t nbins;
+ size_t nfeatures;
+ size_t row_stride;
+
+ // Create a global histogram matrix based on a given DMatrix device wrapper
+ void Init(::sycl::queue qu, Context const * ctx,
+ const sycl::DeviceMatrix& p_fmat_device, int max_num_bins);
+
+ template
+ void SetIndexData(::sycl::queue qu, BinIdxType* index_data,
+ const sycl::DeviceMatrix &dmat_device,
+ size_t nbins, size_t row_stride, uint32_t* offsets);
+
+ void ResizeIndex(size_t n_index, bool isDense);
+
+ inline void GetFeatureCounts(size_t* counts) const {
+ auto nfeature = cut_device.Ptrs().Size() - 1;
+ for (unsigned fid = 0; fid < nfeature; ++fid) {
+ auto ibegin = cut_device.Ptrs()[fid];
+ auto iend = cut_device.Ptrs()[fid + 1];
+ for (auto i = ibegin; i < iend; ++i) {
+ *(counts + fid) += hit_count[i];
+ }
+ }
+ }
+ inline bool IsDense() const {
+ return isDense_;
+ }
+
+ private:
+ bool isDense_;
+};
+
+} // namespace common
+} // namespace sycl
+} // namespace xgboost
+#endif // PLUGIN_SYCL_DATA_GRADIENT_INDEX_H_
diff --git a/plugin/sycl/predictor/predictor.cc b/plugin/sycl/predictor/predictor.cc
index dd56dd3bd..943949c2a 100755
--- a/plugin/sycl/predictor/predictor.cc
+++ b/plugin/sycl/predictor/predictor.cc
@@ -280,7 +280,8 @@ class Predictor : public xgboost::Predictor {
uint32_t tree_end = 0) const override {
::sycl::queue qu = device_manager.GetQueue(ctx_->Device());
// TODO(razdoburdin): remove temporary workaround after cache fix
- sycl::DeviceMatrix device_matrix(qu, dmat);
+ sycl::DeviceMatrix device_matrix;
+ device_matrix.Init(qu, dmat);
auto* out_preds = &predts->predictions;
if (tree_end == 0) {
diff --git a/plugin/sycl/tree/expand_entry.h b/plugin/sycl/tree/expand_entry.h
new file mode 100644
index 000000000..2520ff95d
--- /dev/null
+++ b/plugin/sycl/tree/expand_entry.h
@@ -0,0 +1,50 @@
+/*!
+ * Copyright 2017-2024 by Contributors
+ * \file expand_entry.h
+ */
+#ifndef PLUGIN_SYCL_TREE_EXPAND_ENTRY_H_
+#define PLUGIN_SYCL_TREE_EXPAND_ENTRY_H_
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wtautological-constant-compare"
+#include "../../src/tree/constraints.h"
+#pragma GCC diagnostic pop
+#include "../../src/tree/hist/expand_entry.h"
+
+namespace xgboost {
+namespace sycl {
+namespace tree {
+/* tree growing policies */
+struct ExpandEntry : public xgboost::tree::ExpandEntryImpl {
+ static constexpr bst_node_t kRootNid = 0;
+
+ xgboost::tree::SplitEntry split;
+
+ ExpandEntry(int nid, int depth) : ExpandEntryImpl{nid, depth} {}
+
+ inline bst_node_t GetSiblingId(const xgboost::RegTree* p_tree) const {
+ CHECK_EQ((*p_tree)[nid].IsRoot(), false);
+ const size_t parent_id = (*p_tree)[nid].Parent();
+ return GetSiblingId(p_tree, parent_id);
+ }
+
+ inline bst_node_t GetSiblingId(const xgboost::RegTree* p_tree, size_t parent_id) const {
+ return p_tree->IsLeftChild(nid) ? p_tree->RightChild(parent_id)
+ : p_tree->LeftChild(parent_id);
+ }
+
+ bool IsValidImpl(xgboost::tree::TrainParam const ¶m, int32_t num_leaves) const {
+ if (split.loss_chg <= kRtEps) return false;
+ if (split.loss_chg < param.min_split_loss) return false;
+ if (param.max_depth > 0 && depth == param.max_depth) return false;
+ if (param.max_leaves > 0 && num_leaves == param.max_leaves) return false;
+
+ return true;
+ }
+};
+
+} // namespace tree
+} // namespace sycl
+} // namespace xgboost
+
+#endif // PLUGIN_SYCL_TREE_EXPAND_ENTRY_H_
diff --git a/python-package/packager/nativelib.py b/python-package/packager/nativelib.py
index 0227cff37..42b510eef 100644
--- a/python-package/packager/nativelib.py
+++ b/python-package/packager/nativelib.py
@@ -32,7 +32,10 @@ def build_libxgboost(
build_dir: pathlib.Path,
build_config: BuildConfiguration,
) -> pathlib.Path:
- """Build libxgboost in a temporary directory and obtain the path to built libxgboost"""
+ """Build libxgboost in a temporary directory and obtain the path to built
+ libxgboost.
+
+ """
logger = logging.getLogger("xgboost.packager.build_libxgboost")
if not cpp_src_dir.is_dir():
@@ -51,8 +54,8 @@ def build_libxgboost(
cmake_cmd.extend(build_config.get_cmake_args())
# Flag for cross-compiling for Apple Silicon
- # We use environment variable because it's the only way to pass down custom flags
- # through the cibuildwheel package, which calls `pip wheel` command.
+ # We use environment variable because it's the only way to pass down custom
+ # flags through the cibuildwheel package, which calls `pip wheel` command.
if "CIBW_TARGET_OSX_ARM64" in os.environ:
cmake_cmd.append("-DCMAKE_OSX_ARCHITECTURES=arm64")
diff --git a/python-package/xgboost/core.py b/python-package/xgboost/core.py
index 27331d3de..36e4bdcf0 100644
--- a/python-package/xgboost/core.py
+++ b/python-package/xgboost/core.py
@@ -804,10 +804,11 @@ class DMatrix: # pylint: disable=too-many-instance-attributes,too-many-public-m
Otherwise, one can pass a list-like input with the same length as number
of columns in `data`, with the following possible values:
- - "c", which represents categorical columns.
- - "q", which represents numeric columns.
- - "int", which represents integer columns.
- - "i", which represents boolean columns.
+
+ - "c", which represents categorical columns.
+ - "q", which represents numeric columns.
+ - "int", which represents integer columns.
+ - "i", which represents boolean columns.
Note that, while categorical types are treated differently from
the rest for model fitting purposes, the other types do not influence
@@ -861,9 +862,9 @@ class DMatrix: # pylint: disable=too-many-instance-attributes,too-many-public-m
self.nthread = nthread if nthread is not None else -1
self.silent = silent
- # force into void_p, mac need to pass things in as void_p
- if data is None:
- self.handle: Optional[ctypes.c_void_p] = None
+ if isinstance(data, ctypes.c_void_p):
+ # Used for constructing DMatrix slice.
+ self.handle = data
return
from .data import _is_iter, dispatch_data_backend
@@ -925,9 +926,10 @@ class DMatrix: # pylint: disable=too-many-instance-attributes,too-many-public-m
self.handle = handle
def __del__(self) -> None:
- if hasattr(self, "handle") and self.handle:
+ if hasattr(self, "handle"):
+ assert self.handle is not None
_check_call(_LIB.XGDMatrixFree(self.handle))
- self.handle = None
+ del self.handle
@_deprecate_positional_args
def set_info(
@@ -1281,19 +1283,19 @@ class DMatrix: # pylint: disable=too-many-instance-attributes,too-many-public-m
"""
from .data import _maybe_np_slice
- res = DMatrix(None)
- res.handle = ctypes.c_void_p()
+ handle = ctypes.c_void_p()
+
rindex = _maybe_np_slice(rindex, dtype=np.int32)
_check_call(
_LIB.XGDMatrixSliceDMatrixEx(
self.handle,
c_array(ctypes.c_int, rindex),
c_bst_ulong(len(rindex)),
- ctypes.byref(res.handle),
+ ctypes.byref(handle),
ctypes.c_int(1 if allow_groups else 0),
)
)
- return res
+ return DMatrix(handle)
@property
def feature_names(self) -> Optional[FeatureNames]:
diff --git a/python-package/xgboost/data.py b/python-package/xgboost/data.py
index 49a0f43b7..07a08dc5f 100644
--- a/python-package/xgboost/data.py
+++ b/python-package/xgboost/data.py
@@ -1053,10 +1053,10 @@ def _is_dlpack(data: DataType) -> bool:
def _transform_dlpack(data: DataType) -> bool:
- from cupy import fromDlpack # pylint: disable=E0401
+ from cupy import from_dlpack # pylint: disable=E0401
assert "used_dltensor" not in str(data)
- data = fromDlpack(data)
+ data = from_dlpack(data)
return data
diff --git a/python-package/xgboost/sklearn.py b/python-package/xgboost/sklearn.py
index 5d651948c..c4713a9e4 100644
--- a/python-package/xgboost/sklearn.py
+++ b/python-package/xgboost/sklearn.py
@@ -5,12 +5,14 @@ import json
import os
import warnings
from concurrent.futures import ThreadPoolExecutor
+from inspect import signature
from typing import (
Any,
Callable,
Dict,
List,
Optional,
+ Protocol,
Sequence,
Tuple,
Type,
@@ -67,14 +69,20 @@ def _can_use_qdm(tree_method: Optional[str]) -> bool:
return tree_method in ("hist", "gpu_hist", None, "auto")
-SklObjective = Optional[
- Union[str, Callable[[np.ndarray, np.ndarray], Tuple[np.ndarray, np.ndarray]]]
-]
+class _SklObjWProto(Protocol): # pylint: disable=too-few-public-methods
+ def __call__(
+ self,
+ y_true: ArrayLike,
+ y_pred: ArrayLike,
+ sample_weight: Optional[ArrayLike],
+ ) -> Tuple[ArrayLike, ArrayLike]: ...
-def _objective_decorator(
- func: Callable[[np.ndarray, np.ndarray], Tuple[np.ndarray, np.ndarray]]
-) -> Objective:
+_SklObjProto = Callable[[ArrayLike, ArrayLike], Tuple[np.ndarray, np.ndarray]]
+SklObjective = Optional[Union[str, _SklObjWProto, _SklObjProto]]
+
+
+def _objective_decorator(func: Union[_SklObjWProto, _SklObjProto]) -> Objective:
"""Decorate an objective function
Converts an objective function using the typical sklearn metrics
@@ -89,6 +97,8 @@ def _objective_decorator(
The target values
y_pred: array_like of shape [n_samples]
The predicted values
+ sample_weight :
+ Optional sample weight, None or a ndarray.
Returns
-------
@@ -103,10 +113,25 @@ def _objective_decorator(
``dmatrix.get_label()``
"""
+ parameters = signature(func).parameters
+ supports_sw = "sample_weight" in parameters
+
def inner(preds: np.ndarray, dmatrix: DMatrix) -> Tuple[np.ndarray, np.ndarray]:
- """internal function"""
+ """Internal function."""
+ sample_weight = dmatrix.get_weight()
labels = dmatrix.get_label()
- return func(labels, preds)
+
+ if sample_weight.size > 0 and not supports_sw:
+ raise ValueError(
+ "Custom objective doesn't have the `sample_weight` parameter while"
+ " sample_weight is used."
+ )
+ if sample_weight.size > 0:
+ fnw = cast(_SklObjWProto, func)
+ return fnw(labels, preds, sample_weight=sample_weight)
+
+ fn = cast(_SklObjProto, func)
+ return fn(labels, preds)
return inner
@@ -172,75 +197,121 @@ def ltr_metric_decorator(func: Callable, n_jobs: Optional[int]) -> Metric:
return inner
-__estimator_doc = """
- n_estimators : Optional[int]
+__estimator_doc = f"""
+ n_estimators : {Optional[int]}
Number of gradient boosted trees. Equivalent to number of boosting
rounds.
"""
__model_doc = f"""
- max_depth : Optional[int]
+ max_depth : {Optional[int]}
+
Maximum tree depth for base learners.
- max_leaves :
+
+ max_leaves : {Optional[int]}
+
Maximum number of leaves; 0 indicates no limit.
- max_bin :
+
+ max_bin : {Optional[int]}
+
If using histogram-based algorithm, maximum number of bins per feature
- grow_policy :
- Tree growing policy. 0: favor splitting at nodes closest to the node, i.e. grow
- depth-wise. 1: favor splitting at nodes with highest loss change.
- learning_rate : Optional[float]
+
+ grow_policy : {Optional[str]}
+
+ Tree growing policy.
+
+ - depthwise: Favors splitting at nodes closest to the node,
+ - lossguide: Favors splitting at nodes with highest loss change.
+
+ learning_rate : {Optional[float]}
+
Boosting learning rate (xgb's "eta")
- verbosity : Optional[int]
+
+ verbosity : {Optional[int]}
+
The degree of verbosity. Valid values are 0 (silent) - 3 (debug).
objective : {SklObjective}
Specify the learning task and the corresponding learning objective or a custom
- objective function to be used. For custom objective, see
- :doc:`/tutorials/custom_metric_obj` and :ref:`custom-obj-metric` for more
- information.
+ objective function to be used.
+
+ For custom objective, see :doc:`/tutorials/custom_metric_obj` and
+ :ref:`custom-obj-metric` for more information, along with the end note for
+ function signatures.
+
+ booster: {Optional[str]}
+
+ Specify which booster to use: ``gbtree``, ``gblinear`` or ``dart``.
+
+ tree_method : {Optional[str]}
- booster: Optional[str]
- Specify which booster to use: `gbtree`, `gblinear` or `dart`.
- tree_method: Optional[str]
Specify which tree method to use. Default to auto. If this parameter is set to
default, XGBoost will choose the most conservative option available. It's
recommended to study this option from the parameters document :doc:`tree method
`
- n_jobs : Optional[int]
+
+ n_jobs : {Optional[int]}
+
Number of parallel threads used to run xgboost. When used with other
Scikit-Learn algorithms like grid search, you may choose which algorithm to
parallelize and balance the threads. Creating thread contention will
significantly slow down both algorithms.
- gamma : Optional[float]
- (min_split_loss) Minimum loss reduction required to make a further partition on a
- leaf node of the tree.
- min_child_weight : Optional[float]
+
+ gamma : {Optional[float]}
+
+ (min_split_loss) Minimum loss reduction required to make a further partition on
+ a leaf node of the tree.
+
+ min_child_weight : {Optional[float]}
+
Minimum sum of instance weight(hessian) needed in a child.
- max_delta_step : Optional[float]
+
+ max_delta_step : {Optional[float]}
+
Maximum delta step we allow each tree's weight estimation to be.
- subsample : Optional[float]
+
+ subsample : {Optional[float]}
+
Subsample ratio of the training instance.
- sampling_method :
+
+ sampling_method : {Optional[str]}
+
Sampling method. Used only by the GPU version of ``hist`` tree method.
- - ``uniform``: select random training instances uniformly.
- - ``gradient_based`` select random training instances with higher probability
+
+ - ``uniform``: Select random training instances uniformly.
+ - ``gradient_based``: Select random training instances with higher probability
when the gradient and hessian are larger. (cf. CatBoost)
- colsample_bytree : Optional[float]
+
+ colsample_bytree : {Optional[float]}
+
Subsample ratio of columns when constructing each tree.
- colsample_bylevel : Optional[float]
+
+ colsample_bylevel : {Optional[float]}
+
Subsample ratio of columns for each level.
- colsample_bynode : Optional[float]
+
+ colsample_bynode : {Optional[float]}
+
Subsample ratio of columns for each split.
- reg_alpha : Optional[float]
+
+ reg_alpha : {Optional[float]}
+
L1 regularization term on weights (xgb's alpha).
- reg_lambda : Optional[float]
+
+ reg_lambda : {Optional[float]}
+
L2 regularization term on weights (xgb's lambda).
- scale_pos_weight : Optional[float]
+
+ scale_pos_weight : {Optional[float]}
Balancing of positive and negative weights.
- base_score : Optional[float]
+
+ base_score : {Optional[float]}
+
The initial prediction score of all instances, global bias.
- random_state : Optional[Union[numpy.random.RandomState, numpy.random.Generator, int]]
+
+ random_state : {Optional[Union[np.random.RandomState, np.random.Generator, int]]}
+
Random number seed.
.. note::
@@ -248,34 +319,44 @@ __model_doc = f"""
Using gblinear booster with shotgun updater is nondeterministic as
it uses Hogwild algorithm.
- missing : float, default np.nan
- Value in the data which needs to be present as a missing value.
- num_parallel_tree: Optional[int]
+ missing : float
+
+ Value in the data which needs to be present as a missing value. Default to
+ :py:data:`numpy.nan`.
+
+ num_parallel_tree: {Optional[int]}
+
Used for boosting random forest.
- monotone_constraints : Optional[Union[Dict[str, int], str]]
+
+ monotone_constraints : {Optional[Union[Dict[str, int], str]]}
+
Constraint of variable monotonicity. See :doc:`tutorial `
for more information.
- interaction_constraints : Optional[Union[str, List[Tuple[str]]]]
+
+ interaction_constraints : {Optional[Union[str, List[Tuple[str]]]]}
+
Constraints for interaction representing permitted interactions. The
constraints must be specified in the form of a nested list, e.g. ``[[0, 1], [2,
3, 4]]``, where each inner list is a group of indices of features that are
allowed to interact with each other. See :doc:`tutorial
` for more information
- importance_type: Optional[str]
+
+ importance_type: {Optional[str]}
+
The feature importance type for the feature_importances\\_ property:
* For tree model, it's either "gain", "weight", "cover", "total_gain" or
"total_cover".
- * For linear model, only "weight" is defined and it's the normalized coefficients
- without bias.
+ * For linear model, only "weight" is defined and it's the normalized
+ coefficients without bias.
- device : Optional[str]
+ device : {Optional[str]}
.. versionadded:: 2.0.0
Device ordinal, available options are `cpu`, `cuda`, and `gpu`.
- validate_parameters : Optional[bool]
+ validate_parameters : {Optional[bool]}
Give warnings for unknown parameter.
@@ -283,14 +364,14 @@ __model_doc = f"""
See the same parameter of :py:class:`DMatrix` for details.
- feature_types : Optional[FeatureTypes]
+ feature_types : {Optional[FeatureTypes]}
.. versionadded:: 1.7.0
Used for specifying feature types without constructing a dataframe. See
:py:class:`DMatrix` for details.
- max_cat_to_onehot : Optional[int]
+ max_cat_to_onehot : {Optional[int]}
.. versionadded:: 1.6.0
@@ -303,7 +384,7 @@ __model_doc = f"""
categorical feature support. See :doc:`Categorical Data
` and :ref:`cat-param` for details.
- max_cat_threshold : Optional[int]
+ max_cat_threshold : {Optional[int]}
.. versionadded:: 1.7.0
@@ -314,7 +395,7 @@ __model_doc = f"""
needs to be set to have categorical feature support. See :doc:`Categorical Data
` and :ref:`cat-param` for details.
- multi_strategy : Optional[str]
+ multi_strategy : {Optional[str]}
.. versionadded:: 2.0.0
@@ -327,7 +408,7 @@ __model_doc = f"""
- ``one_output_per_tree``: One model for each target.
- ``multi_output_tree``: Use multi-target trees.
- eval_metric : Optional[Union[str, List[str], Callable]]
+ eval_metric : {Optional[Union[str, List[str], Callable]]}
.. versionadded:: 1.6.0
@@ -360,7 +441,7 @@ __model_doc = f"""
)
reg.fit(X, y, eval_set=[(X, y)])
- early_stopping_rounds : Optional[int]
+ early_stopping_rounds : {Optional[int]}
.. versionadded:: 1.6.0
@@ -383,7 +464,8 @@ __model_doc = f"""
early stopping. If there's more than one metric in **eval_metric**, the last
metric will be used for early stopping.
- callbacks : Optional[List[TrainingCallback]]
+ callbacks : {Optional[List[TrainingCallback]]}
+
List of callback functions that are applied at end of each iteration.
It is possible to use predefined callbacks by using
:ref:`Callback API `.
@@ -402,7 +484,8 @@ __model_doc = f"""
reg = xgboost.XGBRegressor(**params, callbacks=callbacks)
reg.fit(X, y)
- kwargs : dict, optional
+ kwargs : {Optional[Any]}
+
Keyword arguments for XGBoost Booster object. Full documentation of parameters
can be found :doc:`here `.
Attempting to set a parameter via the constructor args and \\*\\*kwargs
@@ -419,13 +502,16 @@ __custom_obj_note = """
.. note:: Custom objective function
A custom objective function can be provided for the ``objective``
- parameter. In this case, it should have the signature
- ``objective(y_true, y_pred) -> grad, hess``:
+ parameter. In this case, it should have the signature ``objective(y_true,
+ y_pred) -> [grad, hess]`` or ``objective(y_true, y_pred, *, sample_weight)
+ -> [grad, hess]``:
y_true: array_like of shape [n_samples]
The target values
y_pred: array_like of shape [n_samples]
The predicted values
+ sample_weight :
+ Optional sample weights.
grad: array_like of shape [n_samples]
The value of the gradient for each sample point.
diff --git a/python-package/xgboost/spark/core.py b/python-package/xgboost/spark/core.py
index eb226611d..e44182cb3 100644
--- a/python-package/xgboost/spark/core.py
+++ b/python-package/xgboost/spark/core.py
@@ -95,6 +95,7 @@ from .utils import (
deserialize_xgb_model,
get_class_name,
get_logger,
+ get_logger_level,
serialize_booster,
use_cuda,
)
@@ -181,6 +182,8 @@ pred = Pred("prediction", "rawPrediction", "probability", "predContrib")
_INIT_BOOSTER_SAVE_PATH = "init_booster.json"
+_LOG_TAG = "XGBoost-PySpark"
+
class _SparkXGBParams(
HasFeaturesCol,
@@ -1034,6 +1037,8 @@ class _SparkXGBEstimator(Estimator, _SparkXGBParams, MLReadable, MLWritable):
num_workers = self.getOrDefault(self.num_workers)
+ log_level = get_logger_level(_LOG_TAG)
+
def _train_booster(
pandas_df_iter: Iterator[pd.DataFrame],
) -> Iterator[pd.DataFrame]:
@@ -1047,7 +1052,7 @@ class _SparkXGBEstimator(Estimator, _SparkXGBParams, MLReadable, MLWritable):
dev_ordinal = None
use_qdm = _can_use_qdm(booster_params.get("tree_method", None))
-
+ msg = "Training on CPUs"
if run_on_gpu:
dev_ordinal = (
context.partitionId() if is_local else _get_gpu_id(context)
@@ -1058,10 +1063,9 @@ class _SparkXGBEstimator(Estimator, _SparkXGBParams, MLReadable, MLWritable):
# Note: Checking `is_cudf_available` in spark worker side because
# spark worker might has different python environment with driver side.
use_qdm = use_qdm and is_cudf_available()
- get_logger("XGBoost-PySpark").info(
- "Leveraging %s to train with QDM: %s",
- booster_params["device"],
- "on" if use_qdm else "off",
+ msg = (
+ f"Leveraging {booster_params['device']} to train with "
+ f"QDM: {'on' if use_qdm else 'off'}"
)
if use_qdm and (booster_params.get("max_bin", None) is not None):
@@ -1070,6 +1074,7 @@ class _SparkXGBEstimator(Estimator, _SparkXGBParams, MLReadable, MLWritable):
_rabit_args = {}
if context.partitionId() == 0:
_rabit_args = _get_rabit_args(context, num_workers)
+ get_logger(_LOG_TAG, log_level).info(msg)
worker_message = {
"rabit_msg": _rabit_args,
@@ -1127,7 +1132,7 @@ class _SparkXGBEstimator(Estimator, _SparkXGBParams, MLReadable, MLWritable):
ret = rdd_with_resource.collect()[0]
return ret[0], ret[1]
- get_logger("XGBoost-PySpark").info(
+ get_logger(_LOG_TAG).info(
"Running xgboost-%s on %s workers with"
"\n\tbooster params: %s"
"\n\ttrain_call_kwargs_params: %s"
@@ -1139,7 +1144,7 @@ class _SparkXGBEstimator(Estimator, _SparkXGBParams, MLReadable, MLWritable):
dmatrix_kwargs,
)
(config, booster) = _run_job()
- get_logger("XGBoost-PySpark").info("Finished xgboost training!")
+ get_logger(_LOG_TAG).info("Finished xgboost training!")
result_xgb_model = self._convert_to_sklearn_model(
bytearray(booster, "utf-8"), config
@@ -1342,7 +1347,7 @@ class _SparkXGBModel(Model, _SparkXGBParams, MLReadable, MLWritable):
# User don't set gpu configurations, just use cpu
if gpu_per_task is None:
if use_gpu_by_params:
- get_logger("XGBoost-PySpark").warning(
+ get_logger(_LOG_TAG).warning(
"Do the prediction on the CPUs since "
"no gpu configurations are set"
)
@@ -1377,6 +1382,8 @@ class _SparkXGBModel(Model, _SparkXGBParams, MLReadable, MLWritable):
is_local = _is_local(_get_spark_session().sparkContext)
run_on_gpu = self._run_on_gpu()
+ log_level = get_logger_level(_LOG_TAG)
+
@pandas_udf(schema) # type: ignore
def predict_udf(iterator: Iterator[pd.DataFrame]) -> Iterator[pd.Series]:
assert xgb_sklearn_model is not None
@@ -1413,7 +1420,8 @@ class _SparkXGBModel(Model, _SparkXGBParams, MLReadable, MLWritable):
else:
msg = "CUDF or Cupy is unavailable, fallback the inference on the CPUs"
- get_logger("XGBoost-PySpark").info(msg)
+ if context.partitionId() == 0:
+ get_logger(_LOG_TAG, log_level).info(msg)
def to_gpu_if_possible(data: ArrayLike) -> ArrayLike:
"""Move the data to gpu if possible"""
diff --git a/python-package/xgboost/spark/utils.py b/python-package/xgboost/spark/utils.py
index 84333df53..c0a876419 100644
--- a/python-package/xgboost/spark/utils.py
+++ b/python-package/xgboost/spark/utils.py
@@ -8,7 +8,7 @@ import os
import sys
import uuid
from threading import Thread
-from typing import Any, Callable, Dict, Optional, Set, Type
+from typing import Any, Callable, Dict, Optional, Set, Type, Union
import pyspark
from pyspark import BarrierTaskContext, SparkConf, SparkContext, SparkFiles, TaskContext
@@ -98,10 +98,15 @@ def _get_spark_session() -> SparkSession:
return SparkSession.builder.getOrCreate()
-def get_logger(name: str, level: str = "INFO") -> logging.Logger:
+def get_logger(name: str, level: Optional[Union[str, int]] = None) -> logging.Logger:
"""Gets a logger by name, or creates and configures it for the first time."""
logger = logging.getLogger(name)
- logger.setLevel(level)
+ if level is not None:
+ logger.setLevel(level)
+ else:
+ # Default to info if not set.
+ if logger.level == logging.NOTSET:
+ logger.setLevel(logging.INFO)
# If the logger is configured, skip the configure
if not logger.handlers and not logging.getLogger().handlers:
handler = logging.StreamHandler(sys.stderr)
@@ -113,6 +118,12 @@ def get_logger(name: str, level: str = "INFO") -> logging.Logger:
return logger
+def get_logger_level(name: str) -> Optional[int]:
+ """Get the logger level for the given log name"""
+ logger = logging.getLogger(name)
+ return None if logger.level == logging.NOTSET else logger.level
+
+
def _get_max_num_concurrent_tasks(spark_context: SparkContext) -> int:
"""Gets the current max number of concurrent tasks."""
# pylint: disable=protected-access
diff --git a/python-package/xgboost/testing/__init__.py b/python-package/xgboost/testing/__init__.py
index 389066f0e..f7d9510fa 100644
--- a/python-package/xgboost/testing/__init__.py
+++ b/python-package/xgboost/testing/__init__.py
@@ -815,10 +815,15 @@ def softprob_obj(
return objective
-def ls_obj(y_true: np.ndarray, y_pred: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+def ls_obj(
+ y_true: np.ndarray, y_pred: np.ndarray, sample_weight: Optional[np.ndarray] = None
+) -> Tuple[np.ndarray, np.ndarray]:
"""Least squared error."""
grad = y_pred - y_true
hess = np.ones(len(y_true))
+ if sample_weight is not None:
+ grad *= sample_weight
+ hess *= sample_weight
return grad, hess
diff --git a/python-package/xgboost/testing/ranking.py b/python-package/xgboost/testing/ranking.py
index a11eb3e03..72cf37aeb 100644
--- a/python-package/xgboost/testing/ranking.py
+++ b/python-package/xgboost/testing/ranking.py
@@ -100,3 +100,21 @@ def run_ranking_categorical(device: str) -> None:
scores = cross_val_score(ltr, X, y)
for s in scores:
assert s > 0.7
+
+
+def run_normalization(device: str) -> None:
+ """Test normalization."""
+ X, y, qid, _ = tm.make_ltr(2048, 4, 64, 3)
+ ltr = xgb.XGBRanker(objective="rank:pairwise", n_estimators=4, device=device)
+ ltr.fit(X, y, qid=qid, eval_set=[(X, y)], eval_qid=[qid])
+ e0 = ltr.evals_result()
+
+ ltr = xgb.XGBRanker(
+ objective="rank:pairwise",
+ n_estimators=4,
+ device=device,
+ lambdarank_normalization=False,
+ )
+ ltr.fit(X, y, qid=qid, eval_set=[(X, y)], eval_qid=[qid])
+ e1 = ltr.evals_result()
+ assert e1["validation_0"]["ndcg@32"][-1] > e0["validation_0"]["ndcg@32"][-1]
diff --git a/src/collective/aggregator.h b/src/collective/aggregator.h
index f2a9ff528..8a5b31c36 100644
--- a/src/collective/aggregator.h
+++ b/src/collective/aggregator.h
@@ -1,22 +1,21 @@
/**
- * Copyright 2023 by XGBoost contributors
+ * Copyright 2023-2024, XGBoost contributors
*
* Higher level functions built on top the Communicator API, taking care of behavioral differences
* between row-split vs column-split distributed training, and horizontal vs vertical federated
* learning.
*/
#pragma once
-#include
-
#include
#include
#include
#include
#include "communicator-inl.h"
+#include "xgboost/collective/result.h" // for Result
+#include "xgboost/data.h" // for MetaINfo
-namespace xgboost {
-namespace collective {
+namespace xgboost::collective {
/**
* @brief Apply the given function where the labels are.
@@ -31,15 +30,16 @@ namespace collective {
* @param size The size of the buffer.
* @param function The function used to calculate the results.
*/
-template
-void ApplyWithLabels(MetaInfo const& info, void* buffer, size_t size, Function&& function) {
+template
+void ApplyWithLabels(Context const*, MetaInfo const& info, void* buffer, std::size_t size,
+ FN&& function) {
if (info.IsVerticalFederated()) {
// We assume labels are only available on worker 0, so the calculation is done there and result
// broadcast to other workers.
std::string message;
if (collective::GetRank() == 0) {
try {
- std::forward(function)();
+ std::forward(function)();
} catch (dmlc::Error& e) {
message = e.what();
}
@@ -52,7 +52,7 @@ void ApplyWithLabels(MetaInfo const& info, void* buffer, size_t size, Function&&
LOG(FATAL) << &message[0];
}
} else {
- std::forward(function)();
+ std::forward(function)();
}
}
@@ -70,7 +70,8 @@ void ApplyWithLabels(MetaInfo const& info, void* buffer, size_t size, Function&&
* @param function The function used to calculate the results.
*/
template
-void ApplyWithLabels(MetaInfo const& info, HostDeviceVector* result, Function&& function) {
+void ApplyWithLabels(Context const*, MetaInfo const& info, HostDeviceVector* result,
+ Function&& function) {
if (info.IsVerticalFederated()) {
// We assume labels are only available on worker 0, so the calculation is done there and result
// broadcast to other workers.
@@ -114,7 +115,9 @@ void ApplyWithLabels(MetaInfo const& info, HostDeviceVector* result, Function
* @return The global max of the input.
*/
template
-T GlobalMax(MetaInfo const& info, T value) {
+std::enable_if_t, T> GlobalMax(Context const*,
+ MetaInfo const& info,
+ T value) {
if (info.IsRowSplit()) {
collective::Allreduce(&value, 1);
}
@@ -132,16 +135,18 @@ T GlobalMax(MetaInfo const& info, T value) {
* @param values Pointer to the inputs to sum.
* @param size Number of values to sum.
*/
-template
-void GlobalSum(MetaInfo const& info, T* values, size_t size) {
+template
+[[nodiscard]] Result GlobalSum(Context const*, MetaInfo const& info,
+ linalg::TensorView values) {
if (info.IsRowSplit()) {
- collective::Allreduce(values, size);
+ collective::Allreduce(values.Values().data(), values.Size());
}
+ return Success();
}
template
-void GlobalSum(MetaInfo const& info, Container* values) {
- GlobalSum(info, values->data(), values->size());
+[[nodiscard]] Result GlobalSum(Context const* ctx, MetaInfo const& info, Container* values) {
+ return GlobalSum(ctx, info, values->data(), values->size());
}
/**
@@ -157,9 +162,10 @@ void GlobalSum(MetaInfo const& info, Container* values) {
* @return The global ratio of the two inputs.
*/
template
-T GlobalRatio(MetaInfo const& info, T dividend, T divisor) {
+T GlobalRatio(Context const* ctx, MetaInfo const& info, T dividend, T divisor) {
std::array results{dividend, divisor};
- GlobalSum(info, &results);
+ auto rc = GlobalSum(ctx, info, linalg::MakeVec(results.data(), results.size()));
+ collective::SafeColl(rc);
std::tie(dividend, divisor) = std::tuple_cat(results);
if (divisor <= 0) {
return std::numeric_limits::quiet_NaN();
@@ -167,6 +173,4 @@ T GlobalRatio(MetaInfo const& info, T dividend, T divisor) {
return dividend / divisor;
}
}
-
-} // namespace collective
-} // namespace xgboost
+} // namespace xgboost::collective
diff --git a/src/collective/communicator-inl.cc b/src/collective/communicator-inl.cc
new file mode 100644
index 000000000..4164855f1
--- /dev/null
+++ b/src/collective/communicator-inl.cc
@@ -0,0 +1,34 @@
+/**
+ * Copyright 2024, XGBoost contributors
+ */
+#include "communicator-inl.h"
+
+namespace xgboost::collective {
+[[nodiscard]] std::vector> VectorAllgatherV(
+ std::vector> const &input) {
+ auto n_inputs = input.size();
+ std::vector sizes(n_inputs);
+ std::transform(input.cbegin(), input.cend(), sizes.begin(),
+ [](auto const &vec) { return vec.size(); });
+
+ std::vector global_sizes = AllgatherV(sizes);
+ std::vector offset(global_sizes.size() + 1);
+ offset[0] = 0;
+ for (std::size_t i = 1; i < offset.size(); i++) {
+ offset[i] = offset[i - 1] + global_sizes[i - 1];
+ }
+
+ std::vector collected;
+ for (auto const &vec : input) {
+ collected.insert(collected.end(), vec.cbegin(), vec.cend());
+ }
+ auto out = AllgatherV(collected);
+
+ std::vector> result;
+ for (std::size_t i = 1; i < offset.size(); ++i) {
+ std::vector local(out.cbegin() + offset[i - 1], out.cbegin() + offset[i]);
+ result.emplace_back(std::move(local));
+ }
+ return result;
+}
+} // namespace xgboost::collective
diff --git a/src/collective/communicator-inl.h b/src/collective/communicator-inl.h
index 34212def2..991e19f2c 100644
--- a/src/collective/communicator-inl.h
+++ b/src/collective/communicator-inl.h
@@ -1,5 +1,5 @@
/**
- * Copyright 2022-2023 by XGBoost contributors
+ * Copyright 2022-2024, XGBoost contributors
*/
#pragma once
#include
@@ -192,6 +192,18 @@ inline std::vector AllgatherV(std::vector const &input) {
return result;
}
+/**
+ * @brief Gathers variable-length data from all processes and distributes it to all processes.
+ *
+ * @param inputs All the inputs from the local worker. The number of inputs can vary
+ * across different workers. Along with which, the size of each vector in
+ * the input can also vary.
+ *
+ * @return The AllgatherV result, containing vectors from all workers.
+ */
+[[nodiscard]] std::vector> VectorAllgatherV(
+ std::vector> const &input);
+
/**
* @brief Gathers variable-length strings from all processes and distributes them to all processes.
* @param input Variable-length list of variable-length strings.
@@ -294,38 +306,5 @@ template
inline void Allreduce(double *send_receive_buffer, size_t count) {
Communicator::Get()->AllReduce(send_receive_buffer, count, DataType::kDouble, op);
}
-
-template
-struct SpecialAllgatherVResult {
- std::vector offsets;
- std::vector sizes;
- std::vector result;
-};
-
-/**
- * @brief Gathers variable-length data from all processes and distributes it to all processes.
- *
- * We assume each worker has the same number of inputs, but each input may be of a different size.
- *
- * @param inputs All the inputs from the local worker.
- * @param sizes Sizes of each input.
- */
-template
-inline SpecialAllgatherVResult SpecialAllgatherV(std::vector const &inputs,
- std::vector const &sizes) {
- // Gather the sizes across all workers.
- auto const all_sizes = Allgather(sizes);
-
- // Calculate input offsets (std::exclusive_scan).
- std::vector offsets(all_sizes.size());
- for (std::size_t i = 1; i < offsets.size(); i++) {
- offsets[i] = offsets[i - 1] + all_sizes[i - 1];
- }
-
- // Gather all the inputs.
- auto const all_inputs = AllgatherV(inputs);
-
- return {offsets, all_sizes, all_inputs};
-}
} // namespace collective
} // namespace xgboost
diff --git a/src/common/json.cc b/src/common/json.cc
index de9a89f78..2887eeccf 100644
--- a/src/common/json.cc
+++ b/src/common/json.cc
@@ -1,11 +1,12 @@
/**
- * Copyright 2019-2023, XGBoost Contributors
+ * Copyright 2019-2024, XGBoost Contributors
*/
#include "xgboost/json.h"
#include // for array
#include // for isdigit
#include // for isinf, isnan
+#include // for uint8_t, uint16_t, uint32_t
#include // for EOF
#include // for size_t, strtof
#include // for memcpy
@@ -72,15 +73,16 @@ void JsonWriter::Visit(JsonNumber const* num) {
}
void JsonWriter::Visit(JsonInteger const* num) {
- char i2s_buffer_[NumericLimits::kToCharsSize];
+ std::array::kToCharsSize> i2s_buffer_;
auto i = num->GetInteger();
- auto ret = to_chars(i2s_buffer_, i2s_buffer_ + NumericLimits::kToCharsSize, i);
+ auto ret =
+ to_chars(i2s_buffer_.data(), i2s_buffer_.data() + NumericLimits::kToCharsSize, i);
auto end = ret.ptr;
CHECK(ret.ec == std::errc());
- auto digits = std::distance(i2s_buffer_, end);
+ auto digits = std::distance(i2s_buffer_.data(), end);
auto ori_size = stream_->size();
stream_->resize(ori_size + digits);
- std::memcpy(stream_->data() + ori_size, i2s_buffer_, digits);
+ std::memcpy(stream_->data() + ori_size, i2s_buffer_.data(), digits);
}
void JsonWriter::Visit(JsonNull const* ) {
@@ -143,8 +145,10 @@ std::string Value::TypeStr() const {
return "Null";
case ValueKind::kInteger:
return "Integer";
- case ValueKind::kNumberArray:
+ case ValueKind::kF32Array:
return "F32Array";
+ case ValueKind::kF64Array:
+ return "F64Array";
case ValueKind::kU8Array:
return "U8Array";
case ValueKind::kI32Array:
@@ -262,10 +266,11 @@ bool JsonTypedArray::operator==(Value const& rhs) const {
return std::equal(arr.cbegin(), arr.cend(), vec_.cbegin());
}
-template class JsonTypedArray;
-template class JsonTypedArray;
-template class JsonTypedArray;
-template class JsonTypedArray;
+template class JsonTypedArray;
+template class JsonTypedArray;
+template class JsonTypedArray;
+template class JsonTypedArray;
+template class JsonTypedArray;
// Json Number
bool JsonNumber::operator==(Value const& rhs) const {
@@ -708,6 +713,8 @@ Json UBJReader::ParseArray() {
switch (type) {
case 'd':
return ParseTypedArray(n);
+ case 'D':
+ return ParseTypedArray(n);
case 'U':
return ParseTypedArray(n);
case 'l':
@@ -791,12 +798,16 @@ Json UBJReader::Parse() {
return Json{JsonBoolean{true}};
}
case 'F': {
- return Json{JsonBoolean{true}};
+ return Json{JsonBoolean{false}};
}
case 'd': {
auto v = this->ReadPrimitive();
return Json{v};
}
+ case 'D': {
+ auto v = this->ReadPrimitive();
+ return Json{v};
+ }
case 'S': {
auto str = this->DecodeStr();
return Json{str};
@@ -825,10 +836,6 @@ Json UBJReader::Parse() {
Integer::Int i = this->ReadPrimitive();
return Json{i};
}
- case 'D': {
- LOG(FATAL) << "f64 is not supported.";
- break;
- }
case 'H': {
LOG(FATAL) << "High precision number is not supported.";
break;
@@ -882,6 +889,8 @@ void WriteTypedArray(JsonTypedArray const* arr, std::vector* stre
stream->push_back('$');
if (std::is_same::value) {
stream->push_back('d');
+ } else if (std::is_same_v) {
+ stream->push_back('D');
} else if (std::is_same::value) {
stream->push_back('i');
} else if (std::is_same::value) {
@@ -910,6 +919,7 @@ void WriteTypedArray(JsonTypedArray const* arr, std::vector* stre
}
void UBJWriter::Visit(F32Array const* arr) { WriteTypedArray(arr, stream_); }
+void UBJWriter::Visit(F64Array const* arr) { WriteTypedArray(arr, stream_); }
void UBJWriter::Visit(U8Array const* arr) { WriteTypedArray(arr, stream_); }
void UBJWriter::Visit(I32Array const* arr) { WriteTypedArray(arr, stream_); }
void UBJWriter::Visit(I64Array const* arr) { WriteTypedArray(arr, stream_); }
diff --git a/src/common/linalg_op.cuh b/src/common/linalg_op.cuh
index 74cee3757..21fad2dc0 100644
--- a/src/common/linalg_op.cuh
+++ b/src/common/linalg_op.cuh
@@ -13,15 +13,14 @@
#include "xgboost/context.h" // for Context
#include "xgboost/linalg.h" // for TensorView
-namespace xgboost {
-namespace linalg {
+namespace xgboost::linalg {
namespace cuda_impl {
// Use template specialization to dispatch, Windows + CUDA 11.8 doesn't support extended
// lambda inside constexpr if
template
struct ElementWiseImpl {
template
- void operator()(linalg::TensorView t, Fn&& fn, cudaStream_t s) {
+ void operator()(TensorView t, Fn&& fn, cudaStream_t s) {
static_assert(D > 1);
dh::LaunchN(t.Size(), s, [=] __device__(std::size_t i) mutable {
std::apply(fn, linalg::UnravelIndex(i, t.Shape()));
@@ -32,37 +31,59 @@ struct ElementWiseImpl {
template
struct ElementWiseImpl {
template
- void operator()(linalg::TensorView t, Fn&& fn, cudaStream_t s) {
+ void operator()(TensorView t, Fn&& fn, cudaStream_t s) {
dh::LaunchN(t.Size(), s, [=] __device__(std::size_t i) { fn(i); });
}
};
template
-void ElementWiseKernel(linalg::TensorView t, Fn&& fn, cudaStream_t s = nullptr) {
+void ElementWiseKernel(TensorView t, Fn&& fn, cudaStream_t s = nullptr) {
dh::safe_cuda(cudaSetDevice(t.Device().ordinal));
cuda_impl::ElementWiseImpl{}(t, fn, s);
}
} // namespace cuda_impl
template
-void ElementWiseTransformDevice(linalg::TensorView t, Fn&& fn, cudaStream_t s = nullptr)
-{
+void ElementWiseTransformDevice(TensorView t, Fn&& fn, cudaStream_t s = nullptr) {
if (t.Contiguous()) {
auto ptr = t.Values().data();
dh::LaunchN(t.Size(), s, [=] __device__(size_t i) { ptr[i] = fn(i, ptr[i]); });
} else {
dh::LaunchN(t.Size(), s, [=] __device__(size_t i) mutable {
- T& v = detail::Apply(t, linalg::UnravelIndex(i, t.Shape()));
+ T& v = detail::Apply(t, UnravelIndex(i, t.Shape()));
v = fn(i, v);
});
}
}
template
-void ElementWiseKernel(Context const* ctx, linalg::TensorView t, Fn&& fn) {
+void ElementWiseKernel(Context const* ctx, TensorView t, Fn&& fn) {
ctx->IsCUDA() ? cuda_impl::ElementWiseKernel(t, fn)
: ElementWiseKernelHost(t, ctx->Threads(), fn);
}
-} // namespace linalg
-} // namespace xgboost
+
+namespace detail {
+template
+struct IterOp {
+ TensorView v;
+ XGBOOST_DEVICE T& operator()(std::size_t i) {
+ return detail::Apply(v, UnravelIndex(i, v.Shape()));
+ }
+};
+} // namespace detail
+
+// naming: thrust begin
+// returns a thrust iterator for a tensor view.
+template
+auto tcbegin(TensorView v) { // NOLINT
+ return dh::MakeTransformIterator(
+ thrust::make_counting_iterator(0ul),
+ detail::IterOp>, kDim>{v});
+}
+
+template
+auto tcend(TensorView v) { // NOLINT
+ return tcbegin(v) + v.Size();
+}
+} // namespace xgboost::linalg
#endif // XGBOOST_COMMON_LINALG_OP_CUH_
diff --git a/src/common/quantile.cc b/src/common/quantile.cc
index c74db99e4..e521fae69 100644
--- a/src/common/quantile.cc
+++ b/src/common/quantile.cc
@@ -1,5 +1,5 @@
-/*!
- * Copyright 2020-2022 by XGBoost Contributors
+/**
+ * Copyright 2020-2024, XGBoost Contributors
*/
#include "quantile.h"
@@ -145,7 +145,7 @@ struct QuantileAllreduce {
template
void SketchContainerImpl::GatherSketchInfo(
- Context const *, MetaInfo const &info,
+ Context const *ctx, MetaInfo const &info,
std::vector const &reduced,
std::vector *p_worker_segments, std::vector *p_sketches_scan,
std::vector *p_global_sketches) {
@@ -171,7 +171,9 @@ void SketchContainerImpl::GatherSketchInfo(
std::partial_sum(sketch_size.cbegin(), sketch_size.cend(), sketches_scan.begin() + beg_scan + 1);
// Gather all column pointers
- collective::GlobalSum(info, sketches_scan.data(), sketches_scan.size());
+ auto rc =
+ collective::GlobalSum(ctx, info, linalg::MakeVec(sketches_scan.data(), sketches_scan.size()));
+ collective::SafeColl(rc);
for (int32_t i = 0; i < world; ++i) {
size_t back = (i + 1) * (n_columns + 1) - 1;
auto n_entries = sketches_scan.at(back);
@@ -199,14 +201,15 @@ void SketchContainerImpl::GatherSketchInfo(
static_assert(sizeof(typename WQSketch::Entry) / 4 == sizeof(float),
"Unexpected size of sketch entry.");
- collective::GlobalSum(
- info,
- reinterpret_cast(global_sketches.data()),
- global_sketches.size() * sizeof(typename WQSketch::Entry) / sizeof(float));
+ rc = collective::GlobalSum(
+ ctx, info,
+ linalg::MakeVec(reinterpret_cast(global_sketches.data()),
+ global_sketches.size() * sizeof(typename WQSketch::Entry) / sizeof(float)));
+ collective::SafeColl(rc);
}
template
-void SketchContainerImpl::AllreduceCategories(Context const*, MetaInfo const& info) {
+void SketchContainerImpl::AllreduceCategories(Context const* ctx, MetaInfo const& info) {
auto world_size = collective::GetWorldSize();
auto rank = collective::GetRank();
if (world_size == 1 || info.IsColumnSplit()) {
@@ -226,7 +229,8 @@ void SketchContainerImpl::AllreduceCategories(Context const*, MetaInfo
std::vector global_feat_ptrs(feature_ptr.size() * world_size, 0);
size_t feat_begin = rank * feature_ptr.size(); // pointer to current worker
std::copy(feature_ptr.begin(), feature_ptr.end(), global_feat_ptrs.begin() + feat_begin);
- collective::GlobalSum(info, global_feat_ptrs.data(), global_feat_ptrs.size());
+ auto rc = collective::GlobalSum(
+ ctx, info, linalg::MakeVec(global_feat_ptrs.data(), global_feat_ptrs.size()));
// move all categories into a flatten vector to prepare for allreduce
size_t total = feature_ptr.back();
@@ -239,7 +243,8 @@ void SketchContainerImpl::AllreduceCategories(Context const*, MetaInfo
// indptr for indexing workers
std::vector global_worker_ptr(world_size + 1, 0);
global_worker_ptr[rank + 1] = total; // shift 1 to right for constructing the indptr
- collective::GlobalSum(info, global_worker_ptr.data(), global_worker_ptr.size());
+ rc = collective::GlobalSum(ctx, info,
+ linalg::MakeVec(global_worker_ptr.data(), global_worker_ptr.size()));
std::partial_sum(global_worker_ptr.cbegin(), global_worker_ptr.cend(), global_worker_ptr.begin());
// total number of categories in all workers with all features
auto gtotal = global_worker_ptr.back();
@@ -251,7 +256,8 @@ void SketchContainerImpl::AllreduceCategories(Context const*, MetaInfo
CHECK_EQ(rank_size, total);
std::copy(flatten.cbegin(), flatten.cend(), global_categories.begin() + rank_begin);
// gather values from all workers.
- collective::GlobalSum(info, global_categories.data(), global_categories.size());
+ rc = collective::GlobalSum(ctx, info,
+ linalg::MakeVec(global_categories.data(), global_categories.size()));
QuantileAllreduce allreduce_result{global_categories, global_worker_ptr, global_feat_ptrs,
categories_.size()};
ParallelFor(categories_.size(), n_threads_, [&](auto fidx) {
@@ -293,7 +299,9 @@ void SketchContainerImpl