engine.h

Go to the documentation of this file.

/* Brush
copyright 2020 William La Cava
license: GNU/GPL v3
*/
 
#ifndef Engine_H
#define Engine_H
 
#include "util/rnd.h"
#include "init.h"
#include "params.h"
#include "eval/evaluation.h"
#include "vary/variation.h"
#include "pop/population.h"
#include "pop/archive.h"
#include "selection/selection.h"
 
#include "taskflow/taskflow.hpp"
#include <taskflow/algorithm/for_each.hpp>
 
namespace Brush
{
 
using namespace Pop;
using namespace Sel;
using namespace Eval;
using namespace Var;
using namespace nlohmann;
 
template <ProgramType T>
class Engine{
public:
    Engine()
    {
        this->params = Parameters();
        this->ss = SearchSpace();
    };
 
    Engine(Parameters& p, SearchSpace& s)
    {
        this->params = p;
        this->ss = s;
        // TODO: make variation to have a default constructor
        // this->variator(Variation<T>(params, ss)) ;
    };
    
    ~Engine(){};
 
    // outputs a progress bar, filled according to @param percentage.
    void print_progress(float percentage);
    void calculate_stats();
    void print_stats(std::ofstream& log, float fraction);      
    void log_stats(std::ofstream& log);
 
    // all hyperparameters are controlled by the parameter class. please refer to that to change something
    inline Parameters& get_params(){return params;}
    inline void set_params(Parameters& p){params=p;}
 
    inline SearchSpace& get_search_space() { return ss; }
    inline void set_search_space(SearchSpace& space) { ss = space; }
 
    inline bool get_is_fitted(){return is_fitted;}

    bool update_best();
 
    Individual<T>& get_best_ind(){return best_ind;};  
    
    Engine<T> &fit(Dataset& data) {
        run(data);
        return *this;
    };
    Engine<T> &fit(const Ref<const ArrayXXf>& X, const Ref<const ArrayXf>& y)
    {
        // Using constructor 2 to create the dataset
        Dataset d(X,y,params.feature_names,{},params.feature_types,
                params.classification,params.validation_size,
                params.batch_size, params.shuffle_split);
        return fit(d);
    };
 
    auto predict(const Dataset& data) { return this->best_ind.predict(data); };
    auto predict(const Ref<const ArrayXXf>& X)
    {
        Dataset d(X);
        return predict(d);
    };
 
    template <ProgramType P = T>
        requires((P == PT::BinaryClassifier) || (P == PT::MulticlassClassifier))
    auto predict_proba(const Dataset &d) { return this->best_ind.predict_proba(d); };
    template <ProgramType P = T>
        requires((P == PT::BinaryClassifier) || (P == PT::MulticlassClassifier))
    auto predict_proba(const Ref<const ArrayXXf>& X) 
    {
        Dataset d(X);
        return predict_proba(d);
    };

    int get_archive_size(){ return this->archive.individuals.size(); };

    vector<json> get_archive(bool front);
    vector<json> get_population();
 
    void set_population(vector<json> pop_vector);
 
    // locking and unlocking parts of the solutions
    void lock_nodes(int end_depth=0, bool skip_leaves=true);
    void unlock_nodes(int start_depth=0);

    auto predict_archive(int id, const Dataset& data);
    auto predict_archive(int id, const Ref<const ArrayXXf>& X);
 
    template <ProgramType P = T>
        requires((P == PT::BinaryClassifier) || (P == PT::MulticlassClassifier))
    auto predict_proba_archive(int id, const Dataset& data);
    template <ProgramType P = T>
        requires((P == PT::BinaryClassifier) || (P == PT::MulticlassClassifier))
    auto predict_proba_archive(int id, const Ref<const ArrayXXf>& X);
 
    // TODO: predict/predict_proba/archive with longitudinal data

    void run(Dataset &d);
    
    // TODO: should params and ss be private? (that would require better json handling)
    Parameters params;  
    SearchSpace ss;
    
    Individual<T> best_ind; 
    Archive<T> archive;     
    Population<T> pop;      
 
    bool is_fitted = false; 
private:
    Selection<T>  selector;   
    Evaluation<T> evaluator;  
    Selection<T>  survivor;   
    
    Log_Stats stats; 
 
    Timer timer; 
 
    void init();

    inline void set_is_fitted(bool f){is_fitted=f;}
};
 
// TODO: should I serialize data and search space as well?
// Only stuff to make new predictions should be serialized
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Engine<PT::Regressor>, params, best_ind, archive, pop, ss, is_fitted);
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Engine<PT::BinaryClassifier>, params, best_ind, archive, pop, ss, is_fitted);
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Engine<PT::MulticlassClassifier>, params, best_ind, archive, pop, ss, is_fitted);
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Engine<PT::Representer>, params, best_ind, archive, pop, ss, is_fitted);
 
} // Brush
#endif