aplr 10.8.0__tar.gz → 10.10.0__tar.gz

{aplr-10.8.0/aplr.egg-info → aplr-10.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aplr
-Version: 10.8.0
+Version: 10.10.0
 Summary: Automatic Piecewise Linear Regression
 Home-page: https://github.com/ottenbreit-data-science/aplr
 Author: Mathias von Ottenbreit

{aplr-10.8.0 → aplr-10.10.0}/aplr/aplr.py

@@ -69,11 +69,12 @@ class APLRRegressor:
         monotonic_constraints_ignore_interactions: bool = False,
         group_mse_by_prediction_bins: int = 10,
         group_mse_cycle_min_obs_in_bin: int = 30,
-        early_stopping_rounds: int = 500,
+        early_stopping_rounds: int = 200,
         num_first_steps_with_linear_effects_only: int = 0,
         penalty_for_non_linearity: float = 0.0,
         penalty_for_interactions: float = 0.0,
         max_terms: int = 0,
+        ridge_penalty: float = 0.0001,
     ):
         self.m = m
         self.v = v
@@ -120,6 +121,7 @@ class APLRRegressor:
         self.penalty_for_non_linearity = penalty_for_non_linearity
         self.penalty_for_interactions = penalty_for_interactions
         self.max_terms = max_terms
+        self.ridge_penalty = ridge_penalty
 
         # Creating aplr_cpp and setting parameters
         self.APLRRegressor = aplr_cpp.APLRRegressor()
@@ -180,6 +182,7 @@ class APLRRegressor:
         self.APLRRegressor.penalty_for_non_linearity = self.penalty_for_non_linearity
         self.APLRRegressor.penalty_for_interactions = self.penalty_for_interactions
         self.APLRRegressor.max_terms = self.max_terms
+        self.APLRRegressor.ridge_penalty = self.ridge_penalty
 
     def fit(
         self,
@@ -309,6 +312,12 @@ class APLRRegressor:
     def set_intercept(self, value: float):
         self.APLRRegressor.set_intercept(value)
 
+    def remove_provided_custom_functions(self):
+        self.APLRRegressor.remove_provided_custom_functions()
+        self.calculate_custom_validation_error_function = None
+        self.calculate_custom_loss_function = None
+        self.calculate_custom_negative_gradient_function = None
+
     # For sklearn
     def get_params(self, deep=True):
         return {
@@ -343,6 +352,7 @@ class APLRRegressor:
             "penalty_for_non_linearity": self.penalty_for_non_linearity,
             "penalty_for_interactions": self.penalty_for_interactions,
             "max_terms": self.max_terms,
+            "ridge_penalty": self.ridge_penalty,
         }
 
     # For sklearn
@@ -370,11 +380,12 @@ class APLRClassifier:
         max_eligible_terms: int = 7,
         boosting_steps_before_interactions_are_allowed: int = 0,
         monotonic_constraints_ignore_interactions: bool = False,
-        early_stopping_rounds: int = 500,
+        early_stopping_rounds: int = 200,
         num_first_steps_with_linear_effects_only: int = 0,
         penalty_for_non_linearity: float = 0.0,
         penalty_for_interactions: float = 0.0,
         max_terms: int = 0,
+        ridge_penalty: float = 0.0001,
     ):
         self.m = m
         self.v = v
@@ -401,6 +412,7 @@ class APLRClassifier:
         self.penalty_for_non_linearity = penalty_for_non_linearity
         self.penalty_for_interactions = penalty_for_interactions
         self.max_terms = max_terms
+        self.ridge_penalty = ridge_penalty
 
         # Creating aplr_cpp and setting parameters
         self.APLRClassifier = aplr_cpp.APLRClassifier()
@@ -435,6 +447,7 @@ class APLRClassifier:
         self.APLRClassifier.penalty_for_non_linearity = self.penalty_for_non_linearity
         self.APLRClassifier.penalty_for_interactions = self.penalty_for_interactions
         self.APLRClassifier.max_terms = self.max_terms
+        self.APLRClassifier.ridge_penalty = self.ridge_penalty
 
     def fit(
         self,
@@ -527,6 +540,7 @@ class APLRClassifier:
             "penalty_for_non_linearity": self.penalty_for_non_linearity,
             "penalty_for_interactions": self.penalty_for_interactions,
             "max_terms": self.max_terms,
+            "ridge_penalty": self.ridge_penalty,
         }
 
     # For sklearn

