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;
    bool linear_complexity;  
    
    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 {
        auto& ind_ptr = individuals.at(i);
        if (!ind_ptr) {
            HANDLE_ERROR_THROW(fmt::format("Attempted to access null individual at index {}", i));
        }
        return *ind_ptr;
    }
    const Individual<T>& operator [](size_t i) {
        auto& ind_ptr = individuals.at(i);
        if (!ind_ptr) {
            HANDLE_ERROR_THROW(fmt::format("Attempted to access null individual at index {}", i));
        }
        return *ind_ptr;
    }

    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].fitness.complexity < pop[j].fitness.complexity;
        }
    };
 
    struct SortLinearComplexity
    {
        Population& pop;
        SortLinearComplexity(Population& p): pop(p){}
        bool operator()(size_t i, size_t j)
        { 
            return pop[i].fitness.linear_complexity < pop[j].fitness.linear_complexity;
        }
    };
    
    struct SameFitComplexity
    {
        Population<T> & pop;
        SameFitComplexity(Population<T>& p): pop(p){}
        bool operator()(size_t i, size_t j)
        {
            return (pop[i].fitness == pop[j].fitness);
 
            // return (pop[i].fitness == pop[j].fitness
            //     &&  pop[i].fitness.complexity == pop[j].fitness.complexity);
        }
    };
};
 
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Population<PT::Regressor>,
    individuals, island_indexes, pop_size, num_islands, mig_prob, linear_complexity);
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Population<PT::BinaryClassifier>,
    individuals, island_indexes, pop_size, num_islands, mig_prob, linear_complexity);
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Population<PT::MulticlassClassifier>,
    individuals, island_indexes, pop_size, num_islands, mig_prob, linear_complexity);
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Population<PT::Representer>,
    individuals, island_indexes, pop_size, num_islands, mig_prob, linear_complexity);
    
}// Pop
}// Brush
 
#endif