150 lines
4.5 KiB
C++
150 lines
4.5 KiB
C++
// Program to test several EO-ES features
|
|
|
|
#ifdef _MSC_VER
|
|
#pragma warning(disable:4786)
|
|
#endif
|
|
|
|
#include <algorithm>
|
|
#include <string>
|
|
#include <iostream>
|
|
#include <iterator>
|
|
#include <stdexcept>
|
|
|
|
using namespace std;
|
|
|
|
#include <utils/eoParser.h>
|
|
#include <utils/eoState.h>
|
|
|
|
#include <utils/eoStat.h>
|
|
#include <utils/eoFileMonitor.h>
|
|
|
|
// population
|
|
#include <eoPop.h>
|
|
|
|
// evaluation specific
|
|
#include <eoEvalFuncPtr.h>
|
|
|
|
// representation specific
|
|
#include <es/evolution_strategies>
|
|
|
|
#include "real_value.h" // the sphere fitness
|
|
|
|
// Now the main
|
|
///////////////
|
|
typedef double FitT;
|
|
|
|
template <class EOT>
|
|
void runAlgorithm(EOT, eoParser& _parser, eoState& _state, eoEsObjectiveBounds& _bounds);
|
|
|
|
main(int argc, char *argv[])
|
|
{
|
|
// Create the command-line parser
|
|
eoParser parser( argc, argv, "Basic EA for vector<float> with adaptive mutations");
|
|
|
|
// Define Parameters and load them
|
|
eoValueParam<uint32>& seed = parser.createParam(static_cast<uint32>(time(0)), "seed", "Random number seed");
|
|
eoValueParam<string>& load_name = parser.createParam(string(), "Load","Load a state file",'L');
|
|
eoValueParam<string>& save_name = parser.createParam(string(), "Save","Saves a state file",'S');
|
|
eoValueParam<bool>& stdevs = parser.createParam(true, "Stdev", "Use adaptive mutation rates", 's');
|
|
eoValueParam<bool>& corr = parser.createParam(true, "Correl", "Use correlated mutations", 'c');
|
|
eoValueParam<unsigned>& chromSize = parser.createParam(unsigned(1), "ChromSize", "Number of chromosomes", 'n');
|
|
eoValueParam<double>& minimum = parser.createParam(-1.e5, "Min", "Minimum for Objective Variables", 'l');
|
|
eoValueParam<double>& maximum = parser.createParam(1.e5, "Max", "Maximum for Objective Variables", 'h');
|
|
|
|
eoState state;
|
|
state.registerObject(parser);
|
|
rng.reseed(seed.value());
|
|
|
|
if (!load_name.value().empty())
|
|
{ // load the parser. This is only neccessary when the user wants to
|
|
// be able to change the parameters in the state file by hand.
|
|
state.load(load_name.value()); // load the parser
|
|
}
|
|
|
|
state.registerObject(rng);
|
|
|
|
eoEsObjectiveBounds bounds(chromSize.value(), minimum.value(), maximum.value());
|
|
|
|
// Run the appropriate algorithm
|
|
if (stdevs.value() == false && corr.value() == false)
|
|
{
|
|
runAlgorithm(eoEsSimple<FitT>() ,parser, state, bounds);
|
|
}
|
|
else if (corr.value() == true)
|
|
{
|
|
runAlgorithm(eoEsFull<FitT>(),parser, state, bounds);
|
|
}
|
|
else
|
|
{
|
|
runAlgorithm(eoEsStdev<FitT>(), parser, state, bounds);
|
|
}
|
|
|
|
// and save
|
|
if (!save_name.value().empty())
|
|
{
|
|
string file_name = save_name.value();
|
|
save_name.value() = ""; // so that it does not appear in the parser section of the state file
|
|
state.save(file_name);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
template <class EOT>
|
|
void runAlgorithm(EOT, eoParser& _parser, eoState& _state, eoEsObjectiveBounds& _bounds)
|
|
{
|
|
// evaluation
|
|
eoEvalFuncPtr<eoFixedLength<FitT, double> > eval( real_value );
|
|
|
|
// population parameters, unfortunately these can not be altered in the state file
|
|
eoValueParam<unsigned> mu = _parser.createParam(unsigned(50), "mu","Size of the population");
|
|
eoValueParam<unsigned>lambda = _parser.createParam(unsigned(250), "lambda", "No. of children to produce");
|
|
|
|
if (mu.value() > lambda.value())
|
|
{
|
|
throw logic_error("Mu must be smaller than lambda in a comma strategy");
|
|
}
|
|
|
|
// Initialization
|
|
eoEsChromInit<EOT> init(_bounds);
|
|
eoPop<EOT>& pop = _state.takeOwnership(eoPop<EOT>(mu.value(), init));
|
|
|
|
_state.registerObject(pop);
|
|
|
|
// evaluate initial population
|
|
eval.range(pop.begin(), pop.end());
|
|
|
|
// Ok, time to set up the algorithm
|
|
// Proxy for the mutation parameters
|
|
eoEsMutationInit mutateInit(_parser);
|
|
|
|
eoEsMutate<EOT> mutate(mutateInit, _bounds);
|
|
|
|
// monitoring, statistics etc.
|
|
eoAverageStat<EOT> average;
|
|
eoFileMonitor monitor("test.csv");
|
|
|
|
monitor.add(average);
|
|
|
|
// Okok, I'm lazy, here's the algorithm defined inline
|
|
|
|
for (unsigned i = 0; i < 20; ++i)
|
|
{
|
|
pop.resize(pop.size() + lambda.value());
|
|
|
|
for (unsigned j = mu.value(); j < pop.size(); ++j)
|
|
{
|
|
pop[j] = pop[rng.random(mu.value())];
|
|
mutate(pop[j]);
|
|
eval(pop[j]);
|
|
}
|
|
|
|
// comma strategy
|
|
std::sort(pop.begin() + mu.value(), pop.end());
|
|
copy(pop.begin() + mu.value(), pop.begin() + 2 * mu.value(), pop.begin());
|
|
pop.resize(mu.value());
|
|
|
|
average(pop);
|
|
monitor();
|
|
}
|
|
}
|