Refactor parameter handling in RcppRPF and ClassificationRPF

- Removed `set_parameters` method from both RcppRPF and ClassificationRPF classes.
- Updated `get_parameters` to return a structured RPFParams object instead of printing to stdout.
- Removed obsolete test related to parameter setting from test suite.

Author: jyliuu

src/include/cpf.hpp

@@ -3,6 +3,32 @@
 
 #include <vector>
 #include "rpf.hpp"
+enum LossType
+{
+  L1,
+  L2,
+  median,
+  logit,
+  logit_2,
+  logit_3,
+  logit_4,
+  exponential,
+  exponential_2,
+  exponential_3
+};
+struct CPFParams
+{
+  int max_interaction;
+  int n_trees;
+  int n_splits;
+  int split_try;
+  double t_try;
+  bool purify_forest;
+  bool deterministic;
+  int nthreads;
+  bool cross_validate;
+  LossType loss;
+};
 
 class ClassificationRPF : public RandomPlantedForest
 {
@@ -11,25 +37,12 @@ class ClassificationRPF : public RandomPlantedForest
   using RandomPlantedForest::calcOptimalSplit;
   ClassificationRPF(const std::vector<std::vector<double>> &samples_Y, const std::vector<std::vector<double>> &samples_X,
                     const std::string loss = "L2", const std::vector<double> parameters = {1, 50, 30, 10, 0.4, 0, 0, 0, 0, 0, 0.1});
-  void set_parameters(std::vector<std::string> keys, std::vector<double> values);
-  ~ClassificationRPF(){};
+  ~ClassificationRPF() {};
+  CPFParams get_parameters();
 
 private:
   double delta;
   double epsilon;
-  enum LossType
-  {
-    L1,
-    L2,
-    median,
-    logit,
-    logit_2,
-    logit_3,
-    logit_4,
-    exponential,
-    exponential_2,
-    exponential_3
-  };
   LossType loss;
   void (ClassificationRPF::*calcLoss)(Split &);
   void create_tree_family(std::vector<Leaf> initial_leaves, size_t n) override;
@@ -48,5 +61,4 @@ class ClassificationRPF : public RandomPlantedForest
   void exponential_loss_3(Split &split);
 };
 
-
 #endif

src/include/rcpp_interface.hpp

@@ -10,7 +10,6 @@ using namespace Rcpp;
 class RcppInterface
 {
 public:
-  virtual void set_parameters(StringVector keys, NumericVector values) = 0;
   virtual NumericMatrix predict_matrix(const NumericMatrix &X, const NumericVector components) = 0;
   virtual NumericMatrix predict_vector(const NumericVector &X, const NumericVector components) = 0;
   virtual void cross_validation(int n_sets, IntegerVector splits, NumericVector t_tries, IntegerVector split_tries) = 0;
@@ -29,12 +28,11 @@ class RcppRPF : public RandomPlantedForest, public RcppInterface
   NumericMatrix predict_vector(const NumericVector &X, const NumericVector components = {0}) override;
   void cross_validation(int n_sets, IntegerVector splits, NumericVector t_tries, IntegerVector split_tries) override;
   double MSE(const NumericMatrix &Y_predicted, const NumericMatrix &Y_true) override;
-  void set_parameters(StringVector keys, NumericVector values) override;
   List get_model() override;
 
   void purify_3();
   void print();
-  void get_parameters();
+  List get_parameters();
   bool is_purified();
 
 protected:
@@ -46,7 +44,6 @@ class RcppCPF : public ClassificationRPF, public RcppInterface
 public:
   RcppCPF(const NumericMatrix &samples_Y, const NumericMatrix &samples_X,
           const std::string loss = "L2", const NumericVector parameters = {1, 50, 30, 10, 0.4, 0, 0, 0, 0});
-  void set_parameters(StringVector keys, NumericVector values) override;
   NumericMatrix predict_matrix(const NumericMatrix &X, const NumericVector components = {0}) override;
   NumericMatrix predict_vector(const NumericVector &X, const NumericVector components = {0}) override;
   void cross_validation(int n_sets, IntegerVector splits, NumericVector t_tries, IntegerVector split_tries) override;
@@ -55,7 +52,7 @@ class RcppCPF : public ClassificationRPF, public RcppInterface
 
   void purify_3();
   void print();
-  void get_parameters();
+  List get_parameters();
   bool is_purified();
 };
 

src/include/rpf.hpp

@@ -5,6 +5,19 @@
 #include <stdexcept>
 #include "trees.hpp"
 
+struct RPFParams
+{
+  int max_interaction;
+  int n_trees;
+  int n_splits;
+  int split_try;
+  double t_try;
+  bool purify_forest;
+  bool deterministic;
+  int nthreads;
+  bool cross_validate;
+};
+
 class RandomPlantedForest
 {
 
@@ -23,8 +36,7 @@ class RandomPlantedForest
   void print();
   void cross_validation(int n_sets = 4, std::vector<int> splits = {5, 50}, std::vector<double> t_tries = {0.2, 0.5, 0.7, 0.9}, std::vector<int> split_tries = {1, 2, 5, 10});
   double MSE(const std::vector<std::vector<double>> &Y_predicted, const std::vector<std::vector<double>> &Y_true);
-  void get_parameters();
-  void set_parameters(std::vector<std::string> keys, std::vector<double> values);
+  RPFParams get_parameters();
   virtual ~RandomPlantedForest() {};
   bool is_purified();
 

src/lib/cpf.cpp

@@ -1434,100 +1434,7 @@ void ClassificationRPF::fit()
   }
 }
 
