Fix typo. (#8192)

* Fix loading DMatrix binary in distributed env. (#8149)

- Try to load DMatrix binary before trying to parse text input.
- Remove some unmaintained code.

* Fix.

.github/workflows/jvm_tests.yml

@@ -2,9 +2,6 @@ name: XGBoost-JVM-Tests
 
 on: [push, pull_request]
 
-permissions:
-  contents: read # to fetch code (actions/checkout)
-
 jobs:
   test-with-jvm:
     name: Test JVM on OS ${{ matrix.os }}
@@ -12,7 +9,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [windows-latest, ubuntu-latest, macos-11]
+        os: [windows-latest, ubuntu-latest, macos-10.15]
 
     steps:
     - uses: actions/checkout@v2

.github/workflows/main.yml

@@ -6,9 +6,6 @@ name: XGBoost-CI
 # events but only for the master branch
 on: [push, pull_request]
 
-permissions:
-  contents: read # to fetch code (actions/checkout)
-
 # A workflow run is made up of one or more jobs that can run sequentially or in parallel
 jobs:
   gtest-cpu:
@@ -17,7 +14,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [macos-11]
+        os: [macos-10.15]
     steps:
     - uses: actions/checkout@v2
       with:
@@ -75,18 +72,19 @@ jobs:
     - uses: actions/checkout@v2
       with:
         submodules: 'true'
-    - uses: mamba-org/provision-with-micromamba@f347426e5745fe3dfc13ec5baf20496990d0281f # v14
+    - name: Install system packages
+      run: |
+        sudo apt-get install -y --no-install-recommends ninja-build
+    - uses: conda-incubator/setup-miniconda@v2
       with:
-        cache-downloads: true
-        cache-env: true
-        environment-name: cpp_test
-        environment-file: tests/ci_build/conda_env/cpp_test.yml
+        auto-update-conda: true
+        python-version: ${{ matrix.python-version }}
+        activate-environment: test
     - name: Display Conda env
       shell: bash -l {0}
       run: |
         conda info
         conda list
-
     - name: Build and install XGBoost static library
       shell: bash -l {0}
       run: |
@@ -108,7 +106,6 @@ jobs:
         cd ..
         rm -rf ./build
         popd
-
     - name: Build and install XGBoost shared library
       shell: bash -l {0}
       run: |
@@ -132,29 +129,101 @@ jobs:
 
   lint:
     runs-on: ubuntu-latest
-    name: Code linting for C++
+    name: Code linting for Python and C++
     steps:
     - uses: actions/checkout@v2
       with:
         submodules: 'true'
     - uses: actions/setup-python@v2
       with:
-        python-version: "3.8"
+        python-version: '3.7'
         architecture: 'x64'
     - name: Install Python packages
       run: |
-        python -m pip install wheel setuptools cpplint pylint
+        python -m pip install wheel setuptools
+        python -m pip install pylint cpplint numpy scipy scikit-learn
     - name: Run lint
       run: |
-        LINT_LANG=cpp make lint
+        make lint
 
-        python3 dmlc-core/scripts/lint.py --exclude_path \
-            python-package/xgboost/dmlc-core \
-            python-package/xgboost/include \
-            python-package/xgboost/lib \
-            python-package/xgboost/rabit \
-            python-package/xgboost/src \
-            --pylint-rc python-package/.pylintrc \
-            xgboost \
-            cpp \
-            include src python-package
+  mypy:
+    runs-on: ubuntu-latest
+    name: Type checking for Python
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        submodules: 'true'
+    - uses: actions/setup-python@v2
+      with:
+        python-version: '3.7'
+        architecture: 'x64'
+    - name: Install Python packages
+      run: |
+        python -m pip install wheel setuptools mypy pandas dask[complete] distributed
+    - name: Run mypy
+      run: |
+        make mypy
+
+  doxygen:
+    runs-on: ubuntu-latest
+    name: Generate C/C++ API doc using Doxygen
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        submodules: 'true'
+    - uses: actions/setup-python@v2
+      with:
+        python-version: '3.7'
+        architecture: 'x64'
+    - name: Install system packages
+      run: |
+        sudo apt-get install -y --no-install-recommends doxygen graphviz ninja-build
+        python -m pip install wheel setuptools
+        python -m pip install awscli
+    - name: Run Doxygen
+      run: |
+        mkdir build
+        cd build
+        cmake .. -DBUILD_C_DOC=ON -GNinja
+        ninja -v doc_doxygen
+    - name: Extract branch name
+      shell: bash
+      run: echo "##[set-output name=branch;]$(echo ${GITHUB_REF#refs/heads/})"
+      id: extract_branch
+      if: github.ref == 'refs/heads/master' || contains(github.ref, 'refs/heads/release_')
+    - name: Publish
+      run: |
+        cd build/
+        tar cvjf ${{ steps.extract_branch.outputs.branch }}.tar.bz2 doc_doxygen/
+        python -m awscli s3 cp ./${{ steps.extract_branch.outputs.branch }}.tar.bz2 s3://xgboost-docs/doxygen/ --acl public-read
+      if: github.ref == 'refs/heads/master' || contains(github.ref, 'refs/heads/release_')
+      env:
+        AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID_IAM_S3_UPLOADER }}
+        AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY_IAM_S3_UPLOADER }}
+
+  sphinx:
+    runs-on: ubuntu-latest
+    name: Build docs using Sphinx
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        submodules: 'true'
+    - uses: actions/setup-python@v2
+      with:
+        python-version: '3.8'
+        architecture: 'x64'
+    - name: Install system packages
+      run: |
+        sudo apt-get install -y --no-install-recommends graphviz
+        python -m pip install wheel setuptools
+        python -m pip install -r doc/requirements.txt
+    - name: Extract branch name
+      shell: bash
+      run: echo "##[set-output name=branch;]$(echo ${GITHUB_REF#refs/heads/})"
+      id: extract_branch
+      if: github.ref == 'refs/heads/master' || contains(github.ref, 'refs/heads/release_')
+    - name: Run Sphinx
+      run: |
+        make -C doc html
+      env:
+        SPHINX_GIT_BRANCH: ${{ steps.extract_branch.outputs.branch }}

.github/workflows/python_tests.yml

@@ -2,95 +2,27 @@ name: XGBoost-Python-Tests
 
 on: [push, pull_request]
 
-permissions:
-  contents: read # to fetch code (actions/checkout)
-
 jobs:
-  python-mypy-lint:
-    runs-on: ubuntu-latest
-    name: Type and format checks for the Python package
-    strategy:
-      matrix:
-        os: [ubuntu-latest]
-        python-version: ["3.8"]
-    steps:
-    - uses: actions/checkout@v2
-      with:
-        submodules: 'true'
-    - uses: conda-incubator/setup-miniconda@v2
-      with:
-        auto-update-conda: true
-        python-version: ${{ matrix.python-version }}
-        activate-environment: python_lint
-        environment-file: tests/ci_build/conda_env/python_lint.yml
-    - name: Display Conda env
-      shell: bash -l {0}
-      run: |
-        conda info
-        conda list
-    - name: Run mypy
-      shell: bash -l {0}
-      run: |
-        python tests/ci_build/lint_python.py --format=0 --type-check=1 --pylint=0
-    - name: Run formatter
-      shell: bash -l {0}
-      run: |
-        python tests/ci_build/lint_python.py --format=1 --type-check=0 --pylint=0
-    - name: Run pylint
-      shell: bash -l {0}
-      run: |
-        python tests/ci_build/lint_python.py --format=0 --type-check=0 --pylint=1
-
-  python-sdist-test-on-Linux:
-    # Mismatched glibcxx version between system and conda forge.
-    runs-on: ${{ matrix.os }}
-    name: Test installing XGBoost Python source package on ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ubuntu-latest]
-    steps:
-    - uses: actions/checkout@e2f20e631ae6d7dd3b768f56a5d2af784dd54791 # v2.5.0
-      with:
-        submodules: 'true'
-    - uses: mamba-org/provision-with-micromamba@f347426e5745fe3dfc13ec5baf20496990d0281f # v14
-      with:
-        cache-downloads: true
-        cache-env: false
-        environment-name: sdist_test
-        environment-file: tests/ci_build/conda_env/sdist_test.yml
-    - name: Display Conda env
-      shell: bash -l {0}
-      run: |
-        conda info
-        conda list
-    - name: Build and install XGBoost
-      shell: bash -l {0}
-      run: |
-        cd python-package
-        python --version
-        python setup.py sdist
-        pip install -v ./dist/xgboost-*.tar.gz
-        cd ..
-        python -c 'import xgboost'
-
   python-sdist-test:
-    # Use system toolchain instead of conda toolchain for macos and windows.
-    # MacOS has linker error if clang++ from conda-forge is used
     runs-on: ${{ matrix.os }}
     name: Test installing XGBoost Python source package on ${{ matrix.os }}
     strategy:
       matrix:
-        os: [macos-11, windows-latest]
+        os: [ubuntu-latest, macos-10.15, windows-latest]
         python-version: ["3.8"]
     steps:
     - uses: actions/checkout@v2
       with:
         submodules: 'true'
     - name: Install osx system dependencies
-      if: matrix.os == 'macos-11'
+      if: matrix.os == 'macos-10.15'
       run: |
         brew install ninja libomp
-    - uses: conda-incubator/setup-miniconda@35d1405e78aa3f784fe3ce9a2eb378d5eeb62169 # v2.1.1
+    - name: Install Ubuntu system dependencies
+      if: matrix.os == 'ubuntu-latest'
+      run: |
+        sudo apt-get install -y --no-install-recommends ninja-build
+    - uses: conda-incubator/setup-miniconda@v2
       with:
         auto-update-conda: true
         python-version: ${{ matrix.python-version }}
@@ -110,58 +42,6 @@ jobs:
         cd ..
         python -c 'import xgboost'
 
-  python-tests-on-macos:
-    name: Test XGBoost Python package on ${{ matrix.config.os }}
-    runs-on: ${{ matrix.config.os }}
-    timeout-minutes: 60
-    strategy:
-      matrix:
-        config:
-          - {os: macos-11}
-
-    steps:
-    - uses: actions/checkout@e2f20e631ae6d7dd3b768f56a5d2af784dd54791 # v2.5.0
-      with:
-        submodules: 'true'
-
-    - uses: mamba-org/provision-with-micromamba@f347426e5745fe3dfc13ec5baf20496990d0281f # v14
-      with:
-        cache-downloads: true
-        cache-env: false
-        environment-name: macos_test
-        environment-file: tests/ci_build/conda_env/macos_cpu_test.yml
-
-    - name: Display Conda env
-      shell: bash -l {0}
-      run: |
-        conda info
-        conda list
-
-    - name: Build XGBoost on macos
-      shell: bash -l {0}
-      run: |
-        brew install ninja
-
-        mkdir build
-        cd build
-        # Set prefix, to use OpenMP library from Conda env
-        # See https://github.com/dmlc/xgboost/issues/7039#issuecomment-1025038228
-        # to learn why we don't use libomp from Homebrew.
-        cmake .. -GNinja -DCMAKE_PREFIX_PATH=$CONDA_PREFIX
-        ninja
-
-    - name: Install Python package
-      shell: bash -l {0}
-      run: |
-        cd python-package
-        python --version
-        python setup.py install
-
-    - name: Test Python package
-      shell: bash -l {0}
-      run: |
-        pytest -s -v -rxXs --durations=0 ./tests/python
-
   python-tests-on-win:
     name: Test XGBoost Python package on ${{ matrix.config.os }}
     runs-on: ${{ matrix.config.os }}
@@ -207,4 +87,56 @@ jobs:
     - name: Test Python package
       shell: bash -l {0}
       run: |
