aplr 10.7.3__tar.gz → 10.8.0__tar.gz

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

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

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

@@ -196,6 +196,7 @@ class APLRRegressor:
         predictor_learning_rates: List[float] = [],
         predictor_penalties_for_non_linearity: List[float] = [],
         predictor_penalties_for_interactions: List[float] = [],
+        predictor_min_observations_in_split: List[int] = [],
     ):
         self.__set_params_cpp()
         self.APLRRegressor.fit(
@@ -212,6 +213,7 @@ class APLRRegressor:
             predictor_learning_rates,
             predictor_penalties_for_non_linearity,
             predictor_penalties_for_interactions,
+            predictor_min_observations_in_split,
         )
 
     def predict(
@@ -447,6 +449,7 @@ class APLRClassifier:
         predictor_learning_rates: List[float] = [],
         predictor_penalties_for_non_linearity: List[float] = [],
         predictor_penalties_for_interactions: List[float] = [],
+        predictor_min_observations_in_split: List[int] = [],
     ):
         self.__set_params_cpp()
         self.APLRClassifier.fit(
@@ -461,6 +464,7 @@ class APLRClassifier:
             predictor_learning_rates,
             predictor_penalties_for_non_linearity,
             predictor_penalties_for_interactions,
+            predictor_min_observations_in_split,
         )
         # For sklearn
         self.classes_ = np.arange(len(self.APLRClassifier.get_categories()))

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

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

{aplr-10.7.3 → aplr-10.8.0}/aplr.egg-info/SOURCES.txt

@@ -1,6 +1,7 @@
 LICENSE
 MANIFEST.in
 README.md
+pyproject.toml
 setup.py
 aplr/__init__.py
 aplr/aplr.py
@@ -1801,52 +1802,4 @@ dependencies/eigen-3.4.0/unsupported/test/polynomialutils.cpp
 dependencies/eigen-3.4.0/unsupported/test/sparse_extra.cpp
 dependencies/eigen-3.4.0/unsupported/test/special_functions.cpp
 dependencies/eigen-3.4.0/unsupported/test/special_packetmath.cpp
-dependencies/eigen-3.4.0/unsupported/test/splines.cpp
-dependencies/pybind11/LICENSE.txt
-dependencies/pybind11/__init__.py
-dependencies/pybind11/__main__.py
-dependencies/pybind11/_version.py
-dependencies/pybind11/commands.py
-dependencies/pybind11/py.typed
-dependencies/pybind11/setup_helpers.py
-dependencies/pybind11/include/pybind11/attr.h
-dependencies/pybind11/include/pybind11/buffer_info.h
-dependencies/pybind11/include/pybind11/cast.h
-dependencies/pybind11/include/pybind11/chrono.h
-dependencies/pybind11/include/pybind11/common.h
-dependencies/pybind11/include/pybind11/complex.h
-dependencies/pybind11/include/pybind11/eigen.h
-dependencies/pybind11/include/pybind11/embed.h
-dependencies/pybind11/include/pybind11/eval.h
-dependencies/pybind11/include/pybind11/functional.h
-dependencies/pybind11/include/pybind11/gil.h
-dependencies/pybind11/include/pybind11/gil_safe_call_once.h
-dependencies/pybind11/include/pybind11/iostream.h
-dependencies/pybind11/include/pybind11/numpy.h
-dependencies/pybind11/include/pybind11/operators.h
-dependencies/pybind11/include/pybind11/options.h
-dependencies/pybind11/include/pybind11/pybind11.h
-dependencies/pybind11/include/pybind11/pytypes.h
-dependencies/pybind11/include/pybind11/stl.h
-dependencies/pybind11/include/pybind11/stl_bind.h
-dependencies/pybind11/include/pybind11/type_caster_pyobject_ptr.h
-dependencies/pybind11/include/pybind11/typing.h
-dependencies/pybind11/include/pybind11/detail/class.h
-dependencies/pybind11/include/pybind11/detail/common.h
-dependencies/pybind11/include/pybind11/detail/descr.h
-dependencies/pybind11/include/pybind11/detail/init.h
-dependencies/pybind11/include/pybind11/detail/internals.h
-dependencies/pybind11/include/pybind11/detail/type_caster_base.h
-dependencies/pybind11/include/pybind11/detail/typeid.h
-dependencies/pybind11/include/pybind11/eigen/common.h
-dependencies/pybind11/include/pybind11/eigen/matrix.h
-dependencies/pybind11/include/pybind11/eigen/tensor.h
-dependencies/pybind11/include/pybind11/stl/filesystem.h
-dependencies/pybind11/share/cmake/pybind11/FindPythonLibsNew.cmake
-dependencies/pybind11/share/cmake/pybind11/pybind11Common.cmake
-dependencies/pybind11/share/cmake/pybind11/pybind11Config.cmake
-dependencies/pybind11/share/cmake/pybind11/pybind11ConfigVersion.cmake
-dependencies/pybind11/share/cmake/pybind11/pybind11NewTools.cmake
-dependencies/pybind11/share/cmake/pybind11/pybind11Targets.cmake
-dependencies/pybind11/share/cmake/pybind11/pybind11Tools.cmake
-dependencies/pybind11/share/pkgconfig/pybind11.pc
+dependencies/eigen-3.4.0/unsupported/test/splines.cpp

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