{aplr-10.8.0 → aplr-10.10.0/aplr.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aplr
-Version: 10.8.0
+Version: 10.10.0
 Summary: Automatic Piecewise Linear Regression
 Home-page: https://github.com/ottenbreit-data-science/aplr
 Author: Mathias von Ottenbreit

{aplr-10.8.0 → aplr-10.10.0}/cpp/APLRClassifier.h

@@ -52,13 +52,14 @@ public:
     std::vector<std::string> unique_term_affiliations;
     std::map<std::string, size_t> unique_term_affiliation_map;
     std::vector<std::vector<size_t>> base_predictors_in_each_unique_term_affiliation;
+    double ridge_penalty;
 
     APLRClassifier(size_t m = 3000, double v = 0.5, uint_fast32_t random_state = std::numeric_limits<uint_fast32_t>::lowest(), size_t n_jobs = 0,
                    size_t cv_folds = 5, 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 = 4, size_t ineligible_boosting_steps_added = 15, size_t max_eligible_terms = 7,
                    size_t boosting_steps_before_interactions_are_allowed = 0, bool monotonic_constraints_ignore_interactions = false,
-                   size_t early_stopping_rounds = 500, size_t num_first_steps_with_linear_effects_only = 0,
-                   double penalty_for_non_linearity = 0.0, double penalty_for_interactions = 0.0, size_t max_terms = 0);
+                   size_t early_stopping_rounds = 200, size_t num_first_steps_with_linear_effects_only = 0,
+                   double penalty_for_non_linearity = 0.0, double penalty_for_interactions = 0.0, size_t max_terms = 0, double ridge_penalty = 0.0001);
     APLRClassifier(const APLRClassifier &other);
     ~APLRClassifier();
     void fit(const MatrixXd &X, const std::vector<std::string> &y, const VectorXd &sample_weight = VectorXd(0),
@@ -85,7 +86,7 @@ APLRClassifier::APLRClassifier(size_t m, double v, uint_fast32_t random_state, s
                                size_t min_observations_in_split, size_t ineligible_boosting_steps_added, size_t max_eligible_terms,
                                size_t boosting_steps_before_interactions_are_allowed, bool monotonic_constraints_ignore_interactions,
                                size_t early_stopping_rounds, size_t num_first_steps_with_linear_effects_only,
-                               double penalty_for_non_linearity, double penalty_for_interactions, size_t max_terms)
+                               double penalty_for_non_linearity, double penalty_for_interactions, size_t max_terms, double ridge_penalty)
     : m{m}, v{v}, random_state{random_state}, n_jobs{n_jobs}, cv_folds{cv_folds},
       bins{bins}, verbosity{verbosity}, max_interaction_level{max_interaction_level},
       max_interactions{max_interactions}, min_observations_in_split{min_observations_in_split},
