aplr 10.16.0__tar.gz → 10.17.1__tar.gz

{aplr-10.16.0/aplr.egg-info → aplr-10.17.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: aplr
-Version: 10.16.0
+Version: 10.17.1
 Summary: Automatic Piecewise Linear Regression
 Home-page: https://github.com/ottenbreit-data-science/aplr
 Author: Mathias von Ottenbreit
@@ -16,19 +16,6 @@ License-File: LICENSE
 Requires-Dist: numpy>=1.11
 Provides-Extra: plots
 Requires-Dist: matplotlib>=3.0; extra == "plots"
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license
-Dynamic: license-file
-Dynamic: platform
-Dynamic: provides-extra
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
 
 # APLR
 **Automatic Piecewise Linear Regression**

{aplr-10.16.0 → aplr-10.17.1}/aplr/aplr.py

@@ -76,6 +76,7 @@ class APLRRegressor:
         max_terms: int = 0,
         ridge_penalty: float = 0.0001,
         mean_bias_correction: bool = False,
+        faster_convergence: bool = False,
     ):
         self.m = m
         self.v = v
@@ -124,6 +125,7 @@ class APLRRegressor:
         self.max_terms = max_terms
         self.ridge_penalty = ridge_penalty
         self.mean_bias_correction = mean_bias_correction
+        self.faster_convergence = faster_convergence
 
         # Creating aplr_cpp and setting parameters
         self.APLRRegressor = aplr_cpp.APLRRegressor()
@@ -186,6 +188,7 @@ class APLRRegressor:
         self.APLRRegressor.max_terms = self.max_terms
         self.APLRRegressor.ridge_penalty = self.ridge_penalty
         self.APLRRegressor.mean_bias_correction = self.mean_bias_correction
+        self.APLRRegressor.faster_convergence = self.faster_convergence
 
     def fit(
         self,
@@ -469,6 +472,7 @@ class APLRRegressor:
             "max_terms": self.max_terms,
             "ridge_penalty": self.ridge_penalty,
             "mean_bias_correction": self.mean_bias_correction,
+            "faster_convergence": self.faster_convergence,
         }
 
     # For sklearn

{aplr-10.16.0 → aplr-10.17.1/aplr.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: aplr
-Version: 10.16.0
+Version: 10.17.1
 Summary: Automatic Piecewise Linear Regression
 Home-page: https://github.com/ottenbreit-data-science/aplr
 Author: Mathias von Ottenbreit
@@ -16,19 +16,6 @@ License-File: LICENSE
 Requires-Dist: numpy>=1.11
 Provides-Extra: plots
 Requires-Dist: matplotlib>=3.0; extra == "plots"
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license
-Dynamic: license-file
-Dynamic: platform
-Dynamic: provides-extra
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
 
 # APLR
 **Automatic Piecewise Linear Regression**

{aplr-10.16.0 → aplr-10.17.1}/aplr.egg-info/SOURCES.txt

@@ -19,7 +19,6 @@ cpp/main.cpp
 cpp/pythonbinding.cpp
 cpp/term.h
 cpp/tests.cpp
-cpp/build/CMakeFiles/3.16.3/CompilerIdCXX/CMakeCXXCompilerId.cpp
 dependencies/eigen-3.4.0/.gitignore
 dependencies/eigen-3.4.0/.gitlab-ci.yml
 dependencies/eigen-3.4.0/.hgeol

{aplr-10.16.0 → aplr-10.17.1}/cpp/APLRRegressor.h

@@ -148,7 +148,7 @@ private:
     void update_coefficient_steps(size_t boosting_step);
     double calculate_quantile_mean_response(const VectorXd &predictions, bool top_quantile);
     void calculate_and_validate_validation_error(size_t boosting_step);
-    double calculate_validation_error(const VectorXd &predictions);
+    double calculate_validation_error(const VectorXd &predictions, const std::string &metric = "default");
     double calculate_group_mse_by_prediction_validation_error(const VectorXd &predictions);
     void update_term_eligibility();
     void update_a_term_coefficient_round_robin(size_t boosting_step);
@@ -196,6 +196,7 @@ private:
     void throw_error_if_m_is_invalid();
     bool model_has_not_been_trained();
     void throw_error_if_quantile_is_invalid();
+    void throw_error_if_validation_tuning_metric_is_invalid();
     std::vector<size_t> compute_relevant_term_indexes(const std::string &unique_term_affiliation);
     std::vector<double> compute_split_points(size_t predictor_index, const std::vector<size_t> &relevant_term_indexes);
     VectorXd compute_contribution_to_linear_predictor_from_specific_terms(const MatrixXd &X, const std::vector<size_t> &term_indexes,
@@ -259,6 +260,7 @@ public:
     VectorXd max_predictor_values_in_training;
     double ridge_penalty;
     bool mean_bias_correction;
+    bool faster_convergence;
 
     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,
@@ -272,8 +274,8 @@ public:
                   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 = 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, bool mean_bias_correction = false);
+                  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, bool mean_bias_correction = false, bool faster_convergence = false);
     APLRRegressor(const APLRRegressor &other);
     APLRRegressor &operator=(const APLRRegressor &other);
     ~APLRRegressor();