@@ -66,7 +66,8 @@ public:
              const std::vector<size_t> &prioritized_predictors_indexes = {}, const std::vector<int> &monotonic_constraints = {},
              const std::vector<std::vector<size_t>> &interaction_constraints = {}, const std::vector<double> &predictor_learning_rates = {},
              const std::vector<double> &predictor_penalties_for_non_linearity = {},
-             const std::vector<double> &predictor_penalties_for_interactions = {});
+             const std::vector<double> &predictor_penalties_for_interactions = {},
+             const std::vector<size_t> &predictor_min_observations_in_split = {});
     MatrixXd predict_class_probabilities(const MatrixXd &X, bool cap_predictions_to_minmax_in_training = false);
     std::vector<std::string> predict(const MatrixXd &X, bool cap_predictions_to_minmax_in_training = false);
     MatrixXd calculate_local_feature_contribution(const MatrixXd &X);
@@ -123,7 +124,8 @@ void APLRClassifier::fit(const MatrixXd &X, const std::vector<std::string> &y, c
                          const MatrixXi &cv_observations, const std::vector<size_t> &prioritized_predictors_indexes,
                          const std::vector<int> &monotonic_constraints, const std::vector<std::vector<size_t>> &interaction_constraints,
                          const std::vector<double> &predictor_learning_rates, const std::vector<double> &predictor_penalties_for_non_linearity,
-                         const std::vector<double> &predictor_penalties_for_interactions)
+                         const std::vector<double> &predictor_penalties_for_interactions,
+                         const std::vector<size_t> &predictor_min_observations_in_split)
 {
     initialize();
     find_categories(y);
@@ -145,7 +147,8 @@ void APLRClassifier::fit(const MatrixXd &X, const std::vector<std::string> &y, c
         logit_models[categories[0]].max_terms = max_terms;
         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);
+                                        predictor_penalties_for_non_linearity, predictor_penalties_for_interactions,
+                                        predictor_min_observations_in_split);
 
         logit_models[categories[1]] = logit_models[categories[0]];
         invert_second_model_in_two_class_case(logit_models[categories[1]]);
@@ -166,7 +169,8 @@ void APLRClassifier::fit(const MatrixXd &X, const std::vector<std::string> &y, c
             logit_models[category].max_terms = max_terms;
             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);
+                                       predictor_penalties_for_non_linearity, predictor_penalties_for_interactions,
+                                       predictor_min_observations_in_split);
         }
     }
 

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

@@ -59,6 +59,7 @@ private:
     std::vector<double> predictor_learning_rates;
     std::vector<double> predictor_penalties_for_non_linearity;
     std::vector<double> predictor_penalties_for_interactions;
+    std::vector<size_t> predictor_min_observations_in_split;
     VectorXi group_train;
     VectorXi group_validation;
     std::set<int> unique_groups_train;
