evolutionary_algorithm.h

/****************************************************************************************************************/
/*                                                                                                              */
/*   OpenNN: Open Neural Networks Library                                                                       */
/*   www.artelnics.com/opennn                                                                                   */
/*                                                                                                              */
/*   E V O L U T I O N A R Y   A L G O R I T H M   C L A S S   H E A D E R                                      */
/*                                                                                                              */
/*   Roberto Lopez                                                                                              */
/*   Artelnics - Making intelligent use of data                                                                 */
/*   [email protected]                                                                                 */
/*                                                                                                              */
/****************************************************************************************************************/

#ifndef __EVOLUTIONARYALGORITHM_H__
#define __EVOLUTIONARYALGORITHM_H__

// System includes

#include <string>
#include <sstream>
#include <iostream>
#include <fstream>
#include <algorithm>
#include <functional>
#include <cmath>
#include <time.h>

// OpenNN includes

#include "training_algorithm.h"
#include "performance_functional.h"

namespace OpenNN
{


class EvolutionaryAlgorithm : public TrainingAlgorithm
{

public:

   // ENUMERATIONS


   enum FitnessAssignmentMethod{LinearRanking};


   enum SelectionMethod{RouletteWheel};


   enum RecombinationMethod{Line, Intermediate};


   enum MutationMethod{Normal, Uniform};


   // DEFAULT CONSTRUCTOR

   explicit EvolutionaryAlgorithm(void);

    // GENERAL CONSTRUCTOR

   explicit EvolutionaryAlgorithm(PerformanceFunctional*);

   // XML CONSTRUCTOR

   explicit EvolutionaryAlgorithm(const tinyxml2::XMLDocument&);


   // DESTRUCTOR

   virtual ~EvolutionaryAlgorithm(void);

      // STRUCTURES


   struct EvolutionaryAlgorithmResults : public TrainingAlgorithm::TrainingAlgorithmResults
   {  

       EvolutionaryAlgorithmResults(void)
       {
           evolutionary_algorithm_pointer = NULL;
       }


       EvolutionaryAlgorithmResults(EvolutionaryAlgorithm* new_evolutionary_algorithm_pointer)
       {
           evolutionary_algorithm_pointer = new_evolutionary_algorithm_pointer;
       }


       virtual ~EvolutionaryAlgorithmResults(void)
       {
       }


      EvolutionaryAlgorithm* evolutionary_algorithm_pointer;

      // Training history


      Vector< Matrix<double> > population_history;


      Vector< Vector<double> > best_individual_history;


      Vector<double> mean_norm_history;


      Vector<double> standard_deviation_norm_history;


      Vector<double> best_norm_history;


      Vector< Vector<double> > performance_history;


      Vector<double> mean_performance_history;


      Vector<double> standard_deviation_performance_history;


      Vector<double> best_performance_history;


      Vector<double> generalization_performance_history;


      Vector<double> elapsed_time_history;

      // Final values


      double final_mean_norm;


      double final_standard_deviation_norm;


      double final_best_norm;


      double final_mean_performance;


      double final_standard_deviation_performance;


      double final_best_performance;


      double final_generalization_performance;


      double elapsed_time;


      size_t generations_number;

      void resize_training_history(const size_t&);
      std::string to_string(void) const;
      Matrix<std::string> write_final_results(const size_t& precision = 3) const;
   };


   // METHODS

   // Get methods

   // Training parameters

   const double& get_warning_parameters_norm(void) const;

   const double& get_error_parameters_norm(void) const;

   // Stopping criteria

   const double& get_best_performance_goal(void) const;
   const size_t& get_maximum_generalization_performance_decreases(void) const;

   const size_t& get_maximum_generations_number(void) const;
   const double& get_maximum_time(void) const;

   // Reserve training history

   const bool& get_reserve_generalization_performance_history(void) const;

   const bool& get_reserve_elapsed_time_history(void) const;

   // Population methods

   size_t get_population_size(void) const;

   const Matrix<double>& get_population(void) const;

   // Training operators

   const FitnessAssignmentMethod& get_fitness_assignment_method(void) const;
   std::string write_fitness_assignment_method(void) const;

   const SelectionMethod& get_selection_method(void) const;
   std::string write_selection_method(void) const;

   const RecombinationMethod& get_recombination_method(void) const;
   std::string write_recombination_method(void) const;

   const MutationMethod& get_mutation_method(void) const;
   std::string write_mutation_method(void) const;

   // Population values

   const Vector<double>& get_performance(void) const;
   const Vector<double>& get_fitness(void) const;
   const Vector<bool>& get_selection(void) const;

   const size_t& get_elitism_size(void) const;
   const double& get_selective_pressure(void) const;

   const double& get_recombination_size(void) const;
   const double& get_mutation_rate(void) const;
   const double& get_mutation_range(void) const;    
   const double& get_mean_performance_goal(void) const;
   const double& get_standard_deviation_performance_goal(void) const;

   const bool& get_reserve_population_history(void) const;
   const bool& get_reserve_best_individual_history(void) const;
   const bool& get_reserve_mean_norm_history(void) const;
   const bool& get_reserve_standard_deviation_norm_history(void) const;
   const bool& get_reserve_best_norm_history(void) const;

   const bool& get_reserve_mean_performance_history(void) const;
   const bool& get_reserve_standard_deviation_performance_history(void) const;
   const bool& get_reserve_best_performance_history(void) const;

