save changes

include/LightGBM/feature_group.h

@@ -286,7 +286,10 @@ class FeatureGroup {
   }
 
   inline void CopySubrowByCol(const FeatureGroup* full_feature, const data_size_t* used_indices, data_size_t num_used_indices, int fidx) {
+    Log::Warning("in CopySubrowByCol");
     if (!is_multi_val_) {
+      Log::Warning("is not multi val");
+      Log::Warning("full_feature->bin_data_.get() = %ld", full_feature->bin_data_.get());
       bin_data_->CopySubrow(full_feature->bin_data_.get(), used_indices, num_used_indices);
     } else {
       multi_bin_data_[fidx]->CopySubrow(full_feature->multi_bin_data_[fidx].get(), used_indices, num_used_indices);

include/LightGBM/objective_function.h

@@ -108,6 +108,11 @@ class ObjectiveFunction {
   virtual bool NeedConvertOutputCUDA () const { return false; }
 
   #endif  // USE_CUDA
+
+  virtual void SetDataIndices(const data_size_t* used_data_indices) const { used_data_indices_ = used_data_indices; }
+
+ private:
+  mutable const data_size_t* used_data_indices_ = nullptr;
 };
 
 void UpdatePointwiseScoresForOneQuery(data_size_t query_id, double* score_pointwise, const double* score_pairwise, data_size_t cnt_pointwise,

src/boosting/bagging.hpp

@@ -60,6 +60,7 @@ class BaggingSampleStrategy : public SampleStrategy {
       } else {
         // get subset
         tmp_subset_->ReSize(bag_data_cnt_);
+        Log::Warning("bag_data_indices_.size() = %ld, bag_data_cnt_ = %d", bag_data_indices_.size(), bag_data_cnt_);
         tmp_subset_->CopySubrow(train_data_, bag_data_indices_.data(),
                                 bag_data_cnt_, false);
         #ifdef USE_CUDA
@@ -119,8 +120,10 @@ class BaggingSampleStrategy : public SampleStrategy {
           (static_cast<double>(bag_data_cnt_) / num_data_) / config_->bagging_freq;
       is_use_subset_ = false;
       if (config_->device_type != std::string("cuda")) {
-        const int group_threshold_usesubset = 100;
+        const int group_threshold_usesubset = 200;
         const double average_bag_rate_threshold = 0.5;
+        Log::Warning("train_data_->num_feature_groups() = %d", train_data_->num_feature_groups());
+        Log::Warning("average_bag_rate = %f", average_bag_rate);
         if (average_bag_rate <= average_bag_rate_threshold
             && (train_data_->num_feature_groups() < group_threshold_usesubset)) {
           if (tmp_subset_ == nullptr || is_change_dataset) {

src/boosting/gbdt.cpp

@@ -339,6 +339,8 @@ bool GBDT::TrainOneIter(const score_t* gradients, const score_t* hessians) {
     for (int cur_tree_id = 0; cur_tree_id < num_tree_per_iteration_; ++cur_tree_id) {
       init_scores[cur_tree_id] = BoostFromAverage(cur_tree_id, true);
     }
+    data_sample_strategy_->Bagging(iter_, tree_learner_.get(), gradients_.data(), hessians_.data());
+    objective_function_->SetDataIndices(data_sample_strategy_->bag_data_indices().data());
     Boosting();
     gradients = gradients_pointer_;
     hessians = hessians_pointer_;
@@ -361,7 +363,6 @@ bool GBDT::TrainOneIter(const score_t* gradients, const score_t* hessians) {
   }
 
   // bagging logic
-  data_sample_strategy_->Bagging(iter_, tree_learner_.get(), gradients_.data(), hessians_.data());
   const bool is_use_subset = data_sample_strategy_->is_use_subset();
   const data_size_t bag_data_cnt = data_sample_strategy_->bag_data_cnt();
   const std::vector<data_size_t, Common::AlignmentAllocator<data_size_t, kAlignedSize>>& bag_data_indices = data_sample_strategy_->bag_data_indices();

src/io/dataset.cpp

@@ -1140,6 +1140,7 @@ void Dataset::CopySubrow(const Dataset* fullset,
                          data_size_t num_used_indices, bool need_meta_data) {
   CHECK_EQ(num_used_indices, num_data_);
 
+  Log::Warning("copy subrow here !!!!");
   std::vector<int> group_ids, subfeature_ids;
   group_ids.reserve(num_features_);
   subfeature_ids.reserve(num_features_);
@@ -1155,20 +1156,24 @@ void Dataset::CopySubrow(const Dataset* fullset,
       subfeature_ids.emplace_back(-1);
     }
   }
+  Log::Warning("copy subrow step 0 !!!!");
   int num_copy_tasks = static_cast<int>(group_ids.size());
-
-  OMP_INIT_EX();
-  #pragma omp parallel for num_threads(OMP_NUM_THREADS()) schedule(dynamic)
+  // OMP_INIT_EX();
+  // #pragma omp parallel for num_threads(OMP_NUM_THREADS()) schedule(dynamic)
   for (int task_id = 0; task_id < num_copy_tasks; ++task_id) {
-    OMP_LOOP_EX_BEGIN();
+    // OMP_LOOP_EX_BEGIN();
+    Log::Warning("before copy sub row by col 0");
     int group = group_ids[task_id];
     int subfeature = subfeature_ids[task_id];
+    Log::Warning("before copy sub row by col 1");
     feature_groups_[group]->CopySubrowByCol(fullset->feature_groups_[group].get(),
                                             used_indices, num_used_indices, subfeature);
-    OMP_LOOP_EX_END();
+    Log::Warning("after copy sub row by col");
+    // OMP_LOOP_EX_END();
   }
-  OMP_THROW_EX();
+  // OMP_THROW_EX();
 
+  Log::Warning("copy subrow step 1 !!!!");
   if (need_meta_data) {
     metadata_.Init(fullset->metadata_, used_indices, num_used_indices);
   }
@@ -1188,6 +1193,8 @@ void Dataset::CopySubrow(const Dataset* fullset,
   device_type_ = fullset->device_type_;
   gpu_device_id_ = fullset->gpu_device_id_;
 
+  Log::Warning("copy subrow step 2 !!!!");
+
   #ifdef USE_CUDA
   if (device_type_ == std::string("cuda")) {
     if (cuda_column_data_ == nullptr) {

src/io/dense_bin.hpp

@@ -566,8 +566,11 @@ class DenseBin : public Bin {
 
   void CopySubrow(const Bin* full_bin, const data_size_t* used_indices,
                   data_size_t num_used_indices) override {
+    Log::Warning("is dense");
     auto other_bin = dynamic_cast<const DenseBin<VAL_T, IS_4BIT>*>(full_bin);
+    Log::Warning("other bin created");
     if (IS_4BIT) {
+      Log::Warning("is 4 bit");
       const data_size_t rest = num_used_indices & 1;
       for (int i = 0; i < num_used_indices - rest; i += 2) {
         data_size_t idx = used_indices[i];
@@ -586,6 +589,7 @@ class DenseBin : public Bin {
       }
     } else {
       for (int i = 0; i < num_used_indices; ++i) {
+        CHECK_LT(used_indices[i], data_.size());
         data_[i] = other_bin->data_[used_indices[i]];
       }
     }

src/io/multi_val_pairwise_lambdarank_bin.hpp

@@ -71,9 +71,9 @@ class MultiValDensePairwiseLambdarankBin: public MultiValPairwiseLambdarankBin<B
         // if (bin != 0) {
         //   Log::Warning("first bin = %d, num_feature_ = %d", bin, this->num_feature_);
         // }
-        if (j == 0) {
-          Log::Warning("group index = %d bin = %d gradient = %f hessian = %f", j, bin, gradient, hessian);
-        }
+        // if (j == 0) {
+        //   Log::Warning("group index = %d bin = %d gradient = %f hessian = %f", j, bin, gradient, hessian);
+        // }
 
         const auto ti = (bin + this->offsets_[j]) << 1;
         grad[ti] += gradient;

src/io/pairwise_lambdarank_bin.cpp

@@ -52,6 +52,7 @@ void PairwiseRankingBin<BIN_TYPE, ITERATOR_TYPE>::Push(int tid, data_size_t idx,
 
 template <typename BIN_TYPE, template<typename> class ITERATOR_TYPE>
 void PairwiseRankingBin<BIN_TYPE, ITERATOR_TYPE>::CopySubrow(const Bin* full_bin, const data_size_t* used_indices, data_size_t num_used_indices) {
+  Log::Warning("copy subrow in pairwie ranking bin");
   unpaired_bin_->CopySubrow(full_bin, used_indices, num_used_indices);
 }
 
@@ -98,9 +99,9 @@ void DensePairwiseRankingBin<VAL_T, IS_4BIT, ITERATOR_TYPE>::ConstructHistogramI
     for (; i < pf_end; ++i) {
       const auto paired_idx = USE_INDICES ? data_indices[i] : i;
       const auto ti = GetBinAt(paired_idx) << 1;
-      if (this->group_index_ == 0) {
-        Log::Warning("group index = %d bin = %d gradient = %f hessian = %f", this->group_index_, ti / 2, ordered_gradients[i], ordered_hessians[i]);
-      }
+      // if (this->group_index_ == 0) {
+      //   Log::Warning("group index = %d bin = %d gradient = %f hessian = %f", this->group_index_, ti / 2, ordered_gradients[i], ordered_hessians[i]);
+      // }
       if (USE_HESSIAN) {
         grad[ti] += ordered_gradients[i];
         hess[ti] += ordered_hessians[i];
@@ -113,9 +114,9 @@ void DensePairwiseRankingBin<VAL_T, IS_4BIT, ITERATOR_TYPE>::ConstructHistogramI
   for (; i < end; ++i) {
     const auto paired_idx = USE_INDICES ? data_indices[i] : i;
     const auto ti = GetBinAt(paired_idx) << 1;
-    if (this->group_index_ == 0) {
-      Log::Warning("group index = %d bin = %d gradient = %f hessian = %f", this->group_index_, ti / 2, ordered_gradients[i], ordered_hessians[i]);
-    }
+    // if (this->group_index_ == 0) {
+    //   Log::Warning("group index = %d bin = %d gradient = %f hessian = %f", this->group_index_, ti / 2, ordered_gradients[i], ordered_hessians[i]);
+    // }
     if (USE_HESSIAN) {
       grad[ti] += ordered_gradients[i];
       hess[ti] += ordered_hessians[i];

src/io/sparse_bin.hpp

@@ -745,9 +745,11 @@ class SparseBin : public Bin {
 
   void CopySubrow(const Bin* full_bin, const data_size_t* used_indices,
                   data_size_t num_used_indices) override {
+      Log::Warning("is sparse");
     auto other_bin = dynamic_cast<const SparseBin<VAL_T>*>(full_bin);
     deltas_.clear();
     vals_.clear();
+      Log::Warning("is sparse");
     data_size_t start = 0;
     if (num_used_indices > 0) {
       start = used_indices[0];

src/io/train_share_states.cpp

@@ -374,6 +374,7 @@ void TrainingShareStates::CalcBinOffsets(const std::vector<std::unique_ptr<Featu
   offsets->clear();
   feature_hist_offsets_.clear();
   if (in_is_col_wise) {
+    // Log::Fatal("not supported 0");
     uint32_t cur_num_bin = 0;
     uint32_t hist_cur_num_bin = 0;
     for (int group = 0; group < static_cast<int>(feature_groups.size()); ++group) {
@@ -438,9 +439,10 @@ void TrainingShareStates::CalcBinOffsets(const std::vector<std::unique_ptr<Featu
       }
     }
     sum_dense_ratio /= ncol;
-    const bool is_sparse_row_wise = (1.0f - sum_dense_ratio) >=
-      MultiValBin::multi_val_bin_sparse_threshold ? 1 : 0;
+    const bool is_sparse_row_wise = false; //(1.0f - sum_dense_ratio) >=
+      // MultiValBin::multi_val_bin_sparse_threshold ? 1 : 0;
     if (is_sparse_row_wise) {
+      // Log::Fatal("not supported 1");
       int cur_num_bin = 1;
       uint32_t hist_cur_num_bin = 1;
       for (int group = 0; group < static_cast<int>(feature_groups.size()); ++group) {
@@ -474,6 +476,7 @@ void TrainingShareStates::CalcBinOffsets(const std::vector<std::unique_ptr<Featu
       for (int group = 0; group < static_cast<int>(feature_groups.size()); ++group) {
         const std::unique_ptr<FeatureGroup>& feature_group = feature_groups[group];
         if (feature_group->is_multi_val_) {
+          Log::Fatal("not supported 2");
           for (int i = 0; i < feature_group->num_feature_; ++i) {
             const std::unique_ptr<BinMapper>& bin_mapper = feature_group->bin_mappers_[i];
             if (group == 0 && i == 0 && bin_mapper->GetMostFreqBin() > 0) {

src/treelearner/serial_tree_learner.cpp

@@ -757,7 +757,7 @@ void SerialTreeLearner::SplitInner(Tree* tree, int best_leaf, int* left_leaf,
                                    int* right_leaf, bool update_cnt) {
   Common::FunctionTimer fun_timer("SerialTreeLearner::SplitInner", global_timer);
 
-  histogram_pool_.DumpContent();
+  // histogram_pool_.DumpContent();
 
   SplitInfo& best_split_info = best_split_per_leaf_[best_leaf];
   const int inner_feature_index =
@@ -900,7 +900,7 @@ void SerialTreeLearner::SplitInner(Tree* tree, int best_leaf, int* left_leaf,
   }
 
   // #ifdef DEBUG
-  CheckSplit(best_split_info, *left_leaf, *right_leaf);
+  // CheckSplit(best_split_info, *left_leaf, *right_leaf);
   // #endif
 
   auto leaves_need_update = constraints_->Update(