save changes for debug

include/LightGBM/bin.h

@@ -537,6 +537,8 @@ class Bin {
   virtual const void* GetColWiseData(uint8_t* bit_type, bool* is_sparse, std::vector<BinIterator*>* bin_iterator, const int num_threads) const = 0;
 
   virtual const void* GetColWiseData(uint8_t* bit_type, bool* is_sparse, BinIterator** bin_iterator) const = 0;
+
+  int group_index_ = -1;
 };
 
 

include/LightGBM/feature_group.h

@@ -587,26 +587,26 @@ class FeatureGroup {
       multi_bin_data_.clear();
       for (int i = 0; i < num_feature_; ++i) {
         int addi = bin_mappers_[i]->GetMostFreqBin() == 0 ? 0 : 1;
-        if (bin_mappers_[i]->sparse_rate() >= kSparseThreshold) {
-          multi_bin_data_.emplace_back(Bin::CreateSparseBin(
-              num_data, bin_mappers_[i]->num_bin() + addi));
-        } else {
+        // if (bin_mappers_[i]->sparse_rate() >= kSparseThreshold) {
+        //   multi_bin_data_.emplace_back(Bin::CreateSparseBin(
+        //       num_data, bin_mappers_[i]->num_bin() + addi));
+        // } else {
           multi_bin_data_.emplace_back(
               Bin::CreateDenseBin(num_data, bin_mappers_[i]->num_bin() + addi));
-        }
+        // }
       }
       is_multi_val_ = true;
     } else {
-      if (force_sparse ||
-          (!force_dense && num_feature_ == 1 &&
-           bin_mappers_[0]->sparse_rate() >= kSparseThreshold)) {
-        is_sparse_ = true;
-        bin_data_.reset(Bin::CreateSparseBin(num_data, num_total_bin_));
-      } else {
+      // if (force_sparse ||
+      //     (!force_dense && num_feature_ == 1 &&
+      //      bin_mappers_[0]->sparse_rate() >= kSparseThreshold)) {
+      //   is_sparse_ = true;
+      //   bin_data_.reset(Bin::CreateSparseBin(num_data, num_total_bin_));
+      // } else {
         is_sparse_ = false;
         bin_data_.reset(Bin::CreateDenseBin(num_data, num_total_bin_));
-      }
-      is_multi_val_ = false;
+      // }
+      // is_multi_val_ = false;
     }
   }
 

src/io/bin.cpp

@@ -707,9 +707,10 @@ namespace LightGBM {
       // if (use_pairwise_ranking) {
         Log::Warning("Pairwise ranking with sparse row-wse bins is not supported yet.");
         return CreateMultiValDenseBin(num_data, num_bin, num_feature, offsets, use_pairwise_ranking, paired_ranking_item_global_index_map);
+      // } else {
+      //   return CreateMultiValSparseBin(num_data, num_bin,
+      //                                  average_element_per_row, use_pairwise_ranking, paired_ranking_item_global_index_map);
       // }
-      return CreateMultiValSparseBin(num_data, num_bin,
-                                    average_element_per_row, use_pairwise_ranking, paired_ranking_item_global_index_map);
     } else {
       return CreateMultiValDenseBin(num_data, num_bin, num_feature, offsets, use_pairwise_ranking, paired_ranking_item_global_index_map);
     }

src/io/dataset.cpp

@@ -499,6 +499,7 @@ void PushDataToMultiValBin(
     MultiValBin* ret) {
   Common::FunctionTimer fun_time("Dataset::PushDataToMultiValBin",
                                  global_timer);
+  Log::Warning("num_data = %d", num_data);
   if (ret->IsSparse()) {
     // Log::Fatal("pairwise ranking with sparse multi val bin is not supported.");
     Threading::For<data_size_t>(
@@ -634,11 +635,11 @@ MultiValBin* Dataset::GetMultiBinFromAllFeatures(const std::vector<uint32_t>& of
              1.0 - sum_dense_ratio);
   if (use_pairwise_ranking) {
 
-    for (size_t i = 0; i < iters.size(); ++i) {
-      for (size_t j = 0; j < iters[i].size(); ++j) {
-        Log::Warning("i = %ld, j = %ld, iters[i][j] = %d", i, j, static_cast<int>(iters[i][j] == nullptr));
-      }
-    }
+    // for (size_t i = 0; i < iters.size(); ++i) {
+    //   for (size_t j = 0; j < iters[i].size(); ++j) {
+    //     Log::Warning("i = %ld, j = %ld, iters[i][j] = %d", i, j, static_cast<int>(iters[i][j] == nullptr));
+    //   }
+    // }
 
     const int num_original_features = static_cast<int>(most_freq_bins.size()) / 2;
     std::vector<uint32_t> original_most_freq_bins;
@@ -662,7 +663,7 @@ MultiValBin* Dataset::GetMultiBinFromAllFeatures(const std::vector<uint32_t>& of
     ret.reset(MultiValBin::CreateMultiValBin(
         num_original_data, original_offsets.back(), num_original_features,
         1.0 - sum_dense_ratio, original_offsets, use_pairwise_ranking, metadata_.paired_ranking_item_global_index_map()));
-    PushDataToMultiValBin(num_original_features, original_most_freq_bins, original_offsets, &iters, ret.get());
+    PushDataToMultiValBin(num_original_data, original_most_freq_bins, original_offsets, &iters, ret.get());
   } else {
     ret.reset(MultiValBin::CreateMultiValBin(
         num_data_, offsets.back(), static_cast<int>(most_freq_bins.size()),
@@ -1632,6 +1633,7 @@ void Dataset::ConstructHistogramsInner(
       OMP_LOOP_EX_BEGIN();
       int group = used_dense_group[gi];
       const int num_bin = feature_groups_[group]->num_total_bin_;
+      feature_groups_[group]->bin_data_->group_index_ = gi;
       if (USE_QUANT_GRAD) {
         if (HIST_BITS == 16) {
           auto data_ptr = reinterpret_cast<hist_t*>(reinterpret_cast<int32_t*>(hist_data) + group_bin_boundaries_[group]);

src/io/multi_val_pairwise_lambdarank_bin.hpp

@@ -13,7 +13,9 @@ namespace LightGBM {
 template <typename BIN_TYPE, template<typename> class MULTI_VAL_BIN_TYPE>
 class MultiValPairwiseLambdarankBin : public MULTI_VAL_BIN_TYPE<BIN_TYPE> {
  public:
-  MultiValPairwiseLambdarankBin(data_size_t num_data, int num_bin, int num_feature, const std::vector<uint32_t>& offsets): MULTI_VAL_BIN_TYPE<BIN_TYPE>(num_data, num_bin, num_feature, offsets) {}
+  MultiValPairwiseLambdarankBin(data_size_t num_data, int num_bin, int num_feature, const std::vector<uint32_t>& offsets): MULTI_VAL_BIN_TYPE<BIN_TYPE>(num_data, num_bin, num_feature, offsets) {
+    this->num_bin_ = num_bin * 2;
+  }
  protected:
   const std::pair<data_size_t, data_size_t>* paired_ranking_item_global_index_map_;
 };
@@ -66,6 +68,13 @@ class MultiValDensePairwiseLambdarankBin: public MultiValPairwiseLambdarankBin<B
       const score_t hessian = ORDERED ? hessians[i] : hessians[idx];
       for (int j = 0; j < this->num_feature_; ++j) {
         const uint32_t bin = static_cast<uint32_t>(first_data_ptr[j]);
+        // 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);
+        }
+
         const auto ti = (bin + this->offsets_[j]) << 1;
         grad[ti] += gradient;
         hess[ti] += hessian;
@@ -76,6 +85,9 @@ class MultiValDensePairwiseLambdarankBin: public MultiValPairwiseLambdarankBin<B
       const auto base_offset = this->offsets_.back();
       for (int j = 0; j < this->num_feature_; ++j) {
         const uint32_t bin = static_cast<uint32_t>(second_data_ptr[j]);
+        // if (bin != 0) {
+        //   Log::Warning("second bin = %d, num_feature_ = %d", bin, this->num_feature_);
+        // }
         const auto ti = (bin + this->offsets_[j] + base_offset) << 1;
         grad[ti] += gradient;
         hess[ti] += hessian;

src/io/pairwise_lambdarank_bin.cpp

@@ -98,6 +98,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 (USE_HESSIAN) {
         grad[ti] += ordered_gradients[i];
         hess[ti] += ordered_hessians[i];
@@ -110,6 +113,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 (USE_HESSIAN) {
       grad[ti] += ordered_gradients[i];
       hess[ti] += ordered_hessians[i];

src/io/pairwise_ranking_feature_group.cpp

@@ -35,43 +35,43 @@ void PairwiseRankingFeatureGroup::CreateBinData(int num_data, bool is_multi_val,
     multi_bin_data_.clear();
     for (int i = 0; i < num_feature_; ++i) {
       int addi = bin_mappers_[i]->GetMostFreqBin() == 0 ? 0 : 1;
-      if (bin_mappers_[i]->sparse_rate() >= kSparseThreshold) {
-        if (is_first_or_second_in_pairing_ == 0) {
-          multi_bin_data_.emplace_back(Bin::CreateSparsePairwiseRankingFirstBin(
-              num_data, bin_mappers_[i]->num_bin() + addi, num_data_, paired_ranking_item_index_map_));
-        } else {
-          multi_bin_data_.emplace_back(Bin::CreateSparsePairwiseRankingSecondBin(
-              num_data, bin_mappers_[i]->num_bin() + addi, num_data_, paired_ranking_item_index_map_));
-        }
+      // if (bin_mappers_[i]->sparse_rate() >= kSparseThreshold) {
+      //   if (is_first_or_second_in_pairing_ == 0) {
+      //     multi_bin_data_.emplace_back(Bin::CreateSparsePairwiseRankingFirstBin(
+      //         num_data, bin_mappers_[i]->num_bin() + addi, num_data_, paired_ranking_item_index_map_));
+      //   } else {
+      //     multi_bin_data_.emplace_back(Bin::CreateSparsePairwiseRankingSecondBin(
+      //         num_data, bin_mappers_[i]->num_bin() + addi, num_data_, paired_ranking_item_index_map_));
+      //   }
+      // } else {
+      if (is_first_or_second_in_pairing_ == 0) {
+        multi_bin_data_.emplace_back(
+            Bin::CreateDensePairwiseRankingFirstBin(num_data, bin_mappers_[i]->num_bin() + addi, num_data_, paired_ranking_item_index_map_));
       } else {
-        if (is_first_or_second_in_pairing_ == 0) {
-          multi_bin_data_.emplace_back(
-              Bin::CreateDensePairwiseRankingFirstBin(num_data, bin_mappers_[i]->num_bin() + addi, num_data_, paired_ranking_item_index_map_));
-        } else {
-          multi_bin_data_.emplace_back(
-              Bin::CreateDensePairwiseRankingSecondBin(num_data, bin_mappers_[i]->num_bin() + addi, num_data_, paired_ranking_item_index_map_));
-        }
+        multi_bin_data_.emplace_back(
+            Bin::CreateDensePairwiseRankingSecondBin(num_data, bin_mappers_[i]->num_bin() + addi, num_data_, paired_ranking_item_index_map_));
       }
+      // }
     }
     is_multi_val_ = true;
   } else {
-    if (force_sparse ||
-        (!force_dense && num_feature_ == 1 &&
-          bin_mappers_[0]->sparse_rate() >= kSparseThreshold)) {
-      is_sparse_ = true;
-      if (is_first_or_second_in_pairing_ == 0) {
-        bin_data_.reset(Bin::CreateSparsePairwiseRankingFirstBin(num_data, num_total_bin_, num_data_, paired_ranking_item_index_map_));
-      } else {
-        bin_data_.reset(Bin::CreateSparsePairwiseRankingSecondBin(num_data, num_total_bin_, num_data_, paired_ranking_item_index_map_));
-      }
+    // if (force_sparse ||
+    //     (!force_dense && num_feature_ == 1 &&
+    //       bin_mappers_[0]->sparse_rate() >= kSparseThreshold)) {
+    //   is_sparse_ = true;
+    //   if (is_first_or_second_in_pairing_ == 0) {
+    //     bin_data_.reset(Bin::CreateSparsePairwiseRankingFirstBin(num_data, num_total_bin_, num_data_, paired_ranking_item_index_map_));
+    //   } else {
+    //     bin_data_.reset(Bin::CreateSparsePairwiseRankingSecondBin(num_data, num_total_bin_, num_data_, paired_ranking_item_index_map_));
+    //   }
+    // } else {
+    is_sparse_ = false;
+    if (is_first_or_second_in_pairing_ == 0) {
+      bin_data_.reset(Bin::CreateDensePairwiseRankingFirstBin(num_data, num_total_bin_, num_data_, paired_ranking_item_index_map_));
     } else {
-      is_sparse_ = false;
-      if (is_first_or_second_in_pairing_ == 0) {
-        bin_data_.reset(Bin::CreateDensePairwiseRankingFirstBin(num_data, num_total_bin_, num_data_, paired_ranking_item_index_map_));
-      } else {
-        bin_data_.reset(Bin::CreateDensePairwiseRankingSecondBin(num_data, num_total_bin_, num_data_, paired_ranking_item_index_map_));
-      }
+      bin_data_.reset(Bin::CreateDensePairwiseRankingSecondBin(num_data, num_total_bin_, num_data_, paired_ranking_item_index_map_));
     }
+    // }
     is_multi_val_ = false;
   }
 }

src/io/sparse_bin.hpp

@@ -77,6 +77,7 @@ class SparseBin : public Bin {
   explicit SparseBin(data_size_t num_data) : num_data_(num_data) {
     int num_threads = OMP_NUM_THREADS();
     push_buffers_.resize(num_threads);
+    Log::Warning("sparse bin is created !!!");
   }
 
   ~SparseBin() {}

src/treelearner/feature_histogram.hpp

@@ -20,6 +20,8 @@
 #include "monotone_constraints.hpp"
 #include "split_info.hpp"
 
+#include <fstream>
+
 namespace LightGBM {
 
 class FeatureMetainfo {
@@ -1501,6 +1503,7 @@ class HistogramPool {
       }
       OMP_THROW_EX();
     }
+    offsets_ = offsets;
   }
 
   void ResetConfig(const Dataset* train_data, const Config* config) {
@@ -1522,6 +1525,18 @@ class HistogramPool {
     }
   }
 
+  void DumpContent() const {
+    std::ofstream fout("historam_wise.txt");
+    int cur_offsets_ptr = 0;
+    for (int i = 0; i < data_[0].size() / 2; ++i) {
+      if (i == offsets_[cur_offsets_ptr]) {
+        fout << "offset " << cur_offsets_ptr << " " << offsets_[cur_offsets_ptr] << " " << feature_metas_[cur_offsets_ptr].num_bin << " " << static_cast<int>(feature_metas_[cur_offsets_ptr].offset) << std::endl;
+        ++cur_offsets_ptr;
+      }
+      fout << i << " " << data_[0][2 * i] << " " << data_[0][2 * i + 1] << std::endl;
+    }
+  }
+
   /*!
    * \brief Get data for the specific index
    * \param idx which index want to get
@@ -1591,6 +1606,7 @@ class HistogramPool {
   std::vector<int> inverse_mapper_;
   std::vector<int> last_used_time_;
   int cur_time_ = 0;
+  std::vector<uint32_t> offsets_;
 };
 
 }  // namespace LightGBM

src/treelearner/serial_tree_learner.cpp

@@ -756,6 +756,9 @@ std::set<int> SerialTreeLearner::FindAllForceFeatures(Json force_split_leaf_sett
 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();
+
   SplitInfo& best_split_info = best_split_per_leaf_[best_leaf];
   const int inner_feature_index =
       train_data_->InnerFeatureIndex(best_split_info.feature);
@@ -843,7 +846,7 @@ void SerialTreeLearner::SplitInner(Tree* tree, int best_leaf, int* left_leaf,
   // init the leaves that used on next iteration
   if (!config_->use_quantized_grad) {
     if (best_split_info.left_count < best_split_info.right_count) {
-      CHECK_GT(best_split_info.left_count, 0);
+      // CHECK_GT(best_split_info.left_count, 0);
       smaller_leaf_splits_->Init(*left_leaf, data_partition_.get(),
                                  best_split_info.left_sum_gradient,
                                  best_split_info.left_sum_hessian,
@@ -853,7 +856,7 @@ void SerialTreeLearner::SplitInner(Tree* tree, int best_leaf, int* left_leaf,
                                 best_split_info.right_sum_hessian,
                                 best_split_info.right_output);
     } else {
-      CHECK_GT(best_split_info.right_count, 0);
+      // CHECK_GT(best_split_info.right_count, 0);
       smaller_leaf_splits_->Init(*right_leaf, data_partition_.get(),
                                  best_split_info.right_sum_gradient,
                                  best_split_info.right_sum_hessian,
@@ -865,7 +868,7 @@ void SerialTreeLearner::SplitInner(Tree* tree, int best_leaf, int* left_leaf,
     }
   } else {
     if (best_split_info.left_count < best_split_info.right_count) {
-      CHECK_GT(best_split_info.left_count, 0);
+      // CHECK_GT(best_split_info.left_count, 0);
       smaller_leaf_splits_->Init(*left_leaf, data_partition_.get(),
                                  best_split_info.left_sum_gradient,
                                  best_split_info.left_sum_hessian,
@@ -877,7 +880,7 @@ void SerialTreeLearner::SplitInner(Tree* tree, int best_leaf, int* left_leaf,
                                  best_split_info.right_sum_gradient_and_hessian,
                                  best_split_info.right_output);
     } else {
-      CHECK_GT(best_split_info.right_count, 0);
+      // CHECK_GT(best_split_info.right_count, 0);
       smaller_leaf_splits_->Init(*right_leaf, data_partition_.get(),
                                  best_split_info.right_sum_gradient,
                                  best_split_info.right_sum_hessian,
@@ -896,9 +899,9 @@ void SerialTreeLearner::SplitInner(Tree* tree, int best_leaf, int* left_leaf,
                                                     data_partition_->leaf_count(*right_leaf));
   }
 
-  #ifdef DEBUG
+  // #ifdef DEBUG
   CheckSplit(best_split_info, *left_leaf, *right_leaf);
-  #endif
+  // #endif
 
   auto leaves_need_update = constraints_->Update(
       is_numerical_split, *left_leaf, *right_leaf,
@@ -1057,7 +1060,7 @@ std::vector<int8_t> node_used_features = col_sampler_.GetByNode(tree, leaf);
   *split = bests[best_idx];
 }
 
-#ifdef DEBUG
+// #ifdef DEBUG
 void SerialTreeLearner::CheckSplit(const SplitInfo& best_split_info, const int left_leaf_index, const int right_leaf_index) {
   data_size_t num_data_in_left = 0;
   data_size_t num_data_in_right = 0;
@@ -1114,6 +1117,12 @@ void SerialTreeLearner::CheckSplit(const SplitInfo& best_split_info, const int l
       sum_right_gradient += gradients_[index];
       sum_right_hessian += hessians_[index];
     }
+    Log::Warning("num_data_in_left = %d, best_split_info.left_count = %d", num_data_in_left, best_split_info.left_count);
+    Log::Warning("num_data_in_right = %d, best_split_info.right_count = %d", num_data_in_right, best_split_info.right_count);
+    Log::Warning("sum_left_gradient = %f, best_split_info.left_sum_gradient = %f", sum_left_gradient, best_split_info.left_sum_gradient);
+    Log::Warning("sum_left_hessian = %f, best_split_info.sum_left_hessian = %f", sum_left_hessian, best_split_info.left_sum_hessian);
+    Log::Warning("sum_right_gradient = %f, best_split_info.sum_right_gradient = %f", sum_right_gradient, best_split_info.right_sum_gradient);
+    Log::Warning("sum_right_hessian = %f, best_split_info.sum_right_hessian = %f", sum_right_hessian, best_split_info.right_sum_hessian);
     CHECK_EQ(num_data_in_left, best_split_info.left_count);
     CHECK_EQ(num_data_in_right, best_split_info.right_count);
     CHECK_LE(std::fabs(sum_left_gradient - best_split_info.left_sum_gradient), 1e-3);
@@ -1123,6 +1132,6 @@ void SerialTreeLearner::CheckSplit(const SplitInfo& best_split_info, const int l
     Log::Warning("============================ pass split check ============================");
   }
 }
-#endif
+// #endif
 
 }  // namespace LightGBM

src/treelearner/serial_tree_learner.h

@@ -171,9 +171,9 @@ class SerialTreeLearner: public TreeLearner {
 
   std::set<int> FindAllForceFeatures(Json force_split_leaf_setting);
 
-  #ifdef DEBUG
+  // #ifdef DEBUG
   void CheckSplit(const SplitInfo& best_split_info, const int left_leaf_index, const int right_leaf_index);
-  #endif
+  // #endif
 
   /*!
   * \brief Get the number of data in a leaf