Implement a tree view for the scalar tree. (#11741)

- Add scalar tree view.
- Replace the GPU-specific tree view.
- Replace the walk tree routine.
- Replace the multi-target-specific prediction function.

Author: trivialfis

R-package/src/Makevars.in

@@ -90,6 +90,7 @@ OBJECTS= \
     $(PKGROOT)/src/tree/param.o \
     $(PKGROOT)/src/tree/fit_stump.o \
     $(PKGROOT)/src/tree/tree_model.o \
+    $(PKGROOT)/src/tree/tree_view.o \
     $(PKGROOT)/src/tree/tree_updater.o \
     $(PKGROOT)/src/tree/multi_target_tree_model.o \
     $(PKGROOT)/src/tree/updater_approx.o \

R-package/src/Makevars.win.in

@@ -89,6 +89,7 @@ OBJECTS= \
     $(PKGROOT)/src/tree/param.o \
     $(PKGROOT)/src/tree/fit_stump.o \
     $(PKGROOT)/src/tree/tree_model.o \
+    $(PKGROOT)/src/tree/tree_view.o \
     $(PKGROOT)/src/tree/multi_target_tree_model.o \
     $(PKGROOT)/src/tree/tree_updater.o \
     $(PKGROOT)/src/tree/updater_approx.o \

include/xgboost/base.h

@@ -114,7 +114,7 @@ using bst_bin_t = std::int32_t;  // NOLINT
  */
 using bst_idx_t = std::uint64_t;  // NOLINT
 /**
- * \brief Type for tree node index.
+ * \brief Type for tree node index and tree depth.
  */
 using bst_node_t = std::int32_t;      // NOLINT
 /**

include/xgboost/multi_target_tree_model.h

@@ -15,60 +15,21 @@
 
 #include <cstddef>  // for size_t
 #include <cstdint>  // for uint8_t
-#include <mutex>    // for mutex
 #include <vector>   // for vector
 
 namespace xgboost {
+namespace tree {
+struct MultiTargetTreeView;
+}
 struct TreeParam;
-/**
- * @brief A view to the @MultiTargetTree suitable for both host and device.
- */
-struct MultiTargetTreeView {
-  static bst_node_t constexpr InvalidNodeId() { return -1; }
-
-  bst_node_t const* left;
-  bst_node_t const* right;
-  bst_node_t const* parent;
-
-  bst_feature_t const* split_index;
-  std::uint8_t const* default_left;
-  float const* split_conds;
-
-  // The number of nodes
-  std::size_t n{0};
-
-  linalg::MatrixView<float const> weights;
-
-  [[nodiscard]] XGBOOST_DEVICE bool IsLeaf(bst_node_t nidx) const {
-    return left[nidx] == InvalidNodeId();
-  }
-
-  [[nodiscard]] XGBOOST_DEVICE bst_node_t LeftChild(bst_node_t nidx) const { return left[nidx]; }
-  [[nodiscard]] XGBOOST_DEVICE bst_node_t RightChild(bst_node_t nidx) const { return right[nidx]; }
-  [[nodiscard]] XGBOOST_DEVICE bst_feature_t SplitIndex(bst_node_t nidx) const {
-    return split_index[nidx];
-  }
-  [[nodiscard]] XGBOOST_DEVICE float SplitCond(bst_node_t nidx) const { return split_conds[nidx]; }
-  [[nodiscard]] XGBOOST_DEVICE bool DefaultLeft(bst_node_t nidx) const {
-    return default_left[nidx];
-  }
-  [[nodiscard]] XGBOOST_DEVICE bst_node_t DefaultChild(bst_node_t nidx) const {
-    return this->DefaultLeft(nidx) ? this->LeftChild(nidx) : this->RightChild(nidx);
-  }
-  [[nodiscard]] XGBOOST_DEVICE linalg::VectorView<float const> LeafValue(bst_node_t nidx) const {
-    return this->weights.Slice(nidx, linalg::All());
-  }
-
-  [[nodiscard]] bst_target_t NumTargets() const { return this->weights.Shape(1); }
-  [[nodiscard]] bst_node_t Size() const { return this->n; }
-};
 
 /**
  * @brief Tree structure for multi-target model.
  */
 class MultiTargetTree : public Model {
  public:
-  static bst_node_t constexpr InvalidNodeId() { return MultiTargetTreeView::InvalidNodeId(); }
+  static bst_node_t constexpr InvalidNodeId() { return -1; }
+  friend struct tree::MultiTargetTreeView;
 
  private:
   TreeParam const* param_;
@@ -80,8 +41,6 @@ class MultiTargetTree : public Model {
   HostDeviceVector<float> split_conds_;
   HostDeviceVector<float> weights_;
 
-  mutable std::mutex tree_view_lock_;
-
   [[nodiscard]] linalg::VectorView<float const> NodeWeight(bst_node_t nidx) const {
     auto beg = nidx * this->NumTargets();
     auto v = this->weights_.ConstHostSpan().subspan(beg, this->NumTargets());
@@ -140,27 +99,27 @@ class MultiTargetTree : public Model {
 
   [[nodiscard]] bst_target_t NumTargets() const;
 
+  [[nodiscard]] auto NumLeaves() const { return this->weights_.Size() / this->NumTargets(); }
+
+  [[nodiscard]] bool IsLeftChild(bst_node_t nidx) const {
+    auto p = this->Parent(nidx);
+    return nidx == this->LeftChild(p);
+  }
   [[nodiscard]] std::size_t Size() const;
+  [[nodiscard]] MultiTargetTree* Copy(TreeParam const* param) const;
 
-  [[nodiscard]] bst_node_t Depth(bst_node_t nidx) const {
-    bst_node_t depth{0};
-    while (Parent(nidx) != InvalidNodeId()) {
-      ++depth;
-      nidx = Parent(nidx);
+  common::Span<float const> Weights(DeviceOrd device) const {
+    if (device.IsCPU()) {
+      return this->weights_.ConstHostSpan();
     }
-    return depth;
+    this->weights_.SetDevice(device);
+    return this->weights_.ConstDeviceSpan();
   }
 
   [[nodiscard]] linalg::VectorView<float const> LeafValue(bst_node_t nidx) const {
     CHECK(IsLeaf(nidx));
     return this->NodeWeight(nidx);
   }
-  /**
-   * @brief Get a view to the tree.
-   *
-   *   This method is NOT thread-safe.
-   */
-  [[nodiscard]] MultiTargetTreeView View(Context const* ctx) const;
 
   void LoadModel(Json const& in) override;
   void SaveModel(Json* out) const override;

include/xgboost/tree_model.h

@@ -1,7 +1,7 @@
 /**
  * Copyright 2014-2025, XGBoost Contributors
  *
- * \brief model structure for tree
+ * @brief model structure for tree
  * \author Tianqi Chen
  */
 #ifndef XGBOOST_TREE_MODEL_H_
@@ -10,20 +10,27 @@
 #include <xgboost/base.h>
 #include <xgboost/data.h>
 #include <xgboost/feature_map.h>
-#include <xgboost/linalg.h>  // for VectorView
+#include <xgboost/host_device_vector.h>  // for HostDeviceVector
+#include <xgboost/linalg.h>              // for VectorView
 #include <xgboost/logging.h>
 #include <xgboost/model.h>
 #include <xgboost/multi_target_tree_model.h>  // for MultiTargetTree
 
 #include <algorithm>
 #include <cstring>
-#include <limits>
-#include <memory>  // for make_unique
-#include <stack>
+#include <limits>  // for numeric_limits
+#include <memory>  // for unique_ptr
 #include <string>
+#include <type_traits>  // for is_signed_v
 #include <vector>
 
 namespace xgboost {
+
+namespace tree {
+struct ScalarTreeView;
+struct MultiTargetTreeView;
+}
+
 class Json;
 
 /** @brief meta parameters of the tree */
@@ -46,67 +53,39 @@ struct TreeParam {
   void ToJson(Json* p_out) const;
 };
 
-/*! \brief node statistics used in regression tree */
+/** @brief node statistics used in regression tree */
 struct RTreeNodeStat {
-  /*! \brief loss change caused by current split */
-  bst_float loss_chg;
-  /*! \brief sum of hessian values, used to measure coverage of data */
-  bst_float sum_hess;
-  /*! \brief weight of current node */
-  bst_float base_weight;
-  /*! \brief number of child that is leaf node known up to now */
-  int leaf_child_cnt {0};
+  /** @brief loss change caused by current split */
+  float loss_chg;
+  /** @brief sum of hessian values, used to measure coverage of data */
+  float sum_hess;
+  /** @brief weight of current node */
+  float base_weight;
+  /** @brief number of child that is leaf node known up to now */
+  int leaf_child_cnt{0};
 
   RTreeNodeStat() = default;
-  RTreeNodeStat(float loss_chg, float sum_hess, float weight) :
-      loss_chg{loss_chg}, sum_hess{sum_hess}, base_weight{weight} {}
+  RTreeNodeStat(float loss_chg, float sum_hess, float weight)
+      : loss_chg{loss_chg}, sum_hess{sum_hess}, base_weight{weight} {}
   bool operator==(const RTreeNodeStat& b) const {
-    return loss_chg == b.loss_chg && sum_hess == b.sum_hess &&
-           base_weight == b.base_weight && leaf_child_cnt == b.leaf_child_cnt;
+    return loss_chg == b.loss_chg && sum_hess == b.sum_hess && base_weight == b.base_weight &&
+           leaf_child_cnt == b.leaf_child_cnt;
   }
 };
 
 /**
- * \brief Helper for defining copyable data structure that contains unique pointers.
- */
-template <typename T>
-class CopyUniquePtr {
-  std::unique_ptr<T> ptr_{nullptr};
-
- public:
-  CopyUniquePtr() = default;
-  CopyUniquePtr(CopyUniquePtr const& that) {
-    ptr_.reset(nullptr);
-    if (that.ptr_) {
-      ptr_ = std::make_unique<T>(*that);
-    }
-  }
-  T* get() const noexcept { return ptr_.get(); }  // NOLINT
-
-  T& operator*() { return *ptr_; }
-  T* operator->() noexcept { return this->get(); }
-
-  T const& operator*() const { return *ptr_; }
-  T const* operator->() const noexcept { return this->get(); }
-
-  explicit operator bool() const { return static_cast<bool>(ptr_); }
-  bool operator!() const { return !ptr_; }
-  void reset(T* ptr) { ptr_.reset(ptr); }  // NOLINT
-};
-
-/**
- * \brief define regression tree to be the most common tree model.
+ * @brief define regression tree to be the most common tree model.
  *
  *  This is the data structure used in xgboost's major tree models.
  */
 class RegTree : public Model {
  public:
-  using SplitCondT = bst_float;
+  using SplitCondT = float;
   static constexpr bst_node_t kInvalidNodeId{MultiTargetTree::InvalidNodeId()};
   static constexpr uint32_t kDeletedNodeMarker = std::numeric_limits<uint32_t>::max();
   static constexpr bst_node_t kRoot{0};
 
-  /*! \brief tree node */
+  /** @brief tree node */
   class Node {
    public:
     XGBOOST_DEVICE Node()  {
@@ -305,31 +284,6 @@ class RegTree : public Model {
     return nodes_ == b.nodes_ && stats_ == b.stats_ &&
            deleted_nodes_ == b.deleted_nodes_ && param_ == b.param_;
   }
-  /* \brief Iterate through all nodes in this tree.
-   *
-   * \param Function that accepts a node index, and returns false when iteration should
-   *        stop, otherwise returns true.
-   */
-  template <typename Func> void WalkTree(Func func) const {
-    std::stack<bst_node_t> nodes;
-    nodes.push(kRoot);
-    auto &self = *this;
-    while (!nodes.empty()) {
-      auto nidx = nodes.top();
-      nodes.pop();
-      if (!func(nidx)) {
-        return;
-      }
-      auto left = self.LeftChild(nidx);
-      auto right = self.RightChild(nidx);
-      if (left != RegTree::kInvalidNodeId) {
-        nodes.push(left);
-      }
-      if (right != RegTree::kInvalidNodeId) {
-        nodes.push(right);
-      }
-    }
-  }
   /*!
    * \brief Compares whether 2 trees are equal from a user's perspective.  The equality
    *        compares only non-deleted nodes.
@@ -432,21 +386,10 @@ class RegTree : public Model {
   [[nodiscard]] bst_node_t GetNumLeaves() const;
   [[nodiscard]] bst_node_t GetNumSplitNodes() const;
 
-  /*!
-   * \brief get current depth
-   * \param nid node id
+  /**
+   * @brief Get the depth of a node.
    */
-  [[nodiscard]] std::int32_t GetDepth(bst_node_t nid) const {
-    if (IsMultiTarget()) {
-      return this->p_mt_tree_->Depth(nid);
-    }
-    int depth = 0;
-    while (!nodes_[nid].IsRoot()) {
-      ++depth;
-      nid = nodes_[nid].Parent();
-    }
-    return depth;
-  }
+  [[nodiscard]] bst_node_t GetDepth(bst_node_t nidx) const;
   /**
    * \brief Set the leaf weight for a multi-target tree.
    */
@@ -649,6 +592,10 @@ class RegTree : public Model {
     return this->nodes_.size();
   }
 
+  [[nodiscard]] RegTree* Copy() const;
+  tree::ScalarTreeView HostScView() const;
+  tree::MultiTargetTreeView HostMtView() const;
+
  private:
   template <bool typed>
   void LoadCategoricalSplit(Json const& in);
@@ -668,7 +615,7 @@ class RegTree : public Model {
   // Ptr to split categories of each node.
   std::vector<CategoricalSplitMatrix::Segment> split_categories_segments_;
   // ptr to multi-target tree with vector leaf.
-  CopyUniquePtr<MultiTargetTree> p_mt_tree_;
+  std::unique_ptr<MultiTargetTree> p_mt_tree_;
   // allocate a new node,
   // !!!!!! NOTE: may cause BUG here, nodes.resize
   bst_node_t AllocNode() {

src/gbm/gbtree.cc

@@ -459,7 +459,7 @@ void GBTree::Slice(bst_layer_t begin, bst_layer_t end, bst_layer_t step, Gradien
 
   *out_of_bound =
       detail::SliceTrees(begin, end, step, this->model_, [&](auto in_tree_idx, auto out_l) {
-        auto new_tree = std::make_unique<RegTree>(*this->model_.trees.at(in_tree_idx));
+        std::unique_ptr<RegTree> new_tree{this->model_.trees.at(in_tree_idx)->Copy()};
         out_trees.emplace_back(std::move(new_tree));
 
         bst_group_t group = this->model_.tree_info[in_tree_idx];

src/gbm/gbtree.h

@@ -18,7 +18,8 @@
 #include <vector>
 
 #include "../common/timer.h"
-#include "../tree/param.h"  // TrainParam
+#include "../tree/param.h"      // TrainParam
+#include "../tree/tree_view.h"  // for WalkTree
 #include "gbtree_model.h"
 #include "xgboost/base.h"
 #include "xgboost/data.h"
@@ -231,7 +232,7 @@ class GBTree : public GradientBooster {
       for (auto idx : trees) {
         CHECK_LE(idx, total_n_trees) << "Invalid tree index.";
         auto const& tree = *model_.trees[idx];
-        tree.WalkTree([&](bst_node_t nidx) {
+        tree::WalkTree(tree, [&](auto const& tree, bst_node_t nidx) {
           if (!tree.IsLeaf(nidx)) {
             split_counts[tree.SplitIndex(nidx)]++;
             fn(tree, nidx, tree.SplitIndex(nidx));
@@ -246,18 +247,20 @@ class GBTree : public GradientBooster {
         gain_map[split] = split_counts[split];
       });
     } else if (importance_type == "gain" || importance_type == "total_gain") {
-      if (!model_.trees.empty() && model_.trees.front()->IsMultiTarget()) {
-        LOG(FATAL) << "gain/total_gain " << MTNotImplemented();
-      }
       add_score([&](auto const& tree, bst_node_t nidx, bst_feature_t split) {
-        gain_map[split] += tree.Stat(nidx).loss_chg;
+        if constexpr (tree::IsScalarTree<decltype(tree)>()) {
+          gain_map[split] += tree.Stat(nidx).loss_chg;
+        } else {
+          LOG(FATAL) << "gain/total_gain " << MTNotImplemented();
+        }
       });
     } else if (importance_type == "cover" || importance_type == "total_cover") {
-      if (!model_.trees.empty() && model_.trees.front()->IsMultiTarget()) {
-        LOG(FATAL) << "cover/total_cover " << MTNotImplemented();
-      }
       add_score([&](auto const& tree, bst_node_t nidx, bst_feature_t split) {
-        gain_map[split] += tree.Stat(nidx).sum_hess;
+        if constexpr (tree::IsScalarTree<decltype(tree)>()) {
+          gain_map[split] += tree.Stat(nidx).sum_hess;
+        } else {
+          LOG(FATAL) << "cover/total_cover " << MTNotImplemented();
+        }
       });
     } else {
       LOG(FATAL)