cutpoint_candidates.h

 
#ifndef STOCHTREE_CUTPOINT_CANDIDATES_H_
#define STOCHTREE_CUTPOINT_CANDIDATES_H_
 
#include <stochtree/meta.h>
#include <stochtree/partition_tracker.h>
 
namespace StochTree {
 
class FeatureCutpointGrid {
 public:
  FeatureCutpointGrid(int cutpoint_grid_size) : node_stride_begin_{}, node_stride_length_{}, cutpoint_grid_size_{cutpoint_grid_size} {}
 
  ~FeatureCutpointGrid() {}
 
  void CalculateStrides(Eigen::MatrixXd& covariates, Eigen::VectorXd& residuals, SortedNodeSampleTracker* feature_node_sort_tracker, int32_t node_id, data_size_t node_begin, data_size_t node_end, int32_t feature_index, std::vector<FeatureType>& feature_types);
 
  void CalculateStridesNumeric(Eigen::MatrixXd& covariates, Eigen::VectorXd& residuals, SortedNodeSampleTracker* feature_node_sort_tracker, int32_t node_id, data_size_t node_begin, data_size_t node_end, int32_t feature_index);
 
  void CalculateStridesOrderedCategorical(Eigen::MatrixXd& covariates, Eigen::VectorXd& residuals, SortedNodeSampleTracker* feature_node_sort_tracker, int32_t node_id, data_size_t node_begin, data_size_t node_end, int32_t feature_index);
 
  void CalculateStridesUnorderedCategorical(Eigen::MatrixXd& covariates, Eigen::VectorXd& residuals, SortedNodeSampleTracker* feature_node_sort_tracker, int32_t node_id, data_size_t node_begin, data_size_t node_end, int32_t feature_index);
 
  int32_t NumCutpoints() { return node_stride_begin_.size(); }
 
  int32_t BinStartIndex(int i) { return node_stride_begin_.at(i); }
 
  int32_t BinLength(int i) { return node_stride_length_.at(i); }
 
  int32_t BinEndIndex(int i) { return node_stride_begin_.at(i) + node_stride_length_.at(i); }
 
  double CutpointValue(int i) { return cutpoint_values_.at(i); }
 
  std::vector<std::uint32_t> CutpointVector(int i) {
    std::vector<std::uint32_t> out;
    int bin_stop = i + 1;
    for (int j = 0; j < bin_stop; j++) {
      out.push_back(static_cast<std::uint32_t>(cutpoint_values_.at(j)));
    }
    return out;
  }
 
 private:
  std::vector<data_size_t> node_stride_begin_;
  std::vector<data_size_t> node_stride_length_;
  std::vector<double> cutpoint_values_;
  int32_t cutpoint_grid_size_;
 
  void EnumerateNumericCutpointsDeduplication(Eigen::MatrixXd& covariates, Eigen::VectorXd& residuals, SortedNodeSampleTracker* feature_node_sort_tracker, int32_t node_id, data_size_t node_begin, data_size_t node_end, data_size_t node_size, int32_t feature_index);
 
  void ScanNumericCutpoints(Eigen::MatrixXd& covariates, Eigen::VectorXd& residuals, SortedNodeSampleTracker* feature_node_sort_tracker, int32_t node_id, data_size_t node_begin, data_size_t node_end, data_size_t node_size, int32_t feature_index);
};
 
class CutpointGridContainer {
 public:
  CutpointGridContainer(Eigen::MatrixXd& covariates, Eigen::VectorXd& residuals, int cutpoint_grid_size) {
    num_features_ = covariates.cols();
    feature_cutpoint_grid_.resize(num_features_);
    for (int i = 0; i < num_features_; i++) {
      feature_cutpoint_grid_[i].reset(new FeatureCutpointGrid(cutpoint_grid_size));
    }
    cutpoint_grid_size_ = cutpoint_grid_size;
  }
 
  ~CutpointGridContainer() {}
 
