removed an unnecessary constructor parameter and updated the presentation regarding max_terms

Author: mathias-von-ottenbreit

cpp/APLRClassifier.h

@@ -12,7 +12,6 @@ using namespace Eigen;
 class APLRClassifier
 {
 private:
-    size_t reserved_terms_times_num_x;
     std::map<std::string, VectorXd> response_values; // Key is category and value is response vector
 
     void initialize();
@@ -55,7 +54,7 @@ class APLRClassifier
     std::vector<std::vector<size_t>> base_predictors_in_each_unique_term_affiliation;
 
     APLRClassifier(size_t m = 20000, 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 reserved_terms_times_num_x = 100, size_t bins = 300, size_t verbosity = 0, size_t max_interaction_level = 1,
+                   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,
@@ -81,13 +80,13 @@ class APLRClassifier
 };
 
 APLRClassifier::APLRClassifier(size_t m, double v, uint_fast32_t random_state, size_t n_jobs, size_t cv_folds,
-                               size_t reserved_terms_times_num_x, size_t bins, size_t verbosity, size_t max_interaction_level, size_t max_interactions,
+                               size_t bins, size_t verbosity, size_t max_interaction_level, size_t max_interactions,
                                size_t min_observations_in_split, size_t ineligible_boosting_steps_added, size_t max_eligible_terms,
                                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)
     : m{m}, v{v}, random_state{random_state}, n_jobs{n_jobs}, cv_folds{cv_folds},
-      reserved_terms_times_num_x{reserved_terms_times_num_x}, bins{bins}, verbosity{verbosity}, max_interaction_level{max_interaction_level},
+      bins{bins}, verbosity{verbosity}, max_interaction_level{max_interaction_level},
       max_interactions{max_interactions}, min_observations_in_split{min_observations_in_split},
       ineligible_boosting_steps_added{ineligible_boosting_steps_added}, max_eligible_terms{max_eligible_terms},
       boosting_steps_before_interactions_are_allowed{boosting_steps_before_interactions_are_allowed},
@@ -99,7 +98,7 @@ APLRClassifier::APLRClassifier(size_t m, double v, uint_fast32_t random_state, s
 
 APLRClassifier::APLRClassifier(const APLRClassifier &other)
     : m{other.m}, v{other.v}, random_state{other.random_state}, n_jobs{other.n_jobs}, cv_folds{other.cv_folds},
-      reserved_terms_times_num_x{other.reserved_terms_times_num_x}, bins{other.bins}, verbosity{other.verbosity},
+      bins{other.bins}, verbosity{other.verbosity},
       max_interaction_level{other.max_interaction_level}, max_interactions{other.max_interactions},
       min_observations_in_split{other.min_observations_in_split}, ineligible_boosting_steps_added{other.ineligible_boosting_steps_added},
       max_eligible_terms{other.max_eligible_terms}, logit_models{other.logit_models}, categories{other.categories},
@@ -134,7 +133,7 @@ void APLRClassifier::fit(const MatrixXd &X, const std::vector<std::string> &y, c
     bool two_class_case{categories.size() == 2};
     if (two_class_case)
     {
-        logit_models[categories[0]] = APLRRegressor(m, v, random_state, "binomial", "logit", n_jobs, cv_folds, reserved_terms_times_num_x,
+        logit_models[categories[0]] = APLRRegressor(m, v, random_state, "binomial", "logit", n_jobs, cv_folds,
                                                     bins, verbosity, max_interaction_level, max_interactions, min_observations_in_split, ineligible_boosting_steps_added,
                                                     max_eligible_terms, 1.5, "default", 0.5);
         logit_models[categories[0]].boosting_steps_before_interactions_are_allowed = boosting_steps_before_interactions_are_allowed;
@@ -155,7 +154,7 @@ void APLRClassifier::fit(const MatrixXd &X, const std::vector<std::string> &y, c
     {
         for (auto &category : categories)
         {
-            logit_models[category] = APLRRegressor(m, v, random_state, "binomial", "logit", n_jobs, cv_folds, reserved_terms_times_num_x,
+            logit_models[category] = APLRRegressor(m, v, random_state, "binomial", "logit", n_jobs, cv_folds,
                                                    bins, verbosity, max_interaction_level, max_interactions, min_observations_in_split, ineligible_boosting_steps_added,
                                                    max_eligible_terms, 1.5, "default", 0.5);
             logit_models[category].boosting_steps_before_interactions_are_allowed = boosting_steps_before_interactions_are_allowed;
@@ -212,7 +211,7 @@ void APLRClassifier::create_response_for_each_category(const std::vector<std::st
 
 void APLRClassifier::define_cv_observations(const std::vector<std::string> &y, const MatrixXi &cv_observations_)
 {
-    APLRRegressor aplr_regressor{APLRRegressor(m, v, random_state, "binomial", "logit", n_jobs, cv_folds, reserved_terms_times_num_x,
+    APLRRegressor aplr_regressor{APLRRegressor(m, v, random_state, "binomial", "logit", n_jobs, cv_folds,
                                                bins, verbosity, max_interaction_level, max_interactions, min_observations_in_split, ineligible_boosting_steps_added,
                                                max_eligible_terms, 1.5, "default", 0.5)};
     VectorXd y_dummy_vector{VectorXd(y.size())};

cpp/APLRRegressor.h

@@ -30,7 +30,6 @@ struct ModelForCVFold
 class APLRRegressor
 {
 private:
-    size_t reserved_terms_times_num_x;
     MatrixXd X_train;
     VectorXd y_train;
     VectorXd sample_weight_train;
@@ -250,7 +249,7 @@ class APLRRegressor
 
     APLRRegressor(size_t m = 20000, 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,
-                  size_t reserved_terms_times_num_x = 100, size_t bins = 300, size_t verbosity = 0, size_t max_interaction_level = 1, size_t max_interactions = 100000,
+                  size_t 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, double dispersion_parameter = 1.5,
                   std::string validation_tuning_metric = "default", double quantile = 0.5,
                   const std::function<double(VectorXd, VectorXd, VectorXd, VectorXi, MatrixXd)> &calculate_custom_validation_error_function = {},
@@ -302,7 +301,7 @@ class APLRRegressor
 };
 
 APLRRegressor::APLRRegressor(size_t m, double v, uint_fast32_t random_state, std::string loss_function, std::string link_function, size_t n_jobs,
-                             size_t cv_folds, size_t reserved_terms_times_num_x, size_t bins, size_t verbosity, size_t max_interaction_level,
+                             size_t cv_folds, size_t bins, size_t verbosity, size_t max_interaction_level,
                              size_t max_interactions, size_t min_observations_in_split, size_t ineligible_boosting_steps_added, size_t max_eligible_terms, double dispersion_parameter,
                              std::string validation_tuning_metric, double quantile,
                              const std::function<double(VectorXd, VectorXd, VectorXd, VectorXi, MatrixXd)> &calculate_custom_validation_error_function,
@@ -314,7 +313,7 @@ APLRRegressor::APLRRegressor(size_t m, double v, uint_fast32_t random_state, std
                              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)
-    : reserved_terms_times_num_x{reserved_terms_times_num_x}, intercept{NAN_DOUBLE}, m{m}, v{v},
+    : 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},
       max_interactions{max_interactions}, interactions_eligible{0}, validation_error_steps{MatrixXd(0, 0)},
@@ -335,7 +334,7 @@ APLRRegressor::APLRRegressor(size_t m, double v, uint_fast32_t random_state, std
 }
 
 APLRRegressor::APLRRegressor(const APLRRegressor &other)
-    : reserved_terms_times_num_x{other.reserved_terms_times_num_x}, intercept{other.intercept}, terms{other.terms}, m{other.m}, v{other.v},
+    : intercept{other.intercept}, terms{other.terms}, m{other.m}, v{other.v},
       loss_function{other.loss_function}, link_function{other.link_function}, cv_folds{other.cv_folds},
       n_jobs{other.n_jobs}, random_state{other.random_state}, bins{other.bins},
       verbosity{other.verbosity}, term_names{other.term_names}, term_affiliations{other.term_affiliations}, term_coefficients{other.term_coefficients},
@@ -914,9 +913,9 @@ void APLRRegressor::initialize(const std::vector<int> &monotonic_constraints)
     number_of_base_terms = static_cast<size_t>(X_train.cols());
 
     terms.clear();
-    terms.reserve(X_train.cols() * reserved_terms_times_num_x);
+    terms.reserve(m);
 
-    terms_eligible_current.reserve(X_train.cols() * reserved_terms_times_num_x);
+    terms_eligible_current.reserve(m);
     size_t X_train_cols{static_cast<size_t>(X_train.cols())};
     for (size_t i = 0; i < X_train_cols; ++i)
     {

cpp/pythonbinding.cpp

@@ -20,15 +20,15 @@ std::function<VectorXd(VectorXd)> empty_calculate_custom_differentiate_predictio
 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 &, int &, double &, std::string &,
+        .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<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 &>(),
              py::arg("m") = 20000, 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("reserved_terms_times_num_x") = 100, py::arg("bins") = 300, py::arg("verbosity") = 0,
+             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("dispersion_parameter") = 1.5,
@@ -201,7 +201,7 @@ PYBIND11_MODULE(aplr_cpp, m)
                 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>>>();
 
-                APLRRegressor a(m, v, random_state, loss_function, link_function, n_jobs, cv_folds, 100, bins, verbosity, max_interaction_level,
+                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,
                                 validation_tuning_metric, quantile);
                 a.intercept = intercept;
@@ -282,10 +282,10 @@ 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 &, int &, bool &, int &, int &,
+        .def(py::init<int &, double &, int &, int &, int &, int &, int &, int &, int &, int &, int &, int &, int &, bool &, int &, int &,
                       double &, double &, int &>(),
              py::arg("m") = 20000, py::arg("v") = 0.5, py::arg("random_state") = 0, py::arg("n_jobs") = 0, py::arg("cv_folds") = 5,
-             py::arg("reserved_terms_times_num_x") = 100, py::arg("bins") = 300, py::arg("verbosity") = 0,
+             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,
@@ -380,7 +380,7 @@ PYBIND11_MODULE(aplr_cpp, m)
                 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>>>();
 
-                APLRClassifier a(m, v, random_state, n_jobs, cv_folds, 100, bins, verbosity, max_interaction_level, max_interactions,
+                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);
                 a.logit_models = logit_models;
                 a.categories = categories;

documentation/APLR 10.6.0.pdf

@@ -28,7 +28,7 @@ def trial_filter(task):
         else:
             return []
 
-        exclude_set = set()
+        exclude_set = set(["kddcup", "poker"])
         if task.name in exclude_set:
             return []
     else: