[R package] GPU support (#2732)

* [R] MSVC compatibility

* [GPU] allow seed in BernoulliRng up to size_t and scale to uint32_t

* R package build with cmake and CUDA

* R package CUDA build fixes and cleanups

* always export the R package native initialization routine on windows

* update the install instructions doc

* fix lint

* use static_cast directly to set BernoulliRng seed

* [R] demo for GPU accelerated algorithm

* tidy up the R package cmake stuff

* R pack cmake: installs main dependency packages if needed

* [R] version bump in DESCRIPTION

* update NEWS

* added short missing/sparse values explanations to FAQ

R-package/DESCRIPTION

@@ -1,8 +1,8 @@
 Package: xgboost
 Type: Package
 Title: Extreme Gradient Boosting
-Version: 0.6.4.6
-Date: 2017-01-04
+Version: 0.6.4.7
+Date: 2017-09-25
 Author: Tianqi Chen <tianqi.tchen@gmail.com>, Tong He <hetong007@gmail.com>,
     Michael Benesty <michael@benesty.fr>, Vadim Khotilovich <khotilovich@gmail.com>,
     Yuan Tang <terrytangyuan@gmail.com>

R-package/demo/00Index

@@ -10,3 +10,4 @@ predict_leaf_indices            Predicting the corresponding leaves
 early_stopping                  Early Stop in training
 poisson_regression              Poisson Regression on count data
 tweedie_regression              Tweddie Regression
+gpu_accelerated                 GPU-accelerated tree building algorithms

R-package/demo/README.md

@@ -8,6 +8,7 @@ XGBoost R Feature Walkthrough
 * [Generalized Linear Model](generalized_linear_model.R)
 * [Cross validation](cross_validation.R)
 * [Create a sparse matrix from a dense one](create_sparse_matrix.R)
+* [Use GPU-accelerated tree building algorithms](gpu_accelerated.R)
 
 Benchmarks
 ====

R-package/demo/gpu_accelerated.R

@@ -0,0 +1,45 @@
+# An example of using GPU-accelerated tree building algorithms
+# 
+# NOTE: it can only run if you have a CUDA-enable GPU and the package was 
+#       specially compiled with GPU support.
+#
+# For the current functionality, see 
+# https://xgboost.readthedocs.io/en/latest/gpu/index.html
+#
+
+library('xgboost')
+
+# Simulate N x p random matrix with some binomial response dependent on pp columns
+set.seed(111)
+N <- 1000000
+p <- 50
+pp <- 25
+X <- matrix(runif(N * p), ncol = p)
+betas <- 2 * runif(pp) - 1
+sel <- sort(sample(p, pp))
+m <- X[, sel] %*% betas - 1 + rnorm(N)
+y <- rbinom(N, 1, plogis(m))
+
+tr <- sample.int(N, N * 0.75)
+dtrain <- xgb.DMatrix(X[tr,], label = y[tr])
+dtest <- xgb.DMatrix(X[-tr,], label = y[-tr])
+wl <- list(train = dtrain, test = dtest)
+
+# An example of running 'gpu_hist' algorithm
+# which is
+# - similar to the 'hist'
+# - the fastest option for moderately large datasets
+# - current limitations: max_depth < 16, does not implement guided loss
+# You can use tree_method = 'gpu_exact' for another GPU accelerated algorithm,
+# which is slower, more memory-hungry, but does not use binning.
+param <- list(objective = 'reg:logistic', eval_metric = 'auc', subsample = 0.5, nthread = 4,
+              max_bin = 64, tree_method = 'gpu_hist')
+pt <- proc.time()
+bst_gpu <- xgb.train(param, dtrain, watchlist = wl, nrounds = 50)
+proc.time() - pt
+
+# Compare to the 'hist' algorithm:
+param$tree_method <- 'hist'
+pt <- proc.time()
+bst_hist <- xgb.train(param, dtrain, watchlist = wl, nrounds = 50)
+proc.time() - pt

R-package/demo/runall.R

@@ -10,4 +10,5 @@ demo(predict_leaf_indices)
 demo(early_stopping)
 demo(poisson_regression)
 demo(caret_wrapper)
-demo(tweedie_regression)
+demo(tweedie_regression)
+#demo(gpu_accelerated) # can only run when built with GPU support

R-package/src/init.c

@@ -68,6 +68,9 @@ static const R_CallMethodDef CallEntries[] = {
   {NULL, NULL, 0}
 };
 
+#if defined(_WIN32)
+__declspec(dllexport)
+#endif
 void R_init_xgboost(DllInfo *dll) {
   R_registerRoutines(dll, NULL, CallEntries, NULL, NULL);
   R_useDynamicSymbols(dll, FALSE);

R-package/src/xgboost_R.cc

@@ -112,7 +112,7 @@ SEXP XGDMatrixCreateFromCSC_R(SEXP indptr,
     col_ptr_[i] = static_cast<size_t>(p_indptr[i]);
   }
   #pragma omp parallel for schedule(static)
-  for (size_t i = 0; i < ndata; ++i) {
+  for (int64_t i = 0; i < static_cast<int64_t>(ndata); ++i) {
     indices_[i] = static_cast<unsigned>(p_indices[i]);
     data_[i] = static_cast<float>(p_data[i]);
   }