@@ -103,6 +104,7 @@ private:
     void preprocess_predictor_learning_rates_and_penalties(const MatrixXd &X, const std::vector<double> &predictor_learning_rates,
                                                            const std::vector<double> &predictor_penalties_for_non_linearity,
                                                            const std::vector<double> &predictor_penalties_for_interactions);
+    void preprocess_predictor_min_observations_in_split(const MatrixXd &X, const std::vector<size_t> &predictor_min_observations_in_split);
     void calculate_min_and_max_predictor_values_in_training(const MatrixXd &X);
     std::vector<double> preprocess_predictor_learning_rate_or_penalty(const MatrixXd &X, double general_value,
                                                                       const std::vector<double> &predictor_specific_values);
@@ -270,7 +272,8 @@ public:
              const std::vector<int> &monotonic_constraints = {}, const VectorXi &group = VectorXi(0), const std::vector<std::vector<size_t>> &interaction_constraints = {},
              const MatrixXd &other_data = MatrixXd(0, 0), const std::vector<double> &predictor_learning_rates = {},
              const std::vector<double> &predictor_penalties_for_non_linearity = {},
-             const std::vector<double> &predictor_penalties_for_interactions = {});
+             const std::vector<double> &predictor_penalties_for_interactions = {},
+             const std::vector<size_t> &predictor_min_observations_in_split = {});
     VectorXd predict(const MatrixXd &X, bool cap_predictions_to_minmax_in_training = true);
     void set_term_names(const std::vector<std::string> &X_names);
     void set_term_affiliations(const std::vector<std::string> &X_names);
