bug fix first value is -1.0, threshold for first split point

Author: kjgm

code/DataStructures/src/dataset.cpp

@@ -42,12 +42,14 @@ void Dataset::compute_unique_value_indices() {
         std::sort(idx.begin(), idx.end(),
             [&cur_feature_data](size_t i1, size_t i2) {return cur_feature_data[i1].value < cur_feature_data[i2].value;});
         double prev = -1.0f;
+        bool first = true;
         int cur_unique_value_index = -1;
         for (size_t ix : idx) {
             auto& cur_feature_element = cur_feature_data[ix];
-            if (prev == -1.0f || cur_feature_element.value - prev >= EPSILON) cur_unique_value_index++;
+            if (first || cur_feature_element.value - prev >= EPSILON) cur_unique_value_index++;
             cur_feature_element.unique_value_index = cur_unique_value_index;
             prev = cur_feature_element.value;
+            first = false;
         }
 
     }

code/DataStructures/src/tree.cpp

@@ -32,6 +32,8 @@ int Tree::get_num_branching_nodes() const {
 }
 
 void Tree::make_leaf(int label, int misclassifications) {
+    RUNTIME_ASSERT(misclassifications >= 0, "Leaf should have non-negative misclassifications.");
+    RUNTIME_ASSERT(label >= 0, "Leaf label should be non-negative.");
     this->label = label;
     this->misclassification_score = misclassifications;
     left = nullptr;

code/Engine/src/general_solver.cpp

@@ -53,7 +53,7 @@ void GeneralSolver::create_optimal_decision_tree(const Dataview& dataview, const
     while(!unsearched_intervals.empty()) {
         if (!solution_configuration.stopwatch.IsWithinTimeLimit()) return;
         auto current_interval = unsearched_intervals.front(); unsearched_intervals.pop();
-                
+
         if (interval_pruner.subinterval_pruning(current_interval, current_optimal_decision_tree->misclassification_score)) {
             continue;
         }
@@ -70,7 +70,7 @@ void GeneralSolver::create_optimal_decision_tree(const Dataview& dataview, const
         const int interval_half_distance = std::max(split_point - possible_split_indices[left], possible_split_indices[right] - split_point);
 
         const float threshold = mid > 0 ? (current_feature[possible_split_indices[mid - 1]].value + current_feature[split_point].value) / 2.0f 
-                                  : current_feature[split_point].value - 2 * EPSILON;  
+                                  : (current_feature[split_point].value + current_feature[0].value) / 2.0f;  
 
         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());
@@ -101,11 +101,16 @@ void GeneralSolver::create_optimal_decision_tree(const Dataview& dataview, const
             statistics::total_number_of_general_solver_calls += 1;
             const Configuration right_solution_configuration = solution_configuration.GetRightSubtreeConfig(left_solution_configuration.max_gap);
             GeneralSolver::create_optimal_decision_tree(smaller_data, right_solution_configuration, smaller_optimal_dt, smaller_ub);
-        
+            RUNTIME_ASSERT(left_optimal_dt->misclassification_score >= 0, "Left tree should have non-negative misclassification score.");
+            RUNTIME_ASSERT(right_optimal_dt->misclassification_score >= 0, "Right tree should have non-negative misclassification score.");
+
             const int current_best_score = left_optimal_dt->misclassification_score + right_optimal_dt->misclassification_score;
+
             if (current_best_score < current_optimal_decision_tree->misclassification_score) {
-                current_optimal_decision_tree->misclassification_score = current_best_score;
+                RUNTIME_ASSERT(left_optimal_dt->is_initialized(), "Left tree should be initialized.");
+                RUNTIME_ASSERT(right_optimal_dt->is_initialized(), "Right tree should be initialized.");
 
+                current_optimal_decision_tree->misclassification_score = current_best_score;
                 current_optimal_decision_tree->update_split(feature_index, threshold, left_optimal_dt, right_optimal_dt);
 
                 if (current_best_score == 0) {
@@ -155,6 +160,7 @@ void GeneralSolver::calculate_leaf_node(int class_number, int instance_number, c
     const int best_misclassification_score = instance_number - best_classification_score;
 
     if (best_misclassification_score < current_optimal_decision_tree->misclassification_score) {
+        RUNTIME_ASSERT(best_classification_label != -1, "Cannot assign negative leaf label.");
         current_optimal_decision_tree->make_leaf(best_classification_label, best_misclassification_score);
     }
 }

code/Engine/src/specialized_solver.cpp

@@ -51,23 +51,25 @@ void SpecializedSolver::get_best_left_right_scores(const Dataview& dataview, int
     const auto& split_feature = dataview.get_sorted_dataset_feature(feature_index);
     const auto& unsorted_split_feature = dataview.get_unsorted_dataset_feature(feature_index);
     std::vector<int> split_feature_split_indices(unsorted_split_feature.size());
-    double prev = -1.0f;
     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) {
             split_index = split_feature_data.unique_value_index;
         }
     }
+    RUNTIME_ASSERT(split_index != -1, "Split index not found.");
 
     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);
+    
 
-    left_tree.classification_score = left_tree.size - upper_bound;
-    right_tree.classification_score = right_tree.size - upper_bound;
+    left_tree.classification_score = std::max(0, left_tree.size - upper_bound);
+    right_tree.classification_score = std::max(0, 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);
 
@@ -106,15 +108,21 @@ void SpecializedSolver::get_best_left_right_scores(const Dataview& dataview, int
         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, std::make_shared<Tree>(left_tree.best_left_label, -1), std::make_shared<Tree>(left_tree.best_right_label, -1));
+        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.");
     }
     left_optimal_dt->misclassification_score = left_tree.size - left_tree.classification_score;
+    RUNTIME_ASSERT(left_optimal_dt->misclassification_score >= 0, "LR - Left tree misclassification score should be non-negative.");
 
     if (right_tree.classification_score == right_tree.max_label_frequency) {
         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, std::make_shared<Tree>(right_tree.best_left_label, -1), std::make_shared<Tree>(right_tree.best_right_label, -1));
+        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.");
     }
     right_optimal_dt->misclassification_score = right_tree.size - right_tree.classification_score;
+    RUNTIME_ASSERT(right_optimal_dt->misclassification_score >= 0, "LR - Right tree misclassification score should be non-negative.");
 }
 
 template <bool is_same_feature>
@@ -177,6 +185,7 @@ void SpecializedSolver::process_depth_one_feature(const Dataview& dataview,
         }
 
         if (left_classification_score + right_classification_score > tree.classification_score) {
+            RUNTIME_ASSERT(tree.classification_score <= tree.size, "LR - Classification score cannot exceed the number of instances.");
             tree.classification_score = left_classification_score + right_classification_score;
             tree.best_feature_index = current_feature_index;
             tree.best_threshold = (current_feature_data.value + tree.previous_value) / 2.0f;
@@ -233,14 +242,16 @@ void SpecializedSolver::create_optimal_decision_tree(const Dataview& dataview, c
         const int mid = (left + right) / 2;
         const int split_point = possible_split_indices[mid];
 
-        const float threshold = mid > 0 ? (current_feature[possible_split_indices[mid - 1]].value + current_feature[split_point].value) / 2.0f
-            : current_feature[split_point].value - 2 * EPSILON;
+        const float threshold = mid > 0 ? (current_feature[possible_split_indices[mid - 1]].value + current_feature[split_point].value) / 2.0f 
+                                  : (current_feature[split_point].value + current_feature[0].value) / 2.0f;  
 
         std::shared_ptr<Tree> left_optimal_dt = std::make_shared<Tree>();
         std::shared_ptr<Tree> right_optimal_dt = std::make_shared<Tree>();
 
         statistics::total_number_of_specialized_solver_calls += 1;
         get_best_left_right_scores(dataview, feature_index, split_point, threshold, left_optimal_dt, right_optimal_dt, current_optimal_decision_tree->misclassification_score);
+        RUNTIME_ASSERT(left_optimal_dt->misclassification_score >= 0, "D2 - Left tree should have non-negative misclassification score.");
+        RUNTIME_ASSERT(right_optimal_dt->misclassification_score >= 0, "D2 - Right tree should have non-negative misclassification score.");
 
         const int current_best_score = left_optimal_dt->misclassification_score + right_optimal_dt->misclassification_score;
 

code/Utilities/include/configuration.h

@@ -3,13 +3,33 @@
 
 #include <chrono>
 #include "stopwatch.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)
+#else
+#define RUNTIME_ASSERT(cond, msg)                                             \
+        do {                                                                      \
+            if (!(cond)) {                                                        \
+                std::cerr << "Assertion failed: " << #cond                        \
+                          << "\nMessage: " << msg                                 \
+                          << "\nFile: " << __FILE__                               \
+                          << "\nLine: " << __LINE__ << std::endl;                 \
+                std::terminate();                                                 \
+            }                                                                     \
+        } while (0)
+#endif
+
 struct Configuration {
     int max_depth;
     int max_gap;