bug fix static stats to dynamic stats

Author: kjgm

code/Engine/include/general_solver.h

@@ -9,7 +9,6 @@
 #include "cache.h"
 #include "dataset.h"
 #include "dataview.h"
-#include "general_solver.h"
 #include "intervals_pruner.h"
 #include "specialized_solver.h"
 #include "statistics.h"
@@ -31,6 +30,7 @@ struct SplitInfo {
     int mid = -1;           // the mid point in the interval, the split point we are splitting on now
     int split_point = -1;   // the sample index of the first sample right of the split
     float threshold = -1;   // the split threshold (in the continuous numbers, not the unique_value_index)
+    int unique_value_threshold = -1; // the split threshold (in the unique value index, not the continuous value)
     std::shared_ptr<Tree> left_optimal_dt;
     std::shared_ptr<Tree> right_optimal_dt;
 };
@@ -72,7 +72,7 @@ class GeneralSolver {
      * @param current_optimal_tree The current optimal tree.
      * @param upper_bound The upper bound for the search space.
      */
-    static void solve_split(const Dataview& dataview, const Configuration& config, SplitInfo& split, std::shared_ptr<Tree>& current_optimal_tree, float upper_bound);
+    static void solve_split(const Dataview& dataview, Configuration& config, SplitInfo& split, std::shared_ptr<Tree>& current_optimal_tree, float upper_bound);
 
     /**
      * Calculates the misclassification score if the current node is a leaf node.

code/Engine/include/specialized_solver.h

@@ -10,28 +10,25 @@
 #include "dataset.h"
 #include "dataview.h"
 #include "intervals_pruner.h"
-#include "specialized_solver.h"
 #include "statistics.h"
 #include "tree.h"
 
+
 class Depth1ScoreHelper;
 
+struct SplitInfo;
+
 class SpecializedSolver {
 public:
     /**
      * Calculates the misclassification scores for both the left and right splits of the dataset using only one dataset traversal.
      * 
      * @param dataset The dataset to calculate the scores from.
-     * @param feature_index The index of the feature to split on.
-     * @param split_point The split point for the feature.
-     * @param threshold The threshold value for the split.
-     * @param left_optimal_tree The optimal tree for the left split.
-     * @param right_optimal_tree The optimal tree for the right split.
+     * @param split Information on the root node split, such as what feature to split on
      * @param upper_bound The upper bound for the scores.
      * @param complexity_cost The cost of adding a node
      */
-    static void get_best_left_right_scores(const Dataview& dataset, int feature_index, int split_point, float threshold, 
-        std::shared_ptr<Tree>& left_optimal_tree, std::shared_ptr<Tree>& right_optimal_tree, float upper_bound, float complexity_cost);
+    static void get_best_left_right_scores(const Dataview& dataset, SplitInfo& split, float upper_bound, float complexity_cost);
 
 private:
     /**

code/Engine/src/general_solver.cpp

@@ -8,7 +8,7 @@ void GeneralSolver::create_optimal_decision_tree(const Dataview& dataview, Confi
     // Check if we have the subproblem cached already
     if (Cache::global_cache.is_cached(dataview, config.max_depth)) {
         current_optimal_decision_tree = Cache::global_cache.retrieve(dataview, config.max_depth);
-        statistics::total_number_cache_hits += 1;
+        config.stats->total_number_cache_hits += 1;
         return;
     }
 
@@ -57,6 +57,7 @@ SplitInfo initialize_split(const std::vector<int>& possible_split_indices, const
     split.split_point = possible_split_indices[(left + right) / 2];
     split.threshold = split.mid > 0 ? (current_feature[possible_split_indices[split.mid - 1]].value + current_feature[split.split_point].value) / 2.0f
         : (current_feature[split.split_point].value + current_feature[0].value) / 2.0f;
+    split.unique_value_threshold = current_feature[split.split_point].unique_value_index;
     split.left_optimal_dt = std::make_shared<Tree>();
     split.right_optimal_dt = std::make_shared<Tree>();
     return split;
@@ -110,12 +111,12 @@ void GeneralSolver::create_optimal_decision_tree(const Dataview& dataview, Confi
         if (split.left_optimal_dt->is_initialized() && split.right_optimal_dt->is_initialized() && current_best_score < current_optimal_decision_tree->objective) {
             current_optimal_decision_tree->update_split(feature_index, split.threshold, split.left_optimal_dt, split.right_optimal_dt, config.complexity_cost);
             upper_bound = std::min(upper_bound, current_best_score);
-            if (current_best_score <= config.complexity_cost + EPSILON) return;
             if (PRINT_INTERMEDIARY_TIME_SOLUTIONS && config.is_root)  {
-                const auto stop = std::chrono::high_resolution_clock::now();
-                const auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(stop - starting_time);
-                std::cout << "Time taken to get the misclassification score " << current_best_score << ": " << duration.count() / 1000.0 << " seconds" << std::endl;
+                std::cout << "Time taken to get the misclassification score " << current_best_score 
+                        << ": " << std::fixed << std::setprecision(4) << config.stopwatch.TimeElapsedInSeconds() << " seconds ("
+                        << (config.stats->total_number_of_general_solver_calls + config.stats->total_number_of_specialized_solver_calls) <<" expansions)" << std::endl;
             }
+            if (current_best_score <= config.complexity_cost + EPSILON) return;
         }
         // Add the result to the interval pruner
         interval_pruner.add_result(split.mid, split.left_optimal_dt->objective, split.right_optimal_dt->objective);
@@ -141,26 +142,24 @@ void GeneralSolver::create_optimal_decision_tree(const Dataview& dataview, Confi
     }
 }
 
-void GeneralSolver::solve_split(const Dataview& dataview, const Configuration& config, SplitInfo& split, std::shared_ptr<Tree>& current_optimal_tree, float upper_bound) {
+void GeneralSolver::solve_split(const Dataview& dataview, Configuration& config, SplitInfo& split, std::shared_ptr<Tree>& current_optimal_tree, float upper_bound) {
     const std::vector<Dataset::FeatureElement>& current_feature = dataview.get_sorted_dataset_feature(split.feature);
     const auto& possible_split_indices = dataview.get_possible_split_indices(split.feature);
 
     if (config.max_depth == 2) {
         // If the maximum remaining depth is two, we use our special depth two solver
-        statistics::total_number_of_specialized_solver_calls += 1;
-        SpecializedSolver::get_best_left_right_scores(dataview, split.feature, split.split_point, split.threshold, split.left_optimal_dt, split.right_optimal_dt, upper_bound, config.complexity_cost);
+        config.stats->total_number_of_specialized_solver_calls += 1;
+        SpecializedSolver::get_best_left_right_scores(dataview, split, upper_bound, config.complexity_cost);
         RUNTIME_ASSERT(split.left_optimal_dt->objective >= 0, "D2 - Left tree should have non-negative misclassification score.");
         RUNTIME_ASSERT(split.right_optimal_dt->objective >= 0, "D2 - Right tree should have non-negative misclassification score.");
     } else {
         // We compute the distance from the split point to the sample indicies of the left and right interval split points
         const int interval_half_distance = std::max(split.split_point - possible_split_indices[split.left], possible_split_indices[split.right] - split.split_point);
-        // The unique-value index of the split point. We use this to split the data (rather than the continuous threshold, which may give numerical instability)
-        const int split_unique_value_index = current_feature[split.split_point].unique_value_index;
 
         // Split the dataset in two based on the split point
         Dataview left_dataview = Dataview(dataview.get_class_number(), dataview.should_sort_by_gini_index());
         Dataview right_dataview = Dataview(dataview.get_class_number(), dataview.should_sort_by_gini_index());
-        Dataview::split_data_points(dataview, split.feature, split.split_point, split_unique_value_index, left_dataview, right_dataview, config.max_depth);
+        Dataview::split_data_points(dataview, split.feature, split.split_point, split.unique_value_threshold, left_dataview, right_dataview, config.max_depth);
 
         // We first compute the subtree for the bigger dataset since it might make computing the smaller dataset obsolete
         auto& smaller_data = (left_dataview.get_dataset_size() < right_dataview.get_dataset_size()) ? left_dataview : right_dataview;
@@ -175,7 +174,7 @@ void GeneralSolver::solve_split(const Dataview& dataview, const Configuration& c
             : current_optimal_tree->objective;
 
         // Recursively solve the subtree
-        statistics::total_number_of_general_solver_calls += 1;
+        config.stats->total_number_of_general_solver_calls += 1;
         Configuration left_solution_configuration = config.GetLeftSubtreeConfig();
         GeneralSolver::create_optimal_decision_tree(larger_data, left_solution_configuration, larger_optimal_dt, larger_ub);
         RUNTIME_ASSERT(larger_optimal_dt->objective >= 0, "Right tree should have non-negative misclassification score.");
@@ -189,7 +188,7 @@ void GeneralSolver::solve_split(const Dataview& dataview, const Configuration& c
         // We compute the second subtree only if we have a positive upper bound, larger than zero.
         // If the upper bound is precisely zero, but not because of the interval_half distance, we also want to compute the subproblem
         if (smaller_ub > 0 || (std::abs(smaller_ub) <= EPSILON && std::abs(smaller_obj_ub) <= EPSILON)) {
-            statistics::total_number_of_general_solver_calls += 1;
+            config.stats->total_number_of_general_solver_calls += 1;
             Configuration right_solution_configuration = config.GetRightSubtreeConfig(left_solution_configuration.max_gap);
             GeneralSolver::create_optimal_decision_tree(smaller_data, right_solution_configuration, smaller_optimal_dt, smaller_ub);
             RUNTIME_ASSERT(smaller_optimal_dt->objective >= 0, "Left tree should have non-negative misclassification score.");

code/Engine/src/specialized_solver.cpp

@@ -1,4 +1,5 @@
 #include "specialized_solver.h"
+#include "general_solver.h"
 
 class Depth1ScoreHelper {
 public:
@@ -43,19 +44,19 @@ class Depth1ScoreHelper {
     std::vector<int> current_label_frequency;
 };
 
-void SpecializedSolver::get_best_left_right_scores(const Dataview& dataview, int feature_index, int split_point, float threshold, std::shared_ptr<Tree> &left_optimal_dt, std::shared_ptr<Tree> &right_optimal_dt, float upper_bound, float complexity_cost) {
+void SpecializedSolver::get_best_left_right_scores(const Dataview& dataview, SplitInfo& split, float upper_bound, float complexity_cost) {
     RUNTIME_ASSERT(dataview.get_dataset_size() > 0, "Dataset cannot be empty.");
     RUNTIME_ASSERT(upper_bound >= complexity_cost, "Upper bound should always be complexity-cost or higher.");
-    RUNTIME_ASSERT(left_optimal_dt->objective >= 0, "Current objective should always be zero or higher.");
-    RUNTIME_ASSERT(right_optimal_dt->objective >= 0, "Current objective should always be zero or higher.");
+    RUNTIME_ASSERT(split.left_optimal_dt->objective >= 0, "Current objective should always be zero or higher.");
+    RUNTIME_ASSERT(split.right_optimal_dt->objective >= 0, "Current objective should always be zero or higher.");
 
-    const auto& split_feature = dataview.get_sorted_dataset_feature(feature_index);
-    const auto& unsorted_split_feature = dataview.get_unsorted_dataset_feature(feature_index);
+    const auto& split_feature = dataview.get_sorted_dataset_feature(split.feature);
+    const auto& unsorted_split_feature = dataview.get_unsorted_dataset_feature(split.feature);
     std::vector<int> split_feature_split_indices(unsorted_split_feature.size());
     int split_index = -1;
     for (const auto& split_feature_data : split_feature) {
         split_feature_split_indices[split_feature_data.data_point_index] = split_feature_data.unique_value_index;
-        if (split_index == -1 && split_feature_data.value >= threshold) {
+        if (split_index == -1 && split_feature_data.unique_value_index >= split.unique_value_threshold) {
             split_index = split_feature_data.unique_value_index;
         }
     }
@@ -64,15 +65,15 @@ void SpecializedSolver::get_best_left_right_scores(const Dataview& dataview, int
     const int dataset_size = dataview.get_dataset_size();
     const int class_number = dataview.get_class_number();
 
-    RUNTIME_ASSERT(split_point > 0 && split_point < dataset_size, "left and right subtree need to be non-empty.");
-    Depth1ScoreHelper left_tree(split_point, class_number);
-    Depth1ScoreHelper right_tree(dataset_size - split_point, class_number);
+    RUNTIME_ASSERT(split.split_point > 0 && split.split_point < dataset_size, "left and right subtree need to be non-empty.");
+    Depth1ScoreHelper left_tree(split.split_point, class_number);
+    Depth1ScoreHelper right_tree(dataset_size - split.split_point, class_number);
 
 
     left_tree.classification_score = std::max(0.0f, float(left_tree.size) - upper_bound);
     right_tree.classification_score = std::max(0.0f, float(right_tree.size) - upper_bound);
 
-    Dataview::initialize_split_parameters(split_feature, class_number, dataview.get_label_frequency(), split_point, left_tree.label_frequency, right_tree.label_frequency);
+    Dataview::initialize_split_parameters(split_feature, class_number, dataview.get_label_frequency(), split.split_point, left_tree.label_frequency, right_tree.label_frequency);
 
     left_tree.max_label_frequency = 0;
     right_tree.max_label_frequency = 0;
@@ -91,38 +92,38 @@ void SpecializedSolver::get_best_left_right_scores(const Dataview& dataview, int
 
     for (int current_feature_index = 0; current_feature_index < dataview.get_feature_number(); current_feature_index++) {
         if (left_tree.classification_score + right_tree.classification_score == dataset_size) break;
-        if (current_feature_index == feature_index) {
-            process_depth_one_feature<true>(dataview, feature_index, split_point, current_feature_index, split_index,
+        if (current_feature_index == split.feature) {
+            process_depth_one_feature<true>(dataview, split.feature, split.split_point, current_feature_index, split_index,
                 left_tree, right_tree, split_feature_split_indices, upper_bound, complexity_cost);
         } else {
-            process_depth_one_feature<false>(dataview, feature_index, split_point, current_feature_index, split_index,
+            process_depth_one_feature<false>(dataview, split.feature, split.split_point, current_feature_index, split_index,
                 left_tree, right_tree, split_feature_split_indices, upper_bound, complexity_cost);
         }
     }
 
     if (left_tree.is_leaf()) {
-        left_optimal_dt->make_leaf(left_tree.max_label, left_tree.size - left_tree.classification_score);
+        split.left_optimal_dt->make_leaf(left_tree.max_label, left_tree.size - left_tree.classification_score);
     } else {
-        left_optimal_dt->update_split(left_tree.best_feature_index, left_tree.best_threshold, 
+        split.left_optimal_dt->update_split(left_tree.best_feature_index, left_tree.best_threshold, 
             std::make_shared<Tree>(left_tree.best_left_label, -1), 
             std::make_shared<Tree>(left_tree.best_right_label, -1), complexity_cost);
-        left_optimal_dt->objective = left_tree.get_objective(complexity_cost);
+        split.left_optimal_dt->objective = left_tree.get_objective(complexity_cost);
         //RUNTIME_ASSERT(left_tree.best_left_label != -1, "Left tree left label should be initialized.");
         //RUNTIME_ASSERT(left_tree.best_right_label != -1, "Left tree right label should be initialized.");
     }
-    RUNTIME_ASSERT(left_optimal_dt->objective >= 0, "LR - Left tree misclassification score should be non-negative.");
+    RUNTIME_ASSERT(split.left_optimal_dt->objective >= 0, "LR - Left tree misclassification score should be non-negative.");
 
     if (right_tree.is_leaf()) {
-        right_optimal_dt->make_leaf(right_tree.max_label, right_tree.size - right_tree.classification_score);
+        split.right_optimal_dt->make_leaf(right_tree.max_label, right_tree.size - right_tree.classification_score);
     } else {
-        right_optimal_dt->update_split(right_tree.best_feature_index, right_tree.best_threshold,
+        split.right_optimal_dt->update_split(right_tree.best_feature_index, right_tree.best_threshold,
             std::make_shared<Tree>(right_tree.best_left_label, -1),
             std::make_shared<Tree>(right_tree.best_right_label, -1), complexity_cost);
-        right_optimal_dt->objective = right_tree.get_objective(complexity_cost);
+        split.right_optimal_dt->objective = right_tree.get_objective(complexity_cost);
         //RUNTIME_ASSERT(right_tree.best_left_label != -1, "Right tree left label should be initialized.");
         //RUNTIME_ASSERT(right_tree.best_right_label != -1, "Right tree right label should be initialized.");
     }
-    RUNTIME_ASSERT(right_optimal_dt->objective >= 0, "LR - Right tree misclassification score should be non-negative.");
+    RUNTIME_ASSERT(split.right_optimal_dt->objective >= 0, "LR - Right tree misclassification score should be non-negative.");
 }
 
 template <bool is_same_feature>
@@ -159,11 +160,13 @@ void SpecializedSolver::process_depth_one_feature(const Dataview& dataview,
 
         tree.can_skip--;
 
-        if (current_feature_data.unique_value_index == tree.previous_unique_value_index || tree.can_skip > 0){
+        if (current_feature_data.unique_value_index == tree.previous_unique_value_index || tree.can_skip > 0) {
             tree.current_element_count++;
             tree.current_label_frequency[current_feature_data.label]++;
             tree.previous_value = current_feature_data.value;
             tree.previous_unique_value_index = current_feature_data.unique_value_index;
+            RUNTIME_ASSERT(tree.current_label_frequency[current_feature_data.label] <= tree.label_frequency[current_feature_data.label]
+                , "Current label frequency can never exceed the maximum label frequency.");
             continue;
         }
 

code/Utilities/include/configuration.h

@@ -1,19 +1,15 @@
 #ifndef CONFIGURATION_H
 #define CONFIGURATION_H
 
-#include <chrono>
 #include "stopwatch.h"
+#include "statistics.h"
 #include <cassert>
 #include <stdexcept>
 #include <iostream>
 
 #define EPSILON 0.0000001f
 
 #define PRINT_INTERMEDIARY_TIME_SOLUTIONS 0
-extern std::chrono::high_resolution_clock::time_point starting_time;
-
-
-
 
 #ifdef NDEBUG
 #define RUNTIME_ASSERT(cond, msg) ((void)0)
@@ -31,6 +27,9 @@ extern std::chrono::high_resolution_clock::time_point starting_time;
 #endif
 
 struct Configuration {
+
+    Configuration() : stats(std::make_shared<statistics>()) {}
+
     int max_depth{ 3 };
     int max_gap{ 0 };
     float max_gap_decay{ 0.0 };
@@ -40,6 +39,7 @@ struct Configuration {
     bool sort_gini{ false };
     float complexity_cost{ 0.0 };
     Stopwatch stopwatch;
+    std::shared_ptr<statistics> stats{ nullptr };
     Configuration GetLeftSubtreeConfig() const;
     Configuration GetRightSubtreeConfig(int left_gap) const;
 };

code/Utilities/include/statistics.h

@@ -3,13 +3,13 @@
 
 class statistics {
 public:
-    static unsigned long long total_number_of_specialized_solver_calls;
-    static unsigned long long total_number_of_general_solver_calls;
-    static unsigned long long total_number_cache_hits;
+    unsigned long long total_number_of_specialized_solver_calls{ 0 };
+    unsigned long long total_number_of_general_solver_calls{ 0 };
+    unsigned long long total_number_cache_hits{ 0 };
 
-    static bool should_print;
+    bool should_print{ false };
 
-    static void print_statistics();
+    void print_statistics();
 };
 
 #endif // STATISTICS_H