AbstractGA.h

Go to the documentation of this file.

 
#ifndef DIGNEA_ABSTRACTGA_H
#define DIGNEA_ABSTRACTGA_H
 
#include <dignea/core/Crossover.h>
#include <dignea/core/Mutation.h>
#include <dignea/core/Problem.h>
#include <dignea/core/Replacement.h>
#include <dignea/core/Selection.h>
#include <dignea/evaluators/PopulationEvaluator.h>
#include <dignea/utilities/exceptions/NoMOAllowed.h>
#include <dignea/utilities/random/PseudoRandom.h>
 
#include <memory>
#include <vector>
 
#include "AbstractEA.h"
 
using namespace std;
 
template <class S>
class AbstractGA : public AbstractEA<S> {
   public:
    AbstractGA();
 
    virtual ~AbstractGA() = default;
 
    virtual string getName() const = 0;
 
    json to_json() const override;
 
    virtual Front<S> getResults() const;
 
    void run() override;
 
    void setProblem(shared_ptr<Problem<S>> prob) override;
 
    void setProblem(Problem<S> *prob) override;
 
   protected:
    virtual void initProgress();
 
    virtual void updateProgress() = 0;
 
    virtual void finishProgress();
 
    virtual bool isStoppingConditionReached();
 
    virtual void createInitialPopulation();
 
    virtual void evaluatePopulation(vector<S> &pop);
 
    virtual vector<S> createMating();
 
    virtual void reproduction(S &, S &);
 
   public:
    double getMutationRate() const;
 
    void setMutationRate(double mutationRate);
 
    double getCrossRate() const;
 
    void setCrossRate(double crossRate);
 
    const Mutation<S> *getMutation() const;
 
    void setMutation(unique_ptr<Mutation<S>> mutation);
 
    const Crossover<S> *getCrossover() const;
 
    void setCrossover(unique_ptr<Crossover<S>> crossover);
 
    const Selection<S> *getSelection() const;
 
    void setSelection(unique_ptr<Selection<S>> selectionOperator);
 
   protected:
    double mutationRate; 
    double crossRate;    
    unique_ptr<Mutation<S>> mutation;       
    unique_ptr<Crossover<S>> crossover;     
    unique_ptr<Selection<S>> selection;     
    unique_ptr<Replacement<S>> replacement; 
   public:
    static double DEFAULT_MUTATION_RATE;
    static double DEFAULT_CROSSOVER_RATE;
    static int DEFAULT_POPULATION_SIZE;
};
 
template <class S>
double AbstractGA<S>::DEFAULT_MUTATION_RATE = 0.05;
template <class S>
double AbstractGA<S>::DEFAULT_CROSSOVER_RATE = 0.8;
 
template <class S>
int AbstractGA<S>::DEFAULT_POPULATION_SIZE = 32;
 
template <class S>
AbstractGA<S>::AbstractGA()
    : AbstractEA<S>(),
      mutationRate(DEFAULT_MUTATION_RATE),
      crossRate(DEFAULT_CROSSOVER_RATE) {
    this->populationSize = DEFAULT_POPULATION_SIZE;
    this->mutation = nullptr;
    this->crossover = nullptr;
    this->selection = nullptr;
    this->evaluator = make_unique<PopulationEvaluator<S>>();
}
 
template <class S>
void AbstractGA<S>::createInitialPopulation() {
    this->population.resize(this->populationSize);
    for (int i = 0; i < this->getPopulationSize(); i++) {
        this->population[i] = this->problem->createSolution();
    }
    // Usamos el método por si empleamos un evaluador paralelo
    this->evaluatePopulation(this->population);
    // Reseteamos el printingcheck --> Para el uso de repeticiones en los
    // experimentos
    this->nextCheckpoint = 0;
    this->updateEvolution(0, this->population);
    this->initProgress();
}
 
template <class S>
void AbstractGA<S>::evaluatePopulation(vector<S> &pop) {
    this->evaluator->evaluate(pop, this->problem.get());
}
 
template <class S>
bool AbstractGA<S>::isStoppingConditionReached() {
    return (this->performedEvaluations >= this->maxEvaluations);
}
 
template <class S>
void AbstractGA<S>::initProgress() {
    this->performedEvaluations = this->populationSize;
}
 