-        pytest -s -v -rxXs --durations=0 ./tests/python
+        pytest -s -v ./tests/python
+
+  python-tests-on-macos:
+    name: Test XGBoost Python package on ${{ matrix.config.os }}
+    runs-on: ${{ matrix.config.os }}
+    strategy:
+      matrix:
+        config:
+          - {os: macos-10.15, python-version "3.8" }
+
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        submodules: 'true'
+
+    - uses: conda-incubator/setup-miniconda@v2
+      with:
+        auto-update-conda: true
+        python-version: ${{ matrix.config.python-version }}
+        activate-environment: macos_test
+        environment-file: tests/ci_build/conda_env/macos_cpu_test.yml
+
+    - name: Display Conda env
+      shell: bash -l {0}
+      run: |
+        conda info
+        conda list
+
+    - name: Build XGBoost on macos
+      shell: bash -l {0}
+      run: |
+        brew install ninja
+
+        mkdir build
+        cd build
+        # Set prefix, to use OpenMP library from Conda env
+        # See https://github.com/dmlc/xgboost/issues/7039#issuecomment-1025038228
+        # to learn why we don't use libomp from Homebrew.
+        cmake .. -GNinja -DGOOGLE_TEST=ON -DUSE_DMLC_GTEST=ON -DCMAKE_PREFIX_PATH=$CONDA_PREFIX
+        ninja
+
+    - name: Install Python package
+      shell: bash -l {0}
+      run: |
+        cd python-package
+        python --version
+        python setup.py bdist_wheel --universal
+        pip install ./dist/*.whl
+
+    - name: Test Python package
+      shell: bash -l {0}
+      run: |
+        pytest -s -v ./tests/python

.github/workflows/python_wheels.yml

@@ -2,9 +2,6 @@ name: XGBoost-Python-Wheels
 
 on: [push, pull_request]
 
-permissions:
-  contents: read # to fetch code (actions/checkout)
-
 jobs:
   python-wheels:
     name: Build wheel for ${{ matrix.platform_id }}
@@ -23,7 +20,7 @@ jobs:
     - name: Setup Python
       uses: actions/setup-python@v2
       with:
-        python-version: "3.8"
+        python-version: '3.9'
     - name: Build wheels
       run: bash tests/ci_build/build_python_wheels.sh ${{ matrix.platform_id }} ${{ github.sha }}
     - name: Extract branch name

.github/workflows/r_nold.yml

@@ -10,9 +10,6 @@ on:
 env:
   R_PACKAGES: c('XML', 'igraph', 'data.table', 'ggplot2', 'DiagrammeR', 'Ckmeans.1d.dp', 'vcd', 'testthat', 'lintr', 'knitr', 'rmarkdown', 'e1071', 'cplm', 'devtools', 'float', 'titanic')
 
-permissions:
-  contents: read # to fetch code (actions/checkout)
-
 jobs:
   test-R-noLD:
     if: github.event.comment.body == '/gha run r-nold-test' && contains('OWNER,MEMBER,COLLABORATOR', github.event.comment.author_association)

.github/workflows/r_tests.yml

@@ -5,10 +5,6 @@ on: [push, pull_request]
 env:
   R_PACKAGES: c('XML', 'data.table', 'ggplot2', 'DiagrammeR', 'Ckmeans.1d.dp', 'vcd', 'testthat', 'lintr', 'knitr', 'rmarkdown', 'e1071', 'cplm', 'devtools', 'float', 'titanic')
   GITHUB_PAT: ${{ secrets.GITHUB_TOKEN }}
-  _R_CHECK_EXAMPLE_TIMING_CPU_TO_ELAPSED_THRESHOLD_: 2.5
-
-permissions:
-  contents: read # to fetch code (actions/checkout)
 
 jobs:
   lintr:
@@ -17,7 +13,7 @@ jobs:
     strategy:
       matrix:
         config:
-          - {os: ubuntu-latest, r: 'release'}
+          - {os: windows-latest, r: 'release', compiler: 'mingw', build: 'autotools'}
     env:
       R_REMOTES_NO_ERRORS_FROM_WARNINGS: true
       RSPM: ${{ matrix.config.rspm }}
@@ -27,7 +23,7 @@ jobs:
       with:
         submodules: 'true'
 
-    - uses: r-lib/actions/setup-r@v2
+    - uses: r-lib/actions/setup-r@master
       with:
         r-version: ${{ matrix.config.r }}
 
@@ -35,8 +31,8 @@ jobs:
       uses: actions/cache@v2
       with:
         path: ${{ env.R_LIBS_USER }}
-        key: ${{ runner.os }}-r-${{ matrix.config.r }}-5-${{ hashFiles('R-package/DESCRIPTION') }}
-        restore-keys: ${{ runner.os }}-r-${{ matrix.config.r }}-5-${{ hashFiles('R-package/DESCRIPTION') }}
+        key: ${{ runner.os }}-r-${{ matrix.config.r }}-3-${{ hashFiles('R-package/DESCRIPTION') }}
+        restore-keys: ${{ runner.os }}-r-${{ matrix.config.r }}-3-${{ hashFiles('R-package/DESCRIPTION') }}
 
     - name: Install dependencies
       shell: Rscript {0}
@@ -53,9 +49,8 @@ jobs:
     - name: Run lintr
       run: |
         cd R-package
-        R CMD INSTALL .
-        # Disable lintr errors for now: https://github.com/dmlc/xgboost/issues/8012
-        Rscript tests/helper_scripts/run_lint.R || true
+        R.exe CMD INSTALL .
+        Rscript.exe tests/helper_scripts/run_lint.R
 
   test-with-R:
     runs-on: ${{ matrix.config.os }}
@@ -69,7 +64,6 @@ jobs:
           - {os: windows-latest, r: 'release', compiler: 'mingw', build: 'cmake'}
     env:
       R_REMOTES_NO_ERRORS_FROM_WARNINGS: true
-      _R_CHECK_EXAMPLE_TIMING_CPU_TO_ELAPSED_THRESHOLD_: 2.5
       RSPM: ${{ matrix.config.rspm }}
 
     steps:
@@ -77,7 +71,7 @@ jobs:
       with:
         submodules: 'true'
 
-    - uses: r-lib/actions/setup-r@v2
+    - uses: r-lib/actions/setup-r@master
       with:
         r-version: ${{ matrix.config.r }}
 
@@ -85,29 +79,24 @@ jobs:
       uses: actions/cache@v2
       with:
         path: ${{ env.R_LIBS_USER }}
-        key: ${{ runner.os }}-r-${{ matrix.config.r }}-5-${{ hashFiles('R-package/DESCRIPTION') }}
-        restore-keys: ${{ runner.os }}-r-${{ matrix.config.r }}-5-${{ hashFiles('R-package/DESCRIPTION') }}
+        key: ${{ runner.os }}-r-${{ matrix.config.r }}-3-${{ hashFiles('R-package/DESCRIPTION') }}
+        restore-keys: ${{ runner.os }}-r-${{ matrix.config.r }}-3-${{ hashFiles('R-package/DESCRIPTION') }}
 
     - name: Install dependencies
       shell: Rscript {0}
-      if: matrix.config.os != 'windows-latest'
       run: |
         install.packages(${{ env.R_PACKAGES }},
                          repos = 'http://cloud.r-project.org',
                          dependencies = c('Depends', 'Imports', 'LinkingTo'))
-
-    - name: Install binary dependencies
+    - name: Install igraph on Windows
       shell: Rscript {0}
       if: matrix.config.os == 'windows-latest'
       run: |
-        install.packages(${{ env.R_PACKAGES }},
-                         type = 'binary',
-                         repos = 'http://cloud.r-project.org',
-                         dependencies = c('Depends', 'Imports', 'LinkingTo'))
+        install.packages('igraph', type='binary', dependencies = c('Depends', 'Imports', 'LinkingTo'))
 
     - uses: actions/setup-python@v2
       with:
-        python-version: "3.8"
+        python-version: '3.7'
         architecture: 'x64'
 
     - name: Test R
@@ -123,20 +112,16 @@ jobs:
         config:
           - {r: 'release'}
 
-    env:
-      _R_CHECK_EXAMPLE_TIMING_CPU_TO_ELAPSED_THRESHOLD_: 2.5
-      MAKE: "make -j$(nproc)"
-
     steps:
     - uses: actions/checkout@v2
       with:
         submodules: 'true'
 
-    - uses: r-lib/actions/setup-r@v2
+    - uses: r-lib/actions/setup-r@master
       with:
         r-version: ${{ matrix.config.r }}
 
-    - uses: r-lib/actions/setup-tinytex@v2
+    - uses: r-lib/actions/setup-tinytex@master
 
     - name: Install system packages
       run: |
@@ -146,8 +131,8 @@ jobs:
       uses: actions/cache@v2
       with:
         path: ${{ env.R_LIBS_USER }}
-        key: ${{ runner.os }}-r-${{ matrix.config.r }}-5-${{ hashFiles('R-package/DESCRIPTION') }}
-        restore-keys: ${{ runner.os }}-r-${{ matrix.config.r }}-5-${{ hashFiles('R-package/DESCRIPTION') }}
+        key: ${{ runner.os }}-r-${{ matrix.config.r }}-3-${{ hashFiles('R-package/DESCRIPTION') }}
+        restore-keys: ${{ runner.os }}-r-${{ matrix.config.r }}-3-${{ hashFiles('R-package/DESCRIPTION') }}
 
     - name: Install dependencies
       shell: Rscript {0}

.github/workflows/scorecards.yml

@@ -1,54 +0,0 @@
-name: Scorecards supply-chain security
-on:
-  # Only the default branch is supported.
-  branch_protection_rule:
-  schedule:
-    - cron: '17 2 * * 6'
-  push:
-    branches: [ "master" ]
-
-# Declare default permissions as read only.
-permissions: read-all
-
-jobs:
-  analysis:
-    name: Scorecards analysis
-    runs-on: ubuntu-latest
-    permissions:
-      # Needed to upload the results to code-scanning dashboard.
-      security-events: write
-      # Used to receive a badge.
-      id-token: write
-
-    steps:
-      - name: "Checkout code"
-        uses: actions/checkout@a12a3943b4bdde767164f792f33f40b04645d846 # tag=v3.0.0
-        with:
-          persist-credentials: false
-
-      - name: "Run analysis"
-        uses: ossf/scorecard-action@865b4092859256271290c77adbd10a43f4779972 # tag=v2.0.3
-        with:
-          results_file: results.sarif
-          results_format: sarif
-
-          # Publish the results for public repositories to enable scorecard badges. For more details, see
-          # https://github.com/ossf/scorecard-action#publishing-results. 
-          # For private repositories, `publish_results` will automatically be set to `false`, regardless 
-          # of the value entered here.
-          publish_results: true
-
-      # Upload the results as artifacts (optional). Commenting out will disable uploads of run results in SARIF
-      # format to the repository Actions tab.
-      - name: "Upload artifact"
-        uses: actions/upload-artifact@6673cd052c4cd6fcf4b4e6e60ea986c889389535 # tag=v3.0.0
-        with:
-          name: SARIF file
-          path: results.sarif
-          retention-days: 5
-
-      # Upload the results to GitHub's code scanning dashboard.
-      - name: "Upload to code-scanning"
-        uses: github/codeql-action/upload-sarif@5f532563584d71fdef14ee64d17bafb34f751ce5 # tag=v1.0.26
-        with:
-          sarif_file: results.sarif

.gitignore

@@ -52,8 +52,6 @@ Debug
 R-package.Rproj
 *.cache*
 .mypy_cache/
-doxygen
-
 # java
 java/xgboost4j/target
 java/xgboost4j/tmp
@@ -99,11 +97,8 @@ metastore_db
 R-package/src/Makevars
 *.lib
 
-# Visual Studio
-.vs/
-CMakeSettings.json
-*.ilk
-*.pdb
+# Visual Studio Code
+/.vscode/
 
 # IntelliJ/CLion
 .idea
@@ -135,7 +130,4 @@ credentials.csv
 # Visual Studio code + extensions
 .vscode
 .metals
-.bloop
-
-# hypothesis python tests
-.hypothesis
+.bloop

.readthedocs.yaml

@@ -1,35 +0,0 @@
-# .readthedocs.yaml
-# Read the Docs configuration file
-# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
-
-# Required
-version: 2
-
-submodules:
-  include: all
-
-# Set the version of Python and other tools you might need
-build:
-  os: ubuntu-22.04
-  tools:
-    python: "3.8"
-  apt_packages:
-    - graphviz
-    - cmake
-    - g++
-    - doxygen
-    - ninja-build
-
-# Build documentation in the docs/ directory with Sphinx
-sphinx:
-   configuration: doc/conf.py
-
-# If using Sphinx, optionally build your docs in additional formats such as PDF
-formats:
-   - pdf
-
-# Optionally declare the Python requirements required to build your docs
-python:
-  install:
-   - requirements: doc/requirements.txt
-  system_packages: true

CMakeLists.txt

@@ -1,10 +1,9 @@
-cmake_minimum_required(VERSION 3.18 FATAL_ERROR)
-project(xgboost LANGUAGES CXX C VERSION 1.7.6)
+cmake_minimum_required(VERSION 3.14 FATAL_ERROR)
+project(xgboost LANGUAGES CXX C VERSION 1.6.2)
 include(cmake/Utils.cmake)
 list(APPEND CMAKE_MODULE_PATH "${xgboost_SOURCE_DIR}/cmake/modules")
 cmake_policy(SET CMP0022 NEW)
 cmake_policy(SET CMP0079 NEW)
-cmake_policy(SET CMP0076 NEW)
 set(CMAKE_POLICY_DEFAULT_CMP0063 NEW)
 cmake_policy(SET CMP0063 NEW)
 
@@ -67,7 +66,6 @@ address, leak, undefined and thread.")
 ## Plugins
 option(PLUGIN_DENSE_PARSER "Build dense parser plugin" OFF)
 option(PLUGIN_RMM "Build with RAPIDS Memory Manager (RMM)" OFF)
-option(PLUGIN_FEDERATED "Build with Federated Learning" OFF)
 ## TODO: 1. Add check if DPC++ compiler is used for building
 option(PLUGIN_UPDATER_ONEAPI "DPC++ updater" OFF)
 option(ADD_PKGCONFIG "Add xgboost.pc into system." ON)
@@ -118,20 +116,6 @@ endif (BUILD_STATIC_LIB AND (R_LIB OR JVM_BINDINGS))
 if (PLUGIN_RMM AND (NOT BUILD_WITH_CUDA_CUB))
   message(SEND_ERROR "Cannot build with RMM using cub submodule.")
 endif (PLUGIN_RMM AND (NOT BUILD_WITH_CUDA_CUB))
-if (PLUGIN_FEDERATED)
-  if (CMAKE_CROSSCOMPILING)
-    message(SEND_ERROR "Cannot cross compile with federated learning support")
-  endif ()
-  if (BUILD_STATIC_LIB)
-    message(SEND_ERROR "Cannot build static lib with federated learning support")
-  endif ()
-  if (R_LIB OR JVM_BINDINGS)
-    message(SEND_ERROR "Cannot enable federated learning support when R or JVM packages are enabled.")
-  endif ()
-  if (WIN32)
-    message(SEND_ERROR "Federated learning not supported for Windows platform")
-  endif ()
-endif ()
 
 #-- Sanitizer
 if (USE_SANITIZER)
@@ -146,8 +130,8 @@ if (USE_CUDA)
   message(STATUS "Configured CUDA host compiler: ${CMAKE_CUDA_HOST_COMPILER}")
 
   enable_language(CUDA)
-  if (${CMAKE_CUDA_COMPILER_VERSION} VERSION_LESS 11.0)
-    message(FATAL_ERROR "CUDA version must be at least 11.0!")
+  if (${CMAKE_CUDA_COMPILER_VERSION} VERSION_LESS 10.1)
+    message(FATAL_ERROR "CUDA version must be at least 10.1!")
   endif()
   set(GEN_CODE "")
   format_gencode_flags("${GPU_COMPUTE_VER}" GEN_CODE)
@@ -168,30 +152,12 @@ find_package(Threads REQUIRED)
 
 if (USE_OPENMP)
   if (APPLE)
-    find_package(OpenMP)
-    if (NOT OpenMP_FOUND)
-      # Try again with extra path info; required for libomp 15+ from Homebrew
-      execute_process(COMMAND brew --prefix libomp
-                      OUTPUT_VARIABLE HOMEBREW_LIBOMP_PREFIX
-                      OUTPUT_STRIP_TRAILING_WHITESPACE)
-      set(OpenMP_C_FLAGS
-        "-Xpreprocessor -fopenmp -I${HOMEBREW_LIBOMP_PREFIX}/include")
-      set(OpenMP_CXX_FLAGS
-        "-Xpreprocessor -fopenmp -I${HOMEBREW_LIBOMP_PREFIX}/include")
-      set(OpenMP_C_LIB_NAMES omp)
-      set(OpenMP_CXX_LIB_NAMES omp)
-      set(OpenMP_omp_LIBRARY ${HOMEBREW_LIBOMP_PREFIX}/lib/libomp.dylib)
-      find_package(OpenMP REQUIRED)
-    endif ()
-  else ()
-    find_package(OpenMP REQUIRED)
-  endif ()
+    # 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)
-#Add for IBM i
-if (${CMAKE_SYSTEM_NAME} MATCHES "OS400")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")
-  set(CMAKE_CXX_ARCHIVE_CREATE "<CMAKE_AR> -X64 qc <TARGET> <OBJECTS>")
-endif()
 
 if (USE_NCCL)
   find_package(Nccl REQUIRED)

Jenkinsfile

@@ -0,0 +1,453 @@
+#!/usr/bin/groovy
+// -*- mode: groovy -*-
+// Jenkins pipeline
+// See documents at https://jenkins.io/doc/book/pipeline/jenkinsfile/
+
+// Command to run command inside a docker container
+dockerRun = 'tests/ci_build/ci_build.sh'
+
+// Which CUDA version to use when building reference distribution wheel
+ref_cuda_ver = '11.0.3'
+
+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'
+  }
+
+  // Setup common job properties
+  options {
+    ansiColor('xterm')
+    timestamps()
+    timeout(time: 240, unit: 'MINUTES')
+    buildDiscarder(logRotator(numToKeepStr: '10'))
+    preserveStashes()
+  }
+
+  // Build stages
+  stages {
+    stage('Jenkins Linux: Initialize') {
+      agent { label 'job_initializer' }
+      steps {
+        script {
+          def buildNumber = env.BUILD_NUMBER as int
+          if (buildNumber > 1) milestone(buildNumber - 1)
+          milestone(buildNumber)
+
+          checkoutSrcs()
+          commit_id = "${GIT_COMMIT}"
+        }
+        sh 'python3 tests/jenkins_get_approval.py'
+        stash name: 'srcs'
+      }
+    }
+    stage('Jenkins Linux: Build') {
+      agent none
+      steps {
+        script {
+          parallel ([
+            'clang-tidy': { ClangTidy() },
+            'build-cpu': { BuildCPU() },
+            'build-cpu-arm64': { BuildCPUARM64() },
+            'build-cpu-rabit-mock': { BuildCPUMock() },
+            // Build reference, distribution-ready Python wheel with CUDA 11.0
+            // using CentOS 7 image
+            'build-gpu-cuda11.0': { BuildCUDA(cuda_version: '11.0.3', build_rmm: true) },
+            'build-gpu-rpkg': { BuildRPackageWithCUDA(cuda_version: '11.0.3') },
+            'build-jvm-packages-gpu-cuda11.0': { BuildJVMPackagesWithCUDA(spark_version: '3.0.1', cuda_version: '11.0.3') },
+            'build-jvm-packages': { BuildJVMPackages(spark_version: '3.0.1') },
+            'build-jvm-doc': { BuildJVMDoc() }
+          ])
+        }
+      }
+    }
+    stage('Jenkins Linux: Test') {
+      agent none
+      steps {
+        script {
+          parallel ([
+            'test-python-cpu': { TestPythonCPU() },
+            'test-python-cpu-arm64': { TestPythonCPUARM64() },
+            // artifact_cuda_version doesn't apply to RMM tests; RMM tests will always match CUDA version between artifact and host env
+            'test-python-gpu-cuda11.0': { TestPythonGPU(artifact_cuda_version: '11.0.3', host_cuda_version: '11.0.3', test_rmm: true) },
+            'test-python-mgpu-cuda11.0': { TestPythonGPU(artifact_cuda_version: '11.0.3', host_cuda_version: '11.0.3', multi_gpu: true, test_rmm: true) },
+            'test-cpp-gpu-cuda11.0': { TestCppGPU(artifact_cuda_version: '11.0.3', host_cuda_version: '11.0.3', test_rmm: true) },
+            'test-jvm-jdk8': { CrossTestJVMwithJDK(jdk_version: '8', spark_version: '3.0.0') }
+          ])
+        }
+      }
+    }
+    stage('Jenkins Linux: Deploy') {
+      agent none
+      steps {
+        script {
+          parallel ([
+            'deploy-jvm-packages': { DeployJVMPackages(spark_version: '3.0.0') }
+          ])
+        }
+      }
+    }
+  }
+}
+
+// check out source code from git
+def checkoutSrcs() {
+  retry(5) {
+    try {
+      timeout(time: 2, unit: 'MINUTES') {
+        checkout scm
+        sh 'git submodule update --init'
+      }
+    } catch (exc) {
+      deleteDir()
+      error "Failed to fetch source codes"
+    }
+  }
+}
+
+def GetCUDABuildContainerType(cuda_version) {
+  return (cuda_version == ref_cuda_ver) ? 'gpu_build_centos7' : 'gpu_build'
+}
+
+def ClangTidy() {
+  node('linux && cpu_build') {
+    unstash name: 'srcs'
+    echo "Running clang-tidy job..."
+    def container_type = "clang_tidy"
+    def docker_binary = "docker"
+    def dockerArgs = "--build-arg CUDA_VERSION_ARG=11.0.3"
+    sh """
+    ${dockerRun} ${container_type} ${docker_binary} ${dockerArgs} python3 tests/ci_build/tidy.py --cuda-archs 75
+    """
+    deleteDir()
+  }
+}
+
+def BuildCPU() {
+  node('linux && cpu') {
+    unstash name: 'srcs'
+    echo "Build CPU"
+    def container_type = "cpu"
+    def docker_binary = "docker"
+    sh """
+    ${dockerRun} ${container_type} ${docker_binary} 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 -DPLUGIN_DENSE_PARSER=ON
+    ${dockerRun} ${container_type} ${docker_binary} bash -c "cd build && ctest --extra-verbose"
+    """
+    // 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'"
+    sh """
+    ${dockerRun} ${container_type} ${docker_binary} tests/ci_build/build_via_cmake.sh -DUSE_SANITIZER=ON -DENABLED_SANITIZERS="address;leak;undefined" \
+      -DCMAKE_BUILD_TYPE=Debug -DSANITIZER_PATH=/usr/lib/x86_64-linux-gnu/
+    ${docker_extra_params} ${dockerRun} ${container_type} ${docker_binary} bash -c "cd build && ctest --exclude-regex AllTestsInDMLCUnitTests --extra-verbose"
+    """
+
+    stash name: 'xgboost_cli', includes: 'xgboost'
+    deleteDir()
+  }
+}
+
+def BuildCPUARM64() {
+  node('linux && arm64') {
+    unstash name: 'srcs'
+    echo "Build CPU ARM64"
+    def container_type = "aarch64"
+    def docker_binary = "docker"
+    def wheel_tag = "manylinux2014_aarch64"
+    sh """
+    ${dockerRun} ${container_type} ${docker_binary} tests/ci_build/build_via_cmake.sh --conda-env=aarch64_test -DOPEN_MP:BOOL=ON -DHIDE_CXX_SYMBOL=ON
+    ${dockerRun} ${container_type} ${docker_binary} bash -c "cd build && ctest --extra-verbose"
+    ${dockerRun} ${container_type} ${docker_binary} bash -c "cd python-package && rm -rf dist/* && python setup.py bdist_wheel --universal"
+    ${dockerRun} ${container_type} ${docker_binary} python tests/ci_build/rename_whl.py python-package/dist/*.whl ${commit_id} ${wheel_tag}
+    ${dockerRun} ${container_type} ${docker_binary} bash -c "auditwheel repair --plat ${wheel_tag} python-package/dist/*.whl && python tests/ci_build/rename_whl.py wheelhouse/*.whl ${commit_id} ${wheel_tag}"
+    mv -v wheelhouse/*.whl python-package/dist/
+    # Make sure that libgomp.so is vendored in the wheel
+    ${dockerRun} ${container_type} ${docker_binary} bash -c "unzip -l python-package/dist/*.whl | grep libgomp || exit -1"
+    """
+    echo 'Stashing Python wheel...'
+    stash name: "xgboost_whl_arm64_cpu", includes: 'python-package/dist/*.whl'
+    if (env.BRANCH_NAME == 'master' || env.BRANCH_NAME.startsWith('release')) {
+      echo 'Uploading Python wheel...'
+      sh """
+      ${dockerRun} ${container_type} ${docker_binary} bash -c "source activate aarch64_test && python -m awscli s3 cp python-package/dist/*.whl s3://xgboost-nightly-builds/${BRANCH_NAME}/ --acl public-read --no-progress"
+      """
+    }
+    stash name: 'xgboost_cli_arm64', 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 BuildCUDA(args) {
+  node('linux && cpu_build') {
+    unstash name: 'srcs'
+    echo "Build with CUDA ${args.cuda_version}"
+    def container_type = GetCUDABuildContainerType(args.cuda_version)
+    def docker_binary = "docker"
+    def docker_args = "--build-arg CUDA_VERSION_ARG=${args.cuda_version}"
+    def arch_flag = ""
+    if (env.BRANCH_NAME != 'master' && !(env.BRANCH_NAME.startsWith('release'))) {
+      arch_flag = "-DGPU_COMPUTE_VER=75"
+    }
+    def wheel_tag = "manylinux2014_x86_64"
+    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 ${arch_flag}
+    ${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} python tests/ci_build/rename_whl.py python-package/dist/*.whl ${commit_id} ${wheel_tag}
+    """
+    if (args.cuda_version == ref_cuda_ver) {
+      sh """
+      ${dockerRun} auditwheel_x86_64 ${docker_binary} auditwheel repair --plat ${wheel_tag} python-package/dist/*.whl
+      ${dockerRun} ${container_type} ${docker_binary} ${docker_args} python tests/ci_build/rename_whl.py wheelhouse/*.whl ${commit_id} ${wheel_tag}
+      mv -v wheelhouse/*.whl python-package/dist/
+      # Make sure that libgomp.so is vendored in the wheel
+      ${dockerRun} auditwheel_x86_64 ${docker_binary} bash -c "unzip -l python-package/dist/*.whl | grep libgomp  || exit -1"
+      """
+    }
+    echo 'Stashing Python wheel...'
+    stash name: "xgboost_whl_cuda${args.cuda_version}", includes: 'python-package/dist/*.whl'
+    if (args.cuda_version == ref_cuda_ver && (env.BRANCH_NAME == 'master' || env.BRANCH_NAME.startsWith('release'))) {
+      echo 'Uploading Python wheel...'
+      sh """
+      ${dockerRun} ${container_type} ${docker_binary} ${docker_args} python -m awscli s3 cp python-package/dist/*.whl s3://xgboost-nightly-builds/${BRANCH_NAME}/ --acl public-read --no-progress
+      """
+    }
+    echo 'Stashing C++ test executable (testxgboost)...'
+    stash name: "xgboost_cpp_tests_cuda${args.cuda_version}", includes: 'build/testxgboost'
+    if (args.build_rmm) {
+      echo "Build with CUDA ${args.cuda_version} and RMM"
+      container_type = "rmm"
+      docker_binary = "docker"
+      docker_args = "--build-arg CUDA_VERSION_ARG=${args.cuda_version}"
+      sh """
+      rm -rf build/
+      ${dockerRun} ${container_type} ${docker_binary} ${docker_args} tests/ci_build/build_via_cmake.sh --conda-env=gpu_test -DUSE_CUDA=ON -DUSE_NCCL=ON -DPLUGIN_RMM=ON -DBUILD_WITH_CUDA_CUB=ON ${arch_flag}
+      ${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} python tests/ci_build/rename_whl.py python-package/dist/*.whl ${commit_id} manylinux2014_x86_64
+      """
+      echo 'Stashing Python wheel...'
+      stash name: "xgboost_whl_rmm_cuda${args.cuda_version}", includes: 'python-package/dist/*.whl'
+      echo 'Stashing C++ test executable (testxgboost)...'
+      stash name: "xgboost_cpp_tests_rmm_cuda${args.cuda_version}", includes: 'build/testxgboost'
+    }
+    deleteDir()
+  }
+}
+
+def BuildRPackageWithCUDA(args) {
+  node('linux && cpu_build') {
+    unstash name: 'srcs'
+    def container_type = 'gpu_build_r_centos7'
+    def docker_binary = "docker"
+    def docker_args = "--build-arg CUDA_VERSION_ARG=${args.cuda_version}"
+    if (env.BRANCH_NAME == 'master' || env.BRANCH_NAME.startsWith('release')) {
+      sh """
+      ${dockerRun} ${container_type} ${docker_binary} ${docker_args} tests/ci_build/build_r_pkg_with_cuda.sh ${commit_id}
+      """
+      echo 'Uploading R tarball...'
+      sh """
+      ${dockerRun} ${container_type} ${docker_binary} ${docker_args} python -m awscli s3 cp xgboost_r_gpu_linux_*.tar.gz s3://xgboost-nightly-builds/${BRANCH_NAME}/ --acl public-read --no-progress
+      """
+    }
+    deleteDir()
+  }
+}
+
+def BuildJVMPackagesWithCUDA(args) {
+  node('linux && mgpu') {
+    unstash name: 'srcs'
+    echo "Build XGBoost4J-Spark with Spark ${args.spark_version}, CUDA ${args.cuda_version}"
+    def container_type = "jvm_gpu_build"
+    def docker_binary = "nvidia-docker"
+    def docker_args = "--build-arg CUDA_VERSION_ARG=${args.cuda_version}"
+    def arch_flag = ""
+    if (env.BRANCH_NAME != 'master' && !(env.BRANCH_NAME.startsWith('release'))) {
+      arch_flag = "-DGPU_COMPUTE_VER=75"
+    }
+    // Use only 4 CPU cores
+    def docker_extra_params = "CI_DOCKER_EXTRA_PARAMS_INIT='--cpuset-cpus 0-3'"
+    sh """
+    ${docker_extra_params} ${dockerRun} ${container_type} ${docker_binary} ${docker_args} tests/ci_build/build_jvm_packages.sh ${args.spark_version} -Duse.cuda=ON $arch_flag
+    """
+    echo "Stashing XGBoost4J JAR with CUDA ${args.cuda_version} ..."
+    stash name: 'xgboost4j_jar_gpu', includes: "jvm-packages/xgboost4j-gpu/target/*.jar,jvm-packages/xgboost4j-spark-gpu/target/*.jar"
+    deleteDir()
+  }
+}
+
+def BuildJVMPackages(args) {
+  node('linux && cpu') {
+    unstash name: 'srcs'
+    echo "Build XGBoost4J-Spark with Spark ${args.spark_version}"
+    def container_type = "jvm"
+    def docker_binary = "docker"
+    // Use only 4 CPU cores
+    def docker_extra_params = "CI_DOCKER_EXTRA_PARAMS_INIT='--cpuset-cpus 0-3'"
+    sh """
+    ${docker_extra_params} ${dockerRun} ${container_type} ${docker_binary} tests/ci_build/build_jvm_packages.sh ${args.spark_version}
+    """
+    echo 'Stashing XGBoost4J JAR...'
+    stash name: 'xgboost4j_jar', includes: "jvm-packages/xgboost4j/target/*.jar,jvm-packages/xgboost4j-spark/target/*.jar,jvm-packages/xgboost4j-example/target/*.jar"
+    deleteDir()
+  }
+}
+
+def BuildJVMDoc() {
+  node('linux && cpu') {
+    unstash name: 'srcs'
+    echo "Building JVM doc..."
+    def container_type = "jvm"
+    def docker_binary = "docker"
+    sh """
+    ${dockerRun} ${container_type} ${docker_binary} tests/ci_build/build_jvm_doc.sh ${BRANCH_NAME}
+    """
+    if (env.BRANCH_NAME == 'master' || env.BRANCH_NAME.startsWith('release')) {
+      echo 'Uploading doc...'
+      sh """
+      ${dockerRun} ${container_type} ${docker_binary} python -m awscli s3 cp jvm-packages/${BRANCH_NAME}.tar.bz2 s3://xgboost-docs/${BRANCH_NAME}.tar.bz2 --acl public-read --no-progress
+      """
+    }
+    deleteDir()
+  }
+}
+
+def TestPythonCPU() {
+  node('linux && cpu') {
+    unstash name: "xgboost_whl_cuda${ref_cuda_ver}"
+    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
+    """
+    deleteDir()
+  }
+}
+
+def TestPythonCPUARM64() {
+  node('linux && arm64') {
+    unstash name: "xgboost_whl_arm64_cpu"
+    unstash name: 'srcs'
+    unstash name: 'xgboost_cli_arm64'
+    echo "Test Python CPU ARM64"
+    def container_type = "aarch64"
+    def docker_binary = "docker"
+    sh """
+    ${dockerRun} ${container_type} ${docker_binary} tests/ci_build/test_python.sh cpu-arm64
+    """
+    deleteDir()
+  }
+}
+
+def TestPythonGPU(args) {
+  def nodeReq = (args.multi_gpu) ? 'linux && mgpu' : 'linux && gpu'
+  def artifact_cuda_version = (args.artifact_cuda_version) ?: ref_cuda_ver
+  node(nodeReq) {
+    unstash name: "xgboost_whl_cuda${artifact_cuda_version}"
+    unstash name: "xgboost_cpp_tests_cuda${artifact_cuda_version}"
+    unstash name: 'srcs'
+    echo "Test Python GPU: CUDA ${args.host_cuda_version}"
+    def container_type = "gpu"
+    def docker_binary = "nvidia-docker"
+    def docker_args = "--build-arg CUDA_VERSION_ARG=${args.host_cuda_version}"
+    def mgpu_indicator = (args.multi_gpu) ? 'mgpu' : 'gpu'
+    // Allocate extra space in /dev/shm to enable NCCL
+    def docker_extra_params = (args.multi_gpu) ? "CI_DOCKER_EXTRA_PARAMS_INIT='--shm-size=4g'" : ''
+    sh "${docker_extra_params} ${dockerRun} ${container_type} ${docker_binary} ${docker_args} tests/ci_build/test_python.sh ${mgpu_indicator}"
+    if (args.test_rmm) {
+      sh "rm -rfv build/ python-package/dist/"
+      unstash name: "xgboost_whl_rmm_cuda${args.host_cuda_version}"
+      unstash name: "xgboost_cpp_tests_rmm_cuda${args.host_cuda_version}"
+      sh "${docker_extra_params} ${dockerRun} ${container_type} ${docker_binary} ${docker_args} tests/ci_build/test_python.sh ${mgpu_indicator} --use-rmm-pool"
+    }
+    deleteDir()
+  }
+}
+
+def TestCppGPU(args) {
+  def nodeReq = 'linux && mgpu'
+  def artifact_cuda_version = (args.artifact_cuda_version) ?: ref_cuda_ver
+  node(nodeReq) {
+    unstash name: "xgboost_cpp_tests_cuda${artifact_cuda_version}"
+    unstash name: 'srcs'
+    echo "Test C++, CUDA ${args.host_cuda_version}, rmm: ${args.test_rmm}"
+    def container_type = "gpu"
+    def docker_binary = "nvidia-docker"
+    def docker_args = "--build-arg CUDA_VERSION_ARG=${args.host_cuda_version}"
+    sh "${dockerRun} ${container_type} ${docker_binary} ${docker_args} build/testxgboost"
+    if (args.test_rmm) {
+      sh "rm -rfv build/"
+      unstash name: "xgboost_cpp_tests_rmm_cuda${args.host_cuda_version}"
+      echo "Test C++, CUDA ${args.host_cuda_version} with RMM"
+      container_type = "rmm"
+      docker_binary = "nvidia-docker"
+      docker_args = "--build-arg CUDA_VERSION_ARG=${args.host_cuda_version}"
+      sh """
+      ${dockerRun} ${container_type} ${docker_binary} ${docker_args} bash -c "source activate gpu_test && build/testxgboost --use-rmm-pool"
+      """
+    }
+    deleteDir()
+  }
+}
+
+def CrossTestJVMwithJDK(args) {
+  node('linux && cpu') {
+    unstash name: 'xgboost4j_jar'
+    unstash name: 'srcs'
+    if (args.spark_version != null) {
+      echo "Test XGBoost4J on a machine with JDK ${args.jdk_version}, Spark ${args.spark_version}"
+    } else {
+      echo "Test XGBoost4J on a machine with JDK ${args.jdk_version}"
+    }
+    def container_type = "jvm_cross"
+    def docker_binary = "docker"
+    def spark_arg = (args.spark_version != null) ? "--build-arg SPARK_VERSION=${args.spark_version}" : ""
+    def docker_args = "--build-arg JDK_VERSION=${args.jdk_version} ${spark_arg}"
+    // Run integration tests only when spark_version is given
+    def docker_extra_params = (args.spark_version != null) ? "CI_DOCKER_EXTRA_PARAMS_INIT='-e RUN_INTEGRATION_TEST=1'" : ""
+    sh """
+    ${docker_extra_params} ${dockerRun} ${container_type} ${docker_binary} ${docker_args} tests/ci_build/test_jvm_cross.sh
+    """
+    deleteDir()
+  }
+}
+
+def 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...'
+      sh """
+      ${dockerRun} jvm_gpu_build docker --build-arg CUDA_VERSION_ARG=11.0.3 tests/ci_build/deploy_jvm_packages.sh ${args.spark_version}
+      """
+    }
+    deleteDir()
+  }
+}

Jenkinsfile-win64

@@ -0,0 +1,163 @@
+#!/usr/bin/groovy
+// -*- mode: groovy -*-
+
+/* 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
+
+  // Setup common job properties
+  options {
+    timestamps()
+    timeout(time: 240, unit: 'MINUTES')
+    buildDiscarder(logRotator(numToKeepStr: '10'))
+    preserveStashes()
+  }
+
+  // Build stages
+  stages {
+    stage('Jenkins Win64: Initialize') {
+      agent { label 'job_initializer' }
+      steps {
+        script {
+          def buildNumber = env.BUILD_NUMBER as int
+          if (buildNumber > 1) milestone(buildNumber - 1)
+          milestone(buildNumber)
+          checkoutSrcs()
+          commit_id = "${GIT_COMMIT}"
+        }
+        sh 'python3 tests/jenkins_get_approval.py'
+        stash name: 'srcs'
+      }
+    }
+    stage('Jenkins Win64: Build') {
+      agent none
+      steps {
+        script {
+          parallel ([
+            'build-win64-cuda11.0': { BuildWin64() },
+            'build-rpkg-win64-cuda11.0': { BuildRPackageWithCUDAWin64() }
+          ])
+        }
+      }
+    }
+    stage('Jenkins Win64: Test') {
+      agent none
+      steps {
+        script {
+          parallel ([
+            'test-win64-cuda11.0': { TestWin64() },
+          ])
+        }
+      }
+    }
+  }
+}
+
+// check out source code from git
+def checkoutSrcs() {
+  retry(5) {
+    try {
+      timeout(time: 2, unit: 'MINUTES') {
+        checkout scm
+        sh 'git submodule update --init'
+      }
+    } catch (exc) {
+      deleteDir()
+      error "Failed to fetch source codes"
+    }
+  }
+}
+
+def BuildWin64() {
+  node('win64 && cuda11_unified') {
+    deleteDir()
+    unstash name: 'srcs'
+    echo "Building XGBoost for Windows AMD64 target..."
+    bat "nvcc --version"
+    def arch_flag = ""
+    if (env.BRANCH_NAME != 'master' && !(env.BRANCH_NAME.startsWith('release'))) {
+      arch_flag = "-DGPU_COMPUTE_VER=75"
+    }
+    bat """
+    mkdir build
+    cd build
+    cmake .. -G"Visual Studio 15 2017 Win64" -DUSE_CUDA=ON -DCMAKE_VERBOSE_MAKEFILE=ON -DGOOGLE_TEST=ON -DUSE_DMLC_GTEST=ON ${arch_flag} -DCMAKE_UNITY_BUILD=ON
+    """
+    bat """
+    cd build
+    "C:\\Program Files (x86)\\Microsoft Visual Studio\\2017\\Community\\MSBuild\\15.0\\Bin\\MSBuild.exe" xgboost.sln /m /p:Configuration=Release /nodeReuse:false
+    """
+    bat """
+    cd python-package
+    conda activate && python setup.py bdist_wheel --universal && for /R %%i in (dist\\*.whl) DO python ../tests/ci_build/rename_whl.py "%%i" ${commit_id} win_amd64
+    """
+    echo "Insert vcomp140.dll (OpenMP runtime) into the wheel..."
+    bat """
+    cd python-package\\dist
+    COPY /B ..\\..\\tests\\ci_build\\insert_vcomp140.py
+    conda activate && python insert_vcomp140.py *.whl
+    """
+    echo 'Stashing Python wheel...'
+    stash name: 'xgboost_whl', includes: 'python-package/dist/*.whl'
+    if (env.BRANCH_NAME == 'master' || env.BRANCH_NAME.startsWith('release')) {
+      echo 'Uploading Python wheel...'
+      path = "${BRANCH_NAME}/"
+      s3Upload bucket: 'xgboost-nightly-builds', path: path, acl: 'PublicRead', workingDir: 'python-package/dist', includePathPattern:'**/*.whl'
+    }
+    echo 'Stashing C++ test executable (testxgboost)...'
+    stash name: 'xgboost_cpp_tests', includes: 'build/testxgboost.exe'
+    stash name: 'xgboost_cli', includes: 'xgboost.exe'
+    deleteDir()
+  }
+}
+
+def BuildRPackageWithCUDAWin64() {
+  node('win64 && cuda11_unified') {
+    deleteDir()
+    unstash name: 'srcs'
+    bat "nvcc --version"
+    if (env.BRANCH_NAME == 'master' || env.BRANCH_NAME.startsWith('release')) {
+      bat """
+      bash tests/ci_build/build_r_pkg_with_cuda_win64.sh ${commit_id}
+      """
+      echo 'Uploading R tarball...'
+      path = "${BRANCH_NAME}/"
+      s3Upload bucket: 'xgboost-nightly-builds', path: path, acl: 'PublicRead', includePathPattern:'xgboost_r_gpu_win64_*.tar.gz'
+    }
+    deleteDir()
+  }
+}
+
+def TestWin64() {
+  node('win64 && cuda11_unified') {
+    deleteDir()
+    unstash name: 'srcs'
+    unstash name: 'xgboost_whl'
+    unstash name: 'xgboost_cli'
+    unstash name: 'xgboost_cpp_tests'
+    echo "Test Win64"
+    bat "nvcc --version"
+    echo "Running C++ tests..."
+    bat "build\\testxgboost.exe"
+    echo "Installing Python dependencies..."
+    def env_name = 'win64_' + UUID.randomUUID().toString().replaceAll('-', '')
+    bat "conda activate && mamba env create -n ${env_name} --file=tests/ci_build/conda_env/win64_test.yml"
+    echo "Installing Python wheel..."
+    bat """
+    conda activate ${env_name} && for /R %%i in (python-package\\dist\\*.whl) DO python -m pip install "%%i"
+    """
+    echo "Running Python tests..."
+    bat "conda activate ${env_name} && python -X faulthandler -m pytest -v -s -rxXs --fulltrace tests\\python"
+    bat """
+    conda activate ${env_name} && python -X faulthandler -m pytest -v -s -rxXs --fulltrace -m "(not slow) and (not mgpu)" tests\\python-gpu
+    """
+    bat "conda env remove --name ${env_name}"
+    deleteDir()
+  }
+}

Makefile

@@ -87,6 +87,22 @@ cover: check
 endif
 
 
+# dask is required to pass, others are not
+# If any of the dask tests failed, contributor won't see the other error.
+mypy:
+	cd python-package; \
+	mypy ./xgboost/dask.py && \
+	mypy ./xgboost/rabit.py && \
+	mypy ./xgboost/tracker.py && \
+	mypy ./xgboost/sklearn.py && \
+	mypy ../demo/guide-python/external_memory.py && \
+	mypy ../demo/guide-python/categorical.py && \
+	mypy ../demo/guide-python/cat_in_the_dat.py && \
+	mypy ../tests/python-gpu/test_gpu_with_dask.py && \
+	mypy ../tests/python/test_data_iterator.py && \
+	mypy ../tests/python-gpu/test_gpu_data_iterator.py  || exit 1; \
+	mypy . || true ;
+
 clean:
 	$(RM) -rf build lib bin *~ */*~ */*/*~ */*/*/*~ */*.o */*/*.o */*/*/*.o #xgboost
 	$(RM) -rf build_tests *.gcov tests/cpp/xgboost_test
@@ -123,8 +139,16 @@ 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
-	cat R-package/src/Makevars.win|sed '2s/.*/PKGROOT=./' > xgboost/src/Makevars.win
+# Configure Makevars.win (Windows-specific Makevars, likely using MinGW)
+	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
 	bash xgboost/remove_warning_suppression_pragma.sh

NEWS.md

@@ -3,264 +3,6 @@ XGBoost Change Log
 
 This file records the changes in xgboost library in reverse chronological order.
 
