fix additional files note (#4699)

* fix additional files note

* Trigger CI

* Trigger CI

.clang-tidy

@@ -1,4 +1,4 @@
-Checks: 'modernize-*,-modernize-make-*,-modernize-raw-string-literal,google-*,-google-default-arguments,-clang-diagnostic-#pragma-messages,readability-identifier-naming'
+Checks: 'modernize-*,-modernize-make-*,-modernize-use-auto,-modernize-raw-string-literal,google-*,-google-default-arguments,-clang-diagnostic-#pragma-messages,readability-identifier-naming'
 CheckOptions:
   - { key: readability-identifier-naming.ClassCase,           value: CamelCase  }
   - { key: readability-identifier-naming.StructCase,          value: CamelCase  }
@@ -6,8 +6,8 @@ CheckOptions:
   - { key: readability-identifier-naming.TypedefCase,          value: CamelCase  }
   - { key: readability-identifier-naming.TypeTemplateParameterCase,          value: CamelCase  }
   - { key: readability-identifier-naming.MemberCase,          value: lower_case  }
-  - { key: readability-identifier-naming.PrivateMemberSuffix,           value: '_'  }
-  - { key: readability-identifier-naming.ProtectedMemberSuffix,           value: '_'  }
+  - { key: readability-identifier-naming.PrivateMemberSuffix,    value: '_'  }
+  - { key: readability-identifier-naming.ProtectedMemberSuffix,  value: '_'  }
   - { key: readability-identifier-naming.EnumCase,          value: CamelCase  }
   - { key: readability-identifier-naming.EnumConstant,          value: CamelCase  }
   - { key: readability-identifier-naming.EnumConstantPrefix,          value: k  }

.gitignore

@@ -91,3 +91,8 @@ lib/
 metastore_db
 
 plugin/updater_gpu/test/cpp/data
+/include/xgboost/build_config.h
+
+# files from R-package source install
+**/config.status
+R-package/src/Makevars

.travis.yml

@@ -3,71 +3,30 @@ sudo: required
 
 # Enabling test on Linux and OS X
 os:
-  - linux
   - osx
 
-osx_image: xcode8
-
-group: deprecated-2017Q4
+osx_image: xcode9.3
 
 # Use Build Matrix to do lint and build seperately
 env:
   matrix:
-    # code lint
-    - TASK=lint
-    # r package test
-    - TASK=r_test
     # python package test
     - TASK=python_test
-    - TASK=python_lightweight_test
     # java package test
     - TASK=java_test
     # cmake test
-    - TASK=cmake_test
-    # c++ test
-    - TASK=cpp_test
-    # distributed test
-    - TASK=distributed_test
-    # address sanitizer test
-    - TASK=sanitizer_test
-
-matrix:
-  exclude:
-    - os: osx
-      env: TASK=lint
-    - os: osx
-      env: TASK=cmake_test
-    - os: linux
-      env: TASK=r_test
-    - os: osx
-      env: TASK=python_lightweight_test
-    - os: osx
-      env: TASK=cpp_test
-    - os: osx
-      env: TASK=distributed_test
-    - os: osx
-      env: TASK=sanitizer_test
+    # - TASK=cmake_test
 
 # dependent apt packages
 addons:
-  apt:
-    sources:
-      - llvm-toolchain-trusty-5.0
-      - ubuntu-toolchain-r-test
-      - george-edison55-precise-backports
+  homebrew:
     packages:
-      - clang
-      - clang-tidy-5.0
-      - cmake-data
-      - doxygen
-      - wget
-      - libcurl4-openssl-dev
-      - unzip
+      - gcc@7
       - graphviz
-      - gcc-4.8
-      - g++-4.8
-      - gcc-7
-      - g++-7
+      - openssl
+      - libgit2
+      - r
+    update: true
 
 before_install:
   - source dmlc-core/scripts/travis/travis_setup_env.sh

CMakeLists.txt

@@ -1,264 +1,229 @@
-cmake_minimum_required (VERSION 3.2)
-project(xgboost)
+cmake_minimum_required(VERSION 3.3)
+project(xgboost LANGUAGES CXX C VERSION 0.90)
 include(cmake/Utils.cmake)
 list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake/modules")
-find_package(OpenMP)
+cmake_policy(SET CMP0022 NEW)
+
+message(STATUS "CMake version ${CMAKE_VERSION}")
+if (MSVC)
+  cmake_minimum_required(VERSION 3.11)
+endif (MSVC)
 
 set_default_configuration_release()
-msvc_use_static_runtime()
 
-# Options
-option(USE_CUDA  "Build with GPU acceleration")
+#-- Options
+option(BUILD_C_DOC "Build documentation for C APIs using Doxygen." OFF)
+option(USE_OPENMP "Build with OpenMP support." ON)
+## Bindings
 option(JVM_BINDINGS "Build JVM bindings" OFF)
-option(GOOGLE_TEST "Build google tests" OFF)
 option(R_LIB "Build shared library for R package" OFF)
+## Dev
+option(GOOGLE_TEST "Build google tests" OFF)
+option(USE_DMLC_GTEST "Use google tests bundled with dmlc-core submodule (EXPERIMENTAL)" OFF)
+option(USE_NVTX "Build with cuda profiling annotations. Developers only." OFF)
+set(NVTX_HEADER_DIR "" CACHE PATH "Path to the stand-alone nvtx header")
+## CUDA
+option(USE_CUDA  "Build with GPU acceleration" OFF)
+option(USE_NCCL  "Build with NCCL to enable multi-GPU support." OFF)
+option(BUILD_WITH_SHARED_NCCL "Build with shared NCCL library." OFF)
 set(GPU_COMPUTE_VER "" CACHE STRING
-  "Space separated list of compute versions to be built against, e.g. '35 61'")
+  "Semicolon separated list of compute versions to be built against, e.g. '35;61'")
+if (BUILD_WITH_SHARED_NCCL AND (NOT USE_NCCL))
+  message(SEND_ERROR "Build XGBoost with -DUSE_NCCL=ON to enable BUILD_WITH_SHARED_NCCL.")
+endif (BUILD_WITH_SHARED_NCCL AND (NOT USE_NCCL))
+## Sanitizers
 option(USE_SANITIZER "Use santizer flags" OFF)
 option(SANITIZER_PATH "Path to sanitizes.")
 set(ENABLED_SANITIZERS "address" "leak" CACHE STRING
   "Semicolon separated list of sanitizer names. E.g 'address;leak'. Supported sanitizers are
 address, leak and thread.")
-
-# Plugins
+## Plugins
 option(PLUGIN_LZ4 "Build lz4 plugin" OFF)
 option(PLUGIN_DENSE_PARSER "Build dense parser plugin" OFF)
 
-# Deprecation warning
-if(USE_AVX)
+## Deprecation warning
+if (USE_AVX)
   message(WARNING "The option 'USE_AVX' is deprecated as experimental AVX features have been removed from xgboost.")
-endif()
-
-# Compiler flags
-set(CMAKE_CXX_STANDARD 11)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-if(OpenMP_CXX_FOUND OR OPENMP_FOUND)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
-endif()
-set(CMAKE_POSITION_INDEPENDENT_CODE ON)
-if(MSVC)
-  # Multithreaded compilation
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")
-else()
-  # Correct error for GCC 5 and cuda
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_MWAITXINTRIN_H_INCLUDED -D_FORCE_INLINES")
-  # Performance
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -funroll-loops")
-endif()
-if(WIN32 AND MINGW)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static-libstdc++")
-endif()
+endif (USE_AVX)
 
 # Sanitizer
-if(USE_SANITIZER)
+if (USE_SANITIZER)
+  # Older CMake versions have had troubles with Sanitizer
+  cmake_minimum_required(VERSION 3.12)
   include(cmake/Sanitizer.cmake)
   enable_sanitizers("${ENABLED_SANITIZERS}")
-endif(USE_SANITIZER)
+endif (USE_SANITIZER)
+
+if (USE_CUDA)
+  cmake_minimum_required(VERSION 3.12)
+  SET(USE_OPENMP ON CACHE BOOL "CUDA requires OpenMP" FORCE)
+  # `export CXX=' is ignored by CMake CUDA.
+  set(CMAKE_CUDA_HOST_COMPILER ${CMAKE_CXX_COMPILER})
+  message(STATUS "Configured CUDA host compiler: ${CMAKE_CUDA_HOST_COMPILER}")
+
+  enable_language(CUDA)
+  set(GEN_CODE "")
+  format_gencode_flags("${GPU_COMPUTE_VER}" GEN_CODE)
+  message(STATUS "CUDA GEN_CODE: ${GEN_CODE}")
+endif (USE_CUDA)
 
 # dmlc-core
-add_subdirectory(dmlc-core)
-set(LINK_LIBRARIES dmlc rabit)
-
-# enable custom logging
-add_definitions(-DDMLC_LOG_CUSTOMIZE=1)
-
-# compiled code customizations for R package
-if(R_LIB)
-  add_definitions(
-    -DXGBOOST_STRICT_R_MODE=1
-    -DXGBOOST_CUSTOMIZE_GLOBAL_PRNG=1
-    -DDMLC_LOG_BEFORE_THROW=0
-    -DDMLC_DISABLE_STDIN=1
-    -DDMLC_LOG_CUSTOMIZE=1
-    -DRABIT_CUSTOMIZE_MSG_
-    -DRABIT_STRICT_CXX98_
-  )
-endif()
-
-# Gather source files
-include_directories (
-    ${PROJECT_SOURCE_DIR}/include
-    ${PROJECT_SOURCE_DIR}/dmlc-core/include
-    ${PROJECT_SOURCE_DIR}/rabit/include
-)
-
-file(GLOB_RECURSE SOURCES
-    src/*.cc
-    src/*.h
-    include/*.h
-)
-
-# Only add main function for executable target
-list(REMOVE_ITEM SOURCES ${PROJECT_SOURCE_DIR}/src/cli_main.cc)
-
-file(GLOB_RECURSE TEST_SOURCES "tests/cpp/*.cc")
-
-file(GLOB_RECURSE CUDA_SOURCES
-    src/*.cu
-    src/*.cuh
-)
-
-# Add plugins to source files
-if(PLUGIN_LZ4)
-  list(APPEND SOURCES plugin/lz4/sparse_page_lz4_format.cc)
-  link_libraries(lz4)
-endif()
-if(PLUGIN_DENSE_PARSER)
-  list(APPEND SOURCES plugin/dense_parser/dense_libsvm.cc)
-endif()
+msvc_use_static_runtime()
+add_subdirectory(${PROJECT_SOURCE_DIR}/dmlc-core)
+set_target_properties(dmlc PROPERTIES
+  CXX_STANDARD 11
+  CXX_STANDARD_REQUIRED ON
+  POSITION_INDEPENDENT_CODE ON)
+list(APPEND LINKED_LIBRARIES_PRIVATE dmlc)
 
 # rabit
-# TODO: Create rabit cmakelists.txt
-set(RABIT_SOURCES
+# full rabit doesn't build on windows, so we can't import it as subdirectory
+if(MINGW OR R_LIB)
+  set(RABIT_SOURCES
+    rabit/src/engine_empty.cc
+    rabit/src/c_api.cc)
+else ()
+  set(RABIT_SOURCES
     rabit/src/allreduce_base.cc
     rabit/src/allreduce_robust.cc
     rabit/src/engine.cc
-    rabit/src/c_api.cc
-)
-set(RABIT_EMPTY_SOURCES
-    rabit/src/engine_empty.cc
-    rabit/src/c_api.cc
-)
-if(MINGW OR R_LIB)
-  # build a dummy rabit library
-  add_library(rabit STATIC ${RABIT_EMPTY_SOURCES})
-else()
-  add_library(rabit STATIC ${RABIT_SOURCES})
-endif()
+    rabit/src/c_api.cc)
+endif (MINGW OR R_LIB)
+add_library(rabit STATIC ${RABIT_SOURCES})
+target_include_directories(rabit PRIVATE
+  $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/dmlc-core/include>
+  $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/rabit/include/rabit>)
+set_target_properties(rabit
+  PROPERTIES
+  CXX_STANDARD 11
+  CXX_STANDARD_REQUIRED ON
+  POSITION_INDEPENDENT_CODE ON)
+list(APPEND LINKED_LIBRARIES_PRIVATE rabit)
 
-if(USE_CUDA)
-  find_package(CUDA 8.0 REQUIRED)
-  cmake_minimum_required(VERSION 3.5)
+# Exports some R specific definitions and objects
+if (R_LIB)
+  add_subdirectory(${PROJECT_SOURCE_DIR}/R-package)
+endif (R_LIB)
 
-  add_definitions(-DXGBOOST_USE_CUDA)
+# core xgboost
+add_subdirectory(${PROJECT_SOURCE_DIR}/src)
+set(XGBOOST_OBJ_SOURCES "${XGBOOST_OBJ_SOURCES};$<TARGET_OBJECTS:objxgboost>")
 
-  include_directories(cub)
+#-- Shared library
+add_library(xgboost SHARED ${XGBOOST_OBJ_SOURCES} ${PLUGINS_SOURCES})
+target_include_directories(xgboost
+  INTERFACE
+  $<INSTALL_INTERFACE:${CMAKE_INSTALL_PREFIX}/include>
+  $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>)
+target_link_libraries(xgboost PRIVATE ${LINKED_LIBRARIES_PRIVATE})
 
-  if(USE_NCCL)
-    find_package(Nccl REQUIRED)
-    include_directories(${NCCL_INCLUDE_DIR})
-    add_definitions(-DXGBOOST_USE_NCCL)
-  endif()
+# This creates its own shared library `xgboost4j'.
+if (JVM_BINDINGS)
+  add_subdirectory(${PROJECT_SOURCE_DIR}/jvm-packages)
+endif (JVM_BINDINGS)
+#-- End shared library
 
-  set(GENCODE_FLAGS "")
-  format_gencode_flags("${GPU_COMPUTE_VER}" GENCODE_FLAGS)
-  message("cuda architecture flags: ${GENCODE_FLAGS}")
+#-- CLI for xgboost
+add_executable(runxgboost ${PROJECT_SOURCE_DIR}/src/cli_main.cc ${XGBOOST_OBJ_SOURCES})
+# For cli_main.cc only
+if (USE_OPENMP)
+  find_package(OpenMP REQUIRED)
+  target_compile_options(runxgboost PRIVATE ${OpenMP_CXX_FLAGS})
+endif (USE_OPENMP)
+target_include_directories(runxgboost
+  PRIVATE
+  ${PROJECT_SOURCE_DIR}/include
+  ${PROJECT_SOURCE_DIR}/dmlc-core/include
+  ${PROJECT_SOURCE_DIR}/rabit/include)
+target_link_libraries(runxgboost PRIVATE ${LINKED_LIBRARIES_PRIVATE})
+set_target_properties(
+  runxgboost PROPERTIES
+  OUTPUT_NAME xgboost
+  CXX_STANDARD 11
+  CXX_STANDARD_REQUIRED ON)
+#-- End CLI for xgboost
 
-  set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS};--expt-extended-lambda;--expt-relaxed-constexpr;${GENCODE_FLAGS};-lineinfo;")
-  if(NOT MSVC)
-    set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS};-Xcompiler -fPIC; -Xcompiler -Werror; -std=c++11")
-  endif()
+set_output_directory(runxgboost ${PROJECT_SOURCE_DIR})
+set_output_directory(xgboost ${PROJECT_SOURCE_DIR}/lib)
+# Ensure these two targets do not build simultaneously, as they produce outputs with conflicting names
+add_dependencies(xgboost runxgboost)
 
-  cuda_add_library(gpuxgboost ${CUDA_SOURCES} STATIC)
-
-  if(USE_NCCL)
-    link_directories(${NCCL_LIBRARY})
-    target_link_libraries(gpuxgboost ${NCCL_LIB_NAME})
-  endif()
-  list(APPEND LINK_LIBRARIES gpuxgboost)
-endif()
-
-
-# flags and sources for R-package
-if(R_LIB)
-  file(GLOB_RECURSE R_SOURCES
-    R-package/src/*.h
-    R-package/src/*.c
-    R-package/src/*.cc
-  )
-  list(APPEND SOURCES ${R_SOURCES})
-endif()
-
-add_library(objxgboost OBJECT ${SOURCES})
-
-
-# building shared library for R package
-if(R_LIB)
-  find_package(LibR REQUIRED)
-
-  list(APPEND LINK_LIBRARIES "${LIBR_CORE_LIBRARY}")
-  MESSAGE(STATUS "LIBR_CORE_LIBRARY " ${LIBR_CORE_LIBRARY})
-
-  include_directories(
-    "${LIBR_INCLUDE_DIRS}"
-    "${PROJECT_SOURCE_DIR}"
-  )
-
-  # Shared library target for the R package
-  add_library(xgboost SHARED $<TARGET_OBJECTS:objxgboost>)
-  target_link_libraries(xgboost ${LINK_LIBRARIES})
-  # R uses no lib prefix in shared library names of its packages
+#-- Installing XGBoost
+if (R_LIB)
   set_target_properties(xgboost PROPERTIES PREFIX "")
-  if(APPLE)
+  if (APPLE)
     set_target_properties(xgboost PROPERTIES SUFFIX ".so")
-  endif()
-
+  endif (APPLE)
   setup_rpackage_install_target(xgboost ${CMAKE_CURRENT_BINARY_DIR})
-  # use a dummy location for any other remaining installs
   set(CMAKE_INSTALL_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/dummy_inst")
+endif (R_LIB)
+if (MINGW)
+  set_target_properties(xgboost PROPERTIES PREFIX "")
+endif (MINGW)
 
-# main targets: shared library & exe
-else()
-  # Executable
-  add_executable(runxgboost $<TARGET_OBJECTS:objxgboost> src/cli_main.cc)
-  set_target_properties(runxgboost PROPERTIES
-    OUTPUT_NAME xgboost
-  )
-  set_output_directory(runxgboost ${PROJECT_SOURCE_DIR})
-  target_link_libraries(runxgboost ${LINK_LIBRARIES})
+if (BUILD_C_DOC)
+  include(cmake/Doc.cmake)
+  run_doxygen()
+endif (BUILD_C_DOC)
 
-  # Shared library
-  add_library(xgboost SHARED $<TARGET_OBJECTS:objxgboost>)
-  target_link_libraries(xgboost ${LINK_LIBRARIES})
-  set_output_directory(xgboost ${PROJECT_SOURCE_DIR}/lib)
-  if(MINGW)
-    # remove the 'lib' prefix to conform to windows convention for shared library names
-    set_target_properties(xgboost PROPERTIES PREFIX "")
-  endif()
+include(GNUInstallDirs)
+# Exposing only C APIs.
+install(FILES
+  "${PROJECT_SOURCE_DIR}/include/xgboost/c_api.h"
+  DESTINATION
+  include/xgboost/)
 
-  #Ensure these two targets do not build simultaneously, as they produce outputs with conflicting names
-  add_dependencies(xgboost runxgboost)
-endif()
+install(TARGETS xgboost runxgboost
+  EXPORT XGBoostTargets
+  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+  INCLUDES DESTINATION ${LIBLEGACY_INCLUDE_DIRS})
+install(EXPORT XGBoostTargets
+  FILE XGBoostTargets.cmake
+  NAMESPACE xgboost::
+  DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/xgboost)
 
+include(CMakePackageConfigHelpers)
+configure_package_config_file(
+  ${CMAKE_CURRENT_LIST_DIR}/cmake/xgboost-config.cmake.in
+  ${CMAKE_CURRENT_BINARY_DIR}/cmake/xgboost-config.cmake
+  INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/xgboost)
+write_basic_package_version_file(
+  ${CMAKE_BINARY_DIR}/cmake/xgboost-config-version.cmake
+  VERSION ${XGBOOST_VERSION}
+  COMPATIBILITY AnyNewerVersion)
+install(
+  FILES
+  ${CMAKE_BINARY_DIR}/cmake/xgboost-config.cmake
+  ${CMAKE_BINARY_DIR}/cmake/xgboost-config-version.cmake
+  DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/xgboost)
 
-# JVM
-if(JVM_BINDINGS)
-    find_package(JNI QUIET REQUIRED)
-
-    include_directories(${JNI_INCLUDE_DIRS} jvm-packages/xgboost4j/src/native)
-
-    add_library(xgboost4j SHARED
-        $<TARGET_OBJECTS:objxgboost>
-        jvm-packages/xgboost4j/src/native/xgboost4j.cpp)
-    set_output_directory(xgboost4j ${PROJECT_SOURCE_DIR}/lib)
-    target_link_libraries(xgboost4j
-        ${LINK_LIBRARIES}
-        ${JAVA_JVM_LIBRARY})
-endif()
-
-
-# Test
-if(GOOGLE_TEST)
+#-- Test
+if (GOOGLE_TEST)
   enable_testing()
-  find_package(GTest REQUIRED)
+  # Unittests.
+  add_subdirectory(${PROJECT_SOURCE_DIR}/tests/cpp)
+  add_test(
+    NAME TestXGBoostLib
+    COMMAND testxgboost
+    WORKING_DIRECTORY ${PROJECT_BINARY_DIR})
 
-  auto_source_group("${TEST_SOURCES}")
-  include_directories(${GTEST_INCLUDE_DIRS})
+  # CLI tests
+  configure_file(
+    ${PROJECT_SOURCE_DIR}/tests/cli/machine.conf.in
+    ${PROJECT_BINARY_DIR}/tests/cli/machine.conf
+    @ONLY)
+  add_test(
+    NAME TestXGBoostCLI
+    COMMAND runxgboost ${PROJECT_BINARY_DIR}/tests/cli/machine.conf
+    WORKING_DIRECTORY ${PROJECT_BINARY_DIR})
+  set_tests_properties(TestXGBoostCLI
+    PROPERTIES
+    PASS_REGULAR_EXPRESSION ".*test-rmse:0.087.*")
+endif (GOOGLE_TEST)
 
-  if(USE_CUDA)
-    file(GLOB_RECURSE CUDA_TEST_SOURCES "tests/cpp/*.cu")
-    cuda_compile(CUDA_TEST_OBJS ${CUDA_TEST_SOURCES})
-  else()
-    set(CUDA_TEST_OBJS "")
-  endif()
-
-  add_executable(testxgboost ${TEST_SOURCES} ${CUDA_TEST_OBJS} $<TARGET_OBJECTS:objxgboost>)
-  set_output_directory(testxgboost ${PROJECT_SOURCE_DIR})
-  target_link_libraries(testxgboost ${GTEST_LIBRARIES} ${LINK_LIBRARIES})
-
-  add_test(TestXGBoost testxgboost)
-endif()
-
-
-# Group sources
-auto_source_group("${SOURCES}")
+# For MSVC: Call msvc_use_static_runtime() once again to completely
+# replace /MD with /MT. See https://github.com/dmlc/xgboost/issues/4462
+# for issues caused by mixing of /MD and /MT flags
+msvc_use_static_runtime()

CONTRIBUTORS.md

@@ -85,4 +85,7 @@ List of Contributors
 * [Andrew Thia](https://github.com/BlueTea88)
   - Andrew Thia implemented feature interaction constraints
 * [Wei Tian](https://github.com/weitian)
-* [Chen Qin] (https://github.com/chenqin)
+* [Chen Qin](https://github.com/chenqin)
+* [Sam Wilkinson](https://samwilkinson.io)
+* [Matthew Jones](https://github.com/mt-jones)
+* [Jiaxiang Li](https://github.com/JiaxiangBU)

Jenkinsfile

@@ -3,106 +3,343 @@
 // Jenkins pipeline
 // See documents at https://jenkins.io/doc/book/pipeline/jenkinsfile/
 
-import groovy.transform.Field
-
-/* Unrestricted tasks: tasks that do NOT generate artifacts */
-
 // Command to run command inside a docker container
-def dockerRun = 'tests/ci_build/ci_build.sh'
-// Utility functions
-@Field
-def utils
-
-def buildMatrix = [
-    [ "enabled": true,  "os" : "linux", "withGpu": true, "withNccl": true,  "withOmp": true, "pythonVersion": "2.7", "cudaVersion": "9.2", "multiGpu": true],
-    [ "enabled": true,  "os" : "linux", "withGpu": true, "withNccl": true,  "withOmp": true, "pythonVersion": "2.7", "cudaVersion": "9.2" ],
-    [ "enabled": true,  "os" : "linux", "withGpu": true, "withNccl": true,  "withOmp": true, "pythonVersion": "2.7", "cudaVersion": "8.0" ],
-    [ "enabled": true,  "os" : "linux", "withGpu": true, "withNccl": false, "withOmp": true, "pythonVersion": "2.7", "cudaVersion": "8.0" ],
-]
+dockerRun = 'tests/ci_build/ci_build.sh'
 
 pipeline {
-    // Each stage specify its own agent
-    agent none
+  // Each stage specify its own agent
+  agent none
 
-    // Setup common job properties
-    options {
-        ansiColor('xterm')
-        timestamps()
-        timeout(time: 120, unit: 'MINUTES')
-        buildDiscarder(logRotator(numToKeepStr: '10'))
-    }
+  environment {
+    DOCKER_CACHE_REPO = '492475357299.dkr.ecr.us-west-2.amazonaws.com'
+  }
 
-    // Build stages
-    stages {
-        stage('Jenkins: Get sources') {
-            agent {
-                label 'unrestricted'
-            }
-            steps {
-                script {
-                    utils = load('tests/ci_build/jenkins_tools.Groovy')
-                    utils.checkoutSrcs()
-                }
-                stash name: 'srcs', excludes: '.git/'
-                milestone label: 'Sources ready', ordinal: 1
-            }
-        }
-        stage('Jenkins: Build & Test') {
-            steps {
-                script {
-                    parallel (buildMatrix.findAll{it['enabled']}.collectEntries{ c ->
-                        def buildName = utils.getBuildName(c)
-                        utils.buildFactory(buildName, c, false, this.&buildPlatformCmake)
-                    })
-                }
-            }
+  // Setup common job properties
+  options {
+    ansiColor('xterm')
+    timestamps()
+    timeout(time: 120, unit: 'MINUTES')
+    buildDiscarder(logRotator(numToKeepStr: '10'))
+    preserveStashes()
+  }
+
+  // Build stages
+  stages {
+    stage('Jenkins Linux: Get sources') {
+      agent { label 'linux && cpu' }
+      steps {
+        script {
+          checkoutSrcs()
         }
+        stash name: 'srcs'
+        milestone ordinal: 1
+      }
     }
+    stage('Jenkins Linux: Formatting Check') {
+      agent none
+      steps {
+        script {
+          parallel ([
+            'clang-tidy': { ClangTidy() },
+            'lint': { Lint() },
+            'sphinx-doc': { SphinxDoc() },
+            'doxygen': { Doxygen() }
+          ])
+        }
+        milestone ordinal: 2
+      }
+    }
+    stage('Jenkins Linux: Build') {
+      agent none
+      steps {
+        script {
+          parallel ([
+            'build-cpu': { BuildCPU() },
+            'build-gpu-cuda8.0': { BuildCUDA(cuda_version: '8.0') },
+            'build-gpu-cuda9.0': { BuildCUDA(cuda_version: '9.0') },
+            'build-gpu-cuda10.0': { BuildCUDA(cuda_version: '10.0') },
+            'build-gpu-cuda10.1': { BuildCUDA(cuda_version: '10.1') },
+            'build-jvm-packages': { BuildJVMPackages(spark_version: '2.4.3') },
+            'build-jvm-doc': { BuildJVMDoc() }
+          ])
+        }
+        milestone ordinal: 3
+      }
+    }
+    stage('Jenkins Linux: Test') {
+      agent none
+      steps {
+        script {
+          parallel ([
+            'test-python-cpu': { TestPythonCPU() },
+            'test-python-gpu-cuda8.0': { TestPythonGPU(cuda_version: '8.0') },
+            'test-python-gpu-cuda9.0': { TestPythonGPU(cuda_version: '9.0') },
+            'test-python-gpu-cuda10.0': { TestPythonGPU(cuda_version: '10.0') },
+            'test-python-gpu-cuda10.1': { TestPythonGPU(cuda_version: '10.1') },
+            'test-python-mgpu-cuda10.1': { TestPythonGPU(cuda_version: '10.1', multi_gpu: true) },
+            'test-cpp-gpu': { TestCppGPU(cuda_version: '10.1') },
+            'test-cpp-mgpu': { TestCppGPU(cuda_version: '10.1', multi_gpu: true) },
+            'test-jvm-jdk8': { CrossTestJVMwithJDK(jdk_version: '8', spark_version: '2.4.3') },
+            'test-jvm-jdk11': { CrossTestJVMwithJDK(jdk_version: '11') },
+            'test-jvm-jdk12': { CrossTestJVMwithJDK(jdk_version: '12') },
+            'test-r-3.4.4': { TestR(use_r35: false) },
+            'test-r-3.5.3': { TestR(use_r35: true) }
+          ])
+        }
+        milestone ordinal: 4
+      }
+    }
+  }
 }
 
-/**
- * Build platform and test it via cmake.
- */
-def buildPlatformCmake(buildName, conf, nodeReq, dockerTarget) {
-    def opts = utils.cmakeOptions(conf)
-    // Destination dir for artifacts
-    def distDir = "dist/${buildName}"
-    def dockerArgs = ""
-    if (conf["withGpu"]) {
-        dockerArgs = "--build-arg CUDA_VERSION=" + conf["cudaVersion"]
-    }
-    def test_suite = conf["withGpu"] ? (conf["multiGpu"] ? "mgpu" : "gpu") : "cpu"
-    // Build node - this is returned result
-    retry(3) {
-        node(nodeReq) {
-            unstash name: 'srcs'
-            echo """
-            |===== XGBoost CMake build =====
-            |  dockerTarget: ${dockerTarget}
-            |  cmakeOpts   : ${opts}
-            |=========================
-            """.stripMargin('|')
-            // Invoke command inside docker
-            sh """
-            ${dockerRun} ${dockerTarget} ${dockerArgs} tests/ci_build/build_via_cmake.sh ${opts}
-            ${dockerRun} ${dockerTarget} ${dockerArgs} tests/ci_build/test_${test_suite}.sh
-            """
-            if (!conf["multiGpu"]) {
-                sh """
-                ${dockerRun} ${dockerTarget} ${dockerArgs} bash -c "cd python-package; rm -f dist/*; python setup.py bdist_wheel --universal"
-                rm -rf "${distDir}"; mkdir -p "${distDir}/py"
-                cp xgboost "${distDir}"
-                cp -r python-package/dist "${distDir}/py"
-                # Test the wheel for compatibility on a barebones CPU container
-                ${dockerRun} release ${dockerArgs} bash -c " \
-                    pip install --user python-package/dist/xgboost-*-none-any.whl && \
-                    python -m nose -v tests/python"
-                # Test the wheel for compatibility on CUDA 10.0 container
-                ${dockerRun} gpu --build-arg CUDA_VERSION=10.0 bash -c " \
-                    pip install --user python-package/dist/xgboost-*-none-any.whl && \
-                    python -m nose -v --eval-attr='(not slow) and (not mgpu)' tests/python-gpu"
-                """
-            }
-        }
+// check out source code from git
+def checkoutSrcs() {
+  retry(5) {
+    try {
+      timeout(time: 2, unit: 'MINUTES') {
+        checkout scm
+        sh 'git submodule update --init'
+      }
+    } catch (exc) {
+      deleteDir()
+      error "Failed to fetch source codes"
     }
+  }
+}
+
+def ClangTidy() {
+  node('linux && cpu') {
+    unstash name: 'srcs'
+    echo "Running clang-tidy job..."
+    def container_type = "clang_tidy"
+    def docker_binary = "docker"
+    def dockerArgs = "--build-arg CUDA_VERSION=9.2"
+    sh """
+    ${dockerRun} ${container_type} ${docker_binary} ${dockerArgs} tests/ci_build/clang_tidy.sh
+    """
+    deleteDir()
+  }
+}
+
+def Lint() {
+  node('linux && cpu') {
+    unstash name: 'srcs'
+    echo "Running lint..."
+    def container_type = "cpu"
+    def docker_binary = "docker"
+    sh """
+    ${dockerRun} ${container_type} ${docker_binary} make lint
+    """
+    deleteDir()
+  }
+}
+
+def SphinxDoc() {
+  node('linux && cpu') {
+    unstash name: 'srcs'
+    echo "Running sphinx-doc..."
+    def container_type = "cpu"
+    def docker_binary = "docker"
+    def docker_extra_params = "CI_DOCKER_EXTRA_PARAMS_INIT='-e SPHINX_GIT_BRANCH=${BRANCH_NAME}'"
+    sh """#!/bin/bash
+    ${docker_extra_params} ${dockerRun} ${container_type} ${docker_binary} make -C doc html
+    """
+    deleteDir()
+  }
+}
+
+def Doxygen() {
+  node('linux && cpu') {
+    unstash name: 'srcs'
+    echo "Running doxygen..."
+    def container_type = "cpu"
+    def docker_binary = "docker"
+    sh """
+    ${dockerRun} ${container_type} ${docker_binary} tests/ci_build/doxygen.sh ${BRANCH_NAME}
+    """
+    archiveArtifacts artifacts: "build/${BRANCH_NAME}.tar.bz2", allowEmptyArchive: true
+    echo 'Uploading doc...'
+    s3Upload file: "build/${BRANCH_NAME}.tar.bz2", bucket: 'xgboost-docs', acl: 'PublicRead', path: "doxygen/${BRANCH_NAME}.tar.bz2"
+    deleteDir()
+  }
+}
+
+def BuildCPU() {
+  node('linux && cpu') {
+    unstash name: 'srcs'
+    echo "Build CPU"
+    def container_type = "cpu"
+    def docker_binary = "docker"
+    sh """
+    ${dockerRun} ${container_type} ${docker_binary} tests/ci_build/build_via_cmake.sh
+    ${dockerRun} ${container_type} ${docker_binary} build/testxgboost
+    """
+    // Sanitizer test
+    def docker_extra_params = "CI_DOCKER_EXTRA_PARAMS_INIT='-e ASAN_SYMBOLIZER_PATH=/usr/bin/llvm-symbolizer -e ASAN_OPTIONS=symbolize=1 --cap-add SYS_PTRACE'"
+    def docker_args = "--build-arg CMAKE_VERSION=3.12"
+    sh """
+    ${dockerRun} ${container_type} ${docker_binary} ${docker_args} tests/ci_build/build_via_cmake.sh -DUSE_SANITIZER=ON -DENABLED_SANITIZERS="address" \
+      -DCMAKE_BUILD_TYPE=Debug -DSANITIZER_PATH=/usr/lib/x86_64-linux-gnu/
+    ${docker_extra_params} ${dockerRun} ${container_type} ${docker_binary} build/testxgboost
+    """
+    deleteDir()
+  }
+}
+
+def BuildCUDA(args) {
+  node('linux && cpu') {
+    unstash name: 'srcs'
+    echo "Build with CUDA ${args.cuda_version}"
+    def container_type = "gpu_build"
+    def docker_binary = "docker"
+    def docker_args = "--build-arg CUDA_VERSION=${args.cuda_version}"
+    sh """
+    ${dockerRun} ${container_type} ${docker_binary} ${docker_args} tests/ci_build/build_via_cmake.sh -DUSE_CUDA=ON -DUSE_NCCL=ON -DOPEN_MP:BOOL=ON
+    ${dockerRun} ${container_type} ${docker_binary} ${docker_args} bash -c "cd python-package && rm -rf dist/* && python setup.py bdist_wheel --universal"
+    """
+    // Stash wheel for CUDA 8.0 / 9.0 target
+    if (args.cuda_version == '8.0') {
+      echo 'Stashing Python wheel...'
+      stash name: 'xgboost_whl_cuda8', includes: 'python-package/dist/*.whl'
+    } else if (args.cuda_version == '9.0') {
+      echo 'Stashing Python wheel...'
+      stash name: 'xgboost_whl_cuda9', includes: 'python-package/dist/*.whl'
+      archiveArtifacts artifacts: "python-package/dist/*.whl", allowEmptyArchive: true
+      echo 'Stashing C++ test executable (testxgboost)...'
+      stash name: 'xgboost_cpp_tests', includes: 'build/testxgboost'
+    }
+    deleteDir()
+  }
+}
+
+def BuildJVMPackages(args) {
+  node('linux && cpu') {
+    unstash name: 'srcs'
+    echo "Build XGBoost4J-Spark with Spark ${args.spark_version}"
+    def container_type = "jvm"
+    def docker_binary = "docker"
+    // Use only 4 CPU cores
+    def docker_extra_params = "CI_DOCKER_EXTRA_PARAMS_INIT='--cpuset-cpus 0-3'"
+    sh """
+    ${docker_extra_params} ${dockerRun} ${container_type} ${docker_binary} tests/ci_build/build_jvm_packages.sh ${args.spark_version}
+    """
+    echo 'Stashing XGBoost4J JAR...'
+    stash name: 'xgboost4j_jar', includes: 'jvm-packages/xgboost4j/target/*.jar,jvm-packages/xgboost4j-spark/target/*.jar,jvm-packages/xgboost4j-example/target/*.jar'
+    deleteDir()
+  }
+}
+
+def BuildJVMDoc() {
+  node('linux && cpu') {
+    unstash name: 'srcs'
+    echo "Building JVM doc..."
+    def container_type = "jvm"
+    def docker_binary = "docker"
+    sh """
+    ${dockerRun} ${container_type} ${docker_binary} tests/ci_build/build_jvm_doc.sh ${BRANCH_NAME}
+    """
+    archiveArtifacts artifacts: "jvm-packages/${BRANCH_NAME}.tar.bz2", allowEmptyArchive: true
+    echo 'Uploading doc...'
+    s3Upload file: "jvm-packages/${BRANCH_NAME}.tar.bz2", bucket: 'xgboost-docs', acl: 'PublicRead', path: "${BRANCH_NAME}.tar.bz2"
+    deleteDir()
+  }
+}
+
+def TestPythonCPU() {
+  node('linux && cpu') {
+    unstash name: 'xgboost_whl_cuda9'
+    unstash name: 'srcs'
+    echo "Test Python CPU"
+    def container_type = "cpu"
+    def docker_binary = "docker"
+    sh """
+    ${dockerRun} ${container_type} ${docker_binary} tests/ci_build/test_python.sh cpu
+    """
+    deleteDir()
+  }
+}
+
+def TestPythonGPU(args) {
+  nodeReq = (args.multi_gpu) ? 'linux && mgpu' : 'linux && gpu'
+  node(nodeReq) {
+    if (args.cuda_version == '8.0') {
+      unstash name: 'xgboost_whl_cuda8'
+    } else {
+      unstash name: 'xgboost_whl_cuda9'
+    }
+    unstash name: 'srcs'
+    echo "Test Python GPU: CUDA ${args.cuda_version}"
+    def container_type = "gpu"
+    def docker_binary = "nvidia-docker"
+    def docker_args = "--build-arg CUDA_VERSION=${args.cuda_version}"
+    if (args.multi_gpu) {
+      echo "Using multiple GPUs"
+      sh """
+      ${dockerRun} ${container_type} ${docker_binary} ${docker_args} tests/ci_build/test_python.sh mgpu
+      """
+    } else {
+      echo "Using a single GPU"
+      sh """
+      ${dockerRun} ${container_type} ${docker_binary} ${docker_args} tests/ci_build/test_python.sh gpu
+      """
+    }
+    deleteDir()
+  }
+}
+
+def TestCppGPU(args) {
+  nodeReq = (args.multi_gpu) ? 'linux && mgpu' : 'linux && gpu'
+  node(nodeReq) {
+    unstash name: 'xgboost_cpp_tests'
+    unstash name: 'srcs'
+    echo "Test C++, CUDA ${args.cuda_version}"
+    def container_type = "gpu"
+    def docker_binary = "nvidia-docker"
+    def docker_args = "--build-arg CUDA_VERSION=${args.cuda_version}"
+    if (args.multi_gpu) {
+      echo "Using multiple GPUs"
+      sh "${dockerRun} ${container_type} ${docker_binary} ${docker_args} build/testxgboost --gtest_filter=*.MGPU_*"
+    } else {
+      echo "Using a single GPU"
+      sh "${dockerRun} ${container_type} ${docker_binary} ${docker_args} build/testxgboost --gtest_filter=-*.MGPU_*"
+    }
+    deleteDir()
+  }
+}
+
+def CrossTestJVMwithJDK(args) {
+  node('linux && cpu') {
+    unstash name: 'xgboost4j_jar'
+    unstash name: 'srcs'
+    if (args.spark_version != null) {
+      echo "Test XGBoost4J on a machine with JDK ${args.jdk_version}, Spark ${args.spark_version}"
+    } else {
+      echo "Test XGBoost4J on a machine with JDK ${args.jdk_version}"
+    }
+    def container_type = "jvm_cross"
+    def docker_binary = "docker"
+    def spark_arg = (args.spark_version != null) ? "--build-arg SPARK_VERSION=${args.spark_version}" : ""
+    def docker_args = "--build-arg JDK_VERSION=${args.jdk_version} ${spark_arg}"
+    // Run integration tests only when spark_version is given
+    def docker_extra_params = (args.spark_version != null) ? "CI_DOCKER_EXTRA_PARAMS_INIT='-e RUN_INTEGRATION_TEST=1'" : ""
+    sh """
+    ${docker_extra_params} ${dockerRun} ${container_type} ${docker_binary} ${docker_args} tests/ci_build/test_jvm_cross.sh
+    """
+    deleteDir()
+  }
+}
+
+def TestR(args) {
+  node('linux && cpu') {
+    unstash name: 'srcs'
+    echo "Test R package"
+    def container_type = "rproject"
+    def docker_binary = "docker"
+    def use_r35_flag = (args.use_r35) ? "1" : "0"
+    def docker_args = "--build-arg USE_R35=${use_r35_flag}"
+    sh """
+    ${dockerRun} ${container_type} ${docker_binary} ${docker_args} tests/ci_build/build_test_rpkg.sh
+    """
+    deleteDir()
+  }
 }

Jenkinsfile-restricted

@@ -1,123 +0,0 @@
-#!/usr/bin/groovy
-// -*- mode: groovy -*-
-// Jenkins pipeline
-// See documents at https://jenkins.io/doc/book/pipeline/jenkinsfile/
-
-import groovy.transform.Field
-
-/* Restricted tasks: tasks generating artifacts, such as binary wheels and
-                     documentation */
-
-// Command to run command inside a docker container
-def dockerRun = 'tests/ci_build/ci_build.sh'
-// Utility functions
-@Field
-def utils
-@Field
-def commit_id
-@Field
-def branch_name
-
-def buildMatrix = [
-    [ "enabled": true,  "os" : "linux", "withGpu": true, "withNccl": true,  "withOmp": true, "pythonVersion": "2.7", "cudaVersion": "9.2" ],
-    [ "enabled": true,  "os" : "linux", "withGpu": true, "withNccl": true,  "withOmp": true, "pythonVersion": "2.7", "cudaVersion": "8.0" ],
-    [ "enabled": true,  "os" : "linux", "withGpu": true, "withNccl": false, "withOmp": true, "pythonVersion": "2.7", "cudaVersion": "8.0" ],
-]
-
-pipeline {
-    // Each stage specify its own agent
-    agent none
-
-    // Setup common job properties
-    options {
-        ansiColor('xterm')
-        timestamps()
-        timeout(time: 120, unit: 'MINUTES')
-        buildDiscarder(logRotator(numToKeepStr: '10'))
-    }
-
-    // Build stages
-    stages {
-        stage('Jenkins: Get sources') {
-            agent {
-                label 'restricted'
-            }
-            steps {
-                script {
-                    utils = load('tests/ci_build/jenkins_tools.Groovy')
-                    utils.checkoutSrcs()
-                    commit_id = "${GIT_COMMIT}"
-                    branch_name = "${GIT_LOCAL_BRANCH}"
-                }
-                stash name: 'srcs', excludes: '.git/'
-                milestone label: 'Sources ready', ordinal: 1
-            }
-        }
-        stage('Jenkins: Build doc') {
-            steps {
-                script {
-                    retry(3) {
-                        node('linux && cpu && restricted') {
-                            unstash name: 'srcs'
-                            echo 'Building doc...'
-                            dir ('jvm-packages') {
-                                sh "bash ./build_doc.sh ${commit_id}"
-                                archiveArtifacts artifacts: "${commit_id}.tar.bz2", allowEmptyArchive: true
-                                echo 'Deploying doc...'
-                                withAWS(credentials:'xgboost-doc-bucket') {
-                                    s3Upload file: "${commit_id}.tar.bz2", bucket: 'xgboost-docs', acl: 'PublicRead', path: "${branch_name}.tar.bz2"
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        stage('Jenkins: Build artifacts') {
-            steps {
-                script {
-                    parallel (buildMatrix.findAll{it['enabled']}.collectEntries{ c ->
-                        def buildName = utils.getBuildName(c)
-                        utils.buildFactory(buildName, c, true, this.&buildPlatformCmake)
-                    })
-                }
-            }
-        }
-    }
-}
-
-/**
- * Build platform and test it via cmake.
- */
-def buildPlatformCmake(buildName, conf, nodeReq, dockerTarget) {
-    def opts = utils.cmakeOptions(conf)
-    // Destination dir for artifacts
-    def distDir = "dist/${buildName}"
-    def dockerArgs = ""
-    if(conf["withGpu"]){
-        dockerArgs = "--build-arg CUDA_VERSION=" + conf["cudaVersion"]
-    }
-    // Build node - this is returned result
-    retry(3) {
-        node(nodeReq) {
-            unstash name: 'srcs'
-            echo """
-            |===== XGBoost CMake build =====
-            |  dockerTarget: ${dockerTarget}
-            |  cmakeOpts   : ${opts}
-            |=========================
-            """.stripMargin('|')
-            // Invoke command inside docker
-            sh """
-            ${dockerRun} ${dockerTarget} ${dockerArgs} tests/ci_build/build_via_cmake.sh ${opts}
-            ${dockerRun} ${dockerTarget} ${dockerArgs} bash -c "cd python-package; rm -f dist/*; python setup.py bdist_wheel --universal"
-            rm -rf "${distDir}"; mkdir -p "${distDir}/py"
-            cp xgboost "${distDir}"
-            cp -r lib "${distDir}"
-            cp -r python-package/dist "${distDir}/py"
-            """
-            archiveArtifacts artifacts: "${distDir}/**/*.*", allowEmptyArchive: true
-        }
-    }
-}

Jenkinsfile-win64

@@ -0,0 +1,134 @@
+#!/usr/bin/groovy
+// -*- mode: groovy -*-
+
+/* Jenkins pipeline for Windows AMD64 target */
+
+pipeline {
+  agent none
+  // Build stages
+  stages {
+    stage('Jenkins Win64: Get sources') {
+      agent { label 'win64 && build' }
+      steps {
+        script {
+          checkoutSrcs()
+        }
+        stash name: 'srcs'
+        milestone ordinal: 1
+      }
+    }
+    stage('Jenkins Win64: Build') {
+      agent none
+      steps {
+        script {
+          parallel ([
+            'build-win64-cuda9.0': { BuildWin64() }
+          ])
+        }
+        milestone ordinal: 2
+      }
+    }
+    stage('Jenkins Win64: Test') {
+      agent none
+      steps {
+        script {
+          parallel ([
+            'test-win64-cpu': { TestWin64CPU() },
+            'test-win64-gpu-cuda9.0': { TestWin64GPU(cuda_target: 'cuda9') },
+            'test-win64-gpu-cuda10.0': { TestWin64GPU(cuda_target: 'cuda10_0') },
+            'test-win64-gpu-cuda10.1': { TestWin64GPU(cuda_target: 'cuda10_1') }
+          ])
+        }
+        milestone ordinal: 3
+      }
+    }
+  }
+}
+
+// check out source code from git
+def checkoutSrcs() {
+  retry(5) {
+    try {
+      timeout(time: 2, unit: 'MINUTES') {
+        checkout scm
+        sh 'git submodule update --init'
+      }
+    } catch (exc) {
+      deleteDir()
+      error "Failed to fetch source codes"
+    }
+  }
+}
+
+def BuildWin64() {
+  node('win64 && build') {
+    unstash name: 'srcs'
+    echo "Building XGBoost for Windows AMD64 target..."
+    bat "nvcc --version"
+    bat """
+    mkdir build
+    cd build
+    cmake .. -G"Visual Studio 15 2017 Win64" -DUSE_CUDA=ON -DCMAKE_VERBOSE_MAKEFILE=ON -DGOOGLE_TEST=ON -DUSE_DMLC_GTEST=ON
+    """
+    bat """
+    cd build
+    "C:\\Program Files (x86)\\Microsoft Visual Studio\\2017\\Community\\MSBuild\\15.0\\Bin\\MSBuild.exe" xgboost.sln /m /p:Configuration=Release /nodeReuse:false
+    """
+    bat """
+    cd python-package
+    conda activate && python setup.py bdist_wheel --universal
+    """
+    echo "Insert vcomp140.dll (OpenMP runtime) into the wheel..."
+    bat """
+    cd python-package\\dist
+    COPY /B ..\\..\\tests\\ci_build\\insert_vcomp140.py
+    conda activate && python insert_vcomp140.py *.whl
+    """
+    echo 'Stashing Python wheel...'
+    stash name: 'xgboost_whl', includes: 'python-package/dist/*.whl'
+    archiveArtifacts artifacts: "python-package/dist/*.whl", allowEmptyArchive: true
+    echo 'Stashing C++ test executable (testxgboost)...'
+    stash name: 'xgboost_cpp_tests', includes: 'build/testxgboost.exe'
+    deleteDir()
+  }
+}
+
+def TestWin64CPU() {
+  node('win64 && cpu') {
+    unstash name: 'srcs'
+    unstash name: 'xgboost_whl'
+    echo "Test Win64 CPU"
+    echo "Installing Python wheel..."
+    bat "conda activate && (python -m pip uninstall -y xgboost || cd .)"
+    bat """
+    conda activate && for /R %%i in (python-package\\dist\\*.whl) DO python -m pip install "%%i"
+    """
+    echo "Running Python tests..."
+    bat "conda activate && python -m pytest -v -s --fulltrace tests\\python"
+    bat "conda activate && python -m pip uninstall -y xgboost"
+    deleteDir()
+  }
+}
+
+def TestWin64GPU(args) {
+  node("win64 && gpu && ${args.cuda_target}") {
+    unstash name: 'srcs'
+    unstash name: 'xgboost_whl'
+    unstash name: 'xgboost_cpp_tests'
+    echo "Test Win64 GPU (${args.cuda_target})"
+    bat "nvcc --version"
+    echo "Running C++ tests..."
+    bat "build\\testxgboost.exe"
+    echo "Installing Python wheel..."
+    bat "conda activate && (python -m pip uninstall -y xgboost || cd .)"
+    bat """
+    conda activate && for /R %%i in (python-package\\dist\\*.whl) DO python -m pip install "%%i"
+    """
+    echo "Running Python tests..."
+    bat """
+    conda activate && python -m pytest -v -s --fulltrace -m "(not slow) and (not mgpu)" tests\\python-gpu
+    """
+    bat "conda activate && python -m pip uninstall -y xgboost"
+    deleteDir()
+  }
+}

Makefile

@@ -173,10 +173,14 @@ xgboost: $(CLI_OBJ) $(ALL_DEP)
 	$(CXX) $(CFLAGS) -o $@  $(filter %.o %.a, $^)  $(LDFLAGS)
 
 rcpplint:
-	python2 dmlc-core/scripts/lint.py xgboost ${LINT_LANG} R-package/src
+	python3 dmlc-core/scripts/lint.py xgboost ${LINT_LANG} R-package/src
 
 lint: rcpplint
-	python2 dmlc-core/scripts/lint.py xgboost ${LINT_LANG} include src plugin python-package
+	python3 dmlc-core/scripts/lint.py --exclude_path python-package/xgboost/dmlc-core \
+	  python-package/xgboost/include python-package/xgboost/lib \
+	  python-package/xgboost/make python-package/xgboost/rabit \
+	  python-package/xgboost/src --pylint-rc ${PWD}/python-package/.pylintrc xgboost \
+	  ${LINT_LANG} include src plugin python-package
 
 pylint:
 	flake8 --ignore E501 python-package
@@ -260,7 +264,8 @@ Rpack: clean_all
 	cp ./LICENSE xgboost
 	cat R-package/src/Makevars.in|sed '2s/.*/PKGROOT=./' | sed '3s/.*/ENABLE_STD_THREAD=0/' > xgboost/src/Makevars.in
 	cp xgboost/src/Makevars.in xgboost/src/Makevars.win
-	sed -i -e 's/@OPENMP_CXXFLAGS@/$$\(SHLIB_OPENMP_CFLAGS\)/g' xgboost/src/Makevars.win
+	sed -i -e 's/@OPENMP_CXXFLAGS@/$$\(SHLIB_OPENMP_CXXFLAGS\)/g' xgboost/src/Makevars.win
+	sed -i -e 's/-pthread/$$\(SHLIB_PTHREAD_FLAGS\)/g' xgboost/src/Makevars.win
 	bash R-package/remove_warning_suppression_pragma.sh
 	rm xgboost/remove_warning_suppression_pragma.sh
 

NEWS.md

@@ -3,6 +3,301 @@ XGBoost Change Log
 
 This file records the changes in xgboost library in reverse chronological order.
 
+## v0.90 (2019.05.18)
+
+### XGBoost Python package drops Python 2.x (#4379, #4381)
+Python 2.x is reaching its end-of-life at the end of this year. [Many scientific Python packages are now moving to drop Python 2.x](https://python3statement.org/).
+
+### XGBoost4J-Spark now requires Spark 2.4.x (#4377)
+* Spark 2.3 is reaching its end-of-life soon. See discussion at #4389.
+* **Consistent handling of missing values** (#4309, #4349, #4411): Many users had reported issue with inconsistent predictions between XGBoost4J-Spark and the Python XGBoost package. The issue was caused by Spark mis-handling non-zero missing values (NaN, -1, 999 etc). We now alert the user whenever Spark doesn't handle missing values correctly (#4309, #4349). See [the tutorial for dealing with missing values in XGBoost4J-Spark](https://xgboost.readthedocs.io/en/release_0.90/jvm/xgboost4j_spark_tutorial.html#dealing-with-missing-values). This fix also depends on the availability of Spark 2.4.x.
+
+### Roadmap: better performance scaling for multi-core CPUs (#4310)
+* Poor performance scaling of the `hist` algorithm for multi-core CPUs has been under investigation (#3810). #4310 optimizes quantile sketches and other pre-processing tasks. Special thanks to @SmirnovEgorRu.
+
+### Roadmap: Harden distributed training (#4250)
+* Make distributed training in XGBoost more robust by hardening [Rabit](https://github.com/dmlc/rabit), which implements [the AllReduce primitive](https://en.wikipedia.org/wiki/Reduce_%28parallel_pattern%29). In particular, improve test coverage on mechanisms for fault tolerance and recovery. Special thanks to @chenqin.
+
+### New feature: Multi-class metric functions for GPUs (#4368)
+* Metrics for multi-class classification have been ported to GPU: `merror`, `mlogloss`. Special thanks to @trivialfis.
+* With supported metrics, XGBoost will select the correct devices based on your system and `n_gpus` parameter.
+
+### New feature: Scikit-learn-like random forest API (#4148, #4255, #4258)
+* XGBoost Python package now offers `XGBRFClassifier` and `XGBRFRegressor` API to train random forests. See [the tutorial](https://xgboost.readthedocs.io/en/release_0.90/tutorials/rf.html). Special thanks to @canonizer
+
+### New feature: use external memory in GPU predictor (#4284, #4396, #4438, #4457)
+* It is now possible to make predictions on GPU when the input is read from external memory. This is useful when you want to make predictions with big dataset that does not fit into the GPU memory. Special thanks to @rongou, @canonizer, @sriramch.
+
+  ```python
+  dtest = xgboost.DMatrix('test_data.libsvm#dtest.cache')
+  bst.set_param('predictor', 'gpu_predictor')
+  bst.predict(dtest)
+  ```
+
+* Coming soon: GPU training (`gpu_hist`) with external memory
+
+### New feature: XGBoost can now handle comments in LIBSVM files (#4430)
+* Special thanks to @trivialfis and @hcho3
+
+### New feature: Embed XGBoost in your C/C++ applications using CMake (#4323, #4333, #4453)
+* It is now easier than ever to embed XGBoost in your C/C++ applications. In your CMakeLists.txt, add `xgboost::xgboost` as a linked library:
+
+  ```cmake
+  find_package(xgboost REQUIRED)
+  add_executable(api-demo c-api-demo.c)
+  target_link_libraries(api-demo xgboost::xgboost)
+  ```
+
+  [XGBoost C API documentation is available.](https://xgboost.readthedocs.io/en/release_0.90/dev) Special thanks to @trivialfis
+
+### Performance improvements
+* Use feature interaction constraints to narrow split search space (#4341, #4428)
+* Additional optimizations for `gpu_hist` (#4248, #4283)
+* Reduce OpenMP thread launches in `gpu_hist` (#4343)
+* Additional optimizations for multi-node multi-GPU random forests. (#4238)
+* Allocate unique prediction buffer for each input matrix, to avoid re-sizing GPU array (#4275)
+* Remove various synchronisations from CUDA API calls (#4205)
+* XGBoost4J-Spark
+  - Allow the user to control whether to cache partitioned training data, to potentially reduce execution time (#4268)
+
+### Bug-fixes
+* Fix node reuse in `hist` (#4404)
+* Fix GPU histogram allocation (#4347)
+* Fix matrix attributes not sliced (#4311)
+* Revise AUC and AUCPR metrics now work with weighted ranking task (#4216, #4436)
+* Fix timer invocation for InitDataOnce() in `gpu_hist` (#4206)
+* Fix R-devel errors (#4251)
+* Make gradient update in GPU linear updater thread-safe (#4259)
+* Prevent out-of-range access in column matrix (#4231)
+* Don't store DMatrix handle in Python object until it's initialized, to improve exception safety (#4317)
+* XGBoost4J-Spark
+  - Fix non-deterministic order within a zipped partition on prediction (#4388)
+  - Remove race condition on tracker shutdown (#4224)
+  - Allow set the parameter `maxLeaves`. (#4226)
+  - Allow partial evaluation of dataframe before prediction (#4407)
+  - Automatically set `maximize_evaluation_metrics` if not explicitly given (#4446)
+
+### API changes
+* Deprecate `reg:linear` in favor of `reg:squarederror`. (#4267, #4427)
+* Add attribute getter and setter to the Booster object in XGBoost4J (#4336)
+
+### Maintenance: Refactor C++ code for legibility and maintainability
+* Fix clang-tidy warnings. (#4149)
+* Remove deprecated C APIs. (#4266)
+* Use Monitor class to time functions in `hist`. (#4273)
+* Retire DVec class in favour of c++20 style span for device memory. (#4293)
+* Improve HostDeviceVector exception safety (#4301)
+
+### Maintenance: testing, continuous integration, build system
+* **Major refactor of CMakeLists.txt** (#4323, #4333, #4453): adopt modern CMake and export XGBoost as a target
+* **Major improvement in Jenkins CI pipeline** (#4234)
+  - Migrate all Linux tests to Jenkins (#4401)
+  - Builds and tests are now de-coupled, to test an artifact against multiple versions of CUDA, JDK, and other dependencies (#4401)
+  - Add Windows GPU to Jenkins CI pipeline (#4463, #4469)
+* Support CUDA 10.1 (#4223, #4232, #4265, #4468)
+* Python wheels are now built with CUDA 9.0, so that JIT is not required on Volta architecture (#4459)
+* Integrate with NVTX CUDA profiler (#4205)
+* Add a test for cpu predictor using external memory (#4308)
+* Refactor tests to get rid of duplication (#4358)
+* Remove test dependency on `craigcitro/r-travis`, since it's deprecated (#4353)
+* Add files from local R build to `.gitignore` (#4346)
+* Make XGBoost4J compatible with Java 9+ by revising NativeLibLoader (#4351)
+* Jenkins build for CUDA 10.0 (#4281)
+* Remove remaining `silent` and `debug_verbose` in Python tests (#4299)
+* Use all cores to build XGBoost4J lib on linux (#4304)
+* Upgrade Jenkins Linux build environment to GCC 5.3.1, CMake 3.6.0 (#4306)
+* Make CMakeLists.txt compatible with CMake 3.3 (#4420)
+* Add OpenMP option in CMakeLists.txt (#4339)
+* Get rid of a few trivial compiler warnings (#4312)
+* Add external Docker build cache, to speed up builds on Jenkins CI (#4331, #4334, #4458)
+* Fix Windows tests (#4403)
+* Fix a broken python test (#4395)
+* Use a fixed seed to split data in XGBoost4J-Spark tests, for reproducibility (#4417)
+* Add additional Python tests to test training under constraints (#4426)
+* Enable building with shared NCCL. (#4447)
+
+### Usability Improvements, Documentation
+* Document limitation of one-split-at-a-time Greedy tree learning heuristic (#4233)
+* Update build doc: PyPI wheel now support multi-GPU (#4219)
+* Fix docs for `num_parallel_tree` (#4221)
+* Fix document about `colsample_by*` parameter (#4340)
+* Make the train and test input with same colnames. (#4329)
+* Update R contribute link. (#4236)
+* Fix travis R tests (#4277)
+* Log version number in crash log in XGBoost4J-Spark (#4271, #4303)
+* Allow supression of Rabit output in Booster::train in XGBoost4J (#4262)
+* Add tutorial on handling missing values in XGBoost4J-Spark (#4425)
+* Fix typos (#4345, #4393, #4432, #4435)
+* Added language classifier in setup.py (#4327)
+* Added Travis CI badge (#4344)
+* Add BentoML to use case section (#4400)
+* Remove subtly sexist remark (#4418)
+* Add R vignette about parsing JSON dumps (#4439)
+
+### Acknowledgement
+**Contributors**: Nan Zhu (@CodingCat), Adam Pocock (@Craigacp), Daniel Hen (@Daniel8hen), Jiaxiang Li (@JiaxiangBU), Rory Mitchell (@RAMitchell), Egor Smirnov (@SmirnovEgorRu), Andy Adinets (@canonizer), Jonas (@elcombato), Harry Braviner (@harrybraviner), Philip Hyunsu Cho (@hcho3), Tong He (@hetong007), James Lamb (@jameslamb), Jean-Francois Zinque (@jeffzi), Yang Yang (@jokerkeny), Mayank Suman (@mayanksuman), jess (@monkeywithacupcake), Hajime Morrita (@omo), Ravi Kalia (@project-delphi), @ras44, Rong Ou (@rongou), Shaochen Shi (@shishaochen), Xu Xiao (@sperlingxx), @sriramch, Jiaming Yuan (@trivialfis), Christopher Suchanek (@wsuchy), Bozhao (@yubozhao)
+
+**Reviewers**: Nan Zhu (@CodingCat), Adam Pocock (@Craigacp), Daniel Hen (@Daniel8hen), Jiaxiang Li (@JiaxiangBU), Laurae (@Laurae2), Rory Mitchell (@RAMitchell), Egor Smirnov (@SmirnovEgorRu), @alois-bissuel, Andy Adinets (@canonizer), Chen Qin (@chenqin), Harry Braviner (@harrybraviner), Philip Hyunsu Cho (@hcho3), Tong He (@hetong007), @jakirkham, James Lamb (@jameslamb), Julien Schueller (@jschueller), Mayank Suman (@mayanksuman), Hajime Morrita (@omo), Rong Ou (@rongou), Sara Robinson (@sararob), Shaochen Shi (@shishaochen), Xu Xiao (@sperlingxx), @sriramch, Sean Owen (@srowen), Sergei Lebedev (@superbobry), Yuan (Terry) Tang (@terrytangyuan), Theodore Vasiloudis (@thvasilo), Matthew Tovbin (@tovbinm), Jiaming Yuan (@trivialfis), Xin Yin (@xydrolase)
+
+## v0.82 (2019.03.03)
+This release is packed with many new features and bug fixes.
+
+### Roadmap: better performance scaling for multi-core CPUs (#3957)
+* Poor performance scaling of the `hist` algorithm for multi-core CPUs has been under investigation (#3810). #3957 marks an important step toward better performance scaling, by using software pre-fetching and replacing STL vectors with C-style arrays. Special thanks to @Laurae2 and @SmirnovEgorRu.
+* See #3810 for latest progress on this roadmap.
+
+### New feature: Distributed Fast Histogram Algorithm (`hist`) (#4011, #4102, #4140, #4128)
+* It is now possible to run the `hist` algorithm in distributed setting. Special thanks to @CodingCat. The benefits include:
+  1. Faster local computation via feature binning
+  2. Support for monotonic constraints and feature interaction constraints
+  3. Simpler codebase than `approx`, allowing for future improvement
+* Depth-wise tree growing is now performed in a separate code path, so that cross-node syncronization is performed only once per level.
+
+### New feature: Multi-Node, Multi-GPU training (#4095)
+* Distributed training is now able to utilize clusters equipped with NVIDIA GPUs. In particular, the rabit AllReduce layer will communicate GPU device information. Special thanks to @mt-jones, @RAMitchell, @rongou, @trivialfis, @canonizer, and @jeffdk.
+* Resource management systems will be able to assign a rank for each GPU in the cluster.
+* In Dask, users will be able to construct a collection of XGBoost processes over an inhomogeneous device cluster (i.e. workers with different number and/or kinds of GPUs).
+
+### New feature: Multiple validation datasets in XGBoost4J-Spark (#3904, #3910)
+* You can now track the performance of the model during training with multiple evaluation datasets. By specifying `eval_sets` or call `setEvalSets` over a `XGBoostClassifier` or `XGBoostRegressor`, you can pass in multiple evaluation datasets typed as a `Map` from `String` to `DataFrame`. Special thanks to @CodingCat.
+* See the usage of multiple validation datasets [here](https://github.com/dmlc/xgboost/blob/0c1d5f1120c0a159f2567b267f0ec4ffadee00d0/jvm-packages/xgboost4j-example/src/main/scala/ml/dmlc/xgboost4j/scala/example/spark/SparkTraining.scala#L66-L78)
+
+### New feature: Additional metric functions for GPUs (#3952)
+* Element-wise metrics have been ported to GPU: `rmse`, `mae`, `logloss`, `poisson-nloglik`, `gamma-deviance`, `gamma-nloglik`, `error`, `tweedie-nloglik`. Special thanks to @trivialfis and @RAMitchell.
+* With supported metrics, XGBoost will select the correct devices based on your system and `n_gpus` parameter.
+
+### New feature: Column sampling at individual nodes (splits) (#3971)
+* Columns (features) can now be sampled at individual tree nodes, in addition to per-tree and per-level sampling. To enable per-node sampling, set `colsample_bynode` parameter, which represents the fraction of columns sampled at each node. This parameter is set to 1.0 by default (i.e. no sampling per node). Special thanks to @canonizer.
+* The `colsample_bynode` parameter works cumulatively with other `colsample_by*` parameters: for example, `{'colsample_bynode':0.5, 'colsample_bytree':0.5}` with 100 columns will give 25 features to choose from at each split.
+
+### Major API change: consistent logging level via `verbosity` (#3982, #4002, #4138)
+* XGBoost now allows fine-grained control over logging. You can set `verbosity` to 0 (silent), 1 (warning), 2 (info), and 3 (debug). This is useful for controlling the amount of logging outputs. Special thanks to @trivialfis.
+* Parameters `silent` and `debug_verbose` are now deprecated.
+* Note: Sometimes XGBoost tries to change configurations based on heuristics, which is displayed as warning message.  If there's unexpected behaviour, please try to increase value of verbosity.
+
+### Major bug fix: external memory (#4040, #4193)
+* Clarify object ownership in multi-threaded prefetcher, to avoid memory error.
+* Correctly merge two column batches (which uses [CSC layout](https://en.wikipedia.org/wiki/Sparse_matrix#Compressed_sparse_column_(CSC_or_CCS))).
+* Add unit tests for external memory.
+* Special thanks to @trivialfis and @hcho3.
+
+### Major bug fix: early stopping fixed in XGBoost4J and XGBoost4J-Spark (#3928, #4176)
+* Early stopping in XGBoost4J and XGBoost4J-Spark is now consistent with its counterpart in the Python package. Training stops if the current iteration is `earlyStoppingSteps` away from the best iteration. If there are multiple evaluation sets, only the last one is used to determinate early stop.
+* See the updated documentation [here](https://xgboost.readthedocs.io/en/release_0.82/jvm/xgboost4j_spark_tutorial.html#early-stopping)
+* Special thanks to @CodingCat, @yanboliang, and @mingyang.
+
+### Major bug fix: infrequent features should not crash distributed training (#4045)
+* For infrequently occuring features, some partitions may not get any instance. This scenario used to crash distributed training due to mal-formed ranges. The problem has now been fixed.
+* In practice, one-hot-encoded categorical variables tend to produce rare features, particularly when the cardinality is high.
+* Special thanks to @CodingCat.
+
+### Performance improvements
+* Faster, more space-efficient radix sorting in `gpu_hist` (#3895)
+* Subtraction trick in histogram calculation in `gpu_hist` (#3945)
+* More performant re-partition in XGBoost4J-Spark (#4049)
+
+### Bug-fixes
+* Fix semantics of `gpu_id` when running multiple XGBoost processes on a multi-GPU machine (#3851)
+* Fix page storage path for external memory on Windows (#3869)
+* Fix configuration setup so that DART utilizes GPU (#4024)
+* Eliminate NAN values from SHAP prediction (#3943)
+* Prevent empty quantile sketches in `hist` (#4155)
+* Enable running objectives with 0 GPU (#3878)
+* Parameters are no longer dependent on system locale (#3891, #3907)
+* Use consistent data type in the GPU coordinate descent code (#3917)
+* Remove undefined behavior in the CLI config parser on the ARM platform (#3976)
+* Initialize counters in GPU AllReduce (#3987)
+* Prevent deadlocks in GPU AllReduce (#4113)
+* Load correct values from sliced NumPy arrays (#4147, #4165)
+* Fix incorrect GPU device selection (#4161)
+* Make feature binning logic in `hist` aware of query groups when running a ranking task (#4115). For ranking task, query groups are weighted, not individual instances.
+* Generate correct C++ exception type for `LOG(FATAL)` macro (#4159)
+* Python package
+  - Python package should run on system without `PATH` environment variable (#3845)
+  - Fix `coef_` and `intercept_` signature to be compatible with `sklearn.RFECV` (#3873)
+  - Use UTF-8 encoding in Python package README, to support non-English locale (#3867)
+  - Add AUC-PR to list of metrics to maximize for early stopping (#3936)
+  - Allow loading pickles without `self.booster` attribute, for backward compatibility (#3938, #3944)
+  - White-list DART for feature importances (#4073)
+  - Update usage of [h2oai/datatable](https://github.com/h2oai/datatable) (#4123)
+* XGBoost4J-Spark
+  - Address scalability issue in prediction (#4033)
+  - Enforce the use of per-group weights for ranking task (#4118)
+  - Fix vector size of `rawPredictionCol` in `XGBoostClassificationModel` (#3932)
+  - More robust error handling in Spark tracker (#4046, #4108)
+  - Fix return type of `setEvalSets` (#4105)
+  - Return correct value of `getMaxLeaves` (#4114)
+
+### API changes
+* Add experimental parameter `single_precision_histogram` to use single-precision histograms for the `gpu_hist` algorithm (#3965)
+* Python package
+  - Add option to select type of feature importances in the scikit-learn inferface (#3876)
+  - Add `trees_to_df()` method to dump decision trees as Pandas data frame (#4153)
+  - Add options to control node shapes in the GraphViz plotting function (#3859)
+  - Add `xgb_model` option to `XGBClassifier`, to load previously saved model (#4092)
+  - Passing lists into `DMatrix` is now deprecated (#3970)
+* XGBoost4J
+  - Support multiple feature importance features (#3801)
+
+### Maintenance: Refactor C++ code for legibility and maintainability
+* Refactor `hist` algorithm code and add unit tests (#3836)
+* Minor refactoring of split evaluator in `gpu_hist` (#3889)
+* Removed unused leaf vector field in the tree model (#3989)
+* Simplify the tree representation by combining `TreeModel` and `RegTree` classes (#3995)
+* Simplify and harden tree expansion code (#4008, #4015)
+* De-duplicate parameter classes in the linear model algorithms (#4013)
+* Robust handling of ranges with C++20 span in `gpu_exact` and `gpu_coord_descent` (#4020, #4029)
+* Simplify tree training code (#3825). Also use Span class for robust handling of ranges.
+
+### Maintenance: testing, continuous integration, build system
+* Disallow `std::regex` since it's not supported by GCC 4.8.x (#3870)
+* Add multi-GPU tests for coordinate descent algorithm for linear models (#3893, #3974)
+* Enforce naming style in Python lint (#3896)
+* Refactor Python tests (#3897, #3901): Use pytest exclusively, display full trace upon failure
+* Address `DeprecationWarning` when using Python collections (#3909)
+* Use correct group for maven site plugin (#3937)
+* Jenkins CI is now using on-demand EC2 instances exclusively, due to unreliability of Spot instances (#3948)
+* Better GPU performance logging (#3945)
+* Fix GPU tests on machines with only 1 GPU (#4053)
+* Eliminate CRAN check warnings and notes (#3988)
+* Add unit tests for tree serialization (#3989)
+* Add unit tests for tree fitting functions in `hist` (#4155)
+* Add a unit test for `gpu_exact` algorithm (#4020)
+* Correct JVM CMake GPU flag (#4071)
+* Fix failing Travis CI on Mac (#4086)
+* Speed up Jenkins by not compiling CMake (#4099)
+* Analyze C++ and CUDA code using clang-tidy, as part of Jenkins CI pipeline (#4034)
+* Fix broken R test: Install Homebrew GCC (#4142)
+* Check for empty datasets in GPU unit tests (#4151)
+* Fix Windows compilation (#4139)
+* Comply with latest convention of cpplint (#4157)
+* Fix a unit test in `gpu_hist` (#4158)
+* Speed up data generation in Python tests (#4164)
+
+### Usability Improvements
+* Add link to [InfoWorld 2019 Technology of the Year Award](https://www.infoworld.com/article/3336072/application-development/infoworlds-2019-technology-of-the-year-award-winners.html) (#4116)
+* Remove outdated AWS YARN tutorial (#3885)
+* Document current limitation in number of features (#3886)
+* Remove unnecessary warning when `gblinear` is selected (#3888)
+* Document limitation of CSV parser: header not supported (#3934)
+* Log training parameters in XGBoost4J-Spark (#4091)
+* Clarify early stopping behavior in the scikit-learn interface (#3967)
+* Clarify behavior of `max_depth` parameter (#4078)
+* Revise Python docstrings for ranking task (#4121). In particular, weights must be per-group in learning-to-rank setting.
+* Document parameter `num_parallel_tree` (#4022)
+* Add Jenkins status badge (#4090)
+* Warn users against using internal functions of `Booster` object (#4066)
+* Reformat `benchmark_tree.py` to comply with Python style convention (#4126)
+* Clarify a comment in `objectiveTrait` (#4174)
+* Fix typos and broken links in documentation (#3890, #3872, #3902, #3919, #3975, #4027, #4156, #4167)
+
+### Acknowledgement
+**Contributors** (in no particular order): Jiaming Yuan (@trivialfis), Hyunsu Cho (@hcho3), Nan Zhu (@CodingCat), Rory Mitchell (@RAMitchell), Yanbo Liang (@yanboliang), Andy Adinets (@canonizer), Tong He (@hetong007), Yuan Tang (@terrytangyuan)
+
+**First-time Contributors** (in no particular order): Jelle Zijlstra (@JelleZijlstra), Jiacheng Xu (@jiachengxu), @ajing, Kashif Rasul (@kashif), @theycallhimavi, Joey Gao (@pjgao), Prabakaran Kumaresshan (@nixphix), Huafeng Wang (@huafengw), @lyxthe, Sam Wilkinson (@scwilkinson), Tatsuhito Kato (@stabacov), Shayak Banerjee (@shayakbanerjee), Kodi Arfer (@Kodiologist), @KyleLi1985, Egor Smirnov (@SmirnovEgorRu), @tmitanitky, Pasha Stetsenko (@st-pasha), Kenichi Nagahara (@keni-chi), Abhai Kollara Dilip (@abhaikollara), Patrick Ford (@pford221), @hshujuan, Matthew Jones (@mt-jones), Thejaswi Rao (@teju85), Adam November (@anovember)
+
+**First-time Reviewers** (in no particular order): Mingyang Hu (@mingyang), Theodore Vasiloudis (@thvasilo), Jakub Troszok (@troszok), Rong Ou (@rongou), @Denisevi4, Matthew Jones (@mt-jones), Jeff Kaplan (@jeffdk)
+
 ## v0.81 (2018.11.04)
 ### New feature: feature interaction constraints
 * Users are now able to control which features (independent variables) are allowed to interact by specifying feature interaction constraints (#3466).
@@ -23,6 +318,10 @@ This file records the changes in xgboost library in reverse chronological order.
 * Mitigate tracker "thundering herd" issue on large cluster. Add exponential backoff retry when workers connect to tracker.
 * With this change, we were able to scale to 1.5k executors on a 12 billion row dataset after some tweaks here and there.
 
+### New feature: Additional objective functions for GPUs
+* New objective functions ported to GPU: `hinge`, `multi:softmax`, `multi:softprob`, `count:poisson`, `reg:gamma`, `"reg:tweedie`.
+* With supported objectives, XGBoost will select the correct devices based on your system and `n_gpus` parameter.
+
 ### Major bug fix: learning to rank with XGBoost4J-Spark
 * Previously, `repartitionForData` would shuffle data and lose ordering necessary for ranking task.
 * To fix this issue, data points within each RDD partition is explicitly group by their group (query session) IDs (#3654). Also handle empty RDD partition carefully (#3750).
@@ -33,6 +332,7 @@ This file records the changes in xgboost library in reverse chronological order.
 
 ### API changes
 * Column sampling by level (`colsample_bylevel`) is now functional for `hist` algorithm (#3635, #3862)
+* GPU tag `gpu:` for regression objectives are now deprecated. XGBoost will select the correct devices automatically (#3643)
 * Add `disable_default_eval_metric` parameter to disable default metric (#3606)
 * Experimental AVX support for gradient computation is removed (#3752)
 * XGBoost4J-Spark
@@ -159,7 +459,7 @@ This file records the changes in xgboost library in reverse chronological order.
 ### Acknowledgement
 **Contributors** (in no particular order): Hyunsu Cho (@hcho3), Jiaming Yuan (@trivialfis), Nan Zhu (@CodingCat), Rory Mitchell (@RAMitchell), Andy Adinets (@canonizer), Vadim Khotilovich (@khotilov), Sergei Lebedev (@superbobry)
 
-**First-time Contributors** (in no particular order): Matthew Tovbin (@tovbinm), Jakob Richter (@jakob-r), Grace Lam (@grace-lam), Grant W Schneider (@grantschneider), Andrew Thia (@BlueTea88), Sergei Chipiga (@schipiga), Joseph Bradley (@jkbradley), Chen Qin (@chenqin), Jerry Lin (@linjer), Dmitriy Rybalko (@rdtft), Michael Mui (@mmui), Takahiro Kojima (@515hikaru), Bruce Zhao (@BruceZhaoR), Wei Tian (@weitian), Saumya Bhatnagar (@Sam1301), Juzer Shakir (@JuzerShakir), Zhao Hang (@cleghom), Jonathan Friedman (@jontonsoup), Bruno Tremblay (@meztez), @Shiki-H, @mrgutkun, @gorogm, @htgeis, @jakehoare, @zengxy, @KOLANICH
+**First-time Contributors** (in no particular order): Matthew Tovbin (@tovbinm), Jakob Richter (@jakob-r), Grace Lam (@grace-lam), Grant W Schneider (@grantschneider), Andrew Thia (@BlueTea88), Sergei Chipiga (@schipiga), Joseph Bradley (@jkbradley), Chen Qin (@chenqin), Jerry Lin (@linjer), Dmitriy Rybalko (@rdtft), Michael Mui (@mmui), Takahiro Kojima (@515hikaru), Bruce Zhao (@BruceZhaoR), Wei Tian (@weitian), Saumya Bhatnagar (@Sam1301), Juzer Shakir (@JuzerShakir), Zhao Hang (@cleghom), Jonathan Friedman (@jontonsoup), Bruno Tremblay (@meztez), Boris Filippov (@frenzykryger), @Shiki-H, @mrgutkun, @gorogm, @htgeis, @jakehoare, @zengxy, @KOLANICH
 
 **First-time Reviewers** (in no particular order): Nikita Titov (@StrikerRUS), Xiangrui Meng (@mengxr), Nirmal Borah (@Nirmal-Neel)
 
@@ -174,7 +474,7 @@ This file records the changes in xgboost library in reverse chronological order.
   - Latest master: https://xgboost.readthedocs.io/en/latest
   - 0.80 stable: https://xgboost.readthedocs.io/en/release_0.80
   - 0.72 stable: https://xgboost.readthedocs.io/en/release_0.72
-* Ranking task now uses instance weights (#3379)
+* Support for per-group weights in ranking objective (#3379)
 * Fix inaccurate decimal parsing (#3546)
 * New functionality
   - Query ID column support in LIBSVM data files (#2749). This is convenient for performing ranking task in distributed setting.

R-package/CMakeLists.txt

@@ -0,0 +1,34 @@
+find_package(LibR REQUIRED)
+message(STATUS "LIBR_CORE_LIBRARY " ${LIBR_CORE_LIBRARY})
+
+file(GLOB_RECURSE R_SOURCES
+  ${CMAKE_CURRENT_LIST_DIR}/src/*.cc
+  ${CMAKE_CURRENT_LIST_DIR}/src/*.c)
+# Use object library to expose symbols
+add_library(xgboost-r OBJECT ${R_SOURCES})
+
+set(R_DEFINITIONS
+  -DXGBOOST_STRICT_R_MODE=1
+  -DXGBOOST_CUSTOMIZE_GLOBAL_PRNG=1
+  -DDMLC_LOG_BEFORE_THROW=0
+  -DDMLC_DISABLE_STDIN=1
+  -DDMLC_LOG_CUSTOMIZE=1
+  -DRABIT_CUSTOMIZE_MSG_
+  -DRABIT_STRICT_CXX98_)
+target_compile_definitions(xgboost-r
+  PRIVATE ${R_DEFINITIONS})
+target_include_directories(xgboost-r
+  PRIVATE
+  ${LIBR_INCLUDE_DIRS}
+  ${PROJECT_SOURCE_DIR}/include
+  ${PROJECT_SOURCE_DIR}/dmlc-core/include
+  ${PROJECT_SOURCE_DIR}/rabit/include)
+set_target_properties(
+  xgboost-r PROPERTIES
+  CXX_STANDARD 11
+  CXX_STANDARD_REQUIRED ON
+  POSITION_INDEPENDENT_CODE ON)
+
+set(XGBOOST_DEFINITIONS ${R_DEFINITIONS} PARENT_SCOPE)
+set(XGBOOST_OBJ_SOURCES $<TARGET_OBJECTS:xgboost-r> PARENT_SCOPE)
+set(LINKED_LIBRARIES_PRIVATE ${LINKED_LIBRARIES_PRIVATE} ${LIBR_CORE_LIBRARY} PARENT_SCOPE)

R-package/DESCRIPTION

@@ -1,8 +1,8 @@
 Package: xgboost
 Type: Package
 Title: Extreme Gradient Boosting
-Version: 0.81.0.1
-Date: 2018-08-13
+Version: 0.90.0.1
+Date: 2019-05-18
 Authors@R: c(
   person("Tianqi", "Chen", role = c("aut"),
          email = "tianqi.tchen@gmail.com"),
@@ -52,7 +52,9 @@ Suggests:
     vcd (>= 1.3),
     testthat,
     lintr,
-    igraph (>= 1.0.1)
+    igraph (>= 1.0.1),
+    jsonlite,
+    float
 Depends:
     R (>= 3.3.0)
 Imports:

R-package/R/callbacks.R

@@ -14,7 +14,7 @@
 #' WARNING: side-effects!!! Be aware that these callback functions access and modify things in
 #' the environment from which they are called from, which is a fairly uncommon thing to do in R.
 #'
-#' To write a custom callback closure, make sure you first understand the main concepts about R envoronments.
+#' To write a custom callback closure, make sure you first understand the main concepts about R environments.
 #' Check either R documentation on \code{\link[base]{environment}} or the
 #' \href{http://adv-r.had.co.nz/Environments.html}{Environments chapter} from the "Advanced R"
 #' book by Hadley Wickham. Further, the best option is to read the code of some of the existing callbacks -
@@ -154,7 +154,7 @@ cb.evaluation.log <- function() {
   callback
 }
 
-#' Callback closure for restetting the booster's parameters at each iteration.
+#' Callback closure for resetting the booster's parameters at each iteration.
 #'
 #' @param new_params a list where each element corresponds to a parameter that needs to be reset.
 #'        Each element's value must be either a vector of values of length \code{nrounds}
@@ -470,7 +470,7 @@ cb.save.model <- function(save_period = 0, save_name = "xgboost.model") {
 #' 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
 #' non-overlapping list of k sets of indices, as in a standard k-fold CV. The predictions would not be
-#' meaningful when user-profided folds have overlapping indices as in, e.g., random sampling splits.
+#' meaningful when user-provided folds have overlapping indices as in, e.g., random sampling splits.
 #' When some of the indices in the training dataset are not included into user-provided \code{folds},
 #' their prediction value would be \code{NA}.
 #'
@@ -681,7 +681,7 @@ cb.gblinear.history <- function(sparse=FALSE) {
 #'        using the \code{cb.gblinear.history()} callback.
 #' @param class_index zero-based class index to extract the coefficients for only that
 #'        specific class in a multinomial multiclass model. When it is NULL, all the
-#'        coeffients are returned. Has no effect in non-multiclass models.
+#'        coefficients are returned. Has no effect in non-multiclass models.
 #'
 #' @return
 #' For an \code{xgb.train} result, a matrix (either dense or sparse) with the columns

R-package/R/utils.R

@@ -209,13 +209,14 @@ generate.cv.folds <- function(nfold, nrows, stratified, label, params) {
     if (exists('objective', where = params) &&
         is.character(params$objective)) {
       # If 'objective' provided in params, assume that y is a classification label
-      # unless objective is reg:linear
-      if (params$objective != 'reg:linear')
+      # unless objective is reg:squarederror
+      if (params$objective != 'reg:squarederror')
         y <- factor(y)
     } else {
-      # If no 'objective' given in params, it means that user either wants to use
-      # the default 'reg:linear' objective or has provided a custom obj function.
-      # Here, assume classification setting when y has 5 or less unique values:
+      # If no 'objective' given in params, it means that user either wants to
+      # use the default 'reg:squarederror' objective or has provided a custom
+      # obj function.  Here, assume classification setting when y has 5 or less
+      # unique values:
       if (length(unique(y)) <= 5)
         y <- factor(y)
     }

R-package/R/xgb.Booster.R

@@ -81,7 +81,7 @@ xgb.get.handle <- function(object) {
 #' its handle (pointer) to an internal xgboost model would be invalid. The majority of xgboost methods
 #' should still work for such a model object since those methods would be using
 #' \code{xgb.Booster.complete} internally. However, one might find it to be more efficient to call the
-#' \code{xgb.Booster.complete} function explicitely once after loading a model as an R-object.
+#' \code{xgb.Booster.complete} function explicitly once after loading a model as an R-object.
 #' That would prevent further repeated implicit reconstruction of an internal booster model.
 #'
 #' @return
@@ -95,6 +95,7 @@ xgb.get.handle <- function(object) {
 #' saveRDS(bst, "xgb.model.rds")
 #'
 #' bst1 <- readRDS("xgb.model.rds")
+#' if (file.exists("xgb.model.rds")) file.remove("xgb.model.rds")
 #' # the handle is invalid:
 #' print(bst1$handle)
 #'
@@ -162,7 +163,7 @@ xgb.Booster.complete <- function(object, saveraw = TRUE) {
 #'
 #' With \code{predinteraction = TRUE}, SHAP values of contributions of interaction of each pair of features
 #' are computed. Note that this operation might be rather expensive in terms of compute and memory.
-#' Since it quadratically depends on the number of features, it is recommended to perfom selection
+#' Since it quadratically depends on the number of features, it is recommended to perform selection
 #' of the most important features first. See below about the format of the returned results.
 #'
 #' @return
@@ -418,6 +419,7 @@ predict.xgb.Booster.handle <- function(object, ...) {
 #'
 #' xgb.save(bst, 'xgb.model')
 #' bst1 <- xgb.load('xgb.model')
+#' if (file.exists('xgb.model')) file.remove('xgb.model')
 #' print(xgb.attr(bst1, "my_attribute"))
 #' print(xgb.attributes(bst1))
 #'

R-package/R/xgb.DMatrix.R

@@ -19,6 +19,7 @@
 #' dtrain <- xgb.DMatrix(train$data, label=train$label)
 #' xgb.DMatrix.save(dtrain, 'xgb.DMatrix.data')
 #' dtrain <- xgb.DMatrix('xgb.DMatrix.data')
+#' if (file.exists('xgb.DMatrix.data')) file.remove('xgb.DMatrix.data')
 #' @export
 xgb.DMatrix <- function(data, info = list(), missing = NA, silent = FALSE, ...) {
   cnames <- NULL
@@ -104,7 +105,7 @@ dim.xgb.DMatrix <- function(x) {
 #' Handling of column names of \code{xgb.DMatrix}
 #'
 #' Only column names are supported for \code{xgb.DMatrix}, thus setting of
-#' row names would have no effect and returnten row names would be NULL.
+#' row names would have no effect and returned row names would be NULL.
 #'
 #' @param x object of class \code{xgb.DMatrix}
 #' @param value a list of two elements: the first one is ignored
@@ -266,10 +267,10 @@ setinfo.xgb.DMatrix <- function(object, name, info, ...) {
 
 
 #' Get a new DMatrix containing the specified rows of
-#' orginal xgb.DMatrix object
+#' original xgb.DMatrix object
 #'
 #' Get a new DMatrix containing the specified rows of
-#' orginal xgb.DMatrix object
+#' original xgb.DMatrix object
 #'
 #' @param object Object of class "xgb.DMatrix"
 #' @param idxset a integer vector of indices of rows needed
@@ -301,12 +302,17 @@ slice.xgb.DMatrix <- function(object, idxset, ...) {
 
   attr_list <- attributes(object)
   nr <- nrow(object)
-  len <- sapply(attr_list, length)
+  len <- sapply(attr_list, NROW)
   ind <- which(len == nr)
   if (length(ind) > 0) {
     nms <- names(attr_list)[ind]
     for (i in seq_along(ind)) {
-      attr(ret, nms[i]) <- attr(object, nms[i])[idxset]
+      obj_attr <- attr(object, nms[i])
+      if (NCOL(obj_attr) > 1) {
+        attr(ret, nms[i]) <- obj_attr[idxset,]
+      } else {
+        attr(ret, nms[i]) <- obj_attr[idxset]
+      }
     }
   }
   return(structure(ret, class = "xgb.DMatrix"))

R-package/R/xgb.DMatrix.save.R

@@ -11,6 +11,7 @@
 #' dtrain <- xgb.DMatrix(train$data, label=train$label)
 #' xgb.DMatrix.save(dtrain, 'xgb.DMatrix.data')
 #' dtrain <- xgb.DMatrix('xgb.DMatrix.data')
+#' if (file.exists('xgb.DMatrix.data')) file.remove('xgb.DMatrix.data')
 #' @export
 xgb.DMatrix.save <- function(dmatrix, fname) {
   if (typeof(fname) != "character")

R-package/R/xgb.cv.R

@@ -6,7 +6,7 @@
 #' \itemize{
 #'   \item \code{objective} objective function, common ones are
 #'   \itemize{
-#'     \item \code{reg:linear} linear regression
+#'     \item \code{reg:squarederror} Regression with squared loss
 #'     \item \code{binary:logistic} logistic regression for classification
 #'   }
 #'   \item \code{eta} step size of each boosting step
@@ -39,7 +39,7 @@
 #' }
 #' @param obj customized objective function. Returns gradient and second order
 #'        gradient with given prediction and dtrain.
-#' @param feval custimized evaluation function. Returns 
+#' @param feval customized evaluation function. Returns
 #'        \code{list(metric='metric-name', value='metric-value')} with given
 #'        prediction and dtrain.
 #' @param stratified a \code{boolean} indicating whether sampling of folds should be stratified
@@ -84,7 +84,7 @@
 #'         capture parameters changed by the \code{\link{cb.reset.parameters}} callback.
 #'   \item \code{callbacks} callback functions that were either automatically assigned or
 #'         explicitly passed.
-#'   \item \code{evaluation_log} evaluation history storead as a \code{data.table} with the
+#'   \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.

R-package/R/xgb.load.R

@@ -28,6 +28,7 @@
 #'                eta = 1, nthread = 2, nrounds = 2,objective = "binary:logistic")
 #' xgb.save(bst, 'xgb.model')
 #' bst <- xgb.load('xgb.model')
+#' if (file.exists('xgb.model')) file.remove('xgb.model')
 #' pred <- predict(bst, test$data)
 #' @export
 xgb.load <- function(modelfile) {

R-package/R/xgb.plot.deepness.R

@@ -27,7 +27,7 @@
 #' a tree's median absolute leaf weight changes through the iterations.
 #'
 #' This function was inspired by the blog post
-#' \url{http://aysent.github.io/2015/11/08/random-forest-leaf-visualization.html}.
+#' \url{https://github.com/aysent/random-forest-leaf-visualization}.
 #' 
 #' @return
 #' 

R-package/R/xgb.plot.importance.R

@@ -30,8 +30,8 @@
 #' Setting \code{rel_to_first = TRUE} allows to see the picture from the perspective of
 #' "what is feature's importance contribution relative to the most important feature?"
 #'
-#' The ggplot-backend method also performs 1-D custering of the importance values, 
-#' with bar colors coresponding to different clusters that have somewhat similar importance values.
+#' The ggplot-backend method also performs 1-D clustering of the importance values,
+#' with bar colors corresponding to different clusters that have somewhat similar importance values.
 #'
 #' @return
 #' The \code{xgb.plot.importance} function creates a \code{barplot} (when \code{plot=TRUE})

R-package/R/xgb.plot.shap.R

@@ -31,7 +31,7 @@
 #' @param plot_loess whether to plot loess-smoothed curves. The smoothing is only done for features with
 #'          more than 5 distinct values.
 #' @param col_loess a color to use for the loess curves.
-#' @param span_loess the \code{span} paramerer in \code{\link[stats]{loess}}'s call.
+#' @param span_loess the \code{span} parameter in \code{\link[stats]{loess}}'s call.
 #' @param which whether to do univariate or bivariate plotting. NOTE: only 1D is implemented so far.
 #' @param plot whether a plot should be drawn. If FALSE, only a lits of matrices is returned.
 #' @param ... other parameters passed to \code{plot}.

R-package/R/xgb.save.R

@@ -27,6 +27,7 @@
 #'                eta = 1, nthread = 2, nrounds = 2,objective = "binary:logistic")
 #' xgb.save(bst, 'xgb.model')
 #' bst <- xgb.load('xgb.model')
+#' if (file.exists('xgb.model')) file.remove('xgb.model')
 #' pred <- predict(bst, test$data)
 #' @export
 xgb.save <- function(model, fname) {

R-package/R/xgb.train.R

@@ -42,7 +42,7 @@
 #' \itemize{
 #' \item \code{objective} specify the learning task and the corresponding learning objective, users can pass a self-defined function to it. The default objective options are below:
 #'   \itemize{
-#'     \item \code{reg:linear} linear regression (Default).
+#'     \item \code{reg:squarederror} Regression with squared loss (Default).
 #'     \item \code{reg:logistic} logistic regression.
 #'     \item \code{binary:logistic} logistic regression for binary classification. Output probability.
 #'     \item \code{binary:logitraw} logistic regression for binary classification, output score before logistic transformation.
@@ -68,7 +68,7 @@
 #'        the performance of each round's model on mat1 and mat2.
 #' @param obj customized objective function. Returns gradient and second order
 #'        gradient with given prediction and dtrain.
-#' @param feval custimized evaluation function. Returns 
+#' @param feval customized evaluation function. Returns
 #'        \code{list(metric='metric-name', value='metric-value')} with given
 #'        prediction and dtrain.
 #' @param verbose If 0, xgboost will stay silent. If 1, it will print information about performance.
@@ -118,7 +118,7 @@
 #' when the \code{eval_metric} parameter is not provided.
 #' User may set one or several \code{eval_metric} parameters.
 #' Note that when using a customized metric, only this single metric can be used.
-#' The folloiwing is the list of built-in metrics for which Xgboost provides optimized implementation:
+#' The following is the list of built-in metrics for which Xgboost provides optimized implementation:
 #'   \itemize{
 #'      \item \code{rmse} root mean square error. \url{http://en.wikipedia.org/wiki/Root_mean_square_error}
 #'      \item \code{logloss} negative log-likelihood. \url{http://en.wikipedia.org/wiki/Log-likelihood}
@@ -147,14 +147,14 @@
 #'   \item \code{handle} a handle (pointer) to the xgboost model in memory.
 #'   \item \code{raw} a cached memory dump of the xgboost model saved as R's \code{raw} type.
 #'   \item \code{niter} number of boosting iterations.
-#'   \item \code{evaluation_log} evaluation history storead as a \code{data.table} with the
+#'   \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 evaluation
 #'         metrics' values. It is created by the \code{\link{cb.evaluation.log}} callback.
 #'   \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
-#'         explicitely passed.
+#'         explicitly passed.
 #'   \item \code{best_iteration} iteration number with the best evaluation metric value
 #'         (only available with early stopping).
 #'   \item \code{best_ntreelimit} the \code{ntreelimit} value corresponding to the best iteration,
@@ -163,7 +163,7 @@
 #'   \item \code{best_score} the best evaluation metric value during early stopping.
 #'         (only available with early stopping).
 #'   \item \code{feature_names} names of the training dataset features
-#'         (only when comun names were defined in training data).
+#'         (only when column names were defined in training data).
 #'   \item \code{nfeatures} number of features in training data.
 #' }
 #'
@@ -186,7 +186,7 @@
 #' watchlist <- list(train = dtrain, eval = dtest)
 #'
 #' ## A simple xgb.train example:
-#' param <- list(max_depth = 2, eta = 1, silent = 1, nthread = 2, 
+#' param <- list(max_depth = 2, eta = 1, verbose = 0, nthread = 2,
 #'               objective = "binary:logistic", eval_metric = "auc")
 #' bst <- xgb.train(param, dtrain, nrounds = 2, watchlist)
 #'
@@ -207,12 +207,12 @@
 #'
 #' # These functions could be used by passing them either:
 #' #  as 'objective' and 'eval_metric' parameters in the params list:
-#' param <- list(max_depth = 2, eta = 1, silent = 1, nthread = 2, 
+#' param <- list(max_depth = 2, eta = 1, verbose = 0, nthread = 2,
 #'               objective = logregobj, eval_metric = evalerror)
 #' bst <- xgb.train(param, dtrain, nrounds = 2, watchlist)
 #'
 #' #  or through the ... arguments:
-#' param <- list(max_depth = 2, eta = 1, silent = 1, nthread = 2)
+#' param <- list(max_depth = 2, eta = 1, verbose = 0, nthread = 2)
 #' bst <- xgb.train(param, dtrain, nrounds = 2, watchlist,
 #'                  objective = logregobj, eval_metric = evalerror)
 #'
@@ -222,7 +222,7 @@
 #'
 #'
 #' ## An xgb.train example of using variable learning rates at each iteration:
-#' param <- list(max_depth = 2, eta = 1, silent = 1, nthread = 2,
+#' param <- list(max_depth = 2, eta = 1, verbose = 0, nthread = 2,
 #'               objective = "binary:logistic", eval_metric = "auc")
 #' my_etas <- list(eta = c(0.5, 0.1))
 #' bst <- xgb.train(param, dtrain, nrounds = 2, watchlist,

R-package/README.md

@@ -30,4 +30,4 @@ Examples
 Development
 -----------
 
-* See the [R Package section](https://xgboost.readthedocs.io/en/latest/how_to/contribute.html#r-package) of the contributors guide.
+* See the [R Package section](https://xgboost.readthedocs.io/en/latest/contribute.html#r-package) of the contributors guide.

R-package/cleanup

@@ -1,3 +1,4 @@
 #!/bin/sh
 
 rm -f src/Makevars
+rm -f CMakeLists.txt

R-package/configure

@@ -1667,12 +1667,12 @@ OPENMP_CXXFLAGS=""
 
 if test `uname -s` = "Linux"
 then
-  OPENMP_CXXFLAGS="\$(SHLIB_OPENMP_CFLAGS)"
+  OPENMP_CXXFLAGS="\$(SHLIB_OPENMP_CXXFLAGS)"
 fi
 
 if test `uname -s` = "Darwin"
 then
-  OPENMP_CXXFLAGS="\$(SHLIB_OPENMP_CFLAGS)"
+  OPENMP_CXXFLAGS="\$(SHLIB_OPENMP_CXXFLAGS)"
   ac_pkg_openmp=no
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether OpenMP will work in a package" >&5
 $as_echo_n "checking whether OpenMP will work in a package... " >&6; }

R-package/configure.ac

@@ -8,12 +8,12 @@ OPENMP_CXXFLAGS=""
 
 if test `uname -s` = "Linux"
 then
-  OPENMP_CXXFLAGS="\$(SHLIB_OPENMP_CFLAGS)"
+  OPENMP_CXXFLAGS="\$(SHLIB_OPENMP_CXXFLAGS)"
 fi
 
 if test `uname -s` = "Darwin"
 then
-  OPENMP_CXXFLAGS="\$(SHLIB_OPENMP_CFLAGS)"
+  OPENMP_CXXFLAGS="\$(SHLIB_OPENMP_CXXFLAGS)"
   ac_pkg_openmp=no
   AC_MSG_CHECKING([whether OpenMP will work in a package])
   AC_LANG_CONFTEST(

R-package/demo/custom_objective.R

@@ -33,7 +33,7 @@ evalerror <- function(preds, dtrain) {
   return(list(metric = "error", value = err))
 }
 
-param <- list(max_depth=2, eta=1, nthread = 2, silent=1, 
+param <- list(max_depth=2, eta=1, nthread = 2, verbosity=0, 
               objective=logregobj, eval_metric=evalerror)
 print ('start training with user customized objective')
 # training with customized objective, we can also do step by step training
@@ -57,7 +57,7 @@ logregobjattr <- function(preds, dtrain) {
   hess <- preds * (1 - preds)
   return(list(grad = grad, hess = hess))
 }
-param <- list(max_depth=2, eta=1, nthread = 2, silent=1, 
+param <- list(max_depth=2, eta=1, nthread = 2, verbosity=0, 
               objective=logregobjattr, eval_metric=evalerror)
 print ('start training with user customized objective, with additional attributes in DMatrix')
 # training with customized objective, we can also do step by step training

R-package/demo/early_stopping.R

@@ -7,7 +7,7 @@ dtest <- xgb.DMatrix(agaricus.test$data, label = agaricus.test$label)
 # note: for customized objective function, we leave objective as default
 # note: what we are getting is margin value in prediction
 # you must know what you are doing
-param <- list(max_depth=2, eta=1, nthread = 2, silent=1)
+param <- list(max_depth=2, eta=1, nthread=2, verbosity=0)
 watchlist <- list(eval = dtest)
 num_round <- 20
 # user define objective function, given prediction, return gradient and second order gradient

R-package/demo/predict_leaf_indices.R

@@ -38,6 +38,7 @@ create.new.tree.features <- function(model, original.features){
 # Convert previous features to one hot encoding
 new.features.train <- create.new.tree.features(bst, agaricus.train$data)
 new.features.test <- create.new.tree.features(bst, agaricus.test$data)
+colnames(new.features.test) <- colnames(new.features.train)
 
 # learning with new features
 new.dtrain <- xgb.DMatrix(data = new.features.train, label = agaricus.train$label)

R-package/man/callbacks.Rd

@@ -18,7 +18,7 @@ the boosting is completed.
 WARNING: side-effects!!! Be aware that these callback functions access and modify things in
 the environment from which they are called from, which is a fairly uncommon thing to do in R.
 
-To write a custom callback closure, make sure you first understand the main concepts about R envoronments.
+To write a custom callback closure, make sure you first understand the main concepts about R environments.
 Check either R documentation on \code{\link[base]{environment}} or the
 \href{http://adv-r.had.co.nz/Environments.html}{Environments chapter} from the "Advanced R"
 book by Hadley Wickham. Further, the best option is to read the code of some of the existing callbacks -

R-package/man/cb.cv.predict.Rd

@@ -15,7 +15,7 @@ depending on the number of prediction outputs per data row. The order of predict
 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
 non-overlapping list of k sets of indices, as in a standard k-fold CV. The predictions would not be
-meaningful when user-profided folds have overlapping indices as in, e.g., random sampling splits.
+meaningful when user-provided folds have overlapping indices as in, e.g., random sampling splits.
 When some of the indices in the training dataset are not included into user-provided \code{folds},
 their prediction value would be \code{NA}.
 }

R-package/man/cb.reset.parameters.Rd

@@ -2,7 +2,7 @@
 % Please edit documentation in R/callbacks.R
 \name{cb.reset.parameters}
 \alias{cb.reset.parameters}
-\title{Callback closure for restetting the booster's parameters at each iteration.}
+\title{Callback closure for resetting the booster's parameters at each iteration.}
 \usage{
 cb.reset.parameters(new_params)
 }
@@ -15,7 +15,7 @@ which returns a new parameter value by using the current iteration number
 and the total number of boosting rounds.}
 }
 \description{
-Callback closure for restetting the booster's parameters at each iteration.
+Callback closure for resetting the booster's parameters at each iteration.
 }
 \details{
 This is a "pre-iteration" callback function used to reset booster's parameters

R-package/man/dimnames.xgb.DMatrix.Rd

@@ -17,7 +17,7 @@ and the second one is column names}
 }
 \description{
 Only column names are supported for \code{xgb.DMatrix}, thus setting of
-row names would have no effect and returnten row names would be NULL.
+row names would have no effect and returned row names would be NULL.
 }
 \details{
 Generic \code{dimnames} methods are used by \code{colnames}.

R-package/man/predict.xgb.Booster.Rd

@@ -7,8 +7,8 @@
 \usage{
 \method{predict}{xgb.Booster}(object, newdata, missing = NA,
   outputmargin = FALSE, ntreelimit = NULL, predleaf = FALSE,
-  predcontrib = FALSE, approxcontrib = FALSE,
-  predinteraction = FALSE, reshape = FALSE, ...)
+  predcontrib = FALSE, approxcontrib = FALSE, predinteraction = FALSE,
+  reshape = FALSE, ...)
 
 \method{predict}{xgb.Booster.handle}(object, ...)
 }
@@ -91,7 +91,7 @@ in \url{http://blog.datadive.net/interpreting-random-forests/}.
 
 With \code{predinteraction = TRUE}, SHAP values of contributions of interaction of each pair of features
 are computed. Note that this operation might be rather expensive in terms of compute and memory.
-Since it quadratically depends on the number of features, it is recommended to perfom selection
+Since it quadratically depends on the number of features, it is recommended to perform selection
 of the most important features first. See below about the format of the returned results.
 }
 \examples{

R-package/man/slice.xgb.DMatrix.Rd

@@ -5,7 +5,7 @@
 \alias{slice.xgb.DMatrix}
 \alias{[.xgb.DMatrix}
 \title{Get a new DMatrix containing the specified rows of
-orginal xgb.DMatrix object}
+original xgb.DMatrix object}
 \usage{
 slice(object, ...)
 
@@ -24,7 +24,7 @@ slice(object, ...)
 }
 \description{
 Get a new DMatrix containing the specified rows of
-orginal xgb.DMatrix object
+original xgb.DMatrix object
 }
 \examples{
 data(agaricus.train, package='xgboost')

R-package/man/xgb.Booster.complete.Rd

@@ -28,7 +28,7 @@ E.g., when an \code{xgb.Booster} model is saved as an R object and then is loade
 its handle (pointer) to an internal xgboost model would be invalid. The majority of xgboost methods
 should still work for such a model object since those methods would be using
 \code{xgb.Booster.complete} internally. However, one might find it to be more efficient to call the
-\code{xgb.Booster.complete} function explicitely once after loading a model as an R-object.
+\code{xgb.Booster.complete} function explicitly once after loading a model as an R-object.
 That would prevent further repeated implicit reconstruction of an internal booster model.
 }
 \examples{
@@ -39,6 +39,7 @@ bst <- xgboost(data = agaricus.train$data, label = agaricus.train$label, max_dep
 saveRDS(bst, "xgb.model.rds")
 
 bst1 <- readRDS("xgb.model.rds")
+if (file.exists("xgb.model.rds")) file.remove("xgb.model.rds")
 # the handle is invalid:
 print(bst1$handle)
 

R-package/man/xgb.DMatrix.Rd

@@ -31,4 +31,5 @@ train <- agaricus.train
 dtrain <- xgb.DMatrix(train$data, label=train$label)
 xgb.DMatrix.save(dtrain, 'xgb.DMatrix.data')
 dtrain <- xgb.DMatrix('xgb.DMatrix.data')
+if (file.exists('xgb.DMatrix.data')) file.remove('xgb.DMatrix.data')
 }

R-package/man/xgb.DMatrix.save.Rd

@@ -20,4 +20,5 @@ train <- agaricus.train
 dtrain <- xgb.DMatrix(train$data, label=train$label)
 xgb.DMatrix.save(dtrain, 'xgb.DMatrix.data')
 dtrain <- xgb.DMatrix('xgb.DMatrix.data')
+if (file.exists('xgb.DMatrix.data')) file.remove('xgb.DMatrix.data')
 }

R-package/man/xgb.attr.Rd

@@ -73,6 +73,7 @@ xgb.attributes(bst) <- list(a = 123, b = "abc")
 
 xgb.save(bst, 'xgb.model')
 bst1 <- xgb.load('xgb.model')
+if (file.exists('xgb.model')) file.remove('xgb.model')
 print(xgb.attr(bst1, "my_attribute"))
 print(xgb.attributes(bst1))
 

R-package/man/xgb.cv.Rd

@@ -4,19 +4,18 @@
 \alias{xgb.cv}
 \title{Cross Validation}
 \usage{
-xgb.cv(params = list(), data, nrounds, nfold, label = NULL,
-  missing = NA, prediction = FALSE, showsd = TRUE,
-  metrics = list(), obj = NULL, feval = NULL, stratified = TRUE,
-  folds = NULL, verbose = TRUE, print_every_n = 1L,
-  early_stopping_rounds = NULL, maximize = NULL, callbacks = list(),
-  ...)
+xgb.cv(params = list(), data, nrounds, nfold, label = NULL, missing = NA,
+  prediction = FALSE, showsd = TRUE, metrics = list(), obj = NULL,
+  feval = NULL, stratified = TRUE, folds = NULL, verbose = TRUE,
+  print_every_n = 1L, early_stopping_rounds = NULL, maximize = NULL,
+  callbacks = list(), ...)
 }
 \arguments{
 \item{params}{the list of parameters. Commonly used ones are:
 \itemize{
   \item \code{objective} objective function, common ones are
   \itemize{
-    \item \code{reg:linear} linear regression
+    \item \code{reg:squarederror} Regression with squared loss
     \item \code{binary:logistic} logistic regression for classification
   }
   \item \code{eta} step size of each boosting step
@@ -59,7 +58,7 @@ from each CV model. This parameter engages the \code{\link{cb.cv.predict}} callb
 \item{obj}{customized objective function. Returns gradient and second order
 gradient with given prediction and dtrain.}
 
-\item{feval}{custimized evaluation function. Returns 
+\item{feval}{customized evaluation function. Returns
 \code{list(metric='metric-name', value='metric-value')} with given
 prediction and dtrain.}
 
@@ -101,7 +100,7 @@ An object of class \code{xgb.cv.synchronous} with the following elements:
         capture parameters changed by the \code{\link{cb.reset.parameters}} callback.
   \item \code{callbacks} callback functions that were either automatically assigned or
         explicitly passed.
-  \item \code{evaluation_log} evaluation history storead as a \code{data.table} with the
+  \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.

R-package/man/xgb.gblinear.history.Rd

@@ -12,7 +12,7 @@ using the \code{cb.gblinear.history()} callback.}
 
 \item{class_index}{zero-based class index to extract the coefficients for only that
 specific class in a multinomial multiclass model. When it is NULL, all the
-coeffients are returned. Has no effect in non-multiclass models.}
+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

R-package/man/xgb.load.Rd

@@ -33,6 +33,7 @@ bst <- xgboost(data = train$data, label = train$label, max_depth = 2,
                eta = 1, nthread = 2, nrounds = 2,objective = "binary:logistic")
 xgb.save(bst, 'xgb.model')
 bst <- xgb.load('xgb.model')
+if (file.exists('xgb.model')) file.remove('xgb.model')
 pred <- predict(bst, test$data)
 }
 \seealso{

R-package/man/xgb.plot.deepness.Rd

@@ -5,11 +5,11 @@
 \alias{xgb.plot.deepness}
 \title{Plot model trees deepness}
 \usage{
-xgb.ggplot.deepness(model = NULL, which = c("2x1", "max.depth",
-  "med.depth", "med.weight"))
+xgb.ggplot.deepness(model = NULL, which = c("2x1", "max.depth", "med.depth",
+  "med.weight"))
 
-xgb.plot.deepness(model = NULL, which = c("2x1", "max.depth",
-  "med.depth", "med.weight"), plot = TRUE, ...)
+xgb.plot.deepness(model = NULL, which = c("2x1", "max.depth", "med.depth",
+  "med.weight"), plot = TRUE, ...)
 }
 \arguments{
 \item{model}{either an \code{xgb.Booster} model generated by the \code{xgb.train} function
@@ -50,7 +50,7 @@ per tree with respect to tree number are created. And \code{which="med.weight"}
 a tree's median absolute leaf weight changes through the iterations.
 
 This function was inspired by the blog post
-\url{http://aysent.github.io/2015/11/08/random-forest-leaf-visualization.html}.
+\url{https://github.com/aysent/random-forest-leaf-visualization}.
 }
 \examples{
 

R-package/man/xgb.plot.importance.Rd

@@ -9,8 +9,8 @@ xgb.ggplot.importance(importance_matrix = NULL, top_n = NULL,
   measure = NULL, rel_to_first = FALSE, n_clusters = c(1:10), ...)
 
 xgb.plot.importance(importance_matrix = NULL, top_n = NULL,
-  measure = NULL, rel_to_first = FALSE, left_margin = 10,
-  cex = NULL, plot = TRUE, ...)
+  measure = NULL, rel_to_first = FALSE, left_margin = 10, cex = NULL,
+  plot = TRUE, ...)
 }
 \arguments{
 \item{importance_matrix}{a \code{data.table} returned by \code{\link{xgb.importance}}.}
@@ -59,8 +59,8 @@ For linear models, \code{rel_to_first = FALSE} would show actual values of the c
 Setting \code{rel_to_first = TRUE} allows to see the picture from the perspective of
 "what is feature's importance contribution relative to the most important feature?"
 
-The ggplot-backend method also performs 1-D custering of the importance values, 
-with bar colors coresponding to different clusters that have somewhat similar importance values.
+The ggplot-backend method also performs 1-D clustering of the importance values,
+with bar colors corresponding to different clusters that have somewhat similar importance values.
 }
 \examples{
 data(agaricus.train)

R-package/man/xgb.plot.shap.Rd

@@ -6,8 +6,8 @@
 \usage{
 xgb.plot.shap(data, shap_contrib = NULL, features = NULL, top_n = 1,
   model = NULL, trees = NULL, target_class = NULL,
-  approxcontrib = FALSE, subsample = NULL, n_col = 1, col = rgb(0,
-  0, 1, 0.2), pch = ".", discrete_n_uniq = 5, discrete_jitter = 0.01,
+  approxcontrib = FALSE, subsample = NULL, n_col = 1, col = rgb(0, 0, 1,
+  0.2), pch = ".", discrete_n_uniq = 5, discrete_jitter = 0.01,
   ylab = "SHAP", plot_NA = TRUE, col_NA = rgb(0.7, 0, 1, 0.6),
   pch_NA = ".", pos_NA = 1.07, plot_loess = TRUE, col_loess = 2,
   span_loess = 0.5, which = c("1d", "2d"), plot = TRUE, ...)
@@ -63,7 +63,7 @@ more than 5 distinct values.}
 
 \item{col_loess}{a color to use for the loess curves.}
 
-\item{span_loess}{the \code{span} paramerer in \code{\link[stats]{loess}}'s call.}
+\item{span_loess}{the \code{span} parameter in \code{\link[stats]{loess}}'s call.}
 
 \item{which}{whether to do univariate or bivariate plotting. NOTE: only 1D is implemented so far.}
 

R-package/man/xgb.save.Rd

@@ -33,6 +33,7 @@ bst <- xgboost(data = train$data, label = train$label, max_depth = 2,
                eta = 1, nthread = 2, nrounds = 2,objective = "binary:logistic")
 xgb.save(bst, 'xgb.model')
 bst <- xgb.load('xgb.model')
+if (file.exists('xgb.model')) file.remove('xgb.model')
 pred <- predict(bst, test$data)
 }
 \seealso{

R-package/man/xgb.train.Rd

@@ -5,17 +5,15 @@
 \alias{xgboost}
 \title{eXtreme Gradient Boosting Training}
 \usage{
-xgb.train(params = list(), data, nrounds, watchlist = list(),
-  obj = NULL, feval = NULL, verbose = 1, print_every_n = 1L,
+xgb.train(params = list(), data, nrounds, watchlist = list(), obj = NULL,
+  feval = NULL, verbose = 1, print_every_n = 1L,
   early_stopping_rounds = NULL, maximize = NULL, save_period = NULL,
-  save_name = "xgboost.model", xgb_model = NULL, callbacks = list(),
-  ...)
+  save_name = "xgboost.model", xgb_model = NULL, callbacks = list(), ...)
 
 xgboost(data = NULL, label = NULL, missing = NA, weight = NULL,
   params = list(), nrounds, verbose = 1, print_every_n = 1L,
   early_stopping_rounds = NULL, maximize = NULL, save_period = NULL,
-  save_name = "xgboost.model", xgb_model = NULL, callbacks = list(),
-  ...)
+  save_name = "xgboost.model", xgb_model = NULL, callbacks = list(), ...)
 }
 \arguments{
 \item{params}{the list of parameters.
@@ -41,6 +39,7 @@ xgboost(data = NULL, label = NULL, missing = NA, weight = NULL,
   \item \code{colsample_bytree} subsample ratio of columns when constructing each tree. Default: 1
   \item \code{num_parallel_tree} Experimental parameter. number of trees to grow per round. Useful to test Random Forest through Xgboost (set \code{colsample_bytree < 1}, \code{subsample  < 1}  and \code{round = 1}) accordingly. Default: 1
   \item \code{monotone_constraints} A numerical vector consists of \code{1}, \code{0} and \code{-1} with its length equals to the number of features in the training data. \code{1} is increasing, \code{-1} is decreasing and \code{0} is no constraint.
+  \item \code{interaction_constraints} A list of vectors specifying feature indices of permitted interactions. Each item of the list represents one permitted interaction where specified features are allowed to interact with each other. Feature index values should start from \code{0} (\code{0} references the first column).  Leave argument unspecified for no interaction constraints.
 }
 
 2.2. Parameter for Linear Booster
@@ -56,7 +55,7 @@ xgboost(data = NULL, label = NULL, missing = NA, weight = NULL,
 \itemize{
 \item \code{objective} specify the learning task and the corresponding learning objective, users can pass a self-defined function to it. The default objective options are below:
   \itemize{
-    \item \code{reg:linear} linear regression (Default).
+    \item \code{reg:squarederror} Regression with squared loss (Default).
     \item \code{reg:logistic} logistic regression.
     \item \code{binary:logistic} logistic regression for binary classification. Output probability.
     \item \code{binary:logitraw} logistic regression for binary classification, output score before logistic transformation.
@@ -86,7 +85,7 @@ the performance of each round's model on mat1 and mat2.}
 \item{obj}{customized objective function. Returns gradient and second order
 gradient with given prediction and dtrain.}
 
-\item{feval}{custimized evaluation function. Returns 
+\item{feval}{customized evaluation function. Returns
 \code{list(metric='metric-name', value='metric-value')} with given
 prediction and dtrain.}
 
@@ -140,14 +139,14 @@ An object of class \code{xgb.Booster} with the following elements:
   \item \code{handle} a handle (pointer) to the xgboost model in memory.
   \item \code{raw} a cached memory dump of the xgboost model saved as R's \code{raw} type.
   \item \code{niter} number of boosting iterations.
-  \item \code{evaluation_log} evaluation history storead as a \code{data.table} with the
+  \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 evaluation
         metrics' values. It is created by the \code{\link{cb.evaluation.log}} callback.
   \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
-        explicitely passed.
+        explicitly passed.
   \item \code{best_iteration} iteration number with the best evaluation metric value
         (only available with early stopping).
   \item \code{best_ntreelimit} the \code{ntreelimit} value corresponding to the best iteration,
@@ -156,7 +155,7 @@ An object of class \code{xgb.Booster} with the following elements:
   \item \code{best_score} the best evaluation metric value during early stopping.
         (only available with early stopping).
   \item \code{feature_names} names of the training dataset features
-        (only when comun names were defined in training data).
+        (only when column names were defined in training data).
   \item \code{nfeatures} number of features in training data.
 }
 }
@@ -178,7 +177,7 @@ The evaluation metric is chosen automatically by Xgboost (according to the objec
 when the \code{eval_metric} parameter is not provided.
 User may set one or several \code{eval_metric} parameters.
 Note that when using a customized metric, only this single metric can be used.
-The folloiwing is the list of built-in metrics for which Xgboost provides optimized implementation:
+The following is the list of built-in metrics for which Xgboost provides optimized implementation:
   \itemize{
      \item \code{rmse} root mean square error. \url{http://en.wikipedia.org/wiki/Root_mean_square_error}
      \item \code{logloss} negative log-likelihood. \url{http://en.wikipedia.org/wiki/Log-likelihood}
@@ -210,7 +209,7 @@ dtest <- xgb.DMatrix(agaricus.test$data, label = agaricus.test$label)
 watchlist <- list(train = dtrain, eval = dtest)
 
 ## A simple xgb.train example:
-param <- list(max_depth = 2, eta = 1, silent = 1, nthread = 2, 
+param <- list(max_depth = 2, eta = 1, verbose = 0, nthread = 2,
               objective = "binary:logistic", eval_metric = "auc")
 bst <- xgb.train(param, dtrain, nrounds = 2, watchlist)
 
@@ -231,12 +230,12 @@ evalerror <- function(preds, dtrain) {
 
 # These functions could be used by passing them either:
 #  as 'objective' and 'eval_metric' parameters in the params list:
-param <- list(max_depth = 2, eta = 1, silent = 1, nthread = 2, 
+param <- list(max_depth = 2, eta = 1, verbose = 0, nthread = 2,
               objective = logregobj, eval_metric = evalerror)
 bst <- xgb.train(param, dtrain, nrounds = 2, watchlist)
 
 #  or through the ... arguments:
-param <- list(max_depth = 2, eta = 1, silent = 1, nthread = 2)
+param <- list(max_depth = 2, eta = 1, verbose = 0, nthread = 2)
 bst <- xgb.train(param, dtrain, nrounds = 2, watchlist,
                  objective = logregobj, eval_metric = evalerror)
 
@@ -246,7 +245,7 @@ bst <- xgb.train(param, dtrain, nrounds = 2, watchlist,
 
 
 ## An xgb.train example of using variable learning rates at each iteration:
-param <- list(max_depth = 2, eta = 1, silent = 1, nthread = 2,
+param <- list(max_depth = 2, eta = 1, verbose = 0, nthread = 2,
               objective = "binary:logistic", eval_metric = "auc")
 my_etas <- list(eta = c(0.5, 0.1))
 bst <- xgb.train(param, dtrain, nrounds = 2, watchlist,

R-package/src/Makevars.in

@@ -17,8 +17,8 @@ endif
 $(foreach v, $(XGB_RFLAGS), $(warning $(v)))
 
 PKG_CPPFLAGS=  -I$(PKGROOT)/include -I$(PKGROOT)/dmlc-core/include -I$(PKGROOT)/rabit/include -I$(PKGROOT) $(XGB_RFLAGS)
-PKG_CXXFLAGS= @OPENMP_CXXFLAGS@ $(SHLIB_PTHREAD_FLAGS)
-PKG_LIBS = @OPENMP_CXXFLAGS@ $(SHLIB_PTHREAD_FLAGS)
+PKG_CXXFLAGS= @OPENMP_CXXFLAGS@ -pthread
+PKG_LIBS = @OPENMP_CXXFLAGS@ -pthread
 OBJECTS= ./xgboost_R.o ./xgboost_custom.o ./xgboost_assert.o ./init.o\
          $(PKGROOT)/amalgamation/xgboost-all0.o $(PKGROOT)/amalgamation/dmlc-minimum0.o\
          $(PKGROOT)/rabit/src/engine_empty.o $(PKGROOT)/rabit/src/c_api.o

R-package/src/Makevars.win

@@ -29,8 +29,8 @@ endif
 $(foreach v, $(XGB_RFLAGS), $(warning $(v)))
 
 PKG_CPPFLAGS=  -I$(PKGROOT)/include -I$(PKGROOT)/dmlc-core/include -I$(PKGROOT)/rabit/include -I$(PKGROOT) $(XGB_RFLAGS)
-PKG_CXXFLAGS= $(SHLIB_OPENMP_CFLAGS) $(SHLIB_PTHREAD_FLAGS)
-PKG_LIBS = $(SHLIB_OPENMP_CFLAGS) $(SHLIB_PTHREAD_FLAGS)
+PKG_CXXFLAGS= $(SHLIB_OPENMP_CXXFLAGS) $(SHLIB_PTHREAD_FLAGS)
+PKG_LIBS = $(SHLIB_OPENMP_CXXFLAGS) $(SHLIB_PTHREAD_FLAGS)
 OBJECTS= ./xgboost_R.o ./xgboost_custom.o ./xgboost_assert.o ./init.o\
          $(PKGROOT)/amalgamation/xgboost-all0.o $(PKGROOT)/amalgamation/dmlc-minimum0.o\
          $(PKGROOT)/rabit/src/engine_empty.o $(PKGROOT)/rabit/src/c_api.o

R-package/src/init.c

@@ -70,7 +70,7 @@ static const R_CallMethodDef CallEntries[] = {
 
 #if defined(_WIN32)
 __declspec(dllexport)
-#endif
+#endif  // defined(_WIN32)
 void R_init_xgboost(DllInfo *dll) {
   R_registerRoutines(dll, NULL, CallEntries, NULL, NULL);
   R_useDynamicSymbols(dll, FALSE);

R-package/src/xgboost_R.h

@@ -1,6 +1,6 @@
 /*!
  * Copyright 2014 (c) by Contributors
- * \file xgboost_wrapper_R.h
+ * \file xgboost_R.h
  * \author Tianqi Chen
  * \brief R wrapper of xgboost
  */

R-package/src/xgboost_custom.cc

@@ -3,7 +3,7 @@
 // to change behavior of libxgboost
 
 #include <xgboost/logging.h>
-#include "src/common/random.h"
+#include "../../src/common/random.h"
 #include "./xgboost_R.h"
 
 // redirect the messages to R's console.
@@ -32,7 +32,10 @@ extern "C" {
 
 namespace xgboost {
 ConsoleLogger::~ConsoleLogger() {
-  dmlc::CustomLogMessage::Log(log_stream_.str());
+  if (cur_verbosity_ == LogVerbosity::kIgnore ||
+      cur_verbosity_ <= global_verbosity_) {
+    dmlc::CustomLogMessage::Log(log_stream_.str());
+  }
 }
 TrackerLogger::~TrackerLogger() {
   dmlc::CustomLogMessage::Log(log_stream_.str());
@@ -46,10 +49,11 @@ namespace common {
 bool CheckNAN(double v) {
   return ISNAN(v);
 }
+#if !defined(XGBOOST_USE_CUDA)
 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

R-package/tests/testthat/test_basic.R

@@ -182,7 +182,7 @@ test_that("xgb.cv works", {
   expect_is(cv, 'xgb.cv.synchronous')
   expect_false(is.null(cv$evaluation_log))
   expect_lt(cv$evaluation_log[, min(test_error_mean)], 0.03)
-  expect_lt(cv$evaluation_log[, min(test_error_std)], 0.004)
+  expect_lt(cv$evaluation_log[, min(test_error_std)], 0.008)
   expect_equal(cv$niter, 2)
   expect_false(is.null(cv$folds) && is.list(cv$folds))
   expect_length(cv$folds, 5)

R-package/tests/testthat/test_callbacks.R

@@ -236,7 +236,7 @@ test_that("early stopping using a specific metric works", {
   expect_equal(length(pred), 1611)
   logloss_pred <- sum(-ltest * log(pred) - (1 - ltest) * log(1 - pred)) / length(ltest)
   logloss_log <- bst$evaluation_log[bst$best_iteration, test_logloss]
-  expect_equal(logloss_log, logloss_pred, tolerance = 5e-6)
+  expect_equal(logloss_log, logloss_pred, tolerance = 1e-5)
 })
 
 test_that("early stopping xgb.cv works", {
@@ -282,7 +282,7 @@ test_that("prediction in xgb.cv works for gblinear too", {
 })
 
 test_that("prediction in early-stopping xgb.cv works", {
-  set.seed(1)
+  set.seed(11)
   expect_output(
     cv <- xgb.cv(param, dtrain, nfold = 5, eta = 0.1, nrounds = 20,
                  early_stopping_rounds = 5, maximize = FALSE, prediction = TRUE)

R-package/tests/testthat/test_custom_objective.R

@@ -31,7 +31,7 @@ num_round <- 2
 test_that("custom objective works", {
   bst <- xgb.train(param, dtrain, num_round, watchlist)
   expect_equal(class(bst), "xgb.Booster")
-  expect_equal(length(bst$raw), 1094)
+  expect_equal(length(bst$raw), 1100)
   expect_false(is.null(bst$evaluation_log))
   expect_false(is.null(bst$evaluation_log$eval_error))
   expect_lt(bst$evaluation_log[num_round, eval_error], 0.03)
@@ -58,5 +58,5 @@ test_that("custom objective using DMatrix attr works", {
   param$objective = logregobjattr
   bst <- xgb.train(param, dtrain, num_round, watchlist)
   expect_equal(class(bst), "xgb.Booster")
-  expect_equal(length(bst$raw), 1094)
+  expect_equal(length(bst$raw), 1100)
 })

R-package/tests/testthat/test_helpers.R

@@ -163,6 +163,7 @@ test_that("xgb-attribute functionality", {
   # serializing:
   xgb.save(bst.Tree, 'xgb.model')
   bst <- xgb.load('xgb.model')
+  if (file.exists('xgb.model')) file.remove('xgb.model')
   expect_equal(xgb.attr(bst, "my_attr"), val)
   expect_equal(xgb.attributes(bst), list.ch)
   # deletion:
@@ -199,10 +200,12 @@ if (grepl('Windows', Sys.info()[['sysname']]) ||
 test_that("xgb.Booster serializing as R object works", {
   saveRDS(bst.Tree, 'xgb.model.rds')
   bst <- readRDS('xgb.model.rds')
+  if (file.exists('xgb.model.rds')) file.remove('xgb.model.rds')
   dtrain <- xgb.DMatrix(sparse_matrix, label = label)
   expect_equal(predict(bst.Tree, dtrain), predict(bst, dtrain), tolerance = float_tolerance)
   expect_equal(xgb.dump(bst.Tree), xgb.dump(bst))
   xgb.save(bst, 'xgb.model')
+  if (file.exists('xgb.model')) file.remove('xgb.model')
   nil_ptr <- new("externalptr")
   class(nil_ptr) <- "xgb.Booster.handle"
   expect_true(identical(bst$handle, nil_ptr))

R-package/tests/testthat/test_interactions.R

@@ -81,6 +81,39 @@ test_that("predict feature interactions works", {
   expect_lt(max(abs(intr - gt_intr)), 0.1)
 })
 
+test_that("SHAP contribution values are not NAN", {
+  d <- data.frame(
+    x1 = c(-2.3, 1.4, 5.9, 2, 2.5, 0.3, -3.6, -0.2, 0.5, -2.8, -4.6, 3.3, -1.2,
+           -1.1, -2.3, 0.4, -1.5, -0.2, -1, 3.7),
+    x2 = c(291.179171, 269.198331, 289.942097, 283.191669, 269.673332,
+           294.158346, 287.255835, 291.530838, 285.899586, 269.290833,
+           268.649586, 291.530841, 280.074593, 269.484168, 293.94042,
+           294.327506, 296.20709, 295.441669, 283.16792, 270.227085),
+    y = c(9, 15, 5.7, 9.2, 22.4, 5, 9, 3.2, 7.2, 13.1, 7.8, 16.9, 6.5, 22.1,
+          5.3, 10.4, 11.1, 13.9, 11, 20.5),
+    fold = c(2, 2, 2, 1, 2, 2, 1, 2, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2))
+
+  ivs <- c("x1", "x2")
+
+  fit <- xgboost(
+    verbose = 0,
+    params = list(
+      objective = "reg:squarederror",
+      eval_metric = "rmse"),
+    data = as.matrix(subset(d, fold == 2)[, ivs]),
+    label = subset(d, fold == 2)$y,
+    nthread = 1,
+    nrounds = 3)
+
+  shaps <- as.data.frame(predict(fit,
+    newdata = as.matrix(subset(d, fold == 1)[, ivs]),
+    predcontrib = T))
+  result <- cbind(shaps, sum = rowSums(shaps), pred = predict(fit,
+      newdata = as.matrix(subset(d, fold == 1)[, ivs])))
+
+  expect_true(identical(TRUE, all.equal(result$sum, result$pred, tol = 1e-6)))
+})
+
 
 test_that("multiclass feature interactions work", {
   dm <- xgb.DMatrix(as.matrix(iris[,-5]), label=as.numeric(iris$Species)-1)

R-package/vignettes/discoverYourData.Rmd

@@ -138,7 +138,7 @@ levels(df[,Treatment])
 
 Next step, we will transform the categorical data to dummy variables.
 Several encoding methods exist, e.g., [one-hot encoding](http://en.wikipedia.org/wiki/One-hot) is a common approach.
-We will use the [dummy contrast coding](http://www.ats.ucla.edu/stat/r/library/contrast_coding.htm#dummy) which is popular because it producess "full rank" encoding (also see [this blog post by Max Kuhn](http://appliedpredictivemodeling.com/blog/2013/10/23/the-basics-of-encoding-categorical-data-for-predictive-models)).
+We will use the [dummy contrast coding](http://www.ats.ucla.edu/stat/r/library/contrast_coding.htm#dummy) which is popular because it produces "full rank" encoding (also see [this blog post by Max Kuhn](http://appliedpredictivemodeling.com/blog/2013/10/23/the-basics-of-encoding-categorical-data-for-predictive-models)).
 
 The purpose is to transform each value of each *categorical* feature into a *binary* feature `{0, 1}`.
 
@@ -268,7 +268,7 @@ c2 <- chisq.test(df$Age, output_vector)
 print(c2)
 ```
 
-Pearson correlation between Age and illness disapearing is **`r round(c2$statistic, 2 )`**.
+Pearson correlation between Age and illness disappearing is **`r round(c2$statistic, 2 )`**.
 
 ```{r, warning=FALSE, message=FALSE}
 c2 <- chisq.test(df$AgeDiscret, output_vector)

R-package/vignettes/xgboostPresentation.Rmd

@@ -313,7 +313,7 @@ Until now, all the learnings we have performed were based on boosting trees. **X
 bst <- xgb.train(data=dtrain, booster = "gblinear", max_depth=2, nthread = 2, nrounds=2, watchlist=watchlist, eval_metric = "error", eval_metric = "logloss", objective = "binary:logistic")
 ```
 
-In this specific case, *linear boosting* gets sligtly better performance metrics than decision trees based algorithm.
+In this specific case, *linear boosting* gets slightly better performance metrics than decision trees based algorithm.
 
 In simple cases, it will happen because there is nothing better than a linear algorithm to catch a linear link. However, decision trees are much better to catch a non linear link between predictors and outcome. Because there is no silver bullet, we advise you to check both algorithms with your own datasets to have an idea of what to use.
 

R-package/vignettes/xgboostfromJSON.Rmd

@@ -0,0 +1,189 @@
+---
+title: "XGBoost from JSON"
+output:
+  rmarkdown::html_vignette:
+    number_sections: yes
+    toc: yes
+author: Roland Stevenson
+vignette: >
+  %\VignetteIndexEntry{XGBoost from JSON}
+  %\VignetteEngine{knitr::rmarkdown}
+  \usepackage[utf8]{inputenc}
+---
+
+XGBoost from JSON
+=================
+
+## Introduction
+
+The purpose of this Vignette is to show you how to correctly load and work with an **Xgboost** model that has been dumped to JSON.  **Xgboost** internally converts all data to [32-bit floats](https://en.wikipedia.org/wiki/Single-precision_floating-point_format), and the values dumped to JSON are decimal representations of these values.  When working with a model that has been parsed from a JSON file, care must be taken to correctly treat:
+
+- the input data, which should be converted to 32-bit floats
+- any 32-bit floats that were stored in JSON as decimal representations
+- any calculations must be done with 32-bit mathematical operators
+
+## Setup
+
+For the purpose of this tutorial we will load the xgboost, jsonlite, and float packages.  We'll also set `digits=22` in our options in case we want to inspect many digits of our results.
+
+```{r}
+require(xgboost)
+require(jsonlite)
+require(float)
+options(digits=22)
+```
+
+We will create a toy binary logistic model based on the example first provided [here](https://github.com/dmlc/xgboost/issues/3960), so that we can easily understand the structure of the dumped JSON model object.  This will allow us to understand where discrepancies can occur and how they should be handled.
+
+```{r}
+dates <- c(20180130, 20180130, 20180130,
+           20180130, 20180130, 20180130,
+           20180131, 20180131, 20180131,
+           20180131, 20180131, 20180131,
+           20180131, 20180131, 20180131,
+           20180134, 20180134, 20180134)
+
+labels <- c(1, 1, 1,
+            1, 1, 1,
+            0, 0, 0,
+            0, 0, 0,
+            0, 0, 0,
+            0, 0, 0)
+
+data <- data.frame(dates = dates, labels=labels)
+
+bst <- xgboost(
+  data = as.matrix(data$dates), 
+  label = labels,
+  nthread = 2,
+  nrounds = 1,
+  objective = "binary:logistic",
+  missing = NA,
+  max_depth = 1
+)
+```
+
+## Comparing results
+We will now dump the model to JSON and attempt to illustrate a variety of issues that can arise, and how to properly deal with them.
+
+First let's dump the model to JSON:
+
+```{r}
+bst_json <- xgb.dump(bst, with_stats = FALSE, dump_format='json')
+bst_from_json <- fromJSON(bst_json, simplifyDataFrame = FALSE)
+node <- bst_from_json[[1]]
+cat(bst_json)
+```
+
+The tree JSON shown by the above code-chunk tells us that if the data is less than 20180132, the tree will output the value in the first leaf.  Otherwise it will output the value in the second leaf.  Let's try to reproduce this manually with the data we have and confirm that it matches the model predictions we've already calculated.
+
+```{r}
+bst_preds_logodds <- predict(bst,as.matrix(data$dates), outputmargin = TRUE)
+
+# calculate the logodds values using the JSON representation
+bst_from_json_logodds <- ifelse(data$dates<node$split_condition,
+                                node$children[[1]]$leaf,
+                                node$children[[2]]$leaf)
+
+bst_preds_logodds
+bst_from_json_logodds
+
+# test that values are equal
+bst_preds_logodds == bst_from_json_logodds
+
+```
+None are equal.  What happened?
+
+At this stage two things happened:
+
+- input data was not converted to 32-bit floats
+- the JSON variables were not converted to 32-bit floats
+
+### Lesson 1: All data is 32-bit floats
+
+> When working with imported JSON, all data must be converted to 32-bit floats
+
+To explain this, let's repeat the comparison and round to two decimals:
+
+```{r}
+round(bst_preds_logodds,2) == round(bst_from_json_logodds,2)
+```
+
+If we round to two decimals, we see that only the elements related to data values of `20180131` don't agree.  If we convert the data to floats, they agree:
+
+```{r}
+# now convert the dates to floats first
+bst_from_json_logodds <- ifelse(fl(data$dates)<node$split_condition,
+                                node$children[[1]]$leaf,
+                                node$children[[2]]$leaf)
+
+# test that values are equal
+round(bst_preds_logodds,2) == round(bst_from_json_logodds,2)
+```
+
+What's the lesson?  If we are going to work with an imported JSON model, any data must be converted to floats first.  In this case, since '20180131' cannot be represented as a 32-bit float, it is rounded up to 20180132, as shown here:
+
+```{r}
+fl(20180131)
+```
+
+
+### Lesson 2: JSON parameters are 32-bit floats
+
+> All JSON parameters stored as floats must be converted to floats.
+
+Let's now say we do care about numbers past the first two decimals.
+
+```{r}
+# test that values are equal
+bst_preds_logodds == bst_from_json_logodds
+```
+
+None are exactly equal.  What happened?  Although we've converted the data to 32-bit floats, we also need to convert the JSON parameters to 32-bit floats.  Let's do this:
+
+```{r}
+# now convert the dates to floats first
+bst_from_json_logodds <- ifelse(fl(data$dates)<fl(node$split_condition),
+                                as.numeric(fl(node$children[[1]]$leaf)),
+                                as.numeric(fl(node$children[[2]]$leaf)))
+
+# test that values are equal
+bst_preds_logodds == bst_from_json_logodds
+```
+All equal.  What's the lesson?  If we are going to work with an imported JSON model, any JSON parameters that were stored as floats must also be converted to floats first.
+
+### Lesson 3: Use 32-bit math
+
+> Always use 32-bit numbers and operators
+
+We were able to get the log-odds to agree, so now let's manually calculate the sigmoid of the log-odds.  This should agree with the xgboost predictions.
+
+
+```{r}
+bst_preds <- predict(bst,as.matrix(data$dates))
+
+# calculate the predictions casting doubles to floats
+bst_from_json_preds <- ifelse(fl(data$dates)<fl(node$split_condition),
+                              as.numeric(1/(1+exp(-1*fl(node$children[[1]]$leaf)))),
+                              as.numeric(1/(1+exp(-1*fl(node$children[[2]]$leaf))))
+)
+
+# test that values are equal
+bst_preds == bst_from_json_preds
+```
+
+None are exactly equal again.  What is going on here?  Well, since we are using the value `1` in the calcuations, we have introduced a double into the calculation.  Because of this, all float values are promoted to 64-bit doubles and the 64-bit version of the exponentiation operator `exp` is also used.  On the other hand, xgboost uses the 32-bit version of the exponentation operator in its [sigmoid function](https://github.com/dmlc/xgboost/blob/54980b8959680a0da06a3fc0ec776e47c8cbb0a1/src/common/math.h#L25-L27).
+
+How do we fix this?  We have to ensure we use the correct datatypes everywhere and the correct operators.  If we use only floats, the float library that we have loaded will ensure the 32-bit float exponention operator is applied. 
+```{r}
+# calculate the predictions casting doubles to floats
+bst_from_json_preds <- ifelse(fl(data$dates)<fl(node$split_condition),
+                              as.numeric(fl(1)/(fl(1)+exp(fl(-1)*fl(node$children[[1]]$leaf)))),
+                              as.numeric(fl(1)/(fl(1)+exp(fl(-1)*fl(node$children[[2]]$leaf))))
+)
+
+# test that values are equal
+bst_preds == bst_from_json_preds
+```
+
+All equal.  What's the lesson?  We have to ensure that all calculations are done with 32-bit floating point operators if we want to reproduce the results that we see with xgboost.

README.md

@@ -1,6 +1,7 @@
 <img src=https://raw.githubusercontent.com/dmlc/dmlc.github.io/master/img/logo-m/xgboost.png width=135/>  eXtreme Gradient Boosting
 ===========
-[![Build Status](https://travis-ci.org/dmlc/xgboost.svg?branch=master)](https://travis-ci.org/dmlc/xgboost)
+[![Build Status](https://xgboost-ci.net/job/xgboost/job/master/badge/icon?style=plastic)](https://xgboost-ci.net/blue/organizations/jenkins/xgboost/activity)
+[![Build Status](https://img.shields.io/travis/dmlc/xgboost.svg?label=build&logo=travis&branch=master)](https://travis-ci.org/dmlc/xgboost)
 [![Build Status](https://ci.appveyor.com/api/projects/status/5ypa8vaed6kpmli8?svg=true)](https://ci.appveyor.com/project/tqchen/xgboost)
 [![Documentation Status](https://readthedocs.org/projects/xgboost/badge/?version=latest)](https://xgboost.readthedocs.org)
 [![GitHub license](http://dmlc.github.io/img/apache2.svg)](./LICENSE)
@@ -31,3 +32,35 @@ Reference
 ---------
 - Tianqi Chen and Carlos Guestrin. [XGBoost: A Scalable Tree Boosting System](http://arxiv.org/abs/1603.02754). In 22nd SIGKDD Conference on Knowledge Discovery and Data Mining, 2016
 - XGBoost originates from research project at University of Washington.
+
+Sponsors
+--------
+Become a sponsor and get a logo here. See details at [Sponsoring the XGBoost Project](https://xgboost.ai/sponsors). The funds are used to defray the cost of continuous integration and testing infrastructure (https://xgboost-ci.net).
+
+## Open Source Collective sponsors
+[![Backers on Open Collective](https://opencollective.com/xgboost/backers/badge.svg)](#backers) [![Sponsors on Open Collective](https://opencollective.com/xgboost/sponsors/badge.svg)](#sponsors) 
+
+### Sponsors
+[[Become a sponsor](https://opencollective.com/xgboost#sponsor)]
+
+<!--<a href="https://opencollective.com/xgboost/sponsor/0/website" target="_blank"><img src="https://opencollective.com/xgboost/sponsor/0/avatar.svg"></a>-->
+<a href="https://www.nvidia.com/en-us/" target="_blank"><img src="https://raw.githubusercontent.com/xgboost-ai/xgboost-ai.github.io/master/images/sponsors/nvidia.jpg" alt="NVIDIA" width="72" height="72"></a>
+<a href="https://opencollective.com/xgboost/sponsor/1/website" target="_blank"><img src="https://opencollective.com/xgboost/sponsor/1/avatar.svg"></a>
+<a href="https://opencollective.com/xgboost/sponsor/2/website" target="_blank"><img src="https://opencollective.com/xgboost/sponsor/2/avatar.svg"></a>
+<a href="https://opencollective.com/xgboost/sponsor/3/website" target="_blank"><img src="https://opencollective.com/xgboost/sponsor/3/avatar.svg"></a>
+<a href="https://opencollective.com/xgboost/sponsor/4/website" target="_blank"><img src="https://opencollective.com/xgboost/sponsor/4/avatar.svg"></a>
+<a href="https://opencollective.com/xgboost/sponsor/5/website" target="_blank"><img src="https://opencollective.com/xgboost/sponsor/5/avatar.svg"></a>
+<a href="https://opencollective.com/xgboost/sponsor/6/website" target="_blank"><img src="https://opencollective.com/xgboost/sponsor/6/avatar.svg"></a>
+<a href="https://opencollective.com/xgboost/sponsor/7/website" target="_blank"><img src="https://opencollective.com/xgboost/sponsor/7/avatar.svg"></a>
+<a href="https://opencollective.com/xgboost/sponsor/8/website" target="_blank"><img src="https://opencollective.com/xgboost/sponsor/8/avatar.svg"></a>
+<a href="https://opencollective.com/xgboost/sponsor/9/website" target="_blank"><img src="https://opencollective.com/xgboost/sponsor/9/avatar.svg"></a>
+
+### Backers
+[[Become a backer](https://opencollective.com/xgboost#backer)]
+
+<a href="https://opencollective.com/xgboost#backers" target="_blank"><img src="https://opencollective.com/xgboost/backers.svg?width=890"></a>
+
+## Other sponsors
+The sponsors in this list are donating cloud hours in lieu of cash donation.
+
+<a href="https://aws.amazon.com/" target="_blank"><img src="https://raw.githubusercontent.com/xgboost-ai/xgboost-ai.github.io/master/images/sponsors/aws.png" alt="Amazon Web Services" width="72" height="72"></a>

amalgamation/xgboost-all0.cc

@@ -48,7 +48,7 @@
 #include "../src/tree/tree_model.cc"
 #include "../src/tree/tree_updater.cc"
 #include "../src/tree/updater_colmaker.cc"
-#include "../src/tree/updater_fast_hist.cc"
+#include "../src/tree/updater_quantile_hist.cc"
 #include "../src/tree/updater_prune.cc"
 #include "../src/tree/updater_refresh.cc"
 #include "../src/tree/updater_sync.cc"

appveyor.yml

@@ -36,26 +36,32 @@ install:
     - set PATH=C:\msys64\mingw64\bin;C:\msys64\usr\bin;%PATH%
     - gcc -v
     - ls -l C:\
-    # Miniconda2
-    - set PATH=;C:\Miniconda-x64;C:\Miniconda-x64\Scripts;%PATH%
+    # Miniconda3
+    - call C:\Miniconda3-x64\Scripts\activate.bat
+    - conda info
     - where python
     - python --version
     # do python build for mingw and one of the msvc jobs
     - set DO_PYTHON=off
     - if /i "%target%" == "mingw" set DO_PYTHON=on
     - if /i "%target%_%ver%_%configuration%" == "msvc_2015_Release" set DO_PYTHON=on
-    - if /i "%DO_PYTHON%" == "on" conda install -y numpy scipy pandas matplotlib nose scikit-learn graphviz python-graphviz
+    - if /i "%DO_PYTHON%" == "on" (
+        conda config --set always_yes true &&
+        conda update -q conda &&
+        conda install -y numpy scipy pandas matplotlib pytest scikit-learn graphviz python-graphviz
+      )
+    - set PATH=C:\Miniconda3-x64\Library\bin\graphviz;%PATH%
     # R: based on https://github.com/krlmlr/r-appveyor
     - ps: |
         if($env:target -eq 'rmingw' -or $env:target -eq 'rmsvc') {
           #$ErrorActionPreference = "Stop"
-          Invoke-WebRequest http://raw.github.com/krlmlr/r-appveyor/master/scripts/appveyor-tool.ps1 -OutFile "$Env:TEMP\appveyor-tool.ps1"
+          Invoke-WebRequest https://raw.githubusercontent.com/krlmlr/r-appveyor/master/scripts/appveyor-tool.ps1 -OutFile "$Env:TEMP\appveyor-tool.ps1"
           Import-Module "$Env:TEMP\appveyor-tool.ps1"
           Bootstrap
-          $DEPS = "c('data.table','magrittr','stringi','ggplot2','DiagrammeR','Ckmeans.1d.dp','vcd','testthat','lintr','knitr','rmarkdown')"
-          cmd.exe /c "R.exe -q -e ""install.packages($DEPS, repos='$CRAN', type='both')"" 2>&1"
           $BINARY_DEPS = "c('XML','igraph')"
           cmd.exe /c "R.exe -q -e ""install.packages($BINARY_DEPS, repos='$CRAN', type='win.binary')"" 2>&1"
+          $DEPS = "c('data.table','magrittr','stringi','ggplot2','DiagrammeR','Ckmeans.1d.dp','vcd','testthat','lintr','knitr','rmarkdown')"
+          cmd.exe /c "R.exe -q -e ""install.packages($DEPS, repos='$CRAN', type='both')"" 2>&1"
         }
 
 build_script:
@@ -96,10 +102,11 @@ build_script:
 
 test_script:
     - cd %APPVEYOR_BUILD_FOLDER%
-    - if /i "%DO_PYTHON%" == "on" python -m nose tests/python
+    - if /i "%DO_PYTHON%" == "on" python -m pytest tests/python
     # mingw R package: run the R check (which includes unit tests), and also keep the built binary package
     - if /i "%target%" == "rmingw" (
         set _R_CHECK_CRAN_INCOMING_=FALSE&&
+        set _R_CHECK_FORCE_SUGGESTS_=FALSE&&
         R.exe CMD check xgboost*.tar.gz --no-manual --no-build-vignettes --as-cran --install-args=--build
       )
     # MSVC R package: run only the unit tests

build.sh

@@ -1,51 +0,0 @@
-#!/bin/bash
-# This is a simple script to make xgboost in MAC and Linux
-# Basically, it first try to make with OpenMP, if fails, disable OpenMP and make it again.
-# This will automatically make xgboost for MAC users who don't have OpenMP support.
-# In most cases, type make will give what you want.
-
-# See additional instruction in doc/build.md
-set -e
-
-if make; then
-    echo "Successfully build multi-thread xgboost"
-else
-
-    not_ready=0
-
-    if [[ ! -e ./rabit/Makefile ]]; then
-        echo ""
-        echo "Please init the rabit submodule:"
-        echo "git submodule update --init --recursive -- rabit"
-        not_ready=1
-    fi
-    
-    if [[ ! -e ./dmlc-core/Makefile ]]; then
-        echo ""
-        echo "Please init the dmlc-core submodule:"
-        echo "git submodule update --init --recursive -- dmlc-core"
-        not_ready=1
-    fi
-
-    if [[ "${not_ready}" == "1" ]]; then
-        echo ""
-        echo "Please fix the errors above and retry the build, or reclone the repository with:"
-        echo "git clone --recursive https://github.com/dmlc/xgboost.git"
-        echo ""
-        exit 1
-    fi
-
-
-    echo "-----------------------------"
-    echo "Building multi-thread xgboost failed"
-    echo "Start to build single-thread xgboost"
-    make clean_all
-    make config=make/minimum.mk
-    if [ $? -eq 0 ] ;then
-      echo "Successfully build single-thread xgboost"
-      echo "If you want multi-threaded version"
-      echo "See additional instructions in doc/build.md"
-    else
-      echo "Failed to build single-thread xgboost"
-    fi
-fi

cmake/Doc.cmake

@@ -0,0 +1,16 @@
+function (run_doxygen)
+  find_package(Doxygen REQUIRED)
+
+  if (NOT DOXYGEN_DOT_FOUND)
+    message(FATAL_ERROR "Command `dot` not found.  Please install graphviz.")
+  endif (NOT DOXYGEN_DOT_FOUND)
+
+  configure_file(
+    ${PROJECT_SOURCE_DIR}/doc/Doxyfile.in
+    ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile @ONLY)
+  add_custom_target( doc_doxygen ALL
+    COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
+    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+    COMMENT "Generate C APIs documentation."
+    VERBATIM)
+endfunction (run_doxygen)

cmake/Utils.cmake

@@ -1,4 +1,3 @@
-
 # Automatically set source group based on folder
 function(auto_source_group SOURCES)
 
@@ -18,6 +17,10 @@ endfunction(auto_source_group)
 function(msvc_use_static_runtime)
   if(MSVC)
       set(variables
+          CMAKE_C_FLAGS_DEBUG
+          CMAKE_C_FLAGS_MINSIZEREL
+          CMAKE_C_FLAGS_RELEASE
+          CMAKE_C_FLAGS_RELWITHDEBINFO
           CMAKE_CXX_FLAGS_DEBUG
           CMAKE_CXX_FLAGS_MINSIZEREL
           CMAKE_CXX_FLAGS_RELEASE
@@ -29,6 +32,23 @@ function(msvc_use_static_runtime)
               set(${variable} "${${variable}}"  PARENT_SCOPE)
           endif()
       endforeach()
+      set(variables
+          CMAKE_CUDA_FLAGS
+          CMAKE_CUDA_FLAGS_DEBUG
+          CMAKE_CUDA_FLAGS_MINSIZEREL
+          CMAKE_CUDA_FLAGS_RELEASE
+          CMAKE_CUDA_FLAGS_RELWITHDEBINFO
+      )
+      foreach(variable ${variables})
+          if(${variable} MATCHES "-MD")
+              string(REGEX REPLACE "-MD" "-MT" ${variable} "${${variable}}")
+              set(${variable} "${${variable}}"  PARENT_SCOPE)
+          endif()
+          if(${variable} MATCHES "/MD")
+              string(REGEX REPLACE "/MD" "/MT" ${variable} "${${variable}}")
+              set(${variable} "${${variable}}"  PARENT_SCOPE)
+          endif()
+      endforeach()
   endif()
 endfunction(msvc_use_static_runtime)
 
@@ -57,9 +77,14 @@ endfunction(set_default_configuration_release)
 # Generate nvcc compiler flags given a list of architectures
 # Also generates PTX for the most recent architecture for forwards compatibility
 function(format_gencode_flags flags out)
+  if(CMAKE_CUDA_COMPILER_VERSION MATCHES "^([0-9]+\\.[0-9]+)")
+    set(CUDA_VERSION "${CMAKE_MATCH_1}")
+  endif()
   # Set up architecture flags
   if(NOT flags)
-    if((CUDA_VERSION_MAJOR EQUAL 9) OR (CUDA_VERSION_MAJOR GREATER 9))
+    if(CUDA_VERSION VERSION_GREATER_EQUAL "10.0")
+      set(flags "35;50;52;60;61;70;75")
+    elseif(CUDA_VERSION VERSION_GREATER_EQUAL "9.0")
       set(flags "35;50;52;60;61;70")
     else()
       set(flags "35;50;52;60;61")
@@ -67,11 +92,11 @@ function(format_gencode_flags flags out)
   endif()
   # Generate SASS
   foreach(ver ${flags})
-    set(${out} "${${out}}-gencode arch=compute_${ver},code=sm_${ver};")
+    set(${out} "${${out}}--generate-code=arch=compute_${ver},code=sm_${ver};")
   endforeach()
   # Generate PTX for last architecture
   list(GET flags -1 ver)
-  set(${out} "${${out}}-gencode arch=compute_${ver},code=compute_${ver};")
+  set(${out} "${${out}}--generate-code=arch=compute_${ver},code=compute_${ver};")
 
   set(${out} "${${out}}" PARENT_SCOPE)
 endfunction(format_gencode_flags flags)
@@ -80,6 +105,10 @@ endfunction(format_gencode_flags flags)
 # if necessary, installs the main R package dependencies;
 # runs R CMD INSTALL.
 function(setup_rpackage_install_target rlib_target build_dir)
+  # backup cmake_install.cmake
+  install(CODE "file(COPY \"${build_dir}/R-package/cmake_install.cmake\"
+DESTINATION \"${build_dir}/bak\")")
+
   install(CODE "file(REMOVE_RECURSE \"${build_dir}/R-package\")")
   install(
     DIRECTORY "${PROJECT_SOURCE_DIR}/R-package"
@@ -98,4 +127,8 @@ function(setup_rpackage_install_target rlib_target build_dir)
   install(CODE "execute_process(COMMAND \"${LIBR_EXECUTABLE}\" \"-q\" \"-e\" \"${XGB_DEPS_SCRIPT}\")")
   install(CODE "execute_process(COMMAND \"${LIBR_EXECUTABLE}\" CMD INSTALL\
     \"--no-multiarch\" \"--build\" \"${build_dir}/R-package\")")
+
+  # restore cmake_install.cmake
+  install(CODE "file(RENAME \"${build_dir}/bak/cmake_install.cmake\"
+ \"${build_dir}/R-package/cmake_install.cmake\")")
 endfunction(setup_rpackage_install_target)

cmake/modules/FindNccl.cmake

@@ -32,20 +32,28 @@
 #
 # This module assumes that the user has already called find_package(CUDA)
 
+if (NCCL_LIBRARY)
+  # Don't cache NCCL_LIBRARY to enable switching between static and shared.
+  unset(NCCL_LIBRARY CACHE)
+endif()
 
-set(NCCL_LIB_NAME nccl_static)
+if (BUILD_WITH_SHARED_NCCL)
+  # libnccl.so
+  set(NCCL_LIB_NAME nccl)
+else ()
+  # libnccl_static.a
+  set(NCCL_LIB_NAME nccl_static)
+endif (BUILD_WITH_SHARED_NCCL)
 
 find_path(NCCL_INCLUDE_DIR
   NAMES nccl.h
-  PATHS $ENV{NCCL_ROOT}/include ${NCCL_ROOT}/include ${CUDA_INCLUDE_DIRS} /usr/include)
+  PATHS $ENV{NCCL_ROOT}/include ${NCCL_ROOT}/include)
 
 find_library(NCCL_LIBRARY
   NAMES ${NCCL_LIB_NAME}
-  PATHS $ENV{NCCL_ROOT}/lib ${NCCL_ROOT}/lib ${CUDA_INCLUDE_DIRS}/../lib /usr/lib)
+  PATHS $ENV{NCCL_ROOT}/lib/ ${NCCL_ROOT}/lib)
 
-if (NCCL_INCLUDE_DIR AND NCCL_LIBRARY)
-  get_filename_component(NCCL_LIBRARY ${NCCL_LIBRARY} PATH)
-endif ()
+message(STATUS "Using nccl library: ${NCCL_LIBRARY}")
 
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(Nccl DEFAULT_MSG
@@ -54,5 +62,4 @@ find_package_handle_standard_args(Nccl DEFAULT_MSG
 mark_as_advanced(
   NCCL_INCLUDE_DIR
   NCCL_LIBRARY
-  NCCL_LIB_NAME
 )

cmake/xgboost-config.cmake.in

@@ -0,0 +1,5 @@
+@PACKAGE_INIT@
+
+if(NOT TARGET xgboost::xgboost)
+  include(${CMAKE_CURRENT_LIST_DIR}/XGBoostTargets.cmake)
+endif()

demo/README.md

@@ -119,6 +119,7 @@ If you have particular usecase of xgboost that you would like to highlight.
 Send a PR to add a one sentence description:)
 
 - XGBoost is used in [Kaggle Script](https://www.kaggle.com/scripts) to solve data science challenges.
+- Distribute XGBoost as Rest API server from Jupyter notebook with [BentoML](https://github.com/bentoml/bentoml). [Link to notebook](https://github.com/bentoml/BentoML/blob/master/examples/xgboost-predict-titanic-survival/XGBoost-titanic-survival-prediction.ipynb)
 - [Seldon predictive service powered by XGBoost](http://docs.seldon.io/iris-demo.html)
 - XGBoost Distributed is used in [ODPS Cloud Service by Alibaba](https://yq.aliyun.com/articles/6355) (in Chinese)
 - XGBoost is incoporated as part of [Graphlab Create](https://dato.com/products/create/) for scalable machine learning.
@@ -135,6 +136,7 @@ Send a PR to add a one sentence description:)
 
 ## Awards
 - [John Chambers Award](http://stat-computing.org/awards/jmc/winners.html) - 2016 Winner: XGBoost R Package, by Tong He (Simon Fraser University) and Tianqi Chen (University of Washington)
+- [InfoWorld’s 2019 Technology of the Year Award](https://www.infoworld.com/article/3336072/application-development/infoworlds-2019-technology-of-the-year-award-winners.html)
 
 ## Windows Binaries
 Unofficial windows binaries and instructions on how to use them are hosted on [Guido Tapia's blog](http://www.picnet.com.au/blogs/guido/post/2016/09/22/xgboost-windows-x64-binaries-for-download/)

demo/binary_classification/README.md

@@ -62,7 +62,7 @@ test:data = "agaricus.txt.test"
 We use the tree booster and logistic regression objective in our setting. This indicates that we accomplish our task using classic gradient boosting regression tree(GBRT), which is a promising method for binary classification.
 
 The parameters shown in the example gives the most common ones that are needed to use xgboost.
-If you are interested in more parameter settings, the complete parameter settings and detailed descriptions are [here](../../doc/parameter.md). Besides putting the parameters in the configuration file, we can set them by passing them as arguments as below:
+If you are interested in more parameter settings, the complete parameter settings and detailed descriptions are [here](../../doc/parameter.rst). Besides putting the parameters in the configuration file, we can set them by passing them as arguments as below:
 
 ```
 ../../xgboost mushroom.conf max_depth=6

demo/c-api/Makefile

@@ -0,0 +1,19 @@
+SRC=c-api-demo.c
+TGT=c-api-demo
+
+cc=cc
+CFLAGS ?=-O3
+XGBOOST_ROOT ?=../..
+INCLUDE_DIR=-I$(XGBOOST_ROOT)/include -I$(XGBOOST_ROOT)/dmlc-core/include -I$(XGBOOST_ROOT)/rabit/include
+LIB_DIR=-L$(XGBOOST_ROOT)/lib
+
+build: $(TGT)
+
+$(TGT): $(SRC) Makefile
+	$(cc) $(CFLAGS) $(INCLUDE_DIR) $(LIB_DIR) -o $(TGT) $(SRC) -lxgboost
+
+run: $(TGT)
+	LD_LIBRARY_PATH=$(XGBOOST_ROOT)/lib ./$(TGT)
+
+clean:
+	rm -f $(TGT)

demo/c-api/README.md

@@ -0,0 +1,30 @@
+C-APIs
+===
+
+**XGBoost** implements a C API originally designed for various language
+bindings.  For detailed reference, please check xgboost/c_api.h.  Here is a
+demonstration of using the API.
+
+# CMake
+If you use **CMake** for your project, you can either install **XGBoost**
+somewhere in your system and tell CMake to find it by calling
+`find_package(xgboost)`, or put **XGBoost** inside your project's source tree
+and call **CMake** command: `add_subdirectory(xgboost)`.  To use
+`find_package()`, put the following in your **CMakeLists.txt**:
+
+``` CMake
+find_package(xgboost REQUIRED)
+add_executable(api-demo c-api-demo.c)
+target_link_libraries(api-demo xgboost::xgboost)
+```
+
+If you want to put XGBoost inside your project (like git submodule), use this
+instead:
+``` CMake
+add_subdirectory(xgboost)
+add_executable(api-demo c-api-demo.c)
+target_link_libraries(api-demo xgboost)
+```
+
+# make
+You can start by modifying the makefile in this directory to fit your need.

demo/c-api/c-api-demo.c

@@ -0,0 +1,89 @@
+/*!
+ * Copyright 2019 XGBoost contributors
+ *
+ * \file c-api-demo.c
+ * \brief A simple example of using xgboost C API.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <xgboost/c_api.h>
+
+#define safe_xgboost(call) {                                            \
+int err = (call);                                                       \
+if (err != 0) {                                                         \
+  fprintf(stderr, "%s:%d: error in %s: %s\n", __FILE__, __LINE__, #call, XGBGetLastError()); \
+  exit(1);                                                              \
+}                                                                       \
+}
+
+int main(int argc, char** argv) {
+  int silent = 0;
+  int use_gpu = 0;  // set to 1 to use the GPU for training
+  
+  // load the data
+  DMatrixHandle dtrain, dtest;
+  safe_xgboost(XGDMatrixCreateFromFile("../data/agaricus.txt.train", silent, &dtrain));
+  safe_xgboost(XGDMatrixCreateFromFile("../data/agaricus.txt.test", silent, &dtest));
+  
+  // create the booster
+  BoosterHandle booster;
+  DMatrixHandle eval_dmats[2] = {dtrain, dtest};
+  safe_xgboost(XGBoosterCreate(eval_dmats, 2, &booster));
+
+  // configure the training
+  // available parameters are described here:
+  //   https://xgboost.readthedocs.io/en/latest/parameter.html
+  safe_xgboost(XGBoosterSetParam(booster, "tree_method", use_gpu ? "gpu_hist" : "hist"));
+  if (use_gpu) {
+    // set the number of GPUs and the first GPU to use;
+    // this is not necessary, but provided here as an illustration
+    safe_xgboost(XGBoosterSetParam(booster, "n_gpus", "1"));
+    safe_xgboost(XGBoosterSetParam(booster, "gpu_id", "0"));
+  } else {
+    // avoid evaluating objective and metric on a GPU
+    safe_xgboost(XGBoosterSetParam(booster, "n_gpus", "0"));
+  }
+
+  safe_xgboost(XGBoosterSetParam(booster, "objective", "binary:logistic"));
+  safe_xgboost(XGBoosterSetParam(booster, "min_child_weight", "1"));
+  safe_xgboost(XGBoosterSetParam(booster, "gamma", "0.1"));
+  safe_xgboost(XGBoosterSetParam(booster, "max_depth", "3"));
+  safe_xgboost(XGBoosterSetParam(booster, "verbosity", silent ? "0" : "1"));
+  
+  // train and evaluate for 10 iterations
+  int n_trees = 10;
+  const char* eval_names[2] = {"train", "test"};
+  const char* eval_result = NULL;
+  for (int i = 0; i < n_trees; ++i) {
+    safe_xgboost(XGBoosterUpdateOneIter(booster, i, dtrain));
+    safe_xgboost(XGBoosterEvalOneIter(booster, i, eval_dmats, eval_names, 2, &eval_result));
+    printf("%s\n", eval_result);
+  }
+
+  // predict
+  bst_ulong out_len = 0;
+  const float* out_result = NULL;
+  int n_print = 10;
+
+  safe_xgboost(XGBoosterPredict(booster, dtest, 0, 0, &out_len, &out_result));
+  printf("y_pred: ");
+  for (int i = 0; i < n_print; ++i) {
+    printf("%1.4f ", out_result[i]);
+  }
+  printf("\n");
+
+  // print true labels
+  safe_xgboost(XGDMatrixGetFloatInfo(dtest, "label", &out_len, &out_result));
+  printf("y_test: ");
+  for (int i = 0; i < n_print; ++i) {
+    printf("%1.4f ", out_result[i]);
+  }
+  printf("\n");
+
+  // free everything
+  safe_xgboost(XGBoosterFree(booster));
+  safe_xgboost(XGDMatrixFree(dtrain));
+  safe_xgboost(XGDMatrixFree(dtest));
+  return 0;
+}

demo/kaggle-otto/README.MD

@@ -1,4 +1,4 @@
-Benckmark for Otto Group Competition
+Benchmark for Otto Group Competition
 =========
 
 This is a folder containing the benchmark for the [Otto Group Competition on Kaggle](http://www.kaggle.com/c/otto-group-product-classification-challenge).
@@ -20,5 +20,3 @@ devtools::install_github('tqchen/xgboost',subdir='R-package')
 ```
 
 Windows users may need to install [RTools](http://cran.r-project.org/bin/windows/Rtools/) first.
-
-

demo/regression/README.md

@@ -6,9 +6,9 @@ Using XGBoost for regression is very similar to using it for binary classificati
 The dataset we used is the [computer hardware dataset from UCI repository](https://archive.ics.uci.edu/ml/datasets/Computer+Hardware). The demo for regression is almost the same as the [binary classification demo](../binary_classification), except a little difference in general parameter:
 ```
 # General parameter
-# this is the only difference with classification, use reg:linear to do linear regression
+# this is the only difference with classification, use reg:squarederror to do linear regression
 # when labels are in [0,1] we can also use reg:logistic
-objective = reg:linear
+objective = reg:squarederror
 ...
 
 ```

demo/regression/machine.conf

@@ -1,9 +1,9 @@
 # General Parameters, see comment for each definition
 # choose the tree booster, can also change to gblinear
 booster = gbtree
-# this is the only difference with classification, use reg:linear to do linear classification
+# this is the only difference with classification, use reg:squarederror to do linear classification
 # when labels are in [0,1] we can also use reg:logistic
-objective = reg:linear
+objective = reg:squarederror
 
 # Tree Booster Parameters
 # step size shrinkage

demo/yearpredMSD/yearpredMSD.conf

@@ -1,9 +1,9 @@
 # General Parameters, see comment for each definition
 # choose the tree booster, can also change to gblinear
 booster = gbtree
-# this is the only difference with classification, use reg:linear to do linear classification
+# this is the only difference with classification, use reg:squarederror to do linear classification
 # when labels are in [0,1] we can also use reg:logistic
-objective = reg:linear
+objective = reg:squarederror
 
 # Tree Booster Parameters
 # step size shrinkage
@@ -27,4 +27,3 @@ data = "yearpredMSD.libsvm.train"
 eval[test] = "yearpredMSD.libsvm.test"
 # The path of test data
 #test:data = "yearpredMSD.libsvm.test"
-

dev/query_contributors.py

@@ -0,0 +1,63 @@
+"""Query list of all contributors and reviewers in a release"""
+
+from sh.contrib import git
+import sys
+import re
+import requests
+import json
+
+if len(sys.argv) != 5:
+    print(f'Usage: {sys.argv[0]} [starting commit/tag] [ending commit/tag] [GitHub username] [GitHub password]')
+    sys.exit(1)
+
+from_commit = sys.argv[1]
+to_commit = sys.argv[2]
+username = sys.argv[3]
+password = sys.argv[4]
+
+contributors = set()
+reviewers = set()
+
+for line in git.log(f'{from_commit}..{to_commit}', '--pretty=format:%s', '--reverse'):
+    m = re.search('\(#([0-9]+)\)', line.rstrip())
+    if m:
+        pr_id = m.group(1)
+        print(f'PR #{pr_id}')
+
+        r = requests.get(f'https://api.github.com/repos/dmlc/xgboost/pulls/{pr_id}/commits', auth=(username, password))
+        assert r.status_code == requests.codes.ok, f'Code: {r.status_code}, Text: {r.text}'
+        commit_list = json.loads(r.text)
+        try:
+            contributors.update([commit['author']['login'] for commit in commit_list])
+        except TypeError:
+            contributors.update(str(input(f'Error fetching contributors for PR #{pr_id}. Enter it manually, as a space-separated list:')).split(' '))
+
+        r = requests.get(f'https://api.github.com/repos/dmlc/xgboost/pulls/{pr_id}/reviews', auth=(username, password))
+        assert r.status_code == requests.codes.ok, f'Code: {r.status_code}, Text: {r.text}'
+        review_list = json.loads(r.text)
+        reviewers.update([x['user']['login'] for x in review_list])
+
+        r = requests.get(f'https://api.github.com/repos/dmlc/xgboost/issues/{pr_id}/comments', auth=(username, password))
+        assert r.status_code == requests.codes.ok, f'Code: {r.status_code}, Text: {r.text}'
+        comment_list = json.loads(r.text)
+        reviewers.update([x['user']['login'] for x in comment_list])
+
+print('Contributors:', end='')
+for x in sorted(contributors):
+    r = requests.get(f'https://api.github.com/users/{x}', auth=(username, password))
+    assert r.status_code == requests.codes.ok, f'Code: {r.status_code}, Text: {r.text}'
+    user_info = json.loads(r.text)
+    if user_info['name'] is None:
+        print(f"@{x}, ", end='')
+    else:
+        print(f"{user_info['name']} (@{x}), ", end='')
+
+print('Reviewers:', end='')
+for x in sorted(reviewers):
+    r = requests.get(f'https://api.github.com/users/{x}', auth=(username, password))
+    assert r.status_code == requests.codes.ok, f'Code: {r.status_code}, Text: {r.text}'
+    user_info = json.loads(r.text)
+    if user_info['name'] is None:
+        print(f"@{x}, ", end='')
+    else:
+        print(f"{user_info['name']} (@{x}), ", end='')

doc/Doxyfile.in

@@ -38,7 +38,7 @@ PROJECT_NAME           = "xgboost"
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         =
+PROJECT_NUMBER         = @XGBOOST_VERSION@
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a
@@ -58,7 +58,7 @@ PROJECT_LOGO           =
 # entered, it will be relative to the location where doxygen was started. If
 # left blank the current directory will be used.
 
-OUTPUT_DIRECTORY       = doc/doxygen
+OUTPUT_DIRECTORY       = @PROJECT_BINARY_DIR@/doc_doxygen
 
 # If the CREATE_SUBDIRS tag is set to YES, then doxygen will create 4096 sub-
 # directories (in 2 levels) under the output directory of each output format and
@@ -753,7 +753,7 @@ WARN_LOGFILE           =
 # spaces.
 # Note: If this tag is empty the current directory is searched.
 
-INPUT                  = include src/common
+INPUT                  = @PROJECT_SOURCE_DIR@/include @PROJECT_SOURCE_DIR@/src/common
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses

doc/R-package/xgboostPresentation.md

@@ -176,7 +176,7 @@ In a *sparse* matrix, cells containing `0` are not stored in memory. Therefore,
 We will train decision tree model using the following parameters:
 
 * `objective = "binary:logistic"`: we will train a binary classification model ;
-* `max.deph = 2`: the trees won't be deep, because our case is very simple ;
+* `max.depth = 2`: the trees won't be deep, because our case is very simple ;
 * `nthread = 2`: the number of cpu threads we are going to use;
 * `nrounds = 2`: there will be two passes on the data, the second one will enhance the model by further reducing the difference between ground truth and prediction.
 
@@ -576,8 +576,8 @@ print(class(rawVec))
 bst3 <- xgb.load(rawVec)
 pred3 <- predict(bst3, test$data)
 
-# pred2 should be identical to pred
-print(paste("sum(abs(pred3-pred))=", sum(abs(pred2-pred))))
+# pred3 should be identical to pred
+print(paste("sum(abs(pred3-pred))=", sum(abs(pred3-pred))))
 ```
 
 ```

doc/build.rst

@@ -13,7 +13,7 @@ Installation Guide
     #   * xgboost-{version}-py2.py3-none-win_amd64.whl
     pip3 install xgboost
 
-  * The binary wheel will support GPU algorithms (`gpu_exact`, `gpu_hist`) on machines with NVIDIA GPUs. **However, it will not support multi-GPU training; only single GPU will be used.** To enable multi-GPU training, download and install the binary wheel from `this page <https://s3-us-west-2.amazonaws.com/xgboost-wheels/list.html>`_.
+  * The binary wheel will support GPU algorithms (`gpu_exact`, `gpu_hist`) on machines with NVIDIA GPUs. Please note that **training with multiple GPUs is only supported for Linux platform**. See :doc:`gpu/index`.
   * Currently, we provide binary wheels for 64-bit Linux and Windows.
 
 ****************************
@@ -70,19 +70,21 @@ Our goal is to build the shared library:
 The minimal building requirement is
 
 - A recent C++ compiler supporting C++11 (g++-4.8 or higher)
-
-We can edit ``make/config.mk`` to change the compile options, and then build by
-``make``. If everything goes well, we can go to the specific language installation section.
+- CMake 3.2 or higher
 
 Building on Ubuntu/Debian
 =========================
 
-On Ubuntu, one builds XGBoost by running
+On Ubuntu, one builds XGBoost by running CMake:
 
 .. code-block:: bash
 
   git clone --recursive https://github.com/dmlc/xgboost
-  cd xgboost; make -j4
+  cd xgboost
+  mkdir build
+  cd build
+  cmake ..
+  make -j4
 
 Building on OSX
 ===============
@@ -90,11 +92,11 @@ Building on OSX
 Install with pip: simple method
 --------------------------------
 
-First, obtain ``gcc-7`` with Homebrew (https://brew.sh/) to enable multi-threading (i.e. using multiple CPU threads for training). The default Apple Clang compiler does not support OpenMP, so using the default compiler would have disabled multi-threading.
+First, obtain ``gcc-8`` with Homebrew (https://brew.sh/) to enable multi-threading (i.e. using multiple CPU threads for training). The default Apple Clang compiler does not support OpenMP, so using the default compiler would have disabled multi-threading.
 
 .. code-block:: bash
 
-  brew install gcc@7
+  brew install gcc@8
 
 Then install XGBoost with ``pip``:
 
@@ -107,11 +109,11 @@ You might need to run the command with ``--user`` flag if you run into permissio
 Build from the source code - advanced method
 --------------------------------------------
 
-Obtain ``gcc-7`` from Homebrew:
+Obtain ``gcc-8`` from Homebrew:
 
 .. code-block:: bash
 
-  brew install gcc@7
+  brew install gcc@8
 
 Now clone the repository:
 
@@ -119,13 +121,13 @@ Now clone the repository:
 
   git clone --recursive https://github.com/dmlc/xgboost
 
-Create the ``build/`` directory and invoke CMake. Make sure to add ``CC=gcc-7 CXX=g++-7`` so that Homebrew GCC is selected. After invoking CMake, you can build XGBoost with ``make``:
+Create the ``build/`` directory and invoke CMake. Make sure to add ``CC=gcc-8 CXX=g++-8`` so that Homebrew GCC is selected. After invoking CMake, you can build XGBoost with ``make``:
 
 .. code-block:: bash
 
   mkdir build
   cd build
-  CC=gcc-7 CXX=g++-7 cmake ..
+  CC=gcc-8 CXX=g++-8 cmake ..
   make -j4
 
 You may now continue to `Python Package Installation`_.
@@ -142,6 +144,20 @@ We recommend you use `Git for Windows <https://git-for-windows.github.io/>`_, as
 
 XGBoost support compilation with Microsoft Visual Studio and MinGW.
 
+Compile XGBoost with Microsoft Visual Studio
+--------------------------------------------
+To build with Visual Studio, we will need CMake. Make sure to install a recent version of CMake. Then run the following from the root of the XGBoost directory:
+
+.. code-block:: bash
+
+  mkdir build
+  cd build
+  cmake .. -G"Visual Studio 14 2015 Win64"
+
+This specifies an out of source build using the Visual Studio 64 bit generator. (Change the ``-G`` option appropriately if you have a different version of Visual Studio installed.) Open the ``.sln`` file in the build directory and build with Visual Studio.
+
+After the build process successfully ends, you will find a ``xgboost.dll`` library file inside ``./lib/`` folder.
+
 Compile XGBoost using MinGW
 ---------------------------
 After installing `Git for Windows <https://git-for-windows.github.io/>`_, you should have a shortcut named ``Git Bash``. You should run all subsequent steps in ``Git Bash``.
@@ -163,29 +179,15 @@ To build with MinGW, type:
 
 See :ref:`mingw_python` for buildilng XGBoost for Python.
 
-Compile XGBoost with Microsoft Visual Studio
---------------------------------------------
-To build with Visual Studio, we will need CMake. Make sure to install a recent version of CMake. Then run the following from the root of the XGBoost directory:
-
-.. code-block:: bash
-
-  mkdir build
-  cd build
-  cmake .. -G"Visual Studio 12 2013 Win64"
-
-This specifies an out of source build using the MSVC 12 64 bit generator. Open the ``.sln`` file in the build directory and build with Visual Studio. To use the Python module you can copy ``xgboost.dll`` into ``python-package/xgboost``.
-
-After the build process successfully ends, you will find a ``xgboost.dll`` library file inside ``./lib/`` folder, copy this file to the the API package folder like ``python-package/xgboost`` if you are using Python API.
-
-Unofficial windows binaries and instructions on how to use them are hosted on `Guido Tapia's blog <http://www.picnet.com.au/blogs/guido/post/2016/09/22/xgboost-windows-x64-binaries-for-download/>`_.
-
 .. _build_gpu_support:
 
 Building with GPU support
 =========================
 XGBoost can be built with GPU support for both Linux and Windows using CMake. GPU support works with the Python package as well as the CLI version. See `Installing R package with GPU support`_ for special instructions for R.
 
-An up-to-date version of the CUDA toolkit is required.
+An up-to-date version of the CUDA toolkit is required.  Please note that we
+skipped the support for compiling XGBoost with NVCC 10.1 due a small bug in its
+spliter, see `#4264 <https://github.com/dmlc/xgboost/issues/4264>`_.
 
 From the command line on Linux starting from the XGBoost directory:
 
@@ -207,13 +209,7 @@ From the command line on Linux starting from the XGBoost directory:
     cmake .. -DUSE_CUDA=ON -DUSE_NCCL=ON -DNCCL_ROOT=/path/to/nccl2
     make -j4
 
-On Windows, see what options for generators you have for CMake, and choose one with ``[arch]`` replaced with Win64:
-
-.. code-block:: bash
-
-  cmake -help
-
-Then run CMake as follows:
+On Windows, run CMake as follows:
 
 .. code-block:: bash
 
@@ -221,13 +217,15 @@ Then run CMake as follows:
   cd build
   cmake .. -G"Visual Studio 14 2015 Win64" -DUSE_CUDA=ON
 
+(Change the ``-G`` option appropriately if you have a different version of Visual Studio installed.)
+
 .. note:: Visual Studio 2017 Win64 Generator may not work
 
   Choosing the Visual Studio 2017 generator may cause compilation failure. When it happens, specify the 2015 compiler by adding the ``-T`` option:
 
   .. code-block:: bash
 
-    make .. -G"Visual Studio 15 2017 Win64" -T v140,cuda=8.0 -DR_LIB=ON -DUSE_CUDA=ON
+    make .. -G"Visual Studio 15 2017 Win64" -T v140,cuda=8.0 -DUSE_CUDA=ON
 
 To speed up compilation, the compute version specific to your GPU could be passed to cmake as, e.g., ``-DGPU_COMPUTE_VER=50``.
 The above cmake configuration run will create an ``xgboost.sln`` solution file in the build directory. Build this solution in release mode as a x64 build, either from Visual studio or from command line:
@@ -241,15 +239,15 @@ To speed up compilation, run multiple jobs in parallel by appending option ``--
 Customized Building
 ===================
 
-The configuration file ``config.mk`` modifies several compilation flags:
+We recommend the use of CMake for most use cases. See the full range of building options in CMakeLists.txt.
+
+Alternatively, you may use Makefile. The Makefile uses a configuration file ``config.mk``, which lets you modify several compilation flags:
 - Whether to enable support for various distributed filesystems such as HDFS and Amazon S3
 - Which compiler to use
 - And some more
 
 To customize, first copy ``make/config.mk`` to the project root and then modify the copy.
 
-Alternatively, use CMake.
-
 Python Package Installation
 ===========================
 
@@ -275,9 +273,9 @@ package manager, e.g. in Debian use
   If you recompiled XGBoost, then you need to reinstall it again to make the new library take effect.
 
 2. Only set the environment variable ``PYTHONPATH`` to tell Python where to find
-   the library. For example, assume we cloned `xgboost` on the home directory
-   `~`. then we can added the following line in `~/.bashrc`.
-   This option is **recommended for developers** who change the code frequently. The changes will be immediately reflected once you pulled the code and rebuild the project (no need to call ``setup`` again)
+   the library. For example, assume we cloned ``xgboost`` on the home directory
+   ``~``. then we can added the following line in ``~/.bashrc``.
+   This option is **recommended for developers** who change the code frequently. The changes will be immediately reflected once you pulled the code and rebuild the project (no need to call ``setup`` again).
 
 .. code-block:: bash
 
@@ -289,30 +287,22 @@ package manager, e.g. in Debian use
 
   cd python-package; python setup.py develop --user
 
-4. If you are installing the latest XGBoost version which requires compilation, add MinGW to the system PATH:
-
-.. code-block:: bash
-
-    import os
-    os.environ['PATH'] = os.environ['PATH'] + ';C:\\Program Files\\mingw-w64\\x86_64-5.3.0-posix-seh-rt_v4-rev0\\mingw64\\bin'
-
 .. _mingw_python:
 
-Building XGBoost library for Python for Windows with MinGW-w64
---------------------------------------------------------------
+Building XGBoost library for Python for Windows with MinGW-w64 (Advanced)
+-------------------------------------------------------------------------
 
-Windows versions of Python are built with Microsoft Visual Studio. Usually Python binary modules are built with the same compiler the interpreter is built with, raising several potential concerns.
+Windows versions of Python are built with Microsoft Visual Studio. Usually Python binary modules are built with the same compiler the interpreter is built with. However, you may not be able to use Visual Studio, for following reasons:
 
-1. VS is proprietary and commercial software. Microsoft provides a freeware "Community" edition, but its licensing terms are unsuitable for many organizations.
-2. Visual Studio contains telemetry, as documented in `Microsoft Visual Studio Licensing Terms <https://visualstudio.microsoft.com/license-terms/mt736442/>`_. It `has been inserting telemetry <https://old.reddit.com/r/cpp/comments/4ibauu/visual_studio_adding_telemetry_function_calls_to/>`_ into apps for some time. In order to download VS distribution from MS servers one has to run the application containing telemetry. These facts have raised privacy and security concerns among some users and system administrators. Running software with telemetry may be against the policy of your organization.
-3. g++ usually generates faster code on ``-O3``.
+1. VS is proprietary and commercial software. Microsoft provides a freeware "Community" edition, but its licensing terms impose restrictions as to where and how it can be used.
+2. Visual Studio contains telemetry, as documented in `Microsoft Visual Studio Licensing Terms <https://visualstudio.microsoft.com/license-terms/mt736442/>`_. Running software with telemetry may be against the policy of your organization.
 
-So you may want to build XGBoost with g++ own your own risk. This opens a can of worms, because MSVC uses Microsoft runtime and MinGW-w64 uses own runtime, and the runtimes have different incompatible memory allocators. But in fact this setup is usable if you know how to deal with it. Here is some experience.
+So you may want to build XGBoost with GCC own your own risk. This presents some difficulties because MSVC uses Microsoft runtime and MinGW-w64 uses own runtime, and the runtimes have different incompatible memory allocators. But in fact this setup is usable if you know how to deal with it. Here is some experience.
 
 1. The Python interpreter will crash on exit if XGBoost was used. This is usually not a big issue.
 2. ``-O3`` is OK.
 3. ``-mtune=native`` is also OK.
-4. Don't use ``-march=native`` gcc flag. Using it causes the Python interpreter to crash if the dll was actually used.
+4. Don't use ``-march=native`` gcc flag. Using it causes the Python interpreter to crash if the DLL was actually used.
 5. You may need to provide the lib with the runtime libs. If ``mingw32/bin`` is not in ``PATH``, build a wheel (``python setup.py bdist_wheel``), open it with an archiver and put the needed dlls to the directory where ``xgboost.dll`` is situated. Then you can install the wheel with ``pip``.
 
 R Package Installation
@@ -355,7 +345,7 @@ In this case, just start R as you would normally do and run the following:
   setwd('wherever/you/cloned/it/xgboost/R-package/')
   install.packages('.', repos = NULL, type="source")
 
-The package could also be built and installed with cmake (and Visual C++ 2015 on Windows) using instructions from the next section, but without GPU support (omit the ``-DUSE_CUDA=ON`` cmake parameter).
+The package could also be built and installed with CMake (and Visual C++ 2015 on Windows) using instructions from :ref:`r_gpu_support`, but without GPU support (omit the ``-DUSE_CUDA=ON`` cmake parameter).
 
 If all fails, try `Building the shared library`_ to see whether a problem is specific to R package or not.
 
@@ -364,11 +354,11 @@ If all fails, try `Building the shared library`_ to see whether a problem is spe
 Installing R package on Mac OSX with multi-threading
 ----------------------------------------------------
 
-First, obtain ``gcc-7`` with Homebrew (https://brew.sh/) to enable multi-threading (i.e. using multiple CPU threads for training). The default Apple Clang compiler does not support OpenMP, so using the default compiler would have disabled multi-threading.
+First, obtain ``gcc-8`` with Homebrew (https://brew.sh/) to enable multi-threading (i.e. using multiple CPU threads for training). The default Apple Clang compiler does not support OpenMP, so using the default compiler would have disabled multi-threading.
 
 .. code-block:: bash
 
-  brew install gcc@7
+  brew install gcc@8
 
 Now, clone the repository:
 
@@ -376,7 +366,7 @@ Now, clone the repository:
 
   git clone --recursive https://github.com/dmlc/xgboost
 
-Create the ``build/`` directory and invoke CMake with option ``R_LIB=ON``. Make sure to add ``CC=gcc-7 CXX=g++-7`` so that Homebrew GCC is selected. After invoking CMake, you can install the R package by running ``make`` and ``make install``:
+Create the ``build/`` directory and invoke CMake with option ``R_LIB=ON``. Make sure to add ``CC=gcc-8 CXX=g++-8`` so that Homebrew GCC is selected. After invoking CMake, you can install the R package by running ``make`` and ``make install``:
 
 .. code-block:: bash
 
@@ -386,6 +376,8 @@ Create the ``build/`` directory and invoke CMake with option ``R_LIB=ON``. Make
   make -j4
   make install
 
+.. _r_gpu_support:
+
 Installing R package with GPU support
 -------------------------------------
 
@@ -401,7 +393,7 @@ On Linux, starting from the XGBoost directory type:
   make install -j
 
 When default target is used, an R package shared library would be built in the ``build`` area.
-The ``install`` target, in addition, assembles the package files with this shared library under ``build/R-package``, and runs ``R CMD INSTALL``.
+The ``install`` target, in addition, assembles the package files with this shared library under ``build/R-package`` and runs ``R CMD INSTALL``.
 
 On Windows, CMake with Visual C++ Build Tools (or Visual Studio) has to be used to build an R package with GPU support. Rtools must also be installed (perhaps, some other MinGW distributions with ``gendef.exe`` and ``dlltool.exe`` would work, but that was not tested).
 
@@ -412,8 +404,8 @@ On Windows, CMake with Visual C++ Build Tools (or Visual Studio) has to be used
   cmake .. -G"Visual Studio 14 2015 Win64" -DUSE_CUDA=ON -DR_LIB=ON
   cmake --build . --target install --config Release
 
-When ``--target xgboost`` is used, an R package dll would be built under ``build/Release``.
-The ``--target install``, in addition, assembles the package files with this dll under ``build/R-package``, and runs ``R CMD INSTALL``.
+When ``--target xgboost`` is used, an R package DLL would be built under ``build/Release``.
+The ``--target install``, in addition, assembles the package files with this dll under ``build/R-package`` and runs ``R CMD INSTALL``.
 
 If cmake can't find your R during the configuration step, you might provide the location of its executable to cmake like this: ``-DLIBR_EXECUTABLE="C:/Program Files/R/R-3.4.1/bin/x64/R.exe"``.
 
@@ -458,4 +450,3 @@ Trouble Shooting
    .. code-block:: bash
 
      git clone https://github.com/dmlc/xgboost --recursive
-

doc/conf.py

@@ -22,14 +22,22 @@ import os, subprocess
 import shlex
 import guzzle_sphinx_theme
 
-git_branch = [re.sub(r'origin/', '', x.lstrip(' ')) for x in str(git.branch('-r', '--contains', 'HEAD')).rstrip('\n').split('\n')]
-git_branch = [x for x in git_branch if 'HEAD' not in x]
+git_branch = os.getenv('SPHINX_GIT_BRANCH', default=None)
+if git_branch is None:
+    # If SPHINX_GIT_BRANCH environment variable is not given, run git to determine branch name
+    git_branch = [re.sub(r'origin/', '', x.lstrip(' ')) for x in str(git.branch('-r', '--contains', 'HEAD')).rstrip('\n').split('\n')]
+    git_branch = [x for x in git_branch if 'HEAD' not in x]
 print('git_branch = {}'.format(git_branch[0]))
 try:
   filename, _ = urllib.request.urlretrieve('https://s3-us-west-2.amazonaws.com/xgboost-docs/{}.tar.bz2'.format(git_branch[0]))
   call('if [ -d tmp ]; then rm -rf tmp; fi; mkdir -p tmp/jvm; cd tmp/jvm; tar xvf {}'.format(filename), shell=True)
 except HTTPError:
   print('JVM doc not found. Skipping...')
+try:
+  filename, _ = urllib.request.urlretrieve('https://s3-us-west-2.amazonaws.com/xgboost-docs/doxygen/{}.tar.bz2'.format(git_branch[0]))
+  call('mkdir -p tmp/dev; cd tmp/dev; tar xvf {}; mv doc_doxygen/html/* .; rm -rf doc_doxygen'.format(filename), shell=True)
+except HTTPError:
+  print('C API doc not found. Skipping...')
 
 # If extensions (or modules to document with autodoc) are in another directory,
 # add these directories to sys.path here. If the directory is relative to the

doc/contribute.rst

@@ -19,6 +19,7 @@ Everyone is more than welcome to contribute. It is a way to make the project bet
 * `Documents`_
 * `Testcases`_
 * `Sanitizers`_
+* `clang-tidy`_
 * `Examples`_
 * `Core Library`_
 * `Python Package`_
@@ -165,10 +166,35 @@ environment variable:
 
   .. code-block:: bash
 
-    ASAN_OPTIONS=protect_shadow_gap=0 ../testxgboost
+    ASAN_OPTIONS=protect_shadow_gap=0 ${BUILD_DIR}/testxgboost
 
 For details, please consult `official documentation <https://github.com/google/sanitizers/wiki>`_ for sanitizers.
 
+**********
+clang-tidy
+**********
+To run clang-tidy on both C++ and CUDA source code,  run the following command
+from the top level source tree:
+
+  .. code-black:: bash
+    cd /path/to/xgboost/
+    python3 tests/ci_build/tidy.py --gtest-path=/path/to/google-test
+
+The script requires the full path of Google Test library via the ``--gtest-path`` argument.
+
+Also, the script accepts two optional integer arguments, namely ``--cpp`` and ``--cuda``.
+By default they are both set to 1.  If you want to exclude CUDA source from
+linting, use:
+
+  .. code-black:: bash
+    cd /path/to/xgboost/
+    python3 tests/ci_build/tidy.py --cuda=0
+
+Similarly, if you want to exclude C++ source from linting:
+
+  .. code-black:: bash
+    cd /path/to/xgboost/
+    python3 tests/ci_build/tidy.py --cpp=0
 
 ********
 Examples

doc/gpu/index.rst

@@ -37,33 +37,37 @@ Supported parameters
 .. |tick| unicode:: U+2714
 .. |cross| unicode:: U+2718
 
-+--------------------------+---------------+--------------+
-| parameter                | ``gpu_exact`` | ``gpu_hist`` |
-+==========================+===============+==============+
-| ``subsample``            | |cross|       | |tick|       |
-+--------------------------+---------------+--------------+
-| ``colsample_bytree``     | |cross|       | |tick|       |
-+--------------------------+---------------+--------------+
-| ``colsample_bylevel``    | |cross|       | |tick|       |
-+--------------------------+---------------+--------------+
-| ``max_bin``              | |cross|       | |tick|       |
-+--------------------------+---------------+--------------+
-| ``gpu_id``               | |tick|        | |tick|       |
-+--------------------------+---------------+--------------+
-| ``n_gpus``               | |cross|       | |tick|       |
-+--------------------------+---------------+--------------+
-| ``predictor``            | |tick|        | |tick|       |
-+--------------------------+---------------+--------------+
-| ``grow_policy``          | |cross|       | |tick|       |
-+--------------------------+---------------+--------------+
-| ``monotone_constraints`` | |cross|       | |tick|       |
-+--------------------------+---------------+--------------+
++--------------------------------+---------------+--------------+
+| parameter                      | ``gpu_exact`` | ``gpu_hist`` |
++================================+===============+==============+
+| ``subsample``                  | |cross|       | |tick|       |
++--------------------------------+---------------+--------------+
+| ``colsample_bytree``           | |cross|       | |tick|       |
++--------------------------------+---------------+--------------+
+| ``colsample_bylevel``          | |cross|       | |tick|       |
++--------------------------------+---------------+--------------+
+| ``max_bin``                    | |cross|       | |tick|       |
++--------------------------------+---------------+--------------+
+| ``gpu_id``                     | |tick|        | |tick|       |
++--------------------------------+---------------+--------------+
+| ``n_gpus``                     | |cross|       | |tick|       |
++--------------------------------+---------------+--------------+
+| ``predictor``                  | |tick|        | |tick|       |
++--------------------------------+---------------+--------------+
+| ``grow_policy``                | |cross|       | |tick|       |
++--------------------------------+---------------+--------------+
+| ``monotone_constraints``       | |cross|       | |tick|       |
++--------------------------------+---------------+--------------+
+| ``single_precision_histogram`` | |cross|       | |tick|       |
++--------------------------------+---------------+--------------+
 
 GPU accelerated prediction is enabled by default for the above mentioned ``tree_method`` parameters but can be switched to CPU prediction by setting ``predictor`` to ``cpu_predictor``. This could be useful if you want to conserve GPU memory. Likewise when using CPU algorithms, GPU accelerated prediction can be enabled by setting ``predictor`` to ``gpu_predictor``.
 
+The experimental parameter ``single_precision_histogram`` can be set to True to enable building histograms using single precision. This may improve speed, in particular on older architectures.
+
 The device ordinal can be selected using the ``gpu_id`` parameter, which defaults to 0.
 
-Multiple GPUs can be used with the ``gpu_hist`` tree method using the ``n_gpus`` parameter. which defaults to 1. If this is set to -1 all available GPUs will be used.  If ``gpu_id`` is specified as non-zero, the gpu device order is ``mod(gpu_id + i) % n_visible_devices`` for ``i=0`` to ``n_gpus-1``.  As with GPU vs. CPU, multi-GPU will not always be faster than a single GPU due to PCI bus bandwidth that can limit performance.
+Multiple GPUs can be used with the ``gpu_hist`` tree method using the ``n_gpus`` parameter. which defaults to 1. If this is set to -1 all available GPUs will be used.  If ``gpu_id`` is specified as non-zero, the selected gpu devices will be from ``gpu_id`` to ``gpu_id+n_gpus``, please note that ``gpu_id+n_gpus`` must be less than or equal to the number of available GPUs on your system.  As with GPU vs. CPU, multi-GPU will not always be faster than a single GPU due to PCI bus bandwidth that can limit performance.
 
 .. note:: Enabling multi-GPU training
 
@@ -78,6 +82,95 @@ The GPU algorithms currently work with CLI, Python and R packages. See :doc:`/bu
   param['max_bin'] = 16
   param['tree_method'] = 'gpu_hist'
 
+Objective functions
+===================
+Most of the objective functions implemented in XGBoost can be run on GPU.  Following table shows current support status.
+
+.. |tick| unicode:: U+2714
+.. |cross| unicode:: U+2718
+
++-----------------+-------------+
+| Objectives      | GPU support |
++-----------------+-------------+
+| reg:squarederror| |tick|      |
++-----------------+-------------+
+| reg:logistic    | |tick|      |
++-----------------+-------------+
+| binary:logistic | |tick|      |
++-----------------+-------------+
+| binary:logitraw | |tick|      |
++-----------------+-------------+
+| binary:hinge    | |tick|      |
++-----------------+-------------+
+| count:poisson   | |tick|      |
++-----------------+-------------+
+| reg:gamma       | |tick|      |
++-----------------+-------------+
+| reg:tweedie     | |tick|      |
++-----------------+-------------+
+| multi:softmax   | |tick|      |
++-----------------+-------------+
+| multi:softprob  | |tick|      |
++-----------------+-------------+
+| survival:cox    | |cross|     |
++-----------------+-------------+
+| rank:pairwise   | |cross|     |
++-----------------+-------------+
+| rank:ndcg       | |cross|     |
++-----------------+-------------+
+| rank:map        | |cross|     |
++-----------------+-------------+
+
+For multi-gpu support, objective functions also honor the ``n_gpus`` parameter,
+which, by default is set to 1.  To disable running objectives on GPU, just set
+``n_gpus`` to 0.
+
+Metric functions
+===================
+Following table shows current support status for evaluation metrics on the GPU.
+
+.. |tick| unicode:: U+2714
+.. |cross| unicode:: U+2718
+
++-----------------+-------------+
+| Metric          | GPU Support |
++=================+=============+
+| rmse            | |tick|      |
++-----------------+-------------+
+| mae             | |tick|      |
++-----------------+-------------+
+| logloss         | |tick|      |
++-----------------+-------------+
+| error           | |tick|      |
++-----------------+-------------+
+| merror          | |cross|     |
++-----------------+-------------+
+| mlogloss        | |cross|     |
++-----------------+-------------+
+| auc             | |cross|     |
++-----------------+-------------+
+| aucpr           | |cross|     |
++-----------------+-------------+
+| ndcg            | |cross|     |
++-----------------+-------------+
+| map             | |cross|     |
++-----------------+-------------+
+| poisson-nloglik | |tick|      |
++-----------------+-------------+
+| gamma-nloglik   | |tick|      |
++-----------------+-------------+
+| cox-nloglik     | |cross|     |
++-----------------+-------------+
+| gamma-deviance  | |tick|      |
++-----------------+-------------+
+| tweedie-nloglik | |tick|      |
++-----------------+-------------+
+
+As for objective functions, metrics honor the ``n_gpus`` parameter,
+which, by default is set to 1.  To disable running metrics on GPU, just set
+``n_gpus`` to 0.
+
+
 Benchmarks
 ==========
 You can run benchmarks on synthetic data for binary classification:
@@ -102,6 +195,10 @@ Training time time on 1,000,000 rows x 50 columns with 500 boosting iterations a
 
 See `GPU Accelerated XGBoost <https://xgboost.ai/2016/12/14/GPU-accelerated-xgboost.html>`_ and `Updates to the XGBoost GPU algorithms <https://xgboost.ai/2018/07/04/gpu-xgboost-update.html>`_ for additional performance benchmarks of the ``gpu_exact`` and ``gpu_hist`` tree methods.
 
+Developer notes
+==========
+The application may be profiled with annotations by specifying USE_NTVX to cmake and providing the path to the stand-alone nvtx header via NVTX_HEADER_DIR. Regions covered by the 'Monitor' class in cuda code will automatically appear in the nsight profiler.
+
 **********
 References
 **********
@@ -109,13 +206,16 @@ References
 
 `Nvidia Parallel Forall: Gradient Boosting, Decision Trees and XGBoost with CUDA <https://devblogs.nvidia.com/parallelforall/gradient-boosting-decision-trees-xgboost-cuda/>`_
 
-Authors
+Contributors
 =======
-* Rory Mitchell
+Many thanks to the following contributors (alphabetical order):
+* Andrey Adinets
+* Jiaming Yuan
 * Jonathan C. McKinney
+* Matthew Jones
+* Philip Cho
+* Rory Mitchell
 * Shankara Rao Thejaswi Nanditale
 * Vinay Deshpande
-* ... and the rest of the H2O.ai and NVIDIA team.
 
 Please report bugs to the user forum https://discuss.xgboost.ai/.
-

doc/jvm/xgboost4j_spark_tutorial.rst

@@ -57,13 +57,13 @@ and then refer to the snapshot dependency by adding:
 
   <dependency>
       <groupId>ml.dmlc</groupId>
-      <artifactId>xgboost4j</artifactId>
+      <artifactId>xgboost4j-spark</artifactId>
       <version>next_version_num-SNAPSHOT</version>
   </dependency>
 
-.. note:: XGBoost4J-Spark requires Apache Spark 2.3+
+.. note:: XGBoost4J-Spark requires Apache Spark 2.4+
 
-  XGBoost4J-Spark now requires **Apache Spark 2.3+**. Latest versions of XGBoost4J-Spark uses facilities of `org.apache.spark.ml.param.shared` extensively to provide for a tight integration with Spark MLLIB framework, and these facilities are not fully available on earlier versions of Spark.
+  XGBoost4J-Spark now requires **Apache Spark 2.4+**. Latest versions of XGBoost4J-Spark uses facilities of `org.apache.spark.ml.param.shared` extensively to provide for a tight integration with Spark MLLIB framework, and these facilities are not fully available on earlier versions of Spark.
 
   Also, make sure to install Spark directly from `Apache website <https://spark.apache.org/>`_. **Upstream XGBoost is not guaranteed to work with third-party distributions of Spark, such as Cloudera Spark.** Consult appropriate third parties to obtain their distribution of XGBoost.
 
@@ -153,6 +153,49 @@ Now, we have a DataFrame containing only two columns, "features" which contains
 "sepal length", "sepal width", "petal length" and "petal width" and "classIndex" which has Double-typed
 labels. A DataFrame like this (containing vector-represented features and numeric labels) can be fed to XGBoost4J-Spark's training engine directly.
 
+Dealing with missing values
+~~~~~~~~~~~~~~~~~~~~~~
+
+Strategies to handle missing values (and therefore overcome issues as above):
+
+In the case that a feature column contains missing values for any reason (could be related to business logic / wrong data ingestion process / etc.), the user should decide on a strategy of how to handle it. 
+The choice of approach depends on the value representing 'missing' which fall into four different categories:
+
+1. 0
+2. NaN
+3. Null
+4. Any other value which is not mentioned in (1) / (2) / (3)
+
+We introduce the following approaches dealing with missing value and their fitting scenarios:
+
+1. Skip VectorAssembler (using setHandleInvalid = "skip") directly. Used in (2), (3).
+2. Keep it (using setHandleInvalid = "keep"), and set the "missing" parameter in XGBClassifier/XGBRegressor as the value representing missing. Used in (2) and (4).
+3. Keep it (using setHandleInvalid = "keep") and transform to other irregular values. Used in (3).
+4. Nothing to be done, used in (1). 
+
+Then, XGBoost will automatically learn what's the ideal direction to go when a value is missing, based on that value and strategy.
+
+Example of setting a missing value (e.g. -999) to the "missing" parameter in XGBoostClassifier:
+
+.. code-block:: scala
+
+  import ml.dmlc.xgboost4j.scala.spark.XGBoostClassifier
+  val xgbParam = Map("eta" -> 0.1f,
+        "missing" -> -999,
+        "objective" -> "multi:softprob",
+        "num_class" -> 3,
+        "num_round" -> 100,
+        "num_workers" -> 2)
+  val xgbClassifier = new XGBoostClassifier(xgbParam).
+        setFeaturesCol("features").
+        setLabelCol("classIndex")
+
+.. note:: Using 0 to represent meaningful value
+
+  Due to the fact that Spark's VectorAssembler transformer only accepts 0 as a missing values, this one creates a problem when the user has 0 as meaningful value plus there are enough 0's to use SparseVector (However, In case the dataset is represented by a DenseVector, the 0 is kept)
+
+  In this case, users are also supposed to transform 0 to some other values to avoid the issue.
+
 Training
 ========
 
@@ -194,11 +237,16 @@ After we set XGBoostClassifier parameters and feature/label column, we can build
 Early Stopping
 ----------------
 
-Early stopping is a feature to prevent the unnecessary training iterations. By specifying ``num_early_stopping_rounds`` or directly call ``setNumEarlyStoppingRounds`` over a XGBoostClassifier or XGBoostRegressor, we can define number of rounds for the evaluation metric going to the unexpected direction to tolerate before stopping the training.
+Early stopping is a feature to prevent the unnecessary training iterations. By specifying ``num_early_stopping_rounds`` or directly call ``setNumEarlyStoppingRounds`` over a XGBoostClassifier or XGBoostRegressor, we can define number of rounds if the evaluation metric going away from the best iteration and early stop training iterations.
 
-In additional to ``num_early_stopping_rounds``, you also need to define ``maximize_evaluation_metrics`` or call ``setMaximizeEvaluationMetrics`` to specify whether you want to maximize or minimize the metrics in training.
+When it comes to custom eval metrics, in additional to ``num_early_stopping_rounds``, you also need to define ``maximize_evaluation_metrics`` or call ``setMaximizeEvaluationMetrics`` to specify whether you want to maximize or minimize the metrics in training. For built-in eval metrics, XGBoost4J-Spark will automatically select the direction.
 
-After specifying these two parameters, the training would stop when the metrics goes to the other direction against the one specified by ``maximize_evaluation_metrics`` for ``num_early_stopping_rounds`` iterations.
+For example, we need to maximize the evaluation metrics (set ``maximize_evaluation_metrics`` with true), and set ``num_early_stopping_rounds`` with 5. The evaluation metric of 10th iteration is the maximum one until now. In the following iterations, if there is no evaluation metric greater than the 10th iteration's (best one), the traning would be early stopped at 15th iteration.  
+
+Training with Evaluation Sets
+----------------
+
+You can also monitor the performance of the model during training with multiple evaluation datasets. By specifying ``eval_sets`` or call ``setEvalSets`` over a XGBoostClassifier or XGBoostRegressor, you can pass in multiple evaluation datasets typed as a Map from String to DataFrame.
 
 Prediction
 ==========

doc/parameter.rst

@@ -23,9 +23,16 @@ General Parameters
 
   - Which booster to use. Can be ``gbtree``, ``gblinear`` or ``dart``; ``gbtree`` and ``dart`` use tree based models while ``gblinear`` uses linear functions.
 
-* ``silent`` [default=0]
+* ``silent`` [default=0] [Deprecated]
 
-  - 0 means printing running messages, 1 means silent mode
+  - Deprecated.  Please use ``verbosity`` instead.
+
+* ``verbosity`` [default=1]
+
+  - Verbosity of printing messages.  Valid values are 0 (silent),
+    1 (warning), 2 (info), 3 (debug).  Sometimes XGBoost tries to change
+    configurations based on heuristics, which is displayed as warning message.
+    If there's unexpected behaviour, please try to increase value of verbosity.
 
 * ``nthread`` [default to maximum number of threads available if not set]
 
@@ -57,8 +64,8 @@ Parameters for Tree Booster
 
 * ``max_depth`` [default=6]
 
-  - Maximum depth of a tree. Increasing this value will make the model more complex and more likely to overfit. 0 indicates no limit. Note that limit is required when ``grow_policy`` is set of ``depthwise``.
-  - range: [0,∞]
+  - Maximum depth of a tree. Increasing this value will make the model more complex and more likely to overfit. 0 is only accepted in ``lossguided`` growing policy when tree_method is set as ``hist`` and it indicates no limit on depth. Beware that XGBoost aggressively consumes memory when training a deep tree.
+  - range: [0,∞] (0 is only accepted in ``lossguided`` growing policy when tree_method is set as ``hist``)
 
 * ``min_child_weight`` [default=1]
 
@@ -75,15 +82,22 @@ Parameters for Tree Booster
   - Subsample ratio of the training instances. Setting it to 0.5 means that XGBoost would randomly sample half of the training data prior to growing trees. and this will prevent overfitting. Subsampling will occur once in every boosting iteration.
   - range: (0,1]
 
-* ``colsample_bytree`` [default=1]
-
-  - Subsample ratio of columns when constructing each tree. Subsampling will occur once in every boosting iteration.
-  - range: (0,1]
-
-* ``colsample_bylevel`` [default=1]
-
-  - Subsample ratio of columns for each split, in each level. Subsampling will occur each time a new split is made.
-  - range: (0,1]
+* ``colsample_bytree``, ``colsample_bylevel``, ``colsample_bynode`` [default=1]
+  - This is a family of parameters for subsampling of columns.
+  - 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_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
+    each split.
 
 * ``lambda`` [default=1, alias: ``reg_lambda``]
 
@@ -96,7 +110,7 @@ Parameters for Tree Booster
 * ``tree_method`` string [default= ``auto``]
 
   - The tree construction algorithm used in XGBoost. See description in the `reference paper <http://arxiv.org/abs/1603.02754>`_.
-  - Distributed and external memory version only support ``tree_method=approx``.
+  - XGBoost supports ``hist`` and ``approx`` for distributed training and only support ``approx`` for external memory version.
   - Choices: ``auto``, ``exact``, ``approx``, ``hist``, ``gpu_exact``, ``gpu_hist``
 
     - ``auto``: Use heuristic to choose the fastest method.
@@ -138,7 +152,7 @@ Parameters for Tree Booster
     - ``refresh``: refreshes tree's statistics and/or leaf values based on the current data. Note that no random subsampling of data rows is performed.
     - ``prune``: prunes the splits where loss < min_split_loss (or gamma).
 
-  - In a distributed setting, the implicit updater sequence value would be adjusted to ``grow_histmaker,prune``.
+  - In a distributed setting, the implicit updater sequence value would be adjusted to ``grow_histmaker,prune`` by default, and you can set ``tree_method`` as ``hist`` to use ``grow_histmaker``. 
 
 * ``refresh_leaf`` [default=1]
 
@@ -178,6 +192,9 @@ Parameters for Tree Booster
     - ``cpu_predictor``: Multicore CPU prediction algorithm.
     - ``gpu_predictor``: Prediction using GPU. Default when ``tree_method`` is ``gpu_exact`` or ``gpu_hist``.
 
+* ``num_parallel_tree``, [default=1]
+  - Number of parallel trees constructed during each iteration. This option is used to support boosted random forest.
+
 Additional parameters for Dart Booster (``booster=dart``)
 =========================================================
 
@@ -276,16 +293,13 @@ Learning Task Parameters
 ************************
 Specify the learning task and the corresponding learning objective. The objective options are below:
 
-* ``objective`` [default=reg:linear]
+* ``objective`` [default=reg:squarederror]
 
-  - ``reg:linear``: linear regression
+  - ``reg:squarederror``: regression with squared loss
   - ``reg:logistic``: logistic regression
   - ``binary:logistic``: logistic regression for binary classification, output probability
   - ``binary:logitraw``: logistic regression for binary classification, output score before logistic transformation
   - ``binary:hinge``: hinge loss for binary classification. This makes predictions of 0 or 1, rather than producing probabilities.
-  - ``gpu:reg:linear``, ``gpu:reg:logistic``, ``gpu:binary:logistic``, ``gpu:binary:logitraw``: versions
-    of the corresponding objective functions evaluated on the GPU; note that like the GPU histogram algorithm,
-    they can only be used when the entire training session uses the same dataset
   - ``count:poisson`` --poisson regression for count data, output mean of poisson distribution
 
     - ``max_delta_step`` is set to 0.7 by default in poisson regression (used to safeguard optimization)

doc/python/python_intro.rst

@@ -48,9 +48,15 @@ The data is stored in a :py:class:`DMatrix <xgboost.DMatrix>` object.
     dtrain = xgb.DMatrix('train.csv?format=csv&label_column=0')
     dtest = xgb.DMatrix('test.csv?format=csv&label_column=0')
 
-  (Note that XGBoost does not support categorical features; if your data contains
-  categorical features, load it as a NumPy array first and then perform
-  `one-hot encoding <http://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.OneHotEncoder.html>`_.)
+  .. note:: Categorical features not supported
+
+    Note that XGBoost does not support categorical features; if your data contains
+    categorical features, load it as a NumPy array first and then perform
+    `one-hot encoding <http://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.OneHotEncoder.html>`_.
+
+  .. note:: Use Pandas to load CSV files with headers
+
+    Currently, the DMLC data parser cannot parse CSV files with headers. Use Pandas (see below) to read CSV files with headers.
 
 * To load a NumPy array into :py:class:`DMatrix <xgboost.DMatrix>`:
 
@@ -95,6 +101,10 @@ The data is stored in a :py:class:`DMatrix <xgboost.DMatrix>` object.
     w = np.random.rand(5, 1)
     dtrain = xgb.DMatrix(data, label=label, missing=-999.0, weight=w)
 
+When performing ranking tasks, the number of weights should be equal
+to number of groups.
+
+
 Setting Parameters
 ------------------
 XGBoost can use either a list of pairs or a dictionary to set :doc:`parameters </parameter>`. For instance:
@@ -155,6 +165,10 @@ A saved model can be loaded as follows:
   bst = xgb.Booster({'nthread': 4})  # init model
   bst.load_model('model.bin')  # load data
 
+Methods including `update` and `boost` from `xgboost.Booster` are designed for
+internal usage only.  The wrapper function `xgboost.train` does some
+pre-configuration including setting up caches and some other parameters.
+
 Early Stopping
 --------------
 If you have a validation set, you can use early stopping to find the optimal number of boosting rounds.
@@ -209,4 +223,3 @@ When you use ``IPython``, you can use the :py:meth:`xgboost.to_graphviz` functio
 .. code-block:: python
 
   xgb.to_graphviz(bst, num_trees=2)
-

doc/tutorials/aws_yarn.rst

@@ -1,216 +1,8 @@
 ###############################
 Distributed XGBoost YARN on AWS
 ###############################
-This is a step-by-step tutorial on how to setup and run distributed `XGBoost <https://github.com/dmlc/xgboost>`_
-on an AWS EC2 cluster. Distributed XGBoost runs on various platforms such as MPI, SGE and Hadoop YARN.
-In this tutorial, we use YARN as an example since this is a widely used solution for distributed computing.
+[This page is under construction.]
 
 .. note:: XGBoost with Spark
 
   If you are preprocessing training data with Spark, consider using :doc:`XGBoost4J-Spark </jvm/xgboost4j_spark_tutorial>`.
-
-************
-Prerequisite
-************
-We need to get a `AWS key-pair <http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html>`_
-to access the AWS services. Let us assume that we are using a key ``mykey`` and  the corresponding permission file ``mypem.pem``.
-
-We also need `AWS credentials <https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html>`_,
-which includes an ``ACCESS_KEY_ID`` and a ``SECRET_ACCESS_KEY``.
-
-Finally, we will need a S3 bucket to host the data and the model, ``s3://mybucket/``
-
-***************************
-Setup a Hadoop YARN Cluster
-***************************
-This sections shows how to start a Hadoop YARN cluster from scratch.
-You can skip this step if you have already have one.
-We will be using `yarn-ec2 <https://github.com/tqchen/yarn-ec2>`_ to start the cluster.
-
-We can first clone the yarn-ec2 script by the following command.
-
-.. code-block:: bash
-
-  git clone https://github.com/tqchen/yarn-ec2
-
-To use the script, we must set the environment variables ``AWS_ACCESS_KEY_ID`` and
-``AWS_SECRET_ACCESS_KEY`` properly. This can be done by adding the following two lines in
-``~/.bashrc`` (replacing the strings with the correct ones)
-
-.. code-block:: bash
-
-  export AWS_ACCESS_KEY_ID=[your access ID]
-  export AWS_SECRET_ACCESS_KEY=[your secret access key]
-
-Now we can launch a master machine of the cluster from EC2:
-
-.. code-block:: bash
-
-  ./yarn-ec2 -k mykey -i mypem.pem launch xgboost
-
-Wait a few mininutes till the master machine gets up.
-
-After the master machine gets up, we can query the public DNS of the master machine using the following command.
-
-.. code-block:: bash
-
-  ./yarn-ec2 -k mykey -i mypem.pem get-master xgboost
-
-It will show the public DNS of the master machine like ``ec2-xx-xx-xx.us-west-2.compute.amazonaws.com``
-Now we can open the browser, and type (replace the DNS with the master DNS)
-
-.. code-block:: none
-
-  ec2-xx-xx-xx.us-west-2.compute.amazonaws.com:8088
-
-This will show the job tracker of the YARN cluster. Note that we may have to wait a few minutes before the master finishes bootstrapping and starts the
-job tracker.
-
-After the master machine gets up, we can freely add more slave machines to the cluster.
-The following command add m3.xlarge instances to the cluster.
-
-.. code-block:: bash
-
-  ./yarn-ec2 -k mykey -i mypem.pem -t m3.xlarge -s 2 addslave xgboost
-
-We can also choose to add two spot instances
-
-.. code-block:: bash
-
-  ./yarn-ec2 -k mykey -i mypem.pem -t m3.xlarge -s 2 addspot xgboost
-
-The slave machines will start up, bootstrap  and report to the master.
-You can check if the slave machines are connected by clicking on the Nodes link on the job tracker.
-Or simply type the following URL (replace DNS ith the master DNS)
-
-.. code-block:: none
-
-  ec2-xx-xx-xx.us-west-2.compute.amazonaws.com:8088/cluster/nodes
-
-One thing we should note is that not all the links in the job tracker work.
-This is due to that many of them use the private IP of AWS, which can only be accessed by EC2.
-We can use ssh proxy to access these packages.
-Now that we have set up a cluster with one master and two slaves, we are ready to run the experiment.
-
-*********************
-Build XGBoost with S3
-*********************
-We can log into the master machine by the following command.
-
-.. code-block:: bash
-
-  ./yarn-ec2 -k mykey -i mypem.pem login xgboost
-
-We will be using S3 to host the data and the result model, so the data won't get lost after the cluster shutdown.
-To do so, we will need to build XGBoost with S3 support. The only thing we need to do is to set ``USE_S3``
-variable to be true. This can be achieved by the following command.
-
-.. code-block:: bash
-
-  git clone --recursive https://github.com/dmlc/xgboost
-  cd xgboost
-  cp make/config.mk config.mk
-  echo "USE_S3=1" >> config.mk
-  make -j4
-
-Now we have built the XGBoost with S3 support. You can also enable HDFS support if you plan to store data on HDFS by turning on ``USE_HDFS`` option.
-XGBoost also relies on the environment variable to access S3, so you will need to add the following two lines to ``~/.bashrc`` (replacing the strings with the correct ones)
-on the master machine as well.
-
-.. code-block:: bash
-
-  export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
-  export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
-  export BUCKET=mybucket
-
-*******************
-Host the Data on S3
-*******************
-In this example, we will copy the example dataset in XGBoost to the S3 bucket as input.
-In normal usecases, the dataset is usually created from existing distributed processing pipeline.
-We can use `s3cmd <http://s3tools.org/s3cmd>`_ to copy the data into mybucket (replace ``${BUCKET}`` with the real bucket name).
-
-.. code-block:: bash
-
-  cd xgboost
-  s3cmd put demo/data/agaricus.txt.train s3://${BUCKET}/xgb-demo/train/
-  s3cmd put demo/data/agaricus.txt.test s3://${BUCKET}/xgb-demo/test/
-
-***************
-Submit the Jobs
-***************
-Now everything is ready, we can submit the XGBoost distributed job to the YARN cluster.
-We will use the `dmlc-submit <https://github.com/dmlc/dmlc-core/tree/master/tracker>`_ script to submit the job.
-
-Now we can run the following script in the distributed training folder (replace ``${BUCKET}`` with the real bucket name)
-
-.. code-block:: bash
-
-  cd xgboost/demo/distributed-training
-  # Use dmlc-submit to submit the job.
-  ../../dmlc-core/tracker/dmlc-submit --cluster=yarn --num-workers=2 --worker-cores=2\
-      ../../xgboost mushroom.aws.conf nthread=2\
-      data=s3://${BUCKET}/xgb-demo/train\
-      eval[test]=s3://${BUCKET}/xgb-demo/test\
-      model_dir=s3://${BUCKET}/xgb-demo/model
-
-All the configurations such as ``data`` and ``model_dir`` can also be directly written into the configuration file.
-Note that we only specified the folder path to the file, instead of the file name.
-XGBoost will read in all the files in that folder as the training and evaluation data.
-
-In this command, we are using two workers, and each worker uses two running threads.
-XGBoost can benefit from using multiple cores in each worker.
-A common choice of working cores can range from 4 to 8.
-The trained model will be saved into the specified model folder. You can browse the model folder.
-
-.. code-block:: bash
-
-  s3cmd ls s3://${BUCKET}/xgb-demo/model/
-
-The following is an example output from distributed training.
-
-.. code-block:: none
-
-  16/02/26 05:41:59 INFO dmlc.Client: jobname=DMLC[nworker=2]:xgboost,username=ubuntu
-  16/02/26 05:41:59 INFO dmlc.Client: Submitting application application_1456461717456_0015
-  16/02/26 05:41:59 INFO impl.YarnClientImpl: Submitted application application_1456461717456_0015
-  2016-02-26 05:42:05,230 INFO @tracker All of 2 nodes getting started
-  2016-02-26 05:42:14,027 INFO [05:42:14] [0]  test-error:0.016139        train-error:0.014433
-  2016-02-26 05:42:14,186 INFO [05:42:14] [1]  test-error:0.000000        train-error:0.001228
-  2016-02-26 05:42:14,947 INFO @tracker All nodes finishes job
-  2016-02-26 05:42:14,948 INFO @tracker 9.71754479408 secs between node start and job finish
-  Application application_1456461717456_0015 finished with state FINISHED at 1456465335961
-
-*****************
-Analyze the Model
-*****************
-After the model is trained, we can analyse the learnt model and use it for future prediction tasks.
-XGBoost is a portable framework, meaning the models in all platforms are *exchangeable*.
-This means we can load the trained model in python/R/Julia and take benefit of data science pipelines
-in these languages to do model analysis and prediction.
-
-For example, you can use `this IPython notebook <https://github.com/dmlc/xgboost/tree/master/demo/distributed-training/plot_model.ipynb>`_
-to plot feature importance and visualize the learnt model.
-
-***************
-Troubleshooting
-***************
-
-If you encounter a problem, the best way might be to use the following command
-to get logs of stdout and stderr of the containers and check what causes the problem.
-
-.. code-block:: bash
-
-  yarn logs -applicationId yourAppId
-
-*****************
-Future Directions
-*****************
-You have learned to use distributed XGBoost on YARN in this tutorial.
-XGBoost is a portable and scalable framework for gradient boosting.
-You can check out more examples and resources in the `resources page <https://github.com/dmlc/xgboost/blob/master/demo/README.md>`_.
-
-The project goal is to make the best scalable machine learning solution available to all platforms.
-The API is designed to be able to portable, and the same code can also run on other platforms such as MPI and SGE.
-XGBoost is actively evolving and we are working on even more exciting features
-such as distributed XGBoost python/R package.

doc/tutorials/feature_interaction_constraint.rst

@@ -143,11 +143,11 @@ first and second constraints (``[0, 1]``, ``[2, 3, 4]``).
 Enforcing Feature Interaction Constraints in XGBoost
 ****************************************************
 
-It is very simple to enforce monotonicity constraints in XGBoost.  Here we will
+It is very simple to enforce feature interaction constraints in XGBoost.  Here we will
 give an example using Python, but the same general idea generalizes to other
 platforms.
 
-Suppose the following code fits your model without monotonicity constraints:
+Suppose the following code fits your model without feature interaction constraints:
 
 .. code-block:: python
 
@@ -155,7 +155,7 @@ Suppose the following code fits your model without monotonicity constraints:
                                    num_boost_round = 1000, evals = evallist,
                                    early_stopping_rounds = 10)
 
-Then fitting with monotonicity constraints only requires adding a single
+Then fitting with feature interaction constraints only requires adding a single
 parameter:
 
 .. code-block:: python

doc/tutorials/index.rst

@@ -14,6 +14,7 @@ See `Awesome XGBoost <https://github.com/dmlc/xgboost/tree/master/demo>`_ for mo
   Distributed XGBoost with XGBoost4J-Spark <https://xgboost.readthedocs.io/en/latest/jvm/xgboost4j_spark_tutorial.html>
   dart
   monotonic
+  rf
   feature_interaction_constraint
   input_format
   param_tuning

doc/tutorials/model.rst

@@ -72,8 +72,7 @@ Decision Tree Ensembles
 ***********************
 Now that we have introduced the elements of supervised learning, let us get started with real trees.
 To begin with, let us first learn about the model choice of XGBoost: **decision tree ensembles**.
-The tree ensemble model consists of a set of classification and regression trees (CART). Here's a simple example of a CART
-that classifies whether someone will like computer games.
+The tree ensemble model consists of a set of classification and regression trees (CART). Here's a simple example of a CART that classifies whether someone will like a hypothetical computer game X.
 
 .. image:: https://raw.githubusercontent.com/dmlc/web-data/master/xgboost/model/cart.png
   :width: 100%
@@ -82,7 +81,7 @@ that classifies whether someone will like computer games.
 We classify the members of a family into different leaves, and assign them the score on the corresponding leaf.
 A CART is a bit different from decision trees, in which the leaf only contains decision values. In CART, a real score
 is associated with each of the leaves, which gives us richer interpretations that go beyond classification.
-This also allows for a pricipled, unified approach to optimization, as we will see in a later part of this tutorial.
+This also allows for a principled, unified approach to optimization, as we will see in a later part of this tutorial.
 
 Usually, a single tree is not strong enough to be used in practice. What is actually used is the ensemble model,
 which sums the prediction of multiple trees together.
@@ -255,6 +254,10 @@ For real valued data, we usually want to search for an optimal split. To efficie
 
 A left to right scan is sufficient to calculate the structure score of all possible split solutions, and we can find the best split efficiently.
 
+.. note:: Limitation of additive tree learning
+
+  Since it is intractable to enumerate all possible tree structures, we add one split at a time. This approach works well most of the time, but there are some edge cases that fail due to this approach. For those edge cases, training results in a degenerate model because we consider only one feature dimension at a time. See `Can Gradient Boosting Learn Simple Arithmetic? <http://mariofilho.com/can-gradient-boosting-learn-simple-arithmetic/>`_ for an example.
+
 **********************
 Final words on XGBoost
 **********************

doc/tutorials/rf.rst

@@ -0,0 +1,106 @@
+#########################
+Random Forests in XGBoost
+#########################
+
+XGBoost is normally used to train gradient-boosted decision trees and other gradient
+boosted models. Random forests use the same model representation and inference, as
+gradient-boosted decision trees, but a different training algorithm.  One can use XGBoost
+to train a standalone random forest or use random forest as a base model for gradient
+boosting.  Here we focus on training standalone random forest.
+
+We have native APIs for training random forests since the early days, and a new
+Scikit-Learn wrapper after 0.82 (not included in 0.82).  Please note that the new
+Scikit-Learn wrapper is still **experimental**, which means we might change the interface
+whenever needed.
+
+****************
+Standalone Random Forest With XGBoost API
+****************
+
+The following parameters must be set to enable random forest training.
+
+* ``booster`` should be set to ``gbtree``, as we are training forests. Note that as this
+  is the default, this parameter needn't be set explicitly.
+* ``subsample`` must be set to a value less than 1 to enable random selection of training
+  cases (rows).
+* One of ``colsample_by*`` parameters must be set to a value less than 1 to enable random
+  selection of columns. Normally, ``colsample_bynode`` would be set to a value less than 1
+  to randomly sample columns at each tree split.
+* ``num_parallel_tree`` should be set to the size of the forest being trained.
+* ``num_boost_round`` should be set to 1 to prevent XGBoost from boosting multiple random
+  forests.  Note that this is a keyword argument to ``train()``, and is not part of the
+  parameter dictionary.
+* ``eta`` (alias: ``learning_rate``) must be set to 1 when training random forest
+  regression.
+* ``random_state`` can be used to seed the random number generator.
+
+
+Other parameters should be set in a similar way they are set for gradient boosting. For
+instance, ``objective`` will typically be ``reg:squarederror`` for regression and
+``binary:logistic`` for classification, ``lambda`` should be set according to a desired
+regularization weight, etc.
+
+If both ``num_parallel_tree`` and ``num_boost_round`` are greater than 1, training will
+use a combination of random forest and gradient boosting strategy. It will perform
+``num_boost_round`` rounds, boosting a random forest of ``num_parallel_tree`` trees at
+each round. If early stopping is not enabled, the final model will consist of
+``num_parallel_tree`` * ``num_boost_round`` trees.
+
+Here is a sample parameter dictionary for training a random forest on a GPU using
+xgboost::
+
+  params = {
+    'colsample_bynode': 0.8,
+    'learning_rate': 1,
+    'max_depth': 5,
+    'num_parallel_tree': 100,
+    'objective': 'binary:logistic',
+    'subsample': 0.8,
+    'tree_method': 'gpu_hist'
+  }
+
+A random forest model can then be trained as follows::
+
+  bst = train(params, dmatrix, num_boost_round=1)
+
+
+**************************
+Standalone Random Forest With Scikit-Learn-Like API
+**************************
+
+``XGBRFClassifier`` and ``XGBRFRegressor`` are SKL-like classes that provide random forest
+functionality. They are basically versions of ``XGBClassifier`` and ``XGBRegressor`` that
+train random forest instead of gradient boosting, and have default values and meaning of
+some of the parameters adjusted accordingly. In particular:
+
+* ``n_estimators`` specifies the size of the forest to be trained; it is converted to
+  ``num_parallel_tree``, instead of the number of boosting rounds
+* ``learning_rate`` is set to 1 by default
+* ``colsample_bynode`` and ``subsample`` are set to 0.8 by default
+* ``booster`` is always ``gbtree``
+
+For a simple example, you can train a random forest regressor with::
+
+    from sklearn.model_selection import KFold
+
+    # Your code ...
+
+    kf = KFold(n_splits=2)
+    for train_index, test_index in kf.split(X, y):
+        xgb_model = xgb.XGBRFRegressor(random_state=42).fit(
+	X[train_index], y[train_index])
+
+Note that these classes have a smaller selection of parameters compared to using
+``train()``. In particular, it is impossible to combine random forests with gradient
+boosting using this API.
+
+
+*******
+Caveats
+*******
+
+* XGBoost uses 2nd order approximation to the objective function. This can lead to results
+  that differ from a random forest implementation that uses the exact value of the
+  objective function.
+* XGBoost does not perform replacement when subsampling training cases. Each training case
+  can occur in a subsampled set either 0 or 1 time.

include/xgboost/base.h

@@ -16,7 +16,7 @@
  */
 #ifndef XGBOOST_STRICT_R_MODE
 #define XGBOOST_STRICT_R_MODE 0
-#endif
+#endif  // XGBOOST_STRICT_R_MODE
 
 /*!
  * \brief Whether always log console message with time.
@@ -26,21 +26,21 @@
  */
 #ifndef XGBOOST_LOG_WITH_TIME
 #define XGBOOST_LOG_WITH_TIME 1
-#endif
+#endif  // XGBOOST_LOG_WITH_TIME
 
 /*!
  * \brief Whether customize the logger outputs.
  */
 #ifndef XGBOOST_CUSTOMIZE_LOGGER
 #define XGBOOST_CUSTOMIZE_LOGGER XGBOOST_STRICT_R_MODE
-#endif
+#endif  // XGBOOST_CUSTOMIZE_LOGGER
 
 /*!
  * \brief Whether to customize global PRNG.
  */
 #ifndef XGBOOST_CUSTOMIZE_GLOBAL_PRNG
 #define XGBOOST_CUSTOMIZE_GLOBAL_PRNG XGBOOST_STRICT_R_MODE
-#endif
+#endif  // XGBOOST_CUSTOMIZE_GLOBAL_PRNG
 
 /*!
  * \brief Check if alignas(*) keyword is supported. (g++ 4.8 or higher)
@@ -49,7 +49,7 @@
 #define XGBOOST_ALIGNAS(X) alignas(X)
 #else
 #define XGBOOST_ALIGNAS(X)
-#endif
+#endif  // defined(__GNUC__) && ((__GNUC__ == 4 && __GNUC_MINOR__ >= 8) || __GNUC__ > 4)
 
 #if defined(__GNUC__) && ((__GNUC__ == 4 && __GNUC_MINOR__ >= 8) || __GNUC__ > 4) && \
     !defined(__CUDACC__)
@@ -64,7 +64,7 @@
 #else
 #define XGBOOST_PARALLEL_SORT(X, Y, Z) std::sort((X), (Y), (Z))
 #define XGBOOST_PARALLEL_STABLE_SORT(X, Y, Z) std::stable_sort((X), (Y), (Z))
-#endif
+#endif  // GLIBC VERSION
 
 /*!
  * \brief Tag function as usable by device
@@ -73,7 +73,7 @@
 #define XGBOOST_DEVICE __host__ __device__
 #else
 #define XGBOOST_DEVICE
-#endif
+#endif  // defined (__CUDA__) || defined(__NVCC__)
 
 /*! \brief namespace of xgboost*/
 namespace xgboost {
@@ -215,7 +215,11 @@ using bst_omp_uint = dmlc::omp_uint;  // NOLINT
 #if __GNUC__ == 4 && __GNUC_MINOR__ < 8
 #define override
 #define final
-#endif
-#endif
+#endif  // __GNUC__ == 4 && __GNUC_MINOR__ < 8
+#endif  // DMLC_USE_CXX11 && defined(__GNUC__) && !defined(__clang_version__)
 }  // namespace xgboost
+
+/* Always keep this #include at the bottom of xgboost/base.h */
+#include <xgboost/build_config.h>
+
 #endif  // XGBOOST_BASE_H_

include/xgboost/build_config.h

@@ -0,0 +1,22 @@
+/*!
+ * Copyright 2019 by Contributors
+ * \file build_config.h
+ */
+#ifndef XGBOOST_BUILD_CONFIG_H_
+#define XGBOOST_BUILD_CONFIG_H_
+
+// These check are for Makefile.
+#if !defined(XGBOOST_MM_PREFETCH_PRESENT) && !defined(XGBOOST_BUILTIN_PREFETCH_PRESENT)
+/* default logic for software pre-fetching */
+#if (defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_AMD64))) || defined(__INTEL_COMPILER)
+// Enable _mm_prefetch for Intel compiler and MSVC+x86
+  #define XGBOOST_MM_PREFETCH_PRESENT
+  #define XGBOOST_BUILTIN_PREFETCH_PRESENT
+#elif defined(__GNUC__)
+// Enable __builtin_prefetch for GCC
+#define XGBOOST_BUILTIN_PREFETCH_PRESENT
+#endif  // GUARDS
+
+#endif  // !defined(XGBOOST_MM_PREFETCH_PRESENT) && !defined()
+
+#endif  // XGBOOST_BUILD_CONFIG_H_

include/xgboost/c_api.h

@@ -10,20 +10,18 @@
 #ifdef __cplusplus
 #define XGB_EXTERN_C extern "C"
 #include <cstdio>
+#include <cstdint>
 #else
 #define XGB_EXTERN_C
 #include <stdio.h>
 #include <stdint.h>
-#endif
-
-// XGBoost C API will include APIs in Rabit C API
-#include <rabit/c_api.h>
+#endif  // __cplusplus
 
 #if defined(_MSC_VER) || defined(_WIN32)
 #define XGB_DLL XGB_EXTERN_C __declspec(dllexport)
 #else
 #define XGB_DLL XGB_EXTERN_C
-#endif
+#endif  // defined(_MSC_VER) || defined(_WIN32)
 
 // manually define unsigned long
 typedef uint64_t bst_ulong;  // NOLINT(*)
@@ -49,7 +47,7 @@ typedef struct {  // NOLINT(*)
   long* offset; // NOLINT(*)
 #else
   int64_t* offset;  // NOLINT(*)
-#endif
+#endif  // __APPLE__
   /*! \brief labels of each instance */
   float* label;
   /*! \brief weight of each instance, can be NULL */
@@ -148,23 +146,6 @@ XGB_DLL int XGDMatrixCreateFromCSREx(const size_t* indptr,
                                      size_t nelem,
                                      size_t num_col,
                                      DMatrixHandle* out);
-/*!
- * \deprecated
- * \brief create a matrix content from CSR format
- * \param indptr pointer to row headers
- * \param indices findex
- * \param data fvalue
- * \param nindptr number of rows in the matrix + 1
- * \param nelem number of nonzero elements in the matrix
- * \param out created dmatrix
- * \return 0 when success, -1 when failure happens
- */
-XGB_DLL int XGDMatrixCreateFromCSR(const bst_ulong *indptr,
-                                   const unsigned *indices,
-                                   const float *data,
-                                   bst_ulong nindptr,
-                                   bst_ulong nelem,
-                                   DMatrixHandle *out);
 /*!
  * \brief create a matrix content from CSC format
  * \param col_ptr pointer to col headers
@@ -183,23 +164,7 @@ XGB_DLL int XGDMatrixCreateFromCSCEx(const size_t* col_ptr,
                                      size_t nelem,
                                      size_t num_row,
                                      DMatrixHandle* out);
-/*!
- * \deprecated
- * \brief create a matrix content from CSC format
- * \param col_ptr pointer to col headers
- * \param indices findex
- * \param data fvalue
- * \param nindptr number of rows in the matrix + 1
- * \param nelem number of nonzero elements in the matrix
- * \param out created dmatrix
- * \return 0 when success, -1 when failure happens
- */
-XGB_DLL int XGDMatrixCreateFromCSC(const bst_ulong *col_ptr,
-                                   const unsigned *indices,
-                                   const float *data,
-                                   bst_ulong nindptr,
-                                   bst_ulong nelem,
-                                   DMatrixHandle *out);
+
 /*!
  * \brief create matrix content from dense matrix
  * \param data pointer to the data space

include/xgboost/data.h

@@ -9,6 +9,7 @@
 
 #include <dmlc/base.h>
 #include <dmlc/data.h>
+#include <rabit/rabit.h>
 #include <cstring>
 #include <memory>
 #include <numeric>
@@ -169,8 +170,16 @@ class SparsePage {
   inline Inst operator[](size_t i) const {
     const auto& data_vec = data.HostVector();
     const auto& offset_vec = offset.HostVector();
+    size_t size;
+    // in distributed mode, some partitions may not get any instance for a feature. Therefore
+    // we should set the size as zero
+    if (rabit::IsDistributed() && i + 1 >= offset_vec.size()) {
+      size = 0;
+    } else {
+      size = offset_vec[i + 1] - offset_vec[i];
+    }
     return {data_vec.data() + offset_vec[i],
-            static_cast<Inst::index_type>(offset_vec[i + 1] - offset_vec[i])};
+            static_cast<Inst::index_type>(size)};
   }
 
   /*! \brief constructor */
@@ -241,42 +250,17 @@ class SparsePage {
    * \brief Push row block into the page.
    * \param batch the row batch.
    */
-  inline void Push(const dmlc::RowBlock<uint32_t>& batch) {
-    auto& data_vec = data.HostVector();
-    auto& offset_vec = offset.HostVector();
-    data_vec.reserve(data.Size() + batch.offset[batch.size] - batch.offset[0]);
-    offset_vec.reserve(offset.Size() + batch.size);
-    CHECK(batch.index != nullptr);
-    for (size_t i = 0; i < batch.size; ++i) {
-      offset_vec.push_back(offset_vec.back() + batch.offset[i + 1] - batch.offset[i]);
-    }
-    for (size_t i = batch.offset[0]; i < batch.offset[batch.size]; ++i) {
-      uint32_t index = batch.index[i];
-      bst_float fvalue = batch.value == nullptr ? 1.0f : batch.value[i];
-      data_vec.emplace_back(index, fvalue);
-    }
-    CHECK_EQ(offset_vec.back(), data.Size());
-  }
+  void Push(const dmlc::RowBlock<uint32_t>& batch);
   /*!
    * \brief Push a sparse page
    * \param batch the row page
    */
-  inline void Push(const SparsePage &batch) {
-    auto& data_vec = data.HostVector();
-    auto& offset_vec = offset.HostVector();
-    const auto& batch_offset_vec = batch.offset.HostVector();
-    const auto& batch_data_vec = batch.data.HostVector();
-    size_t top = offset_vec.back();
-    data_vec.resize(top + batch.data.Size());
-    std::memcpy(dmlc::BeginPtr(data_vec) + top,
-                dmlc::BeginPtr(batch_data_vec),
-                sizeof(Entry) * batch.data.Size());
-    size_t begin = offset.Size();
-    offset_vec.resize(begin + batch.Size());
-    for (size_t i = 0; i < batch.Size(); ++i) {
-      offset_vec[i + begin] = top + batch_offset_vec[i + 1];
-    }
-  }
+  void Push(const SparsePage &batch);
+  /*!
+   * \brief Push a SparsePage stored in CSC format
+   * \param batch The row batch to be pushed
+   */
+  void PushCSC(const SparsePage& batch);
   /*!
    * \brief Push one instance into page
    *  \param inst an instance row
@@ -285,7 +269,6 @@ class SparsePage {
     auto& data_vec = data.HostVector();
     auto& offset_vec = offset.HostVector();
     offset_vec.push_back(offset_vec.back() + inst.size());
-
     size_t begin = data_vec.size();
     data_vec.resize(begin + inst.size());
     if (inst.size() != 0) {
@@ -301,6 +284,7 @@ class BatchIteratorImpl {
  public:
   virtual ~BatchIteratorImpl() {}
   virtual BatchIteratorImpl* Clone() = 0;
+  virtual SparsePage& operator*() = 0;
   virtual const SparsePage& operator*() const = 0;
   virtual void operator++() = 0;
   virtual bool AtEnd() const = 0;
@@ -324,6 +308,11 @@ class BatchIterator {
     ++(*impl_);
   }
 
+  SparsePage& operator*() {
+    CHECK(impl_ != nullptr);
+    return *(*impl_);
+  }
+
   const SparsePage& operator*() const {
     CHECK(impl_ != nullptr);
     return *(*impl_);
@@ -450,12 +439,14 @@ class DMatrix {
    * \param load_row_split Flag to read in part of rows, divided among the workers in distributed mode.
    * \param file_format The format type of the file, used for dmlc::Parser::Create.
    *   By default "auto" will be able to load in both local binary file.
+   * \param page_size Page size for external memory.
    * \return The created DMatrix.
    */
   static DMatrix* Load(const std::string& uri,
                        bool silent,
                        bool load_row_split,
-                       const std::string& file_format = "auto");
+                       const std::string& file_format = "auto",
+                       const size_t page_size = kPageSize);
   /*!
    * \brief create a new DMatrix, by wrapping a row_iterator, and meta info.
    * \param source The source iterator of the data, the create function takes ownership of the source.
@@ -471,6 +462,7 @@ class DMatrix {
    * \param parser The input data parser
    * \param cache_prefix The path to prefix of temporary cache file of the DMatrix when used in external memory mode.
    *     This can be nullptr for common cases, and in-memory mode will be used.
+   * \param page_size Page size for external memory.
    * \sa dmlc::Parser
    * \note dmlc-core provides efficient distributed data parser for libsvm format.
    *  User can create and register customized parser to load their own format using DMLC_REGISTER_DATA_PARSER.
@@ -478,7 +470,11 @@ class DMatrix {
    * \return A created DMatrix.
    */
   static DMatrix* Create(dmlc::Parser<uint32_t>* parser,
-                         const std::string& cache_prefix = "");
+                         const std::string& cache_prefix = "",
+                         const size_t page_size = kPageSize);
+
+  /*! \brief page size 32 MB */
+  static const size_t kPageSize = 32UL << 20UL;
 };
 
 // implementation of inline functions

include/xgboost/learner.h

@@ -11,6 +11,7 @@
 #include <rabit/rabit.h>
 #include <utility>
 #include <map>
+#include <memory>
 #include <string>
 #include <vector>
 #include "./base.h"