refactor

Author: mathias-von-ottenbreit

cpp/APLRRegressor.h

@@ -231,8 +231,8 @@ class APLRRegressor
              const MatrixXd &other_data = MatrixXd(0, 0));
     VectorXd predict(const MatrixXd &X, bool cap_predictions_to_minmax_in_training = true);
     void set_term_names(const std::vector<std::string> &X_names);
-    VectorXd calculate_feature_importance(const MatrixXd &X, const VectorXd &sample_weight);
-    VectorXd calculate_term_importance(const MatrixXd &X, const VectorXd &sample_weight);
+    VectorXd calculate_feature_importance(const MatrixXd &X, const VectorXd &sample_weight = VectorXd(0));
+    VectorXd calculate_term_importance(const MatrixXd &X, const VectorXd &sample_weight = VectorXd(0));
     MatrixXd calculate_local_feature_contribution(const MatrixXd &X);
     MatrixXd calculate_local_term_contribution(const MatrixXd &X);
     MatrixXd calculate_terms(const MatrixXd &X);

cpp/functions.h

@@ -509,19 +509,17 @@ std::vector<double> remove_duplicate_elements_from_vector(const std::vector<doub
     return output;
 }
 
-double calculate_standard_deviation(const VectorXd &vector, const VectorXd &weight = VectorXd(0))
+double calculate_standard_deviation(const VectorXd &vector, const VectorXd &sample_weight = VectorXd(0))
 {
-    bool weight_is_provided{weight.size() > 0};
-    double variance;
-    if (weight_is_provided)
-    {
-        double sum_weight{weight.sum()};
-        double weighted_average_of_vector{(vector.array() * weight.array()).sum() / sum_weight};
-        variance = (weight.array() * (vector.array() - weighted_average_of_vector).pow(2)).sum() / sum_weight;
-    }
+    VectorXd sample_weight_used;
+    bool sample_weight_is_provided{sample_weight.size() > 0};
+    if (sample_weight_is_provided)
+        sample_weight_used = sample_weight / sample_weight.mean();
     else
-    {
-        variance = (vector.array() - vector.mean()).pow(2).mean();
-    }
-    return std::pow(variance, 0.5);
+        sample_weight_used = VectorXd::Constant(vector.rows(), 1.0);
+    double sum_weight{sample_weight_used.sum()};
+    double weighted_average_of_vector{(vector.array() * sample_weight_used.array()).sum() / sum_weight};
+    double variance{(sample_weight_used.array() * (vector.array() - weighted_average_of_vector).pow(2)).sum() / sum_weight};
+    double standard_deviation{std::pow(variance, 0.5)};
+    return standard_deviation;
 }

cpp/term.h

@@ -550,21 +550,11 @@ void Term::estimate_split_point_on_discretized_data()
 
 void Term::estimate_coefficient_and_error(const VectorXd &x, const VectorXd &y, const VectorXd &sample_weight, double error_added)
 {
-    coefficient = estimate_coefficient(x, y, sample_weight);
-    if (std::isfinite(coefficient))
+    coefficient = v * estimate_coefficient(x, y, sample_weight);
+    if (std::isfinite(coefficient) && coefficient_adheres_to_monotonic_constraint())
     {
-        coefficient *= v;
-        bool coefficient_does_not_adhere_to_monotonic_constraint{!coefficient_adheres_to_monotonic_constraint()};
-        if (coefficient_does_not_adhere_to_monotonic_constraint)
-        {
-            coefficient = 0.0;
-            split_point_search_errors_sum = std::numeric_limits<double>::infinity();
-        }
-        else
-        {
-            VectorXd predictions{x * coefficient};
-            split_point_search_errors_sum = calculate_sum_error(calculate_errors(y, predictions, sample_weight, MSE_LOSS_FUNCTION)) + error_added;
-        }
+        VectorXd predictions{x * coefficient};
+        split_point_search_errors_sum = calculate_sum_error(calculate_errors(y, predictions, sample_weight, MSE_LOSS_FUNCTION)) + error_added;
     }
     else
     {

cpp/tests.cpp

@@ -117,6 +117,8 @@ class Tests
         std::cout << predictions.mean() << "\n\n";
         tests.push_back(is_approximately_equal(predictions.mean(), 20.170939369337834));
 
+        VectorXd feature_importance_on_test_set{model.calculate_feature_importance(X_test)};
+        double feature_importance_on_test_set_mean{feature_importance_on_test_set.mean()};
         double feature_importance_mean{model.get_feature_importance().mean()};
         double term_importance_mean{model.get_term_importance().mean()};
         double feature_importance_first{model.get_feature_importance()[0]};
@@ -129,6 +131,7 @@ class Tests
         std::cout << term_importance_first << "\n\n";
         std::cout << term_base_predictor_index_max << "\n\n";
         std::cout << term_interaction_level_max << "\n\n";
+        tests.push_back(is_approximately_equal(feature_importance_on_test_set_mean, 0.3745208543129413));
         tests.push_back(is_approximately_equal(feature_importance_mean, 0.37558643075803277));
         tests.push_back(is_approximately_equal(term_importance_mean, 0.12150899891033366));
         tests.push_back(is_approximately_equal(feature_importance_first, 0.74048121167747938));