EAOptimizer.hh

#ifndef GRAIL_EA_OPTIMIZER_H
#define GRAIL_EA_OPTIMIZER_H
 
#include "Arena.hh"
#include "Crossover.hh"
#include "EvoScript.hh"
#include "Mutation.hh"
#include "Selection.hh"
 
#include <functional>
#include <memory>
#include <random>
#include <vector>
 
namespace grail
{
    namespace evolution
    {
        struct Mutation;
        struct Crossover;
        class Arena;
        class Selection;
        class EvoScript;
 
        enum class ElitismType
        {
            NONE,
            FITNESS_RANKING,
            ROULETTE
        };
 
        class EAOptimizer final
        {
        public:
            EAOptimizer(std::vector<std::unique_ptr<EvoScript>>& initialPopulation,
                        std::unique_ptr<Arena> arenaEvaluation,
                        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{}());
 
            size_t PopulationSize() const;
 
            void Run(int maxEpochCount = 1);
 
            void SetElitism(double rate, ElitismType type);
 
            float CalculatePopulationDiversity() const;
 
            size_t CalculatePopulationIdenticalFront() const;
 
            EvoScript& GetBestIndividual() const;
 
            void SetOnEpochEndedCallback(std::function<void(EAOptimizer& eaOptimizer)> function);
 
            Crossover& GetCrossover() const;
            Mutation& GetMutation() const;
 
            friend std::ostream& operator<<(std::ostream& out, const EAOptimizer& eaOptimizer);
 
        private:
            void AddPopulation(std::vector<std::unique_ptr<EvoScript>>& destination,
                               std::vector<std::unique_ptr<EvoScript>>& source) const;
            void EvaluatePopulation(std::vector<std::unique_ptr<EvoScript>>& onceEvaluatedPopulation,
                                    std::vector<std::unique_ptr<EvoScript>>& neverEvaluatedPopulation);
            void SelectPopulation();
            void CrossoverPopulation();
            void MutatePopulation();
            void Epoch();
 
            float CalculateAverageDiversity(const std::vector<std::unique_ptr<EvoScript>>& population) const;
            size_t CalculateIdenticalFront(const std::vector<std::unique_ptr<EvoScript>>& population) const;
 
        private:
            std::vector<std::unique_ptr<EvoScript>> corePopulation{};
            std::vector<std::unique_ptr<EvoScript>> emptyPopulation{};
 
            std::function<void(EAOptimizer& eaOptimizer)> onEpochFunction = nullptr;
 
            int epochNumber = 0;
            size_t populationCount = 0;
 
            double elitismRate = 0.2;
            ElitismType elitismType = ElitismType::ROULETTE;
 
            std::unique_ptr<Arena> arenaEvaluation = nullptr;
            std::unique_ptr<Crossover> crossover = nullptr;
            std::unique_ptr<Mutation> mutation = nullptr;
            std::unique_ptr<Selection> selection = nullptr;
 
            std::mt19937_64 randGen;
        };
    }
}
#endif // GRAIL_EA_OPTIMIZER_H