first version of pairwie ranking bin

include/LightGBM/bin.h

@@ -466,6 +466,26 @@ class Bin {
   */
   static Bin* CreateSparseBin(data_size_t num_data, int num_bin);
 
+  /*!
+  * \brief Create object for bin data of one feature, used for pairwise ranking, for an original dense bin
+  * \param num_data Size of the pairwise dataset
+  * \param num_bin Number of bin
+  * \param paired_ranking_item_index_map Map from data index to the original index for items in the pair
+  * \return The bin data object
+  */
+  template <template<typename> typename PAIRWISE_BIN_TYPE>
+  static Bin* CreateDensePairwiseRankingBin(data_size_t num_data, int num_bin, const std::pair<data_size_t, data_size_t>* paired_ranking_item_index_map, const uint32_t min_bin, const uint32_t max_bin, const uint32_t most_freq_bin);
+
+  /*!
+  * \brief Create object for bin data of one feature, used for pairwise ranking, for an original sparse bin
+  * \param num_data Size of the pairwise dataset
+  * \param num_bin Number of bin
+  * \param paired_ranking_item_index_map Map from data index to the original index for items in the pair
+  * \return The bin data object
+  */
+  template <template<typename> typename PAIRWISE_BIN_TYPE>
+  static Bin* CreateSparsePairwiseRankingBin(data_size_t num_data, int num_bin, const std::pair<data_size_t, data_size_t>* paired_ranking_item_index_map, const uint32_t min_bin, const uint32_t max_bin, const uint32_t most_freq_bin);
+
   /*!
   * \brief Deep copy the bin
   */

include/LightGBM/dataset.h

@@ -201,7 +201,7 @@ class Metadata {
 
   /*!
   * \brief Build metadata for ranking with pairwise features from metadata of an existing ranking dataset
-  * \param metadata Pointer to metadata of the existing ranking dataset
+  * \param metadata Reference to metadata of the existing ranking dataset
   */
   void BuildPairwiseFeatureRanking(const Metadata& metadata);
 

include/LightGBM/feature_group.h

@@ -350,7 +350,7 @@ class FeatureGroup {
       uint32_t max_bin = bin_offsets_[sub_feature + 1] - 1;
       return bin_data_->GetIterator(min_bin, max_bin, most_freq_bin);
     } else {
-      int addi = bin_mappers_[sub_feature]->GetMostFreqBin() == 0 ? 0 : 1;
+      int addi = most_freq_bin == 0 ? 0 : 1;
       uint32_t min_bin = 1;
       uint32_t max_bin = bin_mappers_[sub_feature]->num_bin() - 1 + addi;
       return multi_bin_data_[sub_feature]->GetIterator(min_bin, max_bin,
@@ -582,7 +582,7 @@ class FeatureGroup {
   }
 
  protected:
-  void CreateBinData(int num_data, bool is_multi_val, bool force_dense, bool force_sparse) {
+  virtual void CreateBinData(int num_data, bool is_multi_val, bool force_dense, bool force_sparse) {
     if (is_multi_val) {
       multi_bin_data_.clear();
       for (int i = 0; i < num_feature_; ++i) {

include/LightGBM/pairwise_ranking_feature_group.h

@@ -3,8 +3,8 @@
  * Licensed under the MIT License. See LICENSE file in the project root for
  * license information.
  */
-#ifndef LIGHTGBM_PAIRWISE_FEATURE_GROUP_H_
-#define LIGHTGBM_PAIRWISE_FEATURE_GROUP_H_
+#ifndef LIGHTGBM_PAIRWISE_RANKING_FEATURE_GROUP_H_
+#define LIGHTGBM_PAIRWISE_RANKING_FEATURE_GROUP_H_
 
 #include "feature_group.h"
 
@@ -25,23 +25,11 @@ class PairwiseRankingFeatureGroup: public FeatureGroup {
   * \param bin_mappers Bin mapper for features
   * \param num_data Total number of data
   * \param is_enable_sparse True if enable sparse feature
+  * \param is_first_or_second_in_pairing Mark whether features in this group belong to the first or second element in the pairing
   */
 
-  PairwiseRankingFeatureGroup(const FeatureGroup& other, int num_data) {
-    num_feature_ = other.num_feature_;
-    is_multi_val_ = false;
-    is_dense_multi_val_ = false;
-    is_sparse_ = false;
-    num_total_bin_ = other.num_total_bin_;
-    bin_offsets_ = other.bin_offsets_;
-    num_data_ = num_data;
-
-    bin_mappers_.reserve(other.bin_mappers_.size());
-    for (auto& bin_mapper : other.bin_mappers_) {
-      bin_mappers_.emplace_back(new BinMapper(*bin_mapper));
-    }
-    CreateBinData(num_data, is_multi_val_, !is_sparse_, is_sparse_);
-  }
+  PairwiseRankingFeatureGroup(const FeatureGroup& other, int num_data, const int is_first_or_second_in_pairing):
+    FeatureGroup(other, num_data), is_first_or_second_in_pairing_(is_first_or_second_in_pairing) {}
 
   /*!
    * \brief Constructor from memory when data is present
@@ -50,21 +38,21 @@ class PairwiseRankingFeatureGroup: public FeatureGroup {
    * \param local_used_indices Local used indices, empty means using all data
    * \param group_id Id of group
    */
-  PairwiseRankingFeatureGroup(const void* memory,
-                              data_size_t num_all_data,
-                              const std::vector<data_size_t>& local_used_indices,
-                              int group_id) {
-    // TODO(shiyu1994)
-  }
-
-  /*!
-   * \brief Constructor from definition in memory (without data)
-   * \param memory Pointer of memory
-   * \param local_used_indices Local used indices, empty means using all data
-   */
-  FeatureGroup(const void* memory, data_size_t num_data, int group_id) {
-    // TODO(shiyu1994)
-  }
+  // PairwiseRankingFeatureGroup(const void* memory,
+  //                             data_size_t num_all_data,
+  //                             const std::vector<data_size_t>& local_used_indices,
+  //                             int group_id) {
+  //   // TODO(shiyu1994)
+  // }
+
+  // /*!
+  //  * \brief Constructor from definition in memory (without data)
+  //  * \param memory Pointer of memory
+  //  * \param local_used_indices Local used indices, empty means using all data
+  //  */
+  // PairwiseRankingFeatureGroup(const void* memory, data_size_t num_data, int group_id): FeatureGroup(memory, num_data, group_id) {
+  //   // TODO(shiyu1994)
+  // }
 
   /*! \brief Destructor */
   ~PairwiseRankingFeatureGroup() {}
@@ -91,17 +79,19 @@ class PairwiseRankingFeatureGroup: public FeatureGroup {
   }
 
  private:
-  void CreateBinData(int num_data, bool is_multi_val, bool force_dense, bool force_sparse) {
-    // TODO(shiyu1994)
-  }
+  template <typename PAIRWISE_BIN_TYPE>
+  void CreateBinDataInner(int num_data, bool is_multi_val, bool force_dense, bool force_sparse);
 
+  void CreateBinData(int num_data, bool is_multi_val, bool force_dense, bool force_sparse) override;
 
   /*! \brief Pairwise data index to original data indices for ranking with pairwise features  */
   const std::pair<data_size_t, data_size_t>* paired_ranking_item_index_map_;
   /*! \brief Number of pairwise data */
   data_size_t num_data_;
+  /*! \brief Mark whether features in this group belong to the first or second element in the pairing */
+  const int is_first_or_second_in_pairing_;
 };
 
 }  // namespace LightGBM
 
-#endif  // LIGHTGBM_PAIRWISE_FEATURE_GROUP_H_
+#endif  // LIGHTGBM_PAIRWISE_RANKING_FEATURE_GROUP_H_

src/io/bin.cpp

@@ -17,6 +17,7 @@
 #include "multi_val_dense_bin.hpp"
 #include "multi_val_sparse_bin.hpp"
 #include "sparse_bin.hpp"
+#include "pairwise_lambdarank_bin.hpp"
 
 namespace LightGBM {
 
@@ -632,6 +633,38 @@ namespace LightGBM {
     }
   }
 
+  template <template<typename> typename PAIRWISE_BIN_TYPE>
+  Bin* Bin::CreateDensePairwiseRankingBin(data_size_t num_data, int num_bin, const std::pair<data_size_t, data_size_t>* paired_ranking_item_index_map, const uint32_t min_bin, const uint32_t max_bin, const uint32_t most_freq_bin) {
+    if (num_bin <= 16) {
+      return new PAIRWISE_BIN_TYPE<DenseBin<uint8_t, true>>(num_data, paired_ranking_item_index_map, new DenseBin<uint8_t, true>(num_data), min_bin, max_bin, most_freq_bin);
+    } else if (num_bin <= 256) {
+      return new PAIRWISE_BIN_TYPE<DenseBin<uint8_t, false>>(num_data, paired_ranking_item_index_map, new DenseBin<uint8_t, false>(num_data), min_bin, max_bin, most_freq_bin);
+    } else if (num_bin <= 65536) {
+      return new PAIRWISE_BIN_TYPE<DenseBin<uint16_t, false>>(num_data, paired_ranking_item_index_map, new DenseBin<uint16_t, false>(num_data), min_bin, max_bin, most_freq_bin);
+    } else {
+      return new PAIRWISE_BIN_TYPE<DenseBin<uint32_t, false>>(num_data, paired_ranking_item_index_map, new DenseBin<uint32_t, false>(num_data), min_bin, max_bin, most_freq_bin);
+    }
+  }
+
+  template <template<typename> typename PAIRWISE_BIN_TYPE>
+  Bin* Bin::CreateSparsePairwiseRankingBin(data_size_t num_data, int num_bin, const std::pair<data_size_t, data_size_t>* paired_ranking_item_index_map, const uint32_t min_bin, const uint32_t max_bin, const uint32_t most_freq_bin) {
+    if (num_bin <= 256) {
+      return new PAIRWISE_BIN_TYPE<SparseBin<uint8_t>>(num_data, paired_ranking_item_index_map, new SparseBin<uint8_t>(num_data), min_bin, max_bin, most_freq_bin);
+    } else if (num_bin <= 65536) {
+      return new PAIRWISE_BIN_TYPE<SparseBin<uint16_t>>(num_data, paired_ranking_item_index_map, new SparseBin<uint16_t>(num_data), min_bin, max_bin, most_freq_bin);
+    } else {
+      return new PAIRWISE_BIN_TYPE<SparseBin<uint32_t>>(num_data, paired_ranking_item_index_map, new SparseBin<uint32_t>(num_data), min_bin, max_bin, most_freq_bin);
+    }
+  }
+
+  template Bin* Bin::CreateSparsePairwiseRankingBin<PairwiseRankingFirstBin>(data_size_t num_data, int num_bin, const std::pair<data_size_t, data_size_t>* paired_ranking_item_index_map, const uint32_t min_bin, const uint32_t max_bin, const uint32_t most_freq_bin);
+
+  template Bin* Bin::CreateSparsePairwiseRankingBin<PairwiseRankingSecondBin>(data_size_t num_data, int num_bin, const std::pair<data_size_t, data_size_t>* paired_ranking_item_index_map, const uint32_t min_bin, const uint32_t max_bin, const uint32_t most_freq_bin);
+
+  template Bin* Bin::CreateDensePairwiseRankingBin<PairwiseRankingFirstBin>(data_size_t num_data, int num_bin, const std::pair<data_size_t, data_size_t>* paired_ranking_item_index_map, const uint32_t min_bin, const uint32_t max_bin, const uint32_t most_freq_bin);
+
+  template Bin* Bin::CreateDensePairwiseRankingBin<PairwiseRankingSecondBin>(data_size_t num_data, int num_bin, const std::pair<data_size_t, data_size_t>* paired_ranking_item_index_map, const uint32_t min_bin, const uint32_t max_bin, const uint32_t most_freq_bin);
+
   MultiValBin* MultiValBin::CreateMultiValBin(data_size_t num_data, int num_bin, int num_feature,
     double sparse_rate, const std::vector<uint32_t>& offsets) {
     if (sparse_rate >= multi_val_bin_sparse_threshold) {
@@ -705,6 +738,8 @@ namespace LightGBM {
     }
   }
 
+
+
   template <>
   const void* DenseBin<uint8_t, false>::GetColWiseData(
     uint8_t* bit_type,

src/io/dataset.cpp

@@ -6,6 +6,7 @@
 #include <LightGBM/dataset.h>
 
 #include <LightGBM/feature_group.h>
+#include <LightGBM/pairwise_ranking_feature_group.h>
 #include <LightGBM/cuda/vector_cudahost.h>
 #include <LightGBM/utils/array_args.h>
 #include <LightGBM/utils/openmp_wrapper.h>
@@ -847,6 +848,7 @@ void Dataset::CreatePairWiseRankingData(const Dataset* dataset, std::vector<std:
   for (int i = 0; i < num_groups_; ++i) {
     int original_group_index = i % dataset->num_groups_;
     int original_group_feature_start = dataset->group_feature_start_[original_group_index];
+    const int is_first_or_second_in_pairing = original_group_index / dataset->num_groups_; // 0 for first, 1 for second
     group_feature_start_[i] = cur_feature_index;
     for (int feature_index_in_group = 0; feature_index_in_group < dataset->group_feature_cnt_[original_group_index]; ++feature_index_in_group) {
       const BinMapper* feature_bin_mapper = dataset->FeatureBinMapper(original_group_feature_start + feature_index_in_group);
@@ -857,7 +859,7 @@ void Dataset::CreatePairWiseRankingData(const Dataset* dataset, std::vector<std:
       feature2subfeature_.push_back(dataset->feature2subfeature_[original_group_feature_start + feature_index_in_group]);
       cur_feature_index += 1;
     }
-    feature_groups_.emplace_back(new FeatureGroup(*dataset->feature_groups_[original_group_index].get(), num_data_));
+    feature_groups_.emplace_back(new PairwiseRankingFeatureGroup(*dataset->feature_groups_[original_group_index].get(), num_data_, is_first_or_second_in_pairing));
     num_total_bin += dataset->FeatureGroupNumBin(original_group_index);
     group_bin_boundaries_.push_back(num_total_bin);
     group_feature_cnt_[i] = dataset->group_feature_cnt_[original_group_index];

src/io/pairwise_lambdarank_bin.hpp

@@ -10,13 +10,20 @@
 
 namespace LightGBM {
 
-template <typename VAL_T>
+template <typename BIN_TYPE>
+class PairwiseRankingFirstBin;
+
+template <typename BIN_TYPE>
+class PairwiseRankingSecondBin;
+
+template <typename BIN_TYPE>
 class PairwiseRankingFirstIterator: public BinIterator {
+ friend PairwiseRankingFirstBin<BIN_TYPE>;
  public:
-  PairwiseRankingFirstIterator(const Bin* unpaired_bin, const std::pair<data_size_t, data_size_t>* paired_ranking_item_index_map) {
+  PairwiseRankingFirstIterator(const BIN_TYPE* unpaired_bin, const std::pair<data_size_t, data_size_t>* paired_ranking_item_index_map, const uint32_t min_bin, const uint32_t max_bin, const uint32_t most_freq_bin) {
     unpaired_bin_ = unpaired_bin;
-    unpaired_bin_iterator_ = unpaired_bin_->GetIterator();
-    unpaired_bin_iterator_->Reset();
+    unpaired_bin_iterator_ = unpaired_bin_->GetIterator(min_bin, max_bin, most_freq_bin);
+    unpaired_bin_iterator_->Reset(0);
     paired_ranking_item_index_map_ = paired_ranking_item_index_map;
     prev_index_ = 0;
     prev_val_ = 0;
@@ -25,20 +32,20 @@ class PairwiseRankingFirstIterator: public BinIterator {
   ~PairwiseRankingFirstIterator() {}
 
   uint32_t Get(data_size_t idx) {
-    const data_size_t data_index = paired_ranking_item_index_map[idx].first
+    const data_size_t data_index = paired_ranking_item_index_map_[idx].first;
     if (data_index != prev_index_) {
       CHECK_GT(data_index, prev_index_);
-      prev_val_ = unpaired_bin_iterator_i_->Get(data_index);
+      prev_val_ = unpaired_bin_iterator_->Get(data_index);
     }
     prev_index_ = data_index;
     return prev_val_;
   }
 
   uint32_t RawGet(data_size_t idx) {
-    const data_size_t data_index = paired_ranking_item_index_map[idx].first
+    const data_size_t data_index = paired_ranking_item_index_map_[idx].first;
     if (data_index != prev_index_) {
       CHECK_GT(data_index, prev_index_);
-      prev_val_ = unpaired_bin_iterator_i_->RawGet(data_index);
+      prev_val_ = unpaired_bin_iterator_->RawGet(data_index);
     }
     prev_index_ = data_index;
     return prev_val_;
@@ -51,43 +58,43 @@ class PairwiseRankingFirstIterator: public BinIterator {
   }
 
  private:
-  const Bin* unpaired_bin_;
+  const BIN_TYPE* unpaired_bin_;
   BinIterator* unpaired_bin_iterator_;
   const std::pair<data_size_t, data_size_t>* paired_ranking_item_index_map_;
-  const data_size_t prev_index_;
-  const uint32_t prev_val_;
+  data_size_t prev_index_;
+  uint32_t prev_val_;
 };
 
-template <typename VAL_T>
+template <typename BIN_TYPE>
 class PairwiseRankingSecondIterator: public BinIterator {
+ friend PairwiseRankingSecondBin<BIN_TYPE>;
  public:
-  PairwiseRankingSecondIterator(const Bin* unpaired_bin, const std::pair<data_size_t, data_size_t>* paired_ranking_item_index_map) {
+  PairwiseRankingSecondIterator(const BIN_TYPE* unpaired_bin, const std::pair<data_size_t, data_size_t>* paired_ranking_item_index_map, const uint32_t min_bin, const uint32_t max_bin, const uint32_t most_freq_bin) {
     unpaired_bin_ = unpaired_bin;
-    unpaired_bin_iterator_ = unpaired_bin_->GetIterator();
-    unpaired_bin_iterator_->Reset();
+    unpaired_bin_iterator_ = unpaired_bin_->GetIterator(min_bin, max_bin, most_freq_bin);
+    unpaired_bin_iterator_->Reset(0);
     paired_ranking_item_index_map_ = paired_ranking_item_index_map;
     prev_index_ = 0;
-    prev_val_ = 0;
   }
 
   ~PairwiseRankingSecondIterator() {}
 
   uint32_t Get(data_size_t idx) {
-    const data_size_t data_index = paired_ranking_item_index_map[idx].second
+    const data_size_t data_index = paired_ranking_item_index_map_[idx].second;
     if (data_index < prev_index_) {
-      unpaired_bin_iterator_i_.Reset(0);
+      unpaired_bin_iterator_->Reset(0);
     }
     prev_index_ = data_index;
-    return unpaired_bin_iterator_i_->Get(data_index);
+    return unpaired_bin_iterator_->Get(data_index);
   }
 
   uint32_t RawGet(data_size_t idx) {
-    const data_size_t data_index = paired_ranking_item_index_map[idx].second
+    const data_size_t data_index = paired_ranking_item_index_map_[idx].second;
     if (data_index < prev_index_) {
-      unpaired_bin_iterator_i_.Reset(0);
+      unpaired_bin_iterator_->Reset(0);
     }
     prev_index_ = data_index;
-    return unpaired_bin_iterator_i_->RawGet(data_index);
+    return unpaired_bin_iterator_->RawGet(data_index);
   }
 
   void Reset(data_size_t idx) {
@@ -96,10 +103,50 @@ class PairwiseRankingSecondIterator: public BinIterator {
   }
 
  private:
-  const Bin* unpaired_bin_;
+  const BIN_TYPE* unpaired_bin_;
   BinIterator* unpaired_bin_iterator_;
   const std::pair<data_size_t, data_size_t>* paired_ranking_item_index_map_;
-  const data_size_t prev_index_;
+  data_size_t prev_index_;
+};
+
+template <typename BIN_TYPE>
+class PairwiseRankingFirstBin: public BIN_TYPE {
+ public:
+  PairwiseRankingFirstBin(data_size_t num_data, const std::pair<data_size_t, data_size_t>* paired_ranking_item_index_map, const BIN_TYPE* unpaired_bin, const uint32_t min_bin, const uint32_t max_bin, const uint32_t most_freq_bin): BIN_TYPE(0), unpaired_bin_(unpaired_bin), min_bin_(min_bin), max_bin_(max_bin), most_freq_bin_(most_freq_bin) {
+    paired_ranking_item_index_map_ = paired_ranking_item_index_map;
+    num_data_ = num_data;
+  }
+
+  BinIterator* GetIterator(uint32_t min_bin, uint32_t max_bin, uint32_t most_freq_bin) const override {
+    return new PairwiseRankingFirstIterator<BIN_TYPE>(unpaired_bin_.get(), paired_ranking_item_index_map_, min_bin_, max_bin_, most_freq_bin_);
+  }
+
+ private:
+  const std::pair<data_size_t, data_size_t>* paired_ranking_item_index_map_;
+  const std::shared_ptr<const BIN_TYPE> unpaired_bin_;
+  const uint32_t min_bin_;
+  const uint32_t max_bin_;
+  const uint32_t most_freq_bin_;
+};
+
+template <typename BIN_TYPE>
+class PairwiseRankingSecondBin: public BIN_TYPE {
+ public:
+  PairwiseRankingSecondBin(data_size_t num_data, const std::pair<data_size_t, data_size_t>* paired_ranking_item_index_map, const BIN_TYPE* unpaired_bin, const uint32_t min_bin, const uint32_t max_bin, const uint32_t most_freq_bin): BIN_TYPE(0), unpaired_bin_(unpaired_bin), min_bin_(min_bin), max_bin_(max_bin), most_freq_bin_(most_freq_bin) {
+    paired_ranking_item_index_map_ = paired_ranking_item_index_map;
+    num_data_ = num_data;
+  }
+
+  BinIterator* GetIterator(uint32_t min_bin, uint32_t max_bin, uint32_t most_freq_bin) const override {
+    return new PairwiseRankingSecondIterator<BIN_TYPE>(unpaired_bin_.get(), paired_ranking_item_index_map_, min_bin_, max_bin_, most_freq_bin_);
+  }
+
+ private:
+  const std::pair<data_size_t, data_size_t>* paired_ranking_item_index_map_;
+  const std::shared_ptr<const BIN_TYPE> unpaired_bin_;
+  const uint32_t min_bin_;
+  const uint32_t max_bin_;
+  const uint32_t most_freq_bin_;
 };
 
 }  // LightGBM