FunctionApproximator.hpp

Go to the documentation of this file.

#ifndef _FUNCTIONAPPROXIMATOR_H_
#define _FUNCTIONAPPROXIMATOR_H_

#include "Parameterizable.hpp"

#include <boost/serialization/nvp.hpp>

#include <string>
#include <vector>
#include <eigen3/Eigen/Core>

namespace DmpBbo {
  
// Forward declarations
class MetaParameters;
class ModelParameters;
class UnifiedModel;

class FunctionApproximator : public Parameterizable
{

public:
  
  FunctionApproximator(const MetaParameters *const meta_parameters, const ModelParameters *const model_parameters=NULL);
  
  FunctionApproximator(const ModelParameters *const model_parameters);

  virtual ~FunctionApproximator(void);
  
  virtual FunctionApproximator* clone(void) const = 0;
  
  virtual void train(
    const Eigen::Ref<const Eigen::MatrixXd>& inputs, 
    const Eigen::Ref<const Eigen::MatrixXd>& targets) = 0;
  
  void train(
    const Eigen::Ref<const Eigen::MatrixXd>& inputs, 
    const Eigen::Ref<const Eigen::MatrixXd>& targets, 
    std::string save_directory, 
    bool overwrite=false);

  void reTrain(
    const Eigen::Ref<const Eigen::MatrixXd>& inputs, 
    const Eigen::Ref<const Eigen::MatrixXd>& targets);
  
  void reTrain(
    const Eigen::Ref<const Eigen::MatrixXd>& inputs, 
    const Eigen::Ref<const Eigen::MatrixXd>& targets, 
    std::string save_directory, 
    bool overwrite=false);
  
  virtual void predict(
    const Eigen::Ref<const Eigen::MatrixXd>& inputs, 
    Eigen::MatrixXd& outputs) = 0;

  virtual void predict(
    const Eigen::Ref<const Eigen::MatrixXd>& inputs, 
    Eigen::MatrixXd& outputs,
    Eigen::MatrixXd& variances)
  {
    predict(inputs, outputs);
    variances.fill(0);
  }

  virtual void predict(
    const Eigen::Ref<const Eigen::MatrixXd>& inputs, 
    Eigen::MatrixXd& outputs, 
    std::vector<Eigen::MatrixXd>& variances)
  {
    predict(inputs, outputs);
    for (unsigned int i=0; i<variances.size(); i++)
      variances[i].fill(0);
  }

  
  virtual void predictVariance(
    const Eigen::Ref<const Eigen::MatrixXd>& inputs,
    Eigen::MatrixXd& variances)
  {
    variances.fill(0);
  }
  
  bool isTrained(void) const
  {
    return (model_parameters_!=NULL);
  }
  
  int getExpectedInputDim(void) const;
  
  int getExpectedOutputDim(void) const;
  
  virtual std::string getName(void) const = 0;
  
  void getSelectableParameters(std::set<std::string>& selected_values_labels) const;
  void setSelectedParameters(const std::set<std::string>& selected_values_labels);
  void getParameterVectorSelectedMinMax(Eigen::VectorXd& min, Eigen::VectorXd& max) const;
  int getParameterVectorSelectedSize(void) const;
  void setParameterVectorSelected(const Eigen::VectorXd& values, bool normalized=false);
  void getParameterVectorSelected(Eigen::VectorXd& values, bool normalized=false) const;

  void getParameterVectorMask(const std::set<std::string> selected_values_labels, Eigen::VectorXi& selected_mask) const;
  int getParameterVectorAllSize(void) const;
  void getParameterVectorAll(Eigen::VectorXd& values) const;
  void setParameterVectorAll(const Eigen::VectorXd& values);

  UnifiedModel* getUnifiedModel(void) const;
  
  friend std::ostream& operator<<(std::ostream& output, const FunctionApproximator& function_approximator) {
    output << function_approximator.toString();
    return output;
  }
  
  std::string toString(void) const;
  
  
  const MetaParameters* getMetaParameters(void) const;
  
  const ModelParameters* getModelParameters(void) const;
  
  void setParameterVectorModifierPrivate(std::string modifier, bool new_value);
  
  static void generateInputsGrid(const Eigen::VectorXd& min, const Eigen::VectorXd& max, const Eigen::VectorXi& n_samples_per_dim, Eigen::MatrixXd& inputs_grid);
  
        virtual bool saveGridData(const Eigen::VectorXd& min, const Eigen::VectorXd& max, const Eigen::VectorXi& n_samples_per_dim, std::string directory, bool overwrite=false) const;
        
protected:

  void setModelParameters(ModelParameters* model_parameters);
  
  
  FunctionApproximator(void) {};
  
        
private:
  
  MetaParameters*  meta_parameters_;
  
  ModelParameters* model_parameters_;
  
  bool checkModelParametersInitialized(void) const;
 
  friend class boost::serialization::access;
  
  template<class Archive>
  void serialize(Archive & ar, const unsigned int version)
  {
    // serialize base class information
    ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Parameterizable);
    
    ar & BOOST_SERIALIZATION_NVP(meta_parameters_);
    ar & BOOST_SERIALIZATION_NVP(model_parameters_);
  }

};

}


#include <boost/serialization/assume_abstract.hpp>
BOOST_SERIALIZATION_ASSUME_ABSTRACT(DmpBbo::FunctionApproximator);
 
#include <boost/serialization/export.hpp>
BOOST_CLASS_IMPLEMENTATION(DmpBbo::FunctionApproximator,boost::serialization::object_serializable);

#endif // _FUNCTIONAPPROXIMATOR_H_