  void Reset(Eigen::MatrixXd& covariates, Eigen::VectorXd& residuals, int cutpoint_grid_size) {
    num_features_ = covariates.cols();
    feature_cutpoint_grid_.resize(num_features_);
    for (int i = 0; i < num_features_; i++) {
      feature_cutpoint_grid_[i].reset(new FeatureCutpointGrid(cutpoint_grid_size));
    }
    cutpoint_grid_size_ = cutpoint_grid_size;
  }
 
  void CalculateStrides(Eigen::MatrixXd& covariates, Eigen::VectorXd& residuals, SortedNodeSampleTracker* feature_node_sort_tracker, int32_t node_id, data_size_t node_begin, data_size_t node_end, int32_t feature_index, std::vector<FeatureType>& feature_types) {
    feature_cutpoint_grid_[feature_index]->CalculateStrides(covariates, residuals, feature_node_sort_tracker, node_id, node_begin, node_end, feature_index, feature_types);
  }
 
  int32_t CutpointGridSize() { return cutpoint_grid_size_; }
 
  int32_t NumCutpoints(int feature_index) { return feature_cutpoint_grid_[feature_index]->NumCutpoints(); }
 
  int32_t BinStartIndex(int i, int feature_index) { return feature_cutpoint_grid_[feature_index]->BinStartIndex(i); }
 
  int32_t BinLength(int i, int feature_index) { return feature_cutpoint_grid_[feature_index]->BinLength(i); }
 
  int32_t BinEndIndex(int i, int feature_index) { return feature_cutpoint_grid_[feature_index]->BinEndIndex(i); }
 
  double CutpointValue(int i, int feature_index) { return feature_cutpoint_grid_[feature_index]->CutpointValue(i); }
 
  std::vector<std::uint32_t> CutpointVector(int i, int feature_index) {
    return feature_cutpoint_grid_[feature_index]->CutpointVector(i);
  }
 
  FeatureCutpointGrid* GetFeatureCutpointGrid(int feature_num) { return feature_cutpoint_grid_[feature_num].get(); }
 
 private:
  std::vector<std::unique_ptr<FeatureCutpointGrid>> feature_cutpoint_grid_;
  int num_features_;
  int cutpoint_grid_size_;
};
 
class NodeCutpointTracker {
 public:
  NodeCutpointTracker(int cutpoint_grid_size) : node_stride_begin_{}, node_stride_length_{}, cutpoint_grid_size_{cutpoint_grid_size}, nodes_enumerated_{} {}
 
  ~NodeCutpointTracker() {}
 
  void CalculateStrides(Eigen::MatrixXd& covariates, Eigen::VectorXd& residuals, SortedNodeSampleTracker* feature_node_sort_tracker, int32_t node_id, data_size_t node_begin, data_size_t node_end, int32_t feature_index);
 
  void CalculateStridesNumeric(Eigen::MatrixXd& covariates, Eigen::VectorXd& residuals, SortedNodeSampleTracker* feature_node_sort_tracker, data_size_t node_begin, data_size_t node_end, int32_t feature_index);
 
  void CalculateStridesCategorical(Eigen::MatrixXd& covariates, Eigen::VectorXd& residuals, SortedNodeSampleTracker* feature_node_sort_tracker, data_size_t node_begin, data_size_t node_end, int32_t feature_index);
 
  int32_t NumCutpoints() { return node_stride_begin_.size(); }
 
  bool NodeCutpointEvaluated(int32_t node_id) {
    return (std::find(nodes_enumerated_.begin(), nodes_enumerated_.end(), node_id) != nodes_enumerated_.end());
  }
 
  int32_t CurrentNodeEvaluated() { return current_node_; }
 
  std::vector<data_size_t> node_stride_begin_;
  std::vector<data_size_t> node_stride_length_;
 
 private:
  int32_t cutpoint_grid_size_;
  std::vector<int32_t> nodes_enumerated_;
  int32_t current_node_;
};
 
}  // namespace StochTree
 
#endif  // STOCHTREE_CUTPOINT_CANDIDATES_H_