Added method to get validation indexes

Author: mathias-von-ottenbreit

API_REFERENCE.md

@@ -184,4 +184,9 @@ The index of the term selected. So ***0*** is the first term, ***1*** is the sec
 
 ## Method: get_validation_group_mse()
 
-***Returns mean squared error on grouped data in the validation set.*** See ***group_size_for_validation_group_mse*** for more information.
+***Returns mean squared error on grouped data in the validation set.*** See ***group_size_for_validation_group_mse*** for more information.
+
+
+## Method: get_validation_indexes()
+
+***Returns a numpy vector containing the indexes of the training data observations used for validation and not training.***

aplr/aplr.py

@@ -93,6 +93,9 @@ def get_m(self)->int:
 
     def get_validation_group_mse(self)->float:
         return self.APLRRegressor.get_validation_group_mse()
+    
+    def get_validation_indexes(self)->npt.ArrayLike:
+        return self.APLRRegressor.get_validation_indexes()
 
     #For sklearn
     def get_params(self, deep=True):

cpp/APLRRegressor.h

@@ -136,6 +136,7 @@ class APLRRegressor
     double max_training_prediction_or_response;
     double validation_group_mse;
     size_t group_size_for_validation_group_mse;
+    std::vector<size_t> validation_indexes;
 
     //Methods
     APLRRegressor(size_t m=1000,double v=0.1,uint_fast32_t random_state=std::numeric_limits<uint_fast32_t>::lowest(),std::string family="gaussian",
@@ -161,6 +162,7 @@ class APLRRegressor
     VectorXd get_intercept_steps();
     size_t get_m();
     double get_validation_group_mse();
+    std::vector<size_t> get_validation_indexes();
 };
 
 //Regular constructor
