feat.h

Go to the documentation of this file.

/* FEAT
copyright 2017 William La Cava
license: GNU/GPL v3
*/
#ifndef FEAT_H
#define FEAT_H
 
//external includes
#include <iostream>
#include <vector>
#include <memory>
#include <shogun/base/init.h>
 
// internal includes
#include "init.h"
#include "util/rnd.h"
#include "util/logger.h"
#include "util/utils.h"
#include "util/io.h"
#include "params.h"
#include "pop/population.h"
#include "sel/selection.h"
#include "eval/evaluation.h"
#include "vary/variation.h"
#include "model/ml.h"
#include "pop/op/node.h"
#include "pop/archive.h" 
#include "pop/op/longitudinal/n_median.h"
 
#ifdef USE_CUDA
    #include "pop/cuda-op/cuda_utils.h" 
    #define GPU true
#else
    #define GPU false
    #define initialize_cuda() 0
#endif
 
// stuff being used
using Eigen::MatrixXf;
using Eigen::ArrayXXf;
using Eigen::VectorXf;
using Eigen::ArrayXf;
typedef Eigen::Array<bool,Eigen::Dynamic,1> ArrayXb;
using std::vector;
using std::string;
using std::unique_ptr;
using std::shared_ptr;
using std::make_shared;
using std::cout; 
namespace nl = nlohmann;
 
namespace FT{
 
using namespace Eval;
using namespace Vary;
 
 
class Feat 
{
    public : 
                    
        // Methods 
        
          
        // Feat(int pop_size=100, int gens = 100, 
        //      string ml = "LinearRidgeRegression", 
        //      bool classification = false, int verbosity = 2, 
        //      int max_stall = 0, string sel ="lexicase", 
        //      string surv="nsga2", float cross_rate = 0.5, 
        //      float root_xo_rate = 0.5, char otype='a', 
        //      string functions = "", unsigned int max_depth = 3, 
        //      unsigned int max_dim = 10, int random_state=-1, 
        //      bool erc = false, string obj="fitness,complexity", 
        //      bool shuffle=true, float split=0.75, float fb=0.5, 
        //      string scorer="", string feature_names="",
        //      bool backprop=false,int iters=10, float lr=0.1, 
        //      int batch_size=0, int n_jobs=0, bool hillclimb=false, 
        //      string logfile="", int max_time=-1, bool residual_xo = false, 
        //      bool stagewise_xo = false, bool stagewise_tol = true, 
        //      bool softmax_norm=false, int save_pop=0, bool normalize=true, 
        //      bool val_from_arch=true, bool corr_delete_mutate=false, 
        //      float simplify=0.0, string protected_groups="",
        //      bool tune_initial=false, bool tune_final=true,
        //      string starting_pop="");
 
        Feat(){}
        ~Feat(){} 
        
        void init();
        inline void set_is_fitted(bool f){is_fitted=f;}
        inline bool get_is_fitted(){return is_fitted;}
 
        void set_pop_size(int pop_size);
        int get_pop_size();
        
        void set_gens(int gens);
        int get_gens();
                    
        void set_ml(string ml);
        string get_ml();
        
        void set_classification(bool classification);
        bool get_classification();
             
        void set_verbosity(int verbosity);
        int get_verbosity();
                    
        void set_max_stall(int max_stall);
        int get_max_stall();
                    
        void set_selection(string sel);
                    
        void set_survival(string surv);
                    
        float get_cross_rate();
        void set_cross_rate(float cross_rate);
        
        void set_root_xo_rate(float cross_rate);
        float get_root_xo_rate(){return this->params.root_xo_rate;};
                    
        vector<char> get_otypes();
        char get_otype(){return params.otype;};
        void set_otype(char ot);
                    
        void set_functions(const vector<string>& fns){ params.set_functions(fns); };
        vector<string> get_functions(){return params.get_functions();};
                    
