individual.h

Go to the documentation of this file.

/* FEAT
copyright 2017 William La Cava
license: GNU/GPL v3
*/
#ifndef INDIVIDUAL_H
#define INDIVIDUAL_H
 
#include "../dat/state.h"
#ifdef USE_CUDA
    #include "cuda-op/cuda_utils.h"
#endif
#include "../dat/data.h"
#include "../params.h"
#include "../model/ml.h"
#include "../util/utils.h"
#include "../util/serialization.h"
#include "nodevector.h"
 
namespace FT{
 
using namespace Model;
 
namespace Pop{
    
 
class Individual{
public:        
    NodeVector program; 
    MatrixXf Phi;      
    VectorXf yhat;     
    VectorXf error;     
    shared_ptr<ML> ml; 
    float fitness;     
    float fitness_v;   
    float fairness;     
    float fairness_v;   
    vector<float> w;   
    vector<float> p;   
    unsigned int dim;  
    vector<float> obj; 
    unsigned int dcounter;  
    vector<unsigned int> dominated; 
    unsigned int rank;             
    float crowd_dist;   
    unsigned int complexity; 
    vector<char> dtypes;    
                                                  // program output
    unsigned id;                                
    vector<int> parent_id;                      
    string eqn; 
   
    Individual();
 
    /* Individual(const Individual& other); */
    
    /* Individual(Individual && other); */
    
    /* Individual& operator=(Individual const& other); */
    
    /* Individual& operator=(Individual && other); */
    void initialize(const Parameters& params, bool random, int id=0);
 
    MatrixXf out(const Data& d, bool predict=false);
 
    MatrixXf out_trace(const Data& d, vector<Trace>& stack_trace);
 
    MatrixXf state_to_phi(State& state);
 
    shared_ptr<CLabels> fit(const Data& d, const Parameters& params, 
            bool& pass);
    shared_ptr<CLabels> fit(const Data& d, const Parameters& params);
    
    shared_ptr<CLabels> fit_tune(const Data& d, 
            const Parameters& params, bool set_default=false);
 
    void tune(const Data& d, const Parameters& params);
    shared_ptr<CLabels> predict(const Data& d);
    VectorXf predict_vector(const Data& d);
    ArrayXXf predict_proba(const Data& d);
    string get_eqn() ;
 
    vector<string> get_features();
 
    string program_str() const;
 
    /* const std::unique_ptr<Node> operator [](int i) const {return program.at(i);} */ 
    /* const std::unique_ptr<Node> & operator [](int i) {return program.at(i);} */
 
    void set_rank(unsigned r);
    
    int size() const;
    
    int get_n_params();
    
    /* size_t subtree(size_t i, char otype) const; */
 
    // // get program depth.
    // unsigned int depth();
 
    unsigned int get_dim();
    
    int check_dominance(const Individual& b) const;
    
    void set_obj(const vector<string>&); 
    
    unsigned int set_complexity();
   
    unsigned int get_complexity() const;
  
    void clone(Individual& cpy, bool sameid=true) const;
    Individual clone();
    
    void set_id(unsigned i);
 
    void set_parents(const vector<Individual>& parents);
    
    void set_parents(const vector<int>& parents){ parent_id = parents; }
 
    vector<float> get_p() const;
    
    float get_p(const size_t i, bool normalize=true) const;
    
    vector<float> get_p(const vector<size_t>& locs, bool normalize=false) const; 
 
    void set_p(const vector<float>& weights, const float& fb, 
               const bool softmax_norm=false);
    
    std::map<char,size_t> get_max_state_size();
    
    void save(string filename);
    void load(string filename);
 
    typedef Array<bool, Dynamic, Dynamic, RowMajor> ArrayXXb;
    /* typedef Array<float, Dynamic, Dynamic, RowMajor> ArrayXXf; */
 
};
 
// serialization
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Individual, 
        program,
        /* Phi, */
        /* yhat, */
        /* error, */
        eqn,
        ml,
        fitness,
        fitness_v,
        fairness,
        fairness_v,
        w,
        p,
        dim,
        obj,
        dcounter,
        dominated,
        rank,
        crowd_dist,
        complexity,
        dtypes,
        id,
        parent_id
        )
}
}
 
#endif