removed parallelization of group-wise metrics

Author: AndreFCruz

include/LightGBM/objective_function.h

@@ -623,25 +623,19 @@ class ConstrainedObjectiveFunction : public ObjectiveFunction
     */
   void ComputeFPR(const double *score, double probabilities_threshold, std::unordered_map<constraint_group_t, double> &group_fpr) const
   {
-    std::mutex fp_mutex, ln_mutex;
     std::unordered_map<int, int> false_positives;
     std::unordered_map<int, int> label_negatives;
 
-    #pragma omp parallel for schedule(static)
     for (data_size_t i = 0; i < num_data_; ++i)
     {
       constraint_group_t group = group_[i];
 
       if (label_[i] == 0)
       {
-        {
-          std::lock_guard<std::mutex> lock(ln_mutex);
-          label_negatives[group] += 1;
-        }
+        label_negatives[group] += 1;
 
         const double z = 1.0f / (1.0f + std::exp(-score[i]));
         if (z >= probabilities_threshold) {
-          std::lock_guard<std::mutex> lock(fp_mutex);
           false_positives[group] += 1;
         }
       }
@@ -693,29 +687,21 @@ class ConstrainedObjectiveFunction : public ObjectiveFunction
     */
   void ComputeHingeFPR(const double *score, std::unordered_map<constraint_group_t, double> &group_fpr) const
   {
-    std::mutex fp_mutex, ln_mutex;
     std::unordered_map<constraint_group_t, double> false_positives; // map of group index to the respective hinge-proxy FPs
     std::unordered_map<constraint_group_t, int> label_negatives;    // map of group index to the respective number of LNs
 
-    #pragma omp parallel for schedule(static)
     for (data_size_t i = 0; i < num_data_; ++i)
     {
       constraint_group_t group = group_[i];
 
       // HingeFPR uses only label negatives
       if (label_[i] == 0)
       {
-        {
-          std::lock_guard<std::mutex> lock(ln_mutex);
-          label_negatives[group] += 1;
-        }
+        label_negatives[group] += 1;
 
         // proxy_margin_ is the line intercept value
         const double hinge_score = proxy_margin_ + score[i];
-        {
-          std::lock_guard<std::mutex> lock(fp_mutex);
-          false_positives[group] += std::max(0.0, hinge_score);
-        }
+        false_positives[group] += std::max(0.0, hinge_score);
       }
     }
 
@@ -741,30 +727,22 @@ class ConstrainedObjectiveFunction : public ObjectiveFunction
    */
   void ComputeQuadraticLossFPR(const double *score, std::unordered_map<constraint_group_t, double> &group_fpr) const
   {
-    std::mutex fp_mutex, ln_mutex;
     std::unordered_map<constraint_group_t, double> false_positives; // map of group index to the respective proxy FPs
     std::unordered_map<constraint_group_t, int> label_negatives;    // map of group index to the respective number of LNs
 
-    #pragma omp parallel for schedule(static)
     for (data_size_t i = 0; i < num_data_; ++i)
     {
       constraint_group_t group = group_[i];
 
       // FPR uses only label NEGATIVES
       if (label_[i] == 0 and score[i] > -proxy_margin_)
       { // Conditions for non-zero proxy-FPR value
-        {
-          std::lock_guard<std::mutex> lock(ln_mutex);
-          label_negatives[group] += 1;
-        }
+        label_negatives[group] += 1;
 
         // proxy_margin_ corresponds to the symmetric of the function's zero point; f(-proxy_margin_)=0
         const double quadratic_score = (1. / 2.) * std::pow(score[i] + proxy_margin_, 2);
         assert(quadratic_score >= 0.);
-        {
-          std::lock_guard<std::mutex> lock(fp_mutex);
-          false_positives[group] += quadratic_score;
-        }
+        false_positives[group] += quadratic_score;
       }
     }
 
@@ -790,31 +768,23 @@ class ConstrainedObjectiveFunction : public ObjectiveFunction
    */
   void ComputeXEntropyLossFPR(const double *score, std::unordered_map<constraint_group_t, double> &group_fpr) const
   {
-    std::mutex fp_mutex, ln_mutex;
     std::unordered_map<constraint_group_t, double> false_positives; // map of group index to the respective proxy FPs
     std::unordered_map<constraint_group_t, int> label_negatives;    // map of group index to the respective number of LNs
     const double xent_horizontal_shift = log(exp(proxy_margin_) - 1);
 
-    #pragma omp parallel for schedule(static)
     for (data_size_t i = 0; i < num_data_; ++i)
     {
       constraint_group_t group = group_[i];
 
       // FPR uses only label NEGATIVES
       if (label_[i] == 0)
       {
-        {
-          std::lock_guard<std::mutex> lock(ln_mutex);
-          label_negatives[group] += 1;
-        }
+        label_negatives[group] += 1;
 
         // proxy_margin_ corresponds to the vertical margin at x=0; l(0) = proxy_margin_
         const double xent_score = log(1 + exp(score[i] + xent_horizontal_shift));
         assert(xent_score >= 0.);
-        {
-          std::lock_guard<std::mutex> lock(fp_mutex);
-          false_positives[group] += xent_score;
-        }
+        false_positives[group] += xent_score;
       }
     }
 
@@ -838,25 +808,19 @@ class ConstrainedObjectiveFunction : public ObjectiveFunction
     */
   void ComputeFNR(const double *score, double probabilities_threshold, std::unordered_map<constraint_group_t, double> &group_fnr) const
   {
-    std::mutex fn_mutex, lp_mutex;
     std::unordered_map<constraint_group_t, int> false_negatives;
     std::unordered_map<constraint_group_t, int> label_positives;
 
-    #pragma omp parallel for schedule(static)
     for (data_size_t i = 0; i < num_data_; ++i)
     {
       constraint_group_t group = group_[i];
 
       if (label_[i] == 1)
       {
-        {
-          std::lock_guard<std::mutex> lock(lp_mutex);
-          label_positives[group] += 1;
-        }
+        label_positives[group] += 1;
 
         const double z = 1.0f / (1.0f + std::exp(-score[i]));
         if (z < probabilities_threshold) {
-          std::lock_guard<std::mutex> lock(fn_mutex);
           false_negatives[group] += 1;
         }
       }
@@ -907,27 +871,19 @@ class ConstrainedObjectiveFunction : public ObjectiveFunction
     */
   void ComputeHingeLossFNR(const double *score, std::unordered_map<constraint_group_t, double> &group_fnr) const
   {
-    std::mutex fn_mutex, lp_mutex;
     std::unordered_map<constraint_group_t, double> false_negatives; // map of group index to the respective hinge-proxy FNs
     std::unordered_map<constraint_group_t, int> label_positives;
 
-    #pragma omp parallel for schedule(static)
     for (data_size_t i = 0; i < num_data_; ++i)
     {
       constraint_group_t group = group_[i];
 
       if (label_[i] == 1)
       {
-        {
-          std::lock_guard<std::mutex> lock(lp_mutex);
-          label_positives[group] += 1;
-        }
+        label_positives[group] += 1;
 
         const double hinge_score = proxy_margin_ - score[i];
-        {
-          std::lock_guard<std::mutex> lock(fn_mutex);
-          false_negatives[group] += std::max(0.0, hinge_score);
-        }
+        false_negatives[group] += std::max(0.0, hinge_score);
       }
     }
 
@@ -952,30 +908,22 @@ class ConstrainedObjectiveFunction : public ObjectiveFunction
    */
   void ComputeQuadraticLossFNR(const double *score, std::unordered_map<constraint_group_t, double> &group_fnr) const
   {
-    std::mutex fn_mutex, lp_mutex;
     std::unordered_map<constraint_group_t, double> false_negatives; // map of group index to the respective proxy FPs
     std::unordered_map<constraint_group_t, int> label_positives;    // map of group index to the respective number of LNs
 
-    #pragma omp parallel for schedule(static)
     for (data_size_t i = 0; i < num_data_; ++i)
     {
       constraint_group_t group = group_[i];
 
       // FNR uses only label POSITIVES
       if (label_[i] == 1 and score[i] < proxy_margin_)
       { // Conditions for non-zero proxy-FNR value
-        {
-          std::lock_guard<std::mutex> lock(lp_mutex);
-          label_positives[group] += 1;
-        }
+        label_positives[group] += 1;
 
         // proxy_margin_ corresponds to the function's zero point; f(proxy_margin_)=0
         const double quadratic_score = (1. / 2.) * std::pow(score[i] - proxy_margin_, 2);
         assert(quadratic_score >= 0.);
-        {
-          std::lock_guard<std::mutex> lock(fn_mutex);
-          false_negatives[group] += quadratic_score;
-        }
+        false_negatives[group] += quadratic_score;
       }
     }
 
@@ -1001,31 +949,23 @@ class ConstrainedObjectiveFunction : public ObjectiveFunction
    */
   void ComputeXEntropyLossFNR(const double *score, std::unordered_map<constraint_group_t, double> &group_fnr) const
   {
-    std::mutex fn_mutex, lp_mutex;
     std::unordered_map<constraint_group_t, double> false_negatives; // map of group index to the respective proxy FPs
     std::unordered_map<constraint_group_t, int> label_positives;    // map of group index to the respective number of LNs
     const double xent_horizontal_shift = log(exp(proxy_margin_) - 1);
 
-    #pragma omp parallel for schedule(static)
     for (data_size_t i = 0; i < num_data_; ++i)
     {
       constraint_group_t group = group_[i];
 
       // FNR uses only label POSITIVES
       if (label_[i] == 1)
       {
-        {
-          std::lock_guard<std::mutex> lock(lp_mutex);
-          label_positives[group] += 1;
-        }
+        label_positives[group] += 1;
 
         // proxy_margin_ corresponds to the vertical margin at x=0; l(0) = proxy_margin_
         const double xent_score = log(1 + exp(xent_horizontal_shift - score[i]));
         assert(xent_score >= 0.);
-        {
-          std::lock_guard<std::mutex> lock(fn_mutex);
-          false_negatives[group] += xent_score;
-        }
+        false_negatives[group] += xent_score;
       }
     }