-/*  retrospectively change parameters of existing class object,
- updates the model, so far only single valued parameters supported,
- for replacing training data use 'set_data',
- note that changing cv does not trigger cross validation */
-void ClassificationRPF::set_parameters(std::vector<std::string> keys, std::vector<double> values)
+CPFParams ClassificationRPF::get_parameters()
 {
-  if (keys.size() != values.size())
-  {
-    std::cout << "Size of input vectors is not the same. " << std::endl;
-    return;
-  }
-
-  for (unsigned int i = 0; i < keys.size(); ++i)
-  {
-    if (keys[i] == "deterministic")
-    {
-      this->deterministic = values[i];
-    }
-    else if (keys[i] == "nthreads")
-    {
-      this->nthreads = values[i];
-    }
-    else if (keys[i] == "purify")
-    {
-      this->purify_forest = values[i];
-    }
-    else if (keys[i] == "n_trees")
-    {
-      this->n_trees = values[i];
-    }
-    else if (keys[i] == "n_splits")
-    {
-      this->n_splits = values[i];
-    }
-    else if (keys[i] == "t_try")
-    {
-      this->t_try = values[i];
-    }
-    else if (keys[i] == "split_try")
-    {
-      this->split_try = values[i];
-    }
-    else if (keys[i] == "max_interaction")
-    {
-      this->max_interaction = values[i];
-    }
-    else if (keys[i] == "cv")
-    {
-      this->cross_validate = values[i];
-    }
-    else if (keys[i] == "loss")
-    {
-      if (keys[i] == "L1")
-      {
-        this->loss = LossType::L1;
-        this->calcLoss = &ClassificationRPF::L1_loss;
-      }
-      else if (keys[i] == "L2")
-      {
-        this->loss = LossType::L2;
-        this->calcLoss = &ClassificationRPF::L2_loss;
-      }
-      else if (keys[i] == "median")
-      {
-        this->loss = LossType::median;
-        this->calcLoss = &ClassificationRPF::median_loss;
-      }
-      else if (keys[i] == "logit")
-      {
-        this->loss = LossType::logit;
-        this->calcLoss = &ClassificationRPF::logit_loss;
-      }
-      else if (keys[i] == "exponential")
-      {
-        this->loss = LossType::exponential;
-        this->calcLoss = &ClassificationRPF::exponential_loss;
-      }
-      else
-      {
-        std::cout << "Unkown loss function." << std::endl;
-      }
-    }
-    else if (keys[i] == "delta")
-    {
-      this->delta = values[i];
-    }
-    else if (keys[i] == "epsilon")
-    {
-      this->epsilon = values[i];
-    }
-    else
-    {
-      std::cout << "Unkown parameter key  '" << keys[i] << "' ." << std::endl;
-    }
-  }
-  this->fit();
+  return {max_interaction, n_trees, n_splits, split_try, t_try, purify_forest, deterministic, nthreads, cross_validate, loss};
 }

src/lib/rcpp_interface.cpp

@@ -114,12 +114,6 @@ double RcppRPF::MSE(const NumericMatrix &Y_predicted, const NumericMatrix &Y_tru
   return RandomPlantedForest::MSE(toStd2D(Y_predicted), toStd2D(Y_true));
 }
 
-void RcppRPF::set_parameters(StringVector keys, NumericVector values)
-{
-  RandomPlantedForest::set_parameters(std::vector<std::string>(keys.begin(), keys.end()),
-                                      std::vector<double>(values.begin(), values.end()));
-}
-
 double RcppRPF::MSE_vec(const NumericVector &Y_predicted, const NumericVector &Y_true)
 {
   return RandomPlantedForest::MSE_vec(toStd1D(Y_predicted), toStd1D(Y_true));
@@ -135,9 +129,18 @@ void RcppRPF::print()
   RandomPlantedForest::print();
 }
 
-void RcppRPF::get_parameters()
+List RcppRPF::get_parameters()
 {
-  RandomPlantedForest::get_parameters();
+  RPFParams params = RandomPlantedForest::get_parameters();
+  return List::create(Named("max_interaction") = params.max_interaction,
+                      Named("n_trees") = params.n_trees,
+                      Named("n_splits") = params.n_splits,
+                      Named("split_try") = params.split_try,
+                      Named("t_try") = params.t_try,
+                      Named("purify_forest") = params.purify_forest,
+                      Named("deterministic") = params.deterministic,
+                      Named("nthreads") = params.nthreads,
+                      Named("cross_validate") = params.cross_validate);
 }
 
 List RcppRPF::get_model()
