EAOptimizer.hh

// Copyright QED Software 2023.
 
#ifndef GRAIL_EA_OPTIMIZER_H
#define GRAIL_EA_OPTIMIZER_H
 
#include "Crossover.hh"
#include "Individual.hh"
#include "Mutation.hh"
#include "Selection.hh"
 
#include <functional>
#include <fstream>
#include <sstream>
#include <memory>
#include <iostream>
#include <memory>
#include <random>
#include <vector>
 
namespace grail
{
namespace evolution
{
    struct Mutation;
    struct Crossover;
    class Selection;
    class Individual;
 
    enum class ElitismType
    {
        NONE,
        FITNESS_RANKING,
        ROULETTE
    };
 
    class EAOptimizer final
    {
    public:
        EAOptimizer(std::vector<std::unique_ptr<Individual>>& initialPopulation,
            size_t maxEpochCount,
            std::unique_ptr<Crossover> crossover = std::make_unique<Crossover>(),
            std::unique_ptr<Mutation> mutation = std::make_unique<Mutation>(),
            std::unique_ptr<Selection> selection = std::make_unique<Selection>(),
            std::mt19937_64::result_type seed = std::random_device{}());
 
        void RunInteractive(std::function<void(Individual& individualToEvaluate)> onEvaluateNeeded,
                            std::function<void(void)> onFinished = nullptr,
                            std::function<void(void)> onNewEpoch = nullptr);
        size_t GetPopulationSize() const;
 
        std::vector<std::unique_ptr<Individual>> GetPopulation() const;
 
        void SetElitism(double rate, ElitismType type);
 
        double GetElitismRate() const;
 
        ElitismType GetElitismType() const;
 
        float CalculatePopulationDiversity() const;
 
        size_t CalculatePopulationIdenticalFrontCount() const;
 
        float CalculatePopulationIdenticalFrontRatio() const;
 
        const Individual& GetBestIndividual() const;
 
        size_t GetEpochNumber() const;
 
        size_t GetMaxEpochCount() const;
 
        Crossover& GetCrossover() const;
 
        Mutation& GetMutation() const;
 
        Selection& GetSelection() const;
 
        void SerializeState(const std::string& filename) const;
 
        bool DeserializeState(const std::string& filename);
 
        friend std::ostream& operator<<(std::ostream& out, const EAOptimizer& eaOptimizer);
 
    private:
        template<class T>
        void DeserializeSimpleValue(std::ifstream& fileStream, T& value)
        {
            std::string line;
            std::getline(fileStream, line);
            std::istringstream stringStreamLine(line);
            stringStreamLine >> std::skipws >> line >> value;
        }
 
        void AddPopulation(std::vector<std::unique_ptr<Individual>>& destination,
                           std::vector<std::unique_ptr<Individual>>& source) const;
        void SelectPopulation();
        void CrossoverPopulation();
        void MutatePopulation();
 
        float CalculateAverageDiversity(const std::vector<std::unique_ptr<Individual>>& population) const;
        size_t CalculateIdenticalFront(const std::vector<std::unique_ptr<Individual>>& population) const;
 
    private:
        Individual* FindFirstNotUpdated(const std::vector<std::unique_ptr<Individual>>& population) const;
 
        std::vector<std::unique_ptr<Individual>> corePopulation{};
        std::vector<std::unique_ptr<Individual>> emptyPopulation{};
 
        size_t epochNumber = 0;
        size_t maxEpoch = 1;
        size_t populationCount = 0;
        bool evaluationInProgress = false;
 
        double elitismRate = 0.2;
        ElitismType elitismType = ElitismType::ROULETTE;
 
        std::unique_ptr<Crossover> crossover;
        std::unique_ptr<Mutation> mutation;
        std::unique_ptr<Selection> selection;
 
        std::mt19937_64 randGen;
    };
}
}
#endif // GRAIL_EA_OPTIMIZER_H