template <class S>
void AbstractGA<S>::run() {
    if (this->problem) {
        this->createInitialPopulation();
        this->startTime = chrono::system_clock::now();
        while (!this->isStoppingConditionReached()) {
            vector mating = this->createMating();
            this->evaluatePopulation(mating);
            this->population = replacement->replace(this->population, mating);
            this->updateProgress();
            this->updateEvolution(this->performedEvaluations, this->population);
        }
        this->endTime = chrono::system_clock::now();
        this->finishProgress();
    } else {
        throw std::runtime_error("Problem is not set in GA::run");
    }
}
 
template <class S>
vector<S> AbstractGA<S>::createMating() {
    vector<S> offspring(this->populationSize);
    for (int i = 0; i < this->populationSize; i++) {
        S child1 = selection->select(this->population);
        S child2 = selection->select(this->population);
        reproduction(child1, child2);
        offspring[i] = child1;
    }
    return offspring;
}
 
template <class S>
void AbstractGA<S>::reproduction(S &child1, S &child2) {
    // Cruzamos los individuos con cierta probabilidad
    if (PseudoRandom::randDouble() < crossRate) {
        crossover->run(child1, child2);
    }
    mutation->run(child1, mutationRate, this->problem.get());
}
 
template <class S>
double AbstractGA<S>::getMutationRate() const {
    return mutationRate;
}
 
template <class S>
void AbstractGA<S>::setMutationRate(double mutationRate) {
    AbstractGA::mutationRate = mutationRate;
}
 
template <class S>
double AbstractGA<S>::getCrossRate() const {
    return crossRate;
}
 
template <class S>
void AbstractGA<S>::setCrossRate(double crossRate) {
    AbstractGA::crossRate = crossRate;
}
 
template <class S>
const Mutation<S> *AbstractGA<S>::getMutation() const {
    return mutation.get();
}
 
template <class S>
void AbstractGA<S>::setMutation(unique_ptr<Mutation<S>> newMut) {
    this->mutation = move(newMut);
}
 
template <class S>
const Crossover<S> *AbstractGA<S>::getCrossover() const {
    return crossover.get();
}
 
template <class S>
void AbstractGA<S>::setCrossover(unique_ptr<Crossover<S>> newCX) {
    this->crossover = move(newCX);
}
 
template <class S>
const Selection<S> *AbstractGA<S>::getSelection() const {
    return selection.get();
}
 
template <class S>
void AbstractGA<S>::setSelection(unique_ptr<Selection<S>> newSelection) {
    this->selection = move(newSelection);
}
 
template <class S>
void AbstractGA<S>::setProblem(shared_ptr<Problem<S>> prob) {
    if (prob->getNumberOfObjs() != 1) {
        std::string where = "AbstractGA setProblem";
        throw(NoMOAllowed(where));
    }
    this->problem = prob;
}
template <class S>
void AbstractGA<S>::setProblem(Problem<S> *prob) {
    if (prob->getNumberOfObjs() != 1) {
        std::string where = "AbstractGA setProblem";
        throw(NoMOAllowed(where));
    }
    this->problem.reset(prob);
}
 
template <class S>
void AbstractGA<S>::finishProgress() {
    std::chrono::duration<double> diff = this->endTime - this->startTime;
    this->elapsedTime = diff.count();
}
 
template <class S>
Front<S> AbstractGA<S>::getResults() const {
    if (!this->population.empty()) {
        vector<S> results;
        // Incluimos solo los individuos factibles
        for (const S &individual : this->population) {
            if (individual.getConstraintCoeff() == 0.0) {
                results.push_back(S(individual));
            }
        }
        results.erase(unique(results.begin(), results.end()), results.end());
        return Front<S>(results);
    } else
        return Front<S>(0);
}
 
template <class S>
json AbstractGA<S>::to_json() const {
    json data = AbstractEA<S>::to_json();
    if (mutation) data["mutation"] = this->mutation->getName();
    if (crossover) data["crossover"] = this->crossover->getName();
    if (selection) data["selection"] = this->selection->getName();
    if (replacement) data["replacement"] = this->replacement->getName();
    data["mutation_rate"] = this->mutationRate;
    data["crossover_rate"] = this->crossRate;
    return data;
}
 
#endif  // DIGNEA_ABSTRACTGA_H