@@ -377,7 +380,8 @@ void APLRRegressor::fit(const MatrixXd &X, const VectorXd &y, const VectorXd &sa
                         const std::vector<int> &monotonic_constraints, const VectorXi &group, const std::vector<std::vector<size_t>> &interaction_constraints,
                         const MatrixXd &other_data, const std::vector<double> &predictor_learning_rates,
                         const std::vector<double> &predictor_penalties_for_non_linearity,
-                        const std::vector<double> &predictor_penalties_for_interactions)
+                        const std::vector<double> &predictor_penalties_for_interactions,
+                        const std::vector<size_t> &predictor_min_observations_in_split)
 {
     throw_error_if_loss_function_does_not_exist();
     throw_error_if_link_function_does_not_exist();
@@ -392,6 +396,7 @@ void APLRRegressor::fit(const MatrixXd &X, const VectorXd &y, const VectorXd &sa
     preprocess_penalties();
     preprocess_predictor_learning_rates_and_penalties(X, predictor_learning_rates, predictor_penalties_for_non_linearity,
                                                       predictor_penalties_for_interactions);
+    preprocess_predictor_min_observations_in_split(X, predictor_min_observations_in_split);
     calculate_min_and_max_predictor_values_in_training(X);
     cv_fold_models.resize(cv_observations_used.cols());
     for (Eigen::Index i = 0; i < cv_observations_used.cols(); ++i)
@@ -474,6 +479,24 @@ std::vector<double> APLRRegressor::preprocess_predictor_learning_rate_or_penalty
     return output;
 }
 
+void APLRRegressor::preprocess_predictor_min_observations_in_split(
+    const MatrixXd &X,
+    const std::vector<size_t> &predictor_min_observations_in_split)
+{
+    if (predictor_min_observations_in_split.empty())
+    {
+        this->predictor_min_observations_in_split = std::vector<size_t>(X.cols(), min_observations_in_split);
+    }
+    else if (predictor_min_observations_in_split.size() != X.cols())
+    {
+        throw std::runtime_error("The size of predictor_min_observations_in_split does not match the number of columns in X.");
+    }
+    else
+    {
+        this->predictor_min_observations_in_split = predictor_min_observations_in_split;
+    }
+}
+
 void APLRRegressor::calculate_min_and_max_predictor_values_in_training(const MatrixXd &X)
 {
     min_predictor_values_in_training = VectorXd(X.cols());
@@ -1239,10 +1262,18 @@ void APLRRegressor::execute_boosting_step(size_t boosting_step, Eigen::Index fol
         update_coefficient_steps(boosting_step);
         if (!model_has_changed_in_this_boosting_step)
         {
-            abort_boosting = true;
-            if (verbosity >= 1)
+            if (linear_effects_only_in_this_boosting_step || non_linear_effects_allowed_in_this_boosting_step)
+            {
+                find_optimal_m_and_update_model_accordingly();
+                stopped_early = true;
+            }
+            else
             {
-                std::cout << "No further reduction in training loss was possible. Terminating the boosting procedure.\n";
+                abort_boosting = true;
+                if (verbosity >= 1)
+                {
+                    std::cout << "No further reduction in training loss was possible. Terminating the boosting procedure.\n";
+                }
             }
         }
         abort_boosting_when_no_validation_error_improvement_in_the_last_early_stopping_rounds(boosting_step);
@@ -1337,7 +1368,8 @@ void APLRRegressor::estimate_split_point_for_each_term(std::vector<Term> &terms,
                 {
                     terms[terms_indexes[i]].estimate_split_point(X_train, neg_gradient_current, sample_weight_train, bins,
                                                                  predictor_learning_rates[terms[terms_indexes[i]].base_term],
-                                                                 min_observations_in_split, linear_effects_only_in_this_boosting_step,
+                                                                 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]);
                 } });
@@ -1357,7 +1389,8 @@ void APLRRegressor::estimate_split_point_for_each_term(std::vector<Term> &terms,
         {
             terms[terms_indexes[i]].estimate_split_point(X_train, neg_gradient_current, sample_weight_train, bins,
                                                          predictor_learning_rates[terms[terms_indexes[i]].base_term],
-                                                         min_observations_in_split, linear_effects_only_in_this_boosting_step,
+                                                         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]);
         }
@@ -1793,7 +1826,7 @@ void APLRRegressor::update_a_term_coefficient_round_robin(size_t boosting_step)
     terms_eligible_current[term_to_update_in_this_boosting_step].estimate_split_point(X_train, neg_gradient_current, sample_weight_train,
                                                                                       bins,
                                                                                       predictor_learning_rates[terms_eligible_current[term_to_update_in_this_boosting_step].base_term],
-                                                                                      min_observations_in_split,
+                                                                                      predictor_min_observations_in_split[terms_eligible_current[term_to_update_in_this_boosting_step].base_term],
                                                                                       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],

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

@@ -51,6 +51,7 @@ PYBIND11_MODULE(aplr_cpp, m)
              py::arg("predictor_learning_rates") = std::vector<double>(),
              py::arg("predictor_penalties_for_non_linearity") = std::vector<double>(),
              py::arg("predictor_penalties_for_interactions") = std::vector<double>(),
+             py::arg("predictor_min_observations_in_split") = std::vector<size_t>(),
              py::call_guard<py::scoped_ostream_redirect, py::scoped_estream_redirect>())
         .def("predict", &APLRRegressor::predict, py::arg("X"), py::arg("bool cap_predictions_to_minmax_in_training") = true)
         .def("set_term_names", &APLRRegressor::set_term_names, py::arg("X_names"))
@@ -298,6 +299,7 @@ PYBIND11_MODULE(aplr_cpp, m)
              py::arg("predictor_learning_rates") = std::vector<double>(),
              py::arg("predictor_penalties_for_non_linearity") = std::vector<double>(),
              py::arg("predictor_penalties_for_interactions") = std::vector<double>(),
+             py::arg("predictor_min_observations_in_split") = std::vector<size_t>(),
              py::call_guard<py::scoped_ostream_redirect, py::scoped_estream_redirect>())
         .def("predict_class_probabilities", &APLRClassifier::predict_class_probabilities, py::arg("X"), py::arg("bool cap_predictions_to_minmax_in_training") = false)
         .def("predict", &APLRClassifier::predict, py::arg("X"), py::arg("bool cap_predictions_to_minmax_in_training") = false)

{aplr-10.7.3 → aplr-10.8.0}/cpp/tests.cpp

@@ -60,6 +60,54 @@ public:
                   << "Passed " << std::accumulate(tests.begin(), tests.end(), 0) << " out of " << tests.size() << " tests.";
     }
 