   // Set methods

   void set(void);
   void set(PerformanceFunctional*);

   void set_default(void);

   void set_fitness_assignment_method(const FitnessAssignmentMethod&);
   void set_fitness_assignment_method(const std::string&);

   void set_selection_method(const SelectionMethod&);
   void set_selection_method(const std::string&);

   void set_recombination_method(const RecombinationMethod&);
   void set_recombination_method(const std::string&);

   void set_mutation_method(const MutationMethod&);
   void set_mutation_method(const std::string&);

   void set_population_size(const size_t&);

   void set_population(const Matrix<double>&);

   void set_performance(const Vector<double>&);
   void set_fitness(const Vector<double>&);
   void set_selection(const Vector<bool>&);

   void set_elitism_size(const size_t&);
   void set_selective_pressure(const double&);
   void set_recombination_size(const double&);

   void set_mutation_rate(const double&);
   void set_mutation_range(const double&);

   void set_maximum_generations_number(const size_t&);
   void set_mean_performance_goal(const double&);
   void set_standard_deviation_performance_goal(const double&);

   void set_reserve_population_history(const bool&);

   void set_reserve_best_individual_history(const bool&);

   void set_reserve_mean_norm_history(const bool&);
   void set_reserve_standard_deviation_norm_history(const bool&);
   void set_reserve_best_norm_history(const bool&);

   void set_reserve_mean_performance_history(const bool&);
   void set_reserve_standard_deviation_performance_history(const bool&);
   void set_reserve_best_performance_history(const bool&);

   void set_reserve_all_training_history(const bool&);

   // Training parameters

   void set_warning_parameters_norm(const double&);

   void set_error_parameters_norm(const double&);

   // Stopping criteria

   void set_best_performance_goal(const double&);
   void set_maximum_generalization_performance_decreases(const size_t&);

   void set_maximum_time(const double&);

   // Reserve training history

   void set_reserve_generalization_performance_history(const bool&);

   void set_reserve_elapsed_time_history(const bool&);

   // Utilities

   void set_display_period(const size_t&);

   // Population methods

   Vector<double> get_individual(const size_t&) const;
   void set_individual(const size_t&, const Vector<double>&);

   size_t calculate_best_individual_index(void) const;

   double calculate_mean_performance(void) const;
   double calculate_standard_deviation_performance(void) const;

   // Initialization methods

   void initialize_population(const double&);

   void randomize_population_uniform(void);
   void randomize_population_uniform(const double&, const double&);
   void randomize_population_uniform(const Vector<double>&, const Vector<double>&);

   void randomize_population_normal(void);
   void randomize_population_normal(const double&, const double&);
   void randomize_population_normal(const Vector<double>&, const Vector<double>&);
    
   // Population norm methods

   Vector<double> calculate_population_norm(void) const;

   // Population performance methods

   void perform_fitness_assignment(void);
   void perform_selection(void);
   void perform_recombination(void);
   void perform_mutation(void);

   void evolve_population(void);

   void evaluate_population(void);

   // Fitness assignment methods

   void perform_linear_ranking_fitness_assignment(void);

   // Selection methods

   void perform_roulette_wheel_selection(void);

   // Recombination methods

   void perform_intermediate_recombination(void);
   void perform_line_recombination(void);

   // Mutation methods

   void perform_normal_mutation(void);
   void perform_uniform_mutation(void);

   // Training methods

   EvolutionaryAlgorithmResults* perform_training(void);

   std::string write_training_algorithm_type(void) const;

   // Serialization methods

   Matrix<std::string> to_string_matrix(void) const;

   tinyxml2::XMLDocument* to_XML(void) const;
   void from_XML(const tinyxml2::XMLDocument&);

   void initialize_random(void);

private:

   // MEMBERS

   // Population stuff


   Matrix<double> population;


   Vector<double> performance;


   Vector<double> fitness;


   Vector<bool> selection;

   // Training operators


   FitnessAssignmentMethod fitness_assignment_method;


   SelectionMethod selection_method;


   RecombinationMethod recombination_method;


   MutationMethod mutation_method;
   

   size_t elitism_size;


   double selective_pressure;


   double recombination_size;


   double mutation_rate;


   double mutation_range;


   double warning_parameters_norm;

   
   double error_parameters_norm;


   // STOPPING CRITERIA


   double mean_performance_goal;


   double standard_deviation_performance_goal;


   double best_performance_goal;


   size_t maximum_generations_number;


   size_t maximum_generalization_performance_decreases;


   double maximum_time;

   // Training history


   bool reserve_population_history;


   bool reserve_best_individual_history;


   bool reserve_mean_norm_history;


   bool reserve_standard_deviation_norm_history;


   bool reserve_best_norm_history;


   bool reserve_mean_performance_history;


   bool reserve_standard_deviation_performance_history;


   bool reserve_best_performance_history;


   bool reserve_elapsed_time_history;


   bool reserve_generalization_performance_history;
};

}

#endif


// OpenNN: An Open Source Neural Networks C++ OpenNN.
// Copyright (c) 2005-2015 Roberto Lopez.
//
// This OpenNN is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or any later version.
//
// This OpenNN is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.

// You should have received a copy of the GNU Lesser General Public
// License along with this OpenNN; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA