Remove Parameter Serialization.

.gitmodules

@@ -1,18 +1,18 @@
 [submodule "third_party/eigen"]
 	path = third_party/eigen
 	url = https://github.com/PX4/eigen.git
-[submodule "third_party/yaml-cpp"]
-	path = third_party/yaml-cpp
-	url = https://github.com/jbeder/yaml-cpp.git
 [submodule "third_party/gflags"]
 	path = third_party/gflags
 	url = https://github.com/gflags/gflags.git
-[submodule "third_party/rapidcheck"]
-	path = third_party/rapidcheck
-	url = https://github.com/emil-e/rapidcheck.git
 [submodule "third_party/googletest"]
 	path = third_party/googletest
 	url = https://github.com/google/googletest.git
 [submodule "third_party/fast-cpp-csv-parser"]
 	path = third_party/fast-cpp-csv-parser
 	url = https://github.com/ben-strasser/fast-cpp-csv-parser.git
+[submodule "third_party/cereal"]
+	path = third_party/cereal
+	url = https://github.com/USCiLab/cereal.git
+[submodule "third_party/Optional"]
+	path = third_party/Optional
+	url = https://github.com/akrzemi1/Optional.git

CMakeLists.txt

@@ -2,8 +2,6 @@ project(albatross)
 cmake_minimum_required(VERSION 2.8.7)
 
 set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake")
-include(ClangTools)
-include(SanitizeTargets)
 
 # Enable Clang auto-formatting, defaults to on. 
 option(ENABLE_AUTOFORMAT "Enable automatic formatting and replacement with clang-format." ON)
@@ -13,12 +11,11 @@ option(ENABLE_AUTOLINT "Enable automatic linting and warning with clang-tidy. "
 option(ENABLE_STACK_ANALYSIS "Enable stack analysis. Requires gcc." OFF)
 
 add_subdirectory(third_party/googletest)
-add_subdirectory(third_party/rapidcheck)
-add_subdirectory(third_party/rapidcheck/extras/gtest)
 
 include_directories(SYSTEM ${gtest_SOURCE_DIR} ${gtest_SOURCE_DIR}/include)
 include_directories(SYSTEM "${PROJECT_SOURCE_DIR}/third_party/eigen/")
-include_directories(SYSTEM "${PROJECT_SOURCE_DIR}/third_party/yaml-cpp/include")
+include_directories(SYSTEM "${PROJECT_SOURCE_DIR}/third_party/cereal/include")
+include_directories(SYSTEM "${PROJECT_SOURCE_DIR}/third_party/Optional/")
 include_directories(SYSTEM "${PROJECT_SOURCE_DIR}/third_party/fast-cpp-csv-parser/")
 
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -fexceptions -frtti")
@@ -27,7 +24,6 @@ set(CMAKE_CXX_FLAGS "-std=c++14 -Wshadow -Wswitch-default -Wswitch-enum -Wundef
 
 include_directories("${PROJECT_SOURCE_DIR}/albatross")
 include(${PROJECT_SOURCE_DIR}/cmake/FindGFlags.cmake)
-include(${PROJECT_SOURCE_DIR}/cmake/FindYaml-Cpp.cmake)
 
 set(albatross_SRCS
 CACHE INTERNAL ""
@@ -40,13 +36,14 @@ set(albatross_HEADERS
     albatross/covariance_functions/noise.h
     albatross/covariance_functions/polynomials.h
     albatross/covariance_functions/radial.h
-    albatross/gp/gp.h
+    albatross/models/gp.h
     albatross/core/keys.h
     albatross/core/model.h
     albatross/core/static_inspection.h
     albatross/core/parameter_handling_mixin.h    
     albatross/evaluate.h    
     albatross/map_utils.h
+    tests/test_utils.h
     CACHE INTERNAL ""
 )
 

albatross/core/model.h

@@ -16,9 +16,13 @@
 #include <Eigen/Core>
 #include <map>
 #include <vector>
+#include "optional.hpp"
 #include "map_utils.h"
+#include "static_inspection.h"
 #include "parameter_handling_mixin.h"
 
+using std::experimental::optional;
+
 namespace albatross {
 
 struct PredictionDistribution {
@@ -39,12 +43,12 @@ struct PredictionDistribution {
  * it is assumed that each feature is regressed to a single double typed
  * target.
  */
-template <class Feature>
+template <class FeatureType>
 struct RegressionDataset {
-  std::vector<Feature> features;
+  std::vector<FeatureType> features;
   Eigen::VectorXd targets;
 
-  RegressionDataset(const std::vector<Feature> &features_,
+  RegressionDataset(const std::vector<FeatureType> &features_,
                     const Eigen::VectorXd &targets_)
       : features(features_), targets(targets_) {
     // If the two inputs aren't the same size they clearly aren't
@@ -63,15 +67,15 @@ using FoldIndexer = std::map<FoldName, FoldIndices>;
  * A combination of training and testing datasets, typically used in cross
  * validation.
  */
-template <class Feature>
+template <class FeatureType>
 struct RegressionFold {
-  RegressionDataset<Feature> train;
-  RegressionDataset<Feature> test;
+  RegressionDataset<FeatureType> train;
+  RegressionDataset<FeatureType> test;
   FoldName name;
   FoldIndices test_indices;
 
-  RegressionFold(const RegressionDataset<Feature> &train_,
-                 const RegressionDataset<Feature> &test_,
+  RegressionFold(const RegressionDataset<FeatureType> &train_,
+                 const RegressionDataset<FeatureType> &test_,
                  const FoldName &name_, const FoldIndices &test_indices_)
       : train(train_), test(test_), name(name_), test_indices(test_indices_){};
 };
@@ -80,30 +84,32 @@ struct RegressionFold {
  * A model that uses a single Feature to estimate the value of a double typed
  * target.
  */
-template <class Feature>
+template <class FeatureType, class ModelFit>
 class RegressionModel : public ParameterHandlingMixin {
  public:
-  RegressionModel() : ParameterHandlingMixin(), has_been_fit_(false){};
+  typedef FeatureType Feature;
+  RegressionModel() : ParameterHandlingMixin(), model_fit_() {};
   virtual ~RegressionModel(){};
 
   /*
    * Provides a wrapper around the implementation `fit_` which performs
    * simple size checks and makes sure the fit method is called before
    * predict.
    */
-  void fit(const std::vector<Feature> &features,
+  ModelFit fit(const std::vector<FeatureType> &features,
            const Eigen::VectorXd &targets) {
     assert(static_cast<s32>(features.size()) ==
            static_cast<s32>(targets.size()));
-    fit_(features, targets);
-    has_been_fit_ = true;
+    auto model_fit = fit_(features, targets);
+    model_fit_ = model_fit;
+    return model_fit;
   }
 
   /*
    * Convenience function which unpacks a dataset into features and targets.
    */
-  void fit(const RegressionDataset<Feature> &dataset) {
-    fit(dataset.features, dataset.targets);
+  ModelFit fit(const RegressionDataset<FeatureType> &dataset) {
+    return fit(dataset.features, dataset.targets);
   }
 
   /*
@@ -112,8 +118,8 @@ class RegressionModel : public ParameterHandlingMixin {
    * properly sized PredictionDistributions.
    */
   PredictionDistribution predict(
-      const std::vector<Feature> &features) const {
-    assert(has_been_fit_);
+      const std::vector<FeatureType> &features) const {
+    assert(model_fit_);
     PredictionDistribution preds = predict_(features);
     assert(static_cast<s32>(preds.mean.size()) ==
            static_cast<s32>(features.size()));
@@ -127,9 +133,9 @@ class RegressionModel : public ParameterHandlingMixin {
    * some models.
    */
   PredictionDistribution fit_and_predict(
-      const std::vector<Feature> &train_features,
+      const std::vector<FeatureType> &train_features,
       const Eigen::VectorXd &train_targets,
-      const std::vector<Feature> &test_features) {
+      const std::vector<FeatureType> &test_features) {
     // Fit using the training data, then predict with the test.
     fit(train_features, train_targets);
     return predict(test_features);
@@ -140,24 +146,31 @@ class RegressionModel : public ParameterHandlingMixin {
    * in a RegressionFold struct
    */
   PredictionDistribution fit_and_predict(
-      const RegressionFold<Feature> &fold) {
+      const RegressionFold<FeatureType> &fold) {
     return fit_and_predict(fold.train.features, fold.train.targets,
                            fold.test.features);
   }
 
+  virtual std::string get_name() const = 0;
+
  protected:
-  virtual void fit_(const std::vector<Feature> &features,
-                    const Eigen::VectorXd &targets) = 0;
+  /*
+   * These methods are required from an implmenting class, notice that
+   * the methods are marked `const`.  Anything that needs to be stored
+   * in the model should be returned in the `ModelFit` type.
+   */
+  virtual ModelFit fit_(const std::vector<FeatureType> &features,
+                          const Eigen::VectorXd &targets) const = 0;
 
   virtual PredictionDistribution predict_(
-      const std::vector<Feature> &features) const = 0;
+      const std::vector<FeatureType> &features) const = 0;
 
-  bool has_been_fit_ = false;
+  optional<ModelFit> model_fit_;
 };
 
-template <class Feature>
+template <class FeatureType, class ModelFit>
 using RegressionModelCreator =
-    std::function<std::unique_ptr<RegressionModel<Feature>>()>;
+    std::function<std::unique_ptr<RegressionModel<FeatureType, ModelFit>>()>;
 }
 
 #endif

albatross/core/parameter_handling_mixin.h

@@ -13,7 +13,6 @@
 #ifndef ALBATROSS_CORE_PARAMETER_HANDLING_MIXIN_H
 #define ALBATROSS_CORE_PARAMETER_HANDLING_MIXIN_H
 
-#include <yaml-cpp/yaml.h>
 #include <fstream>
 #include <iostream>
 #include <map>
@@ -34,50 +33,6 @@ class ParameterHandlingMixin {
 
   virtual ~ParameterHandlingMixin(){};
 
-  virtual std::string get_name() const = 0;
-
-  YAML::Node to_yaml() const {
-    YAML::Node yaml_model;
-    yaml_model[keys::YAML_MODEL_NAME] = get_name();
-
-    YAML::Node yaml_params;
-    for (const auto &pair : get_params()) {
-      yaml_params[pair.first] = pair.second;
-    }
-    yaml_model[keys::YAML_MODEL_PARAMS] = yaml_params;
-    return yaml_model;
-  }
-
-  std::string to_string() const { return YAML::Dump(to_yaml()); }
-
-  void to_file(const std::string &path) const {
-    std::ofstream output_file;
-    output_file.open(path);
-    output_file << to_string();
-    output_file.close();
-  }
-
-  void from_string(const std::string &serialized_string) {
-    // Load the YAML config file
-    const YAML::Node yaml_params = YAML::Load(serialized_string);
-    from_yaml(yaml_params);
-  }
-
-  void from_yaml(const YAML::Node &yaml_input) {
-    YAML::Node yaml_params = yaml_input;
-    if (YAML::Node model_name = yaml_params[keys::YAML_MODEL_NAME]) {
-      assert(model_name.as<std::string>() == get_name());
-      yaml_params = yaml_params[keys::YAML_MODEL_PARAMS].as<YAML::Node>();
-    }
-
-    ParameterStore params;
-    for (YAML::const_iterator it = yaml_params.begin(); it != yaml_params.end();
-         ++it) {
-      params[it->first.as<ParameterKey>()] = it->second.as<ParameterValue>();
-    }
-    set_params(params);
-  }
-
   /*
    * Provides a safe interface to the parameter values
    */
@@ -98,10 +53,9 @@ class ParameterHandlingMixin {
    * Prints out a set of parameters in a way that is both
    * readable and can be easily copy/pasted into code.
    */
-  std::string pretty_params() {
+  std::string to_string() const {
     std::stringstream ss;
-    ss << "name = " << get_name() << std::endl;
-    ss << "params = {" << std::endl;
+    ss << "{" << std::endl;
     for (const auto &pair : get_params()) {
       ss << "    {\"" << pair.first << "\", " << pair.second << "},"
          << std::endl;
@@ -152,6 +106,7 @@ class ParameterHandlingMixin {
  protected:
   ParameterStore params_;
 };
+
 }
 
 #endif

albatross/covariance_functions/covariance_functions.h

@@ -68,25 +68,14 @@ struct CovarianceFunction {
    */
 
   inline auto get_name() const { return covariance_term.get_name(); };
-  inline auto to_string() const { return covariance_term.to_string(); };
   inline auto get_params() const { return covariance_term.get_params(); };
-  inline auto to_yaml() const { return covariance_term.to_yaml(); };
-  inline auto to_file(const std::string &path) const {
-    return covariance_term.to_file(path);
-  };
-  inline auto from_string(const std::string &serialized_string) {
-    return covariance_term.from_string(serialized_string);
-  };
-  inline auto from_yaml(const YAML::Node &yaml_input) {
-    return covariance_term.from_yaml(yaml_input);
-  }
   inline auto set_params(const ParameterStore &params) {
     return covariance_term.set_params(params);
   };
   inline auto set_param(const ParameterKey &key, const ParameterValue &value) {
     return covariance_term.set_param(key, value);
   };
-  inline auto pretty_params() const { return covariance_term.pretty_params(); };
+  inline auto to_string() const { return covariance_term.to_string(); };
   inline auto get_params_as_vector() const {
     return covariance_term.get_params_as_vector();
   };

albatross/covariance_functions/covariance_term.h

@@ -29,6 +29,8 @@ class CovarianceTerm : public ParameterHandlingMixin {
  public:
   CovarianceTerm() : ParameterHandlingMixin(){};
   virtual ~CovarianceTerm(){};
+
+  virtual std::string get_name() const = 0;
 };
 
 /*

albatross/covariance_functions/distance_metrics.h

@@ -23,6 +23,7 @@ class DistanceMetric : public ParameterHandlingMixin {
   DistanceMetric(){};
   virtual ~DistanceMetric(){};
 
+ virtual std::string get_name() const = 0;
  protected:
 };