deprecation of intercept field and bugfixes

Author: mathias-von-ottenbreit

API_REFERENCE_FOR_REGRESSION.md

@@ -1,6 +1,6 @@
 # APLRRegressor
 
-## class aplr.APLRRegressor(m:int=1000, v:float=0.1, random_state:int=0, loss_function:str="mse", link_function:str="identity", n_jobs:int=0, validation_ratio:float=0.2, intercept:float=np.nan, bins:int=300, max_interaction_level:int=1, max_interactions:int=100000, min_observations_in_split:int=20, ineligible_boosting_steps_added:int=10, max_eligible_terms:int=5, verbosity:int=0, dispersion_parameter:float=1.5, validation_tuning_metric:str="default", quantile:float=0.5)
+## class aplr.APLRRegressor(m:int=1000, v:float=0.1, random_state:int=0, loss_function:str="mse", link_function:str="identity", n_jobs:int=0, validation_ratio:float=0.2, bins:int=300, max_interaction_level:int=1, max_interactions:int=100000, min_observations_in_split:int=20, ineligible_boosting_steps_added:int=10, max_eligible_terms:int=5, verbosity:int=0, dispersion_parameter:float=1.5, validation_tuning_metric:str="default", quantile:float=0.5)
 
 ### Constructor parameters
 
@@ -25,9 +25,6 @@ Multi-threading parameter. If ***0*** then uses all available cores for multi-th
 #### validation_ratio (default = 0.2)
 The ratio of training observations to use for validation instead of training. The number of boosting steps is automatically tuned to minimize validation error.
 
-#### intercept (default = nan)
-Specifies the intercept term of the model if you want to predict before doing any training. However, when the ***fit*** method is run then the intercept is estimated based on data and whatever was specified as ***intercept*** when instantiating ***APLRRegressor*** gets overwritten.
-
 #### bins (default = 300)
 Specifies the maximum number of bins to discretize the data into when searching for the best split. The default value works well according to empirical results. This hyperparameter is intended for reducing computational costs. Must be greater than 1.
 

aplr/aplr.py

@@ -5,15 +5,14 @@
 
 
 class APLRRegressor():
-    def __init__(self, m:int=1000, v:float=0.1, random_state:int=0, loss_function:str="mse", link_function:str="identity", n_jobs:int=0, validation_ratio:float=0.2, intercept:float=np.nan, bins:int=300, max_interaction_level:int=1, max_interactions:int=100000, min_observations_in_split:int=20, ineligible_boosting_steps_added:int=10, max_eligible_terms:int=5, verbosity:int=0, dispersion_parameter:float=1.5, validation_tuning_metric:str="default", quantile:float=0.5):
+    def __init__(self, m:int=1000, v:float=0.1, random_state:int=0, loss_function:str="mse", link_function:str="identity", n_jobs:int=0, validation_ratio:float=0.2, bins:int=300, max_interaction_level:int=1, max_interactions:int=100000, min_observations_in_split:int=20, ineligible_boosting_steps_added:int=10, max_eligible_terms:int=5, verbosity:int=0, dispersion_parameter:float=1.5, validation_tuning_metric:str="default", quantile:float=0.5):
         self.m=m
         self.v=v
         self.random_state=random_state
         self.loss_function=loss_function
         self.link_function=link_function
         self.n_jobs=n_jobs
         self.validation_ratio=validation_ratio
-        self.intercept=intercept
         self.bins=bins
         self.max_interaction_level=max_interaction_level
         self.max_interactions=max_interactions
@@ -38,7 +37,6 @@ def __set_params_cpp(self):
         self.APLRRegressor.link_function=self.link_function
         self.APLRRegressor.n_jobs=self.n_jobs
         self.APLRRegressor.validation_ratio=self.validation_ratio
-        self.APLRRegressor.intercept=self.intercept
         self.APLRRegressor.bins=self.bins
         self.APLRRegressor.max_interaction_level=self.max_interaction_level
         self.APLRRegressor.max_interactions=self.max_interactions
@@ -106,7 +104,6 @@ def get_params(self, deep=True):
             "link_function":self.link_function,
             "n_jobs":self.n_jobs,
             "validation_ratio":self.validation_ratio,
-            "intercept":self.intercept,
             "bins":self.bins,
             "max_interaction_level":self.max_interaction_level,
             "max_interactions":self.max_interactions,

cpp/APLRClassifier.h

