reverted to 1.3.2 and added comments to api reference

Author: mathias-von-ottenbreit

API_REFERENCE.md

@@ -1,6 +1,6 @@
 # APLRRegressor
 
-## class aplr.APLRRegressor(m:int=1000, v:float=0.1, random_state:int=0, family:str="gaussian", 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, tweedie_power:float=1.5, cap_outliers_in_validation_set:bool=True, cap_outliers_when_using_the_model:bool=True)
+## class aplr.APLRRegressor(m:int=1000, v:float=0.1, random_state:int=0, family:str="gaussian", 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, tweedie_power:float=1.5)
 
 ### Constructor parameters
 
@@ -52,12 +52,6 @@ Limits 1) the number of terms already in the model that can be considered as int
 #### tweedie_power (default = 1.5)
 Species the variance power for the "tweedie" ***family*** and ***link_function***.
 
-#### cap_outliers_in_validation_set (default = True)
-If ***True*** then term values will be limited by the minimum and maximum values found during model training when calculating validation error. If you need the model to extrapolate then it may be more appropriate to set ***cap_outliers_in_validation_set*** to ***False***. In the latter case the model may become more vulnerable to outliers.
-
-#### cap_outliers_when_using_the_model (default = True)
-If ***True*** then term values will be limited by the minimum and maximum values found during model training when using the model. This can make the model less vulnerable to outliers and is recommended unless you need the model to extrapolate. If you need the model to extrapolate then set ***cap_outliers_when_using_the_model*** to ***False***.
-
 
 ## Method: fit(X:npt.ArrayLike, y:npt.ArrayLike, sample_weight:npt.ArrayLike = np.empty(0), X_names:List[str]=[], validation_set_indexes:List[int]=[])
 
@@ -173,14 +167,4 @@ The index of the term selected. So ***0*** is the first term, ***1*** is the sec
 
 ## Method: get_m()
 
-***Returns the number of boosting steps in the model (the value that minimized validation error).***
-
-
-## Method: set_cap_outliers_when_using_the_model(cap_outliers_when_using_the_model:bool)
-
-***Sets cap_outliers_when_using_the_model.***
-
-### Parameters
-
-#### cap_outliers_when_using_the_model
-True or False.
+***Returns the number of boosting steps in the model (the value that minimized validation error).***

aplr/aplr.py

@@ -5,7 +5,7 @@
 
 
 class APLRRegressor():
-    def __init__(self, m:int=1000, v:float=0.1, random_state:int=0, family:str="gaussian", 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, tweedie_power:float=1.5, cap_outliers_in_validation_set:bool=True, cap_outliers_when_using_the_model:bool=True):
+    def __init__(self, m:int=1000, v:float=0.1, random_state:int=0, family:str="gaussian", 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, tweedie_power:float=1.5):
         self.m=m
         self.v=v
         self.random_state=random_state