+    void test_aplrregressor_mse_predictor_min_observations_in_split()
+    {
+        // Model
+        APLRRegressor model{APLRRegressor()};
+        model.m = 100;
+        model.v = 1.0;
+        model.bins = 10;
+        model.n_jobs = 1;
+        model.loss_function = "mse";
+        model.verbosity = 3;
+        model.max_interaction_level = 100;
+        model.max_interactions = 30;
+        model.min_observations_in_split = 50;
+
+        // Data
+        MatrixXd X_train{load_csv_into_eigen_matrix<MatrixXd>("data/X_train.csv")};
+        MatrixXd X_test{load_csv_into_eigen_matrix<MatrixXd>("data/X_test.csv")};
+        VectorXd y_train{load_csv_into_eigen_matrix<MatrixXd>("data/y_train.csv")};
+        VectorXd y_test{load_csv_into_eigen_matrix<MatrixXd>("data/y_test.csv")};
+
+        VectorXd sample_weight{VectorXd::Constant(y_train.size(), 1.0)};
+
+        MatrixXi cv_observations = MatrixXi::Constant(y_train.rows(), 2, 1);
+        cv_observations.col(0)[273] = -1;
+        cv_observations.col(0)[272] = -1;
+        cv_observations.col(0)[271] = -1;
+        cv_observations.col(0)[270] = -1;
+        cv_observations.col(0)[269] = -1;
+        cv_observations.col(0)[268] = -1;
+        cv_observations.col(0)[267] = -1;
+        cv_observations.col(0)[266] = -1;
+        cv_observations.col(1) = -cv_observations.col(0);
+
+        // Fitting
+        model.fit(X_train, y_train, sample_weight, {}, MatrixXi(0, 0), {}, {}, VectorXi(0), {}, MatrixXd(0, 0), {}, {}, {},
+                  {5, 6, 7, 8, 9, 10, 11, 12, 13});
+        std::cout << "feature importance\n"
+                  << model.feature_importance << "\n\n";
+
+        VectorXd predictions{model.predict(X_test)};
+
+        // Saving results
+        save_as_csv_file("data/output.csv", predictions);
+
+        std::cout << predictions.mean() << "\n\n";
+        tests.push_back(is_approximately_equal(predictions.mean(), 23.788775508596238));
+    }
+
     void test_aplrregressor_cauchy_term_limit()
     {
         // Model
@@ -2226,6 +2274,69 @@ public:
         tests.push_back(is_approximately_equal(local_feature_contribution.mean(), 0.37047735615744898, 0.00001));
     }
 