@@ -93,7 +94,7 @@ APLRClassifier::APLRClassifier(size_t m, double v, uint_fast32_t random_state, s
       boosting_steps_before_interactions_are_allowed{boosting_steps_before_interactions_are_allowed},
       monotonic_constraints_ignore_interactions{monotonic_constraints_ignore_interactions}, early_stopping_rounds{early_stopping_rounds},
       num_first_steps_with_linear_effects_only{num_first_steps_with_linear_effects_only}, penalty_for_non_linearity{penalty_for_non_linearity},
-      penalty_for_interactions{penalty_for_interactions}, max_terms{max_terms}
+      penalty_for_interactions{penalty_for_interactions}, max_terms{max_terms}, ridge_penalty{ridge_penalty}
 {
 }
 
@@ -112,7 +113,8 @@ APLRClassifier::APLRClassifier(const APLRClassifier &other)
       penalty_for_non_linearity{other.penalty_for_non_linearity}, penalty_for_interactions{other.penalty_for_interactions},
       max_terms{other.max_terms}, unique_term_affiliations{other.unique_term_affiliations},
       unique_term_affiliation_map{other.unique_term_affiliation_map},
-      base_predictors_in_each_unique_term_affiliation{other.base_predictors_in_each_unique_term_affiliation}
+      base_predictors_in_each_unique_term_affiliation{other.base_predictors_in_each_unique_term_affiliation},
+      ridge_penalty{other.ridge_penalty}
 {
 }
 
@@ -145,6 +147,7 @@ void APLRClassifier::fit(const MatrixXd &X, const std::vector<std::string> &y, c
         logit_models[categories[0]].penalty_for_non_linearity = penalty_for_non_linearity;
         logit_models[categories[0]].penalty_for_interactions = penalty_for_interactions;
         logit_models[categories[0]].max_terms = max_terms;
+        logit_models[categories[0]].ridge_penalty = ridge_penalty;
         logit_models[categories[0]].fit(X, response_values[categories[0]], sample_weight, X_names, cv_observations, prioritized_predictors_indexes,
                                         monotonic_constraints, VectorXi(0), interaction_constraints, MatrixXd(0, 0), predictor_learning_rates,
                                         predictor_penalties_for_non_linearity, predictor_penalties_for_interactions,
@@ -167,6 +170,7 @@ void APLRClassifier::fit(const MatrixXd &X, const std::vector<std::string> &y, c
             logit_models[category].penalty_for_non_linearity = penalty_for_non_linearity;
             logit_models[category].penalty_for_interactions = penalty_for_interactions;
             logit_models[category].max_terms = max_terms;
+            logit_models[category].ridge_penalty = ridge_penalty;
             logit_models[category].fit(X, response_values[category], sample_weight, X_names, cv_observations, prioritized_predictors_indexes,
                                        monotonic_constraints, VectorXi(0), interaction_constraints, MatrixXd(0, 0), predictor_learning_rates,
                                        predictor_penalties_for_non_linearity, predictor_penalties_for_interactions,

{aplr-10.8.0 → aplr-10.10.0}/cpp/APLRRegressor.h

@@ -83,6 +83,7 @@ private:
     size_t term_to_update_in_this_boosting_step;
     size_t cores_to_use;
     bool stopped_early;
+    std::vector<double> ridge_penalty_weights;
 
     void validate_input_to_fit(const MatrixXd &X, const VectorXd &y, const VectorXd &sample_weight, const std::vector<std::string> &X_names,
                                const MatrixXi &cv_observations, const std::vector<size_t> &prioritized_predictors_indexes,
@@ -250,6 +251,7 @@ public:
     size_t max_terms;
     VectorXd min_predictor_values_in_training;
     VectorXd max_predictor_values_in_training;
+    double ridge_penalty;
 
     APLRRegressor(size_t m = 3000, double v = 0.5, 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, size_t cv_folds = 5,
@@ -262,9 +264,9 @@ public:
                   const std::function<VectorXd(VectorXd)> &calculate_custom_transform_linear_predictor_to_predictions_function = {},
                   const std::function<VectorXd(VectorXd)> &calculate_custom_differentiate_predictions_wrt_linear_predictor_function = {},
                   size_t boosting_steps_before_interactions_are_allowed = 0, bool monotonic_constraints_ignore_interactions = false,
-                  size_t group_mse_by_prediction_bins = 10, size_t group_mse_cycle_min_obs_in_bin = 30, size_t early_stopping_rounds = 500,
+                  size_t group_mse_by_prediction_bins = 10, size_t group_mse_cycle_min_obs_in_bin = 30, size_t early_stopping_rounds = 200,
                   size_t num_first_steps_with_linear_effects_only = 0, double penalty_for_non_linearity = 0.0,
-                  double penalty_for_interactions = 0.0, size_t max_terms = 0);
+                  double penalty_for_interactions = 0.0, size_t max_terms = 0, double ridge_penalty = 0.0001);
     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 = {},
@@ -302,6 +304,7 @@ public:
                                                         size_t unique_term_affiliation_index);
     double get_cv_error();
     void set_intercept(double value);
+    void remove_provided_custom_functions();
 
     friend class APLRClassifier;
 };
@@ -318,7 +321,7 @@ APLRRegressor::APLRRegressor(size_t m, double v, uint_fast32_t random_state, std
                              size_t boosting_steps_before_interactions_are_allowed, bool monotonic_constraints_ignore_interactions,
                              size_t group_mse_by_prediction_bins, size_t group_mse_cycle_min_obs_in_bin, size_t early_stopping_rounds,
                              size_t num_first_steps_with_linear_effects_only, double penalty_for_non_linearity, double penalty_for_interactions,
-                             size_t max_terms)
+                             size_t max_terms, double ridge_penalty)
     : intercept{NAN_DOUBLE}, m{m}, v{v},
       loss_function{loss_function}, link_function{link_function}, cv_folds{cv_folds}, n_jobs{n_jobs}, random_state{random_state},
       bins{bins}, verbosity{verbosity}, max_interaction_level{max_interaction_level},
@@ -335,7 +338,7 @@ APLRRegressor::APLRRegressor(size_t m, double v, uint_fast32_t random_state, std
       monotonic_constraints_ignore_interactions{monotonic_constraints_ignore_interactions}, group_mse_by_prediction_bins{group_mse_by_prediction_bins},
       group_mse_cycle_min_obs_in_bin{group_mse_cycle_min_obs_in_bin}, cv_error{NAN_DOUBLE}, early_stopping_rounds{early_stopping_rounds},
       num_first_steps_with_linear_effects_only{num_first_steps_with_linear_effects_only}, penalty_for_non_linearity{penalty_for_non_linearity},
-      penalty_for_interactions{penalty_for_interactions}, max_terms{max_terms}
+      penalty_for_interactions{penalty_for_interactions}, max_terms{max_terms}, ridge_penalty{ridge_penalty}
 {
 }
 
@@ -367,7 +370,8 @@ APLRRegressor::APLRRegressor(const APLRRegressor &other)
       max_terms{other.max_terms}, min_predictor_values_in_training{other.min_predictor_values_in_training},
       max_predictor_values_in_training{other.max_predictor_values_in_training}, unique_term_affiliations{other.unique_term_affiliations},
       unique_term_affiliation_map{other.unique_term_affiliation_map},
-      base_predictors_in_each_unique_term_affiliation{other.base_predictors_in_each_unique_term_affiliation}
+      base_predictors_in_each_unique_term_affiliation{other.base_predictors_in_each_unique_term_affiliation},
+      ridge_penalty{other.ridge_penalty}
 {
 }
 
@@ -999,6 +1003,12 @@ void APLRRegressor::initialize(const std::vector<int> &monotonic_constraints)
     best_m_so_far = 0;
 
     round_robin_update_of_existing_terms = false;
+
+    ridge_penalty_weights.resize(X_train.cols());
+    for (Eigen::Index i = 0; i < X_train.cols(); ++i)
+    {
+        ridge_penalty_weights[i] = (X_train.col(i).array() * sample_weight_train.array() * X_train.col(i).array()).sum();
+    }
 }
 
 bool APLRRegressor::check_if_base_term_has_only_one_unique_value(size_t base_term)
@@ -1371,7 +1381,9 @@ void APLRRegressor::estimate_split_point_for_each_term(std::vector<Term> &terms,
                                                                  predictor_min_observations_in_split[terms[terms_indexes[i]].base_term],
                                                                  linear_effects_only_in_this_boosting_step,
                                                                  predictor_penalties_for_non_linearity[terms[terms_indexes[i]].base_term],
-                                                                 predictor_penalties_for_interactions[terms[terms_indexes[i]].base_term]);
+                                                                 predictor_penalties_for_interactions[terms[terms_indexes[i]].base_term],
+                                                                ridge_penalty, 
+                                                                ridge_penalty_weights[terms[terms_indexes[i]].base_term]);
                 } });
         }
 
