merge from master

src/metric/dcg_calculator.cpp

@@ -11,14 +11,17 @@ namespace LightGBM {
 
 /*! \brief Declaration for some static members */
 bool DCGCalculator::is_inited_ = false;
-std::vector<float> DCGCalculator::label_gain_;
-std::vector<float> DCGCalculator::discount_;
+std::vector<score_t> DCGCalculator::label_gain_;
+std::vector<score_t> DCGCalculator::discount_;
 const data_size_t DCGCalculator::kMaxPosition = 10000;
 
-void DCGCalculator::Init(std::vector<float> input_label_gain) {
+void DCGCalculator::Init(std::vector<double> input_label_gain) {
   //  only inited one time
   if (is_inited_) { return; }
-  label_gain_ = input_label_gain;
+  label_gain_.clear();
+  for(size_t i = 0;i < input_label_gain.size();++i){
+    label_gain_.push_back(static_cast<score_t>(input_label_gain[i]));
+  }
   discount_.clear();
   for (data_size_t i = 0; i < kMaxPosition; ++i) {
     discount_.emplace_back(1.0f / std::log2(2.0f + i));
@@ -26,8 +29,8 @@ void DCGCalculator::Init(std::vector<float> input_label_gain) {
   is_inited_ = true;
 }
 
-float DCGCalculator::CalMaxDCGAtK(data_size_t k, const float* label, data_size_t num_data) {
-  float ret = 0.0f;
+score_t DCGCalculator::CalMaxDCGAtK(data_size_t k, const float* label, data_size_t num_data) {
+  score_t ret = 0.0f;
   // counts for all labels
   std::vector<data_size_t> label_cnt(label_gain_.size(), 0);
   for (data_size_t i = 0; i < num_data; ++i) {
@@ -53,14 +56,14 @@ float DCGCalculator::CalMaxDCGAtK(data_size_t k, const float* label, data_size_t
 void DCGCalculator::CalMaxDCG(const std::vector<data_size_t>& ks,
                               const float* label,
                               data_size_t num_data,
-                              std::vector<float>* out) {
+                              std::vector<score_t>* out) {
   std::vector<data_size_t> label_cnt(label_gain_.size(), 0);
   // counts for all labels
   for (data_size_t i = 0; i < num_data; ++i) {
     if (static_cast<size_t>(label[i]) >= label_cnt.size()) { Log::Fatal("label excel %d", label[i]); }
     ++label_cnt[static_cast<int>(label[i])];
   }
-  float cur_result = 0.0f;
+  score_t cur_result = 0.0f;
   data_size_t cur_left = 0;
   size_t top_label = label_gain_.size() - 1;
   // calculate k Max DCG by one pass
@@ -83,7 +86,7 @@ void DCGCalculator::CalMaxDCG(const std::vector<data_size_t>& ks,
 }
 
 
-float DCGCalculator::CalDCGAtK(data_size_t k, const float* label,
+score_t DCGCalculator::CalDCGAtK(data_size_t k, const float* label,
                                 const score_t* score, data_size_t num_data) {
   // get sorted indices by score
   std::vector<data_size_t> sorted_idx;
@@ -94,7 +97,7 @@ float DCGCalculator::CalDCGAtK(data_size_t k, const float* label,
            [score](data_size_t a, data_size_t b) {return score[a] > score[b]; });
 
   if (k > num_data) { k = num_data; }
-  float dcg = 0.0f;
+  score_t dcg = 0.0f;
   // calculate dcg
   for (data_size_t i = 0; i < k; ++i) {
     data_size_t idx = sorted_idx[i];
@@ -104,7 +107,7 @@ float DCGCalculator::CalDCGAtK(data_size_t k, const float* label,
 }
 
 void DCGCalculator::CalDCG(const std::vector<data_size_t>& ks, const float* label,
-                           const score_t * score, data_size_t num_data, std::vector<float>* out) {
+                           const score_t * score, data_size_t num_data, std::vector<score_t>* out) {
   // get sorted indices by score
   std::vector<data_size_t> sorted_idx;
   for (data_size_t i = 0; i < num_data; ++i) {
@@ -113,7 +116,7 @@ void DCGCalculator::CalDCG(const std::vector<data_size_t>& ks, const float* labe
   std::sort(sorted_idx.begin(), sorted_idx.end(),
             [score](data_size_t a, data_size_t b) {return score[a] > score[b]; });
 
-  float cur_result = 0.0f;
+  score_t cur_result = 0.0f;
   data_size_t cur_left = 0;
   // calculate multi dcg by one pass
   for (size_t i = 0; i < ks.size(); ++i) {

src/metric/multiclass_metric.hpp

@@ -33,7 +33,7 @@ public:
     // get weights
     weights_ = metadata.weights();
     if (weights_ == nullptr) {
-      sum_weights_ = static_cast<float>(num_data_);
+      sum_weights_ = static_cast<double>(num_data_);
     } else {
       sum_weights_ = 0.0f;
       for (data_size_t i = 0; i < num_data_; ++i) {
@@ -50,14 +50,14 @@ public:
     return false;
   }
   
-  std::vector<float> Eval(const score_t* score) const override {
-    score_t sum_loss = 0.0;
+  std::vector<double> Eval(const score_t* score) const override {
+    double sum_loss = 0.0;
     if (weights_ == nullptr) {
       #pragma omp parallel for schedule(static) reduction(+:sum_loss)
       for (data_size_t i = 0; i < num_data_; ++i) {
-        std::vector<float> rec(num_class_);
+        std::vector<double> rec(num_class_);
         for (int k = 0; k < num_class_; ++k) {
-          rec[k] = static_cast<float>(score[k * num_data_ + i]);
+          rec[k] = static_cast<double>(score[k * num_data_ + i]);
         }
         // add loss
         sum_loss += PointWiseLossCalculator::LossOnPoint(label_[i], rec);
@@ -65,16 +65,16 @@ public:
     } else {
       #pragma omp parallel for schedule(static) reduction(+:sum_loss)
       for (data_size_t i = 0; i < num_data_; ++i) {
-        std::vector<float> rec(num_class_);
+        std::vector<double> rec(num_class_);
         for (int k = 0; k < num_class_; ++k) {
-          rec[k] = static_cast<float>(score[k * num_data_ + i]);
+          rec[k] = static_cast<double>(score[k * num_data_ + i]);
         }
         // add loss
         sum_loss += PointWiseLossCalculator::LossOnPoint(label_[i], rec) * weights_[i];
       }
     }
-    score_t loss = sum_loss / sum_weights_;
-    return std::vector<float>(1, static_cast<float>(loss));
+    double loss = sum_loss / sum_weights_;
+    return std::vector<double>(1, loss);
   }
 
 private:
@@ -89,7 +89,7 @@ private:
   /*! \brief Pointer of weighs */
   const float* weights_;
   /*! \brief Sum weights */
-  float sum_weights_;
+  double sum_weights_;
   /*! \brief Name of this test set */
   std::string name_;
 };
@@ -99,7 +99,7 @@ class MultiErrorMetric: public MulticlassMetric<MultiErrorMetric> {
 public:
   explicit MultiErrorMetric(const MetricConfig& config) :MulticlassMetric<MultiErrorMetric>(config) {}
 
-  inline static score_t LossOnPoint(float label, std::vector<float> score) {
+  inline static score_t LossOnPoint(float label, std::vector<double> score) {
     size_t k = static_cast<size_t>(label);
     for (size_t i = 0; i < score.size(); ++i){
         if (i != k && score[i] > score[k]) {
@@ -119,11 +119,11 @@ class MultiLoglossMetric: public MulticlassMetric<MultiLoglossMetric> {
 public:
   explicit MultiLoglossMetric(const MetricConfig& config) :MulticlassMetric<MultiLoglossMetric>(config) {}
 
-  inline static score_t LossOnPoint(float label, std::vector<float> score) {
+  inline static score_t LossOnPoint(float label, std::vector<double> score) {
     size_t k = static_cast<size_t>(label);
     Common::Softmax(&score);
     if (score[k] > kEpsilon) {
-      return -std::log(score[k]);
+      return static_cast<score_t>(-std::log(score[k]));
     } else {
       return -std::log(kEpsilon);
     }

src/metric/rank_metric.hpp

@@ -51,7 +51,7 @@ public:
     // get query weights
     query_weights_ = metadata.query_weights();
     if (query_weights_ == nullptr) {
-      sum_query_weights_ = static_cast<float>(num_queries_);
+      sum_query_weights_ = static_cast<double>(num_queries_);
     } else {
       sum_query_weights_ = 0.0f;
       for (data_size_t i = 0; i < num_queries_; ++i) {
@@ -84,13 +84,13 @@ public:
     return true;
   }
 
-  std::vector<float> Eval(const score_t* score) const override {
+  std::vector<double> Eval(const score_t* score) const override {
     // some buffers for multi-threading sum up
-    std::vector<std::vector<float>> result_buffer_;
+    std::vector<std::vector<double>> result_buffer_;
     for (int i = 0; i < num_threads_; ++i) {
       result_buffer_.emplace_back(eval_at_.size(), 0.0f);
     }
-    std::vector<float> tmp_dcg(eval_at_.size(), 0.0f);
+    std::vector<score_t> tmp_dcg(eval_at_.size(), 0.0f);
     if (query_weights_ == nullptr) {
 #pragma omp parallel for schedule(guided) firstprivate(tmp_dcg)
       for (data_size_t i = 0; i < num_queries_; ++i) {
@@ -133,7 +133,7 @@ public:
       }
     }
     // Get final average NDCG
-    std::vector<float> result(eval_at_.size(), 0.0f);
+    std::vector<double> result(eval_at_.size(), 0.0f);
     for (size_t j = 0; j < result.size(); ++j) {
       for (int i = 0; i < num_threads_; ++i) {
         result[j] += result_buffer_[i][j];
@@ -157,11 +157,11 @@ private:
   /*! \brief Weights of queries */
   const float* query_weights_;
   /*! \brief Sum weights of queries */
-  float sum_query_weights_;
+  double sum_query_weights_;
   /*! \brief Evaluate position of NDCG */
   std::vector<data_size_t> eval_at_;
   /*! \brief Cache the inverse max dcg for all queries */
-  std::vector<std::vector<float>> inverse_max_dcgs_;
+  std::vector<std::vector<score_t>> inverse_max_dcgs_;
   /*! \brief Number of threads */
   int num_threads_;
 };

src/metric/regression_metric.hpp

@@ -42,7 +42,7 @@ public:
     // get weights
     weights_ = metadata.weights();
     if (weights_ == nullptr) {
-      sum_weights_ = static_cast<float>(num_data_);
+      sum_weights_ = static_cast<double>(num_data_);
     } else {
       sum_weights_ = 0.0f;
       for (data_size_t i = 0; i < num_data_; ++i) {
@@ -51,8 +51,8 @@ public:
     }
   }
 
-  std::vector<float> Eval(const score_t* score) const override {
-    score_t sum_loss = 0.0f;
+  std::vector<double> Eval(const score_t* score) const override {
+    double sum_loss = 0.0f;
     if (weights_ == nullptr) {
 #pragma omp parallel for schedule(static) reduction(+:sum_loss)
       for (data_size_t i = 0; i < num_data_; ++i) {
@@ -66,12 +66,12 @@ public:
         sum_loss += PointWiseLossCalculator::LossOnPoint(label_[i], score[i]) * weights_[i];
       }
     }
-    score_t loss = PointWiseLossCalculator::AverageLoss(sum_loss, sum_weights_);
-    return std::vector<float>(1, static_cast<float>(loss));
+    double loss = PointWiseLossCalculator::AverageLoss(sum_loss, sum_weights_);
+    return std::vector<double>(1, loss);
 
   }
 
-  inline static score_t AverageLoss(score_t sum_loss, score_t sum_weights) {
+  inline static double AverageLoss(double sum_loss, double sum_weights) {
     return sum_loss / sum_weights;
   }
 
@@ -83,7 +83,7 @@ private:
   /*! \brief Pointer of weighs */
   const float* weights_;
   /*! \brief Sum weights */
-  float sum_weights_;
+  double sum_weights_;
   /*! \brief Name of this test set */
   std::string name_;
 };
@@ -97,7 +97,7 @@ public:
     return (score - label)*(score - label);
   }
 
-  inline static score_t AverageLoss(score_t sum_loss, score_t sum_weights) {
+  inline static double AverageLoss(double sum_loss, double sum_weights) {
     // need sqrt the result for L2 loss
     return std::sqrt(sum_loss / sum_weights);
   }

src/objective/binary_objective.hpp

@@ -14,7 +14,7 @@ class BinaryLogloss: public ObjectiveFunction {
 public:
   explicit BinaryLogloss(const ObjectiveConfig& config) {
     is_unbalance_ = config.is_unbalance;
-    sigmoid_ = static_cast<float>(config.sigmoid);
+    sigmoid_ = static_cast<score_t>(config.sigmoid);
     if (sigmoid_ <= 0.0) {
       Log::Fatal("Sigmoid parameter %f :should greater than zero", sigmoid_);
     }
@@ -48,7 +48,7 @@ public:
     // if using unbalance, change the labels weight
     if (is_unbalance_) {
       label_weights_[1] = 1.0f;
-      label_weights_[0] = static_cast<float>(cnt_positive) / cnt_negative;
+      label_weights_[0] = static_cast<score_t>(cnt_positive) / cnt_negative;
     }
   }
 
@@ -80,7 +80,7 @@ public:
     }
   }
 
-  float GetSigmoid() const override {
+  score_t GetSigmoid() const override {
     return sigmoid_;
   }
 
@@ -92,11 +92,11 @@ private:
   /*! \brief True if using unbalance training */
   bool is_unbalance_;
   /*! \brief Sigmoid parameter */
-  float sigmoid_;
+  score_t sigmoid_;
   /*! \brief Values for positive and negative labels */
   int label_val_[2];
   /*! \brief Weights for positive and negative labels */
-  float label_weights_[2];
+  score_t label_weights_[2];
   /*! \brief Weights for data */
   const float* weights_;
 };

src/objective/multiclass_objective.hpp

@@ -38,9 +38,9 @@ public:
     if (weights_ == nullptr) {
       #pragma omp parallel for schedule(static)
       for (data_size_t i = 0; i < num_data_; ++i) {
-        std::vector<float> rec(num_class_);
+        std::vector<double> rec(num_class_);
         for (int k = 0; k < num_class_; ++k){
-          rec[k] = static_cast<float>(score[k * num_data_ + i]);
+          rec[k] = static_cast<double>(score[k * num_data_ + i]);
         }
         Common::Softmax(&rec);  
         for (int k = 0; k < num_class_; ++k) {
@@ -56,9 +56,9 @@ public:
     } else {
       #pragma omp parallel for schedule(static)
       for (data_size_t i = 0; i < num_data_; ++i) {
-        std::vector<float> rec(num_class_);
+        std::vector<double> rec(num_class_);
         for (int k = 0; k < num_class_; ++k){
-          rec[k] = static_cast<float>(score[k * num_data_ + i]);
+          rec[k] = static_cast<double>(score[k * num_data_ + i]);
         }  
         Common::Softmax(&rec);
         for (int k = 0; k < num_class_; ++k) {
@@ -74,7 +74,7 @@ public:
     }
   }
 
-  float GetSigmoid() const override {
+  score_t GetSigmoid() const override {
     return -1.0f;
   }
 

src/objective/rank_objective.hpp

@@ -19,11 +19,11 @@ namespace LightGBM {
 class LambdarankNDCG: public ObjectiveFunction {
 public:
   explicit LambdarankNDCG(const ObjectiveConfig& config) {
-    sigmoid_ = static_cast<float>(config.sigmoid);
+    sigmoid_ = static_cast<score_t>(config.sigmoid);
     // initialize DCG calculator
     DCGCalculator::Init(config.label_gain);
     // copy lable gain to local
-    std::vector<float> label_gain = config.label_gain;
+    std::vector<double> label_gain = config.label_gain;
     for (auto gain : label_gain) {
       label_gain_.push_back(static_cast<score_t>(gain));
     }
@@ -53,10 +53,9 @@ public:
     // cache inverse max DCG, avoid computation many times
     inverse_max_dcgs_ = new score_t[num_queries_];
     for (data_size_t i = 0; i < num_queries_; ++i) {
-      inverse_max_dcgs_[i] = static_cast<score_t>(
-        DCGCalculator::CalMaxDCGAtK(optimize_pos_at_,
+      inverse_max_dcgs_[i] = DCGCalculator::CalMaxDCGAtK(optimize_pos_at_,
         label_ + query_boundaries_[i],
-        query_boundaries_[i + 1] - query_boundaries_[i]));
+        query_boundaries_[i + 1] - query_boundaries_[i]);
 
       if (inverse_max_dcgs_[i] > 0.0) {
         inverse_max_dcgs_[i] = 1.0f / inverse_max_dcgs_[i];
@@ -113,8 +112,7 @@ public:
       const score_t high_score = score[high];
       if (high_score == kMinScore) { continue; }
       const score_t high_label_gain = label_gain_[high_label];
-      const score_t high_discount =
-        static_cast<score_t>(DCGCalculator::GetDiscount(i));
+      const score_t high_discount = DCGCalculator::GetDiscount(i);
       score_t high_sum_lambda = 0.0;
       score_t high_sum_hessian = 0.0;
       for (data_size_t j = 0; j < cnt; ++j) {
@@ -130,8 +128,7 @@ public:
         const score_t delta_score = high_score - low_score;
 
         const score_t low_label_gain = label_gain_[low_label];
-        const score_t low_discount =
-          static_cast<score_t>(DCGCalculator::GetDiscount(j));
+        const score_t low_discount = DCGCalculator::GetDiscount(j);
         // get dcg gap
         const score_t dcg_gap = high_label_gain - low_label_gain;
         // get discount of this pair
@@ -194,11 +191,11 @@ public:
     }
   }
 
-  float GetSigmoid() const override {
+  score_t GetSigmoid() const override {
     // though we use sigmoid transform on objective
     // for the prediction, we actually don't need to transform by sigmoid.
     // since we only need the ranking score.
-    return -1.0;
+    return -1.0f;
   }
 
 private:
@@ -207,7 +204,7 @@ private:
   /*! \brief Cache inverse max DCG, speed up calculation */
   score_t* inverse_max_dcgs_;
   /*! \brief Simgoid param */
-  float sigmoid_;
+  score_t sigmoid_;
   /*! \brief Optimized NDCG@ */
   int optimize_pos_at_;
   /*! \brief Number of queries */

src/objective/regression_objective.hpp

@@ -38,7 +38,7 @@ public:
     }
   }
 
-  float GetSigmoid() const override {
+  score_t GetSigmoid() const override {
     // not sigmoid transform, return -1
     return -1.0f;
   }

src/treelearner/serial_tree_learner.cpp

@@ -415,9 +415,9 @@ void SerialTreeLearner::Split(Tree* tree, int best_Leaf, int* left_leaf, int* ri
   *right_leaf = tree->Split(best_Leaf, best_split_info.feature, best_split_info.threshold,
     train_data_->FeatureAt(best_split_info.feature)->feature_index(),
     train_data_->FeatureAt(best_split_info.feature)->BinToValue(best_split_info.threshold),
-    static_cast<float>(best_split_info.left_output),
-    static_cast<float>(best_split_info.right_output),
-    static_cast<float>(best_split_info.gain));
+    static_cast<double>(best_split_info.left_output),
+    static_cast<double>(best_split_info.right_output),
+    static_cast<double>(best_split_info.gain));
 
   // split data partition
   data_partition_->Split(best_Leaf, train_data_->FeatureAt(best_split_info.feature)->bin_data(),

src/treelearner/serial_tree_learner.h

@@ -38,10 +38,10 @@ public:
     data_partition_->SetUsedDataIndices(used_indices, num_data);
   }
 
-  void AddPredictionToScore(score_t *out_score) const override {
+  void AddPredictionToScore(score_t* out_score) const override {
     #pragma omp parallel for schedule(guided)
     for (int i = 0; i < data_partition_->num_leaves(); ++i) {
-      float output = last_trained_tree_->LeafOutput(i);
+      score_t output = static_cast<score_t>(last_trained_tree_->LeafOutput(i));
       data_size_t* tmp_idx = nullptr;
       data_size_t cnt_leaf_data = data_partition_->GetIndexOnLeaf(i, &tmp_idx);
       for (data_size_t j = 0; j < cnt_leaf_data; ++j) {
@@ -116,7 +116,7 @@ protected:
   /*! \brief mininal sum hessian on one leaf */
   double min_sum_hessian_one_leaf_;
   /*! \brief sub-feature fraction rate */
-  float feature_fraction_;
+  double feature_fraction_;
   /*! \brief training data partition on leaves */
   DataPartition* data_partition_;
   /*! \brief used for generate used features */
@@ -160,7 +160,7 @@ protected:
   /*! \brief  is_data_in_leaf_[i] != 0 means i-th data is marked */
   char* is_data_in_leaf_;
   /*! \brief  max cache size(unit:GB) for historical histogram. < 0 means not limit */
-  float histogram_pool_size_;
+  double histogram_pool_size_;
   /*! \brief used to cache historical histogram to speed up*/
   LRUPool<FeatureHistogram*> histogram_pool_;
   /*! \brief  max depth of tree model */