fixed bug that sometimes formed unnecessarily complex interactions

Author: mathias-von-ottenbreit

cpp/APLRRegressor.h

@@ -733,16 +733,28 @@ VectorXi APLRRegressor::find_indexes_for_terms_to_consider_as_interaction_partne
     size_t number_of_terms_to_consider_as_interaction_partners{find_out_how_many_terms_to_consider_as_interaction_partners()};
     VectorXd split_point_errors(terms.size());
     VectorXi indexes_for_terms_to_consider_as_interaction_partners(terms.size());
+    size_t count{0};
     for (size_t i = 0; i < terms.size(); ++i)
     {
-        split_point_errors[i]=terms[i].split_point_search_errors_sum;
-        indexes_for_terms_to_consider_as_interaction_partners[i]=i;
+        if(terms[i].can_be_used_as_a_given_term)
+        {
+            split_point_errors[count] = terms[i].split_point_search_errors_sum;
+            indexes_for_terms_to_consider_as_interaction_partners[count] = i;
+            ++count;
+        }
     }
-    bool selecting_the_terms_with_lowest_previous_errors_is_necessary{max_eligible_terms<terms.size()};
+    split_point_errors.conservativeResize(count);
+    indexes_for_terms_to_consider_as_interaction_partners.conservativeResize(count);
+    bool selecting_the_terms_with_lowest_previous_errors_is_necessary{number_of_terms_to_consider_as_interaction_partners < indexes_for_terms_to_consider_as_interaction_partners.size()};
     if(selecting_the_terms_with_lowest_previous_errors_is_necessary)
     {
-        indexes_for_terms_to_consider_as_interaction_partners=sort_indexes_ascending(split_point_errors);
-        indexes_for_terms_to_consider_as_interaction_partners.conservativeResize(number_of_terms_to_consider_as_interaction_partners);
+        VectorXi sorted_indexes{sort_indexes_ascending(split_point_errors)};
+        VectorXi temp_indexes(number_of_terms_to_consider_as_interaction_partners);
+        for (size_t i = 0; i < number_of_terms_to_consider_as_interaction_partners; ++i)
+        {
+            temp_indexes[i] = indexes_for_terms_to_consider_as_interaction_partners[sorted_indexes[i]];
+        }
+        indexes_for_terms_to_consider_as_interaction_partners=std::move(temp_indexes);
     }
     return indexes_for_terms_to_consider_as_interaction_partners;
 }
@@ -756,6 +768,7 @@ size_t APLRRegressor::find_out_how_many_terms_to_consider_as_interaction_partner
     }
     return terms_to_consider;
 }
+
 void APLRRegressor::find_sorted_indexes_for_errors_for_interactions_to_consider()
 {
     VectorXd errors_for_interactions_to_consider(interactions_to_consider.size());

cpp/main.cpp

@@ -46,10 +46,10 @@ int main()
     //Saving results
     save_data("output.csv",predictions);
     std::cout<<"min validation_error "<<model.validation_error_steps.minCoeff()<<"\n\n";
-    std::cout<<is_approximately_equal(model.validation_error_steps.minCoeff(),5.82111,0.00001)<<"\n";
+    std::cout<<is_approximately_equal(model.validation_error_steps.minCoeff(),6.32895,0.00001)<<"\n";
 
     std::cout<<"mean prediction "<<predictions.mean()<<"\n\n";
-    std::cout<<is_approximately_equal(predictions.mean(),23.5815,0.0001)<<"\n";
+    std::cout<<is_approximately_equal(predictions.mean(),23.587,0.0001)<<"\n";
 
     std::cout<<"best_m: "<<model.m<<"\n";
 

cpp/term.h

@@ -57,6 +57,7 @@ class Term
     void cleanup_after_fit();
     void cleanup_when_this_term_was_added_as_a_given_term();
     void make_term_ineligible();
+    void determine_if_can_be_used_as_a_given_term(const VectorXd &x);
 
 public:
     //fields
@@ -75,6 +76,7 @@ class Term
     size_t ineligible_boosting_steps;
     VectorXd values_discretized; //Discretized values based on split_point=nan
     VectorXd sample_weight_discretized; //Discretized sample_weight based on split_point=nan
+    bool can_be_used_as_a_given_term;
 
     //methods
     Term(size_t base_term=0,const std::vector<Term> &given_terms=std::vector<Term>(0),double split_point=NAN_DOUBLE,bool direction_right=false,double coefficient=0);
@@ -97,14 +99,15 @@ class Term
 //Regular constructor
 Term::Term(size_t base_term,const std::vector<Term> &given_terms,double split_point,bool direction_right,double coefficient):
 name{""},base_term{base_term},given_terms{given_terms},split_point{split_point},direction_right{direction_right},coefficient{coefficient},
-split_point_search_errors_sum{std::numeric_limits<double>::infinity()},ineligible_boosting_steps{0}
+split_point_search_errors_sum{std::numeric_limits<double>::infinity()},ineligible_boosting_steps{0},can_be_used_as_a_given_term{false}
 {
 }
 
 //Copy constructor
 Term::Term(const Term &other):
 name{other.name},base_term{other.base_term},given_terms{other.given_terms},split_point{other.split_point},direction_right{other.direction_right},
-coefficient{other.coefficient},coefficient_steps{other.coefficient_steps},split_point_search_errors_sum{other.split_point_search_errors_sum},ineligible_boosting_steps{0}
+coefficient{other.coefficient},coefficient_steps{other.coefficient_steps},split_point_search_errors_sum{other.split_point_search_errors_sum},
+ineligible_boosting_steps{0},can_be_used_as_a_given_term{other.can_be_used_as_a_given_term}
 {
 }
 
@@ -180,6 +183,7 @@ void Term::estimate_split_point(const MatrixXd &X,const VectorXd &negative_gradi
     estimate_split_point_on_discretized_data();
     estimate_coefficient_and_error_on_all_data();
     cleanup_after_estimate_split_point();
+    determine_if_can_be_used_as_a_given_term(X.col(base_term));
 }
 
 //Calculate indices that get zeroed out during calculate() because of given terms. Also calculates indices of those observations that do not.
@@ -642,6 +646,20 @@ void Term::cleanup_after_estimate_split_point()
     errors_initial.resize(0);
 }
 
+void Term::determine_if_can_be_used_as_a_given_term(const VectorXd &x)
+{
+    VectorXd values{calculate_without_interactions(x)};
+    can_be_used_as_a_given_term = false;
+    for (auto &value:values)
+    {
+        if(is_approximately_zero(value))
+        {
+            can_be_used_as_a_given_term=true;
+            break;
+        }
+    }
+}
+
 void Term::cleanup_after_fit()
 {
     bins_start_index.clear();

cpp/test ALRRegressor.cpp

@@ -52,7 +52,7 @@ int main()
     save_data("data/output.csv",predictions);
 
     std::cout<<predictions.mean()<<"\n\n";
-    tests.push_back(is_approximately_equal(predictions.mean(),23.6889,0.00001));
+    tests.push_back(is_approximately_equal(predictions.mean(),23.5049,0.00001));
 
     //std::cout<<model.validation_error_steps<<"\n\n";
 

setup.py

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