bugfix

Author: mathias-von-ottenbreit

cpp/APLRRegressor.h

@@ -66,7 +66,7 @@ class APLRRegressor
                     const std::vector<std::vector<size_t>> &interaction_constraints);
     bool check_if_base_term_has_only_one_unique_value(size_t base_term);
     void add_term_to_terms_eligible_current(Term &term);
-    VectorXd calculate_neg_gradient_current(const VectorXd &sample_weight_train);
+    VectorXd calculate_neg_gradient_current();
     void execute_boosting_steps();
     void execute_boosting_step(size_t boosting_step);
     std::vector<size_t> find_terms_eligible_current_indexes_for_a_base_term(size_t base_term);
@@ -109,7 +109,7 @@ class APLRRegressor
     void throw_error_if_sample_weight_contains_invalid_values(const VectorXd &y, const VectorXd &sample_weight);
     void throw_error_if_response_is_not_between_0_and_1(const VectorXd &y, const std::string &error_message);
     void throw_error_if_vector_contains_negative_values(const VectorXd &y, const std::string &error_message);
-    void throw_error_if_response_is_not_greater_than_zero(const VectorXd &y, const std::string &error_message);
+    void throw_error_if_vector_contains_non_positive_values(const VectorXd &y, const std::string &error_message);
     void throw_error_if_dispersion_parameter_is_invalid();
     VectorXd differentiate_predictions_wrt_linear_predictor();
     void scale_response_if_using_log_link_function();
