fix num bin for row wise in pairwise ranking

include/LightGBM/dataset.h

@@ -1155,6 +1155,10 @@ class Dataset {
   const data_size_t* train_query_boundaries_;
   /*! \brief stored number of queries from training dataset, for creating differential features in pairwise lambdarank */
   data_size_t train_num_queries_;
+  /*! \brief stored number of differential features used in training dataset, for creating differential features in pairwise lambdarank */
+  data_size_t num_used_differential_features_;
+  /*! \brief stored number of differential feature groups used in training dataset, for creating differential features in pairwise lambdarank */
+  data_size_t num_used_differential_groups_;
 };
 
 }  // namespace LightGBM

src/boosting/gbdt.cpp

@@ -490,7 +490,9 @@ bool GBDT::EvalAndCheckEarlyStopping() {
 void GBDT::UpdateScore(const Tree* tree, const int cur_tree_id) {
   Common::FunctionTimer fun_timer("GBDT::UpdateScore", global_timer);
   // update training score
+  Log::Warning("before update score 0");
   if (!data_sample_strategy_->is_use_subset()) {
+    Log::Warning("before update score 1");
     train_score_updater_->AddScore(tree_learner_.get(), tree, cur_tree_id);
 
     const data_size_t bag_data_cnt = data_sample_strategy_->bag_data_cnt();
@@ -506,16 +508,20 @@ void GBDT::UpdateScore(const Tree* tree, const int cur_tree_id) {
       }
       #endif  // USE_CUDA
     }
+    Log::Warning("before update score 2");
 
   } else {
+    Log::Warning("before update score 3");
     train_score_updater_->AddScore(tree, cur_tree_id);
   }
 
 
+  Log::Warning("before update score 4");
   // update validation score
   for (auto& score_updater : valid_score_updater_) {
     score_updater->AddScore(tree, cur_tree_id);
   }
+  Log::Warning("before update score 5");
 }
 
 #ifdef USE_CUDA

src/io/dataset.cpp