@@ -22,8 +22,6 @@ def __init__(self, m:int=1000, v:float=0.1, random_state:int=0, family:str="gaus
         self.max_eligible_terms=max_eligible_terms
         self.verbosity=verbosity
         self.tweedie_power=tweedie_power
-        self.cap_outliers_in_validation_set=cap_outliers_in_validation_set
-        self.cap_outliers_when_using_the_model=cap_outliers_when_using_the_model
 
         #Creating aplr_cpp and setting parameters
         self.APLRRegressor=aplr_cpp.APLRRegressor()
@@ -47,8 +45,6 @@ def __set_params_cpp(self):
         self.APLRRegressor.max_eligible_terms=self.max_eligible_terms
         self.APLRRegressor.verbosity=self.verbosity
         self.APLRRegressor.tweedie_power=self.tweedie_power
-        self.APLRRegressor.cap_outliers_in_validation_set=self.cap_outliers_in_validation_set
-        self.APLRRegressor.cap_outliers_when_using_the_model=self.cap_outliers_when_using_the_model
 
     def fit(self, X:npt.ArrayLike, y:npt.ArrayLike, sample_weight:npt.ArrayLike = np.empty(0), X_names:List[str]=[], validation_set_indexes:List[int]=[]):
         self.__set_params_cpp()
@@ -93,13 +89,9 @@ def get_intercept_steps(self)->npt.ArrayLike:
     def get_m(self)->int:
         return self.APLRRegressor.get_m()
 
-    def set_cap_outliers_when_using_the_model(self, cap_outliers_when_using_the_model:bool):
-        self.APLRRegressor.set_cap_outliers_when_using_the_model(cap_outliers_when_using_the_model)
-        self.cap_outliers_when_using_the_model=self.APLRRegressor.cap_outliers_when_using_the_model
-
     #For sklearn
     def get_params(self, deep=True):
-        return {"m": self.m, "v": self.v,"random_state":self.random_state,"family":self.family,"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,"verbosity":self.verbosity,"min_observations_in_split":self.min_observations_in_split,"ineligible_boosting_steps_added":self.ineligible_boosting_steps_added,"max_eligible_terms":self.max_eligible_terms,"tweedie_power":self.tweedie_power,"cap_outliers_in_validation_set":self.cap_outliers_in_validation_set,"cap_outliers_when_using_the_model":self.cap_outliers_when_using_the_model}
+        return {"m": self.m, "v": self.v,"random_state":self.random_state,"family":self.family,"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,"verbosity":self.verbosity,"min_observations_in_split":self.min_observations_in_split,"ineligible_boosting_steps_added":self.ineligible_boosting_steps_added,"max_eligible_terms":self.max_eligible_terms,"tweedie_power":self.tweedie_power}
 
     #For sklearn
     def set_params(self, **parameters):

cpp/APLRRegressor.h

@@ -118,22 +118,18 @@ class APLRRegressor
     size_t number_of_base_terms; 
     VectorXd feature_importance; //Populated in fit() using validation set. Rows are in the same order as in X.
     double tweedie_power;
-    bool cap_outliers_in_validation_set;
-    bool cap_outliers_when_using_the_model;
 
     //Methods
     APLRRegressor(size_t m=1000,double v=0.1,uint_fast32_t random_state=std::numeric_limits<uint_fast32_t>::lowest(),std::string family="gaussian",
         std::string link_function="identity", size_t n_jobs=0, double validation_ratio=0.2,double intercept=NAN_DOUBLE,
         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 tweedie_power=1.5,
-        bool cap_outliers_in_validation_set=true, bool cap_outliers_when_using_the_model=true);
+        size_t min_observations_in_split=20, size_t ineligible_boosting_steps_added=10, size_t max_eligible_terms=5,double tweedie_power=1.5);
     APLRRegressor(const APLRRegressor &other);
     ~APLRRegressor();
     void fit(const MatrixXd &X,const VectorXd &y,const VectorXd &sample_weight=VectorXd(0),const std::vector<std::string> &X_names={},const std::vector<size_t> &validation_set_indexes={});
     VectorXd predict(const MatrixXd &X);
     void set_term_names(const std::vector<std::string> &X_names);
     MatrixXd calculate_local_feature_importance(const MatrixXd &X);
-    MatrixXd calculate_local_feature_importance_base_function(const MatrixXd &X, bool cap_outliers);
     MatrixXd calculate_local_feature_importance_for_terms(const MatrixXd &X);
     MatrixXd calculate_terms(const MatrixXd &X);
     std::vector<std::string> get_term_names();
@@ -144,21 +140,18 @@ class APLRRegressor
     double get_intercept();
     VectorXd get_intercept_steps();
     size_t get_m();
-    void set_cap_outliers_when_using_the_model(bool cap_outliers_when_using_the_model);
 };
 
 //Regular constructor
 APLRRegressor::APLRRegressor(size_t m,double v,uint_fast32_t random_state,std::string family,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,
-    size_t max_interactions,size_t min_observations_in_split,size_t ineligible_boosting_steps_added,size_t max_eligible_terms,double tweedie_power,
-    bool cap_outliers_in_validation_set, bool cap_outliers_when_using_the_model):
+    size_t max_interactions,size_t min_observations_in_split,size_t ineligible_boosting_steps_added,size_t max_eligible_terms,double tweedie_power):
         reserved_terms_times_num_x{reserved_terms_times_num_x},intercept{intercept},m{m},v{v},
         family{family},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},
         intercept_steps{VectorXd(0)},max_interactions{max_interactions},interactions_eligible{0},validation_error_steps{VectorXd(0)},
         min_observations_in_split{min_observations_in_split},ineligible_boosting_steps_added{ineligible_boosting_steps_added},
-        max_eligible_terms{max_eligible_terms},number_of_base_terms{0},tweedie_power{tweedie_power},
-        cap_outliers_in_validation_set{cap_outliers_in_validation_set},cap_outliers_when_using_the_model{cap_outliers_when_using_the_model}
+        max_eligible_terms{max_eligible_terms},number_of_base_terms{0},tweedie_power{tweedie_power}
 {
 }
 
@@ -172,8 +165,7 @@ APLRRegressor::APLRRegressor(const APLRRegressor &other):
     max_interactions{other.max_interactions},interactions_eligible{other.interactions_eligible},validation_error_steps{other.validation_error_steps},
     min_observations_in_split{other.min_observations_in_split},ineligible_boosting_steps_added{other.ineligible_boosting_steps_added},
     max_eligible_terms{other.max_eligible_terms},number_of_base_terms{other.number_of_base_terms},
-    feature_importance{other.feature_importance},tweedie_power{other.tweedie_power},
-    cap_outliers_in_validation_set{other.cap_outliers_in_validation_set},cap_outliers_when_using_the_model{other.cap_outliers_when_using_the_model}
+    feature_importance{other.feature_importance},tweedie_power{other.tweedie_power}
 {
 }
 