@@ -1392,7 +1404,9 @@ void APLRRegressor::estimate_split_point_for_each_term(std::vector<Term> &terms,
                                                          predictor_min_observations_in_split[terms[terms_indexes[i]].base_term],
                                                          linear_effects_only_in_this_boosting_step,
                                                          predictor_penalties_for_non_linearity[terms[terms_indexes[i]].base_term],
-                                                         predictor_penalties_for_interactions[terms[terms_indexes[i]].base_term]);
+                                                         predictor_penalties_for_interactions[terms[terms_indexes[i]].base_term],
+                                                         ridge_penalty,
+                                                         ridge_penalty_weights[terms[terms_indexes[i]].base_term]);
         }
     }
 }
@@ -1830,6 +1844,8 @@ void APLRRegressor::update_a_term_coefficient_round_robin(size_t boosting_step)
                                                                                       linear_effects_only_in_this_boosting_step,
                                                                                       predictor_penalties_for_non_linearity[terms_eligible_current[term_to_update_in_this_boosting_step].base_term],
                                                                                       predictor_penalties_for_interactions[terms_eligible_current[term_to_update_in_this_boosting_step].base_term],
+                                                                                      ridge_penalty,
+                                                                                      ridge_penalty_weights[terms_eligible_current[term_to_update_in_this_boosting_step].base_term],
                                                                                       true);
     terms[term_to_update_in_this_boosting_step].coefficient += terms_eligible_current[term_to_update_in_this_boosting_step].coefficient;
     linear_predictor_update = terms_eligible_current[term_to_update_in_this_boosting_step].calculate_contribution_to_linear_predictor(X_train);
