params.h

Go to the documentation of this file.

/* FEAT
copyright 2017 William La Cava
license: GNU/GPL v3
*/
#ifndef PARAMS_H
#define PARAMS_H
// internal includes
#include "pop/nodewrapper.h"
#include "pop/nodevector.h"
#include "util/logger.h"
#include "util/utils.h"
#include "pop/nodemap.h"
 
namespace FT{
 
using namespace Pop;
using namespace Op;
 
 
struct Parameters
{
    std::map<std::string, Node*> node_map;
    int random_state; 
    int pop_size = 100; 
    int gens = 100;    
    int current_gen;
    string ml;      
    bool classification = false; 
    int max_stall = 0;      
    vector<char> otypes; 
    vector<char> ttypes; 
    char otype;         
    int verbosity = 0;          
    vector<float> term_weights; 
    vector<float> op_weights;   
    NodeVector functions;       
    NodeVector terminals;       
    vector<std::string> longitudinalMap; 
 
    unsigned int max_depth = 3; 
    unsigned int max_size;  
    unsigned int max_dim = 10;  
    bool erc = false;           
    unsigned num_features; 
    vector<string> objectives{"fitness","complexity"};
    bool shuffle = true;             
    float split = 0.75;              
    vector<char> dtypes;      
    float feedback = 0.5;           
    unsigned int n_classes;   
    float cross_rate;         
    vector<int> classes;      
    vector<float> class_weights;  
    vector<float> sample_weights; 
    string scorer;                
    string scorer_;   
    vector<string> feature_names; 
    bool backprop = false;  
    bool hillclimb = false; 
    int max_time = -1;  
    bool use_batch = false; 
    bool residual_xo=false; 
    bool stagewise_xo=false; 
    bool stagewise_xo_tol=true; 
    bool corr_delete_mutate=false;    
    float root_xo_rate = 0.5; 
    bool softmax_norm; 
    bool normalize;    
    vector<bool> protected_groups;  
    bool tune_initial; 
    bool tune_final; 
    string fn_str;      
    int n_jobs = 1; 
 
    struct BP 
    {
       int iters=10;
       float learning_rate = 0.1;
       int batch_size = 0;
       BP(int i, float l, int bs): iters(i), learning_rate(l), batch_size(bs) {};
       BP() = default;
    };
 
    BP bp;                                      
    
    struct HC 
    {
       int iters;
       float step;
       HC(int i, float s): iters(i), step(s) {};
       HC() = default;
    };
    
    HC hc;                                      
    
    // Parameters(int pop_size, int gens, string ml, bool classification, 
    //         int max_stall, char ot, int verbosity, string fs, float cr, 
    //         float root_xor, unsigned int max_depth, unsigned int max_dim, 
    //         bool constant, string obj, bool sh, float sp, float fb, 
    //         string sc, string fn, bool bckprp, int iters, float lr, int bs, 
    //         bool hclimb, int maxt, bool res_xo, bool stg_xo, 
    //         bool stg_xo_tol, bool sftmx, bool nrm, bool corr_mut, 
    //         bool tune_init, bool tune_fin);
 
    Parameters(); 
    ~Parameters(){};
    
    void init(const MatrixXf& X, const VectorXf& y);
  
    void set_current_gen(int g);
    
    void set_scorer(string sc="", bool initialized=false);
    
    void set_term_weights(const vector<float>& w);
    
    void set_op_weights();
    
    std::unique_ptr<Node> createNode(std::string str, float d_val = 0, bool b_val = false, 
                                     size_t loc = 0, string name = "");
    
    vector<string> get_functions();
    void set_functions(const vector<string>& fns);
    
    void updateSize();
    
    void set_max_depth(unsigned int max_depth);
    
    void set_max_dim(unsigned int max_dim);
    
    void set_terminals(int nf, const LongData& Z);
    void set_terminals(int nf){LongData Z; set_terminals(nf,Z); };
 
    void set_feature_names(string fn); 
    string get_feature_names();
    
    string get_protected_groups();
    void set_protected_groups(string fn); 
 
    auto get_objectives(){ return objectives; };
    void set_objectives(const vector<string>& obj);
    
    void set_verbosity(int verbosity);
 
    void set_otype(char ot);
    
    void set_ttypes();
 
    void set_otypes(bool terminals_set=false);
    
    void set_classes(const VectorXf& y);    
    
    void set_sample_weights(VectorXf& y);
 
    void initialize_node_map();
};
 
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Parameters,
    pop_size,                               
    gens,                                   
    current_gen,                            
    ml,                                 
    classification,                     
    max_stall,                              
    otypes,                         
    ttypes,                         
    otype,                                 
    verbosity,
    term_weights,                   
    op_weights,                 
    fn_str,                       
    terminals,                       
    longitudinalMap,        
    max_depth,                  
    max_size,                   
    max_dim,                    
    erc,                                    
    num_features,                      
    objectives,                  
    shuffle,                               
    split,                               
    dtypes,                        
    feedback,                            
    n_classes,                     
    cross_rate,                           
    classes,                        
    class_weights,                
    sample_weights,               
    scorer,                              
    scorer_,
    feature_names,               
    backprop,                              
    hillclimb,                             
    max_time,                              
    use_batch,                             
    residual_xo,                           
    stagewise_xo,                         
    stagewise_xo_tol,                      
    corr_delete_mutate,                    
    root_xo_rate,                         
    softmax_norm,                          
    normalize,                             
    protected_groups,          
    tune_initial, 
    tune_final 
    );
} // FT
#endif