Merge branch 'regression' into spack

Author: vancraar

include/plssvm/svm/csvr.hpp

@@ -29,14 +29,16 @@
 
 #include "igor/igor.hpp"  // igor::parser
 
-#include <algorithm>  // std::all_of
-#include <chrono>     // std::chrono::{time_point, steady_clock, duration_cast, milliseconds}
-#include <cstddef>    // std::size_t
-#include <memory>     // std::addressof
-#include <optional>   // std::make_optional
-#include <tuple>      // std::tie
-#include <utility>    // std::move
-#include <vector>     // std::vector
+#include <algorithm>    // std::all_of
+#include <chrono>       // std::chrono::{time_point, steady_clock, duration_cast, milliseconds}
+#include <cmath>        // std::round
+#include <cstddef>      // std::size_t
+#include <memory>       // std::addressof
+#include <optional>     // std::make_optional
+#include <tuple>        // std::tie
+#include <type_traits>  // std::is_floating_point_v
+#include <utility>      // std::move
+#include <vector>       // std::vector
 
 namespace plssvm {
 
@@ -224,7 +226,11 @@ class csvr : virtual public csvm {
 
         for (std::size_t i = 0; i < data.num_data_points(); ++i) {
             // TODO: is there multiclass regression? https://en.wikipedia.org/wiki/Multinomial_logistic_regression
-            predicted_labels[i] = static_cast<label_type>(votes(i, 0));
+            if constexpr (std::is_floating_point_v<label_type>) {
+                predicted_labels[i] = static_cast<label_type>(votes(i, 0));
+            } else {
+                predicted_labels[i] = static_cast<label_type>(std::round(votes(i, 0)));
+            }
         }
 
         PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_EVENT("predict end");

tests/backends/generic_base_csvr_tests.hpp

@@ -97,9 +97,13 @@ TYPED_TEST_P(GenericCSVRKernelFunction, predict) {
     constexpr plssvm::kernel_function_type kernel = util::test_parameter_value_at_v<0, TypeParam>;
 
     // create parameter struct
-    plssvm::parameter params{ plssvm::kernel_type = kernel };
-    if constexpr (kernel != plssvm::kernel_function_type::linear) {
-        params.gamma = plssvm::real_type{ 1.0 };
+    plssvm::parameter params{ plssvm::cost = 1000.0, plssvm::kernel_type = kernel };
+    if constexpr (kernel == plssvm::kernel_function_type::polynomial) {
+        params.degree = 1;
+        params.gamma = 1.0;
+    }
+    if constexpr (kernel == plssvm::kernel_function_type::sigmoid) {
+        params.gamma = 0.01;
     }
 
     // create data set that is always classifiable
@@ -118,11 +122,16 @@ TYPED_TEST_P(GenericCSVRKernelFunction, predict) {
     const plssvm::regression_model<label_type> model = svr.fit(test_data, plssvm::epsilon = 1e-16);
 
     // actual TEST: predict label
-    [[maybe_unused]] const std::vector<label_type> calculated = svr.predict(model, test_data);
+    std::vector<label_type> calculated = svr.predict(model, test_data);
 
     // check the calculated result for correctness
-    GTEST_SKIP() << "not yet implemented for C-SVR";
-    // EXPECT_EQ(calculated, test_data.labels().value().get());
+    if constexpr (std::is_floating_point_v<label_type>) {
+        // convert a floating point label_type back to a plain integer
+        for (label_type &val : calculated) {
+            val = static_cast<label_type>(std::round(val));
+        }
+    }
+    EXPECT_EQ(calculated, test_data.labels().value().get());
 }
 
 TYPED_TEST_P(GenericCSVRKernelFunction, score_model) {
@@ -158,7 +167,7 @@ TYPED_TEST_P(GenericCSVRKernelFunction, score_model) {
     // check the calculated result for correctness
     // 1.0 is the maximum possible value
     // arbitrary small (negative) values are possible, but the "easy" data set shouldn't result in values smaller 0.0
-    EXPECT_EXCLUSIVE_RANGE(calculated, plssvm::real_type{ 0.0 }, plssvm::real_type{ 1.0 });
+    EXPECT_INCLUSIVE_RANGE(calculated, plssvm::real_type{ 0.0 }, plssvm::real_type{ 1.0 });
 }
 
 TYPED_TEST_P(GenericCSVRKernelFunction, score) {
@@ -194,7 +203,7 @@ TYPED_TEST_P(GenericCSVRKernelFunction, score) {
     // check the calculated result for correctness
     // 1.0 is the maximum possible value
     // arbitrary small (negative) values are possible, but the "easy" data set shouldn't result in values smaller 0.0
-    EXPECT_EXCLUSIVE_RANGE(calculated, plssvm::real_type{ 0.0 }, plssvm::real_type{ 1.0 });
+    EXPECT_INCLUSIVE_RANGE(calculated, plssvm::real_type{ 0.0 }, plssvm::real_type{ 1.0 });
 }
 
 REGISTER_TYPED_TEST_SUITE_P(GenericCSVRKernelFunction,