@@ -2203,6 +2219,7 @@ void APLRRegressor::cleanup_after_fit()
     unique_prediction_groups.clear();
     group_cycle_train.clear();
     unique_groups_cycle_train.clear();
+    ridge_penalty_weights.resize(0);
 }
 
 void APLRRegressor::check_term_integrity()
@@ -2759,4 +2776,11 @@ void APLRRegressor::set_intercept(double value)
         throw std::runtime_error("The new intercept must be finite.");
     intercept = value;
     term_coefficients[0] = value;
+}
+
+void APLRRegressor::remove_provided_custom_functions()
+{
+    calculate_custom_validation_error_function = {};
+    calculate_custom_loss_function = {};
+    calculate_custom_negative_gradient_function = {};
 }

{aplr-10.8.0 → aplr-10.10.0}/cpp/pythonbinding.cpp

@@ -25,7 +25,7 @@ PYBIND11_MODULE(aplr_cpp, m)
                       std::function<double(const VectorXd &y, const VectorXd &predictions, const VectorXd &sample_weight, const VectorXi &group, const MatrixXd &other_data)> &,
                       std::function<VectorXd(const VectorXd &y, const VectorXd &predictions, const VectorXi &group, const MatrixXd &other_data)> &,
                       std::function<VectorXd(const VectorXd &linear_predictor)> &, std::function<VectorXd(const VectorXd &linear_predictor)> &,
-                      int &, bool &, int &, int &, int &, int &, double &, double &, int &>(),
+                      int &, bool &, int &, int &, int &, int &, double &, double &, int &, double &>(),
              py::arg("m") = 3000, py::arg("v") = 0.5, py::arg("random_state") = 0, py::arg("loss_function") = "mse", py::arg("link_function") = "identity",
              py::arg("n_jobs") = 0, py::arg("cv_folds") = 5,
              py::arg("bins") = 300, py::arg("verbosity") = 0,
@@ -42,8 +42,9 @@ PYBIND11_MODULE(aplr_cpp, m)
              py::arg("boosting_steps_before_interactions_are_allowed") = 0,
              py::arg("monotonic_constraints_ignore_interactions") = false,
              py::arg("group_mse_by_prediction_bins") = 10, py::arg("group_mse_cycle_min_obs_in_bin") = 30,
-             py::arg("early_stopping_rounds") = 500, py::arg("num_first_steps_with_linear_effects_only") = 0,
-             py::arg("penalty_for_non_linearity") = 0.0, py::arg("penalty_for_interactions") = 0.0, py::arg("max_terms") = 0)
+             py::arg("early_stopping_rounds") = 200, py::arg("num_first_steps_with_linear_effects_only") = 0,
+             py::arg("penalty_for_non_linearity") = 0.0, py::arg("penalty_for_interactions") = 0.0, py::arg("max_terms") = 0,
+             py::arg("ridge_penalty") = 0.0001)
         .def("fit", &APLRRegressor::fit, py::arg("X"), py::arg("y"), py::arg("sample_weight") = VectorXd(0), py::arg("X_names") = std::vector<std::string>(),
              py::arg("cv_observations") = MatrixXd(0, 0), py::arg("prioritized_predictors_indexes") = std::vector<size_t>(),
              py::arg("monotonic_constraints") = std::vector<int>(), py::arg("group") = VectorXi(0),
@@ -79,6 +80,7 @@ PYBIND11_MODULE(aplr_cpp, m)
              py::arg("max_rows_before_sampling") = 100000)
         .def("get_cv_error", &APLRRegressor::get_cv_error)
         .def("set_intercept", &APLRRegressor::set_intercept, py::arg("value"))
+        .def("remove_provided_custom_functions", &APLRRegressor::remove_provided_custom_functions)
         .def_readwrite("intercept", &APLRRegressor::intercept)
         .def_readwrite("m", &APLRRegressor::m)
         .def_readwrite("m_optimal", &APLRRegressor::m_optimal)
@@ -132,6 +134,7 @@ PYBIND11_MODULE(aplr_cpp, m)
         .def_readwrite("max_terms", &APLRRegressor::max_terms)
         .def_readwrite("min_predictor_values_in_training", &APLRRegressor::min_predictor_values_in_training)
         .def_readwrite("max_predictor_values_in_training", &APLRRegressor::max_predictor_values_in_training)
+        .def_readwrite("ridge_penalty", &APLRRegressor::ridge_penalty)
         .def(py::pickle(
             [](const APLRRegressor &a) { // __getstate__
                 /* Return a tuple that fully encodes the state of the object */
@@ -147,11 +150,11 @@ PYBIND11_MODULE(aplr_cpp, m)
                                       a.penalty_for_non_linearity, a.penalty_for_interactions, a.max_terms,
                                       a.min_predictor_values_in_training, a.max_predictor_values_in_training,
                                       a.term_affiliations, a.number_of_unique_term_affiliations, a.unique_term_affiliations,
-                                      a.unique_term_affiliation_map, a.base_predictors_in_each_unique_term_affiliation);
+                                      a.unique_term_affiliation_map, a.base_predictors_in_each_unique_term_affiliation, a.ridge_penalty);
             },
             [](py::tuple t) { // __setstate__
-                if (t.size() != 48)
-                    throw std::runtime_error("Invalid state!");
+                if (t.size() < 48)
+                    throw std::runtime_error("The pickled APLRRegressor is too old. The oldest compatible version is 10.6.1.");
 
                 /* Create a new C++ instance */
                 size_t m = t[0].cast<size_t>();
@@ -202,6 +205,7 @@ PYBIND11_MODULE(aplr_cpp, m)
                 std::vector<std::string> unique_term_affiliations = t[45].cast<std::vector<std::string>>();
                 std::map<std::string, size_t> unique_term_affiliation_map = t[46].cast<std::map<std::string, size_t>>();
                 std::vector<std::vector<size_t>> base_predictors_in_each_unique_term_affiliation = t[47].cast<std::vector<std::vector<size_t>>>();
+                double ridge_penalty = (t.size() > 48) ? t[48].cast<double>() : 0.0;
 
                 APLRRegressor a(m, v, random_state, loss_function, link_function, n_jobs, cv_folds, bins, verbosity, max_interaction_level,
                                 max_interactions, min_observations_in_split, ineligible_boosting_steps_added, max_eligible_terms, dispersion_parameter,
@@ -237,6 +241,7 @@ PYBIND11_MODULE(aplr_cpp, m)
                 a.unique_term_affiliations = unique_term_affiliations;
                 a.unique_term_affiliation_map = unique_term_affiliation_map;
                 a.base_predictors_in_each_unique_term_affiliation = base_predictors_in_each_unique_term_affiliation;
+                a.ridge_penalty = ridge_penalty;
 
                 return a;
             }));
@@ -285,14 +290,15 @@ PYBIND11_MODULE(aplr_cpp, m)
 
     py::class_<APLRClassifier>(m, "APLRClassifier", py::module_local())
         .def(py::init<int &, double &, int &, int &, int &, int &, int &, int &, int &, int &, int &, int &, int &, bool &, int &, int &,
-                      double &, double &, int &>(),
+                      double &, double &, int &, double &>(),
              py::arg("m") = 3000, py::arg("v") = 0.5, py::arg("random_state") = 0, py::arg("n_jobs") = 0, py::arg("cv_folds") = 5,
              py::arg("bins") = 300, py::arg("verbosity") = 0,
              py::arg("max_interaction_level") = 1, py::arg("max_interactions") = 100000, py::arg("min_observations_in_split") = 4,
              py::arg("ineligible_boosting_steps_added") = 15, py::arg("max_eligible_terms") = 7,
              py::arg("boosting_steps_before_interactions_are_allowed") = 0, py::arg("monotonic_constraints_ignore_interactions") = false,
-             py::arg("early_stopping_rounds") = 500, py::arg("num_first_steps_with_linear_effects_only") = 0,
-             py::arg("penalty_for_non_linearity") = 0.0, py::arg("penalty_for_interactions") = 0.0, py::arg("max_terms") = 0)
+             py::arg("early_stopping_rounds") = 200, py::arg("num_first_steps_with_linear_effects_only") = 0,
+             py::arg("penalty_for_non_linearity") = 0.0, py::arg("penalty_for_interactions") = 0.0, py::arg("max_terms") = 0,
+             py::arg("ridge_penalty") = 0.0001)
         .def("fit", &APLRClassifier::fit, py::arg("X"), py::arg("y"), py::arg("sample_weight") = VectorXd(0), py::arg("X_names") = std::vector<std::string>(),
              py::arg("cv_observations") = MatrixXd(0, 0), py::arg("prioritized_predictors_indexes") = std::vector<size_t>(),
              py::arg("monotonic_constraints") = std::vector<int>(), py::arg("interaction_constraints") = std::vector<std::vector<size_t>>(),
@@ -338,6 +344,7 @@ PYBIND11_MODULE(aplr_cpp, m)
         .def_readwrite("unique_term_affiliations", &APLRClassifier::unique_term_affiliations)
         .def_readwrite("unique_term_affiliation_map", &APLRClassifier::unique_term_affiliation_map)
         .def_readwrite("base_predictors_in_each_unique_term_affiliation", &APLRClassifier::base_predictors_in_each_unique_term_affiliation)
+        .def_readwrite("ridge_penalty", &APLRClassifier::ridge_penalty)
         .def(py::pickle(
             [](const APLRClassifier &a) { // __getstate__
                 /* Return a tuple that fully encodes the state of the object */
@@ -348,11 +355,11 @@ PYBIND11_MODULE(aplr_cpp, m)
                                       a.monotonic_constraints_ignore_interactions, a.early_stopping_rounds,
                                       a.num_first_steps_with_linear_effects_only, a.penalty_for_non_linearity, a.penalty_for_interactions,
                                       a.max_terms, a.unique_term_affiliations, a.unique_term_affiliation_map,
-                                      a.base_predictors_in_each_unique_term_affiliation);
+                                      a.base_predictors_in_each_unique_term_affiliation, a.ridge_penalty);
             },
             [](py::tuple t) { // __setstate__
-                if (t.size() != 27)
-                    throw std::runtime_error("Invalid state!");
+                if (t.size() < 27)
+                    throw std::runtime_error("The pickled APLRClassifier is too old. The oldest compatible version is 10.6.1.");
 
                 /* Create a new C++ instance */
                 size_t m = t[0].cast<size_t>();
@@ -382,6 +389,7 @@ PYBIND11_MODULE(aplr_cpp, m)
                 std::vector<std::string> unique_term_affiliations = t[24].cast<std::vector<std::string>>();
                 std::map<std::string, size_t> unique_term_affiliation_map = t[25].cast<std::map<std::string, size_t>>();
                 std::vector<std::vector<size_t>> base_predictors_in_each_unique_term_affiliation = t[26].cast<std::vector<std::vector<size_t>>>();
+                double ridge_penalty = (t.size() > 27) ? t[27].cast<double>() : 0.0;
 
                 APLRClassifier a(m, v, random_state, n_jobs, cv_folds, bins, verbosity, max_interaction_level, max_interactions,
                                  min_observations_in_split, ineligible_boosting_steps_added, max_eligible_terms);
@@ -400,6 +408,7 @@ PYBIND11_MODULE(aplr_cpp, m)
                 a.unique_term_affiliations = unique_term_affiliations;
                 a.unique_term_affiliation_map = unique_term_affiliation_map;
                 a.base_predictors_in_each_unique_term_affiliation = base_predictors_in_each_unique_term_affiliation;
+                a.ridge_penalty = ridge_penalty;
 
                 return a;
             }));

{aplr-10.8.0 → aplr-10.10.0}/cpp/term.h

@@ -47,11 +47,14 @@ private:
     bool linear_effects_only_in_this_boosting_step;
     double penalty_for_non_linearity;
     double penalty_for_interactions;
+    double ridge_penalty;
+    double ridge_penalty_weight;
 
     void calculate_error_where_given_terms_are_zero(const VectorXd &negative_gradient, const VectorXd &sample_weight);
     void initialize_parameters_in_estimate_split_point(size_t bins, double v, size_t min_observations_in_split,
                                                        bool linear_effects_only_in_this_boosting_step,
-                                                       double penalty_for_non_linearity, double penalty_for_interactions);
+                                                       double penalty_for_non_linearity, double penalty_for_interactions,
+                                                       double ridge_penalty, double ridge_penalty_weight);
     void adjust_min_observations_in_split_to_avoid_computational_errors(size_t min_observations_in_split);
     void sort_vectors_ascending_by_base_term(const MatrixXd &X, const VectorXd &negative_gradient, const VectorXd &sample_weight);
     SortedData sort_data(const VectorXd &values_to_sort, const VectorXd &negative_gradient_to_sort, const VectorXd &sample_weight_to_sort);
@@ -101,7 +104,8 @@ public:
     static bool equals_given_terms(const Term &p1, const Term &p2);
     void estimate_split_point(const MatrixXd &X, const VectorXd &negative_gradient, const VectorXd &sample_weight, size_t bins, double v,
                               size_t min_observations_in_split, bool linear_effects_only_in_this_boosting_step,
-                              double penalty_for_non_linearity, double penalty_for_interactions, bool estimate_coefficient_only = false);
+                              double penalty_for_non_linearity, double penalty_for_interactions, double ridge_penalty,
+                              double ridge_penalty_weight, bool estimate_coefficient_only = false);
     size_t get_interaction_level();
     VectorXd calculate_without_interactions(const VectorXd &x);
     void calculate_rows_to_zero_out_and_not_due_to_given_terms(const MatrixXd &X);
@@ -178,7 +182,8 @@ bool operator==(const Term &p1, const Term &p2)
 
 void Term::estimate_split_point(const MatrixXd &X, const VectorXd &negative_gradient, const VectorXd &sample_weight, size_t bins, double v,
                                 size_t min_observations_in_split, bool linear_effects_only_in_this_boosting_step,
-                                double penalty_for_non_linearity, double penalty_for_interactions, bool estimate_coefficient_only)
+                                double penalty_for_non_linearity, double penalty_for_interactions, double ridge_penalty,
+                                double ridge_penalty_weight, bool estimate_coefficient_only)
 {
     bool learning_rate_is_zero{is_approximately_zero(v)};
     if (learning_rate_is_zero)
@@ -197,7 +202,7 @@ void Term::estimate_split_point(const MatrixXd &X, const VectorXd &negative_grad
     }
 
     initialize_parameters_in_estimate_split_point(bins, v, min_observations_in_split, linear_effects_only_in_this_boosting_step,
-                                                  penalty_for_non_linearity, penalty_for_interactions);
+                                                  penalty_for_non_linearity, penalty_for_interactions, ridge_penalty, ridge_penalty_weight);
     calculate_error_where_given_terms_are_zero(negative_gradient, sample_weight);
     sort_vectors_ascending_by_base_term(X, negative_gradient, sample_weight);
     if (!estimate_coefficient_only)
@@ -322,13 +327,15 @@ void Term::calculate_error_where_given_terms_are_zero(const VectorXd &negative_g
 
 void Term::initialize_parameters_in_estimate_split_point(size_t bins, double v, size_t min_observations_in_split,
                                                          bool linear_effects_only_in_this_boosting_step, double penalty_for_non_linearity,
-                                                         double penalty_for_interactions)
+                                                         double penalty_for_interactions, double ridge_penalty, double ridge_penalty_weight)
 {
     this->bins = bins;
     this->v = v;
     this->linear_effects_only_in_this_boosting_step = linear_effects_only_in_this_boosting_step;
     this->penalty_for_non_linearity = penalty_for_non_linearity;
     this->penalty_for_interactions = penalty_for_interactions;
+    this->ridge_penalty = ridge_penalty;
+    this->ridge_penalty_weight = ridge_penalty_weight;
     adjust_min_observations_in_split_to_avoid_computational_errors(min_observations_in_split);
     max_index = calculate_max_index_in_vector(rows_to_zero_out_and_not_due_to_given_terms.not_zeroed);
 }
@@ -619,6 +626,8 @@ double Term::estimate_coefficient(const VectorXd &x, const VectorXd &y, const Ve
         numerator += x[i] * y[i] * sample_weight[i];
         denominator += x[i] * x[i] * sample_weight[i];
     }
+    if (ridge_penalty > 0.0)
+        denominator += ridge_penalty * ridge_penalty_weight;
     return numerator / denominator;
 }