@@ -163,12 +166,6 @@ RcppCPF::RcppCPF(const NumericMatrix &samples_Y, const NumericMatrix &samples_X,
   }
 }
 
-void RcppCPF::set_parameters(StringVector keys, NumericVector values)
-{
-  ClassificationRPF::set_parameters(std::vector<std::string>(keys.begin(), keys.end()),
-                                    std::vector<double>(values.begin(), values.end()));
-}
-
 NumericMatrix RcppCPF::predict_matrix(const NumericMatrix &X, const NumericVector components)
 {
   auto result = ClassificationRPF::predict_matrix(toStd2D(X), toStd1D(components));
@@ -219,9 +216,18 @@ void RcppCPF::print()
   RandomPlantedForest::print();
 }
 
-void RcppCPF::get_parameters()
+List RcppCPF::get_parameters()
 {
-  RandomPlantedForest::get_parameters();
+  CPFParams params = ClassificationRPF::get_parameters();
+  return List::create(Named("max_interaction") = params.max_interaction,
+                      Named("n_trees") = params.n_trees,
+                      Named("n_splits") = params.n_splits,
+                      Named("split_try") = params.split_try,
+                      Named("t_try") = params.t_try,
+                      Named("purify_forest") = params.purify_forest,
+                      Named("deterministic") = params.deterministic,
+                      Named("nthreads") = params.nthreads,
+                      Named("cross_validate") = params.cross_validate);
 }
 
 List RcppCPF::get_model()

src/lib/rpf.cpp

@@ -1983,68 +1983,7 @@ void RandomPlantedForest::print()
   }
 }
 
-// print parameters of the model to the console
-void RandomPlantedForest::get_parameters()
+RPFParams RandomPlantedForest::get_parameters()
 {
-  std::cout << "Parameters: n_trees=" << n_trees << ", n_splits=" << n_splits << ", max_interaction=" << max_interaction << ", t_try=" << t_try
-            << ", split_try=" << split_try << ", purified=" << purified << ", deterministic=" << deterministic << ", nthreads=" << nthreads
-            << ", feature_size=" << feature_size << ", sample_size=" << sample_size << std::endl;
-}
-
-/*  retrospectively change parameters of existing class object,
- updates the model, so far only single valued parameters supported,
- for replacing training data use 'set_data',
- note that changing cv does not trigger cross validation */
-void RandomPlantedForest::set_parameters(std::vector<std::string> keys, std::vector<double> values)
-{
-  if (keys.size() != values.size())
-  {
-    std::cout << "Size of input vectors is not the same. " << std::endl;
-    return;
-  }
-
-  for (unsigned int i = 0; i < keys.size(); ++i)
-  {
-    if (keys[i] == "deterministic")
-    {
-      this->deterministic = values[i];
-    }
-    else if (keys[i] == "nthreads")
-    {
-      this->nthreads = values[i];
-    }
-    else if (keys[i] == "purify")
-    {
-      this->purify_forest = values[i];
-    }
-    else if (keys[i] == "n_trees")
-    {
-      this->n_trees = values[i];
-    }
-    else if (keys[i] == "n_splits")
-    {
-      this->n_splits = values[i];
-    }
-    else if (keys[i] == "t_try")
-    {
-      this->t_try = values[i];
-    }
-    else if (keys[i] == "split_try")
-    {
-      this->split_try = values[i];
-    }
-    else if (keys[i] == "max_interaction")
-    {
-      this->max_interaction = values[i];
-    }
-    else if (keys[i] == "cv")
-    {
-      this->cross_validate = values[i];
-    }
-    else
-    {
-      std::cout << "Unkown parameter key  '" << keys[i] << "' ." << std::endl;
-    }
-  }
-  this->fit();
+  return {max_interaction, n_trees, n_splits, split_try, t_try, purify_forest, deterministic, nthreads, cross_validate};
 }

src/randomPlantedForest.cpp

@@ -16,21 +16,18 @@ RCPP_MODULE(mod_rpf)
         .method("purify", &RcppRPF::purify_3)
         .method("print", &RcppRPF::print)
         .method("get_parameters", &RcppRPF::get_parameters)
-        .method("set_parameters", &RcppRPF::set_parameters)
         .method("get_model", &RcppRPF::get_model)
         .method("is_purified", &RcppRPF::is_purified);
 
     class_<RcppCPF>("ClassificationRPF")
         .constructor<const NumericMatrix, const NumericMatrix, const String, const NumericVector>()
-        .method("set_parameters", &RcppCPF::set_parameters)
         .method("predict_matrix", &RcppCPF::predict_matrix)
         .method("predict_vector", &RcppCPF::predict_vector)
         .method("cross_validation", &RcppCPF::cross_validation)
         .method("MSE", &RcppCPF::MSE)
         .method("purify", &RcppCPF::purify_3)
         .method("print", &RcppCPF::print)
         .method("get_parameters", &RcppCPF::get_parameters)
-        .method("set_parameters", &RcppCPF::set_parameters)
         .method("get_model", &RcppCPF::get_model)
         .method("is_purified", &RcppCPF::is_purified);
 }