bugfix

Author: mathias-von-ottenbreit

API_REFERENCE_FOR_REGRESSION.md

@@ -314,7 +314,7 @@ A numpy matrix with predictor values.
 
 ## Method: get_coefficient_shape_function(predictor_index:int)
 
-***For the predictor in X specified by predictor_index, get_coefficient_shape_function returns a dictionary with keys equal to predictor values and values equal to coefficient. For each predictor value, the coefficient is the sum of coefficients for relevant terms using only the predictor (interactions with other predictors are ignored). This function makes it easier to interpret APLR models as one can quickly see how the main effects work across relevant values of the predictor. If the predictor is only used as a linear effect in the model then the predictor value is set to 0 even though the coefficient is valid for all values of the predictor.***
+***For the predictor in X specified by predictor_index, get_coefficient_shape_function returns a dictionary with keys equal to predictor values and values equal to coefficient. For each predictor value, the coefficient denotes the change in the linear predictor given that the predictor value increases by one unit (interactions with other predictors are ignored). This function makes it easier to interpret APLR models as one can quickly see how the main effects work across relevant values of the predictor. Predictor values lower than the lowest predictor value in the dictionary have the same coefficient that the lowest predictor value in the dictionary has. Predictor values higher than the highest predictor value in the dictionary have the same coefficient that the highest predictor value in the dictionary has.***
 
 ### Parameters
 

cpp/APLRRegressor.h