        int get_max_depth();
        void set_max_depth(unsigned int max_depth);
         
        int get_max_dim();
        void set_max_dim(unsigned int max_dim);
        
        // void set_max_dim(string str);
        
        void set_random_state(int random_state);
        int get_random_state() { return params.random_state; };
        int get_random_state_() { return r.get_seed(); };
                    
        bool get_erc();
        void set_erc(bool erc);
        
        bool get_shuffle();
        void set_shuffle(bool sh);
 
        
        float get_split();
        void set_split(float sp);
        
        vector<char> get_dtypes();
        void set_dtypes(vector<char> dtypes);
 
        float get_fb();
        void set_fb(float fb);
 
        string get_logfile();
        void set_logfile(string s);
 
        // returns the input argument for scorer.
        string get_scorer();
        void set_scorer(string s);
        // returns the actual scorer determined by the input argument.
        string get_scorer_();
        
        void set_feature_names(string s){params.set_feature_names(s); };
        string get_feature_names(){return params.get_feature_names(); };
 
        void set_backprop(bool bp);
        bool get_backprop(){return params.backprop;};
        
        void set_simplify(float s);
        float get_simplify(){return simplify;};
 
        void set_corr_delete_mutate(bool s);
        bool get_corr_delete_mutate(){return params.corr_delete_mutate;};
        
        void set_hillclimb(bool hc);
        bool get_hillclimb(){return params.hillclimb;};
        
        void set_iters(int iters);
        int get_iters(){return params.bp.iters;};
        
        void set_lr(float lr);
        float get_lr(){return params.bp.learning_rate;};
        
        int get_batch_size(){return params.bp.batch_size;};
        void set_batch_size(int bs);
         
        void set_n_jobs(unsigned t);
        int get_n_jobs(){return omp_get_num_threads();};
        
        void set_max_time(int time);
        int get_max_time(){return params.max_time;};
        
        void set_use_batch();
        
        void set_residual_xo(bool res_xo=true){params.residual_xo=res_xo;};
        bool get_residual_xo(){return params.residual_xo;};
        
        void set_stagewise_xo(bool sem_xo=true){ params.stagewise_xo=sem_xo; };
        bool get_stagewise_xo(){return params.stagewise_xo;};
 
        void set_stagewise_xo_tol(int tol){ params.stagewise_xo_tol = tol;};
        int get_stagewise_xo_tol(){return params.stagewise_xo_tol;};
        
        void set_softmax_norm(bool sftmx=true){params.softmax_norm=sftmx;};
        bool get_softmax_norm(){return params.softmax_norm;};
 
        void set_save_pop(int pp){ save_pop=pp; };
        int get_save_pop(){ return save_pop; };
        
        void set_starting_pop(string sp){ starting_pop=sp; };
        string get_starting_pop(){ return starting_pop; };
 
        void set_normalize(bool in){params.normalize = in;};
        bool get_normalize(){return params.normalize;};
 
        string get_sel(){return this->selector.get_type();};
        void set_sel(string in){this->selector.set_type(in); };
 
        string get_surv(){return this->survivor.get_type();};
        void set_surv(string in){this->survivor.set_type(in); };
 
        bool get_tune_initial(){ return this->params.tune_initial;};
        void set_tune_initial(bool in){ this->params.tune_initial = in;};
 
        bool get_tune_final(){ return this->params.tune_final;};
        void set_tune_final(bool in){ this->params.tune_final = in;};
 
 
        auto get_objectives(){return params.get_objectives(); };  
        void set_objectives(const vector<string>& obj){params.set_objectives(obj);};
 
        string get_protected_groups(){ return params.get_protected_groups(); };
        void set_protected_groups(string pg);
 
        bool get_val_from_arch(){return val_from_arch; };
        void set_val_from_arch(bool in){val_from_arch = in; };
 
