lambda_f.h

Go to the documentation of this file.

 
#if !defined(VITA_LAMBDA_F_H)
#define      VITA_LAMBDA_F_H
 
#include <type_traits>
 
#include "kernel/exceptions.h"
#include "kernel/gp/src/dataframe.h"
#include "kernel/gp/src/interpreter.h"
#include "kernel/gp/src/model_metric.h"
#include "kernel/gp/team.h"
#include "utility/discretization.h"
 
#include "kernel/gp/detail/lambda_f.h"
 
namespace vita
{
 
class basic_lambda_f
{
public:
  virtual ~basic_lambda_f() = default;
 
  virtual value_t operator()(const dataframe::example &) const = 0;
 
  virtual bool is_valid() const = 0;
};
 
// Forward declarations.
namespace serialize
{
 
namespace lambda
{
 
template<class T = i_mep> std::unique_ptr<basic_src_lambda_f> load(
  std::istream &, const symbol_set &);
 
}  // namespace lambda
 
bool save(std::ostream &, const basic_src_lambda_f *);
bool save(std::ostream &, const basic_src_lambda_f &);
bool save(std::ostream &, const std::unique_ptr<basic_src_lambda_f> &);
 
}  // namespace serialize
 
struct classification_result
{
  class_t   label;   
  double sureness;   
};
 
class basic_src_lambda_f : public basic_lambda_f
{
public:
  virtual double measure(const model_metric &, const dataframe &) const = 0;
  virtual std::string name(const value_t &) const = 0;
  virtual classification_result tag(const dataframe::example &) const = 0;
 
private:
  // *** Serialization ***
  virtual std::string serialize_id() const = 0;
  virtual bool save(std::ostream &) const = 0;
 
  template<class T> friend std::unique_ptr<basic_src_lambda_f>
  serialize::lambda::load(std::istream &, const symbol_set &);
  friend bool serialize::save(std::ostream &, const basic_src_lambda_f *);
};
 
// ***********************************************************************
// * Symbolic regression                                                 *
// ***********************************************************************
 
class core_reg_lambda_f : public basic_src_lambda_f {};
 
template<class T, bool S>
class basic_reg_lambda_f : public core_reg_lambda_f,
                           protected detail::reg_lambda_f_storage<T, S>
{
public:
  explicit basic_reg_lambda_f(const T &);
  basic_reg_lambda_f(std::istream &, const symbol_set &);
 
  value_t operator()(const dataframe::example &) const final;
 
  std::string name(const value_t &) const final;
 
  double measure(const model_metric &, const dataframe &) const final;
 
  bool is_valid() const final;
 
  // *** Serialization ***
  static const std::string SERIALIZE_ID;
  bool save(std::ostream &) const final;
 
private:
  // Not useful for regression tasks and moved to private section.
  classification_result tag(const dataframe::example &) const final;
 
  std::string serialize_id() const final { return SERIALIZE_ID; }
 
  value_t eval(const dataframe::example &, std::false_type) const;
  value_t eval(const dataframe::example &, std::true_type) const;
};
 
// ***********************************************************************
// * Classification                                                      *
// ***********************************************************************
 
enum class team_composition
{
  mv,  // majority voting
  wta, // winner takes all
 
  standard = wta
};
 
class core_class_lambda_f : public basic_src_lambda_f {};
 
template<bool N>
class basic_class_lambda_f : public core_class_lambda_f,
                             protected detail::class_names<N>
{
public:
  explicit basic_class_lambda_f(const dataframe &);
 
  value_t operator()(const dataframe::example &) const final;
 
  std::string name(const value_t &) const final;
 
  double measure(const model_metric &, const dataframe &) const final;
 
protected:
  basic_class_lambda_f() = default;
};
 
template<class T, bool S, bool N>
class basic_dyn_slot_lambda_f : public basic_class_lambda_f<N>
{
public:
  basic_dyn_slot_lambda_f(const T &, dataframe &, unsigned);
  basic_dyn_slot_lambda_f(std::istream &, const symbol_set &);
 
  classification_result tag(const dataframe::example &) const final;
 
  bool is_valid() const final;
 
  double training_accuracy() const;
 
  // *** Serialization ***
  static const std::string SERIALIZE_ID;
  bool save(std::ostream &) const final;
 
private:
  // *** Private support methods ***
  void fill_matrix(dataframe &, unsigned);
  std::size_t slot(const dataframe::example &) const;
 
  std::string serialize_id() const final { return SERIALIZE_ID; }
 
  // *** Private data members ***
  basic_reg_lambda_f<T, S> lambda_;
 
  matrix<unsigned> slot_matrix_;
 
  std::vector<class_t> slot_class_;
 
  std::size_t dataset_size_;
};
 
template<class T, bool S, bool N>
class basic_gaussian_lambda_f : public basic_class_lambda_f<N>
{
public:
  basic_gaussian_lambda_f(const T &, dataframe &);
  basic_gaussian_lambda_f(std::istream &, const symbol_set &);
 
  classification_result tag(const dataframe::example &) const final;
 
  bool is_valid() const final;
 
  // *** Serialization ***
  static const std::string SERIALIZE_ID;
  bool save(std::ostream &) const final;
 
private:
  // *** Private support methods ***
  void fill_vector(dataframe &);
  bool load_(std::istream &, const symbol_set &, std::true_type);
  bool load_(std::istream &, const symbol_set &, std::false_type);
 
  std::string serialize_id() const final { return SERIALIZE_ID; }
 
  // *** Private data members ***
  basic_reg_lambda_f<T, S> lambda_;
 
  // gauss_dist[i] = "the gaussian distribution of the i-th class if the
  // classification problem".
  std::vector<distribution<number>> gauss_dist_;
};
 
template<class T, bool S, bool N>
class basic_binary_lambda_f : public basic_class_lambda_f<N>
{
public:
  basic_binary_lambda_f(const T &, dataframe &);
  basic_binary_lambda_f(std::istream &, const symbol_set &);
 
  classification_result tag(const dataframe::example &) const final;
 
  bool is_valid() const final;
 
  // *** Serialization ***
  static const std::string SERIALIZE_ID;
  bool save(std::ostream &) const final;
 
private:
  std::string serialize_id() const final { return SERIALIZE_ID; }
 
  basic_reg_lambda_f<T, S> lambda_;
};
 
// ***********************************************************************
// * Extensions to support teams                                          *
// ***********************************************************************
 
template<class T, bool S, bool N, template<class, bool, bool> class L,
         team_composition C = team_composition::standard>
class team_class_lambda_f : public basic_class_lambda_f<N>
{
public:
  template<class... Args> team_class_lambda_f(const team<T> &, dataframe &,
                                              Args &&...);
  team_class_lambda_f(std::istream &, const symbol_set &);
 
  classification_result tag(const dataframe::example &) const final;
 
  bool is_valid() const final;
 
  static const std::string SERIALIZE_ID;
 
private:
  bool save(std::ostream &) const final;
  std::string serialize_id() const final;
 
  // The components of the team never store the names of the classes. If we
  // need the names, the master class will memorize them.
  std::vector<L<T, S, false>> team_;
 
  class_t classes_;
};
 
template<class T, bool S, bool N>
class basic_dyn_slot_lambda_f<team<T>, S, N>
  : public team_class_lambda_f<T, S, N, basic_dyn_slot_lambda_f>
{
public:
  using basic_dyn_slot_lambda_f::team_class_lambda_f::team_class_lambda_f;
};
 
template<class T, bool S, bool N>
class basic_gaussian_lambda_f<team<T>, S, N>
  : public team_class_lambda_f<T, S, N, basic_gaussian_lambda_f>
{
public:
  using basic_gaussian_lambda_f::team_class_lambda_f::team_class_lambda_f;
};
 
template<class T, bool S, bool N>
class basic_binary_lambda_f<team<T>, S, N>
  : public team_class_lambda_f<T, S, N, basic_binary_lambda_f>
{
public:
  using basic_binary_lambda_f::team_class_lambda_f::team_class_lambda_f;
};
 
// ***********************************************************************
// *  Template aliases to simplify the syntax and help the user          *
// ***********************************************************************
template<class T>
using reg_lambda_f = basic_reg_lambda_f<T, true>;
 
template<class T>
using dyn_slot_lambda_f = basic_dyn_slot_lambda_f<T, true, true>;
 
template<class T>
using gaussian_lambda_f = basic_gaussian_lambda_f<T, true, true>;
 
template<class T>
using binary_lambda_f = basic_binary_lambda_f<T, true, true>;
 
#include "kernel/gp/src/lambda_f.tcc"
}  // namespace vita
 
#endif  // include guard