@@ -2379,110 +2379,65 @@ std::map<double, double> APLRRegressor::get_coefficient_shape_function(size_t pr
         return coefficient_shape_function;
 
     std::vector<double> split_points;
-    split_points.reserve(relevant_term_indexes.size());
-    double linear_term_combined_effect{0.0};
+    split_points.reserve(relevant_term_indexes.size() * 4);
     for (auto &relevant_term_index : relevant_term_indexes)
     {
         bool split_point_exits{std::isfinite(terms[relevant_term_index].split_point)};
         if (split_point_exits)
         {
             split_points.push_back(terms[relevant_term_index].split_point);
         }
-        else
+        for (auto &given_term : terms[relevant_term_index].given_terms)
         {
-            linear_term_combined_effect += terms[relevant_term_index].coefficient;
+            bool split_point_exits{std::isfinite(given_term.split_point)};
+            if (split_point_exits)
+            {
+                split_points.push_back(given_term.split_point);
+            }
         }
     }
-    split_points = remove_duplicate_elements_from_vector(split_points);
-    split_points.shrink_to_fit();
-
     bool no_split_points{split_points.size() == 0};
     if (no_split_points)
     {
-        coefficient_shape_function[0.0] = linear_term_combined_effect;
-        return coefficient_shape_function;
+        split_points.push_back(0);
+        split_points.push_back(1);
     }
-    double increment_around_split_points;
+    split_points = remove_duplicate_elements_from_vector(split_points);
     bool one_split_point{split_points.size() == 1};
     if (one_split_point)
     {
-        increment_around_split_points = split_points[0] / DIVISOR_IN_GET_COEFFICIENT_SHAPE_FUNCTION;
+        split_points.push_back(split_points[0] - 1);
+        split_points = remove_duplicate_elements_from_vector(split_points);
     }
-    else
+
+    VectorXd split_point_increments{VectorXd(split_points.size() - 1)};
+    for (Eigen::Index i = 0; i < split_point_increments.size(); ++i)
     {
-        std::sort(split_points.begin(), split_points.end());
-        VectorXd split_point_increments{VectorXd(split_points.size() - 1)};
-        for (Eigen::Index i = 0; i < split_point_increments.size(); ++i)
-        {
-            split_point_increments[i] = split_points[i + 1] - split_points[i];
-        }
-        double minimum_split_point_increment{split_point_increments.minCoeff()};
-        increment_around_split_points = minimum_split_point_increment / DIVISOR_IN_GET_COEFFICIENT_SHAPE_FUNCTION;
+        split_point_increments[i] = split_points[i + 1] - split_points[i];
     }
+    double minimum_split_point_increment{split_point_increments.minCoeff()};
+    double increment_around_split_points{minimum_split_point_increment / DIVISOR_IN_GET_COEFFICIENT_SHAPE_FUNCTION};
 
-    for (size_t i = 0; i < relevant_term_indexes.size(); ++i)
+    size_t num_split_points{split_points.size()};
+    for (size_t i = 0; i < num_split_points; ++i)
     {
-        bool split_point_exits{std::isfinite(terms[relevant_term_indexes[i]].split_point)};
-        if (split_point_exits)
-        {
-            coefficient_shape_function[terms[relevant_term_indexes[i]].split_point - increment_around_split_points] = linear_term_combined_effect;
-            coefficient_shape_function[terms[relevant_term_indexes[i]].split_point] = linear_term_combined_effect;
-            coefficient_shape_function[terms[relevant_term_indexes[i]].split_point + increment_around_split_points] = linear_term_combined_effect;
-        }
+        split_points.push_back(split_points[i] - increment_around_split_points);
+        split_points.push_back(split_points[i] + increment_around_split_points);
     }
+    split_points.push_back(split_points[split_points.size() - 1] + increment_around_split_points);
+    split_points = remove_duplicate_elements_from_vector(split_points);
+    split_points.shrink_to_fit();
 
-    for (size_t i = 0; i < relevant_term_indexes.size(); ++i)
+    MatrixXd X{MatrixXd::Constant(split_points.size(), number_of_base_terms, 0)};
+    for (size_t i = 0; i < split_points.size(); ++i)
     {
-        bool split_point_exits{std::isfinite(terms[relevant_term_indexes[i]].split_point)};
-        if (split_point_exits)
-        {
-            if (terms[relevant_term_indexes[i]].direction_right)
-            {
-                for (auto &key : coefficient_shape_function)
-                {
-                    bool key_split_point_is_higher{std::isgreater(key.first, terms[relevant_term_indexes[i]].split_point)};
-                    bool key_split_point_is_not_too_high{true};
-                    for (auto &given_term : terms[relevant_term_indexes[i]].given_terms)
-                    {
-                        if (given_term.direction_right != terms[relevant_term_indexes[i]].direction_right)
-                        {
-                            if (std::isgreater(key.first, given_term.split_point))
-                            {
-                                key_split_point_is_not_too_high = false;
-                                break;
-                            }
-                        }
-                    }
-                    if (key_split_point_is_higher && key_split_point_is_not_too_high)
-                    {
-                        key.second += terms[relevant_term_indexes[i]].coefficient;
-                    }
-                }
-            }
-            else
-            {
-                for (auto &key : coefficient_shape_function)
-                {
-                    bool key_split_point_is_lower{std::isless(key.first, terms[relevant_term_indexes[i]].split_point)};
-                    bool key_split_point_is_not_too_low{true};
-                    for (auto &given_term : terms[relevant_term_indexes[i]].given_terms)
-                    {
-                        if (given_term.direction_right != terms[relevant_term_indexes[i]].direction_right)
-                        {
-                            if (std::isless(key.first, given_term.split_point))
-                            {
-                                key_split_point_is_not_too_low = false;
-                                break;
-                            }
-                        }
-                    }
-                    if (!key_split_point_is_lower)
-                        break;
-                    else if (key_split_point_is_not_too_low)
-                        key.second += terms[relevant_term_indexes[i]].coefficient;
-                }
-            }
-        }
+        X.col(predictor_index)[i] = split_points[i];
+    }
+
+    VectorXd contribution_to_linear_predictor{calculate_local_contribution_from_selected_terms(X, {predictor_index})};
+    for (size_t i = 0; i < split_points.size() - 1; ++i)
+    {
+        coefficient_shape_function[split_points[i]] = (contribution_to_linear_predictor[i + 1] - contribution_to_linear_predictor[i]) / (split_points[i + 1] - split_points[i]);
     }
 
     return coefficient_shape_function;
@@ -2494,21 +2449,8 @@ std::vector<size_t> APLRRegressor::compute_relevant_term_indexes(size_t predicto
     relevant_term_indexes.reserve(terms.size());
     for (size_t i = 0; i < terms.size(); ++i)
     {
-        bool predictor_index_is_base_term{terms[i].base_term == predictor_index};
-        if (predictor_index_is_base_term)
-        {
-            bool no_interactions_with_other_base_terms{true};
-            for (auto &given_term : terms[i].given_terms)
-            {
-                if (given_term.base_term != predictor_index)
-                {
-                    no_interactions_with_other_base_terms = false;
-                    break;
-                }
-            }
-            if (no_interactions_with_other_base_terms)
-                relevant_term_indexes.push_back(i);
-        }
+        if (terms[i].term_uses_just_these_predictors({predictor_index}))
+            relevant_term_indexes.push_back(i);
     }
     relevant_term_indexes.shrink_to_fit();
     return relevant_term_indexes;

documentation/APLR 9.10.0.pdf renamed to documentation/APLR 9.10.1.pdf

@@ -111,12 +111,16 @@
     }
 )
 
-# Local (observation specific) contribution to the linear predictor from selected interacting predictors. 
+# Local (observation specific) contribution to the linear predictor from selected interacting predictors.
 # In this example this concerns two-way interaction terms in the model where the second and the third predictors in X interact.
-# The local contribution will be zero for all observations if there are no such terms in the model. 
+# The local contribution will be zero for all observations if there are no such terms in the model.
 # The local contribution can help interpreting interactions (or main effects if only one predictor index is specified).
 # In this example, the local contribution can be plotted against the predictor values for a visual interpretation.
-contribution_from_selected_terms = best_model.calculate_local_contribution_from_selected_terms(X=data_train[predictors],predictor_indexes=[1,2])
+contribution_from_selected_terms = (
+    best_model.calculate_local_contribution_from_selected_terms(
+        X=data_train[predictors], predictor_indexes=[1, 2]
+    )
+)
 
 
 # PREDICTING AND TESTING ON THE TEST SET

examples/train_aplr_regression.py

@@ -25,7 +25,7 @@
 
 setuptools.setup(
     name="aplr",
-    version="9.10.0",
+    version="9.10.1",
     description="Automatic Piecewise Linear Regression",
     ext_modules=[sfc_module],
     author="Mathias von Ottenbreit",