        /*                                                      
         * solo getters
         */
        int get_archive_size(){ return this->archive.individuals.size(); };
        int get_max_size();
        int get_num_features();
        string get_representation();
        string get_model(bool sort=true);
        string get_ind_eqn(bool sort, Individual& ind);
        string get_eqn(bool sort=false); 
        int get_n_params();
        int get_dim();
        int get_complexity();
        vector<nl::json> get_archive(bool front);
        ArrayXf get_coefs();
        int get_n_nodes();
        LongData get_Z(string s, 
                int * idx, int idx_size);
 
 
 
        void fit(MatrixXf& X, VectorXf& y);
        void fit(MatrixXf& X, VectorXf& y, LongData& Z);
                        
        void run_generation(unsigned int g,
                        vector<size_t> survivors,
                        DataRef &d,
                        std::ofstream &log,
                        float percentage,
                        unsigned& stall_count);
                 
        VectorXf predict(MatrixXf& X, LongData& Z);  
        VectorXf predict(MatrixXf& X);
 
        VectorXf predict_archive(int id, MatrixXf& X);  
        VectorXf predict_archive(int id, MatrixXf& X, LongData& Z);
        ArrayXXf predict_proba_archive(int id, MatrixXf& X, LongData& Z);
        ArrayXXf predict_proba_archive(int id, MatrixXf& X);
 
        shared_ptr<CLabels> predict_labels(MatrixXf& X, LongData Z = LongData());  
 
        ArrayXXf predict_proba(MatrixXf& X, LongData& Z);  
        ArrayXXf predict_proba(MatrixXf& X);
 
        MatrixXf transform(MatrixXf& X);
        MatrixXf transform(MatrixXf& X, LongData& Z);
        MatrixXf transform(MatrixXf& X, LongData Z, Individual *ind);
        
        float score(MatrixXf& X, const VectorXf& y,
                 LongData Z = LongData()); 
        
        nl::json get_stats();
 
        void load_best_ind(string filename);
 
        void load_population(string filename, bool justfront=false);
 
        // void load(const string& feat_state);
        void load(const json& j);
        void load_from_file(string filename);
        json save() const;
        void save_to_file(string filename);
        
        bool is_fitted; 
    private:
        // Parameters
        Parameters params;  
 
        Timer timer;       
        // subclasses for main steps of the evolutionary routine
        Population pop;         
        Selection selector;         
        Evaluation evaluator;       
        Variation variator;     
        Selection survivor;         
        Archive archive;          
        bool use_arch;         
        string survival;                        
        Normalizer N;                           
        // performance tracking
        float min_loss;                      
        float min_loss_v;                    
        float best_med_score;  
        int best_complexity;  
        string str_dim; 
        string starting_pop; 
        Individual best_ind;                    
        string logfile;                         
        int save_pop;  
        bool val_from_arch; 
        float simplify;  
        Log_Stats stats; 
 
        /* functions */
        bool update_best(const DataRef& d, bool val=false);    
        
        void calculate_stats(const DataRef& d);
        void print_stats(std::ofstream& log,
                         float fraction);      
        void log_stats(std::ofstream& log);
        
        // gets weights via univariate initial models
        vector<float> univariate_initial_model(DataRef &d, int n_feats);
        void initial_model(DataRef &d);
        void final_model(DataRef& d);
        void simplify_model(DataRef& d, Individual&);
        void update_stall_count(unsigned& stall_count, bool updated);
        
        //serialization
        NLOHMANN_DEFINE_TYPE_INTRUSIVE(Feat,
                params,
                pop,
                selector,
                survivor,
                archive,
                use_arch,
                survival,
                N,
                min_loss,
                min_loss_v,
                best_med_score,
                best_complexity,
                str_dim,
                starting_pop,
                best_ind,
                is_fitted
        );
                
};
 
// forward declarations
void to_json(nl::json&, const Feat&);
void from_json(const nl::json&, Feat&);
 
// serialization
} // FT
#endif