surrogatestrategy.h

 
#ifndef SURROGATESTRATEGY_H
#define SURROGATESTRATEGY_H
 
#include <libcmaes/eo_matrix.h>
#include <libcmaes/cmastrategy.h>
#include <typeinfo>
#include <random>
 
namespace libcmaes
{
  typedef std::function<int (const std::vector<Candidate>&, const dMat&)> CSurrFunc;
 
  typedef std::function<int (std::vector<Candidate>&, const dMat&)> SurrFunc; //TODO: a signature closer to the objective function signature ?
 
 
  template<template <class U,class V> class TStrategy, class TCovarianceUpdate=CovarianceUpdate,class TGenoPheno=GenoPheno<NoBoundStrategy>>
  class SurrogateStrategy : public TStrategy<TCovarianceUpdate,TGenoPheno>
  {
    public:
    SurrogateStrategy(FitFunc &func,
              CMAParameters<TGenoPheno> &parameters);
 
    protected:
    ~SurrogateStrategy();
 
    public:
    int train(const std::vector<Candidate> &candidates,
          const dMat &cov) { return _train(candidates,cov); }
 
    int predict(std::vector<Candidate> &candidates,
        const dMat &cov) { return _predict(candidates,cov); }
 
    double compute_error(const std::vector<Candidate> &test_set,
             const dMat &cov=dMat(0,0));
    
    bool do_train() const { return true; };
 
    void set_ftrain(const CSurrFunc &train) { _train = train; }
 
    void set_fpredict(const SurrFunc &predict) { _predict = predict; }
 
    void set_l(const int &l) { _l = l; }
 
    int get_l() const { return _l; }
 
    void set_exploit(const bool &exploit) { _exploit = exploit; }
 
    bool get_exploit() const { return _exploit; }
 
    double get_train_error() const { return _train_err; }
 
    double get_test_error() const { return _test_err; }
 
    void set_train_error(const double &err) { _train_err = err; }
 
    void set_test_error(const double &err);
    
    void add_to_training_set(const Candidate &c);
 
    inline void set_nsteps(const int &nsteps)
    {
      _nsteps = nsteps;
      if (_nsteps < 0)
    _auto_nsteps = true;
    }
 
    inline void reset_training_set()
    {
      _tset.clear();
      _train_err = _test_err = 0.0;
      _smooth_test_err = 0.5;
    }
    
    int get_nsteps() const { return _nsteps; }
    
  protected:
    bool _exploit = true; 
    int _l = 200; 
    std::vector<Candidate> _tset; 
    CSurrFunc _train; 
    SurrFunc _predict; 
    double _train_err = 0.0; 
    double _test_err = 0.0; 
    double _smooth_test_err = 0.5; 
    double _beta_err = 0.2; 
    int _nsteps = 1; 
    int _auto_nsteps = false; 
    };
 
  template<template <class U,class V> class TStrategy, class TCovarianceUpdate=CovarianceUpdate,class TGenoPheno=GenoPheno<NoBoundStrategy>>
    class SimpleSurrogateStrategy : public SurrogateStrategy<TStrategy,TCovarianceUpdate,TGenoPheno>
    {
    public:
    SimpleSurrogateStrategy(FitFunc &func,
                CMAParameters<TGenoPheno> &parameters);
 
    ~SimpleSurrogateStrategy();
 
    void eval(const dMat &candidates,
          const dMat &phenocandidates=dMat(0,0));
 
    void tell();
 
    int optimize();
    
    int compute_lifelength();
    
    inline bool do_train() const
    {
      if (!SurrogateStrategy<TStrategy,TCovarianceUpdate,TGenoPheno>::_exploit && (int)this->_tset.size() >= this->_l)
    return true;
      return ((this->_niter == 0 || this->_niter % this->_nsteps == 0) && (int)this->_tset.size() >= this->_l);
    }
 
    public:
    double _terr = 0.45; 
    int _nmax = 20;
    };
 
  template<template <class U,class V> class TStrategy, class TCovarianceUpdate=CovarianceUpdate,class TGenoPheno=GenoPheno<NoBoundStrategy>>
    class ACMSurrogateStrategy : public SurrogateStrategy<TStrategy,TCovarianceUpdate,TGenoPheno>
    {
    public:
    ACMSurrogateStrategy(FitFunc &func,
             CMAParameters<TGenoPheno> &parameters);
    
    ~ACMSurrogateStrategy();
    
    dMat ask();
 
    void eval(const dMat &candidates,
          const dMat &phenocandidates=dMat(0,0));
 
    void tell();
 
    int optimize();
    
    protected:
    void pre_selection_eval(const dMat &candidates);
    
    public:
    inline bool do_train() const
    {
      if (!SurrogateStrategy<TStrategy,TCovarianceUpdate,TGenoPheno>::_exploit && (int)this->_tset.size() >= this->_l)
    return true;
      else if (SurrogateStrategy<TStrategy,TCovarianceUpdate,TGenoPheno>::_exploit && (int)this->_tset.size() >= this->_l)
    return true;
      return ((this->_niter == 0 || this->_niter % this->_nsteps == 0) && (int)this->_tset.size() >= this->_l);
    }
 
    private:
    void init_rd(); // initialize random device.
 
    public:
    void set_lambdaprime(const int &lp) { _lambdaprime = lp; }
 
    int get_lambdaprime() const { return _lambdaprime; }
 
    void set_prelambda(const int &pl) { _prelambda = pl; }
 
    int get_prelambda() const { return _prelambda; }
    
    void set_theta_sel0(const double &s) { _theta_sel0 = s; }
    
    double get_theta_sel0() const { return _theta_sel0; }
 
    void set_theta_sel1(const double &s) { _theta_sel1 = s; }
 
    double get_theta_sel1() const { return _theta_sel1; }
 
    protected:
    double _prelambda = 500; 
    double _theta_sel0 = 0.4;  
    double _theta_sel1 = 0.8;  
    int _lambdaprime; 
    private:
    // random numbers for selection sampling
    std::random_device _rd;
    std::normal_distribution<double> _norm_sel0;
    std::normal_distribution<double> _norm_sel1;
    std::mt19937 _gen0;
    std::mt19937 _gen1;
  };
}
 
#endif