+    void test_aplrclassifier_two_class_predictor_min_observations_in_split()
+    {
+        // Model
+        APLRClassifier model{APLRClassifier()};
+        model.m = 100;
+        model.v = 0.05;
+        model.bins = 300;
+        model.n_jobs = 0;
+        model.verbosity = 3;
+        model.max_interaction_level = 100;
+        model.max_interactions = 1000;
+        model.min_observations_in_split = 20;
+        model.ineligible_boosting_steps_added = 10;
+        model.max_eligible_terms = 5;
+        model.max_terms = 4;
+
+        // Data
+        MatrixXd X_train{load_csv_into_eigen_matrix<MatrixXd>("data/X_train.csv")};
+        MatrixXd X_test{load_csv_into_eigen_matrix<MatrixXd>("data/X_test.csv")};
+        VectorXd y_train{load_csv_into_eigen_matrix<MatrixXd>("data/y_train_logit.csv")};
+        VectorXd y_test{load_csv_into_eigen_matrix<MatrixXd>("data/y_test_logit.csv")};
+        std::vector<std::string> y_train_str(y_train.rows());
+        std::vector<std::string> y_test_str(y_test.rows());
+        VectorXd sample_weight{VectorXd::Constant(y_train.size(), 1.0)};
+
+        for (Eigen::Index i = 0; i < y_train.size(); ++i)
+        {
+            y_train_str[i] = std::to_string(y_train[i]);
+        }
+        for (Eigen::Index i = 0; i < y_test.size(); ++i)
+        {
+            y_test_str[i] = std::to_string(y_test[i]);
+        }
+
+        MatrixXi cv_observations = MatrixXi::Constant(y_train.rows(), 2, 1);
+        cv_observations.col(0)[273] = -1;
+        cv_observations.col(0)[272] = -1;
+        cv_observations.col(0)[271] = -1;
+        cv_observations.col(0)[270] = -1;
+        cv_observations.col(0)[269] = -1;
+        cv_observations.col(0)[268] = -1;
+        cv_observations.col(0)[267] = -1;
+        cv_observations.col(0)[266] = -1;
+        cv_observations.col(1) = -cv_observations.col(0);
+
+        // Fitting
+        model.fit(X_train, y_train_str, sample_weight, {}, MatrixXi(0, 0), {}, {}, {}, {}, {}, {}, {2, 3, 4, 5, 6, 7, 8, 9, 10});
+        MatrixXd predicted_class_probabilities{model.predict_class_probabilities(X_test, false)};
+        std::vector<std::string> predictions{model.predict(X_test, false)};
+        MatrixXd local_feature_contribution{model.calculate_local_feature_contribution(X_test)};
+        std::cout << "cv_error\n"
+                  << model.get_cv_error() << "\n\n";
+        tests.push_back(is_approximately_equal(model.get_cv_error(), 0.18970198357702517, 0.000001));
+
+        std::cout << "predicted_class_prob_mean\n"
+                  << predicted_class_probabilities.mean() << "\n\n";
+        tests.push_back(is_approximately_equal(predicted_class_probabilities.mean(), 0.5, 0.00001));
+
+        std::cout << "local_feature_importance_mean\n"
+                  << local_feature_contribution.mean() << "\n\n";
+        tests.push_back(is_approximately_equal(local_feature_contribution.mean(), 0.46597769437683995, 0.00001));
+    }
+
     void test_functions()
     {
         // floating point comparisons
@@ -2404,6 +2515,7 @@ public:
 int main()
 {
     Tests tests{Tests()};
+    tests.test_aplrregressor_mse_predictor_min_observations_in_split();
     tests.test_aplrregressor_cauchy_term_limit();
     tests.test_aplrregressor_cauchy_predictor_specific_penalties_and_learning_rates();
     tests.test_aplrregressor_cauchy_penalties();
@@ -2441,6 +2553,7 @@ int main()
     tests.test_aplrclassifier_two_class_penalties();
     tests.test_aplrclassifier_two_class_predictor_specific_penalties_and_learning_rates();
     tests.test_aplrclassifier_two_class_max_terms();
+    tests.test_aplrclassifier_two_class_predictor_min_observations_in_split();
     tests.test_functions();
     tests.test_term();
     tests.summarize_results();

aplr-10.8.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools", "wheel", "pybind11>=2.13.6"]
+build-backend = "setuptools.build_meta"

{aplr-10.7.3 → aplr-10.8.0}/setup.py

@@ -1,5 +1,6 @@
 import setuptools, sys
 from pathlib import Path
+import pybind11
 
 extra_compile_args = []
 extra_link_args = []
@@ -16,7 +17,7 @@ elif "win" not in sys.platform:
 sfc_module = setuptools.Extension(
     name="aplr_cpp",
     sources=["cpp/pythonbinding.cpp"],
-    include_dirs=["cpp", "dependencies/eigen-3.4.0", "dependencies/pybind11/include"],
+    include_dirs=["cpp", "dependencies/eigen-3.4.0", pybind11.get_include()],
     language="c++",
     extra_compile_args=extra_compile_args,
     extra_link_args=extra_link_args,
@@ -27,7 +28,7 @@ long_description = (this_directory / "README.md").read_text()
 
 setuptools.setup(
     name="aplr",
-    version="10.7.3",
+    version="10.8.0",
     description="Automatic Piecewise Linear Regression",
     ext_modules=[sfc_module],
     author="Mathias von Ottenbreit",

aplr-10.7.3/dependencies/pybind11/LICENSE.txt

@@ -1,29 +0,0 @@
-Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>, All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this
-   list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its contributors
-   may be used to endorse or promote products derived from this software
-   without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-Please also refer to the file .github/CONTRIBUTING.md, which clarifies licensing of
-external contributions to this project including patches, pull requests, etc.

aplr-10.7.3/dependencies/pybind11/__init__.py

@@ -1,17 +0,0 @@
-import sys
-
-if sys.version_info < (3, 6):  # noqa: UP036
-    msg = "pybind11 does not support Python < 3.6. 2.9 was the last release supporting Python 2.7 and 3.5."
-    raise ImportError(msg)
-
-
-from ._version import __version__, version_info
-from .commands import get_cmake_dir, get_include, get_pkgconfig_dir
-
-__all__ = (
-    "version_info",
-    "__version__",
-    "get_include",
-    "get_cmake_dir",
-    "get_pkgconfig_dir",
-)

aplr-10.7.3/dependencies/pybind11/__main__.py

@@ -1,62 +0,0 @@
-# pylint: disable=missing-function-docstring
-
-import argparse
-import sys
-import sysconfig
-
-from ._version import __version__
-from .commands import get_cmake_dir, get_include, get_pkgconfig_dir
-
-
-def print_includes() -> None:
-    dirs = [
-        sysconfig.get_path("include"),
-        sysconfig.get_path("platinclude"),
-        get_include(),
-    ]
-
-    # Make unique but preserve order
-    unique_dirs = []
-    for d in dirs:
-        if d and d not in unique_dirs:
-            unique_dirs.append(d)
-
-    print(" ".join("-I" + d for d in unique_dirs))
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--version",
-        action="version",
-        version=__version__,
-        help="Print the version and exit.",
-    )
-    parser.add_argument(
-        "--includes",
-        action="store_true",
-        help="Include flags for both pybind11 and Python headers.",
-    )
-    parser.add_argument(
-        "--cmakedir",
-        action="store_true",
-        help="Print the CMake module directory, ideal for setting -Dpybind11_ROOT in CMake.",
-    )
-    parser.add_argument(
-        "--pkgconfigdir",
-        action="store_true",
-        help="Print the pkgconfig directory, ideal for setting $PKG_CONFIG_PATH.",
-    )
-    args = parser.parse_args()
-    if not sys.argv[1:]:
-        parser.print_help()
-    if args.includes:
-        print_includes()
-    if args.cmakedir:
-        print(get_cmake_dir())
-    if args.pkgconfigdir:
-        print(get_pkgconfig_dir())
-
-
-if __name__ == "__main__":
-    main()

aplr-10.7.3/dependencies/pybind11/_version.py

@@ -1,12 +0,0 @@
-from typing import Union
-
-
-def _to_int(s: str) -> Union[int, str]:
-    try:
-        return int(s)
-    except ValueError:
-        return s
-
-
-__version__ = "2.12.0"
-version_info = tuple(_to_int(s) for s in __version__.split("."))

aplr-10.7.3/dependencies/pybind11/commands.py

@@ -1,37 +0,0 @@
-import os
-
-DIR = os.path.abspath(os.path.dirname(__file__))
-
-
-def get_include(user: bool = False) -> str:  # noqa: ARG001
-    """
-    Return the path to the pybind11 include directory. The historical "user"
-    argument is unused, and may be removed.
-    """
-    installed_path = os.path.join(DIR, "include")
-    source_path = os.path.join(os.path.dirname(DIR), "include")
-    return installed_path if os.path.exists(installed_path) else source_path
-
-
-def get_cmake_dir() -> str:
-    """
-    Return the path to the pybind11 CMake module directory.
-    """
-    cmake_installed_path = os.path.join(DIR, "share", "cmake", "pybind11")
-    if os.path.exists(cmake_installed_path):
-        return cmake_installed_path
-
-    msg = "pybind11 not installed, installation required to access the CMake files"
-    raise ImportError(msg)
-
-
-def get_pkgconfig_dir() -> str:
-    """
-    Return the path to the pybind11 pkgconfig directory.
-    """
-    pkgconfig_installed_path = os.path.join(DIR, "share", "pkgconfig")
-    if os.path.exists(pkgconfig_installed_path):
-        return pkgconfig_installed_path
-
-    msg = "pybind11 not installed, installation required to access the pkgconfig files"
-    raise ImportError(msg)