@@ -174,7 +176,8 @@ APLRRegressor::APLRRegressor(size_t m,double v,uint_fast32_t random_state,std::s
         intercept_steps{VectorXd(0)},max_interactions{max_interactions},interactions_eligible{0},validation_error_steps{VectorXd(0)},
         min_observations_in_split{min_observations_in_split},ineligible_boosting_steps_added{ineligible_boosting_steps_added},
         max_eligible_terms{max_eligible_terms},number_of_base_terms{0},tweedie_power{tweedie_power},min_training_prediction_or_response{NAN_DOUBLE},
-        max_training_prediction_or_response{NAN_DOUBLE},validation_group_mse{NAN_DOUBLE},group_size_for_validation_group_mse{group_size_for_validation_group_mse}
+        max_training_prediction_or_response{NAN_DOUBLE},validation_group_mse{NAN_DOUBLE},group_size_for_validation_group_mse{group_size_for_validation_group_mse},
+        validation_indexes{std::vector<size_t>(0)}
 {
 }
 
@@ -190,7 +193,7 @@ APLRRegressor::APLRRegressor(const APLRRegressor &other):
     max_eligible_terms{other.max_eligible_terms},number_of_base_terms{other.number_of_base_terms},
     feature_importance{other.feature_importance},tweedie_power{other.tweedie_power},min_training_prediction_or_response{other.min_training_prediction_or_response},
     max_training_prediction_or_response{other.max_training_prediction_or_response},validation_group_mse{other.validation_group_mse},
-    group_size_for_validation_group_mse{other.group_size_for_validation_group_mse}
+    group_size_for_validation_group_mse{other.group_size_for_validation_group_mse},validation_indexes{other.validation_indexes}
 {
 }
 
@@ -363,20 +366,20 @@ void APLRRegressor::define_training_and_validation_sets(const MatrixXd &X,const
 {
     size_t y_size{static_cast<size_t>(y.size())};
     std::vector<size_t> train_indexes;
-    std::vector<size_t> validation_indexes;
     bool use_validation_set_indexes{validation_set_indexes.size()>0};
     if(use_validation_set_indexes)
     {
         std::vector<size_t> all_indexes(y_size);
         std::iota(std::begin(all_indexes),std::end(all_indexes),0);
         validation_indexes=validation_set_indexes;
         train_indexes.reserve(y_size-validation_indexes.size()); 
-        std::remove_copy_if(all_indexes.begin(),all_indexes.end(),std::back_inserter(train_indexes),[&validation_indexes](const size_t &arg)
+        std::remove_copy_if(all_indexes.begin(),all_indexes.end(),std::back_inserter(train_indexes),[this](const size_t &arg)
             { return (std::find(validation_indexes.begin(),validation_indexes.end(),arg) != validation_indexes.end());});
     }
     else
     {
         train_indexes.reserve(y_size);
+        validation_indexes = std::vector<size_t>(0);
         validation_indexes.reserve(y_size);
         std::mt19937 mersenne{random_state};
         std::uniform_real_distribution<double> distribution(0.0,1.0);
@@ -1354,4 +1357,9 @@ size_t APLRRegressor::get_m()
 double APLRRegressor::get_validation_group_mse()
 {
     return validation_group_mse;
+}
+
+std::vector<size_t> APLRRegressor::get_validation_indexes()
+{
+    return validation_indexes;
 }

cpp/pythonbinding.cpp

@@ -36,6 +36,7 @@ PYBIND11_MODULE(aplr_cpp, m) {
         .def("get_intercept_steps", &APLRRegressor::get_intercept_steps)
         .def("get_m", &APLRRegressor::get_m)
         .def("get_validation_group_mse", &APLRRegressor::get_validation_group_mse)
+        .def("get_validation_indexes", &APLRRegressor::get_validation_indexes)
         .def_readwrite("intercept", &APLRRegressor::intercept)
         .def_readwrite("intercept_steps", &APLRRegressor::intercept_steps)
         .def_readwrite("m", &APLRRegressor::m)
@@ -64,17 +65,18 @@ PYBIND11_MODULE(aplr_cpp, m) {
         .def_readwrite("max_training_prediction_or_response",&APLRRegressor::max_training_prediction_or_response)
         .def_readwrite("validation_group_mse",&APLRRegressor::validation_group_mse)
         .def_readwrite("group_size_for_validation_group_mse",&APLRRegressor::group_size_for_validation_group_mse)
+        .def_readwrite("validation_indexes",&APLRRegressor::validation_indexes)
         .def(py::pickle(
             [](const APLRRegressor &a) { // __getstate__
                 /* Return a tuple that fully encodes the state of the object */
                 return py::make_tuple(a.m,a.v,a.random_state,a.family,a.n_jobs,a.validation_ratio,a.intercept,a.bins,a.verbosity,
                     a.max_interaction_level,a.max_interactions,a.validation_error_steps,a.term_names,a.term_coefficients,a.terms,a.intercept_steps,
                     a.interactions_eligible,a.min_observations_in_split,a.ineligible_boosting_steps_added,a.max_eligible_terms,
                     a.number_of_base_terms,a.feature_importance,a.link_function,a.tweedie_power,a.min_training_prediction_or_response,a.max_training_prediction_or_response,
-                    a.validation_group_mse,a.group_size_for_validation_group_mse);
+                    a.validation_group_mse,a.group_size_for_validation_group_mse,a.validation_indexes);
             },
             [](py::tuple t) { // __setstate__
-                if (t.size() != 28)
+                if (t.size() != 29)
                     throw std::runtime_error("Invalid state!");
 
                 /* Create a new C++ instance */
@@ -97,6 +99,7 @@ PYBIND11_MODULE(aplr_cpp, m) {
                 a.max_training_prediction_or_response=t[25].cast<double>();
                 a.validation_group_mse=t[26].cast<double>();
                 a.group_size_for_validation_group_mse=t[27].cast<size_t>();
+                a.validation_indexes=t[28].cast<std::vector<size_t>>();
 
                 return a;
             }

cpp/test ALRRegressor.cpp

@@ -42,7 +42,9 @@ int main()
     //model.fit(X_train,y_train);
     //model.fit(X_train,y_train,sample_weight);
     //model.fit(X_train,y_train,sample_weight,{},{0,1,2,3,4,5,10,static_cast<size_t>(y_train.size()-1)});
-    model.fit(X_train,y_train,sample_weight,{},{0,1,2,3,4,5,10,static_cast<size_t>(y_train.size()-1)},{1,8});
+    std::vector<size_t> validation_indexes{0,1,2,3,4,5,10,static_cast<size_t>(y_train.size()-1)};
+    std::vector<size_t> prioritized_predictor_indexes{1,8};
+    model.fit(X_train,y_train,sample_weight,{},validation_indexes,prioritized_predictor_indexes);
     std::cout<<"feature importance\n"<<model.feature_importance<<"\n\n";
 
     VectorXd predictions{model.predict(X_test)};
@@ -54,7 +56,9 @@ int main()
     std::cout<<predictions.mean()<<"\n\n";
     tests.push_back(is_approximately_equal(predictions.mean(),23.5049,0.00001));
 
-    //std::cout<<model.validation_error_steps<<"\n\n";
+    std::vector<size_t> validation_indexes_from_model{model.get_validation_indexes()};
+    bool validation_indexes_from_model_are_correct{validation_indexes_from_model == validation_indexes};
+    tests.push_back(validation_indexes_from_model_are_correct);
 
     //Test summary
     std::cout<<"\n\nTest summary\n"<<"Passed "<<std::accumulate(tests.begin(),tests.end(),0)<<" out of "<<tests.size()<<" tests.";

setup.py

@@ -15,7 +15,7 @@
 
 setuptools.setup(
     name='aplr',
-    version='1.11.0',
+    version='1.12.0',
     description='Automatic Piecewise Linear Regression',
     ext_modules=[sfc_module],
     author="Mathias von Ottenbreit",