@@ -641,7 +641,9 @@ MultiValBin* Dataset::GetMultiBinFromAllFeatures(const std::vector<uint32_t>& of
     //   }
     // }
 
-    const int num_original_features = static_cast<int>(most_freq_bins.size()) / 2;
+    Log::Warning("most_freq_bins.size() = %d, num_groups_ = %d, num_used_differential_features_ = %d, num_used_differential_groups_ = %d, ncol = %d", static_cast<int>(most_freq_bins.size()), num_groups_, num_used_differential_features_, num_used_differential_groups_, ncol);
+
+    const int num_original_features = (static_cast<int>(most_freq_bins.size()) - num_used_differential_groups_) / 2;
     std::vector<uint32_t> original_most_freq_bins;
     std::vector<uint32_t> original_offsets;
     for (int i = 0; i < num_original_features; ++i) {
@@ -661,7 +663,7 @@ MultiValBin* Dataset::GetMultiBinFromAllFeatures(const std::vector<uint32_t>& of
     fout.close();
     const data_size_t num_original_data = metadata_.query_boundaries()[metadata_.num_queries()];
     ret.reset(MultiValBin::CreateMultiValBin(
-        num_original_data, original_offsets.back(), num_original_features,
+        num_original_data, 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_data, original_most_freq_bins, original_offsets, &iters, ret.get());
   } else {
@@ -1025,6 +1027,10 @@ void Dataset::CreatePairWiseRankingData(const Dataset* dataset, const bool is_va
     group_feature_cnt_[i] = dataset->group_feature_cnt_[original_group_index];
   }
 
+  Log::Warning("cur_feature_index = %d", cur_feature_index);
+
+  num_used_differential_features_ = 0;
+  num_used_differential_groups_ = static_cast<int>(diff_feature_groups.size());
   if (config.use_differential_feature_in_pairwise_ranking) {
     for (size_t i = 0; i < diff_feature_groups.size(); ++i) {
       const std::vector<int>& features_in_group = diff_feature_groups[i];
@@ -1045,6 +1051,7 @@ void Dataset::CreatePairWiseRankingData(const Dataset* dataset, const bool is_va
           used_feature_map_[diff_feature_index + dataset->num_total_features_ * 2] = cur_feature_index;
           ++cur_feature_index;
           ++num_features_in_group;
+          ++num_used_differential_features_;
           const int ori_feature_index = dataset->InnerFeatureIndex(diff_original_feature_index[diff_feature_index]);
           ori_bin_mappers.emplace_back(new BinMapper(*dataset->FeatureBinMapper(ori_feature_index)));
           ori_bin_mappers_for_diff.emplace_back(new BinMapper(*dataset->FeatureBinMapper(ori_feature_index)));
@@ -1080,6 +1087,8 @@ void Dataset::CreatePairWiseRankingData(const Dataset* dataset, const bool is_va
     num_groups_ += static_cast<int>(diff_feature_groups.size());
   }
 
+  Log::Warning("cur_feature_index = %d", cur_feature_index);
+
   feature_groups_.shrink_to_fit();
 
   feature_names_.clear();

src/io/multi_val_pairwise_lambdarank_bin.hpp

@@ -14,7 +14,8 @@ 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) {
-    this->num_bin_ = num_bin * 2;
+    this->num_bin_ = num_bin;
+    Log::Warning("num_bin = %d", num_bin);
   }
  protected:
   const std::pair<data_size_t, data_size_t>* paired_ranking_item_global_index_map_;

src/treelearner/col_sampler.hpp

@@ -89,6 +89,7 @@ class ColSampler {
   }
 
   std::vector<int8_t> GetByNode(const Tree* tree, int leaf) {
+    // Log::Warning("GetByNode step 0");
     // get interaction constraints for current branch
     std::unordered_set<int> allowed_features;
     if (!interaction_constraints_.empty()) {
@@ -110,6 +111,7 @@ class ColSampler {
       }
     }
 
+    // Log::Warning("GetByNode step 1");
     std::vector<int8_t> ret(train_data_->num_features(), 0);
     if (fraction_bynode_ >= 1.0f) {
       if (interaction_constraints_.empty()) {
@@ -124,6 +126,7 @@ class ColSampler {
         return ret;
       }
     }
+    // Log::Warning("GetByNode step 2");
     if (need_reset_bytree_) {
       auto used_feature_cnt = GetCnt(used_feature_indices_.size(), fraction_bynode_);
       std::vector<int>* allowed_used_feature_indices;
@@ -175,6 +178,7 @@ class ColSampler {
         ret[inner_feature_index] = 1;
       }
     }
+    // Log::Warning("GetByNode step 3");
     return ret;
   }
 

src/treelearner/serial_tree_learner.cpp

@@ -68,7 +68,7 @@ void SerialTreeLearner::Init(const Dataset* train_data, bool is_constant_hessian
 
   GetShareStates(train_data_, is_constant_hessian, true);
   histogram_pool_.DynamicChangeSize(train_data_,
-  share_state_->num_hist_total_bin(),
+  share_state_->num_hist_total_bin() * 2,
   share_state_->feature_hist_offsets(),
   config_, max_cache_size, config_->num_leaves);
   Log::Info("Number of data points in the train set: %d, number of used features: %d", num_data_, num_features_);
@@ -320,6 +320,8 @@ void SerialTreeLearner::BeforeTrain() {
     }
   }
 
+  // Log::Warning("smaller_leaf_splits_->leaf_index() = %d before train", smaller_leaf_splits_->leaf_index());
+
   larger_leaf_splits_->Init();
 
   if (cegb_ != nullptr) {
@@ -391,8 +393,12 @@ void SerialTreeLearner::FindBestSplits(const Tree* tree, const std::set<int>* fo
   }
   bool use_subtract = parent_leaf_histogram_array_ != nullptr;
 
+  // Log::Warning("before ConstructHistograms");
   ConstructHistograms(is_feature_used, use_subtract);
+  // Log::Warning("after ConstructHistograms");
+  // Log::Warning("before FindBestSplitsFromHistograms");
   FindBestSplitsFromHistograms(is_feature_used, use_subtract, tree);
+  // Log::Warning("after FindBestSplitsFromHistograms");
 }
 
 void SerialTreeLearner::ConstructHistograms(
@@ -466,21 +472,28 @@ void SerialTreeLearner::ConstructHistograms(
 
 void SerialTreeLearner::FindBestSplitsFromHistograms(
     const std::vector<int8_t>& is_feature_used, bool use_subtract, const Tree* tree) {
+  // Log::Warning("FindBestSplitsFromHistograms step 0");
   Common::FunctionTimer fun_timer(
       "SerialTreeLearner::FindBestSplitsFromHistograms", global_timer);
+  // Log::Warning("FindBestSplitsFromHistograms step 0.1");
   std::vector<SplitInfo> smaller_best(share_state_->num_threads);
   std::vector<SplitInfo> larger_best(share_state_->num_threads);
+  // Log::Warning("smaller_leaf_splits_->leaf_index() = %d", smaller_leaf_splits_->leaf_index());
   std::vector<int8_t> smaller_node_used_features = col_sampler_.GetByNode(tree, smaller_leaf_splits_->leaf_index());
   std::vector<int8_t> larger_node_used_features;
+  // Log::Warning("FindBestSplitsFromHistograms step 0.2");
   double smaller_leaf_parent_output = GetParentOutput(tree, smaller_leaf_splits_.get());
   double larger_leaf_parent_output = 0;
+  // Log::Warning("FindBestSplitsFromHistograms step 0.3");
   if (larger_leaf_splits_ != nullptr && larger_leaf_splits_->leaf_index() >= 0) {
     larger_leaf_parent_output = GetParentOutput(tree, larger_leaf_splits_.get());
   }
   if (larger_leaf_splits_->leaf_index() >= 0) {
     larger_node_used_features = col_sampler_.GetByNode(tree, larger_leaf_splits_->leaf_index());
   }
 
+  // Log::Warning("FindBestSplitsFromHistograms step 1");
+
   if (use_subtract && config_->use_quantized_grad) {
     const int parent_index = std::min(smaller_leaf_splits_->leaf_index(), larger_leaf_splits_->leaf_index());
     const uint8_t parent_hist_bits = gradient_discretizer_->GetHistBitsInNode<false>(parent_index);
@@ -500,15 +513,18 @@ void SerialTreeLearner::FindBestSplitsFromHistograms(
     }
   }
 
+  // Log::Warning("FindBestSplitsFromHistograms step 2");
+
   OMP_INIT_EX();
 // find splits
-#pragma omp parallel for schedule(static) num_threads(share_state_->num_threads)
+// #pragma omp parallel for schedule(static) num_threads(share_state_->num_threads)
   for (int feature_index = 0; feature_index < num_features_; ++feature_index) {
     OMP_LOOP_EX_BEGIN();
     if (!is_feature_used[feature_index]) {
       continue;
     }
     const int tid = omp_get_thread_num();
+  // Log::Warning("FindBestSplitsFromHistograms step 2.1");
     if (config_->use_quantized_grad) {
       const uint8_t hist_bits_bin = gradient_discretizer_->GetHistBitsInLeaf<false>(smaller_leaf_splits_->leaf_index());
       const int64_t int_sum_gradient_and_hessian = smaller_leaf_splits_->int_sum_gradients_and_hessians();
@@ -529,6 +545,7 @@ void SerialTreeLearner::FindBestSplitsFromHistograms(
     }
     int real_fidx = train_data_->RealFeatureIndex(feature_index);
 
+  // Log::Warning("FindBestSplitsFromHistograms step 2.2");
     ComputeBestSplitForFeature(smaller_leaf_histogram_array_, feature_index,
                                real_fidx,
                                smaller_node_used_features[feature_index],
@@ -542,6 +559,7 @@ void SerialTreeLearner::FindBestSplitsFromHistograms(
       continue;
     }
 
+  // Log::Warning("FindBestSplitsFromHistograms step 2.3");
     if (use_subtract) {
       if (config_->use_quantized_grad) {
         const int parent_index = std::min(smaller_leaf_splits_->leaf_index(), larger_leaf_splits_->leaf_index());
@@ -589,6 +607,7 @@ void SerialTreeLearner::FindBestSplitsFromHistograms(
       }
     }
 
+  // Log::Warning("FindBestSplitsFromHistograms step 2.4");
     ComputeBestSplitForFeature(larger_leaf_histogram_array_, feature_index,
                                real_fidx,
                                larger_node_used_features[feature_index],
@@ -599,6 +618,10 @@ void SerialTreeLearner::FindBestSplitsFromHistograms(
     OMP_LOOP_EX_END();
   }
   OMP_THROW_EX();
+
+
+  // Log::Warning("FindBestSplitsFromHistograms step 3");
+
   auto smaller_best_idx = ArrayArgs<SplitInfo>::ArgMax(smaller_best);
   int leaf = smaller_leaf_splits_->leaf_index();
   best_split_per_leaf_[leaf] = smaller_best[smaller_best_idx];