@@ -328,8 +330,8 @@ APLRRegressor::APLRRegressor(size_t m, double v, uint_fast32_t random_state, std
                              const std::function<VectorXd(VectorXd)> &calculate_custom_differentiate_predictions_wrt_linear_predictor_function,
                              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,
-                             double ridge_penalty, bool mean_bias_correction)
+                             size_t num_first_steps_with_linear_effects_only, double penalty_for_non_linearity, double penalty_for_interactions, size_t max_terms, double ridge_penalty,
+                             bool mean_bias_correction, bool faster_convergence)
     : 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},
@@ -346,7 +348,8 @@ 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}, ridge_penalty{ridge_penalty}, mean_bias_correction{mean_bias_correction}
+      penalty_for_interactions{penalty_for_interactions}, max_terms{max_terms}, ridge_penalty{ridge_penalty}, mean_bias_correction{mean_bias_correction},
+      faster_convergence{faster_convergence}
 {
 }
 
@@ -379,7 +382,7 @@ APLRRegressor::APLRRegressor(const APLRRegressor &other)
       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}, ridge_penalty{other.ridge_penalty},
-      mean_bias_correction{other.mean_bias_correction}
+      mean_bias_correction{other.mean_bias_correction}, faster_convergence{other.faster_convergence}
 {
 }
 
@@ -444,6 +447,7 @@ APLRRegressor &APLRRegressor::operator=(const APLRRegressor &other)
     unique_term_affiliation_map = other.unique_term_affiliation_map;
     base_predictors_in_each_unique_term_affiliation = other.base_predictors_in_each_unique_term_affiliation;
     ridge_penalty = other.ridge_penalty;
+    faster_convergence = other.faster_convergence;
     mean_bias_correction = other.mean_bias_correction;
 
     thread_pool.reset();
@@ -468,6 +472,7 @@ void APLRRegressor::fit(const MatrixXd &X, const VectorXd &y, const VectorXd &sa
     throw_error_if_dispersion_parameter_is_invalid();
     throw_error_if_quantile_is_invalid();
     throw_error_if_m_is_invalid();
+    throw_error_if_validation_tuning_metric_is_invalid();
     validate_input_to_fit(X, y, sample_weight, X_names, cv_observations, prioritized_predictors_indexes, monotonic_constraints, group,
                           interaction_constraints, other_data, predictor_learning_rates, predictor_penalties_for_non_linearity,
                           predictor_penalties_for_interactions);
@@ -606,6 +611,8 @@ void APLRRegressor::fit_model_for_cv_fold(const MatrixXd &X, const VectorXd &y,
     remove_unused_terms();
     if (mean_bias_correction)
         correct_mean_bias();
+    VectorXd predictions_validation{predict(X_validation, false)};
+    min_validation_error_for_current_fold = calculate_validation_error(predictions_validation, validation_tuning_metric);
     revert_scaling_if_using_log_link_function();
     set_term_coefficients();
     name_terms(X, X_names);
@@ -644,6 +651,8 @@ void APLRRegressor::throw_error_if_loss_function_does_not_exist()
         loss_function_exists = true;
     else if (loss_function == "huber")
         loss_function_exists = true;
+    else if (loss_function == "exponential_power")
+        loss_function_exists = true;
     else if (loss_function == "custom_function")
         loss_function_exists = true;
     if (!loss_function_exists)
@@ -675,7 +684,7 @@ void APLRRegressor::throw_error_if_dispersion_parameter_is_invalid()
         if (dispersion_parameter_is_invalid)
             throw std::runtime_error("Invalid dispersion_parameter (variance power). It must not equal 1.0 or 2.0 and cannot be below 1.0.");
     }
-    else if (loss_function == "negative_binomial" || loss_function == "cauchy" || loss_function == "weibull" || loss_function == "huber")
+    else if (loss_function == "negative_binomial" || loss_function == "cauchy" || loss_function == "weibull" || loss_function == "huber" || loss_function == "exponential_power")
     {
         bool dispersion_parameter_is_in_invalid{std::islessequal(dispersion_parameter, 0.0)};
         if (dispersion_parameter_is_in_invalid)
@@ -700,6 +709,34 @@ void APLRRegressor::throw_error_if_quantile_is_invalid()
     }
 }
 
