removing normalize dot from implicit regression

nasa · May 25, 2020 · 6a147d6 · 6a147d6
1 parent dc26b87
commit 6a147d6
Show file tree

Hide file tree

Showing 4 changed files with 8 additions and 33 deletions.
diff --git a/app/symbolic_regression_pymodule.cpp b/app/symbolic_regression_pymodule.cpp
@@ -178,10 +178,9 @@ PYBIND11_MODULE(symbolic_regression, m) {
             new (&r) ExplicitRegression(state); });
 
   py::class_<ImplicitRegression>(m, "ImplicitRegression")
-    .def(py::init<ImplicitTrainingData *, int &, bool &, std::string &>(),
+    .def(py::init<ImplicitTrainingData *, int &, std::string &>(),
          py::arg("training_data"),
          py::arg("required_params") = -1,
-         py::arg("normalize_dot") = false,
          py::arg("metric") = "mae")
     .def_property("eval_count",
                   &ImplicitRegression::GetEvalCount,

diff --git a/include/bingocpp/implicit_regression.h b/include/bingocpp/implicit_regression.h
@@ -29,7 +29,7 @@
 #include "bingocpp/utils.h"
 
 typedef std::tuple<Eigen::ArrayXXd, Eigen::ArrayXXd> ImplicitTrainingDataState;
-typedef std::tuple<ImplicitTrainingDataState, std::string, int, bool, int> ImplicitRegressionState;
+typedef std::tuple<ImplicitTrainingDataState, std::string, int, int> ImplicitRegressionState;
 
 
 namespace bingo {
@@ -79,19 +79,16 @@ class ImplicitRegression : public VectorBasedFunction {
  public:
   ImplicitRegression(ImplicitTrainingData *training_data, 
                      int required_params = kNoneRequired,
-                     bool normalize_dot = false,
                      std::string metric="mae") :
       VectorBasedFunction(new ImplicitTrainingData(*training_data), metric) {
     required_params_ = required_params;
-    normalize_dot_ = normalize_dot;
   }
 
   ImplicitRegression(const ImplicitRegressionState &state):
       VectorBasedFunction(new ImplicitTrainingData(std::get<0>(state)),
                           std::get<1>(state)){
     required_params_ = std::get<2>(state);
-    normalize_dot_ = std::get<3>(state);
-    eval_count_ = std::get<4>(state);
+    eval_count_ = std::get<3>(state);
   }
 
   ~ImplicitRegression() {
@@ -104,7 +101,6 @@ class ImplicitRegression : public VectorBasedFunction {
 
  private:
   int required_params_;
-  bool normalize_dot_;
   static const int kNoneRequired = -1;
 };
 

diff --git a/src/implicit_regression.cpp b/src/implicit_regression.cpp
@@ -24,12 +24,10 @@ ImplicitTrainingData *ImplicitTrainingData::GetItem(
 ImplicitRegressionState ImplicitRegression::DumpState() {
   return ImplicitRegressionState(
             ((ImplicitTrainingData*)training_data_)->DumpState(),
-                      metric_, required_params_, normalize_dot_, eval_count_);
+                      metric_, required_params_, eval_count_);
 }
 
-void normalize_by_row(Eigen::ArrayXXd *data_array);
-Eigen::ArrayXXd dfdx_dot_dfdt(bool normalize_dot,
-                              const Eigen::ArrayXXd &dx_dt,
+Eigen::ArrayXXd dfdx_dot_dfdt(const Eigen::ArrayXXd &dx_dt,
                               const Eigen::ArrayXXd &grad);
 bool not_enough_parameters_used(int required_params, 
                                 const Eigen::ArrayXXd &dot_product);
@@ -40,7 +38,6 @@ Eigen::VectorXd ImplicitRegression::EvaluateFitnessVector(
       = individual.EvaluateEquationWithXGradientAt(
       ((ImplicitTrainingData*)training_data_)->x);
   Eigen::ArrayXXd dot_product = dfdx_dot_dfdt(
-      normalize_dot_,
       ((ImplicitTrainingData*)training_data_)->dx_dt,
       eval_and_grad.second);
 
@@ -59,23 +56,10 @@ Eigen::VectorXd ImplicitRegression::EvaluateFitnessVector(
   });
 }
 
-void normalize_by_row(Eigen::ArrayXXd *data_array) {
-  Eigen::ArrayXXd norm_array = data_array->rowwise().norm();
-  for (int i = 0; i < norm_array.rows(); i ++) {
-    data_array->row(i) /= norm_array.row(i)[0];
-  }
-}
-
-Eigen::ArrayXXd dfdx_dot_dfdt(bool normalize_dot,
-                              const Eigen::ArrayXXd &dx_dt,
+Eigen::ArrayXXd dfdx_dot_dfdt(const Eigen::ArrayXXd &dx_dt,
                               const Eigen::ArrayXXd &grad) {
   Eigen::ArrayXXd left_dot = grad;
   Eigen::ArrayXXd right_dot = dx_dt;
-  if (normalize_dot) {
-    normalize_by_row(&left_dot);
-    normalize_by_row(&right_dot);
-  }
-
   return left_dot * right_dot;
 }
 

diff --git a/tests/implicit_regression_tests.cpp b/tests/implicit_regression_tests.cpp
@@ -50,9 +50,7 @@ class ImplicitRegressionTestNormalize : public ImplicitRegressionFixture,
 };
 
 TEST_P(ImplicitRegressionTestNormalize, EvaluateIndividualFitness) {
-  bool normalize_dot_product = GetParam();
-  auto regressor
-      = new ImplicitRegression(training_data_, -1, normalize_dot_product);
+  auto regressor = new ImplicitRegression(training_data_, -1);
   double fitness = regressor->EvaluateIndividualFitness(sum_equation_);
   ASSERT_TRUE(0.14563031020 - fitness < 1e-10);
   delete regressor;
@@ -77,9 +75,7 @@ TEST_P(ImplicitRegressionTestNonNormalized, EvaluateIndividualFitness) {
   auto const &param = GetParam();
   auto required_params = std::get<0>(param);
   auto infinite_fitness = std::get<1>(param);
-  auto regressor = new ImplicitRegression(training_data_,
-                                          required_params,
-                                          infinite_fitness);
+  auto regressor = new ImplicitRegression(training_data_, required_params);
   double fitness = regressor->EvaluateIndividualFitness(sum_equation_);
   ASSERT_TRUE(!std::isfinite(fitness) == infinite_fitness);
   delete regressor;