gp/src/evaluator.h

Go to the documentation of this file.

 
#if !defined(VITA_SRC_EVALUATOR_H)
#define      VITA_SRC_EVALUATOR_H
 
#include "kernel/evaluator.h"
#include "kernel/gp/src/detail/evaluator.h"
 
namespace vita
{
 
template<class T, class DAT = dataframe>
class src_evaluator : public evaluator<T>
{
public:
  static_assert(detail::is_iterable_v<DAT>);
 
  explicit src_evaluator(DAT &);
 
protected:
  DAT *dat_;
};
 
template<class T, class ERRF, class DAT = dataframe>
class sum_of_errors_evaluator : public src_evaluator<T, DAT>
{
public:
  static_assert(std::is_class_v<ERRF>);
  static_assert(detail::is_iterable_v<DAT>);
  static_assert(detail::is_error_functor_v<ERRF, DAT>);
 
  explicit sum_of_errors_evaluator(DAT &);
 
  fitness_t operator()(const T &) override;
  fitness_t fast(const T &) override;
  std::unique_ptr<basic_lambda_f> lambdify(const T &) const override;
 
private:
  fitness_t sum_of_errors_impl(const T &, unsigned);
};
 
template<class T>
class mae_error_functor
{
public:
  mae_error_functor(const T &);
 
  double operator()(const dataframe::example &) const;
 
private:
  basic_reg_lambda_f<T, false> agent_;
};
 
template<class T, class ERRF = mae_error_functor<T>>
class mae_evaluator : public sum_of_errors_evaluator<T, ERRF>
{
public:
  using sum_of_errors_evaluator<T, ERRF>::sum_of_errors_evaluator;
};
 
template<class T>
class rmae_error_functor
{
public:
  explicit rmae_error_functor(const T &);
 
  double operator()(const dataframe::example &) const;
 
private:
  basic_reg_lambda_f<T, false> agent_;
};
 
template<class T, class ERRF = rmae_error_functor<T>>
class rmae_evaluator : public sum_of_errors_evaluator<T, ERRF>
{
public:
  using sum_of_errors_evaluator<T, ERRF>::sum_of_errors_evaluator;
};
 
template<class T>
class mse_error_functor
{
public:
  explicit mse_error_functor(const T &);
 
  double operator()(const dataframe::example &) const;
 
private:
  basic_reg_lambda_f<T, false> agent_;
};
 
template<class T, class ERRF = mse_error_functor<T>>
class mse_evaluator : public sum_of_errors_evaluator<T, ERRF>
{
public:
  using sum_of_errors_evaluator<T, ERRF>::sum_of_errors_evaluator;
};
 
template<class T>
class count_error_functor
{
public:
  explicit count_error_functor(const T &);
 
  double operator()(const dataframe::example &) const;
 
private:
  basic_reg_lambda_f<T, false> agent_;
};
 
template<class T, class ERRF = count_error_functor<T>>
class count_evaluator : public sum_of_errors_evaluator<T, ERRF>
{
public:
  using sum_of_errors_evaluator<T, ERRF>::sum_of_errors_evaluator;
};
 
template<class T>
class classification_evaluator : public src_evaluator<T>
{
public:
  explicit classification_evaluator(dataframe &d) : src_evaluator<T>(d) {}
};
 
template<class T>
class dyn_slot_evaluator : public classification_evaluator<T>
{
public:
  explicit dyn_slot_evaluator(dataframe &, unsigned = 10);
 
  fitness_t operator()(const T &) override;
  std::unique_ptr<basic_lambda_f> lambdify(const T &) const override;
 
private:
  unsigned x_slot_;
};
 
template<class T>
class gaussian_evaluator : public classification_evaluator<T>
{
public:
  explicit gaussian_evaluator(dataframe &d) : classification_evaluator<T>(d) {}
 
  fitness_t operator()(const T &) override;
  std::unique_ptr<basic_lambda_f> lambdify(const T &) const override;
};
 
template<class T>
class binary_evaluator : public classification_evaluator<T>
{
public:
  explicit binary_evaluator(dataframe &d) : classification_evaluator<T>(d) {}
 
  fitness_t operator()(const T &) override;
  std::unique_ptr<basic_lambda_f> lambdify(const T &) const override;
};
 
#include "kernel/gp/src/evaluator.tcc"
}  // namespace vita
 
#endif  // include guard