bugfix

Author: mathias-von-ottenbreit

API_REFERENCE.md

@@ -53,7 +53,7 @@ Limits 1) the number of terms already in the model that can be considered as int
 Specifies the variance power for the "tweedie" ***family***.
 
 #### validation_tuning_metric (default = "default")
-Specifies which tuning metric to use for validating the model. Available options are "default" (using the same methodology as when calculating the training error), "mse", "mae" and "rankability". The default is often a choice that fits well with respect to the ***family*** chosen. However, if you want to use ***family*** as a tuning parameter then the default is not suitable. "rankability" uses a methodology similar to the one described in https://towardsdatascience.com/how-to-calculate-roc-auc-score-for-regression-models-c0be4fdf76bb
+Specifies which metric to use for validating the model and tuning ***m***. Available options are "default" (using the same methodology as when calculating the training error), "mse", "mae" and "rankability". The default is often a choice that fits well with respect to the ***family*** chosen. However, if you want to use ***family*** or ***tweedie_power*** as tuning parameters then the default is not suitable. "rankability" uses a methodology similar to the one described in https://towardsdatascience.com/how-to-calculate-roc-auc-score-for-regression-models-c0be4fdf76bb
 
 ## Method: fit(X:npt.ArrayLike, y:npt.ArrayLike, sample_weight:npt.ArrayLike = np.empty(0), X_names:List[str]=[], validation_set_indexes:List[int]=[], prioritized_predictors_indexes:List[int]=[], monotonic_constraints:List[int]=[])
 

cpp/APLRRegressor.h

@@ -46,7 +46,7 @@ class APLRRegressor
     double scaling_factor_for_log_link_function;
     std::vector<size_t> predictor_indexes;
     std::vector<size_t> prioritized_predictors_indexes;
-    std::vector<int> monotonic_constraints; //Make this VectorXi and validate for nan/inf input
+    std::vector<int> monotonic_constraints;
 
     //Methods
     void validate_input_to_fit(const MatrixXd &X,const VectorXd &y,const VectorXd &sample_weight,const std::vector<std::string> &X_names, 
@@ -78,6 +78,7 @@ class APLRRegressor
     void update_gradient_and_errors();
     void add_new_term(size_t boosting_step);
     void calculate_and_validate_validation_error(size_t boosting_step);
+    void calculate_validation_error(size_t boosting_step, const VectorXd &predictions);
     void update_term_eligibility();
     void print_summary_after_boosting_step(size_t boosting_step);
     void update_coefficients_for_all_steps();
@@ -962,50 +963,14 @@ void APLRRegressor::add_new_term(size_t boosting_step)
 
 void APLRRegressor::calculate_and_validate_validation_error(size_t boosting_step)
 {
-    VectorXd rescaled_predictions_current_validation(0);
-    bool link_function_is_log{link_function=="log"};
-    if(link_function_is_log)
-    {
-        rescaled_predictions_current_validation = predictions_current_validation / scaling_factor_for_log_link_function;
-    }
-    
-    bool using_default{validation_tuning_metric=="default"};
-    bool using_mse{validation_tuning_metric=="mse"};
-    bool using_mae{validation_tuning_metric=="mae"};
-    bool using_rankability{validation_tuning_metric=="rankability"};
-    if(using_default)
-    {
-        if(link_function_is_log)
-            validation_error_steps[boosting_step]=calculate_mean_error(calculate_errors(y_validation,rescaled_predictions_current_validation,sample_weight_validation,family,tweedie_power),sample_weight_validation);
-        else
-            validation_error_steps[boosting_step]=calculate_mean_error(calculate_errors(y_validation,predictions_current_validation,sample_weight_validation,family,tweedie_power),sample_weight_validation);
-    }
-    else if(using_mse)
-    {
-        if(link_function_is_log)
-            validation_error_steps[boosting_step]=calculate_mean_error(calculate_errors(y_validation,rescaled_predictions_current_validation,sample_weight_validation),sample_weight_validation);
-        else
-            validation_error_steps[boosting_step]=calculate_mean_error(calculate_errors(y_validation,predictions_current_validation,sample_weight_validation),sample_weight_validation);
-    }
-    else if(using_mae)
-    {
-        if(link_function_is_log)
-            validation_error_steps[boosting_step]=calculate_mean_error(calculate_absolute_errors(y_validation,rescaled_predictions_current_validation,sample_weight_validation),sample_weight_validation);
-        else
-            validation_error_steps[boosting_step]=calculate_mean_error(calculate_absolute_errors(y_validation,predictions_current_validation,sample_weight_validation),sample_weight_validation);
-    }
-    else if(using_rankability)
+    if(link_function=="log")
     {
-        if(link_function_is_log)
-            validation_error_steps[boosting_step]=-calculate_rankability(y_validation,rescaled_predictions_current_validation,sample_weight_validation,random_state);
-        else
-            validation_error_steps[boosting_step]=-calculate_rankability(y_validation,predictions_current_validation,sample_weight_validation,random_state);
+        VectorXd rescaled_predictions_current_validation{predictions_current_validation / scaling_factor_for_log_link_function};
+        calculate_validation_error(boosting_step, rescaled_predictions_current_validation);
     }
     else
-    {
-        throw std::runtime_error(validation_tuning_metric + " is an invalid validation_tuning_metric.");
-    }
-
+        calculate_validation_error(boosting_step, predictions_current_validation);
+    
     bool validation_error_is_invalid{std::isinf(validation_error_steps[boosting_step])};
     if(validation_error_is_invalid)
     {
@@ -1015,6 +980,20 @@ void APLRRegressor::calculate_and_validate_validation_error(size_t boosting_step
     }
 }
 
+void APLRRegressor::calculate_validation_error(size_t boosting_step, const VectorXd &predictions)
+{
+    if(validation_tuning_metric=="default")
+        validation_error_steps[boosting_step]=calculate_mean_error(calculate_errors(y_validation,predictions,sample_weight_validation,family,tweedie_power),sample_weight_validation);
+    else if(validation_tuning_metric=="mse")
+        validation_error_steps[boosting_step]=calculate_mean_error(calculate_errors(y_validation,predictions,sample_weight_validation),sample_weight_validation);
+    else if(validation_tuning_metric=="mae")
+        validation_error_steps[boosting_step]=calculate_mean_error(calculate_absolute_errors(y_validation,predictions,sample_weight_validation),sample_weight_validation);
+    else if(validation_tuning_metric=="rankability")
+        validation_error_steps[boosting_step]=-calculate_rankability(y_validation,predictions,sample_weight_validation,random_state);
+    else
+        throw std::runtime_error(validation_tuning_metric + " is an invalid validation_tuning_metric.");
+}
+
 void APLRRegressor::update_term_eligibility()
 {
     number_of_eligible_terms=terms_eligible_current.size();

cpp/functions.h

@@ -353,6 +353,9 @@ double calculate_rankability(const VectorXd &y_true, const VectorXd &y_pred, con
         }
     }
     double rankability{num_ranked_correctly/num_pairs};
+    bool rankability_is_invalid{!std::isfinite(rankability)};
+    if(rankability_is_invalid)
+        rankability=0.5;
 
     return rankability;
 }

setup.py

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