| //-----------------------------------------------------------------------------
// FirstRealEA.cpp //----------------------------------------------------------------------------- //* // Still an instance of a VERY simple Real-coded Genetic Algorithm // (see FirstBitGA.cpp) but now with Breeder - and Combined Ops // //----------------------------------------------------------------------------- // standard includes #include <stdexcept> // runtime_error #include <iostream> // cout #include <strstream> // ostrstream, istrstream // the general include for eo #include <eo> |
| #include <es.h> //----------------------------------------------------------------------------- // define your individuals typedef eoReal<double> Indi; |
| //-----------------------------------------------------------------------------
// a simple fitness function that computes the euclidian norm of a real vector // Now in a separate file, and declared as binary_value(const vector<bool> &) #include "real_value.h" |
| //-----------------------------------------------------------------------------
void main_function(int argc, char **argv) { |
| const unsigned int SEED = 42; //
seed for random number generator
const unsigned int T_SIZE = 3; // size for tournament selection const unsigned int VEC_SIZE = 8; // Number of object variables in genotypes const unsigned int POP_SIZE = 20; // Size of population const unsigned int MAX_GEN = 500; // Maximum number of generation before STOP const unsigned int MIN_GEN = 10; // Minimum number of generation before ... const unsigned int STEADY_GEN = 50; // stop after STEADY_GEN gen. without improvelent const float P_CROSS = 0.8; // Crossover probability const float P_MUT = 0.5; // mutation probability const double EPSILON = 0.01; // range for real uniform mutation double SIGMA = 0.3; // std dev. for normal mutation // some parameters for chosing among different operators const double hypercubeRate = 0.5; // relative weight for hypercube Xover const double segmentRate = 0.5; // relative weight for segment Xover const double uniformMutRate = 0.5; // relative weight for uniform mutation const double detMutRate = 0.5; // relative weight for det-uniform mutation const double normalMutRate = 0.5; // relative weight for normal mutation |
| //////////////////////////
// Random seed ////////////////////////// //reproducible random seed: if you don't change SEED above, // you'll aways get the same result, NOT a random run rng.reseed(SEED); |
| /////////////////////////////
// Fitness function //////////////////////////// // Evaluation: from a plain C++ fn to an EvalFunc Object // you need to give the full description of the function eoEvalFuncPtr<Indi, double, const vector<double>& > eval( real_value ); |
| ////////////////////////////////
// Initilisation of population //////////////////////////////// // based on a uniform generator eoInitFixedLength<Indi, uniform_generator<double> > random(VEC_SIZE, uniform_generator<double>(-1.0, 1.0)); // Initialization of the population eoPop<Indi> pop(POP_SIZE, random); // and evaluate it in one loop
|
| // sort pop before printing
it!
pop.sort(); // Print (sorted) intial population (raw printout) cout << "Initial Population" << endl; cout << pop; |
| /////////////////////////////////////
// selection and replacement //////////////////////////////////// |
| // The robust tournament selection
eoDetTournamentSelect<Indi> selectOne(T_SIZE); // is now encapsulated in a eoSelectPerc (entage) eoSelectPerc<Indi> select(selectOne);// by default rate==1 |
| // And we now have the full
slection/replacement - though with
// no replacement (== generational replacement) at the moment :-) eoNoReplacement<Indi> replace; |
| //////////////////////////////////////
// The variation operators ////////////////////////////////////// |
| // uniform chooce on segment
made by the parents
eoSegmentCrossover<Indi> xoverS; // uniform choice in hypercube built by the parents eoHypercubeCrossover<Indi> xoverA; // Combine them with relative weights eoPropCombinedQuadOp<Indi> xover(xoverS, segmentRate); xover.add(xoverA, hypercubeRate, true); |
|
// offspring(i) uniformly chosen in [parent(i)-epsilon, parent(i)+epsilon] eoUniformMutation<Indi> mutationU(EPSILON); // k (=1) coordinates of parents are uniformly modified eoDetUniformMutation<Indi> mutationD(EPSILON); // all coordinates of parents are normally modified (stDev SIGMA) eoNormalMutation<Indi> mutationN(SIGMA); // Combine them with relative weights eoPropCombinedMonOp<Indi> mutation(mutationU, uniformMutRate); mutation.add(mutationD, detMutRate); mutation.add(mutationN, normalMutRate, true); // The operators are encapsulated
into an eoTRansform object
|
| //////////////////////////////////////
// termination conditions: use more than one ///////////////////////////////////// // stop after MAX_GEN generations eoGenContinue<Indi> genCont(MAX_GEN); // do MIN_GEN gen., then stop after STEADY_GEN gen. without improvement eoSteadyFitContinue<Indi> steadyCont(MIN_GEN, STEADY_GEN); // stop when fitness reaches a target (here VEC_SIZE) eoFitContinue<Indi> fitCont(0); // do stop when one of the above says so eoCombinedContinue<Indi> continuator(genCont); continuator.add(steadyCont); continuator.add(fitCont); |
| /////////////////////////////////////////
// the algorithm //////////////////////////////////////// // Easy EA requires // selection, transformation, eval, replacement, and stopping criterion eoEasyEA<Indi> gga(continuator, eval, select, transform, replace); // Apply algo to pop - that's it! cout << "\n Here we go\n\n"; gga(pop); |
| // Print (sorted) intial population
pop.sort(); cout << "FINAL Population\n" << pop << endl; |
| }
// A main that catches the exceptions int main(int argc, char **argv) { #ifdef _MSC_VER // rng.reseed(42); int flag = _CrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF); flag |= _CRTDBG_LEAK_CHECK_DF; _CrtSetDbgFlag(flag); // _CrtSetBreakAlloc(100); #endif try { main_function(argc, argv); } catch(exception& e) { cout << "Exception: " << e.what() << '\n'; } return 1; } |