Learner.hpp

//
// Created by Mateus Coutinho Mari on 9/7/2018.
//
 
#pragma once
 
#include "Solution.hpp"
#include "Data.hpp"
#include "Timer.hpp"
 
namespace mltk{
    template <typename T>
    class Learner;
    
    template < class T > using LearnerPointer = std::shared_ptr<mltk::Learner< T > >;
    
    template < typename T = double >
    class  Learner {
    protected:
      std::shared_ptr<Data< T > > samples;
      double rate = 0.5f;
      double start_time = 0.0f;
      double max_time = 110;
      int steps = 0;
      int ctot = 0;
      double EPS = 0.0000001;
      double MIN_INC = 1.001;
      int MAX_IT = 1E9;
      int MAX_UP = 1E9;
      int MAX_EPOCH = 1E9;
      int verbose = 1;
      Timer timer = Timer();
      size_t seed = 0;
      double pred_prob = 1.0;
    
    public:
      virtual ~Learner() = default;
    
      Learner< T >() = default;
    
      explicit Learner< T > (DataPointer< T > _samples): samples(_samples) {}
    
      Learner< T > (const Learner< T > &learner){
        this->samples = learner.samples;
        this->EPS = learner.EPS;
        this->rate = learner.rate;
        this->start_time = learner.start_time;
        this->max_time = learner.max_time;
        this->steps = learner.steps;
        this->ctot = learner.ctot;
        this->MIN_INC = learner.MIN_INC;
        this->MAX_IT = learner.MAX_IT;
        this->MAX_UP = learner.MAX_UP;
        this->MAX_EPOCH = learner.MAX_EPOCH;
        this->verbose = learner.verbose;
        this->seed = learner.seed;
      }
    
    
      virtual bool train () = 0;
      virtual double evaluate (const Point< T > &p, bool raw_value=false) = 0;
 
      virtual mltk::Point<double> batchEvaluate (const Data< T >& data);
      
      /*********************************************
       *               Getters                     *
       *********************************************/
    
      virtual std::string getFormulationString() = 0;
      inline auto getSamples() { return this->samples; }
      [[nodiscard]] inline double getElapsedTime() const { return timer.elapsed(); }
      [[nodiscard]] inline int getCtot() const { return ctot; }
      [[nodiscard]] inline int getSteps() const { return steps; }
      [[nodiscard]] inline int getUpdates() const { return ctot; }
      [[nodiscard]] inline double getMaxTime() const { return max_time; }
      [[nodiscard]] double getPredictionProbability() const { return pred_prob; }
    
      /*********************************************
      *               Setters                     *
      *********************************************/
    
      void setSeed(const size_t _seed){ this->seed = _seed; }
      virtual void setSamples(const Data< T > &data) { this->samples = make_data<T>(data); }
      virtual void setSamples(DataPointer< T > data) { this->samples =  data; }
      void setTimer(Timer _timer) { this->timer = _timer; }
      inline void setSteps(int _steps) { this->steps = _steps; }
      void setCtot(int _ctot) { this->ctot = _ctot;}
      void setVerbose(int _verbose) { this->verbose = _verbose;}
      void setStartTime(double stime) { this->start_time = stime;}
      void setMaxTime(double maxtime) { this->max_time = maxtime;}
      void setEPS(double eps) { this->EPS = eps;}
      void setMaxIterations(int max_it) { this->MAX_IT = max_it;}
      void setMaxEpochs(int MAX_EPOCHS) {this->MAX_EPOCH = MAX_EPOCHS;}
      void setMaxUpdates(int max_up) { this->MAX_UP = max_up;}
      void setLearningRate(double learning_rate) { this->rate = learning_rate;}
    };
 
    /*********************************************
     *               Implementation              *
     *********************************************/
 
    template<typename T>
    mltk::Point<double> Learner<T>::batchEvaluate (const Data< T >& data){
        mltk::Point<double> preds(data.size());
        std::transform(data.begin(), data.end(), preds.begin(), [this](auto point){
            return this->evaluate(*point);
        });
        return preds;
    }
}