individual.h

Go to the documentation of this file.

#ifndef INDIVIDUAL_H
#define INDIVIDUAL_H
 
#include "../program/program.h"
#include "fitness.h"
 
#include <functional>
 
using namespace nlohmann;
 
namespace Brush{
namespace Pop{
 
template<ProgramType T> 
class Individual{
public: // TODO: make these private (and work with nlohman json)
    Program<T> program; 
 
    // store just info that we dont have a getter. size, depth, complexity: they can all be obtained with program.<function here>
 
    // error is the aggregation of error vector, and can be user sppecified
    
    // this flag is used to avoid re-fitting an individual. the program is_fitted_ flag is used to perform checks (like in predict with weights). They are two different things and I think I;ll keep this way (individual is just a container to keep program and fitness together) 
    bool is_fitted_ = false;
 
    // archive utility (and also keep track of evolution) (this is meaningful only
    // if variation is done using the vary() function)
    unsigned id;                 
    vector<unsigned> parent_id;  
    
    // storing what changed in relation to parent inside variation
    string variation = "born"; // spontanegous generation (born), crossover, or which type of mutation
    vector<Node> sampled_nodes = {}; // nodes that were sampled in mutation
 
    VectorXf error;     
 
    Fitness fitness;     
 
    vector<string> objectives; 
       
 
    Individual()
    {
        objectives = {"scorer", "linear_complexity"}; 
        id = 0; // unsigned
    };
 
    Individual(Program<T>& prg) : Individual() {
        program = prg;
    };
 
    void init(SearchSpace& ss, const Parameters& params)
    {
        program = ss.make_program<Program<T>>(params, 0, 0);
 
        // overriding the objectives with the ones from params (to replace
        // the generic "scorer" by the actual scorer set in the params object)
        objectives = params.get_objectives();
 
        // If different from zero, then the program is created with a fixed depth and size.
        // If zero, it samples the value
        // program = SS.make_program<T>(params, params.max_depth, params.max_size);
 
        variation = "born";
    };
 
    // TODO: replace occurences of program.fit with these (also predict and predict_proba)
    Individual<T> &fit(const Dataset& data) {
        program.fit(data);
        this->is_fitted_ = true;
        return *this;
    };
    Individual<T> &fit(const Ref<const ArrayXXf>& X, const Ref<const ArrayXf>& y)
    {
        Dataset d(X,y);
        return fit(d);
    };

    Individual<T>& replace_program(const Program<T>& new_program)
    {
        program.replace_program(new_program);
        this->is_fitted_ = false;
        fitness.clearValues();
        return *this;
    };

    Individual<T>& replace_program(const json& j)
    {
        Program<T> new_program = j;
        return replace_program(new_program);
    };
 
    auto predict(const Dataset& data) { return program.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 program.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);
    };
 
    // just getters
    unsigned int get_size() const { return program.size(); };
    unsigned int get_depth() const { return program.depth(); };
    unsigned int get_complexity() const { return program.complexity(); };
    unsigned int get_linear_complexity() const { return program.linear_complexity(); };
    Program<T>& get_program() { return program; };
    
    string get_model(string fmt="compact", bool pretty=false) {
        return program.get_model(fmt, pretty); };
    string get_dot_model(string extras="") {
        return program.get_dot_model(extras); };
 
    void set_fitness(Fitness &f) { fitness=f; };
    Fitness& get_fitness() { return fitness; };
 
    void set_variation(string v) { variation=v; };
    string get_variation() const { return variation; };
 
    bool get_is_fitted() const { return this->is_fitted_; };
    void set_is_fitted(bool fitted) { this->is_fitted_ = fitted; };
 
    void set_sampled_nodes(const vector<Node>& nodes) { sampled_nodes = nodes; };
    vector<Node> get_sampled_nodes() const { return sampled_nodes; };
    
    unsigned int get_id(){ return id;};
    void set_id(unsigned i){id = i;};
    void set_parents(const vector<Individual<T>>& parents){
        parent_id.clear();
        for (const auto& p : parents)
            parent_id.push_back(p.id);
    };     
    void set_parents(const vector<unsigned>& parents){ parent_id = parents; };     
 
    // TODO: USE setters and getters intead of accessing it directly
    // template<ProgramType T>
    // void Individual<T>::set_objectives(const vector<string>& objectives)
 
    // Static map for weights associated with strings.
    // this will determine each fitness metric to be a min/max problem.
    // generic error metric: by default log and multi_log if it is a
    // classification problem, and MSE if it is a regression (so its always
    // a minimization by default, thus "scorer" has weight -1.0)
    inline static std::map<std::string, float> weightsMap = {
        {"complexity",              -1.0},
        {"linear_complexity",       -1.0},
        {"size",                    -1.0},
        {"mse",                     -1.0},
        {"log",                     -1.0},
        {"multi_log",               -1.0},
        {"average_precision_score", +1.0},
        {"balanced_accuracy",       +1.0},
        {"accuracy",                +1.0}
        // {"scorer",                   -1.0}
    };
 
    vector<string> get_objectives() const { return objectives; };
    void set_objectives(vector<string> objs){
        objectives=objs;
        
        vector<float> weights;
        weights.resize(0);
        for (const auto& obj : objectives) {
            // TODO: do i need to use find or this can be done directly?
            auto it = weightsMap.find(obj);
            if (it != weightsMap.end()) {
                weights.push_back(it->second);
            } else {
                throw std::runtime_error(
                    "Unknown metric used as fitness. Value was " + obj);
            }
        }
 
        fitness.set_weights(weights);
    };
};
 
 
// serialization for Individual
template<ProgramType T>
void to_json(json &j, const Individual<T> &p)
{
    // error and sampled nodes are not being serialized
    j = json{
        {"program", p.program},
        {"fitness", p.fitness},
        {"id", p.id},
        {"parent_id", p.parent_id},
        {"objectives", p.objectives},
        {"is_fitted_", p.is_fitted_},
        {"variation", p.variation}
    }; 
}
 
template<ProgramType T>
void from_json(const json &j, Individual<T>& p)
{// TODO: figure  out if this works  with private attributes and try to actually make them private (and use getters and setters)
    j.at("program").get_to( p.program );
    j.at("fitness").get_to( p.fitness );
    j.at("id").get_to( p.id );
    j.at("parent_id").get_to( p.parent_id );
    j.at("objectives").get_to( p.objectives );
    j.at("is_fitted_").get_to( p.is_fitted_ );
    j.at("variation").get_to( p.variation );
}
} // Pop
} // Brush
 
#endif