population.h

Go to the documentation of this file.

#ifndef POPULATION_H
#define POPULATION_H
 
#include "../util/utils.h"
#include "../util/error.h"
#include "../ind/individual.h"
 
namespace Brush {   
namespace Pop {
 
template<ProgramType T> 
class Population{
public:
    size_t pop_size;
    int num_islands;
    float mig_prob;
    
    vector<std::shared_ptr<Individual<T>>> individuals;
    vector<vector<size_t>> island_indexes;
 
    Population();
    ~Population(){};
    
    void init(SearchSpace& ss, const Parameters& params);
 
    // initialize based on list of individuals
    void init(vector<Individual<T>>& individuals, const Parameters& params);
 
    // save serialized population
    void save(string filename);
    // load serialized population
    void load(string filename);
 
    int size() { return individuals.size(); };
 
    vector<size_t> get_island_indexes(int island){ return island_indexes.at(island); };
 
    void add_offspring_indexes(int island);
    
    void update(vector<vector<size_t>> survivors);
    
    const Individual<T>& operator [](size_t i) const {return *individuals.at(i);}
    const Individual<T>& operator [](size_t i) {return *individuals.at(i);}
 
    string print_models(string sep="\n");
 
    vector<vector<size_t>> sorted_front(unsigned rank=1);
 
    // pareto front ignoring island divisions
    vector<size_t> hall_of_fame(unsigned rank=1);
    
    // perform a migration in the population. Individuals from sorted front or hall of fame will replace others by the
    // probability set in parameters. Expects a population without offspring
    void migrate();
 
    struct SortComplexity
    {
        Population& pop;
        SortComplexity(Population& p): pop(p){}
        bool operator()(size_t i, size_t j)
        { 
            return pop[i].get_complexity() < pop[j].get_complexity();
        }
    };
    
    struct SameFitComplexity
    {
        Population<T> & pop;
        SameFitComplexity(Population<T>& p): pop(p){}
        bool operator()(size_t i, size_t j)
        {
            return pop[i].get_complexity() == pop[j].get_complexity();
        }
    };
};
 
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(
    Population<PT::Regressor>, individuals, island_indexes, pop_size, num_islands);
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(
    Population<PT::BinaryClassifier>, individuals, island_indexes, pop_size, num_islands);
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(
    Population<PT::MulticlassClassifier>, individuals, island_indexes, pop_size, num_islands);
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(
    Population<PT::Representer>, individuals, island_indexes, pop_size, num_islands);
    
}// Pop
}// Brush
 
#endif