-## v1.6.1 (2022 May 9)
-This is a patch release for bug fixes and Spark barrier mode support. The R package is unchanged.
-
-### Experimental support for categorical data
-- Fix segfault when the number of samples is smaller than the number of categories. (https://github.com/dmlc/xgboost/pull/7853)
-- Enable partition-based split for all model types. (https://github.com/dmlc/xgboost/pull/7857)
-
-### JVM packages
-We replaced the old parallelism tracker with spark barrier mode to improve the robustness of the JVM package and fix the GPU training pipeline.
-- Fix GPU training pipeline quantile synchronization. (#7823, #7834)
-- Use barrier model in spark package. (https://github.com/dmlc/xgboost/pull/7836, https://github.com/dmlc/xgboost/pull/7840, https://github.com/dmlc/xgboost/pull/7845, https://github.com/dmlc/xgboost/pull/7846)
-- Fix shared object loading on some platforms. (https://github.com/dmlc/xgboost/pull/7844)
-
-## v1.6.0 (2022 Apr 16)
-
-After a long period of development, XGBoost v1.6.0 is packed with many new features and
-improvements. We summarize them in the following sections starting with an introduction to
-some major new features, then moving on to language binding specific changes including new
-features and notable bug fixes for that binding.
-
-### Development of categorical data support
-This version of XGBoost features new improvements and full coverage of experimental
-categorical data support in Python and C package with tree model.  Both `hist`, `approx`
-and `gpu_hist` now support training with categorical data.  Also, partition-based
-categorical split is introduced in this release. This split type is first available in
-LightGBM in the context of gradient boosting. The previous XGBoost release supported one-hot split where the splitting criteria is of form `x \in {c}`, i.e. the categorical feature `x` is tested against a single candidate. The new release allows for more expressive conditions: `x \in S` where the categorical feature `x` is tested against multiple candidates. Moreover, it is now possible to use any tree algorithms (`hist`, `approx`, `gpu_hist`) when creating categorical splits. For more
-information, please see our tutorial on [categorical
-data](https://xgboost.readthedocs.io/en/latest/tutorials/categorical.html), along with
-examples linked on that page. (#7380, #7708, #7695, #7330, #7307, #7322, #7705,
-#7652, #7592, #7666, #7576, #7569, #7529, #7575, #7393, #7465, #7385, #7371, #7745, #7810)
-
-In the future, we will continue to improve categorical data support with new features and
-optimizations. Also, we are looking forward to bringing the feature beyond Python binding,
-contributions and feedback are welcomed! Lastly, as a result of experimental status, the
-behavior might be subject to change, especially the default value of related
-hyper-parameters.
-
-### Experimental support for multi-output model
-
-XGBoost 1.6 features initial support for the multi-output model, which includes
-multi-output regression and multi-label classification. Along with this, the XGBoost
-classifier has proper support for base margin without to need for the user to flatten the
-input. In this initial support, XGBoost builds one model for each target similar to the
-sklearn meta estimator, for more details, please see our [quick
-introduction](https://xgboost.readthedocs.io/en/latest/tutorials/multioutput.html).
-
-(#7365, #7736, #7607, #7574, #7521, #7514, #7456, #7453, #7455, #7434, #7429, #7405, #7381)
-
-### External memory support
-External memory support for both approx and hist tree method is considered feature
-complete in XGBoost 1.6.  Building upon the iterator-based interface introduced in the
-previous version, now both `hist` and `approx` iterates over each batch of data during
-training and prediction.  In previous versions, `hist` concatenates all the batches into
-an internal representation, which is removed in this version.  As a result, users can
-expect higher scalability in terms of data size but might experience lower performance due
-to disk IO. (#7531, #7320, #7638, #7372)
-
-### Rewritten approx
-
-The `approx` tree method is rewritten based on the existing `hist` tree method. The
-rewrite closes the feature gap between `approx` and `hist` and improves the performance.
-Now the behavior of `approx` should be more aligned with `hist` and `gpu_hist`. Here is a
-list of user-visible changes:
-
-- Supports both `max_leaves` and `max_depth`.
-- Supports `grow_policy`.
-- Supports monotonic constraint.
-- Supports feature weights.
-- Use `max_bin` to replace `sketch_eps`.
-- Supports categorical data.
-- Faster performance for many of the datasets.
-- Improved performance and robustness for distributed training.
-- Supports prediction cache.
-- Significantly better performance for external memory when `depthwise` policy is used.
-
-### New serialization format
-Based on the existing JSON serialization format, we introduce UBJSON support as a more
-efficient alternative. Both formats will be available in the future and we plan to
-gradually [phase out](https://github.com/dmlc/xgboost/issues/7547) support for the old
-binary model format.  Users can opt to use the different formats in the serialization
-function by providing the file extension `json` or `ubj`. Also, the `save_raw` function in
-all supported languages bindings gains a new parameter for exporting the model in different
-formats, available options are `json`, `ubj`, and `deprecated`, see document for the
-language binding you are using for details. Lastly, the default internal serialization
-format is set to UBJSON, which affects Python pickle and R RDS. (#7572, #7570, #7358,
-#7571, #7556, #7549, #7416)
-
-### General new features and improvements
-Aside from the major new features mentioned above, some others are summarized here:
-
-* Users can now access the build information of XGBoost binary in Python and C
-  interface. (#7399, #7553)
-* Auto-configuration of `seed_per_iteration` is removed, now distributed training should
-  generate closer results to single node training when sampling is used. (#7009)
-* A new parameter `huber_slope` is introduced for the `Pseudo-Huber` objective.
-* During source build, XGBoost can choose cub in the system path automatically. (#7579)
-* XGBoost now honors the CPU counts from CFS, which is usually set in docker
-  environments. (#7654, #7704)
-* The metric `aucpr` is rewritten for better performance and GPU support. (#7297, #7368)
-* Metric calculation is now performed in double precision. (#7364)
-* XGBoost no longer mutates the global OpenMP thread limit. (#7537, #7519, #7608, #7590,
-  #7589, #7588, #7687)
-* The default behavior of `max_leave` and `max_depth` is now unified (#7302, #7551).
-* CUDA fat binary is now compressed. (#7601)
-* Deterministic result for evaluation metric and linear model. In previous versions of
-  XGBoost, evaluation results might differ slightly for each run due to parallel reduction
-  for floating-point values, which is now addressed. (#7362, #7303, #7316, #7349)
-* XGBoost now uses double for GPU Hist node sum, which improves the accuracy of
-  `gpu_hist`. (#7507)
-
-### Performance improvements
-Most of the performance improvements are integrated into other refactors during feature
-developments. The `approx` should see significant performance gain for many datasets as
-mentioned in the previous section, while the `hist` tree method also enjoys improved
-performance with the removal of the internal `pruner` along with some other
-refactoring. Lastly, `gpu_hist` no longer synchronizes the device during training. (#7737)
-
-### General bug fixes
-This section lists bug fixes that are not specific to any language binding.
-* The `num_parallel_tree` is now a model parameter instead of a training hyper-parameter,
-  which fixes model IO with random forest. (#7751)
-* Fixes in CMake script for exporting configuration. (#7730)
-* XGBoost can now handle unsorted sparse input. This includes text file formats like
-  libsvm and scipy sparse matrix where column index might not be sorted. (#7731)
-* Fix tree param feature type, this affects inputs with the number of columns greater than
-  the maximum value of int32. (#7565)
-* Fix external memory with gpu_hist and subsampling. (#7481)
-* Check the number of trees in inplace predict, this avoids a potential segfault when an
-  incorrect value for `iteration_range` is provided. (#7409)
-* Fix non-stable result in cox regression (#7756)
-
-### Changes in the Python package
-Other than the changes in Dask, the XGBoost Python package gained some new features and
-improvements along with small bug fixes.
-
-* Python 3.7 is required as the lowest Python version. (#7682)
-* Pre-built binary wheel for Apple Silicon. (#7621, #7612, #7747) Apple Silicon users will
-  now be able to run `pip install xgboost` to install XGBoost.
-* MacOS users no longer need to install `libomp` from Homebrew, as the XGBoost wheel now
-  bundles `libomp.dylib` library.
-* There are new parameters for users to specify the custom metric with new
-  behavior. XGBoost can now output transformed prediction values when a custom objective is
-  not supplied.  See our explanation in the
-  [tutorial](https://xgboost.readthedocs.io/en/latest/tutorials/custom_metric_obj.html#reverse-link-function)
-  for details.
-* For the sklearn interface, following the estimator guideline from scikit-learn, all
-  parameters in `fit` that are not related to input data are moved into the constructor
-  and can be set by `set_params`. (#6751, #7420, #7375, #7369)
-* Apache arrow format is now supported, which can bring better performance to users'
-  pipeline (#7512)
-* Pandas nullable types are now supported (#7760)
-* A new function `get_group` is introduced for `DMatrix` to allow users to get the group
-  information in the custom objective function. (#7564)
-* More training parameters are exposed in the sklearn interface instead of relying on the
-  `**kwargs`. (#7629)
-* A new attribute `feature_names_in_` is defined for all sklearn estimators like
-  `XGBRegressor` to follow the convention of sklearn. (#7526)
-* More work on Python type hint. (#7432, #7348, #7338, #7513, #7707)
-* Support the latest pandas Index type. (#7595)
-* Fix for Feature shape mismatch error on s390x platform (#7715)
-* Fix using feature names for constraints with multiple groups (#7711)
-* We clarified the behavior of the callback function when it contains mutable
-  states. (#7685)
-* Lastly, there are some code cleanups and maintenance work. (#7585, #7426, #7634, #7665,
-  #7667, #7377, #7360, #7498, #7438, #7667, #7752, #7749, #7751)
-
-### Changes in the Dask interface
-* Dask module now supports user-supplied host IP and port address of scheduler node.
-  Please see [introduction](https://xgboost.readthedocs.io/en/latest/tutorials/dask.html#troubleshooting) and
-  [API document](https://xgboost.readthedocs.io/en/latest/python/python_api.html#optional-dask-configuration)
-  for reference. (#7645, #7581)
-* Internal `DMatrix` construction in dask now honers thread configuration. (#7337)
-* A fix for `nthread` configuration using the Dask sklearn interface. (#7633)
-* The Dask interface can now handle empty partitions.  An empty partition is different
-  from an empty worker, the latter refers to the case when a worker has no partition of an
-  input dataset, while the former refers to some partitions on a worker that has zero
-  sizes. (#7644, #7510)
-* Scipy sparse matrix is supported as Dask array partition. (#7457)
-* Dask interface is no longer considered experimental. (#7509)
-
-### Changes in the R package
-This section summarizes the new features, improvements, and bug fixes to the R package.
-
-* `load.raw` can optionally construct a booster as return. (#7686)
-* Fix parsing decision stump, which affects both transforming text representation to data
-  table and plotting. (#7689)
-* Implement feature weights. (#7660)
-* Some improvements for complying the CRAN release policy. (#7672, #7661, #7763)
-* Support CSR data for predictions (#7615)
-* Document update (#7263, #7606)
-* New maintainer for the CRAN package (#7691, #7649)
-* Handle non-standard installation of toolchain on macos (#7759)
-
-### Changes in JVM-packages
-Some new features for JVM-packages are introduced for a more integrated GPU pipeline and
-better compatibility with musl-based Linux. Aside from this, we have a few notable bug
-fixes.
-
-* User can specify the tracker IP address for training, which helps running XGBoost on
-  restricted network environments. (#7808)
-* Add support for detecting musl-based Linux (#7624)
-* Add `DeviceQuantileDMatrix` to Scala binding (#7459)
-* Add Rapids plugin support, now more of the JVM pipeline can be accelerated by RAPIDS (#7491, #7779, #7793, #7806)
-* The setters for CPU and GPU are more aligned (#7692, #7798)
-* Control logging for early stopping (#7326)
-* Do not repartition when nWorker = 1 (#7676)
-* Fix the prediction issue for `multi:softmax` (#7694)
-* Fix for serialization of custom objective and eval (#7274)
-* Update documentation about Python tracker (#7396)
-* Remove jackson from dependency, which fixes CVE-2020-36518. (#7791)
-* Some refactoring to the training pipeline for better compatibility between CPU and
-  GPU. (#7440, #7401, #7789, #7784)
-* Maintenance work. (#7550, #7335, #7641, #7523, #6792, #4676)
-
-### Deprecation
-Other than the changes in the Python package and serialization, we removed some deprecated
-features in previous releases. Also, as mentioned in the previous section, we plan to
-phase out the old binary format in future releases.
-
-* Remove old warning in 1.3 (#7279)
-* Remove label encoder deprecated in 1.3. (#7357)
-* Remove old callback deprecated in 1.3. (#7280)
-* Pre-built binary will no longer support deprecated CUDA architectures including sm35 and
-  sm50. Users can continue to use these platforms with source build. (#7767)
-
-### Documentation
-This section lists some of the general changes to XGBoost's document, for language binding
-specific change please visit related sections.
-
-* Document is overhauled to use the new RTD theme, along with integration of Python
-  examples using Sphinx gallery. Also, we replaced most of the hard-coded URLs with sphinx
-  references. (#7347, #7346, #7468, #7522, #7530)
-* Small update along with fixes for broken links, typos, etc. (#7684, #7324, #7334, #7655,
-  #7628, #7623, #7487, #7532, #7500, #7341, #7648, #7311)
-* Update document for GPU. [skip ci] (#7403)
-* Document the status of RTD hosting. (#7353)
-* Update document for building from source. (#7664)
-* Add note about CRAN release [skip ci] (#7395)
-
-### Maintenance
-This is a summary of maintenance work that is not specific to any language binding.
-
-* Add CMake option to use /MD runtime (#7277)
-* Add clang-format configuration. (#7383)
-* Code cleanups (#7539, #7536, #7466, #7499, #7533, #7735, #7722, #7668, #7304, #7293,
-  #7321, #7356, #7345, #7387, #7577, #7548, #7469, #7680, #7433, #7398)
-* Improved tests with better coverage and latest dependency (#7573, #7446, #7650, #7520,
-  #7373, #7723, #7611, #7771)
-* Improved automation of the release process. (#7278, #7332, #7470)
-* Compiler workarounds (#7673)
-* Change shebang used in CLI demo. (#7389)
-* Update affiliation (#7289)
-
-### CI
-Some fixes and update to XGBoost's CI infrastructure. (#7739, #7701, #7382, #7662, #7646,
-#7582, #7407, #7417, #7475, #7474, #7479, #7472, #7626)
-
-
 ## v1.5.0 (2021 Oct 11)
 
 This release comes with many exciting new features and optimizations, along with some bug

R-package/CMakeLists.txt

@@ -31,7 +31,7 @@ if (USE_OPENMP)
 endif (USE_OPENMP)
 set_target_properties(
   xgboost-r PROPERTIES
-  CXX_STANDARD 17
+  CXX_STANDARD 14
   CXX_STANDARD_REQUIRED ON
   POSITION_INDEPENDENT_CODE ON)
 

R-package/DESCRIPTION

@@ -1,8 +1,8 @@
 Package: xgboost
 Type: Package
 Title: Extreme Gradient Boosting
-Version: 1.7.6.1
-Date: 2023-06-16
+Version: 1.6.2.1
+Date: 2022-03-29
 Authors@R: c(
   person("Tianqi", "Chen", role = c("aut"),
          email = "tianqi.tchen@gmail.com"),
@@ -66,6 +66,5 @@ Imports:
     methods,
     data.table (>= 1.9.6),
     jsonlite (>= 1.0),
-RoxygenNote: 7.2.3
-Encoding: UTF-8
-SystemRequirements: GNU make, C++17
+RoxygenNote: 7.1.1
+SystemRequirements: GNU make, C++14

R-package/LICENSE

@@ -1,9 +1,9 @@
-Copyright (c) 2014-2023, Tianqi Chen and XBGoost Contributors
+Copyright (c) 2014 by Tianqi Chen and Contributors 
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
-
+    
    http://www.apache.org/licenses/LICENSE-2.0
 
 Unless required by applicable law or agreed to in writing, software

R-package/R/callbacks.R

@@ -544,11 +544,9 @@ cb.cv.predict <- function(save_models = FALSE) {
 #'
 #' @return
 #' Results are stored in the \code{coefs} element of the closure.
-#' The \code{\link{xgb.gblinear.history}} convenience function provides an easy
-#' way to access it.
+#' The \code{\link{xgb.gblinear.history}} convenience function provides an easy way to access it.
 #' With \code{xgb.train}, it is either a dense of a sparse matrix.
-#' While with \code{xgb.cv}, it is a list (an element per each fold) of such
-#' matrices.
+#' While with \code{xgb.cv}, it is a list (an element per each fold) of such matrices.
 #'
 #' @seealso
 #' \code{\link{callbacks}}, \code{\link{xgb.gblinear.history}}.
@@ -560,7 +558,7 @@ cb.cv.predict <- function(save_models = FALSE) {
 #' # without considering the 2nd order interactions:
 #' x <- model.matrix(Species ~ .^2, iris)[,-1]
 #' colnames(x)
-#' dtrain <- xgb.DMatrix(scale(x), label = 1*(iris$Species == "versicolor"), nthread = 2)
+#' dtrain <- xgb.DMatrix(scale(x), label = 1*(iris$Species == "versicolor"))
 #' param <- list(booster = "gblinear", objective = "reg:logistic", eval_metric = "auc",
 #'               lambda = 0.0003, alpha = 0.0003, nthread = 2)
 #' # For 'shotgun', which is a default linear updater, using high eta values may result in
@@ -585,14 +583,14 @@ cb.cv.predict <- function(save_models = FALSE) {
 #'
 #' # For xgb.cv:
 #' bst <- xgb.cv(param, dtrain, nfold = 5, nrounds = 100, eta = 0.8,
-#'               callbacks = list(cb.gblinear.history()))
+#'              callbacks = list(cb.gblinear.history()))
 #' # coefficients in the CV fold #3
 #' matplot(xgb.gblinear.history(bst)[[3]], type = 'l')
 #'
 #'
 #' #### Multiclass classification:
 #' #
-#' dtrain <- xgb.DMatrix(scale(x), label = as.numeric(iris$Species) - 1, nthread = 2)
+#' dtrain <- xgb.DMatrix(scale(x), label = as.numeric(iris$Species) - 1)
 #' param <- list(booster = "gblinear", objective = "multi:softprob", num_class = 3,
 #'               lambda = 0.0003, alpha = 0.0003, nthread = 2)
 #' # For the default linear updater 'shotgun' it sometimes is helpful

R-package/R/xgb.Booster.R

@@ -328,9 +328,8 @@ predict.xgb.Booster <- function(object, newdata, missing = NA, outputmargin = FA
                                 predleaf = FALSE, predcontrib = FALSE, approxcontrib = FALSE, predinteraction = FALSE,
                                 reshape = FALSE, training = FALSE, iterationrange = NULL, strict_shape = FALSE, ...) {
   object <- xgb.Booster.complete(object, saveraw = FALSE)
-
   if (!inherits(newdata, "xgb.DMatrix"))
-    newdata <- xgb.DMatrix(newdata, missing = missing, nthread = NVL(object$params[["nthread"]], -1))
+    newdata <- xgb.DMatrix(newdata, missing = missing)
   if (!is.null(object[["feature_names"]]) &&
       !is.null(colnames(newdata)) &&
       !identical(object[["feature_names"]], colnames(newdata)))

R-package/R/xgb.DMatrix.R

@@ -18,7 +18,7 @@
 #'
 #' @examples
 #' data(agaricus.train, package='xgboost')
-#' dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label, nthread = 2))
+#' dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label))
 #' xgb.DMatrix.save(dtrain, 'xgb.DMatrix.data')
 #' dtrain <- xgb.DMatrix('xgb.DMatrix.data')
 #' if (file.exists('xgb.DMatrix.data')) file.remove('xgb.DMatrix.data')
@@ -54,10 +54,7 @@ xgb.DMatrix <- function(data, info = list(), missing = NA, silent = FALSE, nthre
     stop("xgb.DMatrix does not support construction from ", typeof(data))
   }
   dmat <- handle
-  attributes(dmat) <- list(class = "xgb.DMatrix")
-  if (!is.null(cnames)) {
-    setinfo(dmat, "feature_name", cnames)
-  }
+  attributes(dmat) <- list(.Dimnames = list(NULL, cnames), class = "xgb.DMatrix")
 
   info <- append(info, list(...))
   for (i in seq_along(info)) {
@@ -110,7 +107,7 @@ xgb.get.DMatrix <- function(data, label = NULL, missing = NA, weight = NULL, nth
 #' @examples
 #' data(agaricus.train, package='xgboost')
 #' train <- agaricus.train
-#' dtrain <- xgb.DMatrix(train$data, label=train$label, nthread = 2)
+#' dtrain <- xgb.DMatrix(train$data, label=train$label)
 #'
 #' stopifnot(nrow(dtrain) == nrow(train$data))
 #' stopifnot(ncol(dtrain) == ncol(train$data))
@@ -138,7 +135,7 @@ dim.xgb.DMatrix <- function(x) {
 #' @examples
 #' data(agaricus.train, package='xgboost')
 #' train <- agaricus.train
-#' dtrain <- xgb.DMatrix(train$data, label=train$label, nthread = 2)
+#' dtrain <- xgb.DMatrix(train$data, label=train$label)
 #' dimnames(dtrain)
 #' colnames(dtrain)
 #' colnames(dtrain) <- make.names(1:ncol(train$data))
@@ -147,9 +144,7 @@ dim.xgb.DMatrix <- function(x) {
 #' @rdname dimnames.xgb.DMatrix
 #' @export
 dimnames.xgb.DMatrix <- function(x) {
-  fn <- getinfo(x, "feature_name")
-  ## row names is null.
-  list(NULL, fn)
+  attr(x, '.Dimnames')
 }
 
 #' @rdname dimnames.xgb.DMatrix
@@ -160,13 +155,13 @@ dimnames.xgb.DMatrix <- function(x) {
   if (!is.null(value[[1L]]))
     stop("xgb.DMatrix does not have rownames")
   if (is.null(value[[2]])) {
-    setinfo(x, "feature_name", NULL)
+    attr(x, '.Dimnames') <- NULL
     return(x)
   }
-  if (ncol(x) != length(value[[2]])) {
-    stop("can't assign ", length(value[[2]]), " colnames to a ", ncol(x), " column xgb.DMatrix")
-  }
-  setinfo(x, "feature_name", value[[2]])
+  if (ncol(x) != length(value[[2]]))
+    stop("can't assign ", length(value[[2]]), " colnames to a ",
+         ncol(x), " column xgb.DMatrix")
+  attr(x, '.Dimnames') <- value
   x
 }
 
@@ -193,7 +188,7 @@ dimnames.xgb.DMatrix <- function(x) {
 #'
 #' @examples
 #' data(agaricus.train, package='xgboost')
-#' dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label, nthread = 2))
+#' dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label))
 #'
 #' labels <- getinfo(dtrain, 'label')
 #' setinfo(dtrain, 'label', 1-labels)
@@ -208,17 +203,13 @@ getinfo <- function(object, ...) UseMethod("getinfo")
 #' @export
 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', "feature_type", "feature_name")) {
-    stop(
-      "getinfo: name must be one of the following\n",
-      "    'label', 'weight', 'base_margin', 'nrow', 'label_lower_bound', 'label_upper_bound', 'feature_type', 'feature_name'"
-    )
+      length(name) != 1 ||
+      !name %in% c('label', 'weight', 'base_margin', 'nrow',
+                   'label_lower_bound', 'label_upper_bound')) {
+    stop("getinfo: name must be one of the following\n",
+         "    'label', 'weight', 'base_margin', 'nrow', 'label_lower_bound', 'label_upper_bound'")
   }
-  if (name == "feature_name" || name == "feature_type") {
-    ret <- .Call(XGDMatrixGetStrFeatureInfo_R, object, name)
-  } else if (name != "nrow"){
+  if (name != "nrow"){
     ret <- .Call(XGDMatrixGetInfo_R, object, name)
   } else {
     ret <- nrow(object)
@@ -249,7 +240,7 @@ getinfo.xgb.DMatrix <- function(object, name, ...) {
 #'
 #' @examples
 #' data(agaricus.train, package='xgboost')
-#' dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label, nthread = 2))
+#' dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label))
 #'
 #' labels <- getinfo(dtrain, 'label')
 #' setinfo(dtrain, 'label', 1-labels)
@@ -303,30 +294,6 @@ setinfo.xgb.DMatrix <- function(object, name, info, ...) {
     .Call(XGDMatrixSetInfo_R, object, name, as.numeric(info))
     return(TRUE)
   }
-
-  set_feat_info <- function(name) {
-    msg <- sprintf(
-      "The number of %s must equal to the number of columns in the input data. %s vs. %s",
-      name,
-      length(info),
-      ncol(object)
-    )
-    if (!is.null(info)) {
-      info <- as.list(info)
-      if (length(info) != ncol(object)) {
-        stop(msg)
-      }
-    }
-    .Call(XGDMatrixSetStrFeatureInfo_R, object, name, info)
-  }
-  if (name == "feature_name") {
-    set_feat_info("feature_name")
-    return(TRUE)
-  }
-  if (name == "feature_type") {
-    set_feat_info("feature_type")
-    return(TRUE)
-  }
   stop("setinfo: unknown info name ", name)
   return(FALSE)
 }
@@ -345,7 +312,7 @@ setinfo.xgb.DMatrix <- function(object, name, info, ...) {
 #'
 #' @examples
 #' data(agaricus.train, package='xgboost')
-#' dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label, nthread = 2))
+#' dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label))
 #'
 #' dsub <- slice(dtrain, 1:42)
 #' labels1 <- getinfo(dsub, 'label')
@@ -401,7 +368,7 @@ slice.xgb.DMatrix <- function(object, idxset, ...) {
 #'
 #' @examples
 #' data(agaricus.train, package='xgboost')
-#' dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label, nthread = 2))
+#' dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label))
 #'
 #' dtrain
 #' print(dtrain, verbose=TRUE)

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

@@ -7,7 +7,7 @@
 #'
 #' @examples
 #' data(agaricus.train, package='xgboost')
-#' dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label, nthread = 2))
+#' dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label))
 #' xgb.DMatrix.save(dtrain, 'xgb.DMatrix.data')
 #' dtrain <- xgb.DMatrix('xgb.DMatrix.data')
 #' if (file.exists('xgb.DMatrix.data')) file.remove('xgb.DMatrix.data')

R-package/R/xgb.create.features.R

@@ -48,8 +48,8 @@
 #' @examples
 #' data(agaricus.train, package='xgboost')
 #' data(agaricus.test, package='xgboost')
-#' dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label, nthread = 2))
-#' dtest <- with(agaricus.test, xgb.DMatrix(data, label = label, nthread = 2))
+#' dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label))
+#' dtest <- with(agaricus.test, xgb.DMatrix(data, label = label))
 #'
 #' param <- list(max_depth=2, eta=1, silent=1, objective='binary:logistic')
 #' nrounds = 4
@@ -65,12 +65,8 @@
 #' new.features.test <- xgb.create.features(model = bst, agaricus.test$data)
 #'
 #' # learning with new features
-#' new.dtrain <- xgb.DMatrix(
-#'   data = new.features.train, label = agaricus.train$label, nthread = 2
-#' )
-#' new.dtest <- xgb.DMatrix(
-#'   data = new.features.test, label = agaricus.test$label, nthread = 2
-#' )
+#' new.dtrain <- xgb.DMatrix(data = new.features.train, label = agaricus.train$label)
+#' new.dtest <- xgb.DMatrix(data = new.features.test, label = agaricus.test$label)
 #' watchlist <- list(train = new.dtrain)
 #' bst <- xgb.train(params = param, data = new.dtrain, nrounds = nrounds, nthread = 2)
 #'
@@ -83,7 +79,7 @@
 #'           accuracy.after, "!\n"))
 #'
 #' @export
-xgb.create.features <- function(model, data, ...) {
+xgb.create.features <- function(model, data, ...){
   check.deprecation(...)
   pred_with_leaf <- predict(model, data, predleaf = TRUE)
   cols <- lapply(as.data.frame(pred_with_leaf), factor)

R-package/R/xgb.cv.R

@@ -110,9 +110,9 @@
 #'
 #' @examples
 #' data(agaricus.train, package='xgboost')
-#' dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label, nthread = 2))
+#' dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label))
 #' cv <- xgb.cv(data = dtrain, nrounds = 3, nthread = 2, nfold = 5, metrics = list("rmse","auc"),
-#'              max_depth = 3, eta = 1, objective = "binary:logistic")
+#'                   max_depth = 3, eta = 1, objective = "binary:logistic")
 #' print(cv)
 #' print(cv, verbose=TRUE)
 #'
@@ -192,7 +192,7 @@ xgb.cv <- function(params=list(), data, nrounds, nfold, label = NULL, missing =
 
   # create the booster-folds
   # train_folds
-  dall <- xgb.get.DMatrix(data, label, missing, nthread = params$nthread)
+  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

R-package/R/xgb.plot.multi.trees.R

@@ -62,9 +62,6 @@
 #' @export
 xgb.plot.multi.trees <- function(model, feature_names = NULL, features_keep = 5, plot_width = NULL, plot_height = NULL,
                                  render = TRUE, ...){
-  if (!requireNamespace("DiagrammeR", quietly = TRUE)) {
-    stop("DiagrammeR is required for xgb.plot.multi.trees")
-  }
   check.deprecation(...)
   tree.matrix <- xgb.model.dt.tree(feature_names = feature_names, model = model)
 

R-package/R/xgb.plot.tree.R

@@ -34,7 +34,7 @@
 #' The branches that also used for missing values are marked as bold
 #' (as in "carrying extra capacity").
 #'
-#' This function uses \href{https://www.graphviz.org/}{GraphViz} as a backend of DiagrammeR.
+#' This function uses \href{http://www.graphviz.org/}{GraphViz} as a backend of DiagrammeR.
 #'
 #' @return
 #'

R-package/R/xgb.train.R

@@ -192,8 +192,8 @@
 #' data(agaricus.train, package='xgboost')
 #' data(agaricus.test, package='xgboost')
 #'
-#' dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label, nthread = 2))
-#' dtest <- with(agaricus.test, xgb.DMatrix(data, label = label, nthread = 2))
+#' dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label))
+#' dtest <- with(agaricus.test, xgb.DMatrix(data, label = label))
 #' watchlist <- list(train = dtrain, eval = dtest)
 #'
 #' ## A simple xgb.train example:

R-package/configure.ac

@@ -2,25 +2,10 @@
 
 AC_PREREQ(2.69)
 
-AC_INIT([xgboost],[1.7.6],[],[xgboost],[])
+AC_INIT([xgboost],[1.6-0],[],[xgboost],[])
 
-: ${R_HOME=`R RHOME`}
-if test -z "${R_HOME}"; then
-  echo "could not determine R_HOME"
-  exit 1
-fi
-
-CXX17=`"${R_HOME}/bin/R" CMD config CXX17`
-CXX17STD=`"${R_HOME}/bin/R" CMD config CXX17STD`
-CXX="${CXX17} ${CXX17STD}"
-CXXFLAGS=`"${R_HOME}/bin/R" CMD config CXXFLAGS`
-
-CC=`"${R_HOME}/bin/R" CMD config CC`
-CFLAGS=`"${R_HOME}/bin/R" CMD config CFLAGS`
-CPPFLAGS=`"${R_HOME}/bin/R" CMD config CPPFLAGS`
-
-LDFLAGS=`"${R_HOME}/bin/R" CMD config LDFLAGS`
-AC_LANG(C++)
+# 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])
@@ -43,19 +28,12 @@ fi
 
 if test `uname -s` = "Darwin"
 then
-  if command -v brew &> /dev/null
-  then
-    HOMEBREW_LIBOMP_PREFIX=`brew --prefix libomp`
-  else
-    # Homebrew not found
-    HOMEBREW_LIBOMP_PREFIX=''
-  fi
-  OPENMP_CXXFLAGS="-Xpreprocessor -fopenmp -I${HOMEBREW_LIBOMP_PREFIX}/include"
-  OPENMP_LIB="-lomp -L${HOMEBREW_LIBOMP_PREFIX}/lib"
+  OPENMP_CXXFLAGS='-Xclang -fopenmp'
+  OPENMP_LIB='-lomp'
   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); ]])])
-  ${CXX} -o conftest conftest.cpp ${CPPFLAGS} ${LDFLAGS} ${OPENMP_LIB} ${OPENMP_CXXFLAGS} 2>/dev/null && ./conftest && ac_pkg_openmp=yes
+  ${CC} -o conftest conftest.c ${CPPFLAGS} ${LDFLAGS} ${OPENMP_LIB} ${OPENMP_CXXFLAGS} 2>/dev/null && ./conftest && ac_pkg_openmp=yes
   AC_MSG_RESULT([${ac_pkg_openmp}])
   if test "${ac_pkg_openmp}" = no; then
     OPENMP_CXXFLAGS=''

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

@@ -15,11 +15,9 @@ selected per iteration.}
 }
 \value{
 Results are stored in the \code{coefs} element of the closure.
-The \code{\link{xgb.gblinear.history}} convenience function provides an easy
-way to access it.
+The \code{\link{xgb.gblinear.history}} convenience function provides an easy way to access it.
 With \code{xgb.train}, it is either a dense of a sparse matrix.
-While with \code{xgb.cv}, it is a list (an element per each fold) of such
-matrices.
+While with \code{xgb.cv}, it is a list (an element per each fold) of such matrices.
 }
 \description{
 Callback closure for collecting the model coefficients history of a gblinear booster
@@ -40,7 +38,7 @@ Callback function expects the following values to be set in its calling frame:
 # without considering the 2nd order interactions:
 x <- model.matrix(Species ~ .^2, iris)[,-1]
 colnames(x)
-dtrain <- xgb.DMatrix(scale(x), label = 1*(iris$Species == "versicolor"), nthread = 2)
+dtrain <- xgb.DMatrix(scale(x), label = 1*(iris$Species == "versicolor"))
 param <- list(booster = "gblinear", objective = "reg:logistic", eval_metric = "auc",
               lambda = 0.0003, alpha = 0.0003, nthread = 2)
 # For 'shotgun', which is a default linear updater, using high eta values may result in
@@ -65,14 +63,14 @@ matplot(xgb.gblinear.history(bst), type = 'l')
 
 # For xgb.cv:
 bst <- xgb.cv(param, dtrain, nfold = 5, nrounds = 100, eta = 0.8,
-              callbacks = list(cb.gblinear.history()))
+             callbacks = list(cb.gblinear.history()))
 # coefficients in the CV fold #3
 matplot(xgb.gblinear.history(bst)[[3]], type = 'l')
 
 
 #### Multiclass classification:
 #
-dtrain <- xgb.DMatrix(scale(x), label = as.numeric(iris$Species) - 1, nthread = 2)
+dtrain <- xgb.DMatrix(scale(x), label = as.numeric(iris$Species) - 1)
 param <- list(booster = "gblinear", objective = "multi:softprob", num_class = 3,
               lambda = 0.0003, alpha = 0.0003, nthread = 2)
 # For the default linear updater 'shotgun' it sometimes is helpful

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

@@ -19,7 +19,7 @@ be directly used with an \code{xgb.DMatrix} object.
 \examples{
 data(agaricus.train, package='xgboost')
 train <- agaricus.train
-dtrain <- xgb.DMatrix(train$data, label=train$label, nthread = 2)
+dtrain <- xgb.DMatrix(train$data, label=train$label)
 
 stopifnot(nrow(dtrain) == nrow(train$data))
 stopifnot(ncol(dtrain) == ncol(train$data))

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

@@ -26,7 +26,7 @@ Since row names are irrelevant, it is recommended to use \code{colnames} directl
 \examples{
 data(agaricus.train, package='xgboost')
 train <- agaricus.train
-dtrain <- xgb.DMatrix(train$data, label=train$label, nthread = 2)
+dtrain <- xgb.DMatrix(train$data, label=train$label)
 dimnames(dtrain)
 colnames(dtrain)
 colnames(dtrain) <- make.names(1:ncol(train$data))

R-package/man/getinfo.Rd

@@ -34,7 +34,7 @@ The \code{name} field can be one of the following:
 }
 \examples{
 data(agaricus.train, package='xgboost')
-dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label, nthread = 2))
+dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label))
 
 labels <- getinfo(dtrain, 'label')
 setinfo(dtrain, 'label', 1-labels)

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

@@ -19,7 +19,7 @@ Currently it displays dimensions and presence of info-fields and colnames.
 }
 \examples{
 data(agaricus.train, package='xgboost')
-dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label, nthread = 2))
+dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label))
 
 dtrain
 print(dtrain, verbose=TRUE)

R-package/man/setinfo.Rd

@@ -33,7 +33,7 @@ The \code{name} field can be one of the following:
 }
 \examples{
 data(agaricus.train, package='xgboost')
-dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label, nthread = 2))
+dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label))
 
 labels <- getinfo(dtrain, 'label')
 setinfo(dtrain, 'label', 1-labels)

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

@@ -28,7 +28,7 @@ original xgb.DMatrix object
 }
 \examples{
 data(agaricus.train, package='xgboost')
-dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label, nthread = 2))
+dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label))
 
 dsub <- slice(dtrain, 1:42)
 labels1 <- getinfo(dsub, 'label')

R-package/man/xgb.DMatrix.Rd

@@ -38,7 +38,7 @@ Supported input file formats are either a LIBSVM text file or a binary file that
 }
 \examples{
 data(agaricus.train, package='xgboost')
-dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label, nthread = 2))
+dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label))
 xgb.DMatrix.save(dtrain, 'xgb.DMatrix.data')
 dtrain <- xgb.DMatrix('xgb.DMatrix.data')
 if (file.exists('xgb.DMatrix.data')) file.remove('xgb.DMatrix.data')

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

@@ -16,7 +16,7 @@ Save xgb.DMatrix object to binary file
 }
 \examples{
 data(agaricus.train, package='xgboost')
-dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label, nthread = 2))
+dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label))
 xgb.DMatrix.save(dtrain, 'xgb.DMatrix.data')
 dtrain <- xgb.DMatrix('xgb.DMatrix.data')
 if (file.exists('xgb.DMatrix.data')) file.remove('xgb.DMatrix.data')

R-package/man/xgb.create.features.Rd

@@ -59,8 +59,8 @@ a rule on certain features."
 \examples{
 data(agaricus.train, package='xgboost')
 data(agaricus.test, package='xgboost')
-dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label, nthread = 2))
-dtest <- with(agaricus.test, xgb.DMatrix(data, label = label, nthread = 2))
+dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label))
+dtest <- with(agaricus.test, xgb.DMatrix(data, label = label))
 
 param <- list(max_depth=2, eta=1, silent=1, objective='binary:logistic')
 nrounds = 4
@@ -76,12 +76,8 @@ new.features.train <- xgb.create.features(model = bst, agaricus.train$data)
 new.features.test <- xgb.create.features(model = bst, agaricus.test$data)
 
 # learning with new features
-new.dtrain <- xgb.DMatrix(
-  data = new.features.train, label = agaricus.train$label, nthread = 2
-)
-new.dtest <- xgb.DMatrix(
-  data = new.features.test, label = agaricus.test$label, nthread = 2
-)
+new.dtrain <- xgb.DMatrix(data = new.features.train, label = agaricus.train$label)
+new.dtest <- xgb.DMatrix(data = new.features.test, label = agaricus.test$label)
 watchlist <- list(train = new.dtrain)
 bst <- xgb.train(params = param, data = new.dtrain, nrounds = nrounds, nthread = 2)
 

R-package/man/xgb.cv.Rd

@@ -158,9 +158,9 @@ Adapted from \url{https://en.wikipedia.org/wiki/Cross-validation_\%28statistics\
 }
 \examples{
 data(agaricus.train, package='xgboost')
-dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label, nthread = 2))
+dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label))
 cv <- xgb.cv(data = dtrain, nrounds = 3, nthread = 2, nfold = 5, metrics = list("rmse","auc"),
-             max_depth = 3, eta = 1, objective = "binary:logistic")
+                  max_depth = 3, eta = 1, objective = "binary:logistic")
 print(cv)
 print(cv, verbose=TRUE)
 

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

@@ -67,7 +67,7 @@ The "Yes" branches are marked by the "< split_value" label.
 The branches that also used for missing values are marked as bold
 (as in "carrying extra capacity").
 
-This function uses \href{https://www.graphviz.org/}{GraphViz} as a backend of DiagrammeR.
+This function uses \href{http://www.graphviz.org/}{GraphViz} as a backend of DiagrammeR.
 }
 \examples{
 data(agaricus.train, package='xgboost')

R-package/man/xgb.train.Rd

@@ -241,8 +241,8 @@ The following callbacks are automatically created when certain parameters are se
 data(agaricus.train, package='xgboost')
 data(agaricus.test, package='xgboost')
 
-dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label, nthread = 2))
-dtest <- with(agaricus.test, xgb.DMatrix(data, label = label, nthread = 2))
+dtrain <- with(agaricus.train, xgb.DMatrix(data, label = label))
+dtest <- with(agaricus.test, xgb.DMatrix(data, label = label))
 watchlist <- list(train = dtrain, eval = dtest)
 
 ## A simple xgb.train example:

R-package/src/Makevars.in

@@ -3,7 +3,7 @@ PKGROOT=../../
 ENABLE_STD_THREAD=1
 # _*_ mode: Makefile; _*_
 
-CXX_STD = CXX17
+CXX_STD = CXX14
 
 XGB_RFLAGS = -DXGBOOST_STRICT_R_MODE=1 -DDMLC_LOG_BEFORE_THROW=0\
            -DDMLC_ENABLE_STD_THREAD=$(ENABLE_STD_THREAD) -DDMLC_DISABLE_STDIN=1\
@@ -19,77 +19,7 @@ $(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 $(CXX_VISIBILITY)
 PKG_LIBS = @OPENMP_CXXFLAGS@ @OPENMP_LIB@ @ENDIAN_FLAG@ @BACKTRACE_LIB@ -pthread
-
-OBJECTS= \
-    ./xgboost_R.o \
-    ./xgboost_custom.o \
-    ./init.o \
-    $(PKGROOT)/src/metric/metric.o \
-    $(PKGROOT)/src/metric/elementwise_metric.o \
-    $(PKGROOT)/src/metric/multiclass_metric.o \
-    $(PKGROOT)/src/metric/rank_metric.o \
-    $(PKGROOT)/src/metric/auc.o \
-    $(PKGROOT)/src/metric/survival_metric.o \
-    $(PKGROOT)/src/objective/objective.o \
-    $(PKGROOT)/src/objective/regression_obj.o \
-    $(PKGROOT)/src/objective/multiclass_obj.o \
-    $(PKGROOT)/src/objective/rank_obj.o \
-    $(PKGROOT)/src/objective/hinge.o \
-    $(PKGROOT)/src/objective/aft_obj.o \
-    $(PKGROOT)/src/objective/adaptive.o \
-    $(PKGROOT)/src/gbm/gbm.o \
-    $(PKGROOT)/src/gbm/gbtree.o \
-    $(PKGROOT)/src/gbm/gbtree_model.o \
-    $(PKGROOT)/src/gbm/gblinear.o \
-    $(PKGROOT)/src/gbm/gblinear_model.o \
-    $(PKGROOT)/src/data/simple_dmatrix.o \
-    $(PKGROOT)/src/data/data.o \
-    $(PKGROOT)/src/data/sparse_page_raw_format.o \
-    $(PKGROOT)/src/data/ellpack_page.o \
-    $(PKGROOT)/src/data/gradient_index.o \
-    $(PKGROOT)/src/data/gradient_index_page_source.o \
-    $(PKGROOT)/src/data/gradient_index_format.o \
-    $(PKGROOT)/src/data/sparse_page_dmatrix.o \
-    $(PKGROOT)/src/data/proxy_dmatrix.o \
-    $(PKGROOT)/src/data/iterative_dmatrix.o \
-    $(PKGROOT)/src/predictor/predictor.o \
-    $(PKGROOT)/src/predictor/cpu_predictor.o \
-    $(PKGROOT)/src/tree/constraints.o \
-    $(PKGROOT)/src/tree/param.o \
-    $(PKGROOT)/src/tree/tree_model.o \
-    $(PKGROOT)/src/tree/tree_updater.o \
-    $(PKGROOT)/src/tree/updater_approx.o \
-    $(PKGROOT)/src/tree/updater_colmaker.o \
-    $(PKGROOT)/src/tree/updater_prune.o \
-    $(PKGROOT)/src/tree/updater_quantile_hist.o \
-    $(PKGROOT)/src/tree/updater_refresh.o \
-    $(PKGROOT)/src/tree/updater_sync.o \
-    $(PKGROOT)/src/linear/linear_updater.o \
-    $(PKGROOT)/src/linear/updater_coordinate.o \
-    $(PKGROOT)/src/linear/updater_shotgun.o \
-    $(PKGROOT)/src/learner.o \
-    $(PKGROOT)/src/logging.o \
-    $(PKGROOT)/src/global_config.o \
-    $(PKGROOT)/src/collective/communicator.o \
-    $(PKGROOT)/src/collective/socket.o \
-    $(PKGROOT)/src/common/charconv.o \
-    $(PKGROOT)/src/common/column_matrix.o \
-    $(PKGROOT)/src/common/common.o \
-    $(PKGROOT)/src/common/hist_util.o \
-    $(PKGROOT)/src/common/host_device_vector.o \
-    $(PKGROOT)/src/common/io.o \
-    $(PKGROOT)/src/common/json.o \
-    $(PKGROOT)/src/common/numeric.o \
-    $(PKGROOT)/src/common/pseudo_huber.o \
-    $(PKGROOT)/src/common/quantile.o \
-    $(PKGROOT)/src/common/random.o \
-    $(PKGROOT)/src/common/survival_util.o \
-    $(PKGROOT)/src/common/threading_utils.o \
-    $(PKGROOT)/src/common/timer.o \
-    $(PKGROOT)/src/common/version.o \
-    $(PKGROOT)/src/c_api/c_api.o \
-    $(PKGROOT)/src/c_api/c_api_error.o \
-    $(PKGROOT)/amalgamation/dmlc-minimum0.o \
-    $(PKGROOT)/rabit/src/engine.o \
-    $(PKGROOT)/rabit/src/rabit_c_api.o \
-    $(PKGROOT)/rabit/src/allreduce_base.o
+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.o $(PKGROOT)/rabit/src/rabit_c_api.o \
+         $(PKGROOT)/rabit/src/allreduce_base.o

R-package/src/Makevars.win

@@ -1,9 +1,21 @@
 # package root
-PKGROOT=../../
+PKGROOT=./
 ENABLE_STD_THREAD=0
 # _*_ mode: Makefile; _*_
 
-CXX_STD = CXX17
+# This file is only used for Windows compilation from GitHub
+# It will be replaced with Makevars.in for the CRAN version
+.PHONY: all xgblib
+all: $(SHLIB)
+$(SHLIB): xgblib
+xgblib:
+	cp -r ../../src .
+	cp -r ../../rabit .
+	cp -r ../../dmlc-core .
+	cp -r ../../include .
+	cp -r ../../amalgamation .
+
+CXX_STD = CXX14
 
 XGB_RFLAGS = -DXGBOOST_STRICT_R_MODE=1 -DDMLC_LOG_BEFORE_THROW=0\
            -DDMLC_ENABLE_STD_THREAD=$(ENABLE_STD_THREAD) -DDMLC_DISABLE_STDIN=1\
@@ -17,79 +29,11 @@ endif
 $(foreach v, $(XGB_RFLAGS), $(warning $(v)))
 
 PKG_CPPFLAGS=  -I$(PKGROOT)/include -I$(PKGROOT)/dmlc-core/include -I$(PKGROOT)/rabit/include -I$(PKGROOT) $(XGB_RFLAGS)
-PKG_CXXFLAGS= $(SHLIB_OPENMP_CXXFLAGS) -DDMLC_CMAKE_LITTLE_ENDIAN=1 $(SHLIB_PTHREAD_FLAGS) $(CXX_VISIBILITY)
-PKG_LIBS = $(SHLIB_OPENMP_CXXFLAGS)  -DDMLC_CMAKE_LITTLE_ENDIAN=1  $(SHLIB_PTHREAD_FLAGS) -lwsock32 -lws2_32
+PKG_CXXFLAGS= $(SHLIB_OPENMP_CXXFLAGS) $(SHLIB_PTHREAD_FLAGS)
+PKG_LIBS = $(SHLIB_OPENMP_CXXFLAGS) $(SHLIB_PTHREAD_FLAGS)
+OBJECTS= ./xgboost_R.o ./xgboost_custom.o ./xgboost_assert.o ./init.o \
+         $(PKGROOT)/amalgamation/xgboost-all0.o $(PKGROOT)/amalgamation/dmlc-minimum0.o \
+         $(PKGROOT)/rabit/src/engine.o $(PKGROOT)/rabit/src/rabit_c_api.o \
+         $(PKGROOT)/rabit/src/allreduce_base.o
 
-OBJECTS= \
-    ./xgboost_R.o \
-    ./xgboost_custom.o \
-    ./init.o \
-    $(PKGROOT)/src/metric/metric.o \
-    $(PKGROOT)/src/metric/elementwise_metric.o \
-    $(PKGROOT)/src/metric/multiclass_metric.o \
-    $(PKGROOT)/src/metric/rank_metric.o \
-    $(PKGROOT)/src/metric/auc.o \
-    $(PKGROOT)/src/metric/survival_metric.o \
-    $(PKGROOT)/src/objective/objective.o \
-    $(PKGROOT)/src/objective/regression_obj.o \
-    $(PKGROOT)/src/objective/multiclass_obj.o \
-    $(PKGROOT)/src/objective/rank_obj.o \
-    $(PKGROOT)/src/objective/hinge.o \
-    $(PKGROOT)/src/objective/aft_obj.o \
-    $(PKGROOT)/src/objective/adaptive.o \
-    $(PKGROOT)/src/gbm/gbm.o \
-    $(PKGROOT)/src/gbm/gbtree.o \
-    $(PKGROOT)/src/gbm/gbtree_model.o \
-    $(PKGROOT)/src/gbm/gblinear.o \
-    $(PKGROOT)/src/gbm/gblinear_model.o \
-    $(PKGROOT)/src/data/simple_dmatrix.o \
-    $(PKGROOT)/src/data/data.o \
-    $(PKGROOT)/src/data/sparse_page_raw_format.o \
-    $(PKGROOT)/src/data/ellpack_page.o \
-    $(PKGROOT)/src/data/gradient_index.o \
-    $(PKGROOT)/src/data/gradient_index_page_source.o \
-    $(PKGROOT)/src/data/gradient_index_format.o \
-    $(PKGROOT)/src/data/sparse_page_dmatrix.o \
-    $(PKGROOT)/src/data/proxy_dmatrix.o \
-    $(PKGROOT)/src/data/iterative_dmatrix.o \
-    $(PKGROOT)/src/predictor/predictor.o \
-    $(PKGROOT)/src/predictor/cpu_predictor.o \
-    $(PKGROOT)/src/tree/constraints.o \
-    $(PKGROOT)/src/tree/param.o \
-    $(PKGROOT)/src/tree/tree_model.o \
-    $(PKGROOT)/src/tree/tree_updater.o \
-    $(PKGROOT)/src/tree/updater_approx.o \
-    $(PKGROOT)/src/tree/updater_colmaker.o \
-    $(PKGROOT)/src/tree/updater_prune.o \
-    $(PKGROOT)/src/tree/updater_quantile_hist.o \
-    $(PKGROOT)/src/tree/updater_refresh.o \
-    $(PKGROOT)/src/tree/updater_sync.o \
-    $(PKGROOT)/src/linear/linear_updater.o \
-    $(PKGROOT)/src/linear/updater_coordinate.o \
-    $(PKGROOT)/src/linear/updater_shotgun.o \
-    $(PKGROOT)/src/learner.o \
-    $(PKGROOT)/src/logging.o \
-    $(PKGROOT)/src/global_config.o \
-    $(PKGROOT)/src/collective/communicator.o \
-    $(PKGROOT)/src/collective/socket.o \
-    $(PKGROOT)/src/common/charconv.o \
-    $(PKGROOT)/src/common/column_matrix.o \
-    $(PKGROOT)/src/common/common.o \
-    $(PKGROOT)/src/common/hist_util.o \
-    $(PKGROOT)/src/common/host_device_vector.o \
-    $(PKGROOT)/src/common/io.o \
-    $(PKGROOT)/src/common/json.o \
-    $(PKGROOT)/src/common/numeric.o \
-    $(PKGROOT)/src/common/pseudo_huber.o \
-    $(PKGROOT)/src/common/quantile.o \
-    $(PKGROOT)/src/common/random.o \
-    $(PKGROOT)/src/common/survival_util.o \
-    $(PKGROOT)/src/common/threading_utils.o \
-    $(PKGROOT)/src/common/timer.o \
-    $(PKGROOT)/src/common/version.o \
-    $(PKGROOT)/src/c_api/c_api.o \
-    $(PKGROOT)/src/c_api/c_api_error.o \
-    $(PKGROOT)/amalgamation/dmlc-minimum0.o \
-    $(PKGROOT)/rabit/src/engine.o \
-    $(PKGROOT)/rabit/src/rabit_c_api.o \
-    $(PKGROOT)/rabit/src/allreduce_base.o
+$(OBJECTS) : xgblib

R-package/src/init.c

@@ -42,15 +42,13 @@ extern SEXP XGDMatrixCreateFromCSR_R(SEXP, SEXP, SEXP, SEXP, SEXP);
 extern SEXP XGDMatrixCreateFromFile_R(SEXP, SEXP);
 extern SEXP XGDMatrixCreateFromMat_R(SEXP, SEXP, SEXP);
 extern SEXP XGDMatrixGetInfo_R(SEXP, SEXP);
-extern SEXP XGDMatrixGetStrFeatureInfo_R(SEXP, SEXP);
 extern SEXP XGDMatrixNumCol_R(SEXP);
 extern SEXP XGDMatrixNumRow_R(SEXP);
 extern SEXP XGDMatrixSaveBinary_R(SEXP, SEXP, SEXP);
 extern SEXP XGDMatrixSetInfo_R(SEXP, SEXP, SEXP);
-extern SEXP XGDMatrixSetStrFeatureInfo_R(SEXP, SEXP, SEXP);
 extern SEXP XGDMatrixSliceDMatrix_R(SEXP, SEXP);
 extern SEXP XGBSetGlobalConfig_R(SEXP);
-extern SEXP XGBGetGlobalConfig_R(void);
+extern SEXP XGBGetGlobalConfig_R();
 extern SEXP XGBoosterFeatureScore_R(SEXP, SEXP);
 
 static const R_CallMethodDef CallEntries[] = {
@@ -80,12 +78,10 @@ static const R_CallMethodDef CallEntries[] = {
   {"XGDMatrixCreateFromFile_R",   (DL_FUNC) &XGDMatrixCreateFromFile_R,   2},
   {"XGDMatrixCreateFromMat_R",    (DL_FUNC) &XGDMatrixCreateFromMat_R,    3},
   {"XGDMatrixGetInfo_R",          (DL_FUNC) &XGDMatrixGetInfo_R,          2},
-  {"XGDMatrixGetStrFeatureInfo_R", (DL_FUNC) &XGDMatrixGetStrFeatureInfo_R, 2},
   {"XGDMatrixNumCol_R",           (DL_FUNC) &XGDMatrixNumCol_R,           1},
   {"XGDMatrixNumRow_R",           (DL_FUNC) &XGDMatrixNumRow_R,           1},
   {"XGDMatrixSaveBinary_R",       (DL_FUNC) &XGDMatrixSaveBinary_R,       3},
   {"XGDMatrixSetInfo_R",          (DL_FUNC) &XGDMatrixSetInfo_R,          3},
-  {"XGDMatrixSetStrFeatureInfo_R", (DL_FUNC) &XGDMatrixSetStrFeatureInfo_R, 3},
   {"XGDMatrixSliceDMatrix_R",     (DL_FUNC) &XGDMatrixSliceDMatrix_R,     2},
   {"XGBSetGlobalConfig_R",        (DL_FUNC) &XGBSetGlobalConfig_R,        1},
   {"XGBGetGlobalConfig_R",        (DL_FUNC) &XGBGetGlobalConfig_R,        0},

R-package/src/xgboost_R.cc

@@ -249,53 +249,15 @@ XGB_DLL SEXP XGDMatrixSetInfo_R(SEXP handle, SEXP field, SEXP array) {
   return R_NilValue;
 }
 
-XGB_DLL SEXP XGDMatrixSetStrFeatureInfo_R(SEXP handle, SEXP field, SEXP array) {
-  R_API_BEGIN();
-  size_t len{0};
-  if (!isNull(array)) {
-    len = length(array);
-  }
-
-  const char *name = CHAR(asChar(field));
-  std::vector<std::string> str_info;
-  for (size_t i = 0; i < len; ++i) {
-    str_info.emplace_back(CHAR(asChar(VECTOR_ELT(array, i))));
-  }
-  std::vector<char const*> vec(len);
-  std::transform(str_info.cbegin(), str_info.cend(), vec.begin(),
-                 [](std::string const &str) { return str.c_str(); });
-  CHECK_CALL(XGDMatrixSetStrFeatureInfo(R_ExternalPtrAddr(handle), name, vec.data(), len));
-  R_API_END();
-  return R_NilValue;
-}
-
-XGB_DLL SEXP XGDMatrixGetStrFeatureInfo_R(SEXP handle, SEXP field) {
-  SEXP ret;
-  R_API_BEGIN();
-  char const **out_features{nullptr};
-  bst_ulong len{0};
-  const char *name = CHAR(asChar(field));
-  XGDMatrixGetStrFeatureInfo(R_ExternalPtrAddr(handle), name, &len, &out_features);
-
-  if (len > 0) {
-    ret = PROTECT(allocVector(STRSXP, len));
-    for (size_t i = 0; i < len; ++i) {
-      SET_STRING_ELT(ret, i, mkChar(out_features[i]));
-    }
-  } else {
-    ret = PROTECT(R_NilValue);
-  }
-  R_API_END();
-  UNPROTECT(1);
-  return ret;
-}
-
 XGB_DLL SEXP XGDMatrixGetInfo_R(SEXP handle, SEXP field) {
   SEXP ret;
   R_API_BEGIN();
   bst_ulong olen;
   const float *res;
-  CHECK_CALL(XGDMatrixGetFloatInfo(R_ExternalPtrAddr(handle), CHAR(asChar(field)), &olen, &res));
+  CHECK_CALL(XGDMatrixGetFloatInfo(R_ExternalPtrAddr(handle),
+                                   CHAR(asChar(field)),
+                                 &olen,
+                                 &res));
   ret = PROTECT(allocVector(REALSXP, olen));
   for (size_t i = 0; i < olen; ++i) {
     REAL(ret)[i] = res[i];

R-package/src/xgboost_assert.c

@@ -0,0 +1,26 @@
+// Copyright (c) 2014 by Contributors
+#include <stdio.h>
+#include <stdarg.h>
+#include <Rinternals.h>
+
+// implements error handling
+void XGBoostAssert_R(int exp, const char *fmt, ...) {
+  char buf[1024];
+  if (exp == 0) {
+    va_list args;
+    va_start(args, fmt);
+    vsprintf(buf, fmt, args);
+    va_end(args);
+    error("AssertError:%s\n", buf);
+  }
+}
+void XGBoostCheck_R(int exp, const char *fmt, ...) {
+  char buf[1024];
+  if (exp == 0) {
+    va_list args;
+    va_start(args, fmt);
+    vsprintf(buf, fmt, args);
+    va_end(args);
+    error("%s\n", buf);
+  }
+}

R-package/tests/helper_scripts/run_lint.R

@@ -13,7 +13,7 @@ my_linters <- list(
   object_usage_linter = lintr::object_usage_linter,
   object_length_linter = lintr::object_length_linter,
   open_curly_linter = lintr::open_curly_linter,
-  semicolon = lintr::semicolon_terminator_linter(semicolon = c("compound", "trailing")),
+  semicolon = lintr::semicolon_terminator_linter,
   seq = lintr::seq_linter,
   spaces_inside_linter = lintr::spaces_inside_linter,
   spaces_left_parentheses_linter = lintr::spaces_left_parentheses_linter,

R-package/tests/testthat/test_dmatrix.R

@@ -42,20 +42,6 @@ test_that("xgb.DMatrix: saving, loading", {
   dtest4 <- xgb.DMatrix(tmp_file, silent = TRUE)
   expect_equal(dim(dtest4), c(3, 4))
   expect_equal(getinfo(dtest4, 'label'), c(0, 1, 0))
-
-  # check that feature info is saved
-  data(agaricus.train, package = 'xgboost')
-  dtrain <- xgb.DMatrix(data = agaricus.train$data, label = agaricus.train$label)
-  cnames <- colnames(dtrain)
-  expect_equal(length(cnames), 126)
-  tmp_file <- tempfile('xgb.DMatrix_')
-  xgb.DMatrix.save(dtrain, tmp_file)
-  dtrain <- xgb.DMatrix(tmp_file)
-  expect_equal(colnames(dtrain), cnames)
-
-  ft <- rep(c("c", "q"), each=length(cnames)/2)
-  setinfo(dtrain, "feature_type", ft)
-  expect_equal(ft, getinfo(dtrain, "feature_type"))
 })
 
 test_that("xgb.DMatrix: getinfo & setinfo", {

R-package/tests/testthat/test_model_compatibility.R

@@ -77,7 +77,6 @@ test_that("Models from previous versions of XGBoost can be loaded", {
     model_xgb_ver <- m[2]
     name <- m[3]
     is_rds <- endsWith(model_file, '.rds')
-    is_json <- endsWith(model_file, '.json')
 
     cpp_warning <- capture.output({
       # Expect an R warning when a model is loaded from RDS and it was generated by version < 1.1.x
@@ -96,13 +95,15 @@ test_that("Models from previous versions of XGBoost can be loaded", {
         run_booster_check(booster, name)
       }
     })
-    cpp_warning <- paste0(cpp_warning, collapse = ' ')
-    if (is_rds && compareVersion(model_xgb_ver, '1.1.1.1') >= 0) {
-      # Expect a C++ warning when a model is loaded from RDS and it was generated by old XGBoost`
-      m <- grepl(paste0('.*If you are loading a serialized model ',
-                        '\\(like pickle in Python, RDS in R\\).*',
-                        'for more details about differences between ',
-                        'saving model and serializing.*'), cpp_warning, perl = TRUE)
+    if (compareVersion(model_xgb_ver, '1.0.0.0') < 0) {
+      # Expect a C++ warning when a model was generated in version < 1.0.x
+      m <- grepl(paste0('.*Loading model from XGBoost < 1\\.0\\.0, consider saving it again for ',
+                        'improved compatibility.*'), cpp_warning, perl = TRUE)
+      expect_true(length(m) > 0 && all(m))
+    } else if (is_rds && model_xgb_ver == '1.1.1.1') {
+      # Expect a C++ warning when a model is loaded from RDS and it was generated by version 1.1.x
+      m <- grepl(paste0('.*Attempted to load internal configuration for a model file that was ',
+                        'generated by a previous version of XGBoost.*'), cpp_warning, perl = TRUE)
       expect_true(length(m) > 0 && all(m))
     }
   })

README.md

@@ -10,7 +10,6 @@
 [![Conda version](https://img.shields.io/conda/vn/conda-forge/py-xgboost.svg)](https://anaconda.org/conda-forge/py-xgboost)
 [![Optuna](https://img.shields.io/badge/Optuna-integrated-blue)](https://optuna.org)
 [![Twitter](https://img.shields.io/badge/@XGBoostProject--_.svg?style=social&logo=twitter)](https://twitter.com/XGBoostProject)
-[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/dmlc/xgboost/badge)](https://api.securityscorecards.dev/projects/github.com/dmlc/xgboost)
 
 [Community](https://xgboost.ai/community) |
 [Documentation](https://xgboost.readthedocs.org) |
@@ -47,11 +46,24 @@ Become a sponsor and get a logo here. See details at [Sponsoring the XGBoost Pro
 ### Sponsors
 [[Become a sponsor](https://opencollective.com/xgboost#sponsor)]
 
+<!--<a href="https://opencollective.com/xgboost/sponsor/0/website" target="_blank"><img src="https://opencollective.com/xgboost/sponsor/0/avatar.svg"></a>-->
 <a href="https://www.nvidia.com/en-us/" target="_blank"><img src="https://raw.githubusercontent.com/xgboost-ai/xgboost-ai.github.io/master/images/sponsors/nvidia.jpg" alt="NVIDIA" width="72" height="72"></a>
-<a href="https://www.intel.com/" target="_blank"><img src="https://images.opencollective.com/intel-corporation/2fa85c1/logo/256.png" width="72" height="72"></a>
-<a href="https://getkoffie.com/?utm_source=opencollective&utm_medium=github&utm_campaign=xgboost" target="_blank"><img src="https://images.opencollective.com/koffielabs/f391ab8/logo/256.png" width="72" height="72"></a>
+<a href="https://opencollective.com/xgboost/sponsor/1/website" target="_blank"><img src="https://opencollective.com/xgboost/sponsor/1/avatar.svg"></a>
+<a href="https://opencollective.com/xgboost/sponsor/2/website" target="_blank"><img src="https://opencollective.com/xgboost/sponsor/2/avatar.svg"></a>
+<a href="https://opencollective.com/xgboost/sponsor/3/website" target="_blank"><img src="https://opencollective.com/xgboost/sponsor/3/avatar.svg"></a>
+<a href="https://opencollective.com/xgboost/sponsor/4/website" target="_blank"><img src="https://opencollective.com/xgboost/sponsor/4/avatar.svg"></a>
+<a href="https://opencollective.com/xgboost/sponsor/5/website" target="_blank"><img src="https://opencollective.com/xgboost/sponsor/5/avatar.svg"></a>
+<a href="https://opencollective.com/xgboost/sponsor/6/website" target="_blank"><img src="https://opencollective.com/xgboost/sponsor/6/avatar.svg"></a>
+<a href="https://opencollective.com/xgboost/sponsor/7/website" target="_blank"><img src="https://opencollective.com/xgboost/sponsor/7/avatar.svg"></a>
+<a href="https://opencollective.com/xgboost/sponsor/8/website" target="_blank"><img src="https://opencollective.com/xgboost/sponsor/8/avatar.svg"></a>
+<a href="https://opencollective.com/xgboost/sponsor/9/website" target="_blank"><img src="https://opencollective.com/xgboost/sponsor/9/avatar.svg"></a>
 
 ### Backers
 [[Become a backer](https://opencollective.com/xgboost#backer)]
 
 <a href="https://opencollective.com/xgboost#backers" target="_blank"><img src="https://opencollective.com/xgboost/backers.svg?width=890"></a>
+
+## Other sponsors
+The sponsors in this list are donating cloud hours in lieu of cash donation.
+
+<a href="https://aws.amazon.com/" target="_blank"><img src="https://raw.githubusercontent.com/xgboost-ai/xgboost-ai.github.io/master/images/sponsors/aws.png" alt="Amazon Web Services" width="72" height="72"></a>

SECURITY.md

@@ -1,22 +0,0 @@
-# Security Policy
-
-## Supported Versions
-
-<!-- Use this section to tell people about which versions of your project are
-currently being supported with security updates. -->
-Security updates are applied only to the most recent release.
-
-## Reporting a Vulnerability
-
-<!-- Use this section to tell people how to report a vulnerability.
-
-Tell them where to go, how often they can expect to get an update on a
-reported vulnerability, what to expect if the vulnerability is accepted or
-declined, etc. -->
-
-To report a security issue, please email
-[security@xgboost-ci.net](mailto:security@xgboost-ci.net)
-with a description of the issue, the steps you took to create the issue,
-affected versions, and, if known, mitigations for the issue.
-
-All support will be made on the best effort base, so please indicate the "urgency level" of the vulnerability as Critical, High, Medium or Low.

amalgamation/xgboost-all0.cc

@@ -0,0 +1,89 @@
+/*!
+ * Copyright 2015-2019 by Contributors.
+ * \brief XGBoost Amalgamation.
+ *  This offers an alternative way to compile the entire library from this single file.
+ *
+ *  Example usage command.
+ *  - $(CXX) -std=c++0x -fopenmp -o -shared libxgboost.so xgboost-all0.cc -ldmlc -lrabit
+ *
+ * \author Tianqi Chen.
+ */
+
+// metrics
+#include "../src/metric/metric.cc"
+#include "../src/metric/elementwise_metric.cc"
+#include "../src/metric/multiclass_metric.cc"
+#include "../src/metric/rank_metric.cc"
+#include "../src/metric/auc.cc"
+#include "../src/metric/survival_metric.cc"
+
+// objectives
+#include "../src/objective/objective.cc"
+#include "../src/objective/regression_obj.cc"
+#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/simple_dmatrix.cc"
+#include "../src/data/data.cc"
+#include "../src/data/sparse_page_raw_format.cc"
+#include "../src/data/ellpack_page.cc"
+#include "../src/data/gradient_index.cc"
+#include "../src/data/gradient_index_page_source.cc"
+#include "../src/data/gradient_index_format.cc"
+#include "../src/data/sparse_page_dmatrix.cc"
+#include "../src/data/proxy_dmatrix.cc"
+
+// prediction
+#include "../src/predictor/predictor.cc"
+#include "../src/predictor/cpu_predictor.cc"
+
+// trees
+#include "../src/tree/constraints.cc"
+#include "../src/tree/hist/param.cc"
+#include "../src/tree/param.cc"
+#include "../src/tree/tree_model.cc"
+#include "../src/tree/tree_updater.cc"
+#include "../src/tree/updater_approx.cc"
+#include "../src/tree/updater_colmaker.cc"
+#include "../src/tree/updater_histmaker.cc"
+#include "../src/tree/updater_prune.cc"
+#include "../src/tree/updater_quantile_hist.cc"
+#include "../src/tree/updater_refresh.cc"
+#include "../src/tree/updater_sync.cc"
+
+// linear
+#include "../src/linear/linear_updater.cc"
+#include "../src/linear/updater_coordinate.cc"
+#include "../src/linear/updater_shotgun.cc"
+
+// global
+#include "../src/learner.cc"
+#include "../src/logging.cc"
+#include "../src/global_config.cc"
+#include "../src/common/common.cc"
+#include "../src/common/random.cc"
+#include "../src/common/charconv.cc"
+#include "../src/common/timer.cc"
+#include "../src/common/quantile.cc"
+#include "../src/common/host_device_vector.cc"
+#include "../src/common/hist_util.cc"
+#include "../src/common/io.cc"
+#include "../src/common/json.cc"
+#include "../src/common/pseudo_huber.cc"
+#include "../src/common/survival_util.cc"
+#include "../src/common/threading_utils.cc"
+#include "../src/common/version.cc"
+
+// c_api
+#include "../src/c_api/c_api.cc"
+#include "../src/c_api/c_api_error.cc"

cmake/Python_version.in

@@ -1 +1 @@
-@xgboost_VERSION_MAJOR@.@xgboost_VERSION_MINOR@.@xgboost_VERSION_PATCH@
+@xgboost_VERSION_MAJOR@.@xgboost_VERSION_MINOR@.@xgboost_VERSION_PATCH@

cmake/Utils.cmake

@@ -91,21 +91,21 @@ function(format_gencode_flags flags out)
   # Set up architecture flags
   if(NOT flags)
     if (CUDA_VERSION VERSION_GREATER_EQUAL "11.1")
-      set(flags "50;60;70;80")
+      set(flags "52;60;61;70;75;80;86")
     elseif (CUDA_VERSION VERSION_GREATER_EQUAL "11.0")
-      set(flags "50;60;70;80")
+      set(flags "52;60;61;70;75;80")
     elseif(CUDA_VERSION VERSION_GREATER_EQUAL "10.0")
-      set(flags "35;50;60;70")
+      set(flags "35;50;52;60;61;70;75")
     elseif(CUDA_VERSION VERSION_GREATER_EQUAL "9.0")
-      set(flags "35;50;60;70")
+      set(flags "35;50;52;60;61;70")
     else()
-      set(flags "35;50;60")
+      set(flags "35;50;52;60;61")
     endif()
   endif()
 
   if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.18")
     cmake_policy(SET CMP0104 NEW)
-    list(GET flags -1 latest_arch)
+    list(POP_BACK flags latest_arch)
     list(TRANSFORM flags APPEND "-real")
     list(APPEND flags ${latest_arch})
     set(CMAKE_CUDA_ARCHITECTURES ${flags})
@@ -144,15 +144,6 @@ function(xgboost_set_cuda_flags target)
     set_property(TARGET ${target} PROPERTY CUDA_ARCHITECTURES ${CMAKE_CUDA_ARCHITECTURES})
   endif (CMAKE_VERSION VERSION_GREATER_EQUAL "3.18")
 
-  if (FORCE_COLORED_OUTPUT)
-    if (FORCE_COLORED_OUTPUT AND (CMAKE_GENERATOR STREQUAL "Ninja") AND
-        ((CMAKE_CXX_COMPILER_ID STREQUAL "GNU") OR
-          (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")))
-      target_compile_options(${target} PRIVATE
-        $<$<COMPILE_LANGUAGE:CUDA>:-Xcompiler=-fdiagnostics-color=always>)
-    endif()
-  endif (FORCE_COLORED_OUTPUT)
-
   if (USE_DEVICE_DEBUG)
     target_compile_options(${target} PRIVATE
       $<$<AND:$<CONFIG:DEBUG>,$<COMPILE_LANGUAGE:CUDA>>:-G;-src-in-ptx>)
@@ -178,10 +169,17 @@ function(xgboost_set_cuda_flags target)
       $<$<COMPILE_LANGUAGE:CUDA>:-Xcompiler=/utf-8>)
   endif (MSVC)
 
-  set_target_properties(${target} PROPERTIES
-    CUDA_STANDARD 17
-    CUDA_STANDARD_REQUIRED ON
-    CUDA_SEPARABLE_COMPILATION OFF)
+  if (PLUGIN_RMM)
+    set_target_properties(${target} PROPERTIES
+      CUDA_STANDARD 17
+      CUDA_STANDARD_REQUIRED ON
+      CUDA_SEPARABLE_COMPILATION OFF)
+  else ()
+    set_target_properties(${target} PROPERTIES
+      CUDA_STANDARD 14
+      CUDA_STANDARD_REQUIRED ON
+      CUDA_SEPARABLE_COMPILATION OFF)
+  endif (PLUGIN_RMM)
 endfunction(xgboost_set_cuda_flags)
 
 macro(xgboost_link_nccl target)
@@ -198,10 +196,17 @@ endmacro(xgboost_link_nccl)
 
 # compile options
 macro(xgboost_target_properties target)
-  set_target_properties(${target} PROPERTIES
-    CXX_STANDARD 17
-    CXX_STANDARD_REQUIRED ON
-    POSITION_INDEPENDENT_CODE ON)
+  if (PLUGIN_RMM)
+    set_target_properties(${target} PROPERTIES
+      CXX_STANDARD 17
+      CXX_STANDARD_REQUIRED ON
+      POSITION_INDEPENDENT_CODE ON)
+  else ()
+    set_target_properties(${target} PROPERTIES
+      CXX_STANDARD 14
+      CXX_STANDARD_REQUIRED ON
+      POSITION_INDEPENDENT_CODE ON)
+  endif (PLUGIN_RMM)
 
   if (HIDE_CXX_SYMBOLS)
     #-- Hide all C++ symbols
@@ -214,9 +219,7 @@ macro(xgboost_target_properties target)
 
   if (ENABLE_ALL_WARNINGS)
     target_compile_options(${target} PUBLIC
-      $<IF:$<COMPILE_LANGUAGE:CUDA>,
-      -Xcompiler=-Wall -Xcompiler=-Wextra -Xcompiler=-Wno-expansion-to-defined,
-      -Wall -Wextra -Wno-expansion-to-defined>
+      $<IF:$<COMPILE_LANGUAGE:CUDA>,-Xcompiler=-Wall -Xcompiler=-Wextra,-Wall -Wextra>
     )
   endif(ENABLE_ALL_WARNINGS)
 
@@ -230,7 +233,7 @@ macro(xgboost_target_properties target)
       $<$<NOT:$<COMPILE_LANGUAGE:CUDA>>:/utf-8>
       -D_CRT_SECURE_NO_WARNINGS
       -D_CRT_SECURE_NO_DEPRECATE
-    )
+      )
   endif (MSVC)
 
   if (WIN32 AND MINGW)
@@ -300,8 +303,4 @@ macro(xgboost_target_link_libraries target)
   if (RABIT_BUILD_MPI)
     target_link_libraries(${target} PRIVATE MPI::MPI_CXX)
   endif (RABIT_BUILD_MPI)
-
-  if (MINGW)
-    target_link_libraries(${target} PRIVATE wsock32 ws2_32)
-  endif (MINGW)
 endmacro(xgboost_target_link_libraries)

demo/README.md

@@ -78,7 +78,7 @@ XGBoost is extensively used by machine learning practitioners to create state of
 this is a list of machine learning winning solutions with XGBoost.
 Please send pull requests if you find ones that are missing here.
 
-- Bishwarup Bhattacharjee, 1st place winner of [Allstate Claims Severity](https://www.kaggle.com/competitions/allstate-claims-severity/overview) conducted on December 2016. Link to [discussion](https://www.kaggle.com/competitions/allstate-claims-severity/discussion/26416)
+
 - Benedikt Schifferer, Gilberto Titericz, Chris Deotte, Christof Henkel, Kazuki Onodera, Jiwei Liu, Bojan Tunguz, Even Oldridge, Gabriel De Souza Pereira Moreira and Ahmet Erdem, 1st place winner of [Twitter RecSys Challenge 2020](https://recsys-twitter.com/) conducted from June,20-August,20. [GPU Accelerated Feature Engineering and Training for Recommender Systems](https://medium.com/rapids-ai/winning-solution-of-recsys2020-challenge-gpu-accelerated-feature-engineering-and-training-for-cd67c5a87b1f)
 - Eugene Khvedchenya,Jessica Fridrich, Jan Butora, Yassine Yousfi 1st place winner in [ALASKA2 Image Steganalysis](https://www.kaggle.com/c/alaska2-image-steganalysis/overview). Link to [discussion](https://www.kaggle.com/c/alaska2-image-steganalysis/discussion/168546)
 - Dan Ofer, Seffi Cohen, Noa Dagan, Nurit, 1st place in WiDS Datathon 2020. Link to [discussion](https://www.kaggle.com/c/widsdatathon2020/discussion/133189)

demo/aft_survival/README.rst

@@ -1,5 +0,0 @@
-Survival Analysis Walkthrough
-=============================
-
-This is a collection of examples for using the XGBoost Python package for training
-survival models. For an introduction, see :doc:`/tutorials/aft_survival_analysis`

demo/aft_survival/aft_survival_demo.py

@@ -1,10 +1,6 @@
 """
-Demo for survival analysis (regression).
-========================================
-
-Demo for survival analysis (regression). using Accelerated Failure Time (AFT) model.
+Demo for survival analysis (regression) using Accelerated Failure Time (AFT) model
 """
-
 import os
 from sklearn.model_selection import ShuffleSplit
 import pandas as pd

demo/aft_survival/aft_survival_demo_with_optuna.py

@@ -1,10 +1,6 @@
 """
-Demo for survival analysis (regression) with Optuna.
-====================================================
-
-Demo for survival analysis (regression) using Accelerated Failure Time (AFT) model,
-using Optuna to tune hyperparameters
-
+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
@@ -49,7 +45,7 @@ def objective(trial):
     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')],
+                    evals=[(dtrain, 'train'), (dvalid, 'valid')], 
                     early_stopping_rounds=50, verbose_eval=False, callbacks=[pruning_callback])
     if bst.best_iteration >= 25:
         return bst.best_score
@@ -67,7 +63,7 @@ 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')],
+                evals=[(dtrain, 'train'), (dvalid, 'valid')], 
                 early_stopping_rounds=50)
 
 # Run prediction on the validation set

demo/aft_survival/aft_survival_viz_demo.py

@@ -1,10 +1,9 @@
 """
 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.
+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
@@ -58,7 +57,7 @@ def plot_intermediate_model_callback(env):
     #              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)

demo/c-api/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.18)
+cmake_minimum_required(VERSION 3.13)
 project(xgboost-c-examples)
 
 add_subdirectory(basic)

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

@@ -18,7 +18,7 @@ if (err != 0) {                                                         \
 }                                                                       \
 }
 
-int main() {
+int main(int argc, char** argv) {
   int silent = 0;
   int use_gpu = 0;  // set to 1 to use the GPU for training
 
@@ -67,21 +67,10 @@ int main() {
 
   // predict
   bst_ulong out_len = 0;
+  const float* out_result = NULL;
   int n_print = 10;
 
-  /* Run prediction with DMatrix object. */
-  char const config[] =
-      "{\"training\": false, \"type\": 0, "
-      "\"iteration_begin\": 0, \"iteration_end\": 0, \"strict_shape\": false}";
-  /* Shape of output prediction */
-  uint64_t const* out_shape;
-  /* Dimension of output prediction */
-  uint64_t out_dim;
-  /* Pointer to a thread local contigious array, assigned in prediction function. */
-  float const* out_result = NULL;
-  safe_xgboost(
-      XGBoosterPredictFromDMatrix(booster, dtest, config, &out_shape, &out_dim, &out_result));
-
+  safe_xgboost(XGBoosterPredict(booster, dtest, 0, 0, 0, &out_len, &out_result));
   printf("y_pred: ");
   for (int i = 0; i < n_print; ++i) {
     printf("%1.4f ", out_result[i]);
@@ -109,12 +98,12 @@ int main() {
     DMatrixHandle dmat;
     safe_xgboost(XGDMatrixCreateFromMat(values, 1, 127, 0.0, &dmat));
 
+    bst_ulong out_len = 0;
     const float* out_result = NULL;
 
-    safe_xgboost(
-        XGBoosterPredictFromDMatrix(booster, dmat, config, &out_shape, &out_dim, &out_result));
-    assert(out_dim == 1);
-    assert(out_shape[0] == 1);
+    safe_xgboost(XGBoosterPredict(booster, dmat, 0, 0, 0, &out_len,
+          &out_result));
+    assert(out_len == 1);
 
     printf("%1.4f \n", out_result[0]);
     safe_xgboost(XGDMatrixFree(dmat));
@@ -133,12 +122,12 @@ int main() {
     safe_xgboost(XGDMatrixCreateFromCSREx(indptr, indices, data, 2, 22, 127,
       &dmat));
 
+    bst_ulong out_len = 0;
     const float* out_result = NULL;
 
-    safe_xgboost(
-        XGBoosterPredictFromDMatrix(booster, dmat, config, &out_shape, &out_dim, &out_result));
-    assert(out_dim == 1);
-    assert(out_shape[0] == 1);
+    safe_xgboost(XGBoosterPredict(booster, dmat, 0, 0, 0, &out_len,
+          &out_result));
+    assert(out_len == 1);
 
     printf("%1.4f \n", out_result[0]);
     safe_xgboost(XGDMatrixFree(dmat));
@@ -165,12 +154,12 @@ int main() {
     safe_xgboost(XGDMatrixCreateFromCSCEx(col_ptr, indices, data, 128, 22, 1,
       &dmat));
 
+    bst_ulong out_len = 0;
     const float* out_result = NULL;
 
-    safe_xgboost(
-        XGBoosterPredictFromDMatrix(booster, dmat, config, &out_shape, &out_dim, &out_result));
-    assert(out_dim == 1);
-    assert(out_shape[0] == 1);
+    safe_xgboost(XGBoosterPredict(booster, dmat, 0, 0, 0, &out_len,
+          &out_result));
+    assert(out_len == 1);
 
     printf("%1.4f \n", out_result[0]);
     safe_xgboost(XGDMatrixFree(dmat));

demo/c-api/external-memory/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.18)
+cmake_minimum_required(VERSION 3.13)
 project(external-memory-demo LANGUAGES C VERSION 0.0.1)
 
 find_package(xgboost REQUIRED)

demo/c-api/external-memory/external_memory.c

@@ -139,8 +139,8 @@ void TrainModel(DMatrix Xy) {
   Booster booster;
   DMatrix cache[] = {Xy};
   safe_xgboost(XGBoosterCreate(cache, 1, &booster));
-  /* Use approx or hist for external memory training. */
-  safe_xgboost(XGBoosterSetParam(booster, "tree_method", "hist"));
+  /* Use approx for external memory training. */
+  safe_xgboost(XGBoosterSetParam(booster, "tree_method", "approx"));
   safe_xgboost(XGBoosterSetParam(booster, "objective", "reg:squarederror"));
 
   /* Start training. */

demo/c-api/inference/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.18)
+cmake_minimum_required(VERSION 3.13)
 project(inference-demo LANGUAGES C VERSION 0.0.1)
 find_package(xgboost REQUIRED)
 

demo/dask/README.rst

@@ -1,5 +1,3 @@
-.. _dask-examples:
-
 XGBoost Dask Feature Walkthrough
 ================================
 

demo/dask/gpu_training.py

@@ -3,13 +3,13 @@ Example of training with Dask on GPU
 ====================================
 """
 from dask_cuda import LocalCUDACluster
-import dask_cudf
 from dask.distributed import Client
 from dask import array as da
-from dask import dataframe as dd
 import xgboost as xgb
 from xgboost import dask as dxgb
 from xgboost.dask import DaskDMatrix
+import cupy as cp
+import argparse
 
 
 def using_dask_matrix(client: Client, X, y):
@@ -45,12 +45,12 @@ def using_quantile_device_dmatrix(client: Client, X, y):
 
     '''
     # Input must be on GPU for `DaskDeviceQuantileDMatrix`.
-    X = dask_cudf.from_dask_dataframe(dd.from_dask_array(X))
-    y = dask_cudf.from_dask_dataframe(dd.from_dask_array(y))
+    X = X.map_blocks(cp.array)
+    y = y.map_blocks(cp.array)
 
     # `DaskDeviceQuantileDMatrix` is used instead of `DaskDMatrix`, be careful
-    # that it can not be used for anything else other than training.
-    dtrain = dxgb.DaskQuantileDMatrix(client, X, y)
+    # that it can not be used for anything else than training.
+    dtrain = dxgb.DaskDeviceQuantileDMatrix(client, X, y)
     output = xgb.dask.train(client,
                             {'verbosity': 2,
                              'tree_method': 'gpu_hist'},
@@ -62,6 +62,12 @@ def using_quantile_device_dmatrix(client: Client, X, y):
 
 
 if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        '--ddqdm', choices=[0, 1], type=int, default=1,
+        help='''Whether should we use `DaskDeviceQuantileDMatrix`''')
+    args = parser.parse_args()
+
     # `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.
@@ -70,10 +76,12 @@ if __name__ == '__main__':
             # generate some random data for demonstration
             m = 100000
             n = 100
-            X = da.random.random(size=(m, n), chunks=10000)
-            y = da.random.random(size=(m, ), chunks=10000)
+            X = da.random.random(size=(m, n), chunks=100)
+            y = da.random.random(size=(m, ), chunks=100)
 
-            print('Using DaskQuantileDMatrix')
-            from_ddqdm = using_quantile_device_dmatrix(client, X, y)
-            print('Using DMatrix')
-            from_dmatrix = using_dask_matrix(client, X, y)
+            if args.ddqdm == 1:
+                print('Using DaskDeviceQuantileDMatrix')
+                from_ddqdm = using_quantile_device_dmatrix(client, X, y)
+            else:
+                print('Using DMatrix')
+                from_dmatrix = using_dask_matrix(client, X, y)

demo/guide-python/basic_walkthrough.py

@@ -1,65 +1,50 @@
 """
 Getting started with XGBoost
 ============================
-
-This is a simple example of using the native XGBoost interface, there are other
-interfaces in the Python package like scikit-learn interface and Dask interface.
-
-
-See :doc:`/python/python_intro` and :doc:`/tutorials/index` for other references.
-
 """
 import numpy as np
+import scipy.sparse
 import pickle
 import xgboost as xgb
 import os
 
-from sklearn.datasets import load_svmlight_file
-
 # 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")
+DEMO_DIR = os.path.join(XGBOOST_ROOT_DIR, 'demo')
 
-# X is a scipy csr matrix, XGBoost supports many other input types,
-X, y = load_svmlight_file(os.path.join(DEMO_DIR, "data", "agaricus.txt.train"))
-dtrain = xgb.DMatrix(X, y)
-# validation set
-X_test, y_test = load_svmlight_file(os.path.join(DEMO_DIR, "data", "agaricus.txt.test"))
-dtest = xgb.DMatrix(X_test, y_test)
+# 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?indexing_mode=1'))
+dtest = xgb.DMatrix(os.path.join(DEMO_DIR, 'data', 'agaricus.txt.test?indexing_mode=1'))
 
 # 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, 'objective': 'binary:logistic'}
 
 # specify validations set to watch performance
-watchlist = [(dtest, "eval"), (dtrain, "train")]
-# number of boosting rounds
+watchlist = [(dtest, 'eval'), (dtrain, 'train')]
 num_round = 2
-bst = xgb.train(param, dtrain, num_boost_round=num_round, evals=watchlist)
+bst = xgb.train(param, dtrain, num_round, watchlist)
 
-# run prediction
+# 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))
-    )
-)
-bst.save_model("model-0.json")
+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")
+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', os.path.join(DEMO_DIR, 'data/featmap.txt'))
 
 # save dmatrix into binary buffer
-dtest.save_binary("dtest.dmatrix")
+dtest.save_binary('dtest.buffer')
 # save model
-bst.save_model("model-1.json")
+bst.save_model('xgb.model')
 # load model and data in
-bst2 = xgb.Booster(model_file="model-1.json")
-dtest2 = xgb.DMatrix("dtest.dmatrix")
+bst2 = xgb.Booster(model_file='xgb.model')
+dtest2 = xgb.DMatrix('dtest.buffer')
 preds2 = bst2.predict(dtest2)
 # assert they are the same
 assert np.sum(np.abs(preds2 - preds)) == 0
@@ -71,3 +56,40 @@ bst3 = pickle.loads(pks)
 preds3 = bst3.predict(dtest2)
 # assert they are the same
 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 = []
+i = 0
+for l in open(os.path.join(DEMO_DIR, '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))
+    i += 1
+csr = scipy.sparse.csr_matrix((dat, (row, col)))
+dtrain = xgb.DMatrix(csr, label=labels)
+watchlist = [(dtest, 'eval'), (dtrain, 'train')]
+bst = xgb.train(param, dtrain, num_round, watchlist)
+
+print('start running example of build DMatrix from scipy.sparse CSC Matrix')
+# we can also construct from csc matrix
+csc = scipy.sparse.csc_matrix((dat, (row, col)))
+dtrain = xgb.DMatrix(csc, label=labels)
+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
+npymat = csr.todense()
+dtrain = xgb.DMatrix(npymat, label=labels)
+watchlist = [(dtest, 'eval'), (dtrain, 'train')]
+bst = xgb.train(param, dtrain, num_round, watchlist)

demo/guide-python/cat_in_the_dat.py

@@ -19,14 +19,13 @@ Also, see the tutorial for using XGBoost with categorical data:
 """
 
 from __future__ import annotations
-
+from time import time
 import os
 from tempfile import TemporaryDirectory
-from time import time
 
 import pandas as pd
-from sklearn.metrics import roc_auc_score
 from sklearn.model_selection import train_test_split
+from sklearn.metrics import roc_auc_score
 
 import xgboost as xgb
 
@@ -64,6 +63,7 @@ def load_cat_in_the_dat() -> tuple[pd.DataFrame, pd.Series]:
 
 params = {
     "tree_method": "gpu_hist",
+    "use_label_encoder": False,
     "n_estimators": 32,
     "colsample_bylevel": 0.7,
 }

demo/guide-python/categorical.py

@@ -16,12 +16,10 @@ categorical data.
     .. versionadded:: 1.5.0
 
 """
-from typing import Tuple
-
-import numpy as np
 import pandas as pd
-
+import numpy as np
 import xgboost as xgb
+from typing import Tuple
 
 
 def make_categorical(

demo/guide-python/continuation.py

@@ -14,13 +14,13 @@ def training_continuation(tmpdir: str, use_pickle: bool) -> None:
     """Basic training continuation."""
     # Train 128 iterations in 1 session
     X, y = load_breast_cancer(return_X_y=True)
-    clf = xgboost.XGBClassifier(n_estimators=128)
+    clf = xgboost.XGBClassifier(n_estimators=128, use_label_encoder=False)
     clf.fit(X, y, eval_set=[(X, y)], eval_metric="logloss")
     print("Total boosted rounds:", clf.get_booster().num_boosted_rounds())
 
     # Train 128 iterations in 2 sessions, with the first one runs for 32 iterations and
     # the second one runs for 96 iterations
-    clf = xgboost.XGBClassifier(n_estimators=32)
+    clf = xgboost.XGBClassifier(n_estimators=32, use_label_encoder=False)
     clf.fit(X, y, eval_set=[(X, y)], eval_metric="logloss")
     assert clf.get_booster().num_boosted_rounds() == 32
 
@@ -54,14 +54,14 @@ def training_continuation_early_stop(tmpdir: str, use_pickle: bool) -> None:
     n_estimators = 512
 
     X, y = load_breast_cancer(return_X_y=True)
-    clf = xgboost.XGBClassifier(n_estimators=n_estimators)
+    clf = xgboost.XGBClassifier(n_estimators=n_estimators, use_label_encoder=False)
     clf.fit(X, y, eval_set=[(X, y)], eval_metric="logloss", callbacks=[early_stop])
     print("Total boosted rounds:", clf.get_booster().num_boosted_rounds())
     best = clf.best_iteration
 
     # Train 512 iterations in 2 sessions, with the first one runs for 128 iterations and
     # the second one runs until early stop.
-    clf = xgboost.XGBClassifier(n_estimators=128)
+    clf = xgboost.XGBClassifier(n_estimators=128, use_label_encoder=False)
     # Reinitialize the early stop callback
     early_stop = xgboost.callback.EarlyStopping(
         rounds=early_stopping_rounds, save_best=True
@@ -79,13 +79,15 @@ def training_continuation_early_stop(tmpdir: str, use_pickle: bool) -> None:
     else:
         path = os.path.join(tmpdir, "model-first-128.json")
         clf.save_model(path)
-        loaded = xgboost.XGBClassifier()
+        loaded = xgboost.XGBClassifier(use_label_encoder=False)
         loaded.load_model(path)
 
     early_stop = xgboost.callback.EarlyStopping(
         rounds=early_stopping_rounds, save_best=True
     )
-    clf = xgboost.XGBClassifier(n_estimators=n_estimators - 128)
+    clf = xgboost.XGBClassifier(
+        n_estimators=n_estimators - 128, use_label_encoder=False
+    )
     clf.fit(
         X,
         y,

demo/guide-python/predict_first_ntree.py

@@ -35,7 +35,7 @@ def native_interface():
 def sklearn_interface():
     X_train, y_train = load_svmlight_file(train)
     X_test, y_test = load_svmlight_file(test)
-    clf = xgb.XGBClassifier(n_estimators=3, max_depth=2, eta=1)
+    clf = xgb.XGBClassifier(n_estimators=3, max_depth=2, eta=1, use_label_encoder=False)
     clf.fit(X_train, y_train, eval_set=[(X_test, y_test)])
     assert clf.n_classes_ == 2
 

demo/guide-python/sklearn_examples.py

@@ -50,8 +50,8 @@ for train_index, test_index in kf.split(X):
 print("Parameter optimization")
 xgb_model = xgb.XGBRegressor(n_jobs=1)
 clf = GridSearchCV(xgb_model,
-                   {'max_depth': [2, 4],
-                    'n_estimators': [50, 100]}, verbose=1, n_jobs=1, cv=3)
+                   {'max_depth': [2, 4, 6],
+                    'n_estimators': [50, 100, 200]}, verbose=1, n_jobs=1)
 clf.fit(X, y)
 print(clf.best_score_)
 print(clf.best_params_)

demo/guide-python/spark_estimator_examples.py

@@ -1,96 +0,0 @@
-"""
-Collection of examples for using xgboost.spark estimator interface
-==================================================================
-
-@author: Weichen Xu
-"""
-import sklearn.datasets
-from pyspark.ml.evaluation import MulticlassClassificationEvaluator, RegressionEvaluator
-from pyspark.ml.linalg import Vectors
-from pyspark.sql import SparkSession
-from pyspark.sql.functions import rand
-from sklearn.model_selection import train_test_split
-from xgboost.spark import SparkXGBClassifier, SparkXGBRegressor
-
-spark = SparkSession.builder.master("local[*]").getOrCreate()
-
-
-def create_spark_df(X, y):
-    return spark.createDataFrame(
-        spark.sparkContext.parallelize(
-            [(Vectors.dense(features), float(label)) for features, label in zip(X, y)]
-        ),
-        ["features", "label"],
-    )
-
-
-# load diabetes dataset (regression dataset)
-diabetes_X, diabetes_y = sklearn.datasets.load_diabetes(return_X_y=True)
-diabetes_X_train, diabetes_X_test, diabetes_y_train, diabetes_y_test = train_test_split(
-    diabetes_X, diabetes_y, test_size=0.3, shuffle=True
-)
-
-diabetes_train_spark_df = create_spark_df(diabetes_X_train, diabetes_y_train)
-diabetes_test_spark_df = create_spark_df(diabetes_X_test, diabetes_y_test)
-
-# train xgboost regressor model
-xgb_regressor = SparkXGBRegressor(max_depth=5)
-xgb_regressor_model = xgb_regressor.fit(diabetes_train_spark_df)
-
-transformed_diabetes_test_spark_df = xgb_regressor_model.transform(
-    diabetes_test_spark_df
-)
-regressor_evaluator = RegressionEvaluator(metricName="rmse")
-print(
-    f"regressor rmse={regressor_evaluator.evaluate(transformed_diabetes_test_spark_df)}"
-)
-
-diabetes_train_spark_df2 = diabetes_train_spark_df.withColumn(
-    "validationIndicatorCol", rand(1) > 0.7
-)
-
-# train xgboost regressor model with validation dataset
-xgb_regressor2 = SparkXGBRegressor(
-    max_depth=5, validation_indicator_col="validationIndicatorCol"
-)
-xgb_regressor_model2 = xgb_regressor2.fit(diabetes_train_spark_df2)
-transformed_diabetes_test_spark_df2 = xgb_regressor_model2.transform(
-    diabetes_test_spark_df
-)
-print(
-    f"regressor2 rmse={regressor_evaluator.evaluate(transformed_diabetes_test_spark_df2)}"
-)
-
-
-# load iris dataset (classification dataset)
-iris_X, iris_y = sklearn.datasets.load_iris(return_X_y=True)
-iris_X_train, iris_X_test, iris_y_train, iris_y_test = train_test_split(
-    iris_X, iris_y, test_size=0.3, shuffle=True
-)
-
-iris_train_spark_df = create_spark_df(iris_X_train, iris_y_train)
-iris_test_spark_df = create_spark_df(iris_X_test, iris_y_test)
-
-# train xgboost classifier model
-xgb_classifier = SparkXGBClassifier(max_depth=5)
-xgb_classifier_model = xgb_classifier.fit(iris_train_spark_df)
-
-transformed_iris_test_spark_df = xgb_classifier_model.transform(iris_test_spark_df)
-classifier_evaluator = MulticlassClassificationEvaluator(metricName="f1")
-print(f"classifier f1={classifier_evaluator.evaluate(transformed_iris_test_spark_df)}")
-
-iris_train_spark_df2 = iris_train_spark_df.withColumn(
-    "validationIndicatorCol", rand(1) > 0.7
-)
-
-# train xgboost classifier model with validation dataset
-xgb_classifier2 = SparkXGBClassifier(
-    max_depth=5, validation_indicator_col="validationIndicatorCol"
-)
-xgb_classifier_model2 = xgb_classifier2.fit(iris_train_spark_df2)
-transformed_iris_test_spark_df2 = xgb_classifier_model2.transform(iris_test_spark_df)
-print(
-    f"classifier2 f1={classifier_evaluator.evaluate(transformed_iris_test_spark_df2)}"
-)
-
-spark.stop()

demo/nvflare/README.md

@@ -1,64 +0,0 @@
-# Experimental Support of Federated XGBoost using NVFlare
-
-This directory contains a demo of Federated Learning using
-[NVFlare](https://nvidia.github.io/NVFlare/).
-
-## Training with CPU only
-
-To run the demo, first build XGBoost with the federated learning plugin enabled (see the
-[README](../../plugin/federated/README.md)).
-
-Install NVFlare (note that currently NVFlare only supports Python 3.8; for NVFlare 2.1.2 we also
-need to pin the protobuf package to 3.20.x to avoid protoc errors):
-```shell
-pip install nvflare protobuf==3.20.1
-```
-
-Prepare the data:
-```shell
-./prepare_data.sh
-```
-
-Start the NVFlare federated server:
-```shell
-./poc/server/startup/start.sh
-```
-
-In another terminal, start the first worker:
-```shell
-./poc/site-1/startup/start.sh
-```
-
-And the second worker:
-```shell
-./poc/site-2/startup/start.sh
-```
-
-Then start the admin CLI, using `admin/admin` as username/password:
-```shell
-./poc/admin/startup/fl_admin.sh
-```
-
-In the admin CLI, run the following command:
-```shell
-submit_job hello-xgboost
-```
-
-Once the training finishes, the model file should be written into
-`./poc/site-1/run_1/test.model.json` and `./poc/site-2/run_1/test.model.json`
-respectively.
-
-Finally, shutdown everything from the admin CLI:
-```shell
-shutdown client
-shutdown server
-```
-
-## Training with GPUs
-
-To demo with Federated Learning using GPUs, make sure your machine has at least 2 GPUs.
-Build XGBoost with the federated learning plugin enabled along with CUDA, but with NCCL
-turned off (see the [README](../../plugin/federated/README.md)).
-
-Modify `config/config_fed_client.json` and set `use_gpus` to `true`, then repeat the steps
-above.

demo/nvflare/config/config_fed_client.json

@@ -1,23 +0,0 @@
-{
-  "format_version": 2,
-  "executors": [
-    {
-      "tasks": [
-        "train"
-      ],
-      "executor": {
-        "path": "trainer.XGBoostTrainer",
-        "args": {
-          "server_address": "localhost:9091",
-          "world_size": 2,
-          "server_cert_path": "server-cert.pem",
-          "client_key_path": "client-key.pem",
-          "client_cert_path": "client-cert.pem",
-          "use_gpus": "false"
-        }
-      }
-    }
-  ],
-  "task_result_filters": [],
-  "task_data_filters": []
-}

demo/nvflare/config/config_fed_server.json

@@ -1,22 +0,0 @@
-{
-  "format_version": 2,
-  "server": {
-    "heart_beat_timeout": 600
-  },
-  "task_data_filters": [],
-  "task_result_filters": [],
-  "workflows": [
-    {
-      "id": "server_workflow",
-      "path": "controller.XGBoostController",
-      "args": {
-        "port": 9091,
-        "world_size": 2,
-        "server_key_path": "server-key.pem",
-        "server_cert_path": "server-cert.pem",
-        "client_cert_path": "client-cert.pem"
-      }
-    }
-  ],
-  "components": []
-}

demo/nvflare/custom/controller.py

@@ -1,68 +0,0 @@
-"""
-Example of training controller with NVFlare
-===========================================
-"""
-import multiprocessing
-
-import xgboost.federated
-from nvflare.apis.client import Client
-from nvflare.apis.fl_context import FLContext
-from nvflare.apis.impl.controller import Controller, Task
-from nvflare.apis.shareable import Shareable
-from nvflare.apis.signal import Signal
-
-from trainer import SupportedTasks
-
-
-class XGBoostController(Controller):
-    def __init__(self, port: int, world_size: int, server_key_path: str,
-                 server_cert_path: str, client_cert_path: str):
-        """Controller for federated XGBoost.
-
-        Args:
-            port: the port for the gRPC server to listen on.
-            world_size: the number of sites.
-            server_key_path: the path to the server key file.
-            server_cert_path: the path to the server certificate file.
-            client_cert_path: the path to the client certificate file.
-        """
-        super().__init__()
-        self._port = port
-        self._world_size = world_size
-        self._server_key_path = server_key_path
-        self._server_cert_path = server_cert_path
-        self._client_cert_path = client_cert_path
-        self._server = None
-
-    def start_controller(self, fl_ctx: FLContext):
-        self._server = multiprocessing.Process(
-            target=xgboost.federated.run_federated_server,
-            args=(self._port, self._world_size, self._server_key_path,
-                  self._server_cert_path, self._client_cert_path))
-        self._server.start()
-
-    def stop_controller(self, fl_ctx: FLContext):
-        if self._server:
-            self._server.terminate()
-
-    def process_result_of_unknown_task(self, client: Client, task_name: str,
-                                       client_task_id: str, result: Shareable,
-                                       fl_ctx: FLContext):
-        self.log_warning(fl_ctx, f"Unknown task: {task_name} from client {client.name}.")
-
-    def control_flow(self, abort_signal: Signal, fl_ctx: FLContext):
-        self.log_info(fl_ctx, "XGBoost training control flow started.")
-        if abort_signal.triggered:
-            return
-        task = Task(name=SupportedTasks.TRAIN, data=Shareable())
-        self.broadcast_and_wait(
-            task=task,
-            min_responses=self._world_size,
-            fl_ctx=fl_ctx,
-            wait_time_after_min_received=1,
-            abort_signal=abort_signal,
-        )
-        if abort_signal.triggered:
-            return
-
-        self.log_info(fl_ctx, "XGBoost training control flow finished.")

demo/nvflare/custom/trainer.py

@@ -1,90 +0,0 @@
-import os
-
-from nvflare.apis.executor import Executor
-from nvflare.apis.fl_constant import ReturnCode, FLContextKey
-from nvflare.apis.fl_context import FLContext
-from nvflare.apis.shareable import Shareable, make_reply
-from nvflare.apis.signal import Signal
-
-import xgboost as xgb
-from xgboost import callback
-
-
-class SupportedTasks(object):
-    TRAIN = "train"
-
-
-class XGBoostTrainer(Executor):
-    def __init__(self, server_address: str, world_size: int, server_cert_path: str,
-                 client_key_path: str, client_cert_path: str, use_gpus: bool):
-        """Trainer for federated XGBoost.
-
-        Args:
-            server_address: address for the gRPC server to connect to.
-            world_size: the number of sites.
-            server_cert_path: the path to the server certificate file.
-            client_key_path: the path to the client key file.
-            client_cert_path: the path to the client certificate file.
-        """
-        super().__init__()
-        self._server_address = server_address
-        self._world_size = world_size
-        self._server_cert_path = server_cert_path
-        self._client_key_path = client_key_path
-        self._client_cert_path = client_cert_path
-        self._use_gpus = use_gpus
-
-    def execute(self, task_name: str, shareable: Shareable, fl_ctx: FLContext,
-                abort_signal: Signal) -> Shareable:
-        self.log_info(fl_ctx, f"Executing {task_name}")
-        try:
-            if task_name == SupportedTasks.TRAIN:
-                self._do_training(fl_ctx)
-                return make_reply(ReturnCode.OK)
-            else:
-                self.log_error(fl_ctx, f"{task_name} is not a supported task.")
-                return make_reply(ReturnCode.TASK_UNKNOWN)
-        except BaseException as e:
-            self.log_exception(fl_ctx,
-                               f"Task {task_name} failed. Exception: {e.__str__()}")
-            return make_reply(ReturnCode.EXECUTION_EXCEPTION)
-
-    def _do_training(self, fl_ctx: FLContext):
-        client_name = fl_ctx.get_prop(FLContextKey.CLIENT_NAME)
-        rank = int(client_name.split('-')[1]) - 1
-        communicator_env = {
-            'xgboost_communicator': 'federated',
-            'federated_server_address': self._server_address,
-            'federated_world_size': self._world_size,
-            'federated_rank': rank,
-            'federated_server_cert': self._server_cert_path,
-            'federated_client_key': self._client_key_path,
-            'federated_client_cert': self._client_cert_path
-        }
-        with xgb.collective.CommunicatorContext(**communicator_env):
-            # Load file, file will not be sharded in federated mode.
-            dtrain = xgb.DMatrix('agaricus.txt.train')
-            dtest = xgb.DMatrix('agaricus.txt.test')
-
-            # Specify parameters via map, definition are same as c++ version
-            param = {'max_depth': 2, 'eta': 1, 'objective': 'binary:logistic'}
-            if self._use_gpus:
-                self.log_info(fl_ctx, f'Training with GPU {rank}')
-                param['tree_method'] = 'gpu_hist'
-                param['gpu_id'] = rank
-
-            # Specify validations set to watch performance
-            watchlist = [(dtest, 'eval'), (dtrain, 'train')]
-            num_round = 20
-
-            # Run training, all the features in training API is available.
-            bst = xgb.train(param, dtrain, num_round, evals=watchlist,
-                            early_stopping_rounds=2, verbose_eval=False,
-                            callbacks=[callback.EvaluationMonitor(rank=rank)])
-
-            # Save the model.
-            workspace = fl_ctx.get_prop(FLContextKey.WORKSPACE_OBJECT)
-            run_number = fl_ctx.get_prop(FLContextKey.CURRENT_RUN)
-            run_dir = workspace.get_run_dir(run_number)
-            bst.save_model(os.path.join(run_dir, "test.model.json"))
-            xgb.collective.communicator_print("Finished training\n")

demo/nvflare/prepare_data.sh

@@ -1,25 +0,0 @@
-#!/bin/bash
-
-set -e
-
-rm -fr ./agaricus* ./*.pem ./poc
-
-world_size=2
-
-# Generate server and client certificates.
-openssl req -x509 -newkey rsa:2048 -days 7 -nodes -keyout server-key.pem -out server-cert.pem -subj "/C=US/CN=localhost"
-openssl req -x509 -newkey rsa:2048 -days 7 -nodes -keyout client-key.pem -out client-cert.pem -subj "/C=US/CN=localhost"
-
-# Split train and test files manually to simulate a federated environment.
-split -n l/${world_size} --numeric-suffixes=1 -a 1 ../data/agaricus.txt.train agaricus.txt.train-site-
-split -n l/${world_size} --numeric-suffixes=1 -a 1 ../data/agaricus.txt.test agaricus.txt.test-site-
-
-poc -n 2
-mkdir -p poc/admin/transfer/hello-xgboost
-cp -fr config custom poc/admin/transfer/hello-xgboost
-cp server-*.pem client-cert.pem poc/server/
-for id in $(eval echo "{1..$world_size}"); do
-  cp server-cert.pem client-*.pem poc/site-"$id"/
-  cp agaricus.txt.train-site-"$id" poc/site-"$id"/agaricus.txt.train
-  cp agaricus.txt.test-site-"$id" poc/site-"$id"/agaricus.txt.test
-done

dev/prepare_jvm_release.py

@@ -1,15 +1,9 @@
-import re
 import os
 import sys
-import platform
 import errno
-import argparse
 import subprocess
 import glob
 import shutil
-import tempfile
-import zipfile
-from urllib.request import urlretrieve
 from contextlib import contextmanager
 
 def normpath(path):
@@ -50,48 +44,7 @@ def run(command, **kwargs):
     print(command)
     subprocess.check_call(command, shell=True, **kwargs)
 
-def get_current_git_tag():
-    out = subprocess.check_output(["git", "tag", "--points-at", "HEAD"])
-    return out.decode().split("\n")[0]
-
-def get_current_commit_hash():
-    out = subprocess.check_output(["git", "rev-parse", "HEAD"])
-    return out.decode().split("\n")[0]
-
-def get_current_git_branch():
-    out = subprocess.check_output(["git", "log", "-n", "1", "--pretty=%d", "HEAD"])
-    m = re.search(r"release_[0-9\.]+", out.decode())
-    if not m:
-        raise ValueError("Expected branch name of form release_xxx")
-    return m.group(0)
-
-def retrieve(url, filename=None):
-    print(f"{url} -> {filename}")
-    return urlretrieve(url, filename)
-
 def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--release-version", type=str, required=True,
-                        help="Version of the release being prepared")
-    args = parser.parse_args()
-
-    if sys.platform != "darwin" or platform.machine() != "x86_64":
-        raise NotImplementedError("Please run this script using an Intel Mac")
-
-    version = args.release_version
-    expected_git_tag = "v" + version
-    current_git_tag = get_current_git_tag()
-    if current_git_tag != expected_git_tag:
-        if not current_git_tag:
-            raise ValueError(f"Expected git tag {expected_git_tag} but current HEAD has no tag. "
-                             f"Run: git checkout {expected_git_tag}")
-        raise ValueError(f"Expected git tag {expected_git_tag} but current HEAD is at tag "
-                         f"{current_git_tag}. Run: git checkout {expected_git_tag}")
-
-    commit_hash = get_current_commit_hash()
-    git_branch = get_current_git_branch()
-    print(f"Using commit {commit_hash} of branch {git_branch}, git tag {current_git_tag}")
-
     with cd("jvm-packages/"):
         print("====copying pure-Python tracker====")
         for use_cuda in [True, False]:
@@ -114,46 +67,12 @@ def main():
                 cp(file, f"{xgboost4j_spark}/src/test/resources")
 
         print("====Creating directories to hold native binaries====")
-        for os_ident, arch in [("linux", "x86_64"), ("windows", "x86_64"), ("macos", "x86_64")]:
-            output_dir = f"xgboost4j/src/main/resources/lib/{os_ident}/{arch}"
+        for os, arch in [("linux", "x86_64"), ("windows", "x86_64"), ("macos", "x86_64")]:
+            output_dir = f"xgboost4j/src/main/resources/lib/{os}/{arch}"
             maybe_makedirs(output_dir)
-        for os_ident, arch in [("linux", "x86_64")]:
-            output_dir = f"xgboost4j-gpu/src/main/resources/lib/{os_ident}/{arch}"
+        for os, arch in [("linux", "x86_64")]:
+            output_dir = f"xgboost4j-gpu/src/main/resources/lib/{os}/{arch}"
             maybe_makedirs(output_dir)
-
-        print("====Downloading native binaries from CI====")
-        nightly_bucket_prefix = "https://s3-us-west-2.amazonaws.com/xgboost-nightly-builds"
-        maven_repo_prefix = "https://s3-us-west-2.amazonaws.com/xgboost-maven-repo/release/ml/dmlc"
-
-        retrieve(url=f"{nightly_bucket_prefix}/{git_branch}/xgboost4j_{commit_hash}.dll",
-                 filename="xgboost4j/src/main/resources/lib/windows/x86_64/xgboost4j.dll")
-
-        with tempfile.TemporaryDirectory() as tempdir:
-            # libxgboost4j.so for Linux x86_64, CPU only
-            zip_path = os.path.join(tempdir, "xgboost4j_2.12.jar")
-            extract_dir = os.path.join(tempdir, "xgboost4j")
-            retrieve(url=f"{maven_repo_prefix}/xgboost4j_2.12/{version}/"
-                         f"xgboost4j_2.12-{version}.jar",
-                     filename=zip_path)
-            os.mkdir(extract_dir)
-            with zipfile.ZipFile(zip_path, "r") as t:
-                t.extractall(extract_dir)
-            cp(os.path.join(extract_dir, "lib", "linux", "x86_64", "libxgboost4j.so"),
-               "xgboost4j/src/main/resources/lib/linux/x86_64/libxgboost4j.so")
-
-            # libxgboost4j.so for Linux x86_64, GPU support
-            zip_path = os.path.join(tempdir, "xgboost4j-gpu_2.12.jar")
-            extract_dir = os.path.join(tempdir, "xgboost4j-gpu")
-            retrieve(url=f"{maven_repo_prefix}/xgboost4j-gpu_2.12/{version}/"
-                         f"xgboost4j-gpu_2.12-{version}.jar",
-                     filename=zip_path)
-            os.mkdir(extract_dir)
-            with zipfile.ZipFile(zip_path, "r") as t:
-                t.extractall(extract_dir)
-            cp(os.path.join(extract_dir, "lib", "linux", "x86_64", "libxgboost4j.so"),
-               "xgboost4j-gpu/src/main/resources/lib/linux/x86_64/libxgboost4j.so")
-
-
     print("====Next Steps====")
     print("1. Gain upload right to Maven Central repo.")
     print("1-1. Sign up for a JIRA account at Sonatype: ")
@@ -162,9 +81,19 @@ def main():
           "https://issues.sonatype.org/browse/OSSRH-67724")
     print("2. Store the Sonatype credentials in .m2/settings.xml. See insturctions in "
           "https://central.sonatype.org/publish/publish-maven/")
-    print("3. Now on a Mac machine, run:")
+    print("3. Obtain Linux and Windows binaries from the CI server")
+    print("3-1. Get xgboost4j_[commit].dll from "
+          "https://s3-us-west-2.amazonaws.com/xgboost-nightly-builds/list.html. Rename it to"
+          "xgboost4j.dll.")
+    print("3-2. For Linux binaries, go to "
+          "https://s3-us-west-2.amazonaws.com/xgboost-maven-repo/list.html and navigate to the "
+          "release/ directory. Find and download two JAR files: xgboost4j_2.12-[version].jar and "
+          "xgboost4j-gpu_2.12-[version].jar. Use unzip command to extract libxgboost4j.so (one "
+          "version compiled with GPU support and another compiled without).")
+    print("4. Put the binaries in xgboost4j(-gpu)/src/main/resources/lib/[os]/[arch]")
+    print("5. Now on a Mac machine, run:")
     print("   GPG_TTY=$(tty) mvn deploy -Prelease -DskipTests")
-    print("4. Log into https://oss.sonatype.org/. On the left menu panel, click Staging "
+    print("6. Log into https://oss.sonatype.org/. On the left menu panel, click Staging "
           "Repositories. Visit the URL https://oss.sonatype.org/content/repositories/mldmlc-1085 "
           "to inspect the staged JAR files. Finally, press Release button to publish the "
           "artifacts to the Maven Central repository.")

dev/release-py-r.py

@@ -3,10 +3,11 @@
 tqdm, sh are required to run this script.
 """
 from urllib.request import urlretrieve
+from typing import cast, Tuple
 import argparse
-from typing import List, Optional
+from typing import List
 from sh.contrib import git
-from packaging import version
+from distutils import version
 import subprocess
 import tqdm
 import os
@@ -26,8 +27,7 @@ def show_progress(block_num, block_size, total_size):
 
     downloaded = block_num * block_size
     if downloaded < total_size:
-        upper = (total_size - downloaded) / 1024
-        pbar.update(min(block_size / 1024, upper))
+        pbar.update(block_size / 1024)
     else:
         pbar.close()
         pbar = None
@@ -138,25 +138,19 @@ def check_path():
 def main(args: argparse.Namespace) -> None:
     check_path()
 
-    rel = version.parse(args.release)
-    assert isinstance(rel, version.Version)
-
-    major = rel.major
-    minor = rel.minor
-    patch = rel.micro
+    rel = version.LooseVersion(args.release)
 
     print("Release:", rel)
-    if not rel.is_prerelease:
+    if len(rel.version) == 3:
         # Major release
-        rc: Optional[str] = None
-        rc_ver: Optional[int] = None
+        major, minor, patch = version.StrictVersion(args.release).version
+        rc = None
+        rc_ver = None
     else:
         # RC release
-        major = rel.major
-        minor = rel.minor
-        patch = rel.micro
-        assert rel.pre is not None
-        rc, rc_ver = rel.pre
+        major, minor, patch, rc, rc_ver = cast(
+            Tuple[int, int, int, str, int], rel.version
+        )
         assert rc == "rc"
 
     release = str(major) + "." + str(minor) + "." + str(patch)

doc/Doxyfile.in

@@ -753,7 +753,7 @@ WARN_LOGFILE           =
 # spaces.
 # Note: If this tag is empty the current directory is searched.
 
-INPUT                  = @PROJECT_SOURCE_DIR@/include
+INPUT                  = @PROJECT_SOURCE_DIR@/include @PROJECT_SOURCE_DIR@/src/common
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
@@ -822,7 +822,7 @@ EXCLUDE_SYMBOLS        =
 # that contain example code fragments that are included (see the \include
 # command).
 
-EXAMPLE_PATH           = @PROJECT_SOURCE_DIR@/demo/c-api/
+EXAMPLE_PATH           =
 
 # If the value of the EXAMPLE_PATH tag contains directories, you can use the
 # EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and
@@ -836,7 +836,7 @@ EXAMPLE_PATTERNS       =
 # irrespective of the value of the RECURSIVE tag.
 # The default value is: NO.
 
-EXAMPLE_RECURSIVE      = YES
+EXAMPLE_RECURSIVE      = NO
 
 # The IMAGE_PATH tag can be used to specify one or more files or directories
 # that contain images that are to be included in the documentation (see the
@@ -1934,7 +1934,7 @@ ENABLE_PREPROCESSING   = YES
 # The default value is: NO.
 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
 
-MACRO_EXPANSION        = YES
+MACRO_EXPANSION        = NO
 
 # If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES then
 # the macro expansion is limited to the macros specified with the PREDEFINED and
@@ -1942,7 +1942,7 @@ MACRO_EXPANSION        = YES
 # The default value is: NO.
 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
 
-EXPAND_ONLY_PREDEF     = YES
+EXPAND_ONLY_PREDEF     = NO
 
 # If the SEARCH_INCLUDES tag is set to YES the includes files in the
 # INCLUDE_PATH will be searched if a #include is found.
@@ -1974,9 +1974,7 @@ INCLUDE_FILE_PATTERNS  =
 # recursively expanded use the := operator instead of the = operator.
 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
 
-PREDEFINED             = DMLC_USE_CXX11 \
-                         "XGB_DLL=" \
-                         "XGB_EXTERN_C="
+PREDEFINED             = DMLC_USE_CXX11
 
 # If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
 # tag can be used to specify a list of macro names that should be expanded. The

doc/build.rst

@@ -136,9 +136,9 @@ From the command line on Linux starting from the XGBoost directory:
 
   To speed up compilation, the compute version specific to your GPU could be passed to cmake as, e.g., ``-DGPU_COMPUTE_VER=50``. A quick explanation and numbers for some architectures can be found `in this page <https://arnon.dk/matching-sm-architectures-arch-and-gencode-for-various-nvidia-cards/>`_.
 
-.. note:: Faster distributed GPU training with NCCL
+.. note:: Enabling distributed GPU training
 
-  By default, distributed GPU training is enabled and uses Rabit for communication. For faster training, set the option ``USE_NCCL=ON``. Faster distributed GPU training depends on NCCL2, available at `this link <https://developer.nvidia.com/nccl>`_. Since NCCL2 is only available for Linux machines, **faster distributed GPU training is available only for Linux**.
+  By default, distributed GPU training is disabled and only a single GPU will be used. To enable distributed GPU training, set the option ``USE_NCCL=ON``. Distributed GPU training depends on NCCL2, available at `this link <https://developer.nvidia.com/nccl>`_. Since NCCL2 is only available for Linux machines, **distributed GPU training is available only for Linux**.
 
   .. code-block:: bash
 
@@ -198,7 +198,7 @@ There are several ways to build and install the package from source:
 
     python setup.py install --use-cuda --use-nccl
 
-  Please refer to ``setup.py`` for a complete list of available options.  Some other
+  Please refer to ``setup.py`` for a complete list of avaiable options.  Some other
   options used for development are only available for using CMake directly.  See next
   section on how to use CMake with setuptools manually.
 

doc/c++.rst

@@ -8,5 +8,5 @@ As a result it's changing quite often and we don't maintain its stability.  Alon
 plugin system (see ``plugin/example`` in XGBoost's source tree), users can utilize some
 existing c++ headers for gaining more access to the internal of XGBoost.
 
-* `C++ interface documentation (latest master branch) <./dev/files.html>`_
+* `C++ interface documentation (latest master branch) <https://xgboost.readthedocs.io/en/latest/dev/files.html>`_
 * `C++ interface documentation (last stable release) <https://xgboost.readthedocs.io/en/stable/dev/files.html>`_

doc/c.rst

@@ -6,59 +6,7 @@ XGBoost implements a set of C API designed for various bindings, we maintain its
 and the CMake/make build interface.  See :doc:`/tutorials/c_api_tutorial` for an
 introduction and ``demo/c-api/`` for related examples.  Also one can generate doxygen
 document by providing ``-DBUILD_C_DOC=ON`` as parameter to ``CMake`` during build, or
-simply look at function comments in ``include/xgboost/c_api.h``. The reference is exported
-to sphinx with the help of breathe, which doesn't contain links to examples but might be
-easier to read. For the original doxygen pages please visit:
+simply look at function comments in ``include/xgboost/c_api.h``.
 
-* `C API documentation (latest master branch) <./dev/c__api_8h.html>`_
+* `C API documentation (latest master branch) <https://xgboost.readthedocs.io/en/latest/dev/c__api_8h.html>`_
 * `C API documentation (last stable release) <https://xgboost.readthedocs.io/en/stable/dev/c__api_8h.html>`_
-
-***************
-C API Reference
-***************
-
-.. contents::
-  :backlinks: none
-  :local:
-
-Library
-=======
-
-.. doxygengroup:: Library
-   :project: xgboost
-
-DMatrix
-=======
-
-.. doxygengroup:: DMatrix
-   :project: xgboost
-
-Streaming
----------
-
-.. doxygengroup:: Streaming
-   :project: xgboost
-
-Booster
-=======
-
-.. doxygengroup:: Booster
-   :project: xgboost
-
-Prediction
-----------
-
-.. doxygengroup:: Prediction
-   :project: xgboost
-
-Serialization
--------------
-
-.. doxygengroup:: Serialization
-   :project: xgboost
-
-Collective
-==========
-
-.. doxygengroup:: Collective
-   :project: xgboost

doc/conf.py

@@ -11,188 +11,124 @@
 #
 # All configuration values have a default; values that are commented out
 # serve to show the default.
-import os
-import re
-import shutil
-import subprocess
-import sys
-import tarfile
-import urllib.request
-import warnings
-from urllib.error import HTTPError
-
+from subprocess import call
 from sh.contrib import git
+import urllib.request
+from urllib.error import HTTPError
+import sys
+import re
+import os
+import subprocess
 
-CURR_PATH = os.path.dirname(os.path.abspath(os.path.expanduser(__file__)))
-PROJECT_ROOT = os.path.normpath(os.path.join(CURR_PATH, os.path.pardir))
-TMP_DIR = os.path.join(CURR_PATH, "tmp")
-DOX_DIR = "doxygen"
-
-
-def run_doxygen():
-    """Run the doxygen make command in the designated folder."""
-    curdir = os.path.normpath(os.path.abspath(os.path.curdir))
-    if os.path.exists(TMP_DIR):
-        print(f"Delete directory {TMP_DIR}")
-        shutil.rmtree(TMP_DIR)
-    else:
-        print(f"Create directory {TMP_DIR}")
-        os.mkdir(TMP_DIR)
-    try:
-        os.chdir(PROJECT_ROOT)
-        if not os.path.exists(DOX_DIR):
-            os.mkdir(DOX_DIR)
-        os.chdir(os.path.join(PROJECT_ROOT, DOX_DIR))
-        print(
-            "Build doxygen at {}".format(
-                os.path.join(PROJECT_ROOT, DOX_DIR, "doc_doxygen")
-            )
-        )
-        subprocess.check_call(["cmake", "..", "-DBUILD_C_DOC=ON", "-GNinja"])
-        subprocess.check_call(["ninja", "doc_doxygen"])
-
-        src = os.path.join(PROJECT_ROOT, DOX_DIR, "doc_doxygen", "html")
-        dest = os.path.join(TMP_DIR, "dev")
-        print(f"Copy directory {src} -> {dest}")
-        shutil.copytree(src, dest)
-    except OSError as e:
-        sys.stderr.write("doxygen execution failed: %s" % e)
-    finally:
-        os.chdir(curdir)
-
-
-def is_readthedocs_build():
-    if os.environ.get("READTHEDOCS", None) == "True":
-        return True
-    warnings.warn(
-        "Skipping Doxygen build... You won't have documentation for C/C++ functions. "
-        "Set environment variable READTHEDOCS=True if you want to build Doxygen. "
-        "(If you do opt in, make sure to install Doxygen, Graphviz, CMake, and C++ compiler "
-        "on your system.)"
-    )
-    return False
-
-
-if is_readthedocs_build():
-    run_doxygen()
-
-
-git_branch = os.getenv("SPHINX_GIT_BRANCH", default=None)
+git_branch = os.getenv('SPHINX_GIT_BRANCH', default=None)
 if not git_branch:
     # If SPHINX_GIT_BRANCH environment variable is not given, run git
     # to determine branch name
     git_branch = [
-        re.sub(r"origin/", "", x.lstrip(" "))
-        for x in str(git.branch("-r", "--contains", "HEAD")).rstrip("\n").split("\n")
+        re.sub(r'origin/', '', x.lstrip(' ')) for x in str(
+            git.branch('-r', '--contains', 'HEAD')).rstrip('\n').split('\n')
     ]
-    git_branch = [x for x in git_branch if "HEAD" not in x]
+    git_branch = [x for x in git_branch if 'HEAD' not in x]
 else:
     git_branch = [git_branch]
-print("git_branch = {}".format(git_branch[0]))
+print('git_branch = {}'.format(git_branch[0]))
 
 try:
     filename, _ = urllib.request.urlretrieve(
-        f"https://s3-us-west-2.amazonaws.com/xgboost-docs/{git_branch[0]}.tar.bz2"
-    )
-    if not os.path.exists(TMP_DIR):
-        print(f"Create directory {TMP_DIR}")
-        os.mkdir(TMP_DIR)
-    jvm_doc_dir = os.path.join(TMP_DIR, "jvm")
-    if os.path.exists(jvm_doc_dir):
-        print(f"Delete directory {jvm_doc_dir}")
-        shutil.rmtree(jvm_doc_dir)
-    print(f"Create directory {jvm_doc_dir}")
-    os.mkdir(jvm_doc_dir)
-
-    with tarfile.open(filename, "r:bz2") as t:
-        t.extractall(jvm_doc_dir)
+        'https://s3-us-west-2.amazonaws.com/xgboost-docs/{}.tar.bz2'.format(
+            git_branch[0]))
+    call(
+        'if [ -d tmp ]; then rm -rf tmp; fi; mkdir -p tmp/jvm; cd tmp/jvm; tar xvf {}'
+        .format(filename),
+        shell=True)
 except HTTPError:
-    print("JVM doc not found. Skipping...")
+    print('JVM doc not found. Skipping...')
+try:
+    filename, _ = urllib.request.urlretrieve(
+        'https://s3-us-west-2.amazonaws.com/xgboost-docs/doxygen/{}.tar.bz2'.
+        format(git_branch[0]))
+    call(
+        'mkdir -p tmp/dev; cd tmp/dev; tar xvf {}; mv doc_doxygen/html/* .; rm -rf doc_doxygen'
+        .format(filename),
+        shell=True)
+except HTTPError:
+    print('C API doc not found. Skipping...')
 
 # If extensions (or modules to document with autodoc) are in another directory,
 # add these directories to sys.path here. If the directory is relative to the
 # documentation root, use os.path.abspath to make it absolute, like shown here.
-libpath = os.path.join(PROJECT_ROOT, "python-package/")
+curr_path = os.path.dirname(os.path.abspath(os.path.expanduser(__file__)))
+libpath = os.path.join(curr_path, '../python-package/')
 sys.path.insert(0, libpath)
-sys.path.insert(0, CURR_PATH)
+sys.path.insert(0, curr_path)
 
 # -- General configuration ------------------------------------------------
 
 # General information about the project.
-project = "xgboost"
-author = "%s developers" % project
-copyright = "2022, %s" % author
-github_doc_root = "https://github.com/dmlc/xgboost/tree/master/doc/"
+project = u'xgboost'
+author = u'%s developers' % project
+copyright = u'2021, %s' % author
+github_doc_root = 'https://github.com/dmlc/xgboost/tree/master/doc/'
 
-os.environ["XGBOOST_BUILD_DOC"] = "1"
+os.environ['XGBOOST_BUILD_DOC'] = '1'
 # Version information.
-import xgboost  # NOQA
-
+import xgboost                  # NOQA
 version = xgboost.__version__
 release = xgboost.__version__
 
 # Add any Sphinx extension module names here, as strings. They can be
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom ones
 extensions = [
-    "matplotlib.sphinxext.plot_directive",
-    "sphinxcontrib.jquery",
-    "sphinx.ext.autodoc",
-    "sphinx.ext.napoleon",
-    "sphinx.ext.mathjax",
-    "sphinx.ext.intersphinx",
+    'matplotlib.sphinxext.plot_directive',
+    'sphinx.ext.autodoc',
+    'sphinx.ext.napoleon',
+    'sphinx.ext.mathjax',
+    'sphinx.ext.intersphinx',
     "sphinx_gallery.gen_gallery",
-    "breathe",
-    "recommonmark",
+    'breathe',
+    'recommonmark'
 ]
 
 sphinx_gallery_conf = {
     # path to your example scripts
-    "examples_dirs": ["../demo/guide-python", "../demo/dask", "../demo/aft_survival"],
+    "examples_dirs": ["../demo/guide-python", "../demo/dask"],
     # path to where to save gallery generated output
-    "gallery_dirs": [
-        "python/examples",
-        "python/dask-examples",
-        "python/survival-examples",
-    ],
+    "gallery_dirs": ["python/examples", "python/dask-examples"],
     "matplotlib_animations": True,
 }
 
 autodoc_typehints = "description"
 
-graphviz_output_format = "png"
-plot_formats = [("svg", 300), ("png", 100), ("hires.png", 300)]
+graphviz_output_format = 'png'
+plot_formats = [('svg', 300), ('png', 100), ('hires.png', 300)]
 plot_html_show_source_link = False
 plot_html_show_formats = False
 
 # Breathe extension variables
-breathe_projects = {}
-if is_readthedocs_build():
-    breathe_projects = {
-        "xgboost": os.path.join(PROJECT_ROOT, DOX_DIR, "doc_doxygen/xml")
-    }
+breathe_projects = {"xgboost": "doxyxml/"}
 breathe_default_project = "xgboost"
 
 # Add any paths that contain templates here, relative to this directory.
-templates_path = ["_templates"]
+templates_path = ['_templates']
 
 # The suffix(es) of source filenames.
 # You can specify multiple suffix as a list of string:
-source_suffix = [".rst", ".md"]
+source_suffix = ['.rst', '.md']
 
 # The encoding of source files.
 # source_encoding = 'utf-8-sig'
 
 # The master toctree document.
-master_doc = "index"
+master_doc = 'index'
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
 #
 # This is also used if you do content translation via gettext catalogs.
 # Usually you set "language" from the command line for these cases.
-language = "en"
+language = None
 
-autoclass_content = "both"
+autoclass_content = 'both'
 
 # There are two options for replacing |today|: either, you set today to some
 # non-false value, then it is used:
@@ -202,10 +138,8 @@ autoclass_content = "both"
 
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
-exclude_patterns = ["_build"]
-html_extra_path = []
-if is_readthedocs_build():
-    html_extra_path = [TMP_DIR]
+exclude_patterns = ['_build']
+html_extra_path = ['./tmp']
 
 # The reST default role (used for this markup: `text`) to use for all
 # documents.
@@ -223,7 +157,7 @@ if is_readthedocs_build():
 # show_authors = False
 
 # The name of the Pygments (syntax highlighting) style to use.
-pygments_style = "sphinx"
+pygments_style = 'sphinx'
 
 # A list of ignored prefixes for module index sorting.
 # modindex_common_prefix = []
@@ -246,37 +180,58 @@ html_logo = "https://raw.githubusercontent.com/dmlc/dmlc.github.io/master/img/lo
 
 html_css_files = ["css/custom.css"]
 
-html_sidebars = {"**": ["logo-text.html", "globaltoc.html", "searchbox.html"]}
+html_sidebars = {
+  '**': ['logo-text.html', 'globaltoc.html', 'searchbox.html']
+}
 
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ["_static"]
+html_static_path = ['_static']
 
 # Output file base name for HTML help builder.
-htmlhelp_basename = project + "doc"
+htmlhelp_basename = project + 'doc'
 
 # -- Options for LaTeX output ---------------------------------------------
-latex_elements = {}
+latex_elements = {
+}
 
 # Grouping the document tree into LaTeX files. List of tuples
 # (source start file, target name, title,
 #  author, documentclass [howto, manual, or own class]).
 latex_documents = [
-    (master_doc, "%s.tex" % project, project, author, "manual"),
+  (master_doc, '%s.tex' % project, project, author, 'manual'),
 ]
 
 intersphinx_mapping = {
-    "python": ("https://docs.python.org/3.8", None),
+    "python": ("https://docs.python.org/3.6", None),
     "numpy": ("https://docs.scipy.org/doc/numpy/", None),
     "scipy": ("https://docs.scipy.org/doc/scipy/reference/", None),
-    "pandas": ("https://pandas.pydata.org/pandas-docs/stable/", None),
+    "pandas": ("http://pandas-docs.github.io/pandas-docs-travis/", None),
     "sklearn": ("https://scikit-learn.org/stable", None),
     "dask": ("https://docs.dask.org/en/stable/", None),
     "distributed": ("https://distributed.dask.org/en/stable/", None),
-    "pyspark": ("https://spark.apache.org/docs/latest/api/python/", None),
 }
 
 
+# hook for doxygen
+def run_doxygen(folder):
+    """Run the doxygen make command in the designated folder."""
+    try:
+        retcode = subprocess.call("cd %s; make doxygen" % folder, shell=True)
+        if retcode < 0:
+            sys.stderr.write("doxygen terminated by signal %s" % (-retcode))
+    except OSError as e:
+        sys.stderr.write("doxygen execution failed: %s" % e)
+
+
+def generate_doxygen_xml(app):
+    """Run the doxygen make commands if we're on the ReadTheDocs server"""
+    read_the_docs_build = os.environ.get('READTHEDOCS', None) == 'True'
+    if read_the_docs_build:
+        run_doxygen('..')
+
+
+# app.add_stylesheet() is deprecated. Use app.add_css_file()
 def setup(app):
-    app.add_css_file("custom.css")
+    app.add_css_file('custom.css')

doc/contrib/ci.rst

@@ -37,128 +37,3 @@ machine in GitHub Actions, cross-compilation is needed; ``cibuildwheel`` takes c
 task of cross-compiling a Python wheel. (Note that ``cibuildwheel`` will call
 ``setup.py bdist_wheel``. Since XGBoost has a native library component, ``setup.py`` contains
 a glue code to call CMake and a C++ compiler to build the native library on the fly.)
-
-*********************************************************
-Reproduce CI testing environments using Docker containers
-*********************************************************
-In our CI pipelines, we use Docker containers extensively to package many software packages together.
-You can reproduce the same testing environment as the CI pipelines by running Docker locally.
-
-=============
-Prerequisites
-=============
-1. Install Docker: https://docs.docker.com/engine/install/ubuntu/
-2. Install NVIDIA Docker runtime: https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html#installing-on-ubuntu-and-debian
-   The runtime lets you access NVIDIA GPUs inside a Docker container.
-
-==============================================
-Building and Running Docker containers locally
-==============================================
-For your convenience, we provide the wrapper script ``tests/ci_build/ci_build.sh``. You can use it as follows:
-
-.. code-block:: bash
-
-  tests/ci_build/ci_build.sh <CONTAINER_TYPE> <DOCKER_BINARY> --build-arg <BUILD_ARG> \
-    <COMMAND> ...
-
-where:
-
-* ``<CONTAINER_TYPE>`` is the identifier for the container. The wrapper script will use the
-  container definition (Dockerfile) located at ``tests/ci_build/Dockerfile.<CONTAINER_TYPE>``.
-  For example, setting the container type to ``gpu`` will cause the script to load the Dockerfile
-  ``tests/ci_build/Dockerfile.gpu``.
-* ``<DOCKER_BINARY>`` must be either ``docker`` or ``nvidia-docker``. Choose ``nvidia-docker``
-  as long as you need to run any GPU code.
-* ``<BUILD_ARG>`` is a build argument to be passed to Docker. Must be of form ``VAR=VALUE``.
-  Example: ``--build-arg CUDA_VERSION_ARG=11.0``. You can pass multiple ``--build-arg``.
-* ``<COMMAND>`` is the command to run inside the Docker container. This can be more than one argument.
-  Example: ``tests/ci_build/build_via_cmake.sh -DUSE_CUDA=ON -DUSE_NCCL=ON``.
-
-Optionally, you can set the environment variable ``CI_DOCKER_EXTRA_PARAMS_INIT`` to pass extra
-arguments to Docker. For example:
-
-.. code-block:: bash
-
-  # Allocate extra space in /dev/shm to enable NCCL
-  export CI_DOCKER_EXTRA_PARAMS_INIT='--shm-size=4g'
-  # Run multi-GPU test suite
-  tests/ci_build/ci_build.sh gpu nvidia-docker --build-arg CUDA_VERSION_ARG=11.0 \
-    tests/ci_build/test_python.sh mgpu
-
-To pass multiple extra arguments:
-
-.. code-block:: bash
-
-  export CI_DOCKER_EXTRA_PARAMS_INIT='-e VAR1=VAL1 -e VAR2=VAL2 -e VAR3=VAL3'
-
-********************************************
-Update pipeline definitions for BuildKite CI
-********************************************
-
-`BuildKite <https://buildkite.com/home>`_ is a SaaS (Software as a Service) platform that orchestrates
-cloud machines to host CI pipelines. The BuildKite platform allows us to define CI pipelines as a
-declarative YAML file.
-
-The pipeline definitions are found in ``tests/buildkite/``:
-
-* ``tests/buildkite/pipeline-win64.yml``: This pipeline builds and tests XGBoost for the Windows platform.
-* ``tests/buildkite/pipeline-mgpu.yml``: This pipeline builds and tests XGBoost with access to multiple
-  NVIDIA GPUs.
-* ``tests/buildkite/pipeline.yml``: This pipeline builds and tests XGBoost with access to a single
-  NVIDIA GPU. Most tests are located here.
-
-****************************************
-Managing Elastic CI Stack with BuildKite
-****************************************
-
-BuildKite allows us to define cloud resources in
-a declarative fashion. Every configuration step is now documented explicitly as code.
-
-**Prerequisite**: You should have some knowledge of `CloudFormation <https://aws.amazon.com/cloudformation/>`_.
-CloudFormation lets us define a stack of cloud resources (EC2 machines, Lambda functions, S3 etc) using
-a single YAML file.
-
-**Prerequisite**: Gain access to the XGBoost project's AWS account (``admin@xgboost-ci.net``), and then
-set up a credential pair in order to provision resources on AWS. See
-`Creating an IAM user in your AWS account <https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html>`_.
-
-* Option 1. Give full admin privileges to your IAM user. This is the simplest option.
-* Option 2. Give limited set of permissions to your IAM user, to reduce the possibility of messing up other resources.
-  For this, use the script ``tests/buildkite/infrastructure/service-user/create_service_user.py``.
-
-=====================
-Worker Image Pipeline
-=====================
-Building images for worker machines used to be a chore: you'd provision an EC2 machine, SSH into it, and
-manually install the necessary packages. This process is not only laborous but also error-prone. You may
-forget to install a package or change a system configuration.
-
-No more. Now we have an automated pipeline for building images for worker machines.
-
-* Run ``tests/buildkite/infrastructure/worker-image-pipeline/create_worker_image_pipelines.py`` in order to provision
-  CloudFormation stacks named ``buildkite-linux-amd64-gpu-worker`` and ``buildkite-windows-gpu-worker``. They are
-  pipelines that create AMIs (Amazon Machine Images) for Linux and Windows workers, respectively.
-* Navigate to the CloudFormation web console to verify that the image builder pipelines have been provisioned. It may
-  take some time.
-* Once they pipelines have been fully provisioned, run the script
-  ``tests/buildkite/infrastructure/worker-image-pipeline/run_pipelines.py`` to execute the pipelines. New AMIs will be
-  uploaded to the EC2 service. You can locate them in the EC2 console.
-* Make sure to modify ``tests/buildkite/infrastructure/aws-stack-creator/metadata.py`` to use the correct AMI IDs.
-  (For ``linux-amd64-cpu`` and ``linux-arm64-cpu``, use the AMIs provided by BuildKite. Consult the ``AWSRegion2AMI``
-  section of https://s3.amazonaws.com/buildkite-aws-stack/latest/aws-stack.yml.)
-
-======================
-EC2 Autoscaling Groups
-======================
-In EC2, you can create auto-scaling groups, where you can dynamically adjust the number of worker instances according to
-workload. When a pull request is submitted, the following steps take place:
-
-1. GitHub sends a signal to the registered webhook, which connects to the BuildKite server.
-2. BuildKite sends a signal to a `Lambda <https://aws.amazon.com/lambda/>`_ function named ``Autoscaling``.
-3. The Lambda function sends a signal to the auto-scaling group. The group scales up and adds additional worker instances.
-4. New worker instances run the test jobs. Test results are reported back to BuildKite.
-5. When the test jobs complete, BuildKite sends a signal to ``Autoscaling``, which in turn requests the autoscaling group
-   to scale down. Idle worker instances are shut down.
-
-To set up the auto-scaling group, run the script ``tests/buildkite/infrastructure/aws-stack-creator/create_stack.py``.
-Check the CloudFormation web console to verify successful provision of auto-scaling groups.

doc/contrib/docs.rst

@@ -11,7 +11,7 @@ Documentation and Examples
 *********
 Documents
 *********
-* Python and C documentation is built using `Sphinx <http://www.sphinx-doc.org/en/master/>`_.
+* Documentation is built using `Sphinx <http://www.sphinx-doc.org/en/master/>`_.
 * Each document is written in `reStructuredText <http://www.sphinx-doc.org/en/master/usage/restructuredtext/basics.html>`_.
 * You can build document locally to see the effect, by running
 

doc/contrib/donate.rst

@@ -13,9 +13,9 @@ DMLC/XGBoost has grown from a research project incubated in academia to one of t
 
 A robust and efficient **continuous integration (CI)** infrastructure is one of the most critical solutions to address the above challenge. A CI service will monitor an open-source repository and run a suite of integration tests for every incoming contribution. This way, the CI ensures that every proposed change in the codebase is compatible with existing functionalities. Furthermore, XGBoost can enable more thorough tests with a powerful CI infrastructure to cover cases which are closer to the production environment.
 
-There are several CI services available free to open source projects, such as Travis CI and AppVeyor. The XGBoost project already utilizes GitHub Actions. However, the XGBoost project has needs that these free services do not adequately address. In particular, the limited usage quota of resources such as CPU and memory leaves XGBoost developers unable to bring "too-intensive" tests. In addition, they do not offer test machines with GPUs for testing XGBoost-GPU code base which has been attracting more and more interest across many organizations. Consequently, the XGBoost project uses a cloud-hosted test farm. We use `BuildKite <https://buildkite.com/xgboost>`_ to organize CI pipelines.
+There are several CI services available free to open source projects, such as Travis CI and AppVeyor. The XGBoost project already utilizes Travis and AppVeyor. However, the XGBoost project has needs that these free services do not adequately address. In particular, the limited usage quota of resources such as CPU and memory leaves XGBoost developers unable to bring "too-intensive" tests. In addition, they do not offer test machines with GPUs for testing XGBoost-GPU code base which has been attracting more and more interest across many organizations. Consequently, the XGBoost project self-hosts a cloud server with Jenkins software installed: https://xgboost-ci.net/.
 
-The cloud-hosted test farm has recurring operating expenses. It utilizes a leading cloud provider (AWS) to accommodate variable workload. BuildKite launches worker machines on AWS on demand, to run the test suite on incoming contributions. To save cost, the worker machines are terminated when they are no longer needed.
+The self-hosted Jenkins CI server has recurring operating expenses. It utilizes a leading cloud provider (AWS) to accommodate variable workload. The master node serving the web interface is available 24/7, to accommodate contributions from people around the globe. In addition, the master node launches slave nodes on demand, to run the test suite on incoming contributions. To save cost, the slave nodes are terminated when they are no longer needed.
 
 To help defray the hosting cost, the XGBoost project seeks donations from third parties.
 
@@ -29,14 +29,14 @@ The Project Management Committee (PMC) of the XGBoost project appointed `Open So
 
 All expenses incurred for hosting CI will be submitted to the fiscal host with receipts. Only the expenses in the following categories will be approved for reimbursement:
 
-* Cloud exprenses for the cloud test farm (https://buildkite.com/xgboost)
+* Cloud exprenses for the Jenkins CI server (https://xgboost-ci.net)
 * Cost of domain https://xgboost-ci.net
-* Monthly cost of using BuildKite
+* Meetup.com account for XGBoost project
 * Hosting cost of the User Forum (https://discuss.xgboost.ai)
 
-Administration of cloud CI infrastructure
------------------------------------------
-The PMC shall appoint committer(s) to administer the cloud CI infrastructure on their behalf. The current administrators are as follows:
+Administration of Jenkins CI server
+-----------------------------------
+The PMC shall appoint committer(s) to administer the Jenkins CI server on their behalf. The current administrators are as follows:
 
 * Primary administrator: `Hyunsu Cho <https://github.com/hcho3>`_
 * Secondary administrator: `Jiaming Yuan <https://github.com/trivialfis>`_

doc/contrib/release.rst

@@ -4,7 +4,7 @@ XGBoost Release Policy
 =======================
 
 Versioning Policy
------------------
+---------------------------
 
 Starting from XGBoost 1.0.0, each XGBoost release will be versioned as [MAJOR].[FEATURE].[MAINTENANCE]
 
@@ -34,20 +34,6 @@ Making a Release
 
    + The CRAN package is maintained by `Tong He <https://github.com/hetong007>`_ and `Jiaming Yuan <https://github.com/trivialfis>`__.
 
+     Before submitting a release, one should test the package on `R-hub <https://builder.r-hub.io/>`__ and `win-builder <https://win-builder.r-project.org/>`__ first.  Please note that the R-hub Windows instance doesn't have the exact same environment as the one hosted on win-builder.
+
    + The Maven package is maintained by `Nan Zhu <https://github.com/CodingCat>`_ and `Hyunsu Cho <https://github.com/hcho3>`_.
-
-
-R CRAN Package
---------------
-Before submitting a release, one should test the package on `R-hub <https://builder.r-hub.io/>`__ and `win-builder <https://win-builder.r-project.org/>`__ first.  Please note that the R-hub Windows instance doesn't have the exact same environment as the one hosted on win-builder.
-
-According to the `CRAN policy <https://cran.r-project.org/web/packages/policies.html>`__:
-
-    If running a package uses multiple threads/cores it must never use more than two simultaneously: the check farm is a shared resource and will typically be running many checks simultaneously.
-
-We need to check the number of CPUs used in examples. Export ``_R_CHECK_EXAMPLE_TIMING_CPU_TO_ELAPSED_THRESHOLD_=2.5`` before running ``R CMD check --as-cran`` `[1] <#references>`__ and make sure the machine you are using has enough CPU cores to reveal any potential policy violation.
-
-References
-----------
-
-[1] https://stat.ethz.ch/pipermail/r-package-devel/2022q4/008610.html

doc/get_started.rst

@@ -19,18 +19,16 @@ Python
 
 .. code-block:: python
 
-  from xgboost import XGBClassifier
-  # read data
-  from sklearn.datasets import load_iris
-  from sklearn.model_selection import train_test_split
-  data = load_iris()
-  X_train, X_test, y_train, y_test = train_test_split(data['data'], data['target'], test_size=.2)
-  # create model instance
-  bst = XGBClassifier(n_estimators=2, max_depth=2, learning_rate=1, objective='binary:logistic')
-  # fit model
-  bst.fit(X_train, y_train)
-  # make predictions
-  preds = bst.predict(X_test)
+  import xgboost as xgb
+  # read in data
+  dtrain = xgb.DMatrix('demo/data/agaricus.txt.train')
+  dtest = xgb.DMatrix('demo/data/agaricus.txt.test')
+  # specify parameters via map
+  param = {'max_depth':2, 'eta':1, 'objective':'binary:logistic' }
+  num_round = 2
+  bst = xgb.train(param, dtrain, num_round)
+  # make prediction
+  preds = bst.predict(dtest)
 
 ***
 R

doc/gpu/index.rst

@@ -4,23 +4,68 @@ XGBoost GPU Support
 
 This page contains information about GPU algorithms supported in XGBoost.
 
-.. note:: CUDA 11.0, Compute Capability 5.0 required (See `this list <https://en.wikipedia.org/wiki/CUDA#GPUs_supported>`_ to look up compute capability of your GPU card.)
+.. note:: CUDA 10.1, Compute Capability 3.5 required
+
+  The GPU algorithms in XGBoost require a graphics card with compute capability 3.5 or higher, with
+  CUDA toolkits 10.1 or later.
+  (See `this list <https://en.wikipedia.org/wiki/CUDA#GPUs_supported>`_ to look up compute capability of your GPU card.)
 
 *********************************************
 CUDA Accelerated Tree Construction Algorithms
 *********************************************
-
-Most of the algorithms in XGBoost including training, prediction and evaluation can be accelerated with CUDA-capable GPUs.
+Tree construction (training) and prediction can be accelerated with CUDA-capable GPUs.
 
 Usage
 =====
-Specify the ``tree_method`` parameter as ``gpu_hist``. For details around the ``tree_method`` parameter, see :doc:`tree method </treemethod>`.
+Specify the ``tree_method`` parameter as one of the following algorithms.
+
+Algorithms
+----------
+
++-----------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| tree_method           | Description                                                                                                                                                           |
++=======================+=======================================================================================================================================================================+
+| gpu_hist              | Equivalent to the XGBoost fast histogram algorithm. Much faster and uses considerably less memory. NOTE: May run very slowly on GPUs older than Pascal architecture.  |
++-----------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 
 Supported parameters
 --------------------
 
+.. |tick| unicode:: U+2714
+.. |cross| unicode:: U+2718
+
++--------------------------------+--------------+
+| parameter                      | ``gpu_hist`` |
++================================+==============+
+| ``subsample``                  | |tick|       |
++--------------------------------+--------------+
+| ``sampling_method``            | |tick|       |
++--------------------------------+--------------+
+| ``colsample_bytree``           | |tick|       |
++--------------------------------+--------------+
+| ``colsample_bylevel``          | |tick|       |
++--------------------------------+--------------+
+| ``max_bin``                    | |tick|       |
++--------------------------------+--------------+
+| ``gamma``                      | |tick|       |
++--------------------------------+--------------+
+| ``gpu_id``                     | |tick|       |
++--------------------------------+--------------+
+| ``predictor``                  | |tick|       |
++--------------------------------+--------------+
+| ``grow_policy``                | |tick|       |
++--------------------------------+--------------+
+| ``monotone_constraints``       | |tick|       |
++--------------------------------+--------------+
+| ``interaction_constraints``    | |tick|       |
++--------------------------------+--------------+
+| ``single_precision_histogram`` | |tick|       |
++--------------------------------+--------------+
+
 GPU accelerated prediction is enabled by default for the above mentioned ``tree_method`` parameters but can be switched to CPU prediction by setting ``predictor`` to ``cpu_predictor``. This could be useful if you want to conserve GPU memory. Likewise when using CPU algorithms, GPU accelerated prediction can be enabled by setting ``predictor`` to ``gpu_predictor``.
 
+The experimental parameter ``single_precision_histogram`` can be set to True to enable building histograms using single precision. This may improve speed, in particular on older architectures.
+
 The device ordinal (which GPU to use if you have many of them) can be selected using the
 ``gpu_id`` parameter, which defaults to 0 (the first device reported by CUDA runtime).
 
@@ -54,9 +99,128 @@ See examples `here
 
 Multi-node Multi-GPU Training
 =============================
+XGBoost supports fully distributed GPU training using `Dask <https://dask.org/>`_. For
+getting started see our tutorial :doc:`/tutorials/dask` and worked examples `here
+<https://github.com/dmlc/xgboost/tree/master/demo/dask>`__, also Python documentation
+:ref:`dask_api` for complete reference.
 
-XGBoost supports fully distributed GPU training using `Dask <https://dask.org/>`_, ``Spark`` and ``PySpark``. For getting started with Dask see our tutorial :doc:`/tutorials/dask` and worked examples `here <https://github.com/dmlc/xgboost/tree/master/demo/dask>`__, also Python documentation :ref:`dask_api` for complete reference. For usage with ``Spark`` using Scala see :doc:`/jvm/xgboost4j_spark_gpu_tutorial`. Lastly for distributed GPU training with ``PySpark``, see :doc:`/tutorials/spark_estimator`.
 
+Objective functions
+===================
+Most of the objective functions implemented in XGBoost can be run on GPU.  Following table shows current support status.
+
++----------------------+-------------+
+| Objectives           | GPU support |
++----------------------+-------------+
+| reg:squarederror     | |tick|      |
++----------------------+-------------+
+| reg:squaredlogerror  | |tick|      |
++----------------------+-------------+
+| reg:logistic         | |tick|      |
++----------------------+-------------+
+| reg:pseudohubererror | |tick|      |
++----------------------+-------------+
+| binary:logistic      | |tick|      |
++----------------------+-------------+
+| binary:logitraw      | |tick|      |
++----------------------+-------------+
+| binary:hinge         | |tick|      |
++----------------------+-------------+
+| count:poisson        | |tick|      |
++----------------------+-------------+
+| reg:gamma            | |tick|      |
++----------------------+-------------+
+| reg:tweedie          | |tick|      |
++----------------------+-------------+
+| multi:softmax        | |tick|      |
++----------------------+-------------+
+| multi:softprob       | |tick|      |
++----------------------+-------------+
+| survival:cox         | |cross|     |
++----------------------+-------------+
+| survival:aft         | |tick|      |
++----------------------+-------------+
+| rank:pairwise        | |tick|      |
++----------------------+-------------+
+| rank:ndcg            | |tick|      |
++----------------------+-------------+
+| rank:map             | |tick|      |
++----------------------+-------------+
+
+Objective will run on GPU if GPU updater (``gpu_hist``), otherwise they will run on CPU by
+default.  For unsupported objectives XGBoost will fall back to using CPU implementation by
+default.  Note that when using GPU ranking objective, the result is not deterministic due
+to the non-associative aspect of floating point summation.
+
+Metric functions
+===================
+Following table shows current support status for evaluation metrics on the GPU.
+
++------------------------------+-------------+
+| Metric                       | GPU Support |
++==============================+=============+
+| rmse                         | |tick|      |
++------------------------------+-------------+
+| rmsle                        | |tick|      |
++------------------------------+-------------+
+| mae                          | |tick|      |
++------------------------------+-------------+
+| mape                         | |tick|      |
++------------------------------+-------------+
+| mphe                         | |tick|      |
++------------------------------+-------------+
+| logloss                      | |tick|      |
++------------------------------+-------------+
+| error                        | |tick|      |
++------------------------------+-------------+
+| merror                       | |tick|      |
++------------------------------+-------------+
+| mlogloss                     | |tick|      |
++------------------------------+-------------+
+| auc                          | |tick|      |
++------------------------------+-------------+
+| aucpr                        | |tick|      |
++------------------------------+-------------+
+| ndcg                         | |tick|      |
++------------------------------+-------------+
+| map                          | |tick|      |
++------------------------------+-------------+
+| poisson-nloglik              | |tick|      |
++------------------------------+-------------+
+| gamma-nloglik                | |tick|      |
++------------------------------+-------------+
+| cox-nloglik                  | |cross|     |
++------------------------------+-------------+
+| aft-nloglik                  | |tick|      |
++------------------------------+-------------+
+| interval-regression-accuracy | |tick|      |
++------------------------------+-------------+
+| gamma-deviance               | |tick|      |
++------------------------------+-------------+
+| tweedie-nloglik              | |tick|      |
++------------------------------+-------------+
+
+Similar to objective functions, default device for metrics is selected based on tree
+updater and predictor (which is selected based on tree updater).
+
+Benchmarks
+==========
+You can run benchmarks on synthetic data for binary classification:
+
+.. code-block:: bash
+
+  python tests/benchmark/benchmark_tree.py --tree_method=gpu_hist
+  python tests/benchmark/benchmark_tree.py --tree_method=hist
+
+Training time on 1,000,000 rows x 50 columns of random data with 500 boosting iterations and 0.25/0.75 test/train split with AMD Ryzen 7 2700 8 core @3.20GHz and NVIDIA 1080ti yields the following results:
+
++--------------+----------+
+| tree_method  | Time (s) |
++==============+==========+
+| gpu_hist     | 12.57    |
++--------------+----------+
+| hist         | 36.01    |
++--------------+----------+
 
 Memory usage
 ============
@@ -68,7 +232,7 @@ The dataset itself is stored on device in a compressed ELLPACK format. The ELLPA
 
 Working memory is allocated inside the algorithm proportional to the number of rows to keep track of gradients, tree positions and other per row statistics. Memory is allocated for histogram bins proportional to the number of bins, number of features and nodes in the tree. For performance reasons we keep histograms in memory from previous nodes in the tree, when a certain threshold of memory usage is passed we stop doing this to conserve memory at some performance loss.
 
-If you are getting out-of-memory errors on a big dataset, try the or :py:class:`xgboost.QuantileDMatrix` or :doc:`external memory version </tutorials/external_memory>`. Note that when ``external memory`` is used for GPU hist, it's best to employ gradient based sampling as well. Last but not least, ``inplace_predict`` can be preferred over ``predict`` when data is already on GPU. Both ``QuantileDMatrix`` and ``inplace_predict`` are automatically enabled if you are using the scikit-learn interface.
+If you are getting out-of-memory errors on a big dataset, try the or :py:class:`xgboost.DeviceQuantileDMatrix` or :doc:`external memory version </tutorials/external_memory>`.
 
 Developer notes
 ===============

doc/install.rst

@@ -64,11 +64,6 @@ Conda should be able to detect the existence of a GPU on your machine and instal
 
 Visit the `Miniconda website <https://docs.conda.io/en/latest/miniconda.html>`_ to obtain Conda.
 
-.. note:: ``py-xgboost-gpu`` not available on Windows.
-
-   The ``py-xgboost-gpu`` is currently not available on Windows. If you are using Windows,
-   please use ``pip`` to install XGBoost with GPU support.
-
 R
 -
 

doc/jvm/xgboost4j_spark_tutorial.rst

@@ -124,7 +124,7 @@ labels. A DataFrame like this (containing vector-represented features and numeri
 .. note::
 
   There is no need to assemble feature columns from version 1.6.1+. Instead, users can specify an array of
-  feature column names by ``setFeaturesCol(value: Array[String])`` and XGBoost4j-Spark will do it.
+  feture column names by ``setFeaturesCol(value: Array[String])`` and XGBoost4j-Spark will do it.
 
 Dealing with missing values
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -345,37 +345,11 @@ and then loading the model in another session:
   val xgbClassificationModel2 = XGBoostClassificationModel.load(xgbClassificationModelPath)
   xgbClassificationModel2.transform(xgbInput)
 
-.. note::
-
-  Besides dumping the model to raw format, users are able to dump the model to be json or ubj format from ``version 1.7.0+``.
-
-  .. code-block:: scala
-
-    val xgbClassificationModelPath = "/tmp/xgbClassificationModel"
-    xgbClassificationModel.write.overwrite().option("format", "json").save(xgbClassificationModelPath)
-
-
 With regards to ML pipeline save and load, please refer the next section.
 
 Interact with Other Bindings of XGBoost
 ---------------------------------------
-After we train a model with XGBoost4j-Spark on massive dataset, sometimes we want to do model serving
-in single machine or integrate it with other single node libraries for further processing.
-
-After saving the model, we can load this model with single node Python XGBoost directly from ``version 1.7.0+``.
-
-.. code-block:: scala
-
-  val xgbClassificationModelPath = "/tmp/xgbClassificationModel"
-  xgbClassificationModel.write.overwrite().save(xgbClassificationModelPath)
-
-.. code-block:: python
-
-  import xgboost as xgb
-  bst = xgb.Booster({'nthread': 4})
-  bst.load_model("/tmp/xgbClassificationModel/data/XGBoostClassificationModel")
-
-Before ``version 1.7.0``, XGBoost4j-Spark needs to export model to local manually by:
+After we train a model with XGBoost4j-Spark on massive dataset, sometimes we want to do model serving in single machine or integrate it with other single node libraries for further processing. XGBoost4j-Spark supports export model to local by:
 
 .. code-block:: scala
 

doc/model.schema

@@ -207,7 +207,7 @@
         }
       }
     },
-    "pseudo_huber_param": {
+    "pseduo_huber_param": {
       "type": "object",
       "properties": {
         "huber_slope": {
@@ -247,7 +247,7 @@
       "items": [
         {
           "type": "number",
-          "minimum": 1
+          "const": 1
         },
         {
           "type": "number",
@@ -400,6 +400,7 @@
                 "reg_loss_param"
               ]
             },
+
             {
               "type": "object",
               "properties": {
@@ -432,14 +433,6 @@
                 "tweedie_regression_param"
               ]
             },
-            {
-              "properties": {
-                "name": {
-                  "const": "reg:absoluteerror"
-                }
-              },
-              "type": "object"
-            },
             {
               "type": "object",
               "properties": {

doc/parameter.rst

@@ -44,7 +44,8 @@ General Parameters
 * ``validate_parameters`` [default to ``false``, except for Python, R and CLI interface]
 
   - When set to True, XGBoost will perform validation of input parameters to check whether
-    a parameter is used or not.
+    a parameter is used or not.  The feature is still experimental.  It's expected to have
+    some false positives.
 
 * ``nthread`` [default to maximum number of threads available if not set]
 
@@ -150,6 +151,15 @@ Parameters for Tree Booster
     - ``hist``: Faster histogram optimized approximate greedy algorithm.
     - ``gpu_hist``: GPU implementation of ``hist`` algorithm.
 
+* ``sketch_eps`` [default=0.03]
+
+  - Only used for ``updater=grow_local_histmaker``.
+  - This roughly translates into ``O(1 / sketch_eps)`` number of bins.
+    Compared to directly select number of bins, this comes with theoretical guarantee with sketch accuracy.
+  - Usually user does not have to tune this.
+    But consider setting to a lower number for more accurate enumeration of split candidates.
+  - range: (0, 1)
+
 * ``scale_pos_weight`` [default=1]
 
   - Control the balance of positive and negative weights, useful for unbalanced classes. A typical value to consider: ``sum(negative instances) / sum(positive instances)``. See :doc:`Parameters Tuning </tutorials/param_tuning>` for more discussion. Also, see Higgs Kaggle competition demo for examples: `R <https://github.com/dmlc/xgboost/blob/master/demo/kaggle-higgs/higgs-train.R>`_, `py1 <https://github.com/dmlc/xgboost/blob/master/demo/kaggle-higgs/higgs-numpy.py>`_, `py2 <https://github.com/dmlc/xgboost/blob/master/demo/kaggle-higgs/higgs-cv.py>`_, `py3 <https://github.com/dmlc/xgboost/blob/master/demo/guide-python/cross_validation.py>`_.
@@ -160,6 +170,7 @@ Parameters for Tree Booster
 
     - ``grow_colmaker``: non-distributed column-based construction of trees.
     - ``grow_histmaker``: distributed tree construction with row-based data splitting based on global proposal of histogram counting.
+    - ``grow_local_histmaker``: based on local histogram counting.
     - ``grow_quantile_histmaker``: Grow tree using quantized histogram.
     - ``grow_gpu_hist``: Grow tree with GPU.
     - ``sync``: synchronizes trees in all distributed nodes.
@@ -224,31 +235,24 @@ Parameters for Tree Booster
     list is a group of indices of features that are allowed to interact with each other.
     See :doc:`/tutorials/feature_interaction_constraint` for more information.
 
-.. _cat-param:
+Additional parameters for ``hist``, ``gpu_hist`` and ``approx`` tree method
+===========================================================================
 
-Parameters for Categorical Feature
-==================================
-
-These parameters are only used for training with categorical data. See
-:doc:`/tutorials/categorical` for more information.
-
-.. note:: These parameters are experimental. ``exact`` tree method is not yet supported.
+* ``single_precision_histogram``, [default= ``false``]
 
+  - Use single precision to build histograms instead of double precision.
 
 * ``max_cat_to_onehot``
 
-  .. versionadded:: 1.6.0
+  .. versionadded:: 1.6
+
+  .. note:: The support for this parameter is experimental.
 
   - A threshold for deciding whether XGBoost should use one-hot encoding based split for
     categorical data.  When number of categories is lesser than the threshold then one-hot
     encoding is chosen, otherwise the categories will be partitioned into children nodes.
-
-* ``max_cat_threshold``
-
-  .. versionadded:: 1.7.0
-
-  - Maximum number of categories considered for each split. Used only by partition-based
-    splits for preventing over-fitting.
+    Only relevant for regression and binary classification. Also, ``exact`` tree method is
+    not supported
 
 Additional parameters for Dart Booster (``booster=dart``)
 =========================================================
@@ -345,7 +349,6 @@ Specify the learning task and the corresponding learning objective. The objectiv
   - ``reg:squaredlogerror``: regression with squared log loss :math:`\frac{1}{2}[log(pred + 1) - log(label + 1)]^2`.  All input labels are required to be greater than -1.  Also, see metric ``rmsle`` for possible issue  with this objective.
   - ``reg:logistic``: logistic regression.
   - ``reg:pseudohubererror``: regression with Pseudo Huber loss, a twice differentiable alternative to absolute loss.
-  - ``reg:absoluteerror``: Regression with L1 error. When tree model is used, leaf value is refreshed after tree construction. If used in distributed training, the leaf value is calculated as the mean value from all workers, which is not guaranteed to be optimal.
   - ``binary:logistic``: logistic regression for binary classification, output probability
   - ``binary:logitraw``: logistic regression for binary classification, output score before logistic transformation
   - ``binary:hinge``: hinge loss for binary classification. This makes predictions of 0 or 1, rather than producing probabilities.
@@ -366,11 +369,9 @@ Specify the learning task and the corresponding learning objective. The objectiv
   - ``reg:gamma``: gamma regression with log-link. Output is a mean of gamma distribution. It might be useful, e.g., for modeling insurance claims severity, or for any outcome that might be `gamma-distributed <https://en.wikipedia.org/wiki/Gamma_distribution#Occurrence_and_applications>`_.
   - ``reg:tweedie``: Tweedie regression with log-link. It might be useful, e.g., for modeling total loss in insurance, or for any outcome that might be `Tweedie-distributed <https://en.wikipedia.org/wiki/Tweedie_distribution#Occurrence_and_applications>`_.
 
-* ``base_score``
+* ``base_score`` [default=0.5]
 
   - The initial prediction score of all instances, global bias
-  - The parameter is automatically estimated for selected objectives before training. To
-    disable the estimation, specify a real number argument.
   - For sufficient number of iterations, changing this value will not have too much effect.
 
 * ``eval_metric`` [default according to objective]

doc/prediction.rst

@@ -153,7 +153,7 @@ underlying booster is ``gbtree`` or ``dart``, which means as long as tree model
 prediction itself should thread safe.  But the safety is only guaranteed with prediction.
 If one tries to train a model in one thread and provide prediction at the other using the
 same model the behaviour is undefined.  This happens easier than one might expect, for
-instance we might accidentally call ``clf.set_params()`` inside a predict function:
+instance we might accidientally call ``clf.set_params()`` inside a predict function:
 
 .. code-block:: python
 

doc/python/.gitignore

@@ -1,3 +1,2 @@
 examples
-dask-examples
-survival-examples
+dask-examples

doc/python/index.rst

@@ -15,4 +15,3 @@ Contents
   model
   examples/index
   dask-examples/index
-  survival-examples/index