@@ -749,7 +741,7 @@ void APLRRegressor::select_the_best_term_and_update_errors(size_t boosting_step)
 
         //Updating current predictions
         VectorXd values{terms_eligible_current[best_term].calculate(X_train)};
-        VectorXd values_validation{terms_eligible_current[best_term].calculate(X_validation, cap_outliers_in_validation_set)};
+        VectorXd values_validation{terms_eligible_current[best_term].calculate(X_validation)};
         linear_predictor_update=values*terms_eligible_current[best_term].coefficient;
         linear_predictor_update_validation=values_validation*terms_eligible_current[best_term].coefficient;
         double error_after_updating_term=calculate_sum_error(calculate_errors(neg_gradient_current,linear_predictor_update,sample_weight_train));
@@ -1002,7 +994,7 @@ void APLRRegressor::set_term_names(const std::vector<std::string> &X_names)
 void APLRRegressor::calculate_feature_importance_on_validation_set()
 {
     feature_importance=VectorXd::Constant(number_of_base_terms,0);
-    MatrixXd li{calculate_local_feature_importance_base_function(X_validation, cap_outliers_in_validation_set)};
+    MatrixXd li{calculate_local_feature_importance(X_validation)};
     for (size_t i = 0; i < static_cast<size_t>(li.cols()); ++i) //for each column calculate mean abs values
     {
         feature_importance[i]=li.col(i).cwiseAbs().mean();
@@ -1012,11 +1004,6 @@ void APLRRegressor::calculate_feature_importance_on_validation_set()
 //Computes local feature importance on data X.
 //Output matrix has columns for each base term in the same order as in X and observations in rows.
 MatrixXd APLRRegressor::calculate_local_feature_importance(const MatrixXd &X)
-{
-    return calculate_local_feature_importance_base_function(X, cap_outliers_when_using_the_model);
-}
-
-MatrixXd APLRRegressor::calculate_local_feature_importance_base_function(const MatrixXd &X, bool cap_outliers)
 {
     validate_that_model_can_be_used(X);
 
@@ -1025,7 +1012,7 @@ MatrixXd APLRRegressor::calculate_local_feature_importance_base_function(const M
     //Terms
     for (size_t i = 0; i < terms.size(); ++i) //for each term
     {
-        VectorXd contrib{terms[i].calculate_prediction_contribution(X, cap_outliers)};
+        VectorXd contrib{terms[i].calculate_prediction_contribution(X)};
         output.col(terms[i].base_term)+=contrib;
     }
 
@@ -1084,7 +1071,7 @@ VectorXd APLRRegressor::calculate_linear_predictor(const MatrixXd &X)
     VectorXd predictions{VectorXd::Constant(X.rows(),intercept)};
     for (size_t i = 0; i < terms.size(); ++i) //for each term
     {
-        VectorXd contrib{terms[i].calculate_prediction_contribution(X, cap_outliers_when_using_the_model)};
+        VectorXd contrib{terms[i].calculate_prediction_contribution(X)};
         predictions+=contrib;
     }
     return predictions;    
@@ -1099,7 +1086,7 @@ MatrixXd APLRRegressor::calculate_local_feature_importance_for_terms(const Matri
     //Terms
     for (size_t i = 0; i < terms.size(); ++i) //for each term
     {
-        VectorXd contrib{terms[i].calculate_prediction_contribution(X, cap_outliers_when_using_the_model)};
+        VectorXd contrib{terms[i].calculate_prediction_contribution(X)};
         output.col(i)+=contrib;
     }
 
@@ -1115,7 +1102,7 @@ MatrixXd APLRRegressor::calculate_terms(const MatrixXd &X)
     //Terms
     for (size_t i = 0; i < terms.size(); ++i) //for each term
     {
-        VectorXd values{terms[i].calculate(X, cap_outliers_when_using_the_model)};
+        VectorXd values{terms[i].calculate(X)};
         output.col(i)+=values;
     }
 
@@ -1160,9 +1147,4 @@ VectorXd APLRRegressor::get_intercept_steps()
 size_t APLRRegressor::get_m()
 {
     return m;
-}
-
-void APLRRegressor::set_cap_outliers_when_using_the_model(bool cap_outliers_when_using_the_model)
-{
-    this->cap_outliers_when_using_the_model=cap_outliers_when_using_the_model;
 }

cpp/main.cpp

@@ -24,8 +24,6 @@ int main()
     model.max_interactions=30;
     model.ineligible_boosting_steps_added=10;
     model.max_eligible_terms=5;
-    model.cap_outliers_in_validation_set=false;
-    model.cap_outliers_when_using_the_model=false;
 
     //Data    
     MatrixXd X_train{load_csv<MatrixXd>("X_train.csv")};