@@ -366,9 +366,9 @@ void APLRRegressor::validate_input_to_fit(const MatrixXd &X, const VectorXd &y,
     throw_error_if_interaction_constraints_has_invalid_indexes(X, interaction_constraints);
     throw_error_if_response_contains_invalid_values(y);
     throw_error_if_sample_weight_contains_invalid_values(y, sample_weight);
-    bool group_is_of_incorrect_size{loss_function == "group_mse" && group.rows() != y.rows()};
+    bool group_is_of_incorrect_size{(loss_function == "group_mse" || validation_tuning_metric == "group_mse") && group.rows() != y.rows()};
     if (group_is_of_incorrect_size)
-        throw std::runtime_error("When loss_function is group_mse then y and group must have the same number of rows.");
+        throw std::runtime_error("When loss_function or validation_tuning_metric is group_mse then y and group must have the same number of rows.");
     bool other_data_is_provided{other_data.size() > 0};
     if (other_data_is_provided)
     {
@@ -439,7 +439,7 @@ void APLRRegressor::throw_error_if_response_contains_invalid_values(const Vector
             error_message = "Response values for the " + loss_function + " loss_function when dispersion_parameter>2 must be greater than zero.";
         else
             error_message = "Response values for the " + loss_function + " loss_function must be greater than zero.";
-        throw_error_if_response_is_not_greater_than_zero(y, error_message);
+        throw_error_if_vector_contains_non_positive_values(y, error_message);
     }
     else if (link_function == "log" || loss_function == "poisson" || loss_function == "negative_binomial" || loss_function == "weibull" || (loss_function == "tweedie" && std::isless(dispersion_parameter, 2) && std::isgreater(dispersion_parameter, 1)))
     {
@@ -471,7 +471,7 @@ void APLRRegressor::throw_error_if_vector_contains_negative_values(const VectorX
         throw std::runtime_error(error_message);
 }
 
-void APLRRegressor::throw_error_if_response_is_not_greater_than_zero(const VectorXd &y, const std::string &error_message)
+void APLRRegressor::throw_error_if_vector_contains_non_positive_values(const VectorXd &y, const std::string &error_message)
 {
     bool response_is_not_greater_than_zero{(y.array() <= 0.0).any()};
     if (response_is_not_greater_than_zero)
@@ -485,10 +485,7 @@ void APLRRegressor::throw_error_if_sample_weight_contains_invalid_values(const V
     {
         if (sample_weight.size() != y.size())
             throw std::runtime_error("sample_weight must have 0 or as many rows as X and y.");
-        throw_error_if_vector_contains_negative_values(sample_weight, "sample_weight cannot contain negative values.");
-        bool sum_is_zero{sample_weight.sum() == 0};
-        if (sum_is_zero)
-            throw std::runtime_error("sample_weight cannot sum to zero.");
+        throw_error_if_vector_contains_non_positive_values(sample_weight, "all sample_weight values must be greater than zero.");
     }
 }
 
@@ -705,7 +702,7 @@ void APLRRegressor::add_term_to_terms_eligible_current(Term &term)
     terms_eligible_current.push_back(term);
 }
 
-VectorXd APLRRegressor::calculate_neg_gradient_current(const VectorXd &sample_weight_train)
+VectorXd APLRRegressor::calculate_neg_gradient_current()
 {
     VectorXd output;
     if (loss_function == "mse")
@@ -720,17 +717,29 @@ VectorXd APLRRegressor::calculate_neg_gradient_current(const VectorXd &sample_we
         output = (y_train.array() - predictions_current.array()).array() * predictions_current.array().pow(-dispersion_parameter);
     else if (loss_function == "group_mse")
     {
-        GroupData group_residuals_and_count{calculate_group_errors_and_count(y_train, predictions_current, group_train, unique_groups_train)};
+        GroupData group_residuals_and_count{calculate_group_errors_and_count(y_train, predictions_current, group_train, unique_groups_train,
+                                                                             sample_weight_train)};
 
         for (int unique_group_value : unique_groups_train)
         {
             group_residuals_and_count.error[unique_group_value] /= group_residuals_and_count.count[unique_group_value];
         }
 
         output = VectorXd(y_train.rows());
-        for (Eigen::Index i = 0; i < y_train.size(); ++i)
+        bool sample_weight_is_provided{sample_weight_train.size() > 0};
+        if (sample_weight_is_provided)
         {
-            output[i] = group_residuals_and_count.error[group_train[i]];
+            for (Eigen::Index i = 0; i < y_train.size(); ++i)
+            {
+                output[i] = group_residuals_and_count.error[group_train[i]] * sample_weight_train[i];
+            }
+        }
+        else
+        {
+            for (Eigen::Index i = 0; i < y_train.size(); ++i)
+            {
+                output[i] = group_residuals_and_count.error[group_train[i]];
+            }
         }
     }
     else if (loss_function == "mae")
@@ -892,7 +901,7 @@ void APLRRegressor::update_linear_predictor_and_predictions()
 
 void APLRRegressor::update_gradient_and_errors()
 {
-    neg_gradient_current = calculate_neg_gradient_current(sample_weight_train);
+    neg_gradient_current = calculate_neg_gradient_current();
     neg_gradient_nullmodel_errors_sum = calculate_sum_error(calculate_errors(neg_gradient_current, linear_predictor_null_model, sample_weight_train, MSE_LOSS_FUNCTION));
 }
 

cpp/functions.h

@@ -94,33 +94,53 @@ VectorXd calculate_tweedie_errors(const VectorXd &y, const VectorXd &predicted,
 struct GroupData
 {
     std::map<int, double> error;
-    std::map<int, size_t> count;
+    std::map<int, double> count;
 };
 
-GroupData calculate_group_errors_and_count(const VectorXd &y, const VectorXd &predicted, const VectorXi &group, const std::set<int> &unique_groups)
+GroupData calculate_group_errors_and_count(const VectorXd &y, const VectorXd &predicted, const VectorXi &group, const std::set<int> &unique_groups,
+                                           const VectorXd &sample_weight)
 {
     GroupData group_data;
     for (int unique_group_value : unique_groups)
     {
         group_data.error[unique_group_value] = 0.0;
-        group_data.count[unique_group_value] = 0;
+        group_data.count[unique_group_value] = 0.0;
     }
-    for (Eigen::Index i = 0; i < group.size(); ++i)
+
+    bool sample_weight_is_provided{sample_weight.size() > 0};
+    if (sample_weight_is_provided)
     {
-        group_data.error[group[i]] += y[i] - predicted[i];
-        group_data.count[group[i]] += 1;
+        for (Eigen::Index i = 0; i < group.size(); ++i)
+        {
+            group_data.error[group[i]] += (y[i] - predicted[i]) * sample_weight[i];
+            group_data.count[group[i]] += sample_weight[i];
+        }
     }
+    else
+    {
+        for (Eigen::Index i = 0; i < group.size(); ++i)
+        {
+            group_data.error[group[i]] += y[i] - predicted[i];
+            group_data.count[group[i]] += 1.0;
+        }
+    }
+
+    for (int unique_group_value : unique_groups)
+    {
+        group_data.error[unique_group_value] = group_data.error[unique_group_value] / group_data.count[unique_group_value];
+    }
+
     return group_data;
 }
 
-VectorXd calculate_group_mse_errors(const VectorXd &y, const VectorXd &predicted, const VectorXi &group, const std::set<int> &unique_groups)
+VectorXd calculate_group_mse_errors(const VectorXd &y, const VectorXd &predicted, const VectorXi &group, const std::set<int> &unique_groups,
+                                    const VectorXd &sample_weight)
 {
-    GroupData group_residuals_and_count{calculate_group_errors_and_count(y, predicted, group, unique_groups)};
+    GroupData group_residuals_and_count{calculate_group_errors_and_count(y, predicted, group, unique_groups, sample_weight)};
 
     for (int unique_group_value : unique_groups)
     {
         group_residuals_and_count.error[unique_group_value] *= group_residuals_and_count.error[unique_group_value];
-        group_residuals_and_count.error[unique_group_value] /= group_residuals_and_count.count[unique_group_value];
     }
 
     VectorXd errors(y.rows());
@@ -191,7 +211,7 @@ VectorXd calculate_errors(const VectorXd &y, const VectorXd &predicted, const Ve
     else if (loss_function == "tweedie")
         errors = calculate_tweedie_errors(y, predicted, dispersion_parameter);
     else if (loss_function == "group_mse")
-        errors = calculate_group_mse_errors(y, predicted, group, unique_groups);
+        errors = calculate_group_mse_errors(y, predicted, group, unique_groups, sample_weight);
     else if (loss_function == "mae")
         errors = calculate_absolute_errors(y, predicted);
     else if (loss_function == "quantile")

cpp/tests.cpp

@@ -600,7 +600,7 @@ class Tests
         VectorXd y_train{load_csv_into_eigen_matrix<MatrixXd>("data/y_train.csv")};
         VectorXd y_test{load_csv_into_eigen_matrix<MatrixXd>("data/y_test.csv")};
 
-        VectorXd sample_weight{VectorXd::Constant(y_train.size(), 1.0)};
+        VectorXd sample_weight{VectorXd::Constant(y_train.size(), 0.5)};
 
         VectorXi group{X_train.col(0).cast<int>()};
 
@@ -610,6 +610,7 @@ class Tests
         // model.fit(X_train,y_train);
         // model.fit(X_train,y_train,sample_weight);
         // model.fit(X_train,y_train,sample_weight,{},{0,1,2,3,4,5,10,static_cast<size_t>(y_train.size()-1)});
+        // model.fit(X_train, y_train, VectorXd(0), {}, {}, {}, {}, group);
         model.fit(X_train, y_train, sample_weight, {}, {}, {}, {}, group);
         std::cout << "feature importance\n"
                   << model.feature_importance << "\n\n";
@@ -621,7 +622,7 @@ class Tests
         save_as_csv_file("data/output.csv", predictions);
 
         std::cout << predictions.mean() << "\n\n";
-        tests.push_back(is_approximately_equal(predictions.mean(), 23.4234, 0.00001));
+        tests.push_back(is_approximately_equal(predictions.mean(), 20.7268, 0.00001));
     }
 
     void test_aplrregressor_int_constr()

setup.py

@@ -15,7 +15,7 @@
 
 setuptools.setup(
     name="aplr",
-    version="7.6.1",
+    version="7.6.2",
     description="Automatic Piecewise Linear Regression",
     ext_modules=[sfc_module],
     author="Mathias von Ottenbreit",