@@ -101,7 +101,7 @@ void APLRClassifier::fit(const MatrixXd &X,const std::vector<std::string> &y,con
     bool two_class_case{categories.size()==2};
     if(two_class_case)
     {
-        logit_models[categories[0]] = APLRRegressor(m,v,random_state,"binomial","logit",n_jobs,validation_ratio,NAN_DOUBLE,reserved_terms_times_num_x,
+        logit_models[categories[0]] = APLRRegressor(m,v,random_state,"binomial","logit",n_jobs,validation_ratio,reserved_terms_times_num_x,
             bins,verbosity,max_interaction_level,max_interactions,min_observations_in_split,ineligible_boosting_steps_added,
             max_eligible_terms,1.5,"default",0.5);
         logit_models[categories[0]].fit(X,response_values[categories[0]],sample_weight,X_names,validation_indexes,prioritized_predictors_indexes,
@@ -114,7 +114,7 @@ void APLRClassifier::fit(const MatrixXd &X,const std::vector<std::string> &y,con
     {
         for (auto &category:categories)
         {
-            logit_models[category] = APLRRegressor(m,v,random_state,"binomial","logit",n_jobs,validation_ratio,NAN_DOUBLE,reserved_terms_times_num_x,
+            logit_models[category] = APLRRegressor(m,v,random_state,"binomial","logit",n_jobs,validation_ratio,reserved_terms_times_num_x,
                 bins,verbosity,max_interaction_level,max_interactions,min_observations_in_split,ineligible_boosting_steps_added,
                 max_eligible_terms,1.5,"default",0.5);
             logit_models[category].fit(X,response_values[category],sample_weight,X_names,validation_indexes,prioritized_predictors_indexes,

cpp/APLRRegressor.h

@@ -110,6 +110,7 @@ class APLRRegressor
     void cap_predictions_to_minmax_in_training(VectorXd &predictions);
     std::string compute_raw_base_term_name(const Term &term, const std::string &X_name);
     void throw_error_if_m_is_invalid();
+    bool model_has_not_been_trained();
 
 public:
     double intercept;
@@ -143,7 +144,7 @@ class APLRRegressor
     double quantile;
 
     APLRRegressor(size_t m=1000,double v=0.1,uint_fast32_t random_state=std::numeric_limits<uint_fast32_t>::lowest(),std::string loss_function="mse",
-        std::string link_function="identity", size_t n_jobs=0, double validation_ratio=0.2,double intercept=NAN_DOUBLE,
+        std::string link_function="identity", size_t n_jobs=0, double validation_ratio=0.2,
         size_t reserved_terms_times_num_x=100, size_t bins=300,size_t verbosity=0,size_t max_interaction_level=1,size_t max_interactions=100000,
         size_t min_observations_in_split=20, size_t ineligible_boosting_steps_added=10, size_t max_eligible_terms=5,double dispersion_parameter=1.5,
         std::string validation_tuning_metric="default", double quantile=0.5);
@@ -169,10 +170,10 @@ class APLRRegressor
 };
 
 APLRRegressor::APLRRegressor(size_t m,double v,uint_fast32_t random_state,std::string loss_function,std::string link_function,size_t n_jobs,
-    double validation_ratio,double intercept,size_t reserved_terms_times_num_x,size_t bins,size_t verbosity,size_t max_interaction_level,
+    double validation_ratio,size_t reserved_terms_times_num_x,size_t bins,size_t verbosity,size_t max_interaction_level,
     size_t max_interactions,size_t min_observations_in_split,size_t ineligible_boosting_steps_added,size_t max_eligible_terms,double dispersion_parameter,
     std::string validation_tuning_metric, double quantile):
-        reserved_terms_times_num_x{reserved_terms_times_num_x},intercept{intercept},m{m},v{v},
+        reserved_terms_times_num_x{reserved_terms_times_num_x},intercept{NAN_DOUBLE},m{m},v{v},
         loss_function{loss_function},link_function{link_function},validation_ratio{validation_ratio},n_jobs{n_jobs},random_state{random_state},
         bins{bins},verbosity{verbosity},max_interaction_level{max_interaction_level},
         max_interactions{max_interactions},interactions_eligible{0},validation_error_steps{VectorXd(0)},
@@ -1274,8 +1275,7 @@ void APLRRegressor::name_terms(const MatrixXd &X, const std::vector<std::string>
 
 void APLRRegressor::set_term_names(const std::vector<std::string> &X_names)
 {
-    bool model_has_not_been_trained{!std::isfinite(intercept)};
-    if(model_has_not_been_trained)
+    if(model_has_not_been_trained())
         throw std::runtime_error("The model must be trained with fit() before term names can be set.");
 
     for (size_t i = 0; i < terms.size(); ++i)
@@ -1306,6 +1306,11 @@ void APLRRegressor::set_term_names(const std::vector<std::string> &X_names)
     }   
 }
 
+bool APLRRegressor::model_has_not_been_trained()
+{
+    return !std::isfinite(intercept);
+}
+
 std::string APLRRegressor::compute_raw_base_term_name(const Term &term, const std::string &X_name)
 {
     std::string name{""};
@@ -1363,7 +1368,7 @@ void APLRRegressor::find_min_and_max_training_predictions_or_responses()
 
 void APLRRegressor::validate_that_model_can_be_used(const MatrixXd &X)
 {
-    if(std::isnan(intercept) || number_of_base_terms==0) throw std::runtime_error("Model must be trained before predict() can be run.");
+    if(model_has_not_been_trained()) throw std::runtime_error("The model must be trained with fit() before predict() can be run.");
     if(X.rows()==0) throw std::runtime_error("X cannot have zero rows.");
     size_t cols_provided{static_cast<size_t>(X.cols())};
     if(cols_provided!=number_of_base_terms) throw std::runtime_error("X must have "+std::to_string(number_of_base_terms) +" columns but "+std::to_string(cols_provided)+" were provided.");