fix additional files note (#4699 )

* fix additional files note * Trigger CI * Trigger CI
Upgrade dmlc-core submodule (#4688 )
2019-07-25 11:21:48 -07:00 · 2019-07-20 11:31:04 -07:00 · 2019-07-18 11:58:54 -07:00 · 2019-07-18 11:58:30 -07:00 · 2019-06-20 14:23:20 -07:00
571 changed files with 18842 additions and 48331 deletions
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -1,21 +1,21 @@
-Checks: 'modernize-*,-modernize-make-*,-modernize-use-auto,-modernize-raw-string-literal,-modernize-avoid-c-arrays,-modernize-use-trailing-return-type,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  }
-  - { key: readability-identifier-naming.TypeAliasCase,             value: CamelCase  }
-  - { 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.EnumCase,                  value: CamelCase  }
-  - { key: readability-identifier-naming.EnumConstant,              value: CamelCase  }
-  - { key: readability-identifier-naming.EnumConstantPrefix,        value: k          }
-  - { key: readability-identifier-naming.GlobalConstantCase,        value: CamelCase  }
-  - { key: readability-identifier-naming.GlobalConstantPrefix,      value: k          }
-  - { key: readability-identifier-naming.StaticConstantCase,        value: CamelCase  }
-  - { key: readability-identifier-naming.StaticConstantPrefix,      value: k          }
-  - { key: readability-identifier-naming.ConstexprVariableCase,     value: CamelCase  }
-  - { key: readability-identifier-naming.ConstexprVariablePrefix,   value: k          }
-  - { key: readability-identifier-naming.FunctionCase,              value: CamelCase  }
-  - { key: readability-identifier-naming.NamespaceCase,             value: lower_case }
+  - { key: readability-identifier-naming.ClassCase,           value: CamelCase  }
+  - { key: readability-identifier-naming.StructCase,          value: CamelCase  }
+  - { key: readability-identifier-naming.TypeAliasCase,          value: CamelCase  }
+  - { 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.EnumCase,          value: CamelCase  }
+  - { key: readability-identifier-naming.EnumConstant,          value: CamelCase  }
+  - { key: readability-identifier-naming.EnumConstantPrefix,          value: k  }
+  - { key: readability-identifier-naming.GlobalConstantCase,          value: CamelCase  }
+  - { key: readability-identifier-naming.GlobalConstantPrefix,          value: k  }
+  - { key: readability-identifier-naming.StaticConstantCase,          value: CamelCase  }
+  - { key: readability-identifier-naming.StaticConstantPrefix,          value: k  }
+  - { key: readability-identifier-naming.ConstexprVariableCase,          value: CamelCase  }
+  - { key: readability-identifier-naming.ConstexprVariablePrefix,          value: k  }
+  - { key: readability-identifier-naming.FunctionCase,          value: CamelCase  }
+  - { key: readability-identifier-naming.NamespaceCase,       value: lower_case }
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@@ -1 +0,0 @@
-open_collective: xgboost
--- a/.gitignore
+++ b/.gitignore
@@ -17,7 +17,7 @@
 *.tar.gz
 *conf
 *buffer
-*.model
+*model
 *pyc
 *.train
 *.test
@@ -65,11 +65,14 @@ nb-configuration*
 .pydevproject
 .settings/
 build
+config.mk
 /xgboost
 *.data
 build_plugin
+.idea
 recommonmark/
 tags
+*.iml
 *.class
 target
 *.swp
@@ -87,19 +90,9 @@ lib/
 # spark
 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
-
-# Visual Studio Code
-/.vscode/
-
-# IntelliJ/CLion
-.idea
-*.iml
-/cmake-build-debug/
-
-# GDB
-.gdb_history
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,55 +1,36 @@
 # disable sudo for container build.
 sudo: required

-# Enabling test OS X
+# Enabling test on Linux and OS X
 os:
-  - linux
  - osx

-osx_image: xcode10.1
-dist: bionic
+osx_image: xcode9.3

 # Use Build Matrix to do lint and build seperately
 env:
  matrix:
    # python package test
    - TASK=python_test
-    # test installation of Python source distribution
-    - TASK=python_sdist_test
    # java package test
    - TASK=java_test
    # cmake test
-    - TASK=cmake_test
+    # - TASK=cmake_test

-  global:
-    - secure: "PR16i9F8QtNwn99C5NDp8nptAS+97xwDtXEJJfEiEVhxPaaRkOp0MPWhogCaK0Eclxk1TqkgWbdXFknwGycX620AzZWa/A1K3gAs+GrpzqhnPMuoBJ0Z9qxXTbSJvCyvMbYwVrjaxc/zWqdMU8waWz8A7iqKGKs/SqbQ3rO6v7c="
-    - secure: "dAGAjBokqm/0nVoLMofQni/fWIBcYSmdq4XvCBX1ZAMDsWnuOfz/4XCY6h2lEI1rVHZQ+UdZkc9PioOHGPZh5BnvE49/xVVWr9c4/61lrDOlkD01ZjSAeoV0fAZq+93V/wPl4QV+MM+Sem9hNNzFSbN5VsQLAiWCSapWsLdKzqA="
-
-matrix:
-  exclude:
-    - os: linux
-      env: TASK=python_test
-    - os: linux
-      env: TASK=java_test
-    - os: linux
-      env: TASK=cmake_test
-
-# dependent brew packages
+# dependent apt packages
 addons:
  homebrew:
    packages:
-      - cmake
-      - libomp
+      - gcc@7
      - graphviz
      - openssl
      - libgit2
-      - wget
      - r
    update: true

 before_install:
-  - source tests/travis/travis_setup_env.sh
-  - if [ "${TASK}" != "python_sdist_test" ]; then export PYTHONPATH=${PYTHONPATH}:${PWD}/python-package; fi
+  - source dmlc-core/scripts/travis/travis_setup_env.sh
+  - export PYTHONPATH=${PYTHONPATH}:${PWD}/python-package
  - echo "MAVEN_OPTS='-Xmx2g -XX:MaxPermSize=1024m -XX:ReservedCodeCacheSize=512m -Dorg.slf4j.simpleLogger.defaultLogLevel=error'" > ~/.mavenrc

 install:
@@ -64,7 +45,7 @@ cache:
    - ${HOME}/.cache/pip

 before_cache:
-  - tests/travis/travis_before_cache.sh
+  - dmlc-core/scripts/travis/travis_before_cache.sh

 after_failure:
  - tests/travis/travis_after_failure.sh
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,91 +1,61 @@
-cmake_minimum_required(VERSION 3.13)
-project(xgboost LANGUAGES CXX C VERSION 1.1.0)
+cmake_minimum_required(VERSION 3.3)
+project(xgboost LANGUAGES CXX C VERSION 0.90)
 include(cmake/Utils.cmake)
-list(APPEND CMAKE_MODULE_PATH "${xgboost_SOURCE_DIR}/cmake/modules")
+list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake/modules")
 cmake_policy(SET CMP0022 NEW)
-cmake_policy(SET CMP0079 NEW)
-cmake_policy(SET CMP0063 NEW)
-
-if ((${CMAKE_VERSION} VERSION_GREATER 3.13) OR (${CMAKE_VERSION} VERSION_EQUAL 3.13))
-  cmake_policy(SET CMP0077 NEW)
-endif ((${CMAKE_VERSION} VERSION_GREATER 3.13) OR (${CMAKE_VERSION} VERSION_EQUAL 3.13))

 message(STATUS "CMake version ${CMAKE_VERSION}")
+if (MSVC)
+  cmake_minimum_required(VERSION 3.11)
+endif (MSVC)

-if (CMAKE_COMPILER_IS_GNUCC AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.0)
-  message(FATAL_ERROR "GCC version must be at least 5.0!")
-endif()
-
-include(${xgboost_SOURCE_DIR}/cmake/FindPrefetchIntrinsics.cmake)
-find_prefetch_intrinsics()
-include(${xgboost_SOURCE_DIR}/cmake/Version.cmake)
-write_version()
 set_default_configuration_release()

 #-- Options
 option(BUILD_C_DOC "Build documentation for C APIs using Doxygen." OFF)
 option(USE_OPENMP "Build with OpenMP support." ON)
-option(BUILD_STATIC_LIB "Build static library" OFF)
 ## Bindings
 option(JVM_BINDINGS "Build JVM bindings" OFF)
 option(R_LIB "Build shared library for R package" OFF)
 ## Dev
-option(USE_DEBUG_OUTPUT "Dump internal training results like gradients and predictions to stdout.
-Should only be used for debugging." OFF)
 option(GOOGLE_TEST "Build google tests" OFF)
-option(USE_DMLC_GTEST "Use google tests bundled with dmlc-core submodule" 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")
-option(RABIT_MOCK "Build rabit with mock" OFF)
-option(HIDE_CXX_SYMBOLS "Build shared library and hide all C++ symbols" OFF)
 ## CUDA
 option(USE_CUDA  "Build with GPU acceleration" OFF)
-option(USE_NCCL  "Build with NCCL to enable distributed GPU support." 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
  "Semicolon separated list of compute versions to be built against, e.g. '35;61'")
-## Copied From dmlc
-option(USE_HDFS "Build with HDFS support" OFF)
-option(USE_AZURE "Build with AZURE support" OFF)
-option(USE_S3 "Build with S3 support" OFF)
+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, undefined and thread.")
+address, leak and thread.")
 ## Plugins
 option(PLUGIN_LZ4 "Build lz4 plugin" OFF)
 option(PLUGIN_DENSE_PARSER "Build dense parser plugin" OFF)

-#-- Checks for building XGBoost
-if (USE_DEBUG_OUTPUT AND (NOT (CMAKE_BUILD_TYPE MATCHES Debug)))
-  message(SEND_ERROR "Do not enable `USE_DEBUG_OUTPUT' with release build.")
-endif (USE_DEBUG_OUTPUT AND (NOT (CMAKE_BUILD_TYPE MATCHES Debug)))
-if (USE_NCCL AND NOT (USE_CUDA))
-  message(SEND_ERROR "`USE_NCCL` must be enabled with `USE_CUDA` flag.")
-endif (USE_NCCL AND NOT (USE_CUDA))
-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))
-if (JVM_BINDINGS AND R_LIB)
-  message(SEND_ERROR "`R_LIB' is not compatible with `JVM_BINDINGS' as they both have customized configurations.")
-endif (JVM_BINDINGS AND R_LIB)
-if (R_LIB AND GOOGLE_TEST)
-  message(WARNING "Some C++ unittests will fail with `R_LIB` enabled,
- as R package redirects some functions to R runtime implementation.")
-endif (R_LIB AND GOOGLE_TEST)
+## Deprecation warning
 if (USE_AVX)
-  message(SEND_ERROR  "The option 'USE_AVX' is deprecated as experimental AVX features have been removed from XGBoost.")
+  message(WARNING "The option 'USE_AVX' is deprecated as experimental AVX features have been removed from xgboost.")
 endif (USE_AVX)

-#-- Sanitizer
+# 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)

 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})
@@ -97,20 +67,9 @@ if (USE_CUDA)
  message(STATUS "CUDA GEN_CODE: ${GEN_CODE}")
 endif (USE_CUDA)

-find_package(Threads REQUIRED)
-
-if (USE_OPENMP)
-  if (APPLE)
-    # Require CMake 3.16+ on Mac OSX, as previous versions of CMake had trouble locating
-    # OpenMP on Mac. See https://github.com/dmlc/xgboost/pull/5146#issuecomment-568312706
-    cmake_minimum_required(VERSION 3.16)
-  endif (APPLE)
-  find_package(OpenMP REQUIRED)
-endif (USE_OPENMP)
-
 # dmlc-core
 msvc_use_static_runtime()
-add_subdirectory(${xgboost_SOURCE_DIR}/dmlc-core)
+add_subdirectory(${PROJECT_SOURCE_DIR}/dmlc-core)
 set_target_properties(dmlc PROPERTIES
  CXX_STANDARD 11
  CXX_STANDARD_REQUIRED ON
@@ -118,52 +77,40 @@ set_target_properties(dmlc PROPERTIES
 list(APPEND LINKED_LIBRARIES_PRIVATE dmlc)

 # rabit
-set(RABIT_BUILD_DMLC OFF)
-set(DMLC_ROOT ${xgboost_SOURCE_DIR}/dmlc-core)
-set(RABIT_WITH_R_LIB ${R_LIB})
-add_subdirectory(rabit)
-
-if (RABIT_MOCK)
-  list(APPEND LINKED_LIBRARIES_PRIVATE rabit_mock_static)
-else()
-  list(APPEND LINKED_LIBRARIES_PRIVATE rabit)
-endif(RABIT_MOCK)
-foreach(lib rabit rabit_base rabit_empty rabit_mock rabit_mock_static)
-  # Explicitly link dmlc to rabit, so that configured header (build_config.h)
-  # from dmlc is correctly applied to rabit.
-  if (TARGET ${lib})
-    target_link_libraries(${lib} dmlc ${CMAKE_THREAD_LIBS_INIT})
-    if (HIDE_CXX_SYMBOLS)  # Hide all C++ symbols from Rabit
-      set_target_properties(${lib} PROPERTIES CXX_VISIBILITY_PRESET hidden)
-    endif (HIDE_CXX_SYMBOLS)
-  endif (TARGET ${lib})
-endforeach()
+# 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)
+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)

 # Exports some R specific definitions and objects
 if (R_LIB)
-  add_subdirectory(${xgboost_SOURCE_DIR}/R-package)
+  add_subdirectory(${PROJECT_SOURCE_DIR}/R-package)
 endif (R_LIB)

 # core xgboost
-list(APPEND LINKED_LIBRARIES_PRIVATE Threads::Threads ${CMAKE_THREAD_LIBS_INIT})
-add_subdirectory(${xgboost_SOURCE_DIR}/plugin)
-add_subdirectory(${xgboost_SOURCE_DIR}/src)
-target_link_libraries(objxgboost PUBLIC dmlc)
+add_subdirectory(${PROJECT_SOURCE_DIR}/src)
 set(XGBOOST_OBJ_SOURCES "${XGBOOST_OBJ_SOURCES};$<TARGET_OBJECTS:objxgboost>")

-#-- library
-if (BUILD_STATIC_LIB)
-  add_library(xgboost STATIC ${XGBOOST_OBJ_SOURCES})
-else (BUILD_STATIC_LIB)
-  add_library(xgboost SHARED ${XGBOOST_OBJ_SOURCES})
-endif (BUILD_STATIC_LIB)
-
-#-- Hide all C++ symbols
-if (HIDE_CXX_SYMBOLS)
-  set_target_properties(objxgboost PROPERTIES CXX_VISIBILITY_PRESET hidden)
-  set_target_properties(xgboost PROPERTIES CXX_VISIBILITY_PRESET hidden)
-endif (HIDE_CXX_SYMBOLS)
-
+#-- Shared library
+add_library(xgboost SHARED ${XGBOOST_OBJ_SOURCES} ${PLUGINS_SOURCES})
 target_include_directories(xgboost
  INTERFACE
  $<INSTALL_INTERFACE:${CMAKE_INSTALL_PREFIX}/include>
@@ -172,18 +119,22 @@ target_link_libraries(xgboost PRIVATE ${LINKED_LIBRARIES_PRIVATE})

 # This creates its own shared library `xgboost4j'.
 if (JVM_BINDINGS)
-  add_subdirectory(${xgboost_SOURCE_DIR}/jvm-packages)
+  add_subdirectory(${PROJECT_SOURCE_DIR}/jvm-packages)
 endif (JVM_BINDINGS)
 #-- End shared library

 #-- CLI for xgboost
-add_executable(runxgboost ${xgboost_SOURCE_DIR}/src/cli_main.cc ${XGBOOST_OBJ_SOURCES})
-
+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
-  ${xgboost_SOURCE_DIR}/include
-  ${xgboost_SOURCE_DIR}/dmlc-core/include
-  ${xgboost_SOURCE_DIR}/rabit/include)
+  ${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
@@ -192,8 +143,8 @@ set_target_properties(
  CXX_STANDARD_REQUIRED ON)
 #-- End CLI for xgboost

-set_output_directory(runxgboost ${xgboost_SOURCE_DIR})
-set_output_directory(xgboost ${xgboost_SOURCE_DIR}/lib)
+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)

@@ -216,9 +167,11 @@ if (BUILD_C_DOC)
 endif (BUILD_C_DOC)

 include(GNUInstallDirs)
-# Install all headers.  Please note that currently the C++ headers does not form an "API".
-install(DIRECTORY ${xgboost_SOURCE_DIR}/include/xgboost
-  DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+# Exposing only C APIs.
+install(FILES
+  "${PROJECT_SOURCE_DIR}/include/xgboost/c_api.h"
+  DESTINATION
+  include/xgboost/)

 install(TARGETS xgboost runxgboost
  EXPORT XGBoostTargets
@@ -250,21 +203,21 @@ install(
 if (GOOGLE_TEST)
  enable_testing()
  # Unittests.
-  add_subdirectory(${xgboost_SOURCE_DIR}/tests/cpp)
+  add_subdirectory(${PROJECT_SOURCE_DIR}/tests/cpp)
  add_test(
    NAME TestXGBoostLib
    COMMAND testxgboost
-    WORKING_DIRECTORY ${xgboost_BINARY_DIR})
+    WORKING_DIRECTORY ${PROJECT_BINARY_DIR})

  # CLI tests
  configure_file(
-    ${xgboost_SOURCE_DIR}/tests/cli/machine.conf.in
-    ${xgboost_BINARY_DIR}/tests/cli/machine.conf
+    ${PROJECT_SOURCE_DIR}/tests/cli/machine.conf.in
+    ${PROJECT_BINARY_DIR}/tests/cli/machine.conf
    @ONLY)
  add_test(
    NAME TestXGBoostCLI
-    COMMAND runxgboost ${xgboost_BINARY_DIR}/tests/cli/machine.conf
-    WORKING_DIRECTORY ${xgboost_BINARY_DIR})
+    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.*")
--- a/CONTRIBUTORS.md
+++ b/CONTRIBUTORS.md
@@ -2,42 +2,34 @@ Contributors of DMLC/XGBoost
 ============================
 XGBoost has been developed and used by a group of active community. Everyone is more than welcomed to is a great way to make the project better and more accessible to more users.

-Project Management Committee(PMC) 
----------
-The Project Management Committee(PMC) consists group of active committers that moderate the discussion, manage the project release, and proposes new committer/PMC members. 
-
-* [Tianqi Chen](https://github.com/tqchen), University of Washington
-  - Tianqi is a Ph.D. student working on large-scale machine learning. He is the creator of the project.
-* [Michael Benesty](https://github.com/pommedeterresautee)
-  - Michael is a lawyer and data scientist in France. He is the creator of XGBoost interactive analysis module in R.
-* [Yuan Tang](https://github.com/terrytangyuan), Ant Financial
-  - Yuan is a software engineer in Ant Financial. He contributed mostly in R and Python packages.
-* [Nan Zhu](https://github.com/CodingCat), Uber
-  - Nan is a software engineer in Uber. He contributed mostly in JVM packages.
-* [Jiaming Yuan](https://github.com/trivialfis)
-  - Jiaming contributed to the GPU algorithms. He has also introduced new abstractions to improve the quality of the C++ codebase.
-* [Hyunsu Cho](http://hyunsu-cho.io/), NVIDIA
-  - Hyunsu is the maintainer of the XGBoost Python package. He also manages the Jenkins continuous integration system (https://xgboost-ci.net/). He is the initial author of the CPU 'hist' updater.
-* [Rory Mitchell](https://github.com/RAMitchell), University of Waikato
-  - Rory is a Ph.D. student at University of Waikato. He is the original creator of the GPU training algorithms. He improved the CMake build system and continuous integration. 
-* [Hongliang Liu](https://github.com/phunterlau)
-
-
 Committers
 ----------
 Committers are people who have made substantial contribution to the project and granted write access to the project.
-
+* [Tianqi Chen](https://github.com/tqchen), University of Washington
+  - Tianqi is a Ph.D. student working on large-scale machine learning. He is the creator of the project.
 * [Tong He](https://github.com/hetong007), Amazon AI
  - Tong is an applied scientist in Amazon AI. He is the maintainer of XGBoost R package.
 * [Vadim Khotilovich](https://github.com/khotilov)
  - Vadim contributes many improvements in R and core packages.
 * [Bing Xu](https://github.com/antinucleon)
  - Bing is the original creator of XGBoost Python package and currently the maintainer of [XGBoost.jl](https://github.com/antinucleon/XGBoost.jl).
+* [Michael Benesty](https://github.com/pommedeterresautee)
+  - Michael is a lawyer and data scientist in France. He is the creator of XGBoost interactive analysis module in R.
+* [Yuan Tang](https://github.com/terrytangyuan), Ant Financial
+  - Yuan is a software engineer in Ant Financial. He contributed mostly in R and Python packages.
+* [Nan Zhu](https://github.com/CodingCat), Uber
+  - Nan is a software engineer in Uber. He contributed mostly in JVM packages.
 * [Sergei Lebedev](https://github.com/superbobry), Criteo
  - Sergei is a software engineer in Criteo. He contributed mostly in JVM packages.
+* [Hongliang Liu](https://github.com/phunterlau)
 * [Scott Lundberg](http://scottlundberg.com/), University of Washington
  - Scott is a Ph.D. student at University of Washington. He is the creator of SHAP, a unified approach to explain the output of machine learning models such as decision tree ensembles. He also helps maintain the XGBoost Julia package.
-
+* [Rory Mitchell](https://github.com/RAMitchell), University of Waikato
+  - Rory is a Ph.D. student at University of Waikato. He is the original creator of the GPU training algorithms. He improved the CMake build system and continuous integration. 
+* [Hyunsu Cho](http://hyunsu-cho.io/), Amazon AI
+  - Hyunsu is an applied scientist in Amazon AI. He is the maintainer of the XGBoost Python package. He also manages the Jenkins continuous integration system (https://xgboost-ci.net/). He is the initial author of the CPU 'hist' updater. 
+* [Jiaming](https://github.com/trivialfis)
+  - Jiaming contributed to the GPU algorithms. He has also introduced new abstractions to improve the quality of the C++ codebase.

 Become a Committer
 ------------------
@@ -97,8 +89,3 @@ List of Contributors
 * [Sam Wilkinson](https://samwilkinson.io)
 * [Matthew Jones](https://github.com/mt-jones)
 * [Jiaxiang Li](https://github.com/JiaxiangBU)
-* [Bryan Woods](https://github.com/bryan-woods)
-  - Bryan added support for cross-validation for the ranking objective
-* [Haoda Fu](https://github.com/fuhaoda)
-* [Evan Kepner](https://github.com/EvanKepner)
-  - Evan Kepner added support for os.PathLike file paths in Python
--- a/148
+++ b/148
@@ -6,25 +6,19 @@
 // Command to run command inside a docker container
 dockerRun = 'tests/ci_build/ci_build.sh'

-import groovy.transform.Field
-
-@Field
-def commit_id   // necessary to pass a variable from one stage to another
-
 pipeline {
  // Each stage specify its own agent
  agent none

  environment {
-    DOCKER_CACHE_ECR_ID = '492475357299'
-    DOCKER_CACHE_ECR_REGION = 'us-west-2'
+    DOCKER_CACHE_REPO = '492475357299.dkr.ecr.us-west-2.amazonaws.com'
  }

  // Setup common job properties
  options {
    ansiColor('xterm')
    timestamps()
-    timeout(time: 240, unit: 'MINUTES')
+    timeout(time: 120, unit: 'MINUTES')
    buildDiscarder(logRotator(numToKeepStr: '10'))
    preserveStashes()
  }
@@ -36,7 +30,6 @@ pipeline {
      steps {
        script {
          checkoutSrcs()
-          commit_id = "${GIT_COMMIT}"
        }
        stash name: 'srcs'
        milestone ordinal: 1
@@ -62,8 +55,8 @@ pipeline {
        script {
          parallel ([
            'build-cpu': { BuildCPU() },
-            'build-cpu-rabit-mock': { BuildCPUMock() },
-            'build-cpu-non-omp': { BuildCPUNonOmp() },
+            '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') },
@@ -79,6 +72,7 @@ pipeline {
        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') },
@@ -88,23 +82,13 @@ pipeline {
            '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
      }
    }
-    stage('Jenkins Linux: Deploy') {
-      agent none
-      steps {
-        script {
-          parallel ([
-            'deploy-jvm-packages': { DeployJVMPackages(spark_version: '2.4.3') }
-          ])
-        }
-        milestone ordinal: 5
-      }
-    }
  }
 }

@@ -129,9 +113,9 @@ def ClangTidy() {
    echo "Running clang-tidy job..."
    def container_type = "clang_tidy"
    def docker_binary = "docker"
-    def dockerArgs = "--build-arg CUDA_VERSION=10.1"
+    def dockerArgs = "--build-arg CUDA_VERSION=9.2"
    sh """
-    ${dockerRun} ${container_type} ${docker_binary} ${dockerArgs} python3 tests/ci_build/tidy.py
+    ${dockerRun} ${container_type} ${docker_binary} ${dockerArgs} tests/ci_build/clang_tidy.sh
    """
    deleteDir()
  }
@@ -173,6 +157,7 @@ def Doxygen() {
    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()
@@ -186,54 +171,17 @@ def BuildCPU() {
    def container_type = "cpu"
    def docker_binary = "docker"
    sh """
-    ${dockerRun} ${container_type} ${docker_binary} rm -fv dmlc-core/include/dmlc/build_config_default.h
-      # This step is not necessary, but here we include it, to ensure that DMLC_CORE_USE_CMAKE flag is correctly propagated
-      # We want to make sure that we use the configured header build/dmlc/build_config.h instead of include/dmlc/build_config_default.h.
-      # See discussion at https://github.com/dmlc/xgboost/issues/5510
    ${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 -e UBSAN_OPTIONS=print_stacktrace=1:log_path=ubsan_error.log --cap-add SYS_PTRACE'"
+    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} tests/ci_build/build_via_cmake.sh -DUSE_SANITIZER=ON -DENABLED_SANITIZERS="address;leak;undefined" \
+    ${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
    """
-
-    stash name: 'xgboost_cli', includes: 'xgboost'
-    deleteDir()
-  }
-}
-
-def BuildCPUMock() {
-  node('linux && cpu') {
-    unstash name: 'srcs'
-    echo "Build CPU with rabit mock"
-    def container_type = "cpu"
-    def docker_binary = "docker"
-    sh """
-    ${dockerRun} ${container_type} ${docker_binary} tests/ci_build/build_mock_cmake.sh
-    """
-    echo 'Stashing rabit C++ test executable (xgboost)...'
-    stash name: 'xgboost_rabit_tests', includes: 'xgboost'
-    deleteDir()
-  }
-}
-
-def BuildCPUNonOmp() {
-  node('linux && cpu') {
-    unstash name: 'srcs'
-    echo "Build CPU without OpenMP"
-    def container_type = "cpu"
-    def docker_binary = "docker"
-    sh """
-    ${dockerRun} ${container_type} ${docker_binary} tests/ci_build/build_via_cmake.sh -DUSE_OPENMP=OFF
-    """
-    echo "Running Non-OpenMP C++ test..."
-    sh """
-    ${dockerRun} ${container_type} ${docker_binary} build/testxgboost
-    """
    deleteDir()
  }
 }
@@ -246,16 +194,17 @@ def BuildCUDA(args) {
    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 -DHIDE_CXX_SYMBOLS=ON
+    ${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"
-    ${dockerRun} ${container_type} ${docker_binary} ${docker_args} python3 tests/ci_build/rename_whl.py python-package/dist/*.whl ${commit_id} manylinux2010_x86_64
    """
-    // Stash wheel for CUDA 10.0 target
-    if (args.cuda_version == '10.0') {
+    // Stash wheel for CUDA 8.0 / 9.0 target
+    if (args.cuda_version == '8.0') {
      echo 'Stashing Python wheel...'
-      stash name: 'xgboost_whl_cuda10', includes: 'python-package/dist/*.whl'
-      path = ("${BRANCH_NAME}" == 'master') ? '' : "${BRANCH_NAME}/"
-      s3Upload bucket: 'xgboost-nightly-builds', path: path, acl: 'PublicRead', workingDir: 'python-package/dist', includePathPattern:'**/*.whl'
+      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'
    }
@@ -275,7 +224,7 @@ def BuildJVMPackages(args) {
    ${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"
+    stash name: 'xgboost4j_jar', includes: 'jvm-packages/xgboost4j/target/*.jar,jvm-packages/xgboost4j-spark/target/*.jar,jvm-packages/xgboost4j-example/target/*.jar'
    deleteDir()
  }
 }
@@ -289,6 +238,7 @@ def BuildJVMDoc() {
    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()
@@ -297,15 +247,13 @@ def BuildJVMDoc() {

 def TestPythonCPU() {
  node('linux && cpu') {
-    unstash name: 'xgboost_whl_cuda10'
+    unstash name: 'xgboost_whl_cuda9'
    unstash name: 'srcs'
-    unstash name: 'xgboost_cli'
    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
-    ${dockerRun} ${container_type} ${docker_binary} tests/ci_build/test_python.sh cpu-py35
    """
    deleteDir()
  }
@@ -314,7 +262,11 @@ def TestPythonCPU() {
 def TestPythonGPU(args) {
  nodeReq = (args.multi_gpu) ? 'linux && mgpu' : 'linux && gpu'
  node(nodeReq) {
-    unstash name: 'xgboost_whl_cuda10'
+    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"
@@ -325,39 +277,12 @@ def TestPythonGPU(args) {
      sh """
      ${dockerRun} ${container_type} ${docker_binary} ${docker_args} tests/ci_build/test_python.sh mgpu
      """
-      if (args.cuda_version != '9.0') {
-        echo "Running tests with cuDF..."
-        sh """
-        ${dockerRun} cudf ${docker_binary} ${docker_args} tests/ci_build/test_python.sh mgpu-cudf
-        """
-      }
    } else {
      echo "Using a single GPU"
      sh """
      ${dockerRun} ${container_type} ${docker_binary} ${docker_args} tests/ci_build/test_python.sh gpu
      """
-      if (args.cuda_version != '9.0') {
-        echo "Running tests with cuDF..."
-        sh """
-        ${dockerRun} cudf ${docker_binary} ${docker_args} tests/ci_build/test_python.sh cudf
-        """
-      }
    }
-    // For CUDA 10.0 target, run cuDF tests too
-    deleteDir()
-  }
-}
-
-def TestCppRabit() {
-  node(nodeReq) {
-    unstash name: 'xgboost_rabit_tests'
-    unstash name: 'srcs'
-    echo "Test C++, rabit mock on"
-    def container_type = "cpu"
-    def docker_binary = "docker"
-    sh """
-    ${dockerRun} ${container_type} ${docker_binary} tests/ci_build/runxgb.sh xgboost tests/ci_build/approx.conf.in
-    """
    deleteDir()
  }
 }
@@ -413,23 +338,8 @@ def TestR(args) {
    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 || tests/ci_build/print_r_stacktrace.sh
+    ${dockerRun} ${container_type} ${docker_binary} ${docker_args} tests/ci_build/build_test_rpkg.sh
    """
    deleteDir()
  }
 }
-
-def DeployJVMPackages(args) {
-  node('linux && cpu') {
-    unstash name: 'srcs'
-    if (env.BRANCH_NAME == 'master' || env.BRANCH_NAME.startsWith('release')) {
-      echo 'Deploying to xgboost-maven-repo S3 repo...'
-      def container_type = "jvm"
-      def docker_binary = "docker"
-      sh """
-      ${dockerRun} ${container_type} ${docker_binary} tests/ci_build/deploy_jvm_packages.sh ${args.spark_version}
-      """
-    }
-    deleteDir()
-  }
-}
--- a/21
+++ b/21
@@ -3,11 +3,6 @@

 /* Jenkins pipeline for Windows AMD64 target */

-import groovy.transform.Field
-
-@Field
-def commit_id   // necessary to pass a variable from one stage to another
-
 pipeline {
  agent none
  // Build stages
@@ -17,7 +12,6 @@ pipeline {
      steps {
        script {
          checkoutSrcs()
-          commit_id = "${GIT_COMMIT}"
        }
        stash name: 'srcs'
        milestone ordinal: 1
@@ -82,7 +76,7 @@ def BuildWin64() {
    """
    bat """
    cd python-package
-    conda activate && python setup.py bdist_wheel --universal && for /R %%i in (dist\\*.whl) DO python ../tests/ci_build/rename_whl.py "%%i" ${commit_id} win_amd64
+    conda activate && python setup.py bdist_wheel --universal
    """
    echo "Insert vcomp140.dll (OpenMP runtime) into the wheel..."
    bat """
@@ -92,11 +86,9 @@ def BuildWin64() {
    """
    echo 'Stashing Python wheel...'
    stash name: 'xgboost_whl', includes: 'python-package/dist/*.whl'
-    path = ("${BRANCH_NAME}" == 'master') ? '' : "${BRANCH_NAME}/"
-    s3Upload bucket: 'xgboost-nightly-builds', path: path, acl: 'PublicRead', workingDir: 'python-package/dist', includePathPattern:'**/*.whl'
+    archiveArtifacts artifacts: "python-package/dist/*.whl", allowEmptyArchive: true
    echo 'Stashing C++ test executable (testxgboost)...'
    stash name: 'xgboost_cpp_tests', includes: 'build/testxgboost.exe'
-    stash name: 'xgboost_cli', includes: 'xgboost.exe'
    deleteDir()
  }
 }
@@ -105,17 +97,12 @@ def TestWin64CPU() {
  node('win64 && cpu') {
    unstash name: 'srcs'
    unstash name: 'xgboost_whl'
-    unstash name: 'xgboost_cli'
    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 "Installing Python dependencies..."
-    bat """
-     conda activate && conda upgrade scikit-learn pandas numpy
-    """
    echo "Running Python tests..."
    bat "conda activate && python -m pytest -v -s --fulltrace tests\\python"
    bat "conda activate && python -m pip uninstall -y xgboost"
@@ -137,10 +124,6 @@ def TestWin64GPU(args) {
    bat """
    conda activate && for /R %%i in (python-package\\dist\\*.whl) DO python -m pip install "%%i"
    """
-    echo "Installing Python dependencies..."
-    bat """
-     conda activate && conda upgrade scikit-learn pandas numpy
-    """
    echo "Running Python tests..."
    bat """
    conda activate && python -m pytest -v -s --fulltrace -m "(not slow) and (not mgpu)" tests\\python-gpu
--- a/2
+++ b/2
@@ -186,7 +186,7 @@
      same "printed page" as the copyright notice for easier
      identification within third-party archives.

-   Copyright (c) 2019 by Contributors
+   Copyright (c) 2018 by Contributors

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
--- a/160
+++ b/160
@@ -1,3 +1,11 @@
+ifndef config
+ifneq ("$(wildcard ./config.mk)","")
+	config = config.mk
+else
+	config = make/config.mk
+endif
+endif
+
 ifndef DMLC_CORE
 	DMLC_CORE = dmlc-core
 endif
@@ -22,8 +30,23 @@ ifndef MAKE_OK
 endif
 $(warning MAKE [$(MAKE)] - $(if $(MAKE_OK),checked OK,PROBLEM))

+ifeq ($(OS), Windows_NT)
+	UNAME="Windows"
+else
+	UNAME=$(shell uname)
+endif
+
+include $(config)
+ifeq ($(USE_OPENMP), 0)
+	export NO_OPENMP = 1
+endif
 include $(DMLC_CORE)/make/dmlc.mk

+# include the plugins
+ifdef XGB_PLUGINS
+include $(XGB_PLUGINS)
+endif
+
 # set compiler defaults for OSX versus *nix
 # let people override either
 OS := $(shell uname)
@@ -44,31 +67,111 @@ export CXX = g++
 endif
 endif

-export CFLAGS= -DDMLC_LOG_CUSTOMIZE=1 -std=c++11 -Wall -Wno-unknown-pragmas -Iinclude $(ADD_CFLAGS)
+export LDFLAGS= -pthread -lm $(ADD_LDFLAGS) $(DMLC_LDFLAGS) $(PLUGIN_LDFLAGS)
+export CFLAGS= -DDMLC_LOG_CUSTOMIZE=1 -std=c++11 -Wall -Wno-unknown-pragmas -Iinclude $(ADD_CFLAGS) $(PLUGIN_CFLAGS)
 CFLAGS += -I$(DMLC_CORE)/include -I$(RABIT)/include -I$(GTEST_PATH)/include
+#java include path
+export JAVAINCFLAGS = -I${JAVA_HOME}/include -I./java

 ifeq ($(TEST_COVER), 1)
 	CFLAGS += -g -O0 -fprofile-arcs -ftest-coverage
 else
 	CFLAGS += -O3 -funroll-loops
+ifeq ($(USE_SSE), 1)
+	CFLAGS += -msse2
+endif
 endif

 ifndef LINT_LANG
 	LINT_LANG= "all"
 endif

+ifeq ($(UNAME), Windows)
+	XGBOOST_DYLIB = lib/xgboost.dll
+	JAVAINCFLAGS += -I${JAVA_HOME}/include/win32
+else
+ifeq ($(UNAME), Darwin)
+	XGBOOST_DYLIB = lib/libxgboost.dylib
+	CFLAGS += -fPIC
+else
+	XGBOOST_DYLIB = lib/libxgboost.so
+	CFLAGS += -fPIC
+endif
+endif
+
+ifeq ($(UNAME), Linux)
+	LDFLAGS += -lrt
+	JAVAINCFLAGS += -I${JAVA_HOME}/include/linux
+endif
+
+ifeq ($(UNAME), Darwin)
+	JAVAINCFLAGS += -I${JAVA_HOME}/include/darwin
+endif
+
+OPENMP_FLAGS =
+ifeq ($(USE_OPENMP), 1)
+	OPENMP_FLAGS = -fopenmp
+else
+	OPENMP_FLAGS = -DDISABLE_OPENMP
+endif
+CFLAGS += $(OPENMP_FLAGS)
+
 # specify tensor path
-.PHONY: clean all lint clean_all doxygen rcpplint pypack Rpack Rbuild Rcheck
+.PHONY: clean all lint clean_all doxygen rcpplint pypack Rpack Rbuild Rcheck java pylint
+
+all: lib/libxgboost.a $(XGBOOST_DYLIB) xgboost
+
+$(DMLC_CORE)/libdmlc.a: $(wildcard $(DMLC_CORE)/src/*.cc $(DMLC_CORE)/src/*/*.cc)
+	+ cd $(DMLC_CORE); "$(MAKE)" libdmlc.a config=$(ROOTDIR)/$(config); cd $(ROOTDIR)
+
+$(RABIT)/lib/$(LIB_RABIT): $(wildcard $(RABIT)/src/*.cc)
+	+ cd $(RABIT); "$(MAKE)" lib/$(LIB_RABIT) USE_SSE=$(USE_SSE); cd $(ROOTDIR)
+
+jvm: jvm-packages/lib/libxgboost4j.so
+
+SRC = $(wildcard src/*.cc src/*/*.cc)
+ALL_OBJ = $(patsubst src/%.cc, build/%.o, $(SRC)) $(PLUGIN_OBJS)
+AMALGA_OBJ = amalgamation/xgboost-all0.o
+LIB_DEP = $(DMLC_CORE)/libdmlc.a $(RABIT)/lib/$(LIB_RABIT)
+ALL_DEP = $(filter-out build/cli_main.o, $(ALL_OBJ)) $(LIB_DEP)
+CLI_OBJ = build/cli_main.o
+include tests/cpp/xgboost_test.mk

 build/%.o: src/%.cc
 	@mkdir -p $(@D)
 	$(CXX) $(CFLAGS) -MM -MT build/$*.o $< >build/$*.d
 	$(CXX) -c $(CFLAGS) $< -o $@

+build_plugin/%.o: plugin/%.cc
+	@mkdir -p $(@D)
+	$(CXX) $(CFLAGS) -MM -MT build_plugin/$*.o $< >build_plugin/$*.d
+	$(CXX) -c $(CFLAGS) $< -o $@
+
 # The should be equivalent to $(ALL_OBJ)  except for build/cli_main.o
 amalgamation/xgboost-all0.o: amalgamation/xgboost-all0.cc
 	$(CXX) -c $(CFLAGS) $< -o $@

+# Equivalent to lib/libxgboost_all.so
+lib/libxgboost_all.so: $(AMALGA_OBJ) $(LIB_DEP)
+	@mkdir -p $(@D)
+	$(CXX) $(CFLAGS) -shared -o $@ $(filter %.o %.a, $^) $(LDFLAGS)
+
+lib/libxgboost.a: $(ALL_DEP)
+	@mkdir -p $(@D)
+	ar crv $@ $(filter %.o, $?)
+
+lib/xgboost.dll lib/libxgboost.so lib/libxgboost.dylib: $(ALL_DEP)
+	@mkdir -p $(@D)
+	$(CXX) $(CFLAGS) -shared -o $@ $(filter %.o %a,  $^) $(LDFLAGS)
+
+jvm-packages/lib/libxgboost4j.so: jvm-packages/xgboost4j/src/native/xgboost4j.cpp $(ALL_DEP)
+	@mkdir -p $(@D)
+	$(CXX) $(CFLAGS) $(JAVAINCFLAGS) -shared -o $@ $(filter %.cpp %.o %.a, $^) $(LDFLAGS)
+
+
+xgboost: $(CLI_OBJ) $(ALL_DEP)
+	$(CXX) $(CFLAGS) -o $@  $(filter %.o %.a, $^)  $(LDFLAGS)
+
 rcpplint:
 	python3 dmlc-core/scripts/lint.py xgboost ${LINT_LANG} R-package/src

@@ -77,7 +180,17 @@ lint: rcpplint
 	  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 python-package
+	  ${LINT_LANG} include src plugin python-package
+
+pylint:
+	flake8 --ignore E501 python-package
+	flake8 --ignore E501 tests/python
+
+test: $(ALL_TEST)
+	$(ALL_TEST)
+
+check: test
+	./tests/cpp/xgboost_test

 ifeq ($(TEST_COVER), 1)
 cover: check
@@ -87,7 +200,7 @@ cover: check
 endif

 clean:
-	$(RM) -rf build lib bin *~ */*~ */*/*~ */*/*/*~ */*.o */*/*.o */*/*/*.o #xgboost
+	$(RM) -rf build build_plugin lib bin *~ */*~ */*/*~ */*/*/*~ */*.o */*/*.o */*/*/*.o #xgboost
 	$(RM) -rf build_tests *.gcov tests/cpp/xgboost_test
 	if [ -d "R-package/src" ]; then \
 		cd R-package/src; \
@@ -99,9 +212,36 @@ clean_all: clean
 	cd $(DMLC_CORE); "$(MAKE)" clean; cd $(ROOTDIR)
 	cd $(RABIT); "$(MAKE)" clean; cd $(ROOTDIR)

+doxygen:
+	doxygen doc/Doxyfile
+
+# create standalone python tar file.
+pypack: ${XGBOOST_DYLIB}
+	cp ${XGBOOST_DYLIB} python-package/xgboost
+	cd python-package; tar cf xgboost.tar xgboost; cd ..
+
 # create pip source dist (sdist) pack for PyPI
 pippack: clean_all
-	cd python-package; python setup.py sdist; mv dist/*.tar.gz ..; cd ..
+	rm -rf xgboost-python
+# remove symlinked directories in python-package/xgboost
+	rm -rf python-package/xgboost/lib
+	rm -rf python-package/xgboost/dmlc-core
+	rm -rf python-package/xgboost/include
+	rm -rf python-package/xgboost/make
+	rm -rf python-package/xgboost/rabit
+	rm -rf python-package/xgboost/src
+	cp -r python-package xgboost-python
+	cp -r Makefile xgboost-python/xgboost/
+	cp -r make xgboost-python/xgboost/
+	cp -r src xgboost-python/xgboost/
+	cp -r tests xgboost-python/xgboost/
+	cp -r include xgboost-python/xgboost/
+	cp -r dmlc-core xgboost-python/xgboost/
+	cp -r rabit xgboost-python/xgboost/
+# Use setup_pip.py instead of setup.py
+	mv xgboost-python/setup_pip.py xgboost-python/setup.py
+# Build sdist tarball
+	cd xgboost-python; python setup.py sdist; mv dist/*.tar.gz ..; cd ..

 # Script to make a clean installable R package.
 Rpack: clean_all
@@ -122,17 +262,10 @@ Rpack: clean_all
 	cp -r dmlc-core/include xgboost/src/dmlc-core/include
 	cp -r dmlc-core/src xgboost/src/dmlc-core/src
 	cp ./LICENSE xgboost
-# Modify PKGROOT in Makevars.in
-	cat R-package/src/Makevars.in|sed '2s/.*/PKGROOT=./' > xgboost/src/Makevars.in
-# Configure Makevars.win (Windows-specific Makevars, likely using MinGW)
+	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
-	cat xgboost/src/Makevars.in| sed '3s/.*/ENABLE_STD_THREAD=0/' > 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
-	sed -i -e 's/@ENDIAN_FLAG@/-DDMLC_CMAKE_LITTLE_ENDIAN=1/g' xgboost/src/Makevars.win
-	sed -i -e 's/@BACKTRACE_LIB@//g' xgboost/src/Makevars.win
-	sed -i -e 's/@OPENMP_LIB@//g' xgboost/src/Makevars.win
-	rm -f xgboost/src/Makevars.win-e   # OSX sed create this extra file; remove it
 	bash R-package/remove_warning_suppression_pragma.sh
 	rm xgboost/remove_warning_suppression_pragma.sh

@@ -145,3 +278,4 @@ Rcheck: Rbuild

 -include build/*.d
 -include build/*/*.d
+-include build_plugin/*/*.d
--- a/NEWS.md
+++ b/NEWS.md
@@ -3,314 +3,6 @@ XGBoost Change Log

 This file records the changes in xgboost library in reverse chronological order.

-## v1.0.0 (2020.02.19)
-This release marks a major milestone for the XGBoost project.
-
-### Apache-style governance, contribution policy, and semantic versioning (#4646, #4659)
-* Starting with 1.0.0 release, the XGBoost Project is adopting Apache-style governance. The full community guideline is [available in the doc website](https://xgboost.readthedocs.io/en/release_1.0.0/contrib/community.html). Note that we now have Project Management Committee (PMC) who would steward the project on the long-term basis. The PMC is also entrusted to run and fund the project's continuous integration (CI) infrastructure (https://xgboost-ci.net).
-* We also adopt the [semantic versioning](https://semver.org/). See [our release versioning policy](https://xgboost.readthedocs.io/en/release_1.0.0/contrib/release.html).
-
-### Better performance scaling for multi-core CPUs (#4502, #4529, #4716, #4851, #5008, #5107, #5138, #5156)
-* Poor performance scaling of the `hist` algorithm for multi-core CPUs has been under investigation (#3810). Previous effort #4529 was replaced with a series of pull requests (#5107, #5138, #5156) aimed at achieving the same performance benefits while keeping the C++ codebase legible. The latest performance benchmark results show [up to 5x speedup on Intel CPUs with many cores](https://github.com/dmlc/xgboost/pull/5156#issuecomment-580024413). Note: #5244, which concludes the effort, will become part of the upcoming release 1.1.0.
-
-### Improved installation experience on Mac OSX (#4672, #5074, #5080, #5146, #5240)
-* It used to be quite complicated to install XGBoost on Mac OSX. XGBoost uses OpenMP to distribute work among multiple CPU cores, and Mac's default C++ compiler (Apple Clang) does not come with OpenMP. Existing work-around (using another C++ compiler) was complex and prone to fail with cryptic diagnosis (#4933, #4949, #4969).
-* Now it only takes two commands to install XGBoost: `brew install libomp` followed by `pip install xgboost`. The installed XGBoost will use all CPU cores.
-* Even better, XGBoost is now available from Homebrew: `brew install xgboost`. See Homebrew/homebrew-core#50467.
-* Previously, if you installed the XGBoost R package using the command `install.packages('xgboost')`, it could only use a single CPU core and you would experience slow training performance. With 1.0.0 release, the R package will use all CPU cores out of box.
-
-### Distributed XGBoost now available on Kubernetes (#4621, #4939)
-* Check out the [tutorial for setting up distributed XGBoost on a Kubernetes cluster](https://xgboost.readthedocs.io/en/release_1.0.0/tutorials/kubernetes.html).
-
-### Ruby binding for XGBoost (#4856)
-
-### New Native Dask interface for multi-GPU and multi-node scaling (#4473, #4507, #4617, #4819, #4907, #4914, #4941, #4942, #4951, #4973, #5048, #5077, #5144, #5270)
-* XGBoost now integrates seamlessly with [Dask](https://dask.org/), a lightweight distributed framework for data processing. Together with the first-class support for cuDF data frames (see below), it is now easier than ever to create end-to-end data pipeline running on one or more NVIDIA GPUs.
-* Multi-GPU training with Dask is now up to 20% faster than the previous release (#4914, #4951).
-
-### First-class support for cuDF data frames and cuPy arrays (#4737, #4745, #4794, #4850, #4891, #4902, #4918, #4927, #4928, #5053, #5189, #5194, #5206, #5219, #5225)
-* [cuDF](https://github.com/rapidsai/cudf) is a data frame library for loading and processing tabular data on NVIDIA GPUs. It provides a Pandas-like API.
-* [cuPy](https://github.com/cupy/cupy) implements a NumPy-compatible multi-dimensional array on NVIDIA GPUs.
-* Now users can keep the data on the GPU memory throughout the end-to-end data pipeline, obviating the need for copying data between the main memory and GPU memory.
-* XGBoost can accept any data structure that exposes `__array_interface__` signature, opening way to support other columar formats that are compatible with Apache Arrow.
-
-### [Feature interaction constraint](https://xgboost.readthedocs.io/en/release_1.0.0/tutorials/feature_interaction_constraint.html) is now available with `approx` and `gpu_hist` algorithms (#4534, #4587, #4596, #5034).
-
-### Learning to rank is now GPU accelerated (#4873, #5004, #5129)
-* Supported ranking objectives: NDGC, Map, Pairwise.
-* [Up to 2x improved training performance on GPUs](https://devblogs.nvidia.com/learning-to-rank-with-xgboost-and-gpu/).
-
-### Enable `gamma` parameter for GPU training (#4874, #4953)
-* The `gamma` parameter specifies the minimum loss reduction required to add a new split in a tree. A larger value for `gamma` has the effect of pre-pruning the tree, by making harder to add splits.
-
-### External memory for GPU training (#4486, #4526, #4747, #4833, #4879, #5014)
-* It is now possible to use NVIDIA GPUs even when the size of training data exceeds the available GPU memory. Note that the external memory support for GPU is still experimental. #5093 will further improve performance and will become part of the upcoming release 1.1.0.
-* RFC for enabling external memory with GPU algorithms: #4357
-
-### Improve Scikit-Learn interface (#4558, #4842, #4929, #5049, #5151, #5130, #5227)
-* Many users of XGBoost enjoy the convenience and breadth of Scikit-Learn ecosystem. In this release, we revise the Scikit-Learn API of XGBoost (`XGBRegressor`, `XGBClassifier`, and `XGBRanker`) to achieve feature parity with the traditional XGBoost interface (`xgboost.train()`).
-* Insert check to validate data shapes.
-* Produce an error message if `eval_set` is not a tuple. An error message is better than silently crashing.
-* Allow using `numpy.RandomState` object.
-* Add `n_jobs` as an alias of `nthread`.
-* Roadmap: #5152
-
-### XGBoost4J-Spark: Redesigning checkpointing mechanism
-* RFC is available at #4786
-* Clean up checkpoint file after a successful training job (#4754): The current implementation in XGBoost4J-Spark does not clean up the checkpoint file after a successful training job. If the user runs another job with the same checkpointing directory, she will get a wrong model because the second job will re-use the checkpoint file left over from the first job. To prevent this scenario, we propose to always clean up the checkpoint file after every successful training job.
-* Avoid Multiple Jobs for Checkpointing (#5082): The current method for checkpoint is to collect the booster produced at the last iteration of each checkpoint internal to Driver and persist it in HDFS. The major issue with this approach is that it needs to re-perform the data preparation for training if the user did not choose to cache the training dataset. To avoid re-performing data prep, we build external-memory checkpointing in the XGBoost4J layer as well.
-* Enable deterministic repartitioning when checkpoint is enabled (#4807): Distributed algorithm for gradient boosting assumes a fixed partition of the training data between multiple iterations. In previous versions, there was no guarantee that data partition would stay the same, especially when a worker goes down and some data had to recovered from previous checkpoint. In this release, we make data partition deterministic by using the data hash value of each data row in computing the partition.
-
-### XGBoost4J-Spark: handle errors thrown by the native code (#4560)
-* All core logic of XGBoost is written in C++, so XGBoost4J-Spark internally uses the C++ code via Java Native Interface (JNI). #4560 adds a proper error handling for any errors or exceptions arising from the C++ code, so that the XGBoost Spark application can be torn down in an orderly fashion.
-
-### XGBoost4J-Spark: Refine method to count the number of alive cores  (#4858)
-* The `SparkParallelismTracker` class ensures that sufficient number of executor cores are alive. To that end, it is important to query the number of alive cores reliably.
-
-### XGBoost4J: Add `BigDenseMatrix` to store more than `Integer.MAX_VALUE` elements (#4383)
-
-### Robust model serialization with JSON (#4632, #4708, #4739, #4868, #4936, #4945, #4974, #5086, #5087, #5089, #5091, #5094, #5110, #5111, #5112, #5120, #5137, #5218, #5222, #5236, #5245, #5248, #5281)
-* In this release, we introduce an experimental support of using [JSON](https://www.json.org/json-en.html) for serializing (saving/loading) XGBoost models and related hyperparameters for training. We would like to eventually replace the old binary format with JSON, since it is an open format and parsers are available in many programming languages and platforms. See [the documentation for model I/O using JSON](https://xgboost.readthedocs.io/en/release_1.0.0/tutorials/saving_model.html). #3980 explains why JSON was chosen over other alternatives.
-* To maximize interoperability and compatibility of the serialized models, we now split serialization into two parts (#4855):
-  1. Model, e.g. decision trees and strictly related metadata like `num_features`.
-  2. Internal configuration, consisting of training parameters and other configurable parameters. For example, `max_delta_step`, `tree_method`, `objective`, `predictor`, `gpu_id`.
-
-  Previously, users often ran into issues where the model file produced by one machine could not load or run on another machine. For example, models trained using a machine with an NVIDIA GPU could not run on another machine without a GPU (#5291, #5234). The reason is that the old binary format saved some internal configuration that were not universally applicable to all machines, e.g. `predictor='gpu_predictor'`.
-
-  Now, model saving function (`Booster.save_model()` in Python) will save only the model, without internal configuration. This will guarantee that your model file would be used anywhere. Internal configuration will be serialized in limited circumstances such as:
-  * Multiple nodes in a distributed system exchange model details over the network.
-  * Model checkpointing, to recover from possible crashes.
-
-  This work proved to be useful for parameter validation as well (see below).
-* Starting with 1.0.0 release, we will use semantic versioning to indicate whether the model produced by one version of XGBoost would be compatible with another version of XGBoost. Any change in the major version indicates a breaking change in the serialization format.
-* We now provide a robust method to save and load scikit-learn related attributes (#5245). Previously, we used Python pickle to save Python attributes related to `XGBClassifier`, `XGBRegressor`, and `XGBRanker` objects. The attributes are necessary to properly interact with scikit-learn. See #4639 for more details. The use of pickling hampered interoperability, as a pickle from one machine may not necessarily work on another machine. Starting with this release, we use an alternative method to serialize the scikit-learn related attributes. The use of Python pickle is now discouraged (#5236, #5281).
-
-### Parameter validation: detection of unused or incorrect parameters (#4553, #4577, #4738, #4801, #4961, #5101, #5157, #5167, #5256)
-* Mis-spelled training parameter is a common user mistake. In previous versions of XGBoost, mis-spelled parameters were silently ignored. Starting with 1.0.0 release, XGBoost will produce a warning message if there is any unused training parameters. Currently, parameter validation is available to R users and Python XGBoost API users. We are working to extend its support to scikit-learn users.
-* Configuration steps now have well-defined semantics (#4542, #4738), so we know exactly where and how the internal configurable parameters are changed.
-* The user can now use `save_config()` function to inspect all (used) training parameters. This is helpful for debugging model performance.
-
-### Allow individual workers to recover from faults (#4808, #4966)
-* Status quo: if a worker fails, all workers are shut down and restarted, and learning resumes from the last checkpoint. This involves requesting resources from the scheduler (e.g. Spark) and shuffling all the data again from scratch. Both of these operations can be quite costly and block training for extended periods of time, especially if the training data is big and the number of worker nodes is in the hundreds.
-* The proposed solution is to recover the single node that failed, instead of shutting down all workers. The rest of the clusters wait until the single failed worker is bootstrapped and catches up with the rest.
-* See roadmap at #4753. Note that this is work in progress. In particular, the feature is not yet available from XGBoost4J-Spark.
-
-### Accurate prediction for DART models
-* Use DART tree weights when computing SHAPs (#5050)
-* Don't drop trees during DART prediction by default (#5115)
-* Fix DART prediction in R (#5204)
-
-### Make external memory more robust
-* Fix issues with training with external memory on cpu (#4487)
-* Fix crash with approx tree method on cpu (#4510)
-* Fix external memory race in `exact` (#4980). Note: `dmlc::ThreadedIter` is not actually thread-safe. We would like to re-design it in the long term.
-
-### Major refactoring of the `DMatrix` class (#4686, #4744, #4748, #5044, #5092, #5108, #5188, #5198)
-* Goal 1: improve performance and reduce memory consumption. Right now, if the user trains a model with a NumPy array as training data, the array gets copies 2-3 times before training begins. We'd like to reduce duplication of the data matrix.
-* Goal 2: Expose a common interface to external data, unify the way DMatrix objects are constructed and simplify the process of adding new external data sources. This work is essential for ingesting cuPy arrays.
-* Goal 3: Handle missing values consistently.
-* RFC: #4354, Roadmap: #5143
-* This work is also relevant to external memory support on GPUs.
-
-### Breaking: XGBoost Python package now requires Python 3.5 or newer (#5021, #5274)
-* Python 3.4 has reached its end-of-life on March 16, 2019, so we now require Python 3.5 or newer.
-
-### Breaking: GPU algorithm now requires CUDA 9.0 and higher (#4527, #4580)
-
-### Breaking: `n_gpus` parameter removed; multi-GPU training now requires a distributed framework (#4579, #4749, #4773, #4810, #4867, #4908)
-* #4531 proposed removing support for single-process multi-GPU training. Contributors would focus on multi-GPU support through distributed frameworks such as Dask and Spark, where the framework would be expected to assign a worker process for each GPU independently. By delegating GPU management and data movement to the distributed framework, we can greatly simplify the core XGBoost codebase, make multi-GPU training more robust, and reduce burden for future development.
-
-### Breaking: Some deprecated features have been removed
-* ``gpu_exact`` training method (#4527, #4742, #4777). Use ``gpu_hist`` instead.
-* ``learning_rates`` parameter in Python (#5155). Use the callback API instead.
-* ``num_roots`` (#5059, #5165), since the current training code always uses a single root node.
-* GPU-specific objectives (#4690), such as `gpu:reg:linear`. Use objectives without `gpu:` prefix; GPU will be used automatically if your machine has one.
-
-### Breaking: the C API function `XGBoosterPredict()` now asks for an extra parameter `training`.
-
-### Breaking: We now use CMake exclusively to build XGBoost. `Makefile` is being sunset.
-* Exception: the R package uses Autotools, as the CRAN ecosystem did not yet adopt CMake widely.
-
-### Performance improvements
-* Smarter choice of histogram construction for distributed `gpu_hist` (#4519)
-* Optimizations for quantization on device (#4572)
-* Introduce caching memory allocator to avoid latency associated with GPU memory allocation (#4554, #4615)
-* Optimize the initialization stage of the CPU `hist` algorithm for sparse datasets (#4625)
-* Prevent unnecessary data copies from GPU memory to the host (#4795)
-* Improve operation efficiency for single prediction (#5016)
-* Group builder modified for incremental building, to speed up building large `DMatrix` (#5098)
-
-### Bug-fixes
-* Eliminate `FutureWarning: Series.base is deprecated` (#4337)
-* Ensure pandas DataFrame column names are treated as strings in type error message (#4481)
-* [jvm-packages] Add back `reg:linear` for scala, as it is only deprecated and not meant to be removed yet (#4490)
-* Fix library loading for Cygwin users (#4499)
-* Fix prediction from loaded pickle (#4516)
-* Enforce exclusion between `pred_interactions=True` and `pred_interactions=True` (#4522)
-* Do not return dangling reference to local `std::string` (#4543)
-* Set the appropriate device before freeing device memory (#4566)
-* Mark `SparsePageDmatrix` destructor default. (#4568)
-* Choose the appropriate tree method only when the tree method is 'auto' (#4571)
-* Fix `benchmark_tree.py` (#4593)
-* [jvm-packages] Fix silly bug in feature scoring (#4604)
-* Fix GPU predictor when the test data matrix has different number of features than the training data matrix used to train the model (#4613)
-* Fix external memory for get column batches. (#4622)
-* [R] Use built-in label when xgb.DMatrix is given to xgb.cv() (#4631)
-* Fix early stopping in the Python package (#4638)
-* Fix AUC error in distributed mode caused by imbalanced dataset (#4645, #4798)
-* [jvm-packages] Expose `setMissing` method in `XGBoostClassificationModel` / `XGBoostRegressionModel` (#4643)
-* Remove initializing stringstream reference. (#4788)
-* [R] `xgb.get.handle` now checks all class listed of `object` (#4800)
-* Do not use `gpu_predictor` unless data comes from GPU (#4836)
-* Fix data loading (#4862)
-* Workaround `isnan` across different environments. (#4883)
-* [jvm-packages] Handle Long-type parameter (#4885)
-* Don't `set_params` at the end of `set_state` (#4947). Ensure that the model does not change after pickling and unpickling multiple times.
-* C++ exceptions should not crash OpenMP loops (#4960)
-* Fix `usegpu` flag in DART. (#4984)
-* Run training with empty `DMatrix` (#4990, #5159)
-* Ensure that no two processes can use the same GPU (#4990)
-* Fix repeated split and 0 cover nodes (#5010)
-* Reset histogram hit counter between multiple data batches (#5035)
-* Fix `feature_name` crated from int64index dataframe. (#5081)
-* Don't use 0 for "fresh leaf" (#5084)
-* Throw error when user attempts to use multi-GPU training and XGBoost has not been compiled with NCCL (#5170)
-* Fix metric name loading (#5122)
-* Quick fix for memory leak in CPU `hist` algorithm (#5153)
-* Fix wrapping GPU ID and prevent data copying (#5160)
-* Fix signature of Span constructor (#5166)
-* Lazy initialization of device vector, so that XGBoost compiled with CUDA can run on a machine without any GPU (#5173)
-* Model loading should not change system locale (#5314)
-* Distributed training jobs would sometimes hang; revert Rabit to fix this regression (dmlc/rabit#132, #5237)
-
-### API changes
-* Add support for cross-validation using query ID (#4474)
-* Enable feature importance property for DART model (#4525)
-* Add `rmsle` metric and `reg:squaredlogerror` objective (#4541)
-* All objective and evaluation metrics are now exposed to JVM packages (#4560)
-* `dump_model()` and `get_dump()` now support exporting in GraphViz language (#4602)
-* Support metrics `ndcg-` and `map-` (#4635)
-* [jvm-packages] Allow chaining prediction (transform) in XGBoost4J-Spark (#4667)
-* [jvm-packages] Add option to bypass missing value check in the Spark layer (#4805). Only use this option if you know what you are doing.
-* [jvm-packages] Add public group getter (#4838)
-* `XGDMatrixSetGroup` C API is now deprecated (#4864). Use `XGDMatrixSetUIntInfo` instead.
-* [R] Added new `train_folds` parameter to `xgb.cv()` (#5114)
-* Ingest meta information from Pandas DataFrame, such as data weights (#5216)
-
-### Maintenance: Refactor code for legibility and maintainability
-* De-duplicate GPU parameters (#4454)
-* Simplify INI-style config reader using C++11 STL (#4478, #4521)
-* Refactor histogram building code for `gpu_hist` (#4528)
-* Overload device memory allocator, to enable instrumentation for compiling memory usage statistics (#4532)
-* Refactor out row partitioning logic from `gpu_hist` (#4554)
-* Remove an unused variable (#4588)
-* Implement tree model dump with code generator, to de-duplicate code for generating dumps in 3 different formats (#4602)
-* Remove `RowSet` class which is no longer being used (#4697)
-* Remove some unused functions as reported by cppcheck (#4743)
-* Mimic CUDA assert output in Span check (#4762)
-* [jvm-packages] Refactor `XGBoost.scala` to put all params processing in one place (#4815)
-* Add some comments for GPU row partitioner (#4832)
-* Span: use `size_t' for index_type,  add `front' and `back'. (#4935)
-* Remove dead code in `exact` algorithm (#5034, #5105)
-* Unify integer types used for row and column indices (#5034)
-* Extract feature interaction constraint from `SplitEvaluator` class. (#5034)
-* [Breaking] De-duplicate paramters and docstrings in the constructors of Scikit-Learn models (#5130)
-* Remove benchmark code from GPU tests (#5141)
-* Clean up Python 2 compatibility code. (#5161)
-* Extensible binary serialization format for `DMatrix::MetaInfo` (#5187). This will be useful for implementing censored labels for survival analysis applications.
-* Cleanup clang-tidy warnings. (#5247)
-
-### Maintenance: testing, continuous integration, build system
-* Use `yaml.safe_load` instead of `yaml.load`. (#4537)
-* Ensure GCC is at least 5.x (#4538)
-* Remove all mention of `reg:linear` from tests (#4544)
-* [jvm-packages] Upgrade to Scala 2.12 (#4574)
-* [jvm-packages] Update kryo dependency to 2.22 (#4575)
-* [CI] Specify account ID when logging into ECR Docker registry (#4584)
-* Use Sphinx 2.1+ to compile documentation (#4609)
-* Make Pandas optional for running Python unit tests (#4620)
-* Fix spark tests on machines with many cores (#4634)
-* [jvm-packages] Update local dev build process (#4640)
-* Add optional dependencies to setup.py (#4655)
-* [jvm-packages] Fix maven warnings (#4664)
-* Remove extraneous files from the R package, to comply with CRAN policy (#4699)
-* Remove VC-2013 support, since it is not C++11 compliant (#4701)
-* [CI] Fix broken installation of Pandas (#4704, #4722)
-* [jvm-packages] Clean up temporary files afer running tests (#4706)
-* Specify version macro in CMake. (#4730)
-* Include dmlc-tracker into XGBoost Python package (#4731)
-* [CI] Use long key ID for Ubuntu repository fingerprints. (#4783)
-* Remove plugin, cuda related code in automake & autoconf files (#4789)
-* Skip related tests when scikit-learn is not installed. (#4791)
-* Ignore vscode and clion files (#4866)
-* Use bundled Google Test by default (#4900)
-* [CI] Raise timeout threshold in Jenkins (#4938)
-* Copy CMake parameter from dmlc-core. (#4948)
-* Set correct file permission. (#4964)
-* [CI] Update lint configuration to support latest pylint convention (#4971)
-* [CI] Upload nightly builds to S3 (#4976, #4979)
-* Add asan.so.5 to cmake script. (#4999)
-* [CI] Fix Travis tests. (#5062)
-* [CI] Locate vcomp140.dll from System32 directory (#5078)
-* Implement training observer to dump internal states of objects (#5088). This will be useful for debugging.
-* Fix visual studio output library directories (#5119)
-* [jvm-packages] Comply with scala style convention + fix broken unit test (#5134)
-* [CI] Repair download URL for Maven 3.6.1 (#5139)
-* Don't use modernize-use-trailing-return-type in clang-tidy. (#5169)
-* Explicitly use UTF-8 codepage when using MSVC (#5197)
-* Add CMake option to run Undefined Behavior Sanitizer (UBSan) (#5211)
-* Make some GPU tests deterministic (#5229)
-* [R] Robust endian detection in CRAN xgboost build (#5232)
-* Support FreeBSD (#5233)
-* Make `pip install xgboost*.tar.gz` work by fixing build-python.sh (#5241)
-* Fix compilation error due to 64-bit integer narrowing to `size_t` (#5250)
-* Remove use of `std::cout` from R package, to comply with CRAN policy (#5261)
-* Update DMLC-Core submodule (#4674, #4688, #4726, #4924)
-* Update Rabit submodule (#4560, #4667, #4718, #4808, #4966, #5237)
-
-### Usability Improvements, Documentation
-* Add Random Forest API to Python API doc (#4500)
-* Fix Python demo and doc. (#4545)
-* Remove doc about not supporting cuda 10.1 (#4578)
-* Address some sphinx warnings and errors, add doc for building doc. (#4589)
-* Add instruction to run formatting checks locally (#4591)
-* Fix docstring for `XGBModel.predict()` (#4592)
-* Doc and demo for customized metric and objective (#4598, #4608)
-* Add to documentation how to run tests locally (#4610)
-* Empty evaluation list in early stopping should produce meaningful error message (#4633)
-* Fixed year to 2019 in conf.py, helpers.h and LICENSE (#4661)
-* Minor updates to links and grammar (#4673)
-* Remove `silent` in doc (#4689)
-* Remove old Python trouble shooting doc (#4729)
-* Add `os.PathLike` support for file paths to DMatrix and Booster Python classes (#4757)
-* Update XGBoost4J-Spark doc (#4804)
-* Regular formatting for evaluation metrics (#4803)
-* [jvm-packages] Refine documentation for handling missing values in XGBoost4J-Spark (#4805)
-* Monitor for distributed envorinment (#4829). This is useful for identifying performance bottleneck.
-* Add check for length of weights and produce a good error message (#4872)
-* Fix DMatrix doc (#4884)
-* Export C++ headers in CMake installation (#4897)
-* Update license year in README.md to 2019 (#4940)
-* Fix incorrectly displayed Note in the doc (#4943)
-* Follow PEP 257 Docstring Conventions (#4959)
-* Document minimum version required for Google Test (#5001)
-* Add better error message for invalid feature names (#5024)
-* Some guidelines on device memory usage (#5038)
-* [doc] Some notes for external memory. (#5065)
-* Update document for `tree_method` (#5106)
-* Update demo for ranking. (#5154)
-* Add new lines for Spark XGBoost missing values section (#5180)
-* Fix simple typo: utilty -> utility (#5182)
-* Update R doc by roxygen2 (#5201)
-* [R] Direct user to use `set.seed()` instead of setting `seed` parameter (#5125)
-* Add Optuna badge to `README.md` (#5208)
-* Fix compilation error in `c-api-demo.c` (#5215)
-
-### Acknowledgement
-**Contributors**: Nan Zhu (@CodingCat), Crissman Loomis (@Crissman), Cyprien Ricque (@Cyprien-Ricque), Evan Kepner (@EvanKepner), K.O. (@Hi-king), KaiJin Ji (@KerryJi), Peter Badida (@KeyWeeUsr), Kodi Arfer (@Kodiologist), Rory Mitchell (@RAMitchell), Egor Smirnov (@SmirnovEgorRu), Jacob Kim (@TheJacobKim), Vibhu Jawa (@VibhuJawa), Marcos (@astrowonk), Andy Adinets (@canonizer), Chen Qin (@chenqin), Christopher Cowden (@cowden), @cpfarrell, @david-cortes, Liangcai Li (@firestarman), @fuhaoda, Philip Hyunsu Cho (@hcho3), @here-nagini, Tong He (@hetong007), Michal Kurka (@michalkurka), Honza Sterba (@honzasterba), @iblumin, @koertkuipers, mattn (@mattn), Mingjie Tang (@merlintang), OrdoAbChao (@mglowacki100), Matthew Jones (@mt-jones), mitama (@nigimitama), Nathan Moore (@nmoorenz), Daniel Stahl (@phillyfan1138), Michaël Benesty (@pommedeterresautee), Rong Ou (@rongou), Sebastian (@sfahnens), Xu Xiao (@sperlingxx), @sriramch, Sean Owen (@srowen), Stephanie Yang (@stpyang), Yuan Tang (@terrytangyuan), Mathew Wicks (@thesuperzapper), Tim Gates (@timgates42), TinkleG (@tinkle1129), Oleksandr Pryimak (@trams), Jiaming Yuan (@trivialfis), Matvey Turkov (@turk0v), Bobby Wang (@wbo4958), yage (@yage99), @yellowdolphin
-
-**Reviewers**: Nan Zhu (@CodingCat), Crissman Loomis (@Crissman), Cyprien Ricque (@Cyprien-Ricque), Evan Kepner (@EvanKepner), John Zedlewski (@JohnZed), KOLANICH (@KOLANICH), KaiJin Ji (@KerryJi), Kodi Arfer (@Kodiologist), Rory Mitchell (@RAMitchell), Egor Smirnov (@SmirnovEgorRu), Nikita Titov (@StrikerRUS), Jacob Kim (@TheJacobKim), Vibhu Jawa (@VibhuJawa), Andrew Kane (@ankane), Arno Candel (@arnocandel), Marcos (@astrowonk), Bryan Woods (@bryan-woods), Andy Adinets (@canonizer), Chen Qin (@chenqin), Thomas Franke (@coding-komek), Peter  (@codingforfun), @cpfarrell, Joshua Patterson (@datametrician), @fuhaoda, Philip Hyunsu Cho (@hcho3), Tong He (@hetong007), Honza Sterba (@honzasterba), @iblumin, @jakirkham, Vadim Khotilovich (@khotilov), Keith Kraus (@kkraus14), @koertkuipers, @melonki, Mingjie Tang (@merlintang), OrdoAbChao (@mglowacki100), Daniel Mahler (@mhlr), Matthew Rocklin (@mrocklin), Matthew Jones (@mt-jones), Michaël Benesty (@pommedeterresautee), PSEUDOTENSOR / Jonathan McKinney (@pseudotensor), Rong Ou (@rongou), Vladimir (@sh1ng), Scott Lundberg (@slundberg), Xu Xiao (@sperlingxx), @sriramch, Pasha Stetsenko (@st-pasha), Stephanie Yang (@stpyang), Yuan Tang (@terrytangyuan), Mathew Wicks (@thesuperzapper), Theodore Vasiloudis (@thvasilo), TinkleG (@tinkle1129), Oleksandr Pryimak (@trams), Jiaming Yuan (@trivialfis), Bobby Wang (@wbo4958), yage (@yage99), @yellowdolphin, Yin Lou (@yinlou)
-
 ## v0.90 (2019.05.18)

 ### XGBoost Python package drops Python 2.x (#4379, #4381)
--- a/R-package/CMakeLists.txt
+++ b/R-package/CMakeLists.txt
@@ -29,10 +29,6 @@ set_target_properties(
  CXX_STANDARD_REQUIRED ON
  POSITION_INDEPENDENT_CODE ON)

-set(XGBOOST_DEFINITIONS "${XGBOOST_DEFINITIONS};${R_DEFINITIONS}" PARENT_SCOPE)
+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)
-
-if (USE_OPENMP)
-  target_link_libraries(xgboost-r PRIVATE OpenMP::OpenMP_CXX)
-endif ()
--- a/R-package/DESCRIPTION
+++ b/R-package/DESCRIPTION
@@ -1,8 +1,8 @@
 Package: xgboost
 Type: Package
 Title: Extreme Gradient Boosting
-Version: 1.1.0.1
-Date: 2020-02-21
+Version: 0.90.0.1
+Date: 2019-05-18
 Authors@R: c(
  person("Tianqi", "Chen", role = c("aut"),
         email = "tianqi.tchen@gmail.com"),
@@ -63,5 +63,5 @@ Imports:
    data.table (>= 1.9.6),
    magrittr (>= 1.5),
    stringi (>= 0.5.2)
-RoxygenNote: 7.1.0
+RoxygenNote: 6.1.0
 SystemRequirements: GNU make, C++11
--- a/R-package/NAMESPACE
+++ b/R-package/NAMESPACE
@@ -14,7 +14,6 @@ S3method(setinfo,xgb.DMatrix)
 S3method(slice,xgb.DMatrix)
 export("xgb.attr<-")
 export("xgb.attributes<-")
-export("xgb.config<-")
 export("xgb.parameters<-")
 export(cb.cv.predict)
 export(cb.early.stop)
@@ -31,7 +30,6 @@ export(xgb.DMatrix)
 export(xgb.DMatrix.save)
 export(xgb.attr)
 export(xgb.attributes)
-export(xgb.config)
 export(xgb.create.features)
 export(xgb.cv)
 export(xgb.dump)
@@ -40,7 +38,6 @@ export(xgb.ggplot.deepness)
 export(xgb.ggplot.importance)
 export(xgb.importance)
 export(xgb.load)
-export(xgb.load.raw)
 export(xgb.model.dt.tree)
 export(xgb.plot.deepness)
 export(xgb.plot.importance)
@@ -49,9 +46,7 @@ export(xgb.plot.shap)
 export(xgb.plot.tree)
 export(xgb.save)
 export(xgb.save.raw)
-export(xgb.serialize)
 export(xgb.train)
-export(xgb.unserialize)
 export(xgboost)
 import(methods)
 importClassesFrom(Matrix,dgCMatrix)
--- a/R-package/R/utils.R
+++ b/R-package/R/utils.R
@@ -28,7 +28,7 @@ NVL <- function(x, val) {
 # Merges booster params with whatever is provided in ...
 # plus runs some checks
 check.booster.params <- function(params, ...) {
-  if (!identical(class(params), "list"))
+  if (typeof(params) != "list")
    stop("params must be a list")

  # in R interface, allow for '.' instead of '_' in parameter names
@@ -78,7 +78,7 @@ check.booster.params <- function(params, ...) {
  if (!is.null(params[['interaction_constraints']]) &&
      typeof(params[['interaction_constraints']]) != "character"){
    # check input class
-    if (!identical(class(params[['interaction_constraints']]),'list')) stop('interaction_constraints should be class list')
+    if (class(params[['interaction_constraints']]) != 'list') stop('interaction_constraints should be class list')
    if (!all(unique(sapply(params[['interaction_constraints']], class)) %in% c('numeric','integer'))) {
      stop('interaction_constraints should be a list of numeric/integer vectors')
    }
@@ -145,7 +145,7 @@ xgb.iter.update <- function(booster_handle, dtrain, iter, obj = NULL) {
  if (is.null(obj)) {
    .Call(XGBoosterUpdateOneIter_R, booster_handle, as.integer(iter), dtrain)
  } else {
-    pred <- predict(booster_handle, dtrain, outputmargin = TRUE, training = TRUE)
+    pred <- predict(booster_handle, dtrain)
    gpair <- obj(pred, dtrain)
    .Call(XGBoosterBoostOneIter_R, booster_handle, dtrain, gpair$grad, gpair$hess)
  }
--- a/R-package/R/xgb.Booster.R
+++ b/R-package/R/xgb.Booster.R
@@ -5,34 +5,20 @@ xgb.Booster.handle <- function(params = list(), cachelist = list(), modelfile =
      !all(vapply(cachelist, inherits, logical(1), what = 'xgb.DMatrix'))) {
    stop("cachelist must be a list of xgb.DMatrix objects")
  }
-  ## Load existing model, dispatch for on disk model file and in memory buffer
+
+  handle <- .Call(XGBoosterCreate_R, cachelist)
  if (!is.null(modelfile)) {
    if (typeof(modelfile) == "character") {
-      ## A filename
-      handle <- .Call(XGBoosterCreate_R, cachelist)
      .Call(XGBoosterLoadModel_R, handle, modelfile[1])
-      class(handle) <- "xgb.Booster.handle"
-      if (length(params) > 0) {
-        xgb.parameters(handle) <- params
-      }
-      return(handle)
    } else if (typeof(modelfile) == "raw") {
-      ## A memory buffer
-      bst <- xgb.unserialize(modelfile)
-      xgb.parameters(bst) <- params
-      return (bst)
+      .Call(XGBoosterLoadModelFromRaw_R, handle, modelfile)
    } else if (inherits(modelfile, "xgb.Booster")) {
-      ## A booster object
      bst <- xgb.Booster.complete(modelfile, saveraw = TRUE)
-      bst <- xgb.unserialize(bst$raw)
-      xgb.parameters(bst) <- params
-      return (bst)
+      .Call(XGBoosterLoadModelFromRaw_R, handle, bst$raw)
    } else {
      stop("modelfile must be either character filename, or raw booster dump, or xgb.Booster object")
    }
  }
-  ## Create new model
-  handle <- .Call(XGBoosterCreate_R, cachelist)
  class(handle) <- "xgb.Booster.handle"
  if (length(params) > 0) {
    xgb.parameters(handle) <- params
@@ -65,13 +51,11 @@ is.null.handle <- function(handle) {
 # Return a verified to be valid handle out of either xgb.Booster.handle or xgb.Booster
 # internal utility function
 xgb.get.handle <- function(object) {
-  if (inherits(object, "xgb.Booster")) {
-    handle <- object$handle
-  } else if (inherits(object, "xgb.Booster.handle")) {
-    handle <- object
-  } else {
+  handle <- switch(class(object)[1],
+    xgb.Booster = object$handle,
+    xgb.Booster.handle = object,
    stop("argument must be of either xgb.Booster or xgb.Booster.handle class")
-  }
+  )
  if (is.null.handle(handle)) {
    stop("invalid xgb.Booster.handle")
  }
@@ -127,29 +111,9 @@ xgb.Booster.complete <- function(object, saveraw = TRUE) {
  if (is.null.handle(object$handle)) {
    object$handle <- xgb.Booster.handle(modelfile = object$raw)
  } else {
-    if (is.null(object$raw) && saveraw) {
-      object$raw <- xgb.serialize(object$handle)
-    }
+    if (is.null(object$raw) && saveraw)
+      object$raw <- xgb.save.raw(object$handle)
  }
-
-  attrs <- xgb.attributes(object)
-  if (!is.null(attrs$best_ntreelimit)) {
-    object$best_ntreelimit <- as.integer(attrs$best_ntreelimit)
-  }
-  if (!is.null(attrs$best_iteration)) {
-    ## Convert from 0 based back to 1 based.
-    object$best_iteration <- as.integer(attrs$best_iteration) + 1
-  }
-  if (!is.null(attrs$best_score)) {
-    object$best_score <- as.numeric(attrs$best_score)
-  }
-  if (!is.null(attrs$best_msg)) {
-    object$best_msg <- attrs$best_msg
-  }
-  if (!is.null(attrs$niter)) {
-    object$niter <- as.integer(attrs$niter)
-  }
-
  return(object)
 }

@@ -173,8 +137,6 @@ xgb.Booster.complete <- function(object, saveraw = TRUE) {
 #' @param reshape whether to reshape the vector of predictions to a matrix form when there are several
 #'        prediction outputs per case. This option has no effect when either of predleaf, predcontrib,
 #'        or predinteraction flags is TRUE.
-#' @param training whether is the prediction result used for training.  For dart booster,
-#'        training predicting will perform dropout.
 #' @param ... Parameters passed to \code{predict.xgb.Booster}
 #'
 #' @details
@@ -324,7 +286,7 @@ xgb.Booster.complete <- function(object, saveraw = TRUE) {
 #' @export
 predict.xgb.Booster <- function(object, newdata, missing = NA, outputmargin = FALSE, ntreelimit = NULL,
                                predleaf = FALSE, predcontrib = FALSE, approxcontrib = FALSE, predinteraction = FALSE,
-                                reshape = FALSE, training = FALSE, ...) {
+                                reshape = FALSE, ...) {

  object <- xgb.Booster.complete(object, saveraw = FALSE)
  if (!inherits(newdata, "xgb.DMatrix"))
@@ -343,8 +305,7 @@ predict.xgb.Booster <- function(object, newdata, missing = NA, outputmargin = FA
  option <- 0L + 1L * as.logical(outputmargin) + 2L * as.logical(predleaf) + 4L * as.logical(predcontrib) +
    8L * as.logical(approxcontrib) + 16L * as.logical(predinteraction)

-  ret <- .Call(XGBoosterPredict_R, object$handle, newdata, option[1],
-               as.integer(ntreelimit), as.integer(training))
+  ret <- .Call(XGBoosterPredict_R, object$handle, newdata, option[1], as.integer(ntreelimit))

  n_ret <- length(ret)
  n_row <- nrow(newdata)
@@ -433,7 +394,7 @@ predict.xgb.Booster.handle <- function(object, ...) {
 #' That would only matter if attributes need to be set many times.
 #' Note, however, that when feeding a handle of an \code{xgb.Booster} object to the attribute setters,
 #' the raw model cache of an \code{xgb.Booster} object would not be automatically updated,
-#' and it would be user's responsibility to call \code{xgb.serialize} to update it.
+#' and it would be user's responsibility to call \code{xgb.save.raw} to update it.
 #'
 #' The \code{xgb.attributes<-} setter either updates the existing or adds one or several attributes,
 #' but it doesn't delete the other existing attributes.
@@ -492,7 +453,7 @@ xgb.attr <- function(object, name) {
  }
  .Call(XGBoosterSetAttr_R, handle, as.character(name[1]), value)
  if (is(object, 'xgb.Booster') && !is.null(object$raw)) {
-    object$raw <- xgb.serialize(object$handle)
+    object$raw <- xgb.save.raw(object$handle)
  }
  object
 }
@@ -532,41 +493,11 @@ xgb.attributes <- function(object) {
    .Call(XGBoosterSetAttr_R, handle, names(a[i]), a[[i]])
  }
  if (is(object, 'xgb.Booster') && !is.null(object$raw)) {
-    object$raw <- xgb.serialize(object$handle)
+    object$raw <- xgb.save.raw(object$handle)
  }
  object
 }

-#' Accessors for model parameters as JSON string.
-#'
-#' @param object Object of class \code{xgb.Booster}
-#' @param value A JSON string.
-#'
-#' @examples
-#' data(agaricus.train, package='xgboost')
-#' train <- agaricus.train
-#'
-#' bst <- xgboost(data = train$data, label = train$label, max_depth = 2,
-#'                eta = 1, nthread = 2, nrounds = 2, objective = "binary:logistic")
-#' config <- xgb.config(bst)
-#'
-#' @rdname xgb.config
-#' @export
-xgb.config <- function(object) {
-  handle <- xgb.get.handle(object)
-  .Call(XGBoosterSaveJsonConfig_R, handle);
-}
-
-#' @rdname xgb.config
-#' @export
-`xgb.config<-` <- function(object, value) {
-  handle <- xgb.get.handle(object)
-  .Call(XGBoosterLoadJsonConfig_R, handle, value)
-  object$raw <- NULL  # force renew the raw buffer
-  object <- xgb.Booster.complete(object)
-  object
-}
-
 #' Accessors for model parameters.
 #'
 #' Only the setter for xgboost parameters is currently implemented.
@@ -603,7 +534,7 @@ xgb.config <- function(object) {
    .Call(XGBoosterSetParam_R, handle, names(p[i]), p[[i]])
  }
  if (is(object, 'xgb.Booster') && !is.null(object$raw)) {
-    object$raw <- xgb.serialize(object$handle)
+    object$raw <- xgb.save.raw(object$handle)
  }
  object
 }
--- a/R-package/R/xgb.DMatrix.R
+++ b/R-package/R/xgb.DMatrix.R
@@ -188,10 +188,9 @@ getinfo <- function(object, ...) UseMethod("getinfo")
 getinfo.xgb.DMatrix <- function(object, name, ...) {
  if (typeof(name) != "character" ||
      length(name) != 1 ||
-      !name %in% c('label', 'weight', 'base_margin', 'nrow',
-                   'label_lower_bound', 'label_upper_bound')) {
+      !name %in% c('label', 'weight', 'base_margin', 'nrow')) {
    stop("getinfo: name must be one of the following\n",
-         "    'label', 'weight', 'base_margin', 'nrow', 'label_lower_bound', 'label_upper_bound'")
+         "    'label', 'weight', 'base_margin', 'nrow'")
  }
  if (name != "nrow"){
    ret <- .Call(XGDMatrixGetInfo_R, object, name)
@@ -244,18 +243,6 @@ setinfo.xgb.DMatrix <- function(object, name, info, ...) {
    .Call(XGDMatrixSetInfo_R, object, name, as.numeric(info))
    return(TRUE)
  }
-  if (name == "label_lower_bound") {
-    if (length(info) != nrow(object))
-      stop("The length of lower-bound labels must equal to the number of rows in the input data")
-    .Call(XGDMatrixSetInfo_R, object, name, as.numeric(info))
-    return(TRUE)
-  }
-  if (name == "label_upper_bound") {
-    if (length(info) != nrow(object))
-      stop("The length of upper-bound labels must equal to the number of rows in the input data")
-    .Call(XGDMatrixSetInfo_R, object, name, as.numeric(info))
-    return(TRUE)
-  }
  if (name == "weight") {
    if (length(info) != nrow(object))
      stop("The length of weights must equal to the number of rows in the input data")
--- a/R-package/R/xgb.cv.R
+++ b/R-package/R/xgb.cv.R
@@ -47,8 +47,6 @@
 #' @param folds \code{list} provides a possibility to use a list of pre-defined CV folds
 #'        (each element must be a vector of test fold's indices). When folds are supplied,
 #'        the \code{nfold} and \code{stratified} parameters are ignored.
-#' @param train_folds \code{list} list specifying which indicies to use for training. If \code{NULL}
-#'        (the default) all indices not specified in \code{folds} will be used for training.
 #' @param verbose \code{boolean}, print the statistics during the process
 #' @param print_every_n Print each n-th iteration evaluation messages when \code{verbose>0}.
 #'        Default is 1 which means all messages are printed. This parameter is passed to the
@@ -101,7 +99,7 @@
 #'         (only available with early stopping).
 #'   \item \code{pred} CV prediction values available when \code{prediction} is set.
 #'         It is either vector or matrix (see \code{\link{cb.cv.predict}}).
-#'   \item \code{models} a list of the CV folds' models. It is only available with the explicit
+#'   \item \code{models} a liost of the CV folds' models. It is only available with the explicit
 #'         setting of the \code{cb.cv.predict(save_models = TRUE)} callback.
 #' }
 #'
@@ -116,7 +114,7 @@
 #' @export
 xgb.cv <- function(params=list(), data, nrounds, nfold, label = NULL, missing = NA,
                   prediction = FALSE, showsd = TRUE, metrics=list(),
-                   obj = NULL, feval = NULL, stratified = TRUE, folds = NULL, train_folds = NULL,
+                   obj = NULL, feval = NULL, stratified = TRUE, folds = NULL,
                   verbose = TRUE, print_every_n=1L,
                   early_stopping_rounds = NULL, maximize = NULL, callbacks = list(), ...) {

@@ -135,15 +133,8 @@ xgb.cv <- function(params=list(), data, nrounds, nfold, label = NULL, missing =

  # Check the labels
  if ( (inherits(data, 'xgb.DMatrix') && is.null(getinfo(data, 'label'))) ||
-       (!inherits(data, 'xgb.DMatrix') && is.null(label))) {
+       (!inherits(data, 'xgb.DMatrix') && is.null(label)))
    stop("Labels must be provided for CV either through xgb.DMatrix, or through 'label=' when 'data' is matrix")
-  } else if (inherits(data, 'xgb.DMatrix')) {
-    if (!is.null(label))
-      warning("xgb.cv: label will be ignored, since data is of type xgb.DMatrix")
-    cv_label = getinfo(data, 'label')
-  } else {
-    cv_label = label
-  }

  # CV folds
  if(!is.null(folds)) {
@@ -153,7 +144,7 @@ xgb.cv <- function(params=list(), data, nrounds, nfold, label = NULL, missing =
  } else {
    if (nfold <= 1)
      stop("'nfold' must be > 1")
-    folds <- generate.cv.folds(nfold, nrow(data), stratified, cv_label, params)
+    folds <- generate.cv.folds(nfold, nrow(data), stratified, label, params)
  }

  # Potential TODO: sequential CV
@@ -188,15 +179,10 @@ xgb.cv <- function(params=list(), data, nrounds, nfold, label = NULL, missing =


  # create the booster-folds
-  # train_folds
  dall <- xgb.get.DMatrix(data, label, missing)
  bst_folds <- lapply(seq_along(folds), function(k) {
    dtest  <- slice(dall, folds[[k]])
-    # code originally contributed by @RolandASc on stackoverflow
-    if(is.null(train_folds))
-       dtrain <- slice(dall, unlist(folds[-k]))
-    else
-       dtrain <- slice(dall, train_folds[[k]])
+    dtrain <- slice(dall, unlist(folds[-k]))
    handle <- xgb.Booster.handle(params, list(dtrain, dtest))
    list(dtrain = dtrain, bst = handle, watchlist = list(train = dtrain, test=dtest), index = folds[[k]])
  })
--- a/R-package/R/xgb.load.R
+++ b/R-package/R/xgb.load.R
@@ -1,30 +1,30 @@
 #' Load xgboost model from binary file
-#'
-#' Load xgboost model from the binary model file.
-#'
+#' 
+#' Load xgboost model from the binary model file. 
+#' 
 #' @param modelfile the name of the binary input file.
-#'
-#' @details
+#' 
+#' @details 
 #' The input file is expected to contain a model saved in an xgboost-internal binary format
-#' using either \code{\link{xgb.save}} or \code{\link{cb.save.model}} in R, or using some
-#' appropriate methods from other xgboost interfaces. E.g., a model trained in Python and
+#' using either \code{\link{xgb.save}} or \code{\link{cb.save.model}} in R, or using some 
+#' appropriate methods from other xgboost interfaces. E.g., a model trained in Python and 
 #' saved from there in xgboost format, could be loaded from R.
-#'
+#' 
 #' Note: a model saved as an R-object, has to be loaded using corresponding R-methods,
 #' not \code{xgb.load}.
-#'
-#' @return
+#' 
+#' @return 
 #' An object of \code{xgb.Booster} class.
-#'
-#' @seealso
-#' \code{\link{xgb.save}}, \code{\link{xgb.Booster.complete}}.
-#'
+#' 
+#' @seealso 
+#' \code{\link{xgb.save}}, \code{\link{xgb.Booster.complete}}. 
+#' 
 #' @examples
 #' data(agaricus.train, package='xgboost')
 #' data(agaricus.test, package='xgboost')
 #' train <- agaricus.train
 #' test <- agaricus.test
-#' bst <- xgboost(data = train$data, label = train$label, max_depth = 2,
+#' 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')
--- a/R-package/R/xgb.load.raw.R
+++ b/R-package/R/xgb.load.raw.R
@@ -1,14 +0,0 @@
-#' Load serialised xgboost model from R's raw vector
-#'
-#' User can generate raw memory buffer by calling xgb.save.raw
-#'
-#' @param buffer the buffer returned by xgb.save.raw
-#'
-#' @export
-xgb.load.raw <- function(buffer) {
-  cachelist <- list()
-  handle <- .Call(XGBoosterCreate_R, cachelist)
-  .Call(XGBoosterLoadModelFromRaw_R, handle, buffer)
-  class(handle) <- "xgb.Booster.handle"
-  return (handle)
-}
--- a/R-package/R/xgb.save.raw.R
+++ b/R-package/R/xgb.save.raw.R
@@ -1,23 +1,23 @@
 #' Save xgboost model to R's raw vector,
-#' user can call xgb.load.raw to load the model back from raw vector
-#'
+#' user can call xgb.load to load the model back from raw vector
+#' 
 #' Save xgboost model from xgboost or xgb.train
-#'
+#' 
 #' @param model the model object.
-#'
+#' 
 #' @examples
 #' data(agaricus.train, package='xgboost')
 #' data(agaricus.test, package='xgboost')
 #' train <- agaricus.train
 #' test <- agaricus.test
-#' bst <- xgboost(data = train$data, label = train$label, max_depth = 2,
+#' bst <- xgboost(data = train$data, label = train$label, max_depth = 2, 
 #'                eta = 1, nthread = 2, nrounds = 2,objective = "binary:logistic")
 #' raw <- xgb.save.raw(bst)
-#' bst <- xgb.load.raw(raw)
+#' bst <- xgb.load(raw)
 #' pred <- predict(bst, test$data)
 #'
 #' @export
 xgb.save.raw <- function(model) {
-  handle <- xgb.get.handle(model)
-  .Call(XGBoosterModelToRaw_R, handle)
+  model <- xgb.get.handle(model)
+  .Call(XGBoosterModelToRaw_R, model)
 }
--- a/R-package/R/xgb.serialize.R
+++ b/R-package/R/xgb.serialize.R
@@ -1,21 +0,0 @@
-#' Serialize the booster instance into R's raw vector.  The serialization method differs
-#' from \code{\link{xgb.save.raw}} as the latter one saves only the model but not
-#' parameters.  This serialization format is not stable across different xgboost versions.
-#'
-#' @param booster the booster instance
-#'
-#' @examples
-#' data(agaricus.train, package='xgboost')
-#' data(agaricus.test, package='xgboost')
-#' train <- agaricus.train
-#' test <- agaricus.test
-#' bst <- xgboost(data = train$data, label = train$label, max_depth = 2,
-#'                eta = 1, nthread = 2, nrounds = 2,objective = "binary:logistic")
-#' raw <- xgb.serialize(bst)
-#' bst <- xgb.unserialize(raw)
-#'
-#' @export
-xgb.serialize <- function(booster) {
-  handle <- xgb.get.handle(booster)
-  .Call(XGBoosterSerializeToBuffer_R, handle)
-}
--- a/R-package/R/xgb.train.R
+++ b/R-package/R/xgb.train.R
@@ -267,7 +267,7 @@ xgb.train <- function(params = list(), data, nrounds, watchlist = list(),
  }

  # evaluation printing callback
-  params <- c(params)
+  params <- c(params, list(silent = ifelse(verbose > 1, 0, 1)))
  print_every_n <- max( as.integer(print_every_n), 1L)
  if (!has.callbacks(callbacks, 'cb.print.evaluation') &&
      verbose) {
@@ -291,13 +291,8 @@ xgb.train <- function(params = list(), data, nrounds, watchlist = list(),
    callbacks <- add.cb(callbacks, cb.early.stop(early_stopping_rounds,
                                                 maximize = maximize, verbose = verbose))
  }
-
  # Sort the callbacks into categories
  cb <- categorize.callbacks(callbacks)
-  params['validate_parameters'] <- TRUE
-  if (!is.null(params[['seed']])) {
-    warning("xgb.train: `seed` is ignored in R package.  Use `set.seed()` instead.")
-  }

  # The tree updating process would need slightly different handling
  is_update <- NVL(params[['process_type']], '.') == 'update'
--- a/R-package/R/xgb.unserialize.R
+++ b/R-package/R/xgb.unserialize.R
@@ -1,12 +0,0 @@
-#' Load the instance back from \code{\link{xgb.serialize}}
-#'
-#' @param buffer the buffer containing booster instance saved by \code{\link{xgb.serialize}}
-#'
-#' @export
-xgb.unserialize <- function(buffer) {
-  cachelist <- list()
-  handle <- .Call(XGBoosterCreate_R, cachelist)
-  .Call(XGBoosterUnserializeFromBuffer_R, handle, buffer)
-  class(handle) <- "xgb.Booster.handle"
-  return (handle)
-}
--- a/R-package/R/xgboost.R
+++ b/R-package/R/xgboost.R
@@ -5,8 +5,8 @@
 #' @export
 xgboost <- function(data = NULL, label = NULL, missing = NA, weight = NULL,
                    params = list(), nrounds,
-                    verbose = 1, print_every_n = 1L,
-                    early_stopping_rounds = NULL, maximize = 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(), ...) {

@@ -18,16 +18,16 @@ xgboost <- function(data = NULL, label = NULL, missing = NA, weight = NULL,
                   early_stopping_rounds = early_stopping_rounds, maximize = maximize,
                   save_period = save_period, save_name = save_name,
                   xgb_model = xgb_model, callbacks = callbacks, ...)
-  return (bst)
+  return(bst)
 }

 #' Training part from Mushroom Data Set
-#'
+#' 
 #' This data set is originally from the Mushroom data set,
 #' UCI Machine Learning Repository.
-#'
+#' 
 #' This data set includes the following fields:
-#'
+#' 
 #' \itemize{
 #'  \item \code{label} the label for each record
 #'  \item \code{data} a sparse Matrix of \code{dgCMatrix} class, with 126 columns.
@@ -35,16 +35,16 @@ xgboost <- function(data = NULL, label = NULL, missing = NA, weight = NULL,
 #'
 #' @references
 #' https://archive.ics.uci.edu/ml/datasets/Mushroom
-#'
-#' Bache, K. & Lichman, M. (2013). UCI Machine Learning Repository
-#' [http://archive.ics.uci.edu/ml]. Irvine, CA: University of California,
+#' 
+#' Bache, K. & Lichman, M. (2013). UCI Machine Learning Repository 
+#' [http://archive.ics.uci.edu/ml]. Irvine, CA: University of California, 
 #' School of Information and Computer Science.
-#'
+#' 
 #' @docType data
 #' @keywords datasets
 #' @name agaricus.train
 #' @usage data(agaricus.train)
-#' @format A list containing a label vector, and a dgCMatrix object with 6513
+#' @format A list containing a label vector, and a dgCMatrix object with 6513 
 #' rows and 127 variables
 NULL

@@ -52,9 +52,9 @@ NULL
 #'
 #' This data set is originally from the Mushroom data set,
 #' UCI Machine Learning Repository.
-#'
+#' 
 #' This data set includes the following fields:
-#'
+#' 
 #' \itemize{
 #'  \item \code{label} the label for each record
 #'  \item \code{data} a sparse Matrix of \code{dgCMatrix} class, with 126 columns.
@@ -62,16 +62,16 @@ NULL
 #'
 #' @references
 #' https://archive.ics.uci.edu/ml/datasets/Mushroom
-#'
-#' Bache, K. & Lichman, M. (2013). UCI Machine Learning Repository
-#' [http://archive.ics.uci.edu/ml]. Irvine, CA: University of California,
+#' 
+#' Bache, K. & Lichman, M. (2013). UCI Machine Learning Repository 
+#' [http://archive.ics.uci.edu/ml]. Irvine, CA: University of California, 
 #' School of Information and Computer Science.
-#'
+#' 
 #' @docType data
 #' @keywords datasets
 #' @name agaricus.test
 #' @usage data(agaricus.test)
-#' @format A list containing a label vector, and a dgCMatrix object with 1611
+#' @format A list containing a label vector, and a dgCMatrix object with 1611 
 #' rows and 126 variables
 NULL

@@ -107,7 +107,7 @@ NULL
 #' @importFrom graphics par
 #' @importFrom graphics title
 #' @importFrom grDevices rgb
-#'
+#' 
 #' @import methods
 #' @useDynLib xgboost, .registration = TRUE
 NULL
--- a/R-package/configure
+++ b/R-package/configure
--- a/R-package/configure.ac
+++ b/R-package/configure.ac
@@ -4,21 +4,6 @@ AC_PREREQ(2.62)

 AC_INIT([xgboost],[0.6-3],[],[xgboost],[])

-# Use this line to set CC variable to a C compiler
-AC_PROG_CC
-
-### Check whether backtrace() is part of libc or the external lib libexecinfo
-AC_MSG_CHECKING([Backtrace lib])
-AC_MSG_RESULT([])
-AC_CHECK_LIB([execinfo], [backtrace], [BACKTRACE_LIB=-lexecinfo], [BACKTRACE_LIB=''])
-
-### Endian detection
-AC_MSG_CHECKING([endian])
-AC_MSG_RESULT([])
-AC_RUN_IFELSE([AC_LANG_PROGRAM([[#include <stdint.h>]], [[const uint16_t endianness = 256; return !!(*(const uint8_t *)&endianness);]])],
-  [ENDIAN_FLAG="-DDMLC_CMAKE_LITTLE_ENDIAN=1"],
-  [ENDIAN_FLAG="-DDMLC_CMAKE_LITTLE_ENDIAN=0"])
-
 OPENMP_CXXFLAGS=""

 if test `uname -s` = "Linux"
@@ -28,28 +13,19 @@ fi

 if test `uname -s` = "Darwin"
 then
-  OPENMP_CXXFLAGS='-Xclang -fopenmp'
-  OPENMP_LIB='/usr/local/lib/libomp.dylib'
+  OPENMP_CXXFLAGS="\$(SHLIB_OPENMP_CXXFLAGS)"
  ac_pkg_openmp=no
  AC_MSG_CHECKING([whether OpenMP will work in a package])
-  AC_LANG_CONFTEST([AC_LANG_PROGRAM([[#include <omp.h>]], [[ return (omp_get_max_threads() <= 1); ]])])
-  ${CC} -o conftest conftest.c /usr/local/lib/libomp.dylib -Xclang -fopenmp 2>/dev/null && ./conftest && ac_pkg_openmp=yes
+  AC_LANG_CONFTEST(
+  [AC_LANG_PROGRAM([[#include <omp.h>]], [[ return omp_get_num_threads (); ]])])
+  PKG_CFLAGS="${OPENMP_CFLAGS}" PKG_LIBS="${OPENMP_CFLAGS}" "$RBIN" CMD SHLIB conftest.c 1>&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD && "$RBIN" --vanilla -q -e "dyn.load(paste('conftest',.Platform\$dynlib.ext,sep=''))" 1>&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD && ac_pkg_openmp=yes
  AC_MSG_RESULT([${ac_pkg_openmp}])
  if test "${ac_pkg_openmp}" = no; then
    OPENMP_CXXFLAGS=''
-    OPENMP_LIB=''
-    echo '*****************************************************************************************'
-    echo 'WARNING: OpenMP is unavailable on this Mac OSX system. Training speed may be suboptimal.'
-    echo '         To use all CPU cores for training jobs, you should install OpenMP by running\n'
-    echo '             brew install libomp'
-    echo '*****************************************************************************************'
  fi
 fi

 AC_SUBST(OPENMP_CXXFLAGS)
-AC_SUBST(OPENMP_LIB)
-AC_SUBST(ENDIAN_FLAG)
-AC_SUBST(BACKTRACE_LIB)
 AC_CONFIG_FILES([src/Makevars])
 AC_OUTPUT

--- a/R-package/demo/gpu_accelerated.R
+++ b/R-package/demo/gpu_accelerated.R
@@ -30,7 +30,7 @@ wl <- list(train = dtrain, test = dtest)
 # - similar to the 'hist'
 # - the fastest option for moderately large datasets
 # - current limitations: max_depth < 16, does not implement guided loss
-# You can use tree_method = 'gpu_hist' for another GPU accelerated algorithm,
+# You can use tree_method = 'gpu_exact' for another GPU accelerated algorithm,
 # which is slower, more memory-hungry, but does not use binning.
 param <- list(objective = 'reg:logistic', eval_metric = 'auc', subsample = 0.5, nthread = 4,
              max_bin = 64, tree_method = 'gpu_hist')
--- a/R-package/man/agaricus.test.Rd
+++ b/R-package/man/agaricus.test.Rd
@@ -4,10 +4,8 @@
 \name{agaricus.test}
 \alias{agaricus.test}
 \title{Test part from Mushroom Data Set}
-\format{
-A list containing a label vector, and a dgCMatrix object with 1611
-rows and 126 variables
-}
+\format{A list containing a label vector, and a dgCMatrix object with 1611 
+rows and 126 variables}
 \usage{
 data(agaricus.test)
 }
@@ -26,8 +24,8 @@ This data set includes the following fields:
 \references{
 https://archive.ics.uci.edu/ml/datasets/Mushroom

-Bache, K. & Lichman, M. (2013). UCI Machine Learning Repository
-[http://archive.ics.uci.edu/ml]. Irvine, CA: University of California,
+Bache, K. & Lichman, M. (2013). UCI Machine Learning Repository 
+[http://archive.ics.uci.edu/ml]. Irvine, CA: University of California, 
 School of Information and Computer Science.
 }
 \keyword{datasets}
--- a/R-package/man/agaricus.train.Rd
+++ b/R-package/man/agaricus.train.Rd
@@ -4,10 +4,8 @@
 \name{agaricus.train}
 \alias{agaricus.train}
 \title{Training part from Mushroom Data Set}
-\format{
-A list containing a label vector, and a dgCMatrix object with 6513
-rows and 127 variables
-}
+\format{A list containing a label vector, and a dgCMatrix object with 6513 
+rows and 127 variables}
 \usage{
 data(agaricus.train)
 }
@@ -26,8 +24,8 @@ This data set includes the following fields:
 \references{
 https://archive.ics.uci.edu/ml/datasets/Mushroom

-Bache, K. & Lichman, M. (2013). UCI Machine Learning Repository
-[http://archive.ics.uci.edu/ml]. Irvine, CA: University of California,
+Bache, K. & Lichman, M. (2013). UCI Machine Learning Repository 
+[http://archive.ics.uci.edu/ml]. Irvine, CA: University of California, 
 School of Information and Computer Science.
 }
 \keyword{datasets}
--- a/R-package/man/cb.early.stop.Rd
+++ b/R-package/man/cb.early.stop.Rd
@@ -4,12 +4,8 @@
 \alias{cb.early.stop}
 \title{Callback closure to activate the early stopping.}
 \usage{
-cb.early.stop(
-  stopping_rounds,
-  maximize = FALSE,
-  metric_name = NULL,
-  verbose = TRUE
-)
+cb.early.stop(stopping_rounds, maximize = FALSE, metric_name = NULL,
+  verbose = TRUE)
 }
 \arguments{
 \item{stopping_rounds}{The number of rounds with no improvement in
--- a/R-package/man/predict.xgb.Booster.Rd
+++ b/R-package/man/predict.xgb.Booster.Rd
@@ -5,20 +5,10 @@
 \alias{predict.xgb.Booster.handle}
 \title{Predict method for eXtreme Gradient Boosting model}
 \usage{
-\method{predict}{xgb.Booster}(
-  object,
-  newdata,
-  missing = NA,
-  outputmargin = FALSE,
-  ntreelimit = NULL,
-  predleaf = FALSE,
-  predcontrib = FALSE,
-  approxcontrib = FALSE,
-  predinteraction = FALSE,
-  reshape = FALSE,
-  training = FALSE,
-  ...
-)
+\method{predict}{xgb.Booster}(object, newdata, missing = NA,
+  outputmargin = FALSE, ntreelimit = NULL, predleaf = FALSE,
+  predcontrib = FALSE, approxcontrib = FALSE, predinteraction = FALSE,
+  reshape = FALSE, ...)

 \method{predict}{xgb.Booster.handle}(object, ...)
 }
@@ -49,9 +39,6 @@ It will use all the trees by default (\code{NULL} value).}
 prediction outputs per case. This option has no effect when either of predleaf, predcontrib,
 or predinteraction flags is TRUE.}

-\item{training}{whether is the prediction result used for training.  For dart booster,
-training predicting will perform dropout.}
-
 \item{...}{Parameters passed to \code{predict.xgb.Booster}}
 }
 \value{
--- a/R-package/man/xgb.attr.Rd
+++ b/R-package/man/xgb.attr.Rd
@@ -55,7 +55,7 @@ than for \code{xgb.Booster}, since only just a handle (pointer) would need to be
 That would only matter if attributes need to be set many times.
 Note, however, that when feeding a handle of an \code{xgb.Booster} object to the attribute setters,
 the raw model cache of an \code{xgb.Booster} object would not be automatically updated,
-and it would be user's responsibility to call \code{xgb.serialize} to update it.
+and it would be user's responsibility to call \code{xgb.save.raw} to update it.

 The \code{xgb.attributes<-} setter either updates the existing or adds one or several attributes,
 but it doesn't delete the other existing attributes.
--- a/R-package/man/xgb.config.Rd
+++ b/R-package/man/xgb.config.Rd
@@ -1,28 +0,0 @@
-% Generated by roxygen2: do not edit by hand
-% Please edit documentation in R/xgb.Booster.R
-\name{xgb.config}
-\alias{xgb.config}
-\alias{xgb.config<-}
-\title{Accessors for model parameters as JSON string.}
-\usage{
-xgb.config(object)
-
-xgb.config(object) <- value
-}
-\arguments{
-\item{object}{Object of class \code{xgb.Booster}}
-
-\item{value}{A JSON string.}
-}
-\description{
-Accessors for model parameters as JSON string.
-}
-\examples{
-data(agaricus.train, package='xgboost')
-train <- agaricus.train
-
-bst <- xgboost(data = train$data, label = train$label, max_depth = 2,
-               eta = 1, nthread = 2, nrounds = 2, objective = "binary:logistic")
-config <- xgb.config(bst)
-
-}
--- a/R-package/man/xgb.create.features.Rd
+++ b/R-package/man/xgb.create.features.Rd
@@ -87,6 +87,6 @@ accuracy.after <- sum((predict(bst, new.dtest) >= 0.5) == agaricus.test$label) /

 # Here the accuracy was already good and is now perfect.
 cat(paste("The accuracy was", accuracy.before, "before adding leaf features and it is now",
-          accuracy.after, "!\n"))
+          accuracy.after, "!\\n"))

 }
--- a/R-package/man/xgb.cv.Rd
+++ b/R-package/man/xgb.cv.Rd
@@ -4,28 +4,11 @@
 \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,
-  train_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:
@@ -86,9 +69,6 @@ by the values of outcome labels.}
 (each element must be a vector of test fold's indices). When folds are supplied,
 the \code{nfold} and \code{stratified} parameters are ignored.}

-\item{train_folds}{\code{list} list specifying which indicies to use for training. If \code{NULL}
-(the default) all indices not specified in \code{folds} will be used for training.}
-
 \item{verbose}{\code{boolean}, print the statistics during the process}

 \item{print_every_n}{Print each n-th iteration evaluation messages when \code{verbose>0}.
@@ -135,7 +115,7 @@ An object of class \code{xgb.cv.synchronous} with the following elements:
        (only available with early stopping).
  \item \code{pred} CV prediction values available when \code{prediction} is set.
        It is either vector or matrix (see \code{\link{cb.cv.predict}}).
-  \item \code{models} a list of the CV folds' models. It is only available with the explicit
+  \item \code{models} a liost of the CV folds' models. It is only available with the explicit
        setting of the \code{cb.cv.predict(save_models = TRUE)} callback.
 }
 }
--- a/R-package/man/xgb.dump.Rd
+++ b/R-package/man/xgb.dump.Rd
@@ -4,14 +4,8 @@
 \alias{xgb.dump}
 \title{Dump an xgboost model in text format.}
 \usage{
-xgb.dump(
-  model,
-  fname = NULL,
-  fmap = "",
-  with_stats = FALSE,
-  dump_format = c("text", "json"),
-  ...
-)
+xgb.dump(model, fname = NULL, fmap = "", with_stats = FALSE,
+  dump_format = c("text", "json"), ...)
 }
 \arguments{
 \item{model}{the model object.}
--- a/R-package/man/xgb.importance.Rd
+++ b/R-package/man/xgb.importance.Rd
@@ -4,14 +4,8 @@
 \alias{xgb.importance}
 \title{Importance of features in a model.}
 \usage{
-xgb.importance(
-  feature_names = NULL,
-  model = NULL,
-  trees = NULL,
-  data = NULL,
-  label = NULL,
-  target = NULL
-)
+xgb.importance(feature_names = NULL, model = NULL, trees = NULL,
+  data = NULL, label = NULL, target = NULL)
 }
 \arguments{
 \item{feature_names}{character vector of feature names. If the model already
--- a/R-package/man/xgb.load.raw.Rd
+++ b/R-package/man/xgb.load.raw.Rd
@@ -1,14 +0,0 @@
-% Generated by roxygen2: do not edit by hand
-% Please edit documentation in R/xgb.load.raw.R
-\name{xgb.load.raw}
-\alias{xgb.load.raw}
-\title{Load serialised xgboost model from R's raw vector}
-\usage{
-xgb.load.raw(buffer)
-}
-\arguments{
-\item{buffer}{the buffer returned by xgb.save.raw}
-}
-\description{
-User can generate raw memory buffer by calling xgb.save.raw
-}
--- a/R-package/man/xgb.model.dt.tree.Rd
+++ b/R-package/man/xgb.model.dt.tree.Rd
@@ -4,14 +4,8 @@
 \alias{xgb.model.dt.tree}
 \title{Parse a boosted tree model text dump}
 \usage{
-xgb.model.dt.tree(
-  feature_names = NULL,
-  model = NULL,
-  text = NULL,
-  trees = NULL,
-  use_int_id = FALSE,
-  ...
-)
+xgb.model.dt.tree(feature_names = NULL, model = NULL, text = NULL,
+  trees = NULL, use_int_id = FALSE, ...)
 }
 \arguments{
 \item{feature_names}{character vector of feature names. If the model already
--- a/R-package/man/xgb.plot.deepness.Rd
+++ b/R-package/man/xgb.plot.deepness.Rd
@@ -5,17 +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
--- a/R-package/man/xgb.plot.importance.Rd
+++ b/R-package/man/xgb.plot.importance.Rd
@@ -5,25 +5,12 @@
 \alias{xgb.plot.importance}
 \title{Plot feature importance as a bar graph}
 \usage{
-xgb.ggplot.importance(
-  importance_matrix = NULL,
-  top_n = NULL,
-  measure = NULL,
-  rel_to_first = FALSE,
-  n_clusters = c(1:10),
-  ...
-)
+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,
-  ...
-)
+xgb.plot.importance(importance_matrix = NULL, top_n = NULL,
+  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}}.}
--- a/R-package/man/xgb.plot.multi.trees.Rd
+++ b/R-package/man/xgb.plot.multi.trees.Rd
@@ -4,15 +4,8 @@
 \alias{xgb.plot.multi.trees}
 \title{Project all trees on one tree and plot it}
 \usage{
-xgb.plot.multi.trees(
-  model,
-  feature_names = NULL,
-  features_keep = 5,
-  plot_width = NULL,
-  plot_height = NULL,
-  render = TRUE,
-  ...
-)
+xgb.plot.multi.trees(model, feature_names = NULL, features_keep = 5,
+  plot_width = NULL, plot_height = NULL, render = TRUE, ...)
 }
 \arguments{
 \item{model}{produced by the \code{xgb.train} function.}
--- a/R-package/man/xgb.plot.shap.Rd
+++ b/R-package/man/xgb.plot.shap.Rd
@@ -4,33 +4,13 @@
 \alias{xgb.plot.shap}
 \title{SHAP contribution dependency plots}
 \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,
-  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,
-  ...
-)
+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,
+  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, ...)
 }
 \arguments{
 \item{data}{data as a \code{matrix} or \code{dgCMatrix}.}
--- a/R-package/man/xgb.plot.tree.Rd
+++ b/R-package/man/xgb.plot.tree.Rd
@@ -4,16 +4,9 @@
 \alias{xgb.plot.tree}
 \title{Plot a boosted tree model}
 \usage{
-xgb.plot.tree(
-  feature_names = NULL,
-  model = NULL,
-  trees = NULL,
-  plot_width = NULL,
-  plot_height = NULL,
-  render = TRUE,
-  show_node_id = FALSE,
-  ...
-)
+xgb.plot.tree(feature_names = NULL, model = NULL, trees = NULL,
+  plot_width = NULL, plot_height = NULL, render = TRUE,
+  show_node_id = FALSE, ...)
 }
 \arguments{
 \item{feature_names}{names of each feature as a \code{character} vector.}
--- a/R-package/man/xgb.save.raw.Rd
+++ b/R-package/man/xgb.save.raw.Rd
@@ -3,7 +3,7 @@
 \name{xgb.save.raw}
 \alias{xgb.save.raw}
 \title{Save xgboost model to R's raw vector,
-user can call xgb.load.raw to load the model back from raw vector}
+user can call xgb.load to load the model back from raw vector}
 \usage{
 xgb.save.raw(model)
 }
@@ -18,10 +18,10 @@ data(agaricus.train, package='xgboost')
 data(agaricus.test, package='xgboost')
 train <- agaricus.train
 test <- agaricus.test
-bst <- xgboost(data = train$data, label = train$label, max_depth = 2,
+bst <- xgboost(data = train$data, label = train$label, max_depth = 2, 
               eta = 1, nthread = 2, nrounds = 2,objective = "binary:logistic")
 raw <- xgb.save.raw(bst)
-bst <- xgb.load.raw(raw)
+bst <- xgb.load(raw)
 pred <- predict(bst, test$data)

 }
--- a/R-package/man/xgb.serialize.Rd
+++ b/R-package/man/xgb.serialize.Rd
@@ -1,29 +0,0 @@
-% Generated by roxygen2: do not edit by hand
-% Please edit documentation in R/xgb.serialize.R
-\name{xgb.serialize}
-\alias{xgb.serialize}
-\title{Serialize the booster instance into R's raw vector.  The serialization method differs
-from \code{\link{xgb.save.raw}} as the latter one saves only the model but not
-parameters.  This serialization format is not stable across different xgboost versions.}
-\usage{
-xgb.serialize(booster)
-}
-\arguments{
-\item{booster}{the booster instance}
-}
-\description{
-Serialize the booster instance into R's raw vector.  The serialization method differs
-from \code{\link{xgb.save.raw}} as the latter one saves only the model but not
-parameters.  This serialization format is not stable across different xgboost versions.
-}
-\examples{
-data(agaricus.train, package='xgboost')
-data(agaricus.test, package='xgboost')
-train <- agaricus.train
-test <- agaricus.test
-bst <- xgboost(data = train$data, label = train$label, max_depth = 2,
-               eta = 1, nthread = 2, nrounds = 2,objective = "binary:logistic")
-raw <- xgb.serialize(bst)
-bst <- xgb.unserialize(raw)
-
-}
--- a/R-package/man/xgb.train.Rd
+++ b/R-package/man/xgb.train.Rd
@@ -5,41 +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,
-  early_stopping_rounds = NULL,
-  maximize = NULL,
-  save_period = NULL,
-  save_name = "xgboost.model",
-  xgb_model = NULL,
-  callbacks = list(),
-  ...
-)
+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(), ...)

-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(),
-  ...
-)
+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(), ...)
 }
 \arguments{
 \item{params}{the list of parameters.
--- a/R-package/man/xgb.unserialize.Rd
+++ b/R-package/man/xgb.unserialize.Rd
@@ -1,14 +0,0 @@
-% Generated by roxygen2: do not edit by hand
-% Please edit documentation in R/xgb.unserialize.R
-\name{xgb.unserialize}
-\alias{xgb.unserialize}
-\title{Load the instance back from \code{\link{xgb.serialize}}}
-\usage{
-xgb.unserialize(buffer)
-}
-\arguments{
-\item{buffer}{the buffer containing booster instance saved by \code{\link{xgb.serialize}}}
-}
-\description{
-Load the instance back from \code{\link{xgb.serialize}}
-}
--- a/R-package/src/Makevars.in
+++ b/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@ @ENDIAN_FLAG@ -pthread
-PKG_LIBS = @OPENMP_CXXFLAGS@ @OPENMP_LIB@ @ENDIAN_FLAG@ @BACKTRACE_LIB@ -pthread
+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
--- a/R-package/src/init.c
+++ b/R-package/src/init.c
@@ -23,12 +23,8 @@ extern SEXP XGBoosterGetAttrNames_R(SEXP);
 extern SEXP XGBoosterGetAttr_R(SEXP, SEXP);
 extern SEXP XGBoosterLoadModelFromRaw_R(SEXP, SEXP);
 extern SEXP XGBoosterLoadModel_R(SEXP, SEXP);
-extern SEXP XGBoosterSaveJsonConfig_R(SEXP handle);
-extern SEXP XGBoosterLoadJsonConfig_R(SEXP handle, SEXP value);
-extern SEXP XGBoosterSerializeToBuffer_R(SEXP handle);
-extern SEXP XGBoosterUnserializeFromBuffer_R(SEXP handle, SEXP raw);
 extern SEXP XGBoosterModelToRaw_R(SEXP);
-extern SEXP XGBoosterPredict_R(SEXP, SEXP, SEXP, SEXP, SEXP);
+extern SEXP XGBoosterPredict_R(SEXP, SEXP, SEXP, SEXP);
 extern SEXP XGBoosterSaveModel_R(SEXP, SEXP);
 extern SEXP XGBoosterSetAttr_R(SEXP, SEXP, SEXP);
 extern SEXP XGBoosterSetParam_R(SEXP, SEXP, SEXP);
@@ -53,12 +49,8 @@ static const R_CallMethodDef CallEntries[] = {
  {"XGBoosterGetAttr_R",          (DL_FUNC) &XGBoosterGetAttr_R,          2},
  {"XGBoosterLoadModelFromRaw_R", (DL_FUNC) &XGBoosterLoadModelFromRaw_R, 2},
  {"XGBoosterLoadModel_R",        (DL_FUNC) &XGBoosterLoadModel_R,        2},
-  {"XGBoosterSaveJsonConfig_R",   (DL_FUNC) &XGBoosterSaveJsonConfig_R,   1},
-  {"XGBoosterLoadJsonConfig_R",   (DL_FUNC) &XGBoosterLoadJsonConfig_R,   2},
-  {"XGBoosterSerializeToBuffer_R",     (DL_FUNC) &XGBoosterSerializeToBuffer_R,     1},
-  {"XGBoosterUnserializeFromBuffer_R", (DL_FUNC) &XGBoosterUnserializeFromBuffer_R, 2},
  {"XGBoosterModelToRaw_R",       (DL_FUNC) &XGBoosterModelToRaw_R,       1},
-  {"XGBoosterPredict_R",          (DL_FUNC) &XGBoosterPredict_R,          5},
+  {"XGBoosterPredict_R",          (DL_FUNC) &XGBoosterPredict_R,          4},
  {"XGBoosterSaveModel_R",        (DL_FUNC) &XGBoosterSaveModel_R,        2},
  {"XGBoosterSetAttr_R",          (DL_FUNC) &XGBoosterSetAttr_R,          3},
  {"XGBoosterSetParam_R",         (DL_FUNC) &XGBoosterSetParam_R,         3},
--- a/R-package/src/xgboost_R.cc
+++ b/R-package/src/xgboost_R.cc
@@ -136,10 +136,9 @@ SEXP XGDMatrixSliceDMatrix_R(SEXP handle, SEXP idxset) {
    idxvec[i] = INTEGER(idxset)[i] - 1;
  }
  DMatrixHandle res;
-  CHECK_CALL(XGDMatrixSliceDMatrixEx(R_ExternalPtrAddr(handle),
-                                     BeginPtr(idxvec), len,
-                                     &res,
-                                     0));
+  CHECK_CALL(XGDMatrixSliceDMatrix(R_ExternalPtrAddr(handle),
+                                   BeginPtr(idxvec), len,
+                                   &res));
  ret = PROTECT(R_MakeExternalPtr(res, R_NilValue, R_NilValue));
  R_RegisterCFinalizerEx(ret, _DMatrixFinalizer, TRUE);
  R_API_END();
@@ -166,9 +165,7 @@ SEXP XGDMatrixSetInfo_R(SEXP handle, SEXP field, SEXP array) {
    for (int i = 0; i < len; ++i) {
      vec[i] = static_cast<unsigned>(INTEGER(array)[i]);
    }
-    CHECK_CALL(XGDMatrixSetUIntInfo(R_ExternalPtrAddr(handle),
-                                    CHAR(asChar(field)),
-                                    BeginPtr(vec), len));
+    CHECK_CALL(XGDMatrixSetGroup(R_ExternalPtrAddr(handle), BeginPtr(vec), len));
  } else {
    std::vector<float> vec(len);
    #pragma omp parallel for schedule(static)
@@ -176,8 +173,8 @@ SEXP XGDMatrixSetInfo_R(SEXP handle, SEXP field, SEXP array) {
      vec[i] = REAL(array)[i];
    }
    CHECK_CALL(XGDMatrixSetFloatInfo(R_ExternalPtrAddr(handle),
-                                     CHAR(asChar(field)),
-                                     BeginPtr(vec), len));
+                                   CHAR(asChar(field)),
+                                   BeginPtr(vec), len));
  }
  R_API_END();
  return R_NilValue;
@@ -295,26 +292,24 @@ SEXP XGBoosterEvalOneIter_R(SEXP handle, SEXP iter, SEXP dmats, SEXP evnames) {
    vec_sptr.push_back(vec_names[i].c_str());
  }
  CHECK_CALL(XGBoosterEvalOneIter(R_ExternalPtrAddr(handle),
-                                  asInteger(iter),
-                                  BeginPtr(vec_dmats),
-                                  BeginPtr(vec_sptr),
-                                  len, &ret));
+                                asInteger(iter),
+                                BeginPtr(vec_dmats),
+                                BeginPtr(vec_sptr),
+                                len, &ret));
  R_API_END();
  return mkString(ret);
 }

-SEXP XGBoosterPredict_R(SEXP handle, SEXP dmat, SEXP option_mask,
-                        SEXP ntree_limit, SEXP training) {
+SEXP XGBoosterPredict_R(SEXP handle, SEXP dmat, SEXP option_mask, SEXP ntree_limit) {
  SEXP ret;
  R_API_BEGIN();
  bst_ulong olen;
  const float *res;
  CHECK_CALL(XGBoosterPredict(R_ExternalPtrAddr(handle),
-                              R_ExternalPtrAddr(dmat),
-                              asInteger(option_mask),
-                              asInteger(ntree_limit),
-                              asInteger(training),
-                              &olen, &res));
+                            R_ExternalPtrAddr(dmat),
+                            asInteger(option_mask),
+                            asInteger(ntree_limit),
+                            &olen, &res));
  ret = PROTECT(allocVector(REALSXP, olen));
  for (size_t i = 0; i < olen; ++i) {
    REAL(ret)[i] = res[i];
@@ -338,6 +333,15 @@ SEXP XGBoosterSaveModel_R(SEXP handle, SEXP fname) {
  return R_NilValue;
 }

+SEXP XGBoosterLoadModelFromRaw_R(SEXP handle, SEXP raw) {
+  R_API_BEGIN();
+  CHECK_CALL(XGBoosterLoadModelFromBuffer(R_ExternalPtrAddr(handle),
+                                          RAW(raw),
+                                          length(raw)));
+  R_API_END();
+  return R_NilValue;
+}
+
 SEXP XGBoosterModelToRaw_R(SEXP handle) {
  SEXP ret;
  R_API_BEGIN();
@@ -353,57 +357,6 @@ SEXP XGBoosterModelToRaw_R(SEXP handle) {
  return ret;
 }

-SEXP XGBoosterLoadModelFromRaw_R(SEXP handle, SEXP raw) {
-  R_API_BEGIN();
-  CHECK_CALL(XGBoosterLoadModelFromBuffer(R_ExternalPtrAddr(handle),
-                                          RAW(raw),
-                                          length(raw)));
-  R_API_END();
-  return R_NilValue;
-}
-
-SEXP XGBoosterSaveJsonConfig_R(SEXP handle) {
-  const char* ret;
-  R_API_BEGIN();
-  bst_ulong len {0};
-  CHECK_CALL(XGBoosterSaveJsonConfig(R_ExternalPtrAddr(handle),
-                                     &len,
-                                     &ret));
-  R_API_END();
-  return mkString(ret);
-}
-
-SEXP XGBoosterLoadJsonConfig_R(SEXP handle, SEXP value) {
-  R_API_BEGIN();
-  XGBoosterLoadJsonConfig(R_ExternalPtrAddr(handle), CHAR(asChar(value)));
-  R_API_END();
-  return R_NilValue;
-}
-
-SEXP XGBoosterSerializeToBuffer_R(SEXP handle) {
-  SEXP ret;
-  R_API_BEGIN();
-  bst_ulong out_len;
-  const char *raw;
-  CHECK_CALL(XGBoosterSerializeToBuffer(R_ExternalPtrAddr(handle), &out_len, &raw));
-  ret = PROTECT(allocVector(RAWSXP, out_len));
-  if (out_len != 0) {
-    memcpy(RAW(ret), raw, out_len);
-  }
-  R_API_END();
-  UNPROTECT(1);
-  return ret;
-}
-
-SEXP XGBoosterUnserializeFromBuffer_R(SEXP handle, SEXP raw) {
-  R_API_BEGIN();
-  XGBoosterUnserializeFromBuffer(R_ExternalPtrAddr(handle),
-                                 RAW(raw),
-                                 length(raw));
-  R_API_END();
-  return R_NilValue;
-}
-
 SEXP XGBoosterDumpModel_R(SEXP handle, SEXP fmap, SEXP with_stats, SEXP dump_format) {
  SEXP out;
  R_API_BEGIN();
--- a/R-package/src/xgboost_R.h
+++ b/R-package/src/xgboost_R.h
@@ -148,10 +148,8 @@ XGB_DLL SEXP XGBoosterEvalOneIter_R(SEXP handle, SEXP iter, SEXP dmats, SEXP evn
 * \param dmat data matrix
 * \param option_mask output_margin:1 predict_leaf:2
 * \param ntree_limit limit number of trees used in prediction
- * \param training Whether the prediction value is used for training.
 */
-XGB_DLL SEXP XGBoosterPredict_R(SEXP handle, SEXP dmat, SEXP option_mask,
-                                SEXP ntree_limit, SEXP training);
+XGB_DLL SEXP XGBoosterPredict_R(SEXP handle, SEXP dmat, SEXP option_mask, SEXP ntree_limit);
 /*!
 * \brief load model from existing file
 * \param handle handle
@@ -179,39 +177,9 @@ XGB_DLL SEXP XGBoosterLoadModelFromRaw_R(SEXP handle, SEXP raw);
 * \brief save model into R's raw array
 * \param handle handle
 * \return raw array
- */
+   */
 XGB_DLL SEXP XGBoosterModelToRaw_R(SEXP handle);

-/*!
- * \brief Save internal parameters as a JSON string
- * \param handle handle
- * \return JSON string
- */
-
-XGB_DLL SEXP XGBoosterSaveJsonConfig_R(SEXP handle);
-/*!
- * \brief Load the JSON string returnd by XGBoosterSaveJsonConfig_R
- * \param handle handle
- * \param value JSON string
- * \return R_NilValue
- */
-XGB_DLL SEXP XGBoosterLoadJsonConfig_R(SEXP handle, SEXP value);
-
-/*!
-  * \brief Memory snapshot based serialization method.  Saves everything states
-  *        into buffer.
-  * \param handle handle to booster
-  */
-XGB_DLL SEXP XGBoosterSerializeToBuffer_R(SEXP handle);
-
-/*!
- * \brief Memory snapshot based serialization method.  Loads the buffer returned
- *        from `XGBoosterSerializeToBuffer'.
- * \param handle handle to booster
- * \return raw byte array
- */
-XGB_DLL SEXP XGBoosterUnserializeFromBuffer_R(SEXP handle, SEXP raw);
-
 /*!
 * \brief dump model into a string
 * \param handle handle
--- a/R-package/tests/testthat/test_basic.R
+++ b/R-package/tests/testthat/test_basic.R
@@ -27,7 +27,7 @@ test_that("train and predict binary classification", {

  pred <- predict(bst, test$data)
  expect_length(pred, 1611)
-
+  
  pred1 <- predict(bst, train$data, ntreelimit = 1)
  expect_length(pred1, 6513)
  err_pred1 <- sum((pred1 > 0.5) != train$label)/length(train$label)
@@ -35,87 +35,6 @@ test_that("train and predict binary classification", {
  expect_lt(abs(err_pred1 - err_log), 10e-6)
 })

-test_that("parameter validation works", {
-  p <- list(foo = "bar")
-  nrounds = 1
-  set.seed(1994)
-
-  d <- cbind(
-    x1 = rnorm(10),
-    x2 = rnorm(10),
-    x3 = rnorm(10))
-  y <- d[,"x1"] + d[,"x2"]^2 +
-    ifelse(d[,"x3"] > .5, d[,"x3"]^2, 2^d[,"x3"]) +
-    rnorm(10)
-  dtrain <- xgb.DMatrix(data=d, info = list(label=y))
-
-  correct <- function() {
-    params <- list(max_depth = 2, booster = "dart",
-                   rate_drop = 0.5, one_drop = TRUE,
-                   objective = "reg:squarederror")
-    xgb.train(params = params, data = dtrain, nrounds = nrounds)
-  }
-  expect_silent(correct())
-  incorrect <- function() {
-    params <- list(max_depth = 2, booster = "dart",
-                   rate_drop = 0.5, one_drop = TRUE,
-                   objective = "reg:squarederror",
-                   foo = "bar", bar = "foo")
-    output <- capture.output(
-      xgb.train(params = params, data = dtrain, nrounds = nrounds))
-    print(output)
-  }
-  expect_output(incorrect(), "bar, foo")
-})
-
-
-test_that("dart prediction works", {
-  nrounds = 32
-  set.seed(1994)
-
-  d <- cbind(
-    x1 = rnorm(100),
-    x2 = rnorm(100),
-    x3 = rnorm(100))
-  y <- d[,"x1"] + d[,"x2"]^2 +
-    ifelse(d[,"x3"] > .5, d[,"x3"]^2, 2^d[,"x3"]) +
-    rnorm(100)
-
-  set.seed(1994)
-  booster_by_xgboost <- xgboost(data = d, label = y, max_depth = 2, booster = "dart",
-                                rate_drop = 0.5, one_drop = TRUE,
-                                eta = 1, nthread = 2, nrounds = nrounds, objective = "reg:squarederror")
-  pred_by_xgboost_0 <- predict(booster_by_xgboost, newdata = d, ntreelimit = 0)
-  pred_by_xgboost_1 <- predict(booster_by_xgboost, newdata = d, ntreelimit = nrounds)
-  expect_true(all(matrix(pred_by_xgboost_0, byrow=TRUE) == matrix(pred_by_xgboost_1, byrow=TRUE)))
-
-  pred_by_xgboost_2 <- predict(booster_by_xgboost, newdata = d, training = TRUE)
-  expect_false(all(matrix(pred_by_xgboost_0, byrow=TRUE) == matrix(pred_by_xgboost_2, byrow=TRUE)))
-
-  set.seed(1994)
-  dtrain <- xgb.DMatrix(data=d, info = list(label=y))
-  booster_by_train <- xgb.train( params = list(
-                                   booster = "dart",
-                                   max_depth = 2,
-                                   eta = 1,
-                                   rate_drop = 0.5,
-                                   one_drop = TRUE,
-                                   nthread = 1,
-                                   tree_method= "exact",
-                                   objective = "reg:squarederror"
-                                 ),
-                                data = dtrain,
-                                nrounds = nrounds
-                                )
-  pred_by_train_0 <- predict(booster_by_train, newdata = dtrain, ntreelimit = 0)
-  pred_by_train_1 <- predict(booster_by_train, newdata = dtrain, ntreelimit = nrounds)
-  pred_by_train_2 <- predict(booster_by_train, newdata = dtrain, training = TRUE)
-
-  expect_true(all(matrix(pred_by_train_0, byrow=TRUE) == matrix(pred_by_xgboost_0, byrow=TRUE)))
-  expect_true(all(matrix(pred_by_train_1, byrow=TRUE) == matrix(pred_by_xgboost_1, byrow=TRUE)))
-  expect_true(all(matrix(pred_by_train_2, byrow=TRUE) == matrix(pred_by_xgboost_2, byrow=TRUE)))
-})
-
 test_that("train and predict softprob", {
  lb <- as.numeric(iris$Species) - 1
  set.seed(11)
@@ -155,7 +74,7 @@ test_that("train and predict softmax", {
  expect_false(is.null(bst$evaluation_log))
  expect_lt(bst$evaluation_log[, min(train_merror)], 0.025)
  expect_equal(bst$niter * 3, xgb.ntree(bst))
-
+  
  pred <- predict(bst, as.matrix(iris[, -5]))
  expect_length(pred, nrow(iris))
  err <- sum(pred != lb)/length(lb)
@@ -171,12 +90,12 @@ test_that("train and predict RF", {
                 num_parallel_tree = 20, subsample = 0.6, colsample_bytree = 0.1)
  expect_equal(bst$niter, 1)
  expect_equal(xgb.ntree(bst), 20)
-
+  
  pred <- predict(bst, train$data)
  pred_err <- sum((pred > 0.5) != lb)/length(lb)
  expect_lt(abs(bst$evaluation_log[1, train_error] - pred_err), 10e-6)
  #expect_lt(pred_err, 0.03)
-
+  
  pred <- predict(bst, train$data, ntreelimit = 20)
  pred_err_20 <- sum((pred > 0.5) != lb)/length(lb)
  expect_equal(pred_err_20, pred_err)
@@ -252,21 +171,6 @@ test_that("training continuation works", {
  expect_equal(dim(bst2$evaluation_log), c(2, 2))
 })

-test_that("model serialization works", {
-  out_path <- "model_serialization"
-  dtrain <- xgb.DMatrix(train$data, label = train$label)
-  watchlist = list(train=dtrain)
-  param <- list(objective = "binary:logistic")
-  booster <- xgb.train(param, dtrain, nrounds = 4, watchlist)
-  raw <- xgb.serialize(booster)
-  saveRDS(raw, out_path)
-  raw <- readRDS(out_path)
-
-  loaded <- xgb.unserialize(raw)
-  raw_from_loaded <- xgb.serialize(loaded)
-  expect_equal(raw, raw_from_loaded)
-  file.remove(out_path)
-})

 test_that("xgb.cv works", {
  set.seed(11)
@@ -287,27 +191,13 @@ test_that("xgb.cv works", {
  expect_false(is.null(cv$call))
 })

-test_that("xgb.cv works with stratified folds", {
-  dtrain <- xgb.DMatrix(train$data, label = train$label)
-  set.seed(314159)
-  cv <- xgb.cv(data = dtrain, max_depth = 2, nfold = 5,
-               eta = 1., nthread = 2, nrounds = 2, objective = "binary:logistic",
-               verbose=TRUE, stratified = FALSE)
-  set.seed(314159)
-  cv2 <- xgb.cv(data = dtrain, max_depth = 2, nfold = 5,
-                eta = 1., nthread = 2, nrounds = 2, objective = "binary:logistic",
-                verbose=TRUE, stratified = TRUE)
-  # Stratified folds should result in a different evaluation logs
-  expect_true(all(cv$evaluation_log[, test_error_mean] != cv2$evaluation_log[, test_error_mean]))
-})
-
 test_that("train and predict with non-strict classes", {
  # standard dense matrix input
  train_dense <- as.matrix(train$data)
  bst <- xgboost(data = train_dense, label = train$label, max_depth = 2,
                 eta = 1, nthread = 2, nrounds = 2, objective = "binary:logistic", verbose = 0)
  pr0 <- predict(bst, train_dense)
-
+  
  # dense matrix-like input of non-matrix class
  class(train_dense) <- 'shmatrix'
  expect_true(is.matrix(train_dense))
@@ -317,7 +207,7 @@ test_that("train and predict with non-strict classes", {
    , regexp = NA)
  expect_error(pr <- predict(bst, train_dense), regexp = NA)
  expect_equal(pr0, pr)
-
+  
  # dense matrix-like input of non-matrix class with some inheritance
  class(train_dense) <- c('pphmatrix','shmatrix')
  expect_true(is.matrix(train_dense))
@@ -327,7 +217,7 @@ test_that("train and predict with non-strict classes", {
    , regexp = NA)
  expect_error(pr <- predict(bst, train_dense), regexp = NA)
  expect_equal(pr0, pr)
-
+  
  # when someone inhertis from xgb.Booster, it should still be possible to use it as xgb.Booster
  class(bst) <- c('super.Booster', 'xgb.Booster')
  expect_error(pr <- predict(bst, train_dense), regexp = NA)
@@ -357,28 +247,18 @@ test_that("colsample_bytree works", {
  test_y <- as.numeric(rowSums(test_x) > 0)
  colnames(train_x) <- paste0("Feature_", sprintf("%03d", 1:100))
  colnames(test_x) <- paste0("Feature_", sprintf("%03d", 1:100))
-  dtrain <- xgb.DMatrix(train_x, label = train_y)
+   dtrain <- xgb.DMatrix(train_x, label = train_y)
  dtest <- xgb.DMatrix(test_x, label = test_y)
  watchlist <- list(train = dtrain, eval = dtest)
-  ## Use colsample_bytree = 0.01, so that roughly one out of 100 features is chosen for
-  ## each tree
-  param <- list(max_depth = 2, eta = 0, nthread = 2,
+   # Use colsample_bytree = 0.01, so that roughly one out of 100 features is
+  # chosen for each tree
+  param <- list(max_depth = 2, eta = 0, silent = 1, nthread = 2,
                colsample_bytree = 0.01, objective = "binary:logistic",
                eval_metric = "auc")
-  set.seed(2)
+   set.seed(2)
  bst <- xgb.train(param, dtrain, nrounds = 100, watchlist, verbose = 0)
  xgb.importance(model = bst)
  # If colsample_bytree works properly, a variety of features should be used
  # in the 100 trees
  expect_gte(nrow(xgb.importance(model = bst)), 30)
 })
-
-test_that("Configuration works", {
-  bst <- xgboost(data = train$data, label = train$label, max_depth = 2,
-                 eta = 1, nthread = 2, nrounds = 2, objective = "binary:logistic",
-                 eval_metric = 'error', eval_metric = 'auc', eval_metric = "logloss")
-  config <- xgb.config(bst)
-  xgb.config(bst) <- config
-  reloaded_config <- xgb.config(bst)
-  expect_equal(config, reloaded_config);
-})
--- a/R-package/tests/testthat/test_callbacks.R
+++ b/R-package/tests/testthat/test_callbacks.R
@@ -30,16 +30,16 @@ param <- list(objective = "binary:logistic", max_depth = 2, nthread = 2)


 test_that("cb.print.evaluation works as expected", {
-
+  
  bst_evaluation <- c('train-auc'=0.9, 'test-auc'=0.8)
  bst_evaluation_err <- NULL
  begin_iteration <- 1
  end_iteration <- 7
-
+  
  f0 <- cb.print.evaluation(period=0)
  f1 <- cb.print.evaluation(period=1)
  f5 <- cb.print.evaluation(period=5)
-
+  
  expect_false(is.null(attr(f1, 'call')))
  expect_equal(attr(f1, 'name'), 'cb.print.evaluation')

@@ -48,15 +48,15 @@ test_that("cb.print.evaluation works as expected", {
  expect_output(f1(), "\\[1\\]\ttrain-auc:0.900000\ttest-auc:0.800000")
  expect_output(f5(), "\\[1\\]\ttrain-auc:0.900000\ttest-auc:0.800000")
  expect_null(f1())
-
+  
  iteration <- 2
  expect_output(f1(), "\\[2\\]\ttrain-auc:0.900000\ttest-auc:0.800000")
  expect_silent(f5())
-
+  
  iteration <- 7
  expect_output(f1(), "\\[7\\]\ttrain-auc:0.900000\ttest-auc:0.800000")
  expect_output(f5(), "\\[7\\]\ttrain-auc:0.900000\ttest-auc:0.800000")
-
+  
  bst_evaluation_err  <- c('train-auc'=0.1, 'test-auc'=0.2)
  expect_output(f1(), "\\[7\\]\ttrain-auc:0.900000\\+0.100000\ttest-auc:0.800000\\+0.200000")
 })
@@ -65,40 +65,40 @@ test_that("cb.evaluation.log works as expected", {

  bst_evaluation <- c('train-auc'=0.9, 'test-auc'=0.8)
  bst_evaluation_err <- NULL
-
+  
  evaluation_log <- list()
  f <- cb.evaluation.log()
-
+  
  expect_false(is.null(attr(f, 'call')))
  expect_equal(attr(f, 'name'), 'cb.evaluation.log')
-
+  
  iteration <- 1
  expect_silent(f())
-  expect_equal(evaluation_log,
+  expect_equal(evaluation_log, 
               list(c(iter=1, bst_evaluation)))
  iteration <- 2
  expect_silent(f())
-  expect_equal(evaluation_log,
+  expect_equal(evaluation_log, 
               list(c(iter=1, bst_evaluation), c(iter=2, bst_evaluation)))
  expect_silent(f(finalize = TRUE))
-  expect_equal(evaluation_log,
+  expect_equal(evaluation_log, 
               data.table(iter=1:2, train_auc=c(0.9,0.9), test_auc=c(0.8,0.8)))
-
+  
  bst_evaluation_err  <- c('train-auc'=0.1, 'test-auc'=0.2)
  evaluation_log <- list()
  f <- cb.evaluation.log()
-
+  
  iteration <- 1
  expect_silent(f())
-  expect_equal(evaluation_log,
+  expect_equal(evaluation_log, 
               list(c(iter=1, c(bst_evaluation, bst_evaluation_err))))
  iteration <- 2
  expect_silent(f())
-  expect_equal(evaluation_log,
+  expect_equal(evaluation_log, 
               list(c(iter=1, c(bst_evaluation, bst_evaluation_err)),
                    c(iter=2, c(bst_evaluation, bst_evaluation_err))))
  expect_silent(f(finalize = TRUE))
-  expect_equal(evaluation_log,
+  expect_equal(evaluation_log, 
               data.table(iter=1:2,
                          train_auc_mean=c(0.9,0.9), train_auc_std=c(0.1,0.1),
                          test_auc_mean=c(0.8,0.8), test_auc_std=c(0.2,0.2)))
@@ -130,18 +130,18 @@ test_that("cb.reset.parameters works as expected", {
  bst1 <- xgb.train(param, dtrain, nrounds = 2, watchlist, verbose = 0,
                    callbacks = list(cb.reset.parameters(my_par)))
  expect_false(is.null(bst1$evaluation_log$train_error))
-  expect_equal(bst0$evaluation_log$train_error,
+  expect_equal(bst0$evaluation_log$train_error, 
               bst1$evaluation_log$train_error)
-
+  
  # same eta but re-set via a function in the callback
  set.seed(111)
  my_par <- list(eta = function(itr, itr_end) 0.9)
  bst2 <- xgb.train(param, dtrain, nrounds = 2, watchlist, verbose = 0,
                    callbacks = list(cb.reset.parameters(my_par)))
  expect_false(is.null(bst2$evaluation_log$train_error))
-  expect_equal(bst0$evaluation_log$train_error,
+  expect_equal(bst0$evaluation_log$train_error, 
               bst2$evaluation_log$train_error)
-
+  
  # different eta re-set as a vector parameter in the callback
  set.seed(111)
  my_par <- list(eta = c(0.6, 0.5))
@@ -149,7 +149,7 @@ test_that("cb.reset.parameters works as expected", {
                    callbacks = list(cb.reset.parameters(my_par)))
  expect_false(is.null(bst3$evaluation_log$train_error))
  expect_false(all(bst0$evaluation_log$train_error == bst3$evaluation_log$train_error))
-
+  
  # resetting multiple parameters at the same time runs with no error
  my_par <- list(eta = c(1., 0.5), gamma = c(1, 2), max_depth = c(4, 8))
  expect_error(
@@ -175,7 +175,7 @@ test_that("cb.reset.parameters works as expected", {
 test_that("cb.save.model works as expected", {
  files <- c('xgboost_01.model', 'xgboost_02.model', 'xgboost.model')
  for (f in files) if (file.exists(f)) file.remove(f)
-
+  
  bst <- xgb.train(param, dtrain, nrounds = 2, watchlist, eta = 1, verbose = 0,
                   save_period = 1, save_name = "xgboost_%02d.model")
  expect_true(file.exists('xgboost_01.model'))
@@ -184,9 +184,6 @@ test_that("cb.save.model works as expected", {
  expect_equal(xgb.ntree(b1), 1)
  b2 <- xgb.load('xgboost_02.model')
  expect_equal(xgb.ntree(b2), 2)
-
-  xgb.config(b2) <- xgb.config(bst)
-  expect_equal(xgb.config(bst), xgb.config(b2))
  expect_equal(bst$raw, b2$raw)

  # save_period = 0 saves the last iteration's model
@@ -194,9 +191,8 @@ test_that("cb.save.model works as expected", {
                   save_period = 0)
  expect_true(file.exists('xgboost.model'))
  b2 <- xgb.load('xgboost.model')
-  xgb.config(b2) <- xgb.config(bst)
  expect_equal(bst$raw, b2$raw)
-
+  
  for (f in files) if (file.exists(f)) file.remove(f)
 })

@@ -215,22 +211,13 @@ test_that("early stopping xgb.train works", {
  err_pred <- err(ltest, pred)
  err_log <- bst$evaluation_log[bst$best_iteration, test_error]
  expect_equal(err_log, err_pred, tolerance = 5e-6)
-
+  
  set.seed(11)
  expect_silent(
    bst0 <- xgb.train(param, dtrain, nrounds = 20, watchlist, eta = 0.3,
                      early_stopping_rounds = 3, maximize = FALSE, verbose = 0)
  )
  expect_equal(bst$evaluation_log, bst0$evaluation_log)
-
-  xgb.save(bst, "model.bin")
-  loaded <- xgb.load("model.bin")
-
-  expect_false(is.null(loaded$best_iteration))
-  expect_equal(loaded$best_iteration, bst$best_ntreelimit)
-  expect_equal(loaded$best_ntreelimit, bst$best_ntreelimit)
-
-  file.remove("model.bin")
 })

 test_that("early stopping using a specific metric works", {
@@ -298,16 +285,15 @@ test_that("prediction in early-stopping xgb.cv works", {
  set.seed(11)
  expect_output(
    cv <- xgb.cv(param, dtrain, nfold = 5, eta = 0.1, nrounds = 20,
-                 early_stopping_rounds = 5, maximize = FALSE, stratified = FALSE,
-                 prediction = TRUE)
+                 early_stopping_rounds = 5, maximize = FALSE, prediction = TRUE)
  , "Stopping. Best iteration")
-
+  
  expect_false(is.null(cv$best_iteration))
  expect_lt(cv$best_iteration, 19)
  expect_false(is.null(cv$evaluation_log))
  expect_false(is.null(cv$pred))
  expect_length(cv$pred, nrow(train$data))
-
+  
  err_pred <- mean( sapply(cv$folds, function(f) mean(err(ltrain[f], cv$pred[f]))) )
  err_log <- cv$evaluation_log[cv$best_iteration, test_error_mean]
  expect_equal(err_pred, err_log, tolerance = 1e-6)
--- a/R-package/tests/testthat/test_custom_objective.R
+++ b/R-package/tests/testthat/test_custom_objective.R
@@ -31,6 +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), 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)
@@ -57,21 +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")
-})
-
-test_that("custom objective with multi-class works", {
-  data = as.matrix(iris[, -5])
-  label =  as.numeric(iris$Species) - 1
-  dtrain <- xgb.DMatrix(data = data, label = label)
-  nclasses <- 3
-
-  fake_softprob <- function(preds, dtrain) {
-    expect_true(all(matrix(preds) == 0.5))
-    grad <- rnorm(dim(as.matrix(preds))[1])
-    expect_equal(dim(data)[1] * nclasses, dim(as.matrix(preds))[1])
-    hess <- rnorm(dim(as.matrix(preds))[1])
-    return (list(grad = grad, hess = hess))
-  }
-  param$objective = fake_softprob
-  bst <- xgb.train(param, dtrain, 1, num_class=nclasses)
+  expect_equal(length(bst$raw), 1100)
 })
--- a/R-package/tests/testthat/test_dmatrix.R
+++ b/R-package/tests/testthat/test_dmatrix.R
@@ -50,12 +50,6 @@ test_that("xgb.DMatrix: getinfo & setinfo", {
  labels <- getinfo(dtest, 'label')
  expect_equal(test_label, getinfo(dtest, 'label'))

-  expect_true(setinfo(dtest, 'label_lower_bound', test_label))
-  expect_equal(test_label, getinfo(dtest, 'label_lower_bound'))
-
-  expect_true(setinfo(dtest, 'label_upper_bound', test_label))
-  expect_equal(test_label, getinfo(dtest, 'label_upper_bound'))
-
  expect_true(length(getinfo(dtest, 'weight')) == 0)
  expect_true(length(getinfo(dtest, 'base_margin')) == 0)

@@ -65,7 +59,7 @@ test_that("xgb.DMatrix: getinfo & setinfo", {
  expect_error(setinfo(dtest, 'group', test_label))

  # providing character values will give a warning
-  expect_warning(setinfo(dtest, 'weight', rep('a', nrow(test_data))))
+  expect_warning( setinfo(dtest, 'weight', rep('a', nrow(test_data))) )

  # any other label should error
  expect_error(setinfo(dtest, 'asdf', test_label))
--- a/R-package/tests/testthat/test_glm.R
+++ b/R-package/tests/testthat/test_glm.R
@@ -40,7 +40,7 @@ test_that("gblinear works", {
  expect_lt(bst$evaluation_log$eval_error[2], ERR_UL)

  bst <- xgb.train(param, dtrain, n, watchlist, verbose = VERB, feature_selector = 'thrifty',
-                   top_k = 50, callbacks = list(cb.gblinear.history(sparse = TRUE)))
+                   top_n = 50, callbacks = list(cb.gblinear.history(sparse = TRUE)))
  expect_lt(bst$evaluation_log$eval_error[n], ERR_UL)
  h <- xgb.gblinear.history(bst)
  expect_equal(dim(h), c(n, ncol(dtrain) + 1))
--- a/R-package/tests/testthat/test_helpers.R
+++ b/R-package/tests/testthat/test_helpers.R
@@ -7,8 +7,8 @@ require(vcd, quietly = TRUE)

 float_tolerance = 5e-6

-# disable some tests for 32-bit environment
-flag_32bit = .Machine$sizeof.pointer != 8
+# disable some tests for Win32
+win32_flag = .Platform$OS.type == "windows" && .Machine$sizeof.pointer != 8

 set.seed(1982)
 data(Arthritis)
@@ -44,7 +44,7 @@ mbst.GLM <- xgboost(data = as.matrix(iris[, -5]), label = mlabel, verbose = 0,


 test_that("xgb.dump works", {
-  if (!flag_32bit)
+  if (!win32_flag)
    expect_length(xgb.dump(bst.Tree), 200)
  dump_file = file.path(tempdir(), 'xgb.model.dump')
  expect_true(xgb.dump(bst.Tree, dump_file, with_stats = T))
@@ -54,7 +54,7 @@ test_that("xgb.dump works", {
  # JSON format
  dmp <- xgb.dump(bst.Tree, dump_format = "json")
  expect_length(dmp, 1)
-  if (!flag_32bit)
+  if (!win32_flag)
    expect_length(grep('nodeid', strsplit(dmp, '\n')[[1]]), 188)
 })

@@ -142,44 +142,6 @@ test_that("predict feature contributions works", {
  }
 })

-test_that("SHAPs sum to predictions, with or without DART", {
-  d <- cbind(
-    x1 = rnorm(100),
-    x2 = rnorm(100),
-    x3 = rnorm(100))
-  y <- d[,"x1"] + d[,"x2"]^2 +
-    ifelse(d[,"x3"] > .5, d[,"x3"]^2, 2^d[,"x3"]) +
-    rnorm(100)
-  nrounds <- 30
-
-  for (booster in list("gbtree", "dart")) {
-    fit <- xgboost(
-      params = c(
-        list(
-          booster = booster,
-          objective = "reg:squarederror",
-          eval_metric = "rmse"),
-        if (booster == "dart")
-          list(rate_drop = .01, one_drop = T)),
-      data = d,
-      label = y,
-      nrounds = nrounds)
-
-    pr <- function(...)
-      predict(fit, newdata = d, ...)
-    pred <- pr()
-    shap <- pr(predcontrib = T)
-    shapi <- pr(predinteraction = T)
-    tol = 1e-5
-
-    expect_equal(rowSums(shap), pred, tol = tol)
-    expect_equal(apply(shapi, 1, sum), pred, tol = tol)
-    for (i in 1 : nrow(d))
-      for (f in list(rowSums, colSums))
-        expect_equal(f(shapi[i,,]), shap[i,], tol = tol)
-  }
-})
-
 test_that("xgb-attribute functionality", {
  val <- "my attribute value"
  list.val <- list(my_attr=val, a=123, b='ok')
@@ -256,7 +218,7 @@ test_that("xgb.model.dt.tree works with and without feature names", {
  names.dt.trees <- c("Tree", "Node", "ID", "Feature", "Split", "Yes", "No", "Missing", "Quality", "Cover")
  dt.tree <- xgb.model.dt.tree(feature_names = feature.names, model = bst.Tree)
  expect_equal(names.dt.trees, names(dt.tree))
-  if (!flag_32bit)
+  if (!win32_flag)
    expect_equal(dim(dt.tree), c(188, 10))
  expect_output(str(dt.tree), 'Feature.*\\"Age\\"')

@@ -283,7 +245,7 @@ test_that("xgb.model.dt.tree throws error for gblinear", {

 test_that("xgb.importance works with and without feature names", {
  importance.Tree <- xgb.importance(feature_names = feature.names, model = bst.Tree)
-  if (!flag_32bit)
+  if (!win32_flag)
    expect_equal(dim(importance.Tree), c(7, 4))
  expect_equal(colnames(importance.Tree), c("Feature", "Gain", "Cover", "Frequency"))
  expect_output(str(importance.Tree), 'Feature.*\\"Age\\"')
--- a/R-package/tests/testthat/test_interaction_constraints.R
+++ b/R-package/tests/testthat/test_interaction_constraints.R
@@ -14,42 +14,25 @@ test_that("interaction constraints for regression", {
  bst <- xgboost(data = train, label = y, max_depth = 3,
                 eta = 0.1, nthread = 2, nrounds = 100, verbose = 0,
                 interaction_constraints = list(c(0,1)))
-
+  
  # Set all observations to have the same x3 values then increment
  #  by the same amount
-  preds <- lapply(c(1,2,3), function(x){
-    tmat <- matrix(c(x1,x2,rep(x,1000)), ncol=3)
-    return(predict(bst, tmat))
-  })
+	preds <- lapply(c(1,2,3), function(x){
+		tmat <- matrix(c(x1,x2,rep(x,1000)), ncol=3)
+		return(predict(bst, tmat))
+	})

  # Check incrementing x3 has the same effect on all observations
  #   since x3 is constrained to be independent of x1 and x2
  #   and all observations start off from the same x3 value
-  diff1 <- preds[[2]] - preds[[1]]
-  test1 <- all(abs(diff1 - diff1[1]) < 1e-4)
-
-  diff2 <- preds[[3]] - preds[[2]]
-  test2 <- all(abs(diff2 - diff2[1]) < 1e-4)
-
+	diff1 <- preds[[2]] - preds[[1]]
+	test1 <- all(abs(diff1 - diff1[1]) < 1e-4)
+	
+	diff2 <- preds[[3]] - preds[[2]]
+	test2 <- all(abs(diff2 - diff2[1]) < 1e-4)
+	
  expect_true({
    test1 & test2
  }, "Interaction Contraint Satisfied")
-})
-
-test_that("interaction constraints scientific representation", {
-  rows <- 10
-  ## When number exceeds 1e5, R paste function uses scientific representation.
-  ## See: https://github.com/dmlc/xgboost/issues/5179
-  cols <- 1e5+10
-
-  d <- matrix(rexp(rows, rate=.1), nrow=rows, ncol=cols)
-  y <- rnorm(rows)
-
-  dtrain <- xgb.DMatrix(data=d, info = list(label=y))
-  inc <- list(c(seq.int(from = 0, to = cols, by = 1)))
-
-  with_inc <- xgb.train(data=dtrain, tree_method='hist',
-                        interaction_constraints=inc, nrounds=10)
-  without_inc <- xgb.train(data=dtrain, tree_method='hist', nrounds=10)
-  expect_equal(xgb.save.raw(with_inc), xgb.save.raw(without_inc))
+  
 })
--- a/R-package/vignettes/xgboostPresentation.Rmd
+++ b/R-package/vignettes/xgboostPresentation.Rmd
@@ -410,7 +410,7 @@ In some very specific cases, like when you want to pilot **XGBoost** from `caret

 ```{r saveLoadRBinVectorModel, message=F, warning=F}
 # save model to R's raw vector
-rawVec <- xgb.serialize(bst)
+rawVec <- xgb.save.raw(bst)

 # print class
 print(class(rawVec))
--- a/README.md
+++ b/README.md
@@ -7,7 +7,6 @@
 [![GitHub license](http://dmlc.github.io/img/apache2.svg)](./LICENSE)
 [![CRAN Status Badge](http://www.r-pkg.org/badges/version/xgboost)](http://cran.r-project.org/web/packages/xgboost)
 [![PyPI version](https://badge.fury.io/py/xgboost.svg)](https://pypi.python.org/pypi/xgboost/)
-[![Optuna](https://img.shields.io/badge/Optuna-integrated-blue)](https://optuna.org)

 [Community](https://xgboost.ai/community) |
 [Documentation](https://xgboost.readthedocs.org) |
@@ -18,16 +17,16 @@
 XGBoost is an optimized distributed gradient boosting library designed to be highly ***efficient***, ***flexible*** and ***portable***.
 It implements machine learning algorithms under the [Gradient Boosting](https://en.wikipedia.org/wiki/Gradient_boosting) framework.
 XGBoost provides a parallel tree boosting (also known as GBDT, GBM) that solve many data science problems in a fast and accurate way.
-The same code runs on major distributed environment (Kubernetes, Hadoop, SGE, MPI, Dask) and can solve problems beyond billions of examples.
+The same code runs on major distributed environment (Hadoop, SGE, MPI) and can solve problems beyond billions of examples.

 License
 -------
-© Contributors, 2019. Licensed under an [Apache-2](https://github.com/dmlc/xgboost/blob/master/LICENSE) license.
+© Contributors, 2016. Licensed under an [Apache-2](https://github.com/dmlc/xgboost/blob/master/LICENSE) license.

 Contribute to XGBoost
 ---------------------
 XGBoost has been developed and used by a group of active community members. Your help is very valuable to make the package better for everyone.
-Checkout the [Community Page](https://xgboost.ai/community).
+Checkout the [Community Page](https://xgboost.ai/community)

 Reference
 ---------
@@ -39,7 +38,7 @@ 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)
+[![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/amalgamation/xgboost-all0.cc
+++ b/amalgamation/xgboost-all0.cc
@@ -1,5 +1,5 @@
 /*!
- * Copyright 2015-2019 by Contributors.
+ * Copyright 2015 by Contributors.
 * \brief XGBoost Amalgamation.
 *  This offers an alternative way to compile the entire library from this single file.
 *
@@ -14,7 +14,6 @@
 #include "../src/metric/elementwise_metric.cc"
 #include "../src/metric/multiclass_metric.cc"
 #include "../src/metric/rank_metric.cc"
-#include "../src/metric/survival_metric.cc"

 // objectives
 #include "../src/objective/objective.cc"
@@ -22,32 +21,29 @@
 #include "../src/objective/multiclass_obj.cc"
 #include "../src/objective/rank_obj.cc"
 #include "../src/objective/hinge.cc"
-#include "../src/objective/aft_obj.cc"

 // gbms
 #include "../src/gbm/gbm.cc"
 #include "../src/gbm/gbtree.cc"
-#include "../src/gbm/gbtree_model.cc"
 #include "../src/gbm/gblinear.cc"
-#include "../src/gbm/gblinear_model.cc"

 // data
 #include "../src/data/data.cc"
+#include "../src/data/simple_csr_source.cc"
 #include "../src/data/simple_dmatrix.cc"
 #include "../src/data/sparse_page_raw_format.cc"
-#include "../src/data/ellpack_page.cc"
-#include "../src/data/ellpack_page_source.cc"

 // prediction
 #include "../src/predictor/predictor.cc"
 #include "../src/predictor/cpu_predictor.cc"

 #if DMLC_ENABLE_STD_THREAD
+#include "../src/data/sparse_page_source.cc"
 #include "../src/data/sparse_page_dmatrix.cc"
+#include "../src/data/sparse_page_writer.cc"
 #endif

-// trees
-#include "../src/tree/param.cc"
+// tress
 #include "../src/tree/split_evaluator.cc"
 #include "../src/tree/tree_model.cc"
 #include "../src/tree/tree_updater.cc"
@@ -58,7 +54,6 @@
 #include "../src/tree/updater_sync.cc"
 #include "../src/tree/updater_histmaker.cc"
 #include "../src/tree/updater_skmaker.cc"
-#include "../src/tree/constraints.cc"

 // linear
 #include "../src/linear/linear_updater.cc"
@@ -69,14 +64,8 @@
 #include "../src/learner.cc"
 #include "../src/logging.cc"
 #include "../src/common/common.cc"
-#include "../src/common/timer.cc"
 #include "../src/common/host_device_vector.cc"
 #include "../src/common/hist_util.cc"
-#include "../src/common/json.cc"
-#include "../src/common/io.cc"
-#include "../src/common/survival_util.cc"
-#include "../src/common/probability_distribution.cc"
-#include "../src/common/version.cc"

 // c_api
 #include "../src/c_api/c_api.cc"
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -2,6 +2,10 @@ environment:
    R_ARCH: x64
    USE_RTOOLS: true
    matrix:
+        - target: msvc
+          ver: 2013
+          generator: "Visual Studio 12 2013 Win64"
+          configuration: Release
        - target: msvc
          ver: 2015
          generator: "Visual Studio 14 2015 Win64"
@@ -94,7 +98,7 @@ build_script:
        cmake .. -G"%generator%" -DCMAKE_CONFIGURATION_TYPES="Release" -DR_LIB=ON &&
        cmake --build . --target install --config Release
      )
-    - if /i "%target%" == "jvm" cd jvm-packages && mvn test -pl :xgboost4j_2.12
+    - if /i "%target%" == "jvm" cd jvm-packages && mvn test -pl :xgboost4j

 test_script:
    - cd %APPVEYOR_BUILD_FOLDER%
--- a/cmake/Doc.cmake
+++ b/cmake/Doc.cmake
@@ -6,7 +6,7 @@ function (run_doxygen)
  endif (NOT DOXYGEN_DOT_FOUND)

  configure_file(
-    ${xgboost_SOURCE_DIR}/doc/Doxyfile.in
+    ${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
--- a/cmake/FindPrefetchIntrinsics.cmake
+++ b/cmake/FindPrefetchIntrinsics.cmake
@@ -1,22 +0,0 @@
-function (find_prefetch_intrinsics)
-  include(CheckCXXSourceCompiles)
-  check_cxx_source_compiles("
-  #include <xmmintrin.h>
-  int main() {
-    char data = 0;
-    const char* address = &data;
-    _mm_prefetch(address, _MM_HINT_NTA);
-    return 0;
-  }
-  " XGBOOST_MM_PREFETCH_PRESENT)
-  check_cxx_source_compiles("
-  int main() {
-    char data = 0;
-    const char* address = &data;
-    __builtin_prefetch(address, 0, 0);
-    return 0;
-  }
-  " XGBOOST_BUILTIN_PREFETCH_PRESENT)
-  set(XGBOOST_MM_PREFETCH_PRESENT ${XGBOOST_MM_PREFETCH_PRESENT} PARENT_SCOPE)
-  set(XGBOOST_BUILTIN_PREFETCH_PRESENT ${XGBOOST_BUILTIN_PREFETCH_PRESENT} PARENT_SCOPE)
-endfunction (find_prefetch_intrinsics)
--- a/cmake/Python_version.in
+++ b/cmake/Python_version.in
@@ -1 +0,0 @@
-@xgboost_VERSION_MAJOR@.@xgboost_VERSION_MINOR@.@xgboost_VERSION_PATCH@
--- a/cmake/Sanitizer.cmake
+++ b/cmake/Sanitizer.cmake
@@ -4,29 +4,24 @@
 #  enable_sanitizers("address;leak")

 # Add flags
-macro(enable_sanitizer sanitizer)
-  if(${sanitizer} MATCHES "address")
+macro(enable_sanitizer santizer)
+  if(${santizer} MATCHES "address")
    find_package(ASan REQUIRED)
    set(SAN_COMPILE_FLAGS "${SAN_COMPILE_FLAGS} -fsanitize=address")
    link_libraries(${ASan_LIBRARY})

-  elseif(${sanitizer} MATCHES "thread")
+  elseif(${santizer} MATCHES "thread")
    find_package(TSan REQUIRED)
    set(SAN_COMPILE_FLAGS "${SAN_COMPILE_FLAGS} -fsanitize=thread")
    link_libraries(${TSan_LIBRARY})

-  elseif(${sanitizer} MATCHES "leak")
+  elseif(${santizer} MATCHES "leak")
    find_package(LSan REQUIRED)
    set(SAN_COMPILE_FLAGS "${SAN_COMPILE_FLAGS} -fsanitize=leak")
    link_libraries(${LSan_LIBRARY})

-  elseif(${sanitizer} MATCHES "undefined")
-    find_package(UBSan REQUIRED)
-    set(SAN_COMPILE_FLAGS "${SAN_COMPILE_FLAGS} -fsanitize=undefined -fno-sanitize-recover=undefined")
-    link_libraries(${UBSan_LIBRARY})
-
  else()
-    message(FATAL_ERROR "Santizer ${sanitizer} not supported.")
+    message(FATAL_ERROR "Santizer ${santizer} not supported.")
  endif()
 endmacro()

--- a/cmake/Utils.cmake
+++ b/cmake/Utils.cmake
@@ -58,18 +58,9 @@ function(set_output_directory target dir)
 		RUNTIME_OUTPUT_DIRECTORY ${dir}
 		RUNTIME_OUTPUT_DIRECTORY_DEBUG ${dir}
 		RUNTIME_OUTPUT_DIRECTORY_RELEASE ${dir}
-		RUNTIME_OUTPUT_DIRECTORY_RELWITHDEBINFO ${dir}
-		RUNTIME_OUTPUT_DIRECTORY_MINSIZEREL ${dir}
 		LIBRARY_OUTPUT_DIRECTORY ${dir}
 		LIBRARY_OUTPUT_DIRECTORY_DEBUG ${dir}
 		LIBRARY_OUTPUT_DIRECTORY_RELEASE ${dir}
-		LIBRARY_OUTPUT_DIRECTORY_RELWITHDEBINFO ${dir}
-		LIBRARY_OUTPUT_DIRECTORY_MINSIZEREL ${dir}
-		ARCHIVE_OUTPUT_DIRECTORY ${dir}
-		ARCHIVE_OUTPUT_DIRECTORY_DEBUG ${dir}
-		ARCHIVE_OUTPUT_DIRECTORY_RELEASE ${dir}
-		ARCHIVE_OUTPUT_DIRECTORY_RELWITHDEBINFO ${dir}
-		ARCHIVE_OUTPUT_DIRECTORY_MINSIZEREL ${dir}
 	)
 endfunction(set_output_directory)

@@ -120,7 +111,7 @@ DESTINATION \"${build_dir}/bak\")")

  install(CODE "file(REMOVE_RECURSE \"${build_dir}/R-package\")")
  install(
-    DIRECTORY "${xgboost_SOURCE_DIR}/R-package"
+    DIRECTORY "${PROJECT_SOURCE_DIR}/R-package"
    DESTINATION "${build_dir}"
    REGEX "src/*" EXCLUDE
    REGEX "R-package/configure" EXCLUDE
--- a/cmake/Version.cmake
+++ b/cmake/Version.cmake
@@ -1,9 +0,0 @@
-function (write_version)
-  message(STATUS "xgboost VERSION: ${xgboost_VERSION}")
-  configure_file(
-    ${xgboost_SOURCE_DIR}/cmake/version_config.h.in
-    ${xgboost_SOURCE_DIR}/include/xgboost/version_config.h @ONLY)
-  configure_file(
-    ${xgboost_SOURCE_DIR}/cmake/Python_version.in
-    ${xgboost_SOURCE_DIR}/python-package/xgboost/VERSION @ONLY)
-endfunction (write_version)
--- a/cmake/modules/FindASan.cmake
+++ b/cmake/modules/FindASan.cmake
@@ -1,7 +1,7 @@
 set(ASan_LIB_NAME ASan)

 find_library(ASan_LIBRARY
-  NAMES libasan.so libasan.so.5 libasan.so.4 libasan.so.3 libasan.so.2 libasan.so.1 libasan.so.0
+  NAMES libasan.so libasan.so.4 libasan.so.3 libasan.so.2 libasan.so.1 libasan.so.0
  PATHS ${SANITIZER_PATH} /usr/lib64 /usr/lib /usr/local/lib64 /usr/local/lib ${CMAKE_PREFIX_PATH}/lib)

 include(FindPackageHandleStandardArgs)
--- a/cmake/modules/FindLibR.cmake
+++ b/cmake/modules/FindLibR.cmake
@@ -50,10 +50,10 @@ function(create_rlib_for_msvc)
      \nDo you have Rtools installed with its MinGW's bin/ in PATH?")
  endif()  
  # extract symbols from R.dll into R.def and R.lib import library
-  execute_process(COMMAND ${GENDEF_EXE}
+  execute_process(COMMAND gendef
    "-" "${LIBR_LIB_DIR}/R.dll"
    OUTPUT_FILE "${CMAKE_CURRENT_BINARY_DIR}/R.def")
-  execute_process(COMMAND ${DLLTOOL_EXE}
+  execute_process(COMMAND dlltool
    "--input-def" "${CMAKE_CURRENT_BINARY_DIR}/R.def"
    "--output-lib" "${CMAKE_CURRENT_BINARY_DIR}/R.lib")
 endfunction(create_rlib_for_msvc)
@@ -103,12 +103,12 @@ else()
    )
    # ask R for the include dir
    execute_process(
-      COMMAND ${LIBR_EXECUTABLE} "--slave" "--vanilla" "-e" "cat(R.home('include'))"
+      COMMAND ${LIBR_EXECUTABLE} "--slave" "--no-save" "-e" "cat(R.home('include'))"
      OUTPUT_VARIABLE LIBR_INCLUDE_DIRS
    )
    # ask R for the lib dir
    execute_process(
-      COMMAND ${LIBR_EXECUTABLE} "--slave" "--vanilla" "-e" "cat(R.home('lib'))"
+      COMMAND ${LIBR_EXECUTABLE} "--slave" "--no-save" "-e" "cat(R.home('lib'))"
      OUTPUT_VARIABLE LIBR_LIB_DIR
    )

--- a/cmake/modules/FindNVML.cmake
+++ b/cmake/modules/FindNVML.cmake
@@ -1,23 +0,0 @@
-if (NVML_LIBRARY)
-  unset(NVML_LIBRARY CACHE)
-endif(NVML_LIBRARY)
-
-set(NVML_LIB_NAME nvml)
-
-find_path(NVML_INCLUDE_DIR
-  NAMES nvml.h
-  PATHS ${CUDA_HOME}/include ${CUDA_INCLUDE} /usr/local/cuda/include)
-
-find_library(NVML_LIBRARY
-  NAMES nvidia-ml)
-
-message(STATUS "Using nvml library: ${NVML_LIBRARY}")
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(NVML DEFAULT_MSG
-                                  NVML_INCLUDE_DIR NVML_LIBRARY)
-
-mark_as_advanced(
-  NVML_INCLUDE_DIR
-  NVML_LIBRARY
-)
--- a/cmake/modules/FindUBSan.cmake
+++ b/cmake/modules/FindUBSan.cmake
@@ -1,13 +0,0 @@
-set(UBSan_LIB_NAME UBSan)
-
-find_library(UBSan_LIBRARY
-  NAMES libubsan.so libubsan.so.5 libubsan.so.4 libubsan.so.3 libubsan.so.2 libubsan.so.1 libubsan.so.0
-  PATHS ${SANITIZER_PATH} /usr/lib64 /usr/lib /usr/local/lib64 /usr/local/lib ${CMAKE_PREFIX_PATH}/lib)
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(UBSan DEFAULT_MSG
-  UBSan_LIBRARY)
-
-mark_as_advanced(
-  UBSan_LIBRARY
-  UBSan_LIB_NAME)
--- a/cmake/version_config.h.in
+++ b/cmake/version_config.h.in
@@ -1,11 +0,0 @@
-/*!
- * Copyright 2019 XGBoost contributors
- */
-#ifndef XGBOOST_VERSION_CONFIG_H_
-#define XGBOOST_VERSION_CONFIG_H_
-
-#define XGBOOST_VER_MAJOR @xgboost_VERSION_MAJOR@
-#define XGBOOST_VER_MINOR @xgboost_VERSION_MINOR@
-#define XGBOOST_VER_PATCH @xgboost_VERSION_PATCH@
-
-#endif  // XGBOOST_VERSION_CONFIG_H_
--- a/demo/README.md
+++ b/demo/README.md
@@ -16,7 +16,6 @@ Contents
 - [Tutorials](#tutorials)
 - [Usecases](#usecases)
 - [Tools using XGBoost](#tools-using-xgboost)
- [Integrations with 3rd party software](#integrations-with-3rd-party-software)
 - [Awards](#awards)
 - [Windows Binaries](#windows-binaries)

@@ -115,7 +114,6 @@ Please send pull requests if you find ones that are missing here.
 - [Complete Guide to Parameter Tuning in XGBoost](http://www.analyticsvidhya.com/blog/2016/03/complete-guide-parameter-tuning-xgboost-with-codes-python/) by Aarshay Jain
 - [Practical XGBoost in Python online course](http://education.parrotprediction.teachable.com/courses/practical-xgboost-in-python) by Parrot Prediction
 - [Spark and XGBoost using Scala](http://www.elenacuoco.com/2016/10/10/scala-spark-xgboost-classification/) by Elena Cuoco
-
 ## Usecases
 If you have particular usecase of xgboost that you would like to highlight.
 Send a PR to add a one sentence description:)
@@ -128,17 +126,14 @@ Send a PR to add a one sentence description:)
 - [Hanjing Su](https://www.52cs.org) from Tencent data platform team: "We use distributed XGBoost for click through prediction in wechat shopping and lookalikes. The problems involve hundreds millions of users and thousands of features. XGBoost is cleanly designed and can be easily integrated into our production environment, reducing our cost in developments."
 - [CNevd](https://github.com/CNevd) from autohome.com ad platform team: "Distributed XGBoost is used for click through rate prediction in our display advertising, XGBoost is highly efficient and flexible and can be easily used on our distributed platform, our ctr made a great improvement with hundred millions samples and millions features due to this awesome XGBoost"

+
+
 ## Tools using XGBoost

 - [BayesBoost](https://github.com/mpearmain/BayesBoost) - Bayesian Optimization using xgboost and sklearn API
 - [gp_xgboost_gridsearch](https://github.com/vatsan/gp_xgboost_gridsearch) - In-database parallel grid-search for XGBoost on [Greenplum](https://github.com/greenplum-db/gpdb) using PL/Python
 - [tpot](https://github.com/rhiever/tpot) - A Python tool that automatically creates and optimizes machine learning pipelines using genetic programming.

-## Integrations with 3rd party software
-Open source integrations with XGBoost:
-* [Neptune.ai](http://neptune.ai/) - Experiment management and collaboration tool for ML/DL/RL specialists. Integration has a form of the [XGBoost callback](https://docs.neptune.ai/integrations/xgboost.html) that automatically logs training and evaluation metrics, as well as saved model (booster), feature importance chart and visualized trees.
-* [Optuna](https://optuna.org/) - An open source hyperparameter optimization framework to automate hyperparameter search. Optuna integrates with XGBoost in the [XGBoostPruningCallback](https://optuna.readthedocs.io/en/stable/reference/integration.html#optuna.integration.XGBoostPruningCallback) that let users easily prune unpromising trials.
-
 ## 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)
--- a/demo/aft_survival/aft_survival_demo.py
+++ b/demo/aft_survival/aft_survival_demo.py
@@ -1,54 +0,0 @@
-"""
-Demo for survival analysis (regression) using Accelerated Failure Time (AFT) model
-"""
-from sklearn.model_selection import ShuffleSplit
-import pandas as pd
-import numpy as np
-import xgboost as xgb
-
-# The Veterans' Administration Lung Cancer Trial
-# The Statistical Analysis of Failure Time Data by Kalbfleisch J. and Prentice R (1980)
-df = pd.read_csv('../data/veterans_lung_cancer.csv')
-print('Training data:')
-print(df)
-
-# Split features and labels
-y_lower_bound = df['Survival_label_lower_bound']
-y_upper_bound = df['Survival_label_upper_bound']
-X = df.drop(['Survival_label_lower_bound', 'Survival_label_upper_bound'], axis=1)
-
-# Split data into training and validation sets
-rs = ShuffleSplit(n_splits=2, test_size=.7, random_state=0)
-train_index, valid_index = next(rs.split(X))
-dtrain = xgb.DMatrix(X.values[train_index, :])
-dtrain.set_float_info('label_lower_bound', y_lower_bound[train_index])
-dtrain.set_float_info('label_upper_bound', y_upper_bound[train_index])
-dvalid = xgb.DMatrix(X.values[valid_index, :])
-dvalid.set_float_info('label_lower_bound', y_lower_bound[valid_index])
-dvalid.set_float_info('label_upper_bound', y_upper_bound[valid_index])
-
-# Train gradient boosted trees using AFT loss and metric
-params = {'verbosity': 0,
-          'objective': 'survival:aft',
-          'eval_metric': 'aft-nloglik',
-          'tree_method': 'hist',
-          'learning_rate': 0.05,
-          'aft_loss_distribution': 'normal',
-          'aft_loss_distribution_scale': 1.20,
-          'max_depth': 6,
-          'lambda': 0.01,
-          'alpha': 0.02}
-bst = xgb.train(params, dtrain, num_boost_round=10000,
-                evals=[(dtrain, 'train'), (dvalid, 'valid')], 
-                early_stopping_rounds=50)
-
-# Run prediction on the validation set
-df = pd.DataFrame({'Label (lower bound)': y_lower_bound[valid_index],
-                   'Label (upper bound)': y_upper_bound[valid_index],
-                   'Predicted label': bst.predict(dvalid)})
-print(df)
-# Show only data points with right-censored labels
-print(df[np.isinf(df['Label (upper bound)'])])
-
-# Save trained model
-bst.save_model('aft_model.json')
--- a/demo/aft_survival/aft_survival_demo_with_optuna.py
+++ b/demo/aft_survival/aft_survival_demo_with_optuna.py
@@ -1,78 +0,0 @@
-"""
-Demo for survival analysis (regression) using Accelerated Failure Time (AFT) model, using Optuna
-to tune hyperparameters
-"""
-from sklearn.model_selection import ShuffleSplit
-import pandas as pd
-import numpy as np
-import xgboost as xgb
-import optuna
-
-# The Veterans' Administration Lung Cancer Trial
-# The Statistical Analysis of Failure Time Data by Kalbfleisch J. and Prentice R (1980)
-df = pd.read_csv('../data/veterans_lung_cancer.csv')
-print('Training data:')
-print(df)
-
-# Split features and labels
-y_lower_bound = df['Survival_label_lower_bound']
-y_upper_bound = df['Survival_label_upper_bound']
-X = df.drop(['Survival_label_lower_bound', 'Survival_label_upper_bound'], axis=1)
-
-# Split data into training and validation sets
-rs = ShuffleSplit(n_splits=2, test_size=.7, random_state=0)
-train_index, valid_index = next(rs.split(X))
-dtrain = xgb.DMatrix(X.values[train_index, :])
-dtrain.set_float_info('label_lower_bound', y_lower_bound[train_index])
-dtrain.set_float_info('label_upper_bound', y_upper_bound[train_index])
-dvalid = xgb.DMatrix(X.values[valid_index, :])
-dvalid.set_float_info('label_lower_bound', y_lower_bound[valid_index])
-dvalid.set_float_info('label_upper_bound', y_upper_bound[valid_index])
-
-# Define hyperparameter search space
-base_params = {'verbosity': 0,
-              'objective': 'survival:aft',
-              'eval_metric': 'aft-nloglik',
-              'tree_method': 'hist'}  # Hyperparameters common to all trials
-def objective(trial):
-    params = {'learning_rate': trial.suggest_loguniform('learning_rate', 0.01, 1.0),
-              'aft_loss_distribution': trial.suggest_categorical('aft_loss_distribution',
-                                                                  ['normal', 'logistic', 'extreme']),
-              'aft_loss_distribution_scale': trial.suggest_loguniform('aft_loss_distribution_scale', 0.1, 10.0),
-              'max_depth': trial.suggest_int('max_depth', 3, 8),
-              'lambda': trial.suggest_loguniform('lambda', 1e-8, 1.0),
-              'alpha': trial.suggest_loguniform('alpha', 1e-8, 1.0)}  # Search space
-    params.update(base_params)
-    pruning_callback = optuna.integration.XGBoostPruningCallback(trial, 'valid-aft-nloglik')
-    bst = xgb.train(params, dtrain, num_boost_round=10000,
-                    evals=[(dtrain, 'train'), (dvalid, 'valid')], 
-                    early_stopping_rounds=50, verbose_eval=False, callbacks=[pruning_callback])
-    if bst.best_iteration >= 25:
-        return bst.best_score
-    else:
-        return np.inf  # Reject models with < 25 trees
-
-# Run hyperparameter search
-study = optuna.create_study(direction='minimize')
-study.optimize(objective, n_trials=200)
-print('Completed hyperparameter tuning with best aft-nloglik = {}.'.format(study.best_trial.value))
-params = {}
-params.update(base_params)
-params.update(study.best_trial.params)
-
-# Re-run training with the best hyperparameter combination
-print('Re-running the best trial... params = {}'.format(params))
-bst = xgb.train(params, dtrain, num_boost_round=10000,
-                evals=[(dtrain, 'train'), (dvalid, 'valid')], 
-                early_stopping_rounds=50)
-
-# Run prediction on the validation set
-df = pd.DataFrame({'Label (lower bound)': y_lower_bound[valid_index],
-                   'Label (upper bound)': y_upper_bound[valid_index],
-                   'Predicted label': bst.predict(dvalid)})
-print(df)
-# Show only data points with right-censored labels
-print(df[np.isinf(df['Label (upper bound)'])])
-
-# Save trained model
-bst.save_model('aft_best_model.json')
--- a/demo/aft_survival/aft_survival_viz_demo.py
+++ b/demo/aft_survival/aft_survival_viz_demo.py
@@ -1,97 +0,0 @@
-"""
-Visual demo for survival analysis (regression) with Accelerated Failure Time (AFT) model.
-
-This demo uses 1D toy data and visualizes how XGBoost fits a tree ensemble. The ensemble model
-starts out as a flat line and evolves into a step function in order to account for all ranged
-labels.
-"""
-import numpy as np
-import xgboost as xgb
-import matplotlib.pyplot as plt
-
-plt.rcParams.update({'font.size': 13})
-
-# Function to visualize censored labels
-def plot_censored_labels(X, y_lower, y_upper):
-    def replace_inf(x, target_value):
-        x[np.isinf(x)] = target_value
-        return x
-    plt.plot(X, y_lower, 'o', label='y_lower', color='blue')
-    plt.plot(X, y_upper, 'o', label='y_upper', color='fuchsia')
-    plt.vlines(X, ymin=replace_inf(y_lower, 0.01), ymax=replace_inf(y_upper, 1000),
-               label='Range for y', color='gray')
-
-# Toy data
-X = np.array([1, 2, 3, 4, 5]).reshape((-1, 1))
-INF = np.inf
-y_lower = np.array([ 10,  15, -INF, 30, 100])
-y_upper = np.array([INF, INF,   20, 50, INF])
-
-# Visualize toy data
-plt.figure(figsize=(5, 4))
-plot_censored_labels(X, y_lower, y_upper)
-plt.ylim((6, 200))
-plt.legend(loc='lower right')
-plt.title('Toy data')
-plt.xlabel('Input feature')
-plt.ylabel('Label')
-plt.yscale('log')
-plt.tight_layout()
-plt.show(block=True)
-
-# Will be used to visualize XGBoost model
-grid_pts = np.linspace(0.8, 5.2, 1000).reshape((-1, 1))
-
-# Train AFT model using XGBoost
-dmat = xgb.DMatrix(X)
-dmat.set_float_info('label_lower_bound', y_lower)
-dmat.set_float_info('label_upper_bound', y_upper)
-params = {'max_depth': 3, 'objective':'survival:aft', 'min_child_weight': 0}
-
-accuracy_history = []
-def plot_intermediate_model_callback(env):
-    """Custom callback to plot intermediate models"""
-    # Compute y_pred = prediction using the intermediate model, at current boosting iteration
-    y_pred = env.model.predict(dmat)
-    # "Accuracy" = the number of data points whose ranged label (y_lower, y_upper) includes
-    #              the corresponding predicted label (y_pred)
-    acc = np.sum(np.logical_and(y_pred >= y_lower, y_pred <= y_upper)/len(X) * 100)
-    accuracy_history.append(acc)
-    
-    # Plot ranged labels as well as predictions by the model
-    plt.subplot(5, 3, env.iteration + 1)
-    plot_censored_labels(X, y_lower, y_upper)
-    y_pred_grid_pts = env.model.predict(xgb.DMatrix(grid_pts))
-    plt.plot(grid_pts, y_pred_grid_pts, 'r-', label='XGBoost AFT model', linewidth=4)
-    plt.title('Iteration {}'.format(env.iteration), x=0.5, y=0.8)
-    plt.xlim((0.8, 5.2))
-    plt.ylim((1 if np.min(y_pred) < 6 else 6, 200))
-    plt.yscale('log')
-
-res = {}
-plt.figure(figsize=(12,13))
-bst = xgb.train(params, dmat, 15, [(dmat, 'train')], evals_result=res,
-                callbacks=[plot_intermediate_model_callback])
-plt.tight_layout()
-plt.legend(loc='lower center', ncol=4,
-           bbox_to_anchor=(0.5, 0),
-           bbox_transform=plt.gcf().transFigure)
-plt.tight_layout()
-
-# Plot negative log likelihood over boosting iterations
-plt.figure(figsize=(8,3))
-plt.subplot(1, 2, 1)
-plt.plot(res['train']['aft-nloglik'], 'b-o', label='aft-nloglik')
-plt.xlabel('# Boosting Iterations')
-plt.legend(loc='best')
-
-# Plot "accuracy" over boosting iterations
-# "Accuracy" = the number of data points whose ranged label (y_lower, y_upper) includes
-#              the corresponding predicted label (y_pred)
-plt.subplot(1, 2, 2)
-plt.plot(accuracy_history, 'r-o', label='Accuracy (%)')
-plt.xlabel('# Boosting Iterations')
-plt.legend(loc='best')
-plt.tight_layout()
-
-plt.show()
--- a/demo/binary_classification/README.md
+++ b/demo/binary_classification/README.md
@@ -156,7 +156,7 @@ If you want to continue boosting from existing model, say 0002.model, use
 ```
 xgboost will load from 0002.model continue boosting for 2 rounds, and save output to continue.model. However, beware that the training and evaluation data specified in mushroom.conf should not change when you use this function.
 #### Use Multi-Threading
-When you are working with a large dataset, you may want to take advantage of parallelism. If your compiler supports OpenMP, xgboost is naturally multi-threaded, to set number of parallel running add ```nthread``` parameter to your configuration.
+When you are working with a large dataset, you may want to take advantage of parallelism. If your compiler supports OpenMP, xgboost is naturally multi-threaded, to set number of parallel running add ```nthread``` parameter to you configuration.
 Eg. ```nthread=10```

 Set nthread to be the number of your real cpu (On Unix, this can be found using ```lscpu```)
--- a/demo/c-api/CMakeLists.txt
+++ b/demo/c-api/CMakeLists.txt
@@ -1,4 +0,0 @@
-cmake_minimum_required(VERSION 3.12)
-find_package(xgboost REQUIRED)
-add_executable(api-demo c-api-demo.c)
-target_link_libraries(api-demo xgboost::xgboost)
--- a/demo/c-api/c-api-demo.c
+++ b/demo/c-api/c-api-demo.c
@@ -36,12 +36,13 @@ int main(int argc, char** argv) {
  //   https://xgboost.readthedocs.io/en/latest/parameter.html
  safe_xgboost(XGBoosterSetParam(booster, "tree_method", use_gpu ? "gpu_hist" : "hist"));
  if (use_gpu) {
-    // set the GPU to use;
+    // 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, "gpu_id", "-1"));
+    safe_xgboost(XGBoosterSetParam(booster, "n_gpus", "0"));
  }

  safe_xgboost(XGBoosterSetParam(booster, "objective", "binary:logistic"));
@@ -65,7 +66,7 @@ int main(int argc, char** argv) {
  const float* out_result = NULL;
  int n_print = 10;

-  safe_xgboost(XGBoosterPredict(booster, dtest, 0, 0, 0, &out_len, &out_result));
+  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]);
--- a/demo/dask/README.md
+++ b/demo/dask/README.md
@@ -1,6 +0,0 @@
-Dask
-====
-
-This directory contains some demonstrations for using `dask` with `XGBoost`.
-For an overview, see
-https://xgboost.readthedocs.io/en/latest/tutorials/dask.html .
--- a/demo/dask/cpu_training.py
+++ b/demo/dask/cpu_training.py
@@ -1,41 +0,0 @@
-import xgboost as xgb
-from xgboost.dask import DaskDMatrix
-from dask.distributed import Client
-from dask.distributed import LocalCluster
-from dask import array as da
-
-
-def main(client):
-    # generate some random data for demonstration
-    m = 100000
-    n = 100
-    X = da.random.random(size=(m, n), chunks=100)
-    y = da.random.random(size=(m, ), chunks=100)
-
-    # DaskDMatrix acts like normal DMatrix, works as a proxy for local
-    # DMatrix scatter around workers.
-    dtrain = DaskDMatrix(client, X, y)
-
-    # Use train method from xgboost.dask instead of xgboost.  This
-    # distributed version of train returns a dictionary containing the
-    # resulting booster and evaluation history obtained from
-    # evaluation metrics.
-    output = xgb.dask.train(client,
-                            {'verbosity': 1,
-                             'tree_method': 'hist'},
-                            dtrain,
-                            num_boost_round=4, evals=[(dtrain, 'train')])
-    bst = output['booster']
-    history = output['history']
-
-    # you can pass output directly into `predict` too.
-    prediction = xgb.dask.predict(client, bst, dtrain)
-    print('Evaluation history:', history)
-    return prediction
-
-
-if __name__ == '__main__':
-    # or use other clusters for scaling
-    with LocalCluster(n_workers=7, threads_per_worker=4) as cluster:
-        with Client(cluster) as client:
-            main(client)
--- a/demo/dask/gpu_training.py
+++ b/demo/dask/gpu_training.py
@@ -1,45 +0,0 @@
-from dask_cuda import LocalCUDACluster
-from dask.distributed import Client
-from dask import array as da
-import xgboost as xgb
-from xgboost.dask import DaskDMatrix
-
-
-def main(client):
-    # generate some random data for demonstration
-    m = 100000
-    n = 100
-    X = da.random.random(size=(m, n), chunks=100)
-    y = da.random.random(size=(m, ), chunks=100)
-
-    # DaskDMatrix acts like normal DMatrix, works as a proxy for local
-    # DMatrix scatter around workers.
-    dtrain = DaskDMatrix(client, X, y)
-
-    # Use train method from xgboost.dask instead of xgboost.  This
-    # distributed version of train returns a dictionary containing the
-    # resulting booster and evaluation history obtained from
-    # evaluation metrics.
-    output = xgb.dask.train(client,
-                            {'verbosity': 2,
-                             # Golden line for GPU training
-                             'tree_method': 'gpu_hist'},
-                            dtrain,
-                            num_boost_round=4, evals=[(dtrain, 'train')])
-    bst = output['booster']
-    history = output['history']
-
-    # you can pass output directly into `predict` too.
-    prediction = xgb.dask.predict(client, bst, dtrain)
-    prediction = prediction.compute()
-    print('Evaluation history:', history)
-    return prediction
-
-
-if __name__ == '__main__':
-    # `LocalCUDACluster` is used for assigning GPU to XGBoost processes.  Here
-    # `n_workers` represents the number of GPUs since we use one GPU per worker
-    # process.
-    with LocalCUDACluster(n_workers=2, threads_per_worker=4) as cluster:
-        with Client(cluster) as client:
-            main(client)
--- a/demo/dask/sklearn_cpu_training.py
+++ b/demo/dask/sklearn_cpu_training.py
@@ -1,39 +0,0 @@
-'''Dask interface demo:
-
-Use scikit-learn regressor interface with CPU histogram tree method.'''
-from dask.distributed import Client
-from dask.distributed import LocalCluster
-from dask import array as da
-import xgboost
-
-
-def main(client):
-    # generate some random data for demonstration
-    n = 100
-    m = 10000
-    partition_size = 100
-    X = da.random.random((m, n), partition_size)
-    y = da.random.random(m, partition_size)
-
-    regressor = xgboost.dask.DaskXGBRegressor(verbosity=1, n_estimators=2)
-    regressor.set_params(tree_method='hist')
-    # assigning client here is optional
-    regressor.client = client
-
-    regressor.fit(X, y, eval_set=[(X, y)])
-    prediction = regressor.predict(X)
-
-    bst = regressor.get_booster()
-    history = regressor.evals_result()
-
-    print('Evaluation history:', history)
-    # returned prediction is always a dask array.
-    assert isinstance(prediction, da.Array)
-    return bst                  # returning the trained model
-
-
-if __name__ == '__main__':
-    # or use other clusters for scaling
-    with LocalCluster(n_workers=4, threads_per_worker=1) as cluster:
-        with Client(cluster) as client:
-            main(client)
--- a/demo/dask/sklearn_gpu_training.py
+++ b/demo/dask/sklearn_gpu_training.py
@@ -1,42 +0,0 @@
-'''Dask interface demo:
-
-Use scikit-learn regressor interface with GPU histogram tree method.'''
-
-from dask.distributed import Client
-# It's recommended to use dask_cuda for GPU assignment
-from dask_cuda import LocalCUDACluster
-from dask import array as da
-import xgboost
-
-
-def main(client):
-    # generate some random data for demonstration
-    n = 100
-    m = 1000000
-    partition_size = 10000
-    X = da.random.random((m, n), partition_size)
-    y = da.random.random(m, partition_size)
-
-    regressor = xgboost.dask.DaskXGBRegressor(verbosity=1)
-    regressor.set_params(tree_method='gpu_hist')
-    # assigning client here is optional
-    regressor.client = client
-
-    regressor.fit(X, y, eval_set=[(X, y)])
-    prediction = regressor.predict(X)
-
-    bst = regressor.get_booster()
-    history = regressor.evals_result()
-
-    print('Evaluation history:', history)
-    # returned prediction is always a dask array.
-    assert isinstance(prediction, da.Array)
-    return bst                  # returning the trained model
-
-
-if __name__ == '__main__':
-    # With dask cuda, one can scale up XGBoost to arbitrary GPU clusters.
-    # `LocalCUDACluster` used here is only for demonstration purpose.
-    with LocalCUDACluster() as cluster:
-        with Client(cluster) as client:
-            main(client)
--- a/demo/data/veterans_lung_cancer.csv
+++ b/demo/data/veterans_lung_cancer.csv
@@ -1,138 +0,0 @@
-Survival_label_lower_bound,Survival_label_upper_bound,Age_in_years,Karnofsky_score,Months_from_Diagnosis,Celltype=adeno,Celltype=large,Celltype=smallcell,Celltype=squamous,Prior_therapy=no,Prior_therapy=yes,Treatment=standard,Treatment=test
-72.0,72.0,69.0,60.0,7.0,0,0,0,1,1,0,1,0
-411.0,411.0,64.0,70.0,5.0,0,0,0,1,0,1,1,0
-228.0,228.0,38.0,60.0,3.0,0,0,0,1,1,0,1,0
-126.0,126.0,63.0,60.0,9.0,0,0,0,1,0,1,1,0
-118.0,118.0,65.0,70.0,11.0,0,0,0,1,0,1,1,0
-10.0,10.0,49.0,20.0,5.0,0,0,0,1,1,0,1,0
-82.0,82.0,69.0,40.0,10.0,0,0,0,1,0,1,1,0
-110.0,110.0,68.0,80.0,29.0,0,0,0,1,1,0,1,0
-314.0,314.0,43.0,50.0,18.0,0,0,0,1,1,0,1,0
-100.0,inf,70.0,70.0,6.0,0,0,0,1,1,0,1,0
-42.0,42.0,81.0,60.0,4.0,0,0,0,1,1,0,1,0
-8.0,8.0,63.0,40.0,58.0,0,0,0,1,0,1,1,0
-144.0,144.0,63.0,30.0,4.0,0,0,0,1,1,0,1,0
-25.0,inf,52.0,80.0,9.0,0,0,0,1,0,1,1,0
-11.0,11.0,48.0,70.0,11.0,0,0,0,1,0,1,1,0
-30.0,30.0,61.0,60.0,3.0,0,0,1,0,1,0,1,0
-384.0,384.0,42.0,60.0,9.0,0,0,1,0,1,0,1,0
-4.0,4.0,35.0,40.0,2.0,0,0,1,0,1,0,1,0
-54.0,54.0,63.0,80.0,4.0,0,0,1,0,0,1,1,0
-13.0,13.0,56.0,60.0,4.0,0,0,1,0,1,0,1,0
-123.0,inf,55.0,40.0,3.0,0,0,1,0,1,0,1,0
-97.0,inf,67.0,60.0,5.0,0,0,1,0,1,0,1,0
-153.0,153.0,63.0,60.0,14.0,0,0,1,0,0,1,1,0
-59.0,59.0,65.0,30.0,2.0,0,0,1,0,1,0,1,0
-117.0,117.0,46.0,80.0,3.0,0,0,1,0,1,0,1,0
-16.0,16.0,53.0,30.0,4.0,0,0,1,0,0,1,1,0
-151.0,151.0,69.0,50.0,12.0,0,0,1,0,1,0,1,0
-22.0,22.0,68.0,60.0,4.0,0,0,1,0,1,0,1,0
-56.0,56.0,43.0,80.0,12.0,0,0,1,0,0,1,1,0
-21.0,21.0,55.0,40.0,2.0,0,0,1,0,0,1,1,0
-18.0,18.0,42.0,20.0,15.0,0,0,1,0,1,0,1,0
-139.0,139.0,64.0,80.0,2.0,0,0,1,0,1,0,1,0
-20.0,20.0,65.0,30.0,5.0,0,0,1,0,1,0,1,0
-31.0,31.0,65.0,75.0,3.0,0,0,1,0,1,0,1,0
-52.0,52.0,55.0,70.0,2.0,0,0,1,0,1,0,1,0
-287.0,287.0,66.0,60.0,25.0,0,0,1,0,0,1,1,0
-18.0,18.0,60.0,30.0,4.0,0,0,1,0,1,0,1,0
-51.0,51.0,67.0,60.0,1.0,0,0,1,0,1,0,1,0
-122.0,122.0,53.0,80.0,28.0,0,0,1,0,1,0,1,0
-27.0,27.0,62.0,60.0,8.0,0,0,1,0,1,0,1,0
-54.0,54.0,67.0,70.0,1.0,0,0,1,0,1,0,1,0
-7.0,7.0,72.0,50.0,7.0,0,0,1,0,1,0,1,0
-63.0,63.0,48.0,50.0,11.0,0,0,1,0,1,0,1,0
-392.0,392.0,68.0,40.0,4.0,0,0,1,0,1,0,1,0
-10.0,10.0,67.0,40.0,23.0,0,0,1,0,0,1,1,0
-8.0,8.0,61.0,20.0,19.0,1,0,0,0,0,1,1,0
-92.0,92.0,60.0,70.0,10.0,1,0,0,0,1,0,1,0
-35.0,35.0,62.0,40.0,6.0,1,0,0,0,1,0,1,0
-117.0,117.0,38.0,80.0,2.0,1,0,0,0,1,0,1,0
-132.0,132.0,50.0,80.0,5.0,1,0,0,0,1,0,1,0
-12.0,12.0,63.0,50.0,4.0,1,0,0,0,0,1,1,0
-162.0,162.0,64.0,80.0,5.0,1,0,0,0,1,0,1,0
-3.0,3.0,43.0,30.0,3.0,1,0,0,0,1,0,1,0
-95.0,95.0,34.0,80.0,4.0,1,0,0,0,1,0,1,0
-177.0,177.0,66.0,50.0,16.0,0,1,0,0,0,1,1,0
-162.0,162.0,62.0,80.0,5.0,0,1,0,0,1,0,1,0
-216.0,216.0,52.0,50.0,15.0,0,1,0,0,1,0,1,0
-553.0,553.0,47.0,70.0,2.0,0,1,0,0,1,0,1,0
-278.0,278.0,63.0,60.0,12.0,0,1,0,0,1,0,1,0
-12.0,12.0,68.0,40.0,12.0,0,1,0,0,0,1,1,0
-260.0,260.0,45.0,80.0,5.0,0,1,0,0,1,0,1,0
-200.0,200.0,41.0,80.0,12.0,0,1,0,0,0,1,1,0
-156.0,156.0,66.0,70.0,2.0,0,1,0,0,1,0,1,0
-182.0,inf,62.0,90.0,2.0,0,1,0,0,1,0,1,0
-143.0,143.0,60.0,90.0,8.0,0,1,0,0,1,0,1,0
-105.0,105.0,66.0,80.0,11.0,0,1,0,0,1,0,1,0
-103.0,103.0,38.0,80.0,5.0,0,1,0,0,1,0,1,0
-250.0,250.0,53.0,70.0,8.0,0,1,0,0,0,1,1,0
-100.0,100.0,37.0,60.0,13.0,0,1,0,0,0,1,1,0
-999.0,999.0,54.0,90.0,12.0,0,0,0,1,0,1,0,1
-112.0,112.0,60.0,80.0,6.0,0,0,0,1,1,0,0,1
-87.0,inf,48.0,80.0,3.0,0,0,0,1,1,0,0,1
-231.0,inf,52.0,50.0,8.0,0,0,0,1,0,1,0,1
-242.0,242.0,70.0,50.0,1.0,0,0,0,1,1,0,0,1
-991.0,991.0,50.0,70.0,7.0,0,0,0,1,0,1,0,1
-111.0,111.0,62.0,70.0,3.0,0,0,0,1,1,0,0,1
-1.0,1.0,65.0,20.0,21.0,0,0,0,1,0,1,0,1
-587.0,587.0,58.0,60.0,3.0,0,0,0,1,1,0,0,1
-389.0,389.0,62.0,90.0,2.0,0,0,0,1,1,0,0,1
-33.0,33.0,64.0,30.0,6.0,0,0,0,1,1,0,0,1
-25.0,25.0,63.0,20.0,36.0,0,0,0,1,1,0,0,1
-357.0,357.0,58.0,70.0,13.0,0,0,0,1,1,0,0,1
-467.0,467.0,64.0,90.0,2.0,0,0,0,1,1,0,0,1
-201.0,201.0,52.0,80.0,28.0,0,0,0,1,0,1,0,1
-1.0,1.0,35.0,50.0,7.0,0,0,0,1,1,0,0,1
-30.0,30.0,63.0,70.0,11.0,0,0,0,1,1,0,0,1
-44.0,44.0,70.0,60.0,13.0,0,0,0,1,0,1,0,1
-283.0,283.0,51.0,90.0,2.0,0,0,0,1,1,0,0,1
-15.0,15.0,40.0,50.0,13.0,0,0,0,1,0,1,0,1
-25.0,25.0,69.0,30.0,2.0,0,0,1,0,1,0,0,1
-103.0,inf,36.0,70.0,22.0,0,0,1,0,0,1,0,1
-21.0,21.0,71.0,20.0,4.0,0,0,1,0,1,0,0,1
-13.0,13.0,62.0,30.0,2.0,0,0,1,0,1,0,0,1
-87.0,87.0,60.0,60.0,2.0,0,0,1,0,1,0,0,1
-2.0,2.0,44.0,40.0,36.0,0,0,1,0,0,1,0,1
-20.0,20.0,54.0,30.0,9.0,0,0,1,0,0,1,0,1
-7.0,7.0,66.0,20.0,11.0,0,0,1,0,1,0,0,1
-24.0,24.0,49.0,60.0,8.0,0,0,1,0,1,0,0,1
-99.0,99.0,72.0,70.0,3.0,0,0,1,0,1,0,0,1
-8.0,8.0,68.0,80.0,2.0,0,0,1,0,1,0,0,1
-99.0,99.0,62.0,85.0,4.0,0,0,1,0,1,0,0,1
-61.0,61.0,71.0,70.0,2.0,0,0,1,0,1,0,0,1
-25.0,25.0,70.0,70.0,2.0,0,0,1,0,1,0,0,1
-95.0,95.0,61.0,70.0,1.0,0,0,1,0,1,0,0,1
-80.0,80.0,71.0,50.0,17.0,0,0,1,0,1,0,0,1
-51.0,51.0,59.0,30.0,87.0,0,0,1,0,0,1,0,1
-29.0,29.0,67.0,40.0,8.0,0,0,1,0,1,0,0,1
-24.0,24.0,60.0,40.0,2.0,1,0,0,0,1,0,0,1
-18.0,18.0,69.0,40.0,5.0,1,0,0,0,0,1,0,1
-83.0,inf,57.0,99.0,3.0,1,0,0,0,1,0,0,1
-31.0,31.0,39.0,80.0,3.0,1,0,0,0,1,0,0,1
-51.0,51.0,62.0,60.0,5.0,1,0,0,0,1,0,0,1
-90.0,90.0,50.0,60.0,22.0,1,0,0,0,0,1,0,1
-52.0,52.0,43.0,60.0,3.0,1,0,0,0,1,0,0,1
-73.0,73.0,70.0,60.0,3.0,1,0,0,0,1,0,0,1
-8.0,8.0,66.0,50.0,5.0,1,0,0,0,1,0,0,1
-36.0,36.0,61.0,70.0,8.0,1,0,0,0,1,0,0,1
-48.0,48.0,81.0,10.0,4.0,1,0,0,0,1,0,0,1
-7.0,7.0,58.0,40.0,4.0,1,0,0,0,1,0,0,1
-140.0,140.0,63.0,70.0,3.0,1,0,0,0,1,0,0,1
-186.0,186.0,60.0,90.0,3.0,1,0,0,0,1,0,0,1
-84.0,84.0,62.0,80.0,4.0,1,0,0,0,0,1,0,1
-19.0,19.0,42.0,50.0,10.0,1,0,0,0,1,0,0,1
-45.0,45.0,69.0,40.0,3.0,1,0,0,0,1,0,0,1
-80.0,80.0,63.0,40.0,4.0,1,0,0,0,1,0,0,1
-52.0,52.0,45.0,60.0,4.0,0,1,0,0,1,0,0,1
-164.0,164.0,68.0,70.0,15.0,0,1,0,0,0,1,0,1
-19.0,19.0,39.0,30.0,4.0,0,1,0,0,0,1,0,1
-53.0,53.0,66.0,60.0,12.0,0,1,0,0,1,0,0,1
-15.0,15.0,63.0,30.0,5.0,0,1,0,0,1,0,0,1
-43.0,43.0,49.0,60.0,11.0,0,1,0,0,0,1,0,1
-340.0,340.0,64.0,80.0,10.0,0,1,0,0,0,1,0,1
-133.0,133.0,65.0,75.0,1.0,0,1,0,0,1,0,0,1
-111.0,111.0,64.0,60.0,5.0,0,1,0,0,1,0,0,1
-231.0,231.0,67.0,70.0,18.0,0,1,0,0,0,1,0,1
-378.0,378.0,65.0,80.0,4.0,0,1,0,0,1,0,0,1
-49.0,49.0,37.0,30.0,3.0,0,1,0,0,1,0,0,1
--- a/demo/distributed-training/README.md
+++ b/demo/distributed-training/README.md
@@ -8,11 +8,7 @@ if you are interested in contributing.
 Build XGBoost with Distributed Filesystem Support
 -------------------------------------------------
 To use distributed xgboost, you only need to turn the options on to build
-with distributed filesystems(HDFS or S3) in cmake.
-
-```
-cmake <path/to/xgboost> -DUSE_HDFS=ON -DUSE_S3=ON -DUSE_AZURE=ON
-```
+with distributed filesystems(HDFS or S3) in ```xgboost/make/config.mk```.


 Step by Step Tutorial on AWS
--- a/demo/gpu_acceleration/README.md
+++ b/demo/gpu_acceleration/README.md
@@ -1,5 +1,7 @@
 # GPU Acceleration Demo

-`cover_type.py` shows how to train a model on the [forest cover type](https://archive.ics.uci.edu/ml/datasets/covertype) dataset using GPU acceleration. The forest cover type dataset has 581,012 rows and 54 features, making it time consuming to process. We compare the run-time and accuracy of the GPU and CPU histogram algorithms.
+This demo shows how to train a model on the [forest cover type](https://archive.ics.uci.edu/ml/datasets/covertype) dataset using GPU acceleration. The forest cover type dataset has 581,012 rows and 54 features, making it time consuming to process. We compare the run-time and accuracy of the GPU and CPU histogram algorithms.

-`memory.py` shows how to repeatedly train xgboost models while freeing memory between iterations.
+This demo requires the [GPU plug-in](https://xgboost.readthedocs.io/en/latest/gpu/index.html) to be built and installed.
+
+The dataset is automatically loaded via the sklearn script. 
--- a/demo/gpu_acceleration/memory.py
+++ b/demo/gpu_acceleration/memory.py
@@ -1,51 +0,0 @@
-import xgboost as xgb
-import numpy as np
-import time
-import pickle
-import GPUtil
-
-n = 10000
-m = 1000
-X = np.random.random((n, m))
-y = np.random.random(n)
-
-param = {'objective': 'binary:logistic',
-         'tree_method': 'gpu_hist'
-         }
-iterations = 5
-dtrain = xgb.DMatrix(X, label=y)
-
-# High memory usage
-# active bst objects with device memory persist across iterations
-boosters = []
-for i in range(iterations):
-    bst = xgb.train(param, dtrain)
-    boosters.append(bst)
-
-print("Example 1")
-GPUtil.showUtilization()
-del boosters
-
-# Better memory usage
-# The bst object can be destroyed by the python gc, freeing device memory
-# The gc may not immediately free the object, so more than one booster can be allocated at a time
-boosters = []
-for i in range(iterations):
-    bst = xgb.train(param, dtrain)
-    boosters.append(pickle.dumps(bst))
-
-print("Example 2")
-GPUtil.showUtilization()
-del boosters
-
-# Best memory usage
-# The gc explicitly frees the booster before starting the next iteration
-boosters = []
-for i in range(iterations):
-    bst = xgb.train(param, dtrain)
-    boosters.append(pickle.dumps(bst))
-    del bst
-
-print("Example 3")
-GPUtil.showUtilization()
-del boosters
--- a/demo/guide-python/README.md
+++ b/demo/guide-python/README.md
@@ -2,8 +2,6 @@ XGBoost Python Feature Walkthrough
 ==================================
 * [Basic walkthrough of wrappers](basic_walkthrough.py)
 * [Customize loss function, and evaluation metric](custom_objective.py)
-* [Re-implement RMSLE as customized metric and objective](custom_rmsle.py)
-* [Re-Implement `multi:softmax` objective as customized objective](custom_softmax.py)
 * [Boosting from existing prediction](boost_from_prediction.py)
 * [Predicting using first n trees](predict_first_ntree.py)
 * [Generalized Linear Model](generalized_linear_model.py)
--- a/demo/guide-python/basic_walkthrough.py
+++ b/demo/guide-python/basic_walkthrough.py
@@ -1,22 +1,16 @@
-#!/usr/bin/env python
+#!/usr/bin/python
 import numpy as np
 import scipy.sparse
 import pickle
 import xgboost as xgb
-import os

-# Make sure the demo knows where to load the data.
-CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
-XGBOOST_ROOT_DIR = os.path.dirname(os.path.dirname(CURRENT_DIR))
-DEMO_DIR = os.path.join(XGBOOST_ROOT_DIR, 'demo')
-
-# simple example
+### simple example
 # load file from text file, also binary buffer generated by xgboost
-dtrain = xgb.DMatrix(os.path.join(DEMO_DIR, 'data', 'agaricus.txt.train'))
-dtest = xgb.DMatrix(os.path.join(DEMO_DIR, 'data', 'agaricus.txt.test'))
+dtrain = xgb.DMatrix('../data/agaricus.txt.train')
+dtest = xgb.DMatrix('../data/agaricus.txt.test')

 # specify parameters via map, definition are same as c++ version
-param = {'max_depth': 2, 'eta': 1, 'objective': 'binary:logistic'}
+param = {'max_depth':2, 'eta':1, 'silent':1, 'objective':'binary:logistic'}

 # specify validations set to watch performance
 watchlist = [(dtest, 'eval'), (dtrain, 'train')]
@@ -26,14 +20,12 @@ bst = xgb.train(param, dtrain, num_round, watchlist)
 # this is prediction
 preds = bst.predict(dtest)
 labels = dtest.get_label()
-print('error=%f' %
-      (sum(1 for i in range(len(preds)) if int(preds[i] > 0.5) != labels[i]) /
-       float(len(preds))))
+print('error=%f' % (sum(1 for i in range(len(preds)) if int(preds[i] > 0.5) != labels[i]) / float(len(preds))))
 bst.save_model('0001.model')
 # dump model
 bst.dump_model('dump.raw.txt')
 # dump model with feature map
-bst.dump_model('dump.nice.txt', os.path.join(DEMO_DIR, 'data/featmap.txt'))
+bst.dump_model('dump.nice.txt', '../data/featmap.txt')

 # save dmatrix into binary buffer
 dtest.save_binary('dtest.buffer')
@@ -58,18 +50,14 @@ assert np.sum(np.abs(preds3 - preds)) == 0
 # build dmatrix from scipy.sparse
 print('start running example of build DMatrix from scipy.sparse CSR Matrix')
 labels = []
-row = []
-col = []
-dat = []
+row = []; col = []; dat = []
 i = 0
-for l in open(os.path.join(DEMO_DIR, 'data', 'agaricus.txt.train')):
+for l in open('../data/agaricus.txt.train'):
    arr = l.split()
    labels.append(int(arr[0]))
    for it in arr[1:]:
-        k, v = it.split(':')
-        row.append(i)
-        col.append(int(k))
-        dat.append(float(v))
+        k,v = it.split(':')
+        row.append(i); col.append(int(k)); dat.append(float(v))
    i += 1
 csr = scipy.sparse.csr_matrix((dat, (row, col)))
 dtrain = xgb.DMatrix(csr, label=labels)
@@ -84,8 +72,8 @@ watchlist = [(dtest, 'eval'), (dtrain, 'train')]
 bst = xgb.train(param, dtrain, num_round, watchlist)

 print('start running example of build DMatrix from numpy array')
-# NOTE: npymat is numpy array, we will convert it into scipy.sparse.csr_matrix
-# in internal implementation then convert to DMatrix
+# NOTE: npymat is numpy array, we will convert it into scipy.sparse.csr_matrix in internal implementation
+# then convert to DMatrix
 npymat = csr.todense()
 dtrain = xgb.DMatrix(npymat, label=labels)
 watchlist = [(dtest, 'eval'), (dtrain, 'train')]
--- a/demo/guide-python/boost_from_prediction.py
+++ b/demo/guide-python/boost_from_prediction.py
@@ -1,4 +1,5 @@
 #!/usr/bin/python
+import numpy as np
 import xgboost as xgb

 dtrain = xgb.DMatrix('../data/agaricus.txt.train')
@@ -7,19 +8,18 @@ watchlist = [(dtest, 'eval'), (dtrain, 'train')]
 ###
 # advanced: start from a initial base prediction
 #
-print('start running example to start from a initial prediction')
+print ('start running example to start from a initial prediction')
 # specify parameters via map, definition are same as c++ version
-param = {'max_depth': 2, 'eta': 1, 'silent': 1, 'objective': 'binary:logistic'}
+param = {'max_depth':2, 'eta':1, 'silent':1, 'objective':'binary:logistic'}
 # train xgboost for 1 round
 bst = xgb.train(param, dtrain, 1, watchlist)
-# Note: we need the margin value instead of transformed prediction in
-# set_base_margin
-# do predict with output_margin=True, will always give you margin values
-# before logistic transformation
+# Note: we need the margin value instead of transformed prediction in set_base_margin
+# do predict with output_margin=True, will always give you margin values before logistic transformation
 ptrain = bst.predict(dtrain, output_margin=True)
 ptest = bst.predict(dtest, output_margin=True)
 dtrain.set_base_margin(ptrain)
 dtest.set_base_margin(ptest)

+
 print('this is result of running from initial prediction')
-bst = xgb.train(param, dtrain, 1, watchlist)
+bst = xgb.train(param, dtrain, 1, watchlist)
--- a/demo/guide-python/cross_validation.py
+++ b/demo/guide-python/cross_validation.py
@@ -45,7 +45,7 @@ xgb.cv(param, dtrain, num_round, nfold=5,
 # you can also do cross validation with customized loss function
 # See custom_objective.py
 ##
-print('running cross validation, with customized loss function')
+print('running cross validation, with cutomsized loss function')
 def logregobj(preds, dtrain):
    labels = dtrain.get_label()
    preds = 1.0 / (1.0 + np.exp(-preds))
--- a/demo/guide-python/custom_objective.py
+++ b/demo/guide-python/custom_objective.py
@@ -16,9 +16,8 @@ param = {'max_depth': 2, 'eta': 1, 'silent': 1}
 watchlist = [(dtest, 'eval'), (dtrain, 'train')]
 num_round = 2

-
-# user define objective function, given prediction, return gradient and second
-# order gradient this is log likelihood loss
+# user define objective function, given prediction, return gradient and second order gradient
+# this is log likelihood loss
 def logregobj(preds, dtrain):
    labels = dtrain.get_label()
    preds = 1.0 / (1.0 + np.exp(-preds))
@@ -26,24 +25,18 @@ def logregobj(preds, dtrain):
    hess = preds * (1.0 - preds)
    return grad, hess

-
 # user defined evaluation function, return a pair metric_name, result
-
-# NOTE: when you do customized loss function, the default prediction value is
-# margin. this may make builtin evaluation metric not function properly for
-# example, we are doing logistic loss, the prediction is score before logistic
-# transformation the builtin evaluation error assumes input is after logistic
-# transformation Take this in mind when you use the customization, and maybe
-# you need write customized evaluation function
+# NOTE: when you do customized loss function, the default prediction value is margin
+# this may make builtin evaluation metric not function properly
+# for example, we are doing logistic loss, the prediction is score before logistic transformation
+# the builtin evaluation error assumes input is after logistic transformation
+# Take this in mind when you use the customization, and maybe you need write customized evaluation function
 def evalerror(preds, dtrain):
    labels = dtrain.get_label()
-    # return a pair metric_name, result. The metric name must not contain a
-    # colon (:) or a space since preds are margin(before logistic
-    # transformation, cutoff at 0)
+    # return a pair metric_name, result. The metric name must not contain a colon (:) or a space
+    # since preds are margin(before logistic transformation, cutoff at 0)
    return 'my-error', float(sum(labels != (preds > 0.0))) / len(labels)

-
 # training with customized objective, we can also do step by step training
 # simply look at xgboost.py's implementation of train
-bst = xgb.train(param, dtrain, num_round, watchlist, obj=logregobj,
-                feval=evalerror)
+bst = xgb.train(param, dtrain, num_round, watchlist, obj=logregobj, feval=evalerror)
--- a/demo/guide-python/custom_rmsle.py
+++ b/demo/guide-python/custom_rmsle.py
@@ -1,197 +0,0 @@
-'''Demo for defining customized metric and objective.  Notice that for
-simplicity reason weight is not used in following example. In this
-script, we implement the Squared Log Error (SLE) objective and RMSLE metric as customized
-functions, then compare it with native implementation in XGBoost.
-
-See doc/tutorials/custom_metric_obj.rst for a step by step
-walkthrough, with other details.
-
-The `SLE` objective reduces impact of outliers in training dataset,
-hence here we also compare its performance with standard squared
-error.
-
-'''
-import numpy as np
-import xgboost as xgb
-from typing import Tuple, Dict, List
-from time import time
-import argparse
-import matplotlib
-from matplotlib import pyplot as plt
-
-# shape of generated data.
-kRows = 4096
-kCols = 16
-
-kOutlier = 10000                # mean of generated outliers
-kNumberOfOutliers = 64
-
-kRatio = 0.7
-kSeed = 1994
-
-kBoostRound = 20
-
-np.random.seed(seed=kSeed)
-
-
-def generate_data() -> Tuple[xgb.DMatrix, xgb.DMatrix]:
-    '''Generate data containing outliers.'''
-    x = np.random.randn(kRows, kCols)
-    y = np.random.randn(kRows)
-    y += np.abs(np.min(y))
-
-    # Create outliers
-    for i in range(0, kNumberOfOutliers):
-        ind = np.random.randint(0, len(y)-1)
-        y[ind] += np.random.randint(0, kOutlier)
-
-    train_portion = int(kRows * kRatio)
-
-    # rmsle requires all label be greater than -1.
-    assert np.all(y > -1.0)
-
-    train_x: np.ndarray = x[: train_portion]
-    train_y: np.ndarray = y[: train_portion]
-    dtrain = xgb.DMatrix(train_x, label=train_y)
-
-    test_x = x[train_portion:]
-    test_y = y[train_portion:]
-    dtest = xgb.DMatrix(test_x, label=test_y)
-    return dtrain, dtest
-
-
-def native_rmse(dtrain: xgb.DMatrix,
-                dtest: xgb.DMatrix) -> Dict[str, Dict[str, List[float]]]:
-    '''Train using native implementation of Root Mean Squared Loss.'''
-    print('Squared Error')
-    squared_error = {
-        'objective': 'reg:squarederror',
-        'eval_metric': 'rmse',
-        'tree_method': 'hist',
-        'seed': kSeed
-    }
-    start = time()
-    results: Dict[str, Dict[str, List[float]]] = {}
-    xgb.train(squared_error,
-              dtrain=dtrain,
-              num_boost_round=kBoostRound,
-              evals=[(dtrain, 'dtrain'), (dtest, 'dtest')],
-              evals_result=results)
-    print('Finished Squared Error in:', time() - start, '\n')
-    return results
-
-
-def native_rmsle(dtrain: xgb.DMatrix,
-                 dtest: xgb.DMatrix) -> Dict[str, Dict[str, List[float]]]:
-    '''Train using native implementation of Squared Log Error.'''
-    print('Squared Log Error')
-    results: Dict[str, Dict[str, List[float]]] = {}
-    squared_log_error = {
-        'objective': 'reg:squaredlogerror',
-        'eval_metric': 'rmsle',
-        'tree_method': 'hist',
-        'seed': kSeed
-    }
-    start = time()
-    xgb.train(squared_log_error,
-              dtrain=dtrain,
-              num_boost_round=kBoostRound,
-              evals=[(dtrain, 'dtrain'), (dtest, 'dtest')],
-              evals_result=results)
-    print('Finished Squared Log Error in:', time() - start)
-    return results
-
-
-def py_rmsle(dtrain: xgb.DMatrix, dtest: xgb.DMatrix) -> Dict:
-    '''Train using Python implementation of Squared Log Error.'''
-    def gradient(predt: np.ndarray, dtrain: xgb.DMatrix) -> np.ndarray:
-        '''Compute the gradient squared log error.'''
-        y = dtrain.get_label()
-        return (np.log1p(predt) - np.log1p(y)) / (predt + 1)
-
-    def hessian(predt: np.ndarray, dtrain: xgb.DMatrix) -> np.ndarray:
-        '''Compute the hessian for squared log error.'''
-        y = dtrain.get_label()
-        return ((-np.log1p(predt) + np.log1p(y) + 1) /
-                np.power(predt + 1, 2))
-
-    def squared_log(predt: np.ndarray,
-                    dtrain: xgb.DMatrix) -> Tuple[np.ndarray, np.ndarray]:
-        '''Squared Log Error objective. A simplified version for RMSLE used as
-        objective function.
-
-        :math:`\frac{1}{2}[log(pred + 1) - log(label + 1)]^2`
-
-        '''
-        predt[predt < -1] = -1 + 1e-6
-        grad = gradient(predt, dtrain)
-        hess = hessian(predt, dtrain)
-        return grad, hess
-
-    def rmsle(predt: np.ndarray, dtrain: xgb.DMatrix) -> Tuple[str, float]:
-        ''' Root mean squared log error metric.
-
-        :math:`\sqrt{\frac{1}{N}[log(pred + 1) - log(label + 1)]^2}`
-        '''
-        y = dtrain.get_label()
-        predt[predt < -1] = -1 + 1e-6
-        elements = np.power(np.log1p(y) - np.log1p(predt), 2)
-        return 'PyRMSLE', float(np.sqrt(np.sum(elements) / len(y)))
-
-    results: Dict[str, Dict[str, List[float]]] = {}
-    xgb.train({'tree_method': 'hist', 'seed': kSeed,
-               'disable_default_eval_metric': 1},
-              dtrain=dtrain,
-              num_boost_round=kBoostRound,
-              obj=squared_log,
-              feval=rmsle,
-              evals=[(dtrain, 'dtrain'), (dtest, 'dtest')],
-              evals_result=results)
-
-    return results
-
-
-def plot_history(rmse_evals, rmsle_evals, py_rmsle_evals):
-    fig, axs = plt.subplots(3, 1)
-    ax0: matplotlib.axes.Axes = axs[0]
-    ax1: matplotlib.axes.Axes = axs[1]
-    ax2: matplotlib.axes.Axes = axs[2]
-
-    x = np.arange(0, kBoostRound, 1)
-
-    ax0.plot(x, rmse_evals['dtrain']['rmse'], label='train-RMSE')
-    ax0.plot(x, rmse_evals['dtest']['rmse'], label='test-RMSE')
-    ax0.legend()
-
-    ax1.plot(x, rmsle_evals['dtrain']['rmsle'], label='train-native-RMSLE')
-    ax1.plot(x, rmsle_evals['dtest']['rmsle'], label='test-native-RMSLE')
-    ax1.legend()
-
-    ax2.plot(x, py_rmsle_evals['dtrain']['PyRMSLE'], label='train-PyRMSLE')
-    ax2.plot(x, py_rmsle_evals['dtest']['PyRMSLE'], label='test-PyRMSLE')
-    ax2.legend()
-
-    plt.show()
-    plt.close()
-
-
-def main(args):
-    dtrain, dtest = generate_data()
-    rmse_evals = native_rmse(dtrain, dtest)
-    rmsle_evals = native_rmsle(dtrain, dtest)
-    py_rmsle_evals = py_rmsle(dtrain, dtest)
-
-    if args.plot != 0:
-        plot_history(rmse_evals, rmsle_evals, py_rmsle_evals)
-
-
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser(
-        description='Arguments for custom RMSLE objective function demo.')
-    parser.add_argument(
-        '--plot',
-        type=int,
-        default=1,
-        help='Set to 0 to disable plotting the evaluation history.')
-    args = parser.parse_args()
-    main(args)
--- a/demo/guide-python/custom_softmax.py
+++ b/demo/guide-python/custom_softmax.py
@@ -1,148 +0,0 @@
-'''Demo for creating customized multi-class objective function.  This demo is
-only applicable after (excluding) XGBoost 1.0.0, as before this version XGBoost
-returns transformed prediction for multi-class objective function.  More
-details in comments.
-
-'''
-
-import numpy as np
-import xgboost as xgb
-from matplotlib import pyplot as plt
-import argparse
-
-np.random.seed(1994)
-
-kRows = 100
-kCols = 10
-kClasses = 4                    # number of classes
-
-kRounds = 10                    # number of boosting rounds.
-
-# Generate some random data for demo.
-X = np.random.randn(kRows, kCols)
-y = np.random.randint(0, 4, size=kRows)
-
-m = xgb.DMatrix(X, y)
-
-
-def softmax(x):
-    '''Softmax function with x as input vector.'''
-    e = np.exp(x)
-    return e / np.sum(e)
-
-
-def softprob_obj(predt: np.ndarray, data: xgb.DMatrix):
-    '''Loss function.  Computing the gradient and approximated hessian (diagonal).
-    Reimplements the `multi:softprob` inside XGBoost.
-
-    '''
-    labels = data.get_label()
-    if data.get_weight().size == 0:
-        # Use 1 as weight if we don't have custom weight.
-        weights = np.ones((kRows, 1), dtype=float)
-    else:
-        weights = data.get_weight()
-
-    # The prediction is of shape (rows, classes), each element in a row
-    # represents a raw prediction (leaf weight, hasn't gone through softmax
-    # yet).  In XGBoost 1.0.0, the prediction is transformed by a softmax
-    # function, fixed in later versions.
-    assert predt.shape == (kRows, kClasses)
-
-    grad = np.zeros((kRows, kClasses), dtype=float)
-    hess = np.zeros((kRows, kClasses), dtype=float)
-
-    eps = 1e-6
-
-    # compute the gradient and hessian, slow iterations in Python, only
-    # suitable for demo.  Also the one in native XGBoost core is more robust to
-    # numeric overflow as we don't do anything to mitigate the `exp` in
-    # `softmax` here.
-    for r in range(predt.shape[0]):
-        target = labels[r]
-        p = softmax(predt[r, :])
-        for c in range(predt.shape[1]):
-            assert target >= 0 or target <= kClasses
-            g = p[c] - 1.0 if c == target else p[c]
-            g = g * weights[r]
-            h = max((2.0 * p[c] * (1.0 - p[c]) * weights[r]).item(), eps)
-            grad[r, c] = g
-            hess[r, c] = h
-
-    # Right now (XGBoost 1.0.0), reshaping is necessary
-    grad = grad.reshape((kRows * kClasses, 1))
-    hess = hess.reshape((kRows * kClasses, 1))
-    return grad, hess
-
-
-def predict(booster, X):
-    '''A customized prediction function that converts raw prediction to
-    target class.
-
-    '''
-    # Output margin means we want to obtain the raw prediction obtained from
-    # tree leaf weight.
-    predt = booster.predict(X, output_margin=True)
-    out = np.zeros(kRows)
-    for r in range(predt.shape[0]):
-        # the class with maximum prob (not strictly prob as it haven't gone
-        # through softmax yet so it doesn't sum to 1, but result is the same
-        # for argmax).
-        i = np.argmax(predt[r])
-        out[r] = i
-    return out
-
-
-def plot_history(custom_results, native_results):
-    fig, axs = plt.subplots(2, 1)
-    ax0 = axs[0]
-    ax1 = axs[1]
-
-    x = np.arange(0, kRounds, 1)
-    ax0.plot(x, custom_results['train']['merror'], label='Custom objective')
-    ax0.legend()
-    ax1.plot(x, native_results['train']['merror'], label='multi:softmax')
-    ax1.legend()
-
-    plt.show()
-
-
-def main(args):
-    custom_results = {}
-    # Use our custom objective function
-    booster_custom = xgb.train({'num_class': kClasses},
-                               m,
-                               num_boost_round=kRounds,
-                               obj=softprob_obj,
-                               evals_result=custom_results,
-                               evals=[(m, 'train')])
-
-    predt_custom = predict(booster_custom, m)
-
-    native_results = {}
-    # Use the same objective function defined in XGBoost.
-    booster_native = xgb.train({'num_class': kClasses},
-                               m,
-                               num_boost_round=kRounds,
-                               evals_result=native_results,
-                               evals=[(m, 'train')])
-    predt_native = booster_native.predict(m)
-
-    # We are reimplementing the loss function in XGBoost, so it should
-    # be the same for normal cases.
-    assert np.all(predt_custom == predt_native)
-
-    if args.plot != 0:
-        plot_history(custom_results, native_results)
-
-
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser(
-        description='Arguments for custom softmax objective function demo.')
-    parser.add_argument(
-        '--plot',
-        type=int,
-        default=1,
-        help='Set to 0 to disable plotting the evaluation history.')
-    args = parser.parse_args()
-    main(args)
--- a/demo/json-model/README.md
+++ b/demo/json-model/README.md
@@ -1,3 +0,0 @@
-We introduced initial support for saving XGBoost model in JSON format in 1.0.0.  Note that
-it's still experimental and under development, output schema is subject to change due to
-bug fixes or further refactoring.  For an overview, see https://xgboost.readthedocs.io/en/latest/tutorials/saving_model.html .
--- a/demo/json-model/json_parser.py
+++ b/demo/json-model/json_parser.py
@@ -1,180 +0,0 @@
-'''Demonstration for parsing JSON tree model file generated by XGBoost.  The
-support is experimental, output schema is subject to change in the future.
-'''
-import json
-import argparse
-
-
-class Tree:
-    '''A tree built by XGBoost.'''
-    # Index into node array
-    _left = 0
-    _right = 1
-    _parent = 2
-    _ind = 3
-    _cond = 4
-    _default_left = 5
-    # Index into stat array
-    _loss_chg = 0
-    _sum_hess = 1
-    _base_weight = 2
-    _child_cnt = 3
-
-    def __init__(self, tree_id: int, nodes, stats):
-        self.tree_id = tree_id
-        self.nodes = nodes
-        self.stats = stats
-
-    def loss_change(self, node_id: int):
-        '''Loss gain of a node.'''
-        return self.stats[node_id][self._loss_chg]
-
-    def sum_hessian(self, node_id: int):
-        '''Sum Hessian of a node.'''
-        return self.stats[node_id][self._sum_hess]
-
-    def base_weight(self, node_id: int):
-        '''Base weight of a node.'''
-        return self.stats[node_id][self._base_weight]
-
-    def num_children(self, node_id: int):
-        '''Number of children of a node.'''
-        return self.stats[node_id][self._child_cnt]
-
-    def split_index(self, node_id: int):
-        '''Split feature index of node.'''
-        return self.nodes[node_id][self._ind]
-
-    def split_condition(self, node_id: int):
-        '''Split value of a node.'''
-        return self.nodes[node_id][self._cond]
-
-    def parent(self, node_id: int):
-        '''Parent ID of a node.'''
-        return self.nodes[node_id][self._parent]
-
-    def left_child(self, node_id: int):
-        '''Left child ID of a node.'''
-        return self.nodes[node_id][self._left]
-
-    def right_child(self, node_id: int):
-        '''Right child ID of a node.'''
-        return self.nodes[node_id][self._right]
-
-    def is_leaf(self, node_id: int):
-        '''Whether a node is leaf.'''
-        return self.nodes[node_id][self._left] == -1
-
-    def is_deleted(self, node_id: int):
-        '''Whether a node is deleted.'''
-        # std::numeric_limits<uint32_t>::max()
-        return self.nodes[node_id][self._ind] == 4294967295
-
-    def __str__(self):
-        stacks = [0]
-        nodes = []
-        while stacks:
-            node = {}
-            nid = stacks.pop()
-
-            node['node id'] = nid
-            node['gain'] = self.loss_change(nid)
-            node['cover'] = self.sum_hessian(nid)
-            nodes.append(node)
-
-            if not self.is_leaf(nid) and not self.is_deleted(nid):
-                left = self.left_child(nid)
-                right = self.right_child(nid)
-                stacks.append(left)
-                stacks.append(right)
-
-        string = '\n'.join(map(lambda x: '  ' + str(x), nodes))
-        return string
-
-
-class Model:
-    '''Gradient boosted tree model.'''
-    def __init__(self, m: dict):
-        '''Construct the Model from JSON object.
-
-         parameters
-         ----------
-          m: A dictionary loaded by json
-        '''
-        # Basic property of a model
-        self.learner_model_shape = model['learner']['learner_model_param']
-        self.num_output_group = int(self.learner_model_shape['num_class'])
-        self.num_feature = int(self.learner_model_shape['num_feature'])
-        self.base_score = float(self.learner_model_shape['base_score'])
-        # A field encoding which output group a tree belongs
-        self.tree_info = model['learner']['gradient_booster']['model'][
-            'tree_info']
-
-        model_shape = model['learner']['gradient_booster']['model'][
-            'gbtree_model_param']
-
-        # JSON representation of trees
-        j_trees = model['learner']['gradient_booster']['model']['trees']
-
-        # Load the trees
-        self.num_trees = int(model_shape['num_trees'])
-        self.leaf_size = int(model_shape['size_leaf_vector'])
-        # Right now XGBoost doesn't support vector leaf yet
-        assert self.leaf_size == 0, str(self.leaf_size)
-
-        trees = []
-        for i in range(self.num_trees):
-            tree = j_trees[i]
-            tree_id = int(tree['id'])
-            assert tree_id == i, (tree_id, i)
-            # properties
-            left_children = tree['left_children']
-            right_children = tree['right_children']
-            parents = tree['parents']
-            split_conditions = tree['split_conditions']
-            split_indices = tree['split_indices']
-            default_left = tree['default_left']
-            # stats
-            base_weights = tree['base_weights']
-            loss_changes = tree['loss_changes']
-            sum_hessian = tree['sum_hessian']
-            leaf_child_counts = tree['leaf_child_counts']
-
-            stats = []
-            nodes = []
-            # We resemble the structure used inside XGBoost, which is similar
-            # to adjacency list.
-            for node_id in range(len(left_children)):
-                nodes.append([
-                    left_children[node_id], right_children[node_id],
-                    parents[node_id], split_indices[node_id],
-                    split_conditions[node_id], default_left[node_id]
-                ])
-                stats.append([
-                    loss_changes[node_id], sum_hessian[node_id],
-                    base_weights[node_id], leaf_child_counts[node_id]
-                ])
-
-            tree = Tree(tree_id, nodes, stats)
-            trees.append(tree)
-
-        self.trees = trees
-
-    def print_model(self):
-        for i, tree in enumerate(self.trees):
-            print('tree_id:', i)
-            print(tree)
-
-
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser(
-        description='Demonstration for loading and printing XGBoost model.')
-    parser.add_argument('--model',
-                        type=str,
-                        required=True,
-                        help='Path to JSON model file.')
-    args = parser.parse_args()
-    with open(args.model, 'r') as fd:
-        model = json.load(fd)
-    model = Model(model)
-    model.print_model()
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Tong He	1995db85e8	fix additional files note (#4699 ) * fix additional files note * Trigger CI * Trigger CI	2019-07-25 11:21:48 -07:00
Philip Hyunsu Cho	9c02016844	Upgrade dmlc-core submodule (#4688 )	2019-07-20 11:31:04 -07:00
Philip Hyunsu Cho	00e58bd08b	Upgrade dmlc-core submodule (#4674 )	2019-07-18 11:58:54 -07:00
Tong He	b77a89ec28	[R] Fix CRAN error for Mac OS X (#4672 ) * fix cran error for mac os x * ignore float on windows check for now	2019-07-18 11:58:30 -07:00
Philip Cho	cafc8bff58	Fix version number in R package	2019-06-20 14:23:20 -07:00
				`@@ -1 +0,0 @@`
				`@xgboost_VERSION_MAJOR@.@xgboost_VERSION_MINOR@.@xgboost_VERSION_PATCH@`