aplr 10.11.1__tar.gz → 10.12.1__tar.gz

{aplr-10.11.1/aplr.egg-info → aplr-10.12.1}/PKG-INFO

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

{aplr-10.11.1 → aplr-10.12.1/aplr.egg-info}/PKG-INFO

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

{aplr-10.11.1 → aplr-10.12.1}/cpp/APLRRegressor.h

@@ -143,6 +143,7 @@ private:
     void update_gradient_and_errors();
     void add_new_term(size_t boosting_step);
     void update_coefficient_steps(size_t boosting_step);
+    double calculate_quantile_mean_response(const VectorXd &predictions, bool top_quantile);
     void calculate_and_validate_validation_error(size_t boosting_step);
     double calculate_validation_error(const VectorXd &predictions);
     double calculate_group_mse_by_prediction_validation_error(const VectorXd &predictions);
@@ -190,6 +191,7 @@ private:
     std::string compute_raw_base_term_name(const Term &term, const std::string &X_name);
     void throw_error_if_m_is_invalid();
     bool model_has_not_been_trained();
+    void throw_error_if_quantile_is_invalid();
     std::vector<size_t> compute_relevant_term_indexes(const std::string &unique_term_affiliation);
     std::vector<double> compute_split_points(size_t predictor_index, const std::vector<size_t> &relevant_term_indexes);
     VectorXd compute_contribution_to_linear_predictor_from_specific_terms(const MatrixXd &X, const std::vector<size_t> &term_indexes,
@@ -390,6 +392,7 @@ void APLRRegressor::fit(const MatrixXd &X, const VectorXd &y, const VectorXd &sa
     throw_error_if_loss_function_does_not_exist();
     throw_error_if_link_function_does_not_exist();
     throw_error_if_dispersion_parameter_is_invalid();
+    throw_error_if_quantile_is_invalid();
     throw_error_if_m_is_invalid();
     validate_input_to_fit(X, y, sample_weight, X_names, cv_observations, prioritized_predictors_indexes, monotonic_constraints, group,
                           interaction_constraints, other_data, predictor_learning_rates, predictor_penalties_for_non_linearity,
@@ -606,6 +609,17 @@ void APLRRegressor::throw_error_if_m_is_invalid()
         throw std::runtime_error("The maximum number of boosting steps, m, must be at least 1.");
 }
 
+void APLRRegressor::throw_error_if_quantile_is_invalid()
+{
+    if (loss_function == "quantile" || validation_tuning_metric == "neg_top_quantile_mean_response" || validation_tuning_metric == "bottom_quantile_mean_response")
+    {
+        if (quantile < 0.0 || quantile > 1.0)
+        {
+            throw std::runtime_error("Quantile must be between 0.0 and 1.0.");
+        }
+    }
+}
+
 void APLRRegressor::validate_input_to_fit(const MatrixXd &X, const VectorXd &y, const VectorXd &sample_weight,
                                           const std::vector<std::string> &X_names, const MatrixXi &cv_observations,
                                           const std::vector<size_t> &prioritized_predictors_indexes, const std::vector<int> &monotonic_constraints, const VectorXi &group,
@@ -931,7 +945,6 @@ void APLRRegressor::scale_response_if_using_log_link_function()
         {
             scaling_factor_for_log_link_function = 1 / inverse_scaling_factor;
             y_train *= scaling_factor_for_log_link_function;
-            y_validation *= scaling_factor_for_log_link_function;
         }
         else
             scaling_factor_for_log_link_function = 1.0;
@@ -1720,6 +1733,31 @@ void APLRRegressor::update_coefficient_steps(size_t boosting_step)
     }
 }
 
+double APLRRegressor::calculate_quantile_mean_response(const VectorXd &predictions, bool top_quantile)
+{
+    double quantile_value{calculate_quantile(predictions, quantile, sample_weight_validation)};
+
+    VectorXd predictions_in_quantile;
+    if (top_quantile)
+    {
+        predictions_in_quantile = (predictions.array() >= quantile_value).cast<double>();
+    }
+    else
+    {
+        predictions_in_quantile = (predictions.array() <= quantile_value).cast<double>();
+    }
+
+    VectorXd y_in_quantile{y_validation.array() * predictions_in_quantile.array()};
+    VectorXd weights_in_quantile{sample_weight_validation.array() * predictions_in_quantile.array()};
+
+    double mean_response{calculate_weighted_average(y_in_quantile, weights_in_quantile)};
+
+    if (std::isnan(mean_response))
+        return std::numeric_limits<double>::infinity();
+
+    return mean_response;
+}
+
 void APLRRegressor::calculate_and_validate_validation_error(size_t boosting_step)
 {
     validation_error_steps.col(0)[boosting_step] = calculate_validation_error(predictions_current_validation);
@@ -1734,13 +1772,19 @@ void APLRRegressor::calculate_and_validate_validation_error(size_t boosting_step
 
 double APLRRegressor::calculate_validation_error(const VectorXd &predictions)
 {
+    VectorXd predictions_used{predictions};
+    if (link_function == "log")
+    {
+        predictions_used /= scaling_factor_for_log_link_function;
+    }
+
     if (validation_tuning_metric == "default")
     {
         if (loss_function == "custom_function")
         {
             try
             {
-                return calculate_custom_loss_function(y_validation, predictions, sample_weight_validation, group_validation, other_data_validation);
+                return calculate_custom_loss_function(y_validation, predictions_used, sample_weight_validation, group_validation, other_data_validation);
             }
             catch (const std::exception &e)
             {
@@ -1750,33 +1794,33 @@ double APLRRegressor::calculate_validation_error(const VectorXd &predictions)
         }
         else if (loss_function == "group_mse_cycle")
         {
-            return calculate_group_mse_by_prediction_validation_error(predictions);
+            return calculate_group_mse_by_prediction_validation_error(predictions_used);
         }
         else
-            return calculate_mean_error(calculate_errors(y_validation, predictions, sample_weight_validation, loss_function, dispersion_parameter, group_validation, unique_groups_validation, quantile), sample_weight_validation);
+            return calculate_mean_error(calculate_errors(y_validation, predictions_used, sample_weight_validation, loss_function, dispersion_parameter, group_validation, unique_groups_validation, quantile), sample_weight_validation);
     }
     else if (validation_tuning_metric == "mse")
-        return calculate_mean_error(calculate_errors(y_validation, predictions, sample_weight_validation, MSE_LOSS_FUNCTION), sample_weight_validation);
+        return calculate_mean_error(calculate_errors(y_validation, predictions_used, sample_weight_validation, MSE_LOSS_FUNCTION), sample_weight_validation);
     else if (validation_tuning_metric == "mae")
-        return calculate_mean_error(calculate_errors(y_validation, predictions, sample_weight_validation, "mae"), sample_weight_validation);
+        return calculate_mean_error(calculate_errors(y_validation, predictions_used, sample_weight_validation, "mae"), sample_weight_validation);
     else if (validation_tuning_metric == "negative_gini")
-        return -calculate_gini(y_validation, predictions, sample_weight_validation) / calculate_gini(y_validation, y_validation, sample_weight_validation);
+        return -calculate_gini(y_validation, predictions_used, sample_weight_validation) / calculate_gini(y_validation, y_validation, sample_weight_validation);
     else if (validation_tuning_metric == "group_mse")
     {
         bool group_is_not_provided{group_validation.rows() == 0};
         if (group_is_not_provided)
             throw std::runtime_error("When validation_tuning_metric is group_mse then the group argument in fit() must be provided.");
-        return calculate_mean_error(calculate_errors(y_validation, predictions, sample_weight_validation, "group_mse", dispersion_parameter, group_validation, unique_groups_validation, quantile), sample_weight_validation);
+        return calculate_mean_error(calculate_errors(y_validation, predictions_used, sample_weight_validation, "group_mse", dispersion_parameter, group_validation, unique_groups_validation, quantile), sample_weight_validation);
     }
     else if (validation_tuning_metric == "group_mse_by_prediction")
     {
-        return calculate_group_mse_by_prediction_validation_error(predictions);
+        return calculate_group_mse_by_prediction_validation_error(predictions_used);
     }
     else if (validation_tuning_metric == "custom_function")
     {
         try
         {
-            return calculate_custom_validation_error_function(y_validation, predictions, sample_weight_validation, group_validation, other_data_validation);
+            return calculate_custom_validation_error_function(y_validation, predictions_used, sample_weight_validation, group_validation, other_data_validation);
         }
         catch (const std::exception &e)
         {
@@ -1784,6 +1828,19 @@ double APLRRegressor::calculate_validation_error(const VectorXd &predictions)
             throw std::runtime_error(error_msg);
         }
     }
+    else if (validation_tuning_metric == "neg_top_quantile_mean_response")
+    {
+        double mean_response{calculate_quantile_mean_response(predictions_used, true)};
+        if (std::isinf(mean_response))
+        {
+            return mean_response;
+        }
+        return -mean_response;
+    }
+    else if (validation_tuning_metric == "bottom_quantile_mean_response")
+    {
+        return calculate_quantile_mean_response(predictions_used, false);
+    }
     else
         throw std::runtime_error(validation_tuning_metric + " is an invalid validation_tuning_metric.");
 }
@@ -1973,7 +2030,6 @@ void APLRRegressor::revert_scaling_if_using_log_link_function()
     if (link_function == "log")
     {
         y_train /= scaling_factor_for_log_link_function;
-        y_validation /= scaling_factor_for_log_link_function;
         intercept += std::log(1 / scaling_factor_for_log_link_function);
         for (Eigen::Index i = 0; i < intercept_steps.size(); ++i)
         {

{aplr-10.11.1 → aplr-10.12.1}/cpp/functions.h

@@ -280,6 +280,27 @@ double calculate_mean_error(const VectorXd &errors, const VectorXd &sample_weigh
     return error;
 }
 
+double calculate_weighted_average(const VectorXd &values, const VectorXd &weights)
+{
+    if (values.size() != weights.size())
+    {
+        throw std::runtime_error("Values and weights must have the same size for weighted average calculation.");
+    }
+    if (values.size() == 0)
+    {
+        return NAN_DOUBLE;
+    }
+
+    double total_weight = weights.sum();
+    if (is_approximately_zero(total_weight))
+    {
+        return NAN_DOUBLE;
+    }
+
+    double weighted_sum = (values.array() * weights.array()).sum();
+    return weighted_sum / total_weight;
+}
+
 double calculate_sum_error(const VectorXd &errors)
 {
     double error{errors.sum()};
@@ -566,4 +587,96 @@ MatrixXd generate_combinations_and_one_additional_column(const std::vector<std::
         }
     }
     return result;
+}
+
+double calculate_quantile(const VectorXd &vector, double quantile, const VectorXd &sample_weight = VectorXd(0))
+{
+    if (quantile < 0.0 || quantile > 1.0)
+    {
+        throw std::runtime_error("Quantile must be between 0.0 and 1.0.");
+    }
+
+    const Eigen::Index n = vector.size();
+    if (n == 0)
+    {
+        return NAN_DOUBLE;
+    }
+
+    VectorXd sample_weight_used;
+    if (sample_weight.size() > 0)
+    {
+        if (sample_weight.size() != n)
+        {
+            throw std::runtime_error("Vector and sample_weight must have the same size.");
+        }
+        sample_weight_used = sample_weight;
+    }
+    else
+    {
+        sample_weight_used = VectorXd::Constant(n, 1.0);
+    }
+
+    if ((sample_weight_used.array() < 0.0).any())
+    {
+        throw std::runtime_error("Sample weights must be non-negative.");
+    }
+
+    double total_weight = sample_weight_used.sum();
+    if (is_approximately_zero(total_weight))
+    {
+        return NAN_DOUBLE;
+    }
+
+    if (n == 1)
+    {
+        return vector[0];
+    }
+
+    std::vector<std::pair<double, double>> weighted_values(n);
+    for (Eigen::Index i = 0; i < n; ++i)
+    {
+        weighted_values[i] = {vector[i], sample_weight_used[i]};
+    }
+
+    std::sort(weighted_values.begin(), weighted_values.end(),
+              [](const auto &a, const auto &b)
+              {
+                  return a.first < b.first;
+              });
+
+    VectorXd quantile_positions(n);
+    double cum_weight = 0.0;
+    for (Eigen::Index i = 0; i < n; ++i)
+    {
+        double current_weight = weighted_values[i].second;
+        cum_weight += current_weight;
+        quantile_positions[i] = (cum_weight - 0.5 * current_weight) / total_weight;
+    }
+
+    auto it = std::upper_bound(quantile_positions.data(), quantile_positions.data() + n, quantile);
+    Eigen::Index upper_index = std::distance(quantile_positions.data(), it);
+
+    if (upper_index == 0)
+    {
+        return weighted_values[0].first;
+    }
+    if (upper_index >= n)
+    {
+        return weighted_values[n - 1].first;
+    }
+
+    Eigen::Index lower_index = upper_index - 1;
+
+    double q_lower = quantile_positions[lower_index];
+    double q_upper = quantile_positions[upper_index];
+    double val_lower = weighted_values[lower_index].first;
+    double val_upper = weighted_values[upper_index].first;
+
+    if (is_approximately_equal(q_lower, q_upper))
+    {
+        return val_lower;
+    }
+
+    double fraction = (quantile - q_lower) / (q_upper - q_lower);
+    return val_lower + fraction * (val_upper - val_lower);
 }

{aplr-10.11.1 → aplr-10.12.1}/cpp/tests.cpp

@@ -1637,6 +1637,88 @@ public:
         tests.push_back(is_approximately_equal(predictions.mean(), 23.646255799722155));
     }
 
+    void test_aplrregressor_neg_top_quantile_mean_response()
+    {
+        // Model
+        APLRRegressor model{APLRRegressor()};
+        model.m = 100;
+        model.v = 1.0;
+        model.bins = 10;
+        model.n_jobs = 1;
+        model.loss_function = "mse";
+        model.validation_tuning_metric = "neg_top_quantile_mean_response";
+        model.verbosity = 3;
+        model.max_interaction_level = 100;
+        model.max_interactions = 30;
+        model.min_observations_in_split = 50;
+        model.ineligible_boosting_steps_added = 10;
+        model.max_eligible_terms = 5;
+        model.quantile = 0.8;
+        model.ridge_penalty = 0.0;
+
+        // 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(), 0.5)};
+
+        // Fitting
+        model.fit(X_train, y_train, sample_weight);
+        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.609343969688034));
+    }
+
+    void test_aplrregressor_bottom_quantile_mean_response()
+    {
+        // Model
+        APLRRegressor model{APLRRegressor()};
+        model.m = 100;
+        model.v = 1.0;
+        model.bins = 10;
+        model.n_jobs = 1;
+        model.loss_function = "mse";
+        model.validation_tuning_metric = "bottom_quantile_mean_response";
+        model.verbosity = 3;
+        model.max_interaction_level = 100;
+        model.max_interactions = 30;
+        model.min_observations_in_split = 50;
+        model.ineligible_boosting_steps_added = 10;
+        model.max_eligible_terms = 5;
+        model.quantile = 0.2;
+        model.ridge_penalty = 0.0;
+
+        // 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(), 0.5)};
+
+        // Fitting
+        model.fit(X_train, y_train, sample_weight);
+        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.273887245225175));
+    }
+
     void test_aplrregressor_weibull()
     {
         // Model
@@ -2685,6 +2767,8 @@ int main()
     tests.test_aplrregressor_poisson();
     tests.test_aplrregressor_poissongamma();
     tests.test_aplrregressor_quantile();
+    tests.test_aplrregressor_neg_top_quantile_mean_response();
+    tests.test_aplrregressor_bottom_quantile_mean_response();
     tests.test_aplrregressor_weibull();
     tests.test_aplrregressor();
     tests.test_aplr_classifier_multi_class_other_params();

{aplr-10.11.1 → aplr-10.12.1}/setup.py

@@ -28,7 +28,7 @@ long_description = (this_directory / "README.md").read_text()
 
 setuptools.setup(
     name="aplr",
-    version="10.11.1",
+    version="10.12.1",
     description="Automatic Piecewise Linear Regression",
     ext_modules=[sfc_module],
     author="Mathias von Ottenbreit",