+void APLRRegressor::throw_error_if_validation_tuning_metric_is_invalid()
+{
+    bool metric_exists{false};
+    if (validation_tuning_metric == "default")
+        metric_exists = true;
+    else if (validation_tuning_metric == "mse")
+        metric_exists = true;
+    else if (validation_tuning_metric == "mae")
+        metric_exists = true;
+    else if (validation_tuning_metric == "huber")
+        metric_exists = true;
+    else if (validation_tuning_metric == "negative_gini")
+        metric_exists = true;
+    else if (validation_tuning_metric == "group_mse")
+        metric_exists = true;
+    else if (validation_tuning_metric == "group_mse_by_prediction")
+        metric_exists = true;
+    else if (validation_tuning_metric == "neg_top_quantile_mean_response")
+        metric_exists = true;
+    else if (validation_tuning_metric == "bottom_quantile_mean_response")
+        metric_exists = true;
+    else if (validation_tuning_metric == "custom_function")
+        metric_exists = true;
+
+    if (!metric_exists)
+        throw std::runtime_error("validation_tuning_metric " + validation_tuning_metric + " is not available in APLR.");
+}
+
 void APLRRegressor::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, const std::vector<int> &monotonic_constraints, const VectorXi &group,
@@ -1245,6 +1282,12 @@ VectorXd APLRRegressor::calculate_neg_gradient_current()
             delta *= scaling_factor_for_log_link_function;
         output = (y_train - predictions_current).array().max(-delta).min(delta);
     }
+    else if (loss_function == "exponential_power")
+    {
+        double p = dispersion_parameter;
+        ArrayXd residuals = y_train.array() - predictions_current.array();
+        output = p * residuals.abs().pow(p - 1.0) * residuals.sign();
+    }
     else if (loss_function == "custom_function")
     {
         try
@@ -1261,6 +1304,28 @@ VectorXd APLRRegressor::calculate_neg_gradient_current()
     if (link_function != "identity")
         output = output.array() * differentiate_predictions_wrt_linear_predictor().array();
 
+    if (faster_convergence && (link_function == "identity" || link_function == "log"))
+    {
+        double standard_deviation_of_neg_gradient{calculate_standard_deviation(output, sample_weight_train)};
+        if (is_approximately_zero(standard_deviation_of_neg_gradient))
+        {
+            return output;
+        }
+
+        ArrayXd denominator{ArrayXd::Ones(y_train.size())};
+        if (link_function != "identity")
+        {
+            denominator = differentiate_predictions_wrt_linear_predictor().array();
+        }
+
+        double desired_standard_deviation{
+            calculate_standard_deviation((y_train - predictions_current).array() / denominator, sample_weight_train)};
+        double adjustment_factor = desired_standard_deviation / standard_deviation_of_neg_gradient;
+
+        if (std::isfinite(adjustment_factor))
+            output *= adjustment_factor;
+    }
+
     return output;
 }
 
@@ -1846,7 +1911,7 @@ void APLRRegressor::calculate_and_validate_validation_error(size_t boosting_step
     }
 }
 
-double APLRRegressor::calculate_validation_error(const VectorXd &predictions)
+double APLRRegressor::calculate_validation_error(const VectorXd &predictions, const std::string &metric)
 {
     VectorXd predictions_used{predictions};
     if (link_function == "log")
@@ -1854,7 +1919,7 @@ double APLRRegressor::calculate_validation_error(const VectorXd &predictions)
         predictions_used /= scaling_factor_for_log_link_function;
     }
 
-    if (validation_tuning_metric == "default")
+    if (metric == "default")
     {
         if (loss_function == "custom_function")
         {
@@ -1875,26 +1940,26 @@ double APLRRegressor::calculate_validation_error(const VectorXd &predictions)
         else
             return calculate_mean_error(calculate_errors(y_validation, predictions_used, sample_weight_validation, loss_function, dispersion_parameter, group_validation, unique_groups_validation, quantile), sample_weight_validation);
     }
-    else if (validation_tuning_metric == "mse")
+    else if (metric == "mse")
         return calculate_mean_error(calculate_errors(y_validation, predictions_used, sample_weight_validation, MSE_LOSS_FUNCTION), sample_weight_validation);
-    else if (validation_tuning_metric == "mae")
+    else if (metric == "mae")
         return calculate_mean_error(calculate_errors(y_validation, predictions_used, sample_weight_validation, "mae"), sample_weight_validation);
-    else if (validation_tuning_metric == "negative_gini")
+    else if (metric == "negative_gini")
         return -calculate_gini(y_validation, predictions_used, sample_weight_validation) / calculate_gini(y_validation, y_validation, sample_weight_validation);
-    else if (validation_tuning_metric == "group_mse")
+    else if (metric == "group_mse")
     {
         bool group_is_not_provided{group_validation.rows() == 0};
         if (group_is_not_provided)
             throw std::runtime_error("When validation_tuning_metric is group_mse then the group argument in fit() must be provided.");
         return calculate_mean_error(calculate_errors(y_validation, predictions_used, sample_weight_validation, "group_mse", dispersion_parameter, group_validation, unique_groups_validation, quantile), sample_weight_validation);
     }
-    else if (validation_tuning_metric == "huber")
+    else if (metric == "huber")
         return calculate_mean_error(calculate_errors(y_validation, predictions_used, sample_weight_validation, "huber", dispersion_parameter), sample_weight_validation);
-    else if (validation_tuning_metric == "group_mse_by_prediction")
+    else if (metric == "group_mse_by_prediction")
     {
         return calculate_group_mse_by_prediction_validation_error(predictions_used);
     }
-    else if (validation_tuning_metric == "custom_function")
+    else if (metric == "custom_function")
     {
         try
         {
@@ -1906,7 +1971,7 @@ double APLRRegressor::calculate_validation_error(const VectorXd &predictions)
             throw std::runtime_error(error_msg);
         }
     }
-    else if (validation_tuning_metric == "neg_top_quantile_mean_response")
+    else if (metric == "neg_top_quantile_mean_response")
     {
         double mean_response{calculate_quantile_mean_response(predictions_used, true)};
         if (std::isinf(mean_response))
@@ -1915,12 +1980,12 @@ double APLRRegressor::calculate_validation_error(const VectorXd &predictions)
         }
         return -mean_response;
     }
-    else if (validation_tuning_metric == "bottom_quantile_mean_response")
+    else if (metric == "bottom_quantile_mean_response")
     {
         return calculate_quantile_mean_response(predictions_used, false);
     }
     else
-        throw std::runtime_error(validation_tuning_metric + " is an invalid validation_tuning_metric.");
+        throw std::runtime_error(metric + " is an invalid validation_tuning_metric.");
 }
 
 double APLRRegressor::calculate_group_mse_by_prediction_validation_error(const VectorXd &predictions)
@@ -2045,7 +2110,7 @@ void APLRRegressor::print_final_summary()
 void APLRRegressor::find_optimal_m_and_update_model_accordingly()
 {
     size_t best_boosting_step_index;
-    min_validation_error_for_current_fold = validation_error_steps.col(0).minCoeff(&best_boosting_step_index);
+    validation_error_steps.col(0).minCoeff(&best_boosting_step_index);
     intercept = intercept_steps[best_boosting_step_index];
     for (size_t i = 0; i < terms.size(); ++i)
     {
@@ -2123,9 +2188,6 @@ void APLRRegressor::correct_mean_bias()
         }
 
         intercept += bias_adjustment;
-
-        VectorXd predictions_validation{predict(X_validation, false)};
-        min_validation_error_for_current_fold = calculate_validation_error(predictions_validation);
     }
 }
 

{aplr-10.16.0 → aplr-10.17.1}/cpp/functions.h

@@ -227,6 +227,12 @@ VectorXd calculate_huber_errors(const VectorXd &y, const VectorXd &predicted, do
     return errors.matrix();
 }
 
+VectorXd calculate_exponential_power_errors(const VectorXd &y, const VectorXd &predicted, double dispersion_parameter)
+{
+    VectorXd errors{(y.array() - predicted.array()).cwiseAbs().pow(dispersion_parameter)};
+    return errors;
+}
+
 VectorXd calculate_errors(const VectorXd &y, const VectorXd &predicted, const VectorXd &sample_weight, const std::string &loss_function = "mse",
                           double dispersion_parameter = 1.5, const VectorXi &group = VectorXi(0), const std::set<int> &unique_groups = {}, double quantile = 0.5)
 {
@@ -255,6 +261,8 @@ VectorXd calculate_errors(const VectorXd &y, const VectorXd &predicted, const Ve
         errors = calculate_weibull_errors(y, predicted, dispersion_parameter);
     else if (loss_function == "huber")
         errors = calculate_huber_errors(y, predicted, dispersion_parameter);
+    else if (loss_function == "exponential_power")
+        errors = calculate_exponential_power_errors(y, predicted, dispersion_parameter);
 
     errors = errors.array() * sample_weight.array();
 

{aplr-10.16.0 → aplr-10.17.1}/cpp/pythonbinding.cpp

@@ -22,10 +22,10 @@ PYBIND11_MODULE(aplr_cpp, m)
     py::class_<APLRRegressor>(m, "APLRRegressor", py::module_local())
         .def(py::init<int &, double &, int &, std::string &, std::string &, int &, int &, int &, int &, int &, int &, int &, int &, int &, double &, std::string &,
                       double &, std::function<double(const VectorXd &y, const VectorXd &predictions, const VectorXd &sample_weight, const VectorXi &group, const MatrixXd &other_data)> &,
-                      std::function<double(const VectorXd &y, const VectorXd &predictions, const VectorXd &sample_weight, const VectorXi &group, const MatrixXd &other_data)> &,
+                      std::function<double(const VectorXd &y, const VectorXd &predictions, const VectorXd &sample_weight, const VectorXi &group, const MatrixXd &other_data)> &, // 20
                       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 &, double &, bool &>(),
+                      int &, bool &, int &, int &, int &, int &, double &, double &, int &, double &, bool &, bool &>(),
              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,
@@ -45,7 +45,7 @@ PYBIND11_MODULE(aplr_cpp, m)
              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,
-             py::arg("mean_bias_correction") = false)
+             py::arg("mean_bias_correction") = false, py::arg("faster_convergence") = true)
         .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),
@@ -137,6 +137,7 @@ PYBIND11_MODULE(aplr_cpp, m)
         .def_readwrite("max_predictor_values_in_training", &APLRRegressor::max_predictor_values_in_training)
         .def_readwrite("ridge_penalty", &APLRRegressor::ridge_penalty)
         .def_readwrite("mean_bias_correction", &APLRRegressor::mean_bias_correction)
+        .def_readwrite("faster_convergence", &APLRRegressor::faster_convergence)
         .def(py::pickle(
             [](const APLRRegressor &a) { // __getstate__
                 /* Return a tuple that fully encodes the state of the object */
@@ -152,7 +153,8 @@ 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.ridge_penalty, a.mean_bias_correction);
+                                      a.unique_term_affiliation_map, a.base_predictors_in_each_unique_term_affiliation, a.ridge_penalty, a.mean_bias_correction,
+                                      a.faster_convergence);
             },
             [](py::tuple t) { // __setstate__
                 if (t.size() < 48)
@@ -209,6 +211,7 @@ PYBIND11_MODULE(aplr_cpp, m)
                 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;
                 bool mean_bias_correction = (t.size() > 49) ? t[49].cast<bool>() : false;
+                bool faster_convergence = (t.size() > 50) ? t[50].cast<bool>() : false;
 
                 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,
@@ -246,6 +249,7 @@ PYBIND11_MODULE(aplr_cpp, m)
                 a.base_predictors_in_each_unique_term_affiliation = base_predictors_in_each_unique_term_affiliation;
                 a.ridge_penalty = ridge_penalty;
                 a.mean_bias_correction = mean_bias_correction;
+                a.faster_convergence = faster_convergence;
 
                 return a;
             }));