Use getORcreateParam instead of createParam when getting values from
the eoParser. Update setORcreateParam.
This commit is contained in:
kuepper
parent
f948ccda3a
commit
438e8ef6d6
9 changed files with 290 additions and 194 deletions
|
|
@ -3,7 +3,7 @@
|
|||
//-----------------------------------------------------------------------------
|
||||
// eoEsMutationInit.h
|
||||
// (c) GeNeura Team, 1998 - EEAAX 1999 - Maarten Keijzer 2000
|
||||
/*
|
||||
/*
|
||||
This library 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
|
||||
|
|
@ -34,11 +34,11 @@
|
|||
|
||||
eoESMutationInit. Proxy class that is used for initializing the mutation
|
||||
operator. It provides an interface between eoEsMutate and the abstract
|
||||
parameterLoader. It also provides the names for the parameters in this
|
||||
parameterLoader. It also provides the names for the parameters in this
|
||||
class as virtual protected member functions.
|
||||
|
||||
|
||||
If you have more than a single ES in a project that need different
|
||||
names in the configuration files, you might consider overriding this class
|
||||
names in the configuration files, you might consider overriding this class
|
||||
to change the names.
|
||||
|
||||
@see eoEsMutate
|
||||
|
|
@ -47,9 +47,9 @@ class eoEsMutationInit
|
|||
{
|
||||
public :
|
||||
|
||||
eoEsMutationInit(eoParser& _parser,
|
||||
std::string _section="ES mutation parameters" ) :
|
||||
parser(_parser), repSection(_section),
|
||||
eoEsMutationInit(eoParser& _parser,
|
||||
std::string _section="ES mutation parameters" ) :
|
||||
parser(_parser), repSection(_section),
|
||||
TauLclParam(0), TauGlbParam(0), TauBetaParam(0) {}
|
||||
|
||||
// because we have virtual function - size
|
||||
|
|
@ -59,7 +59,9 @@ class eoEsMutationInit
|
|||
{
|
||||
if (TauLclParam == 0)
|
||||
{
|
||||
TauLclParam = &parser.createParam(1.0, TauLclName(), "Local Tau (before normalization)", TauLclShort(), section());
|
||||
TauLclParam = &parser.getORcreateParam(1.0, TauLclName(),
|
||||
"Local Tau (before normalization)",
|
||||
TauLclShort(), section());
|
||||
}
|
||||
|
||||
return TauLclParam->value();
|
||||
|
|
@ -69,7 +71,9 @@ class eoEsMutationInit
|
|||
{
|
||||
if (TauGlbParam == 0)
|
||||
{
|
||||
TauGlbParam = &parser.createParam(1.0, TauGlbName(), "Global Tau (before normalization)", TauGlbShort(), section());
|
||||
TauGlbParam = &parser.getORcreateParam(1.0, TauGlbName(),
|
||||
"Global Tau (before normalization)",
|
||||
TauGlbShort(), section());
|
||||
}
|
||||
|
||||
return TauGlbParam->value();
|
||||
|
|
@ -79,25 +83,26 @@ class eoEsMutationInit
|
|||
{
|
||||
if (TauBetaParam == 0)
|
||||
{
|
||||
TauBetaParam = &parser.createParam(0.0873, TauBetaName(), "Beta", TauBetaShort(), section());
|
||||
TauBetaParam = &parser.getORcreateParam(0.0873, TauBetaName(),
|
||||
"Beta", TauBetaShort(), section());
|
||||
}
|
||||
|
||||
return TauBetaParam->value();
|
||||
}
|
||||
|
||||
protected :
|
||||
|
||||
virtual std::string section(void)
|
||||
|
||||
virtual std::string section(void)
|
||||
{ return repSection; }
|
||||
|
||||
virtual std::string TauLclName(void) const { return "TauLoc"; }
|
||||
virtual char TauLclShort(void) const { return 'l'; }
|
||||
|
||||
virtual std::string TauGlbName(void) const { return "TauGlob"; }
|
||||
virtual char TauGlbShort(void) const { return 'g'; }
|
||||
|
||||
virtual std::string TauBetaName(void) const { return "Beta"; }
|
||||
virtual char TauBetaShort(void) const { return 'b'; }
|
||||
virtual std::string TauGlbName(void) const { return "TauGlob"; }
|
||||
virtual char TauGlbShort(void) const { return 'g'; }
|
||||
|
||||
virtual std::string TauBetaName(void) const { return "Beta"; }
|
||||
virtual char TauBetaShort(void) const { return 'b'; }
|
||||
|
||||
private :
|
||||
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@
|
|||
//-----------------------------------------------------------------------------
|
||||
// make_genotype_real.cpp
|
||||
// (c) Maarten Keijzer, Marc Schoenauer and GeNeura Team, 2001
|
||||
/*
|
||||
/*
|
||||
This library 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
|
||||
|
|
@ -27,41 +27,47 @@
|
|||
#ifdef _MSC_VER
|
||||
// to avoid long name warnings
|
||||
#pragma warning(disable:4786)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/** This file contains ***INSTANCIATED DEFINITIONS*** of eoReal Init fns
|
||||
* It should be included in the file that calls any of the corresponding fns
|
||||
* Compiling this file allows one to generate part of the library (i.e. object
|
||||
* files that you just need to link with your own main and fitness code).
|
||||
*
|
||||
* The corresponding ***INSTANCIATED DECLARATIONS*** are contained
|
||||
* The corresponding ***INSTANCIATED DECLARATIONS*** are contained
|
||||
* in src/es/make_real.h
|
||||
* while the TEMPLATIZED code is define in make_genotype_real.h
|
||||
*
|
||||
* It is instanciated in src/es/make_genotype_real.cpp -
|
||||
* It is instanciated in src/es/make_genotype_real.cpp -
|
||||
* and incorporated in the ga/libga.a
|
||||
*
|
||||
* It returns an eoInit<EOT> that can later be used to initialize
|
||||
* It returns an eoInit<EOT> that can later be used to initialize
|
||||
* the population (see make_pop.h).
|
||||
*
|
||||
* It uses a parser (to get user parameters) and a state (to store the memory)
|
||||
* the last argument is to disambiguate the call upon different instanciations.
|
||||
*
|
||||
* WARNING: that last argument will generally be the result of calling
|
||||
* the default ctor of EOT, resulting in most cases in an EOT
|
||||
* WARNING: that last argument will generally be the result of calling
|
||||
* the default ctor of EOT, resulting in most cases in an EOT
|
||||
* that is ***not properly initialized***
|
||||
*/
|
||||
|
||||
// the templatized code
|
||||
#include <es/make_genotype_real.h>
|
||||
|
||||
/// The following function merely call the templatized do_* functions
|
||||
/// The following functions merely call the templatized do_* functions
|
||||
eoRealInitBounded<eoReal<double> > & make_genotype(eoParser& _parser,
|
||||
eoState& _state,
|
||||
eoReal<double> _eo)
|
||||
{
|
||||
return do_make_genotype(_parser, _state, _eo);
|
||||
}
|
||||
|
||||
eoRealInitBounded<eoReal<double> > & make_genotype(eoParser& _parser, eoState& _state, eoReal<double> _eo)
|
||||
|
||||
|
||||
eoRealInitBounded<eoReal<eoMinimizingFitness> > & make_genotype(eoParser& _parser,
|
||||
eoState& _state,
|
||||
eoReal<eoMinimizingFitness> _eo)
|
||||
{
|
||||
return do_make_genotype(_parser, _state, _eo);
|
||||
}
|
||||
eoRealInitBounded<eoReal<eoMinimizingFitness> > & make_genotype(eoParser& _parser, eoState& _state, eoReal<eoMinimizingFitness> _eo)
|
||||
{
|
||||
return do_make_genotype(_parser, _state, _eo);
|
||||
return do_make_genotype(_parser, _state, _eo);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@
|
|||
//-----------------------------------------------------------------------------
|
||||
// make_op.h - the real-valued version
|
||||
// (c) Maarten Keijzer, Marc Schoenauer and GeNeura Team, 2001
|
||||
/*
|
||||
/*
|
||||
This library 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
|
||||
|
|
@ -56,19 +56,21 @@
|
|||
* This is why the template is the complete EOT even though only the fitness
|
||||
* is actually templatized here: the following only applies to bitstrings
|
||||
*
|
||||
* Note : the last parameter is an eoInit: if some operator needs some info
|
||||
* Note : the last parameter is an eoInit: if some operator needs some info
|
||||
* about the gneotypes, the init has it all (e.g. bounds, ...)
|
||||
* Simply do
|
||||
* Simply do
|
||||
* EOT myEO;
|
||||
* _init(myEO);
|
||||
* and myEO is then an ACTUAL object
|
||||
*/
|
||||
|
||||
template <class EOT>
|
||||
eoGenOp<EOT> & do_make_op(eoParameterLoader& _parser, eoState& _state, eoInit<EOT>& _init)
|
||||
{
|
||||
// First, decide whether the objective variables are bounded
|
||||
eoValueParam<eoParamParamType>& boundsParam = _parser.createParam(eoParamParamType("(0,1)"), "objectBounds", "Bounds for variables (unbounded if absent)", 'B', "Genetic Operators");
|
||||
eoValueParam<eoParamParamType>& boundsParam
|
||||
= _parser.getORcreateParam(eoParamParamType("(0,1)"), "objectBounds",
|
||||
"Bounds for variables (unbounded if absent)",
|
||||
'B', "Genetic Operators");
|
||||
|
||||
// get initisalizer size == std::vector size
|
||||
// eoRealInitBounded<EOT> * realInit = (eoRealInitBounded<EOT>*)(&_init);
|
||||
|
|
@ -83,7 +85,7 @@ eoGenOp<EOT> & do_make_op(eoParameterLoader& _parser, eoState& _state, eoInit<EO
|
|||
eoRealVectorBounds * ptBounds;
|
||||
if (_parser.isItThere(boundsParam)) // otherwise, no bounds
|
||||
{
|
||||
/////Warning: this code should probably be replaced by creating
|
||||
/////Warning: this code should probably be replaced by creating
|
||||
///// some eoValueParam<eoRealVectorBounds> with specific implementation
|
||||
//// in eoParser.cpp. At the moemnt, it is there (cf also make_genotype
|
||||
eoParamParamType & ppBounds = boundsParam.value(); // std::pair<std::string,std::vector<std::string> >
|
||||
|
|
@ -98,7 +100,7 @@ eoGenOp<EOT> & do_make_op(eoParameterLoader& _parser, eoState& _state, eoInit<EO
|
|||
v.push_back(r);
|
||||
}
|
||||
// now create the eoRealVectorBounds object
|
||||
if (v.size() == 2) // a min and a max for all variables
|
||||
if (v.size() == 2) // a min and a max for all variables
|
||||
ptBounds = new eoRealVectorBounds(vecSize, v[0], v[1]);
|
||||
else // no time now
|
||||
throw std::runtime_error("Sorry, only unique bounds for all variables implemented at the moment. Come back later");
|
||||
|
|
@ -109,27 +111,34 @@ eoGenOp<EOT> & do_make_op(eoParameterLoader& _parser, eoState& _state, eoInit<EO
|
|||
ptBounds = new eoRealVectorNoBounds(vecSize); // DON'T USE eoDummyVectorNoBounds
|
||||
// as it does not have any dimension
|
||||
|
||||
// this is a temporary version(!),
|
||||
// this is a temporary version(!),
|
||||
// while Maarten codes the full tree-structured general operator input
|
||||
// BTW we must leave that simple version available somehow, as it is the one
|
||||
// that 90% people use!
|
||||
eoValueParam<std::string>& operatorParam = _parser.createParam(std::string("SGA"), "operator", "Description of the operator (SGA only now)", 'o', "Genetic Operators");
|
||||
eoValueParam<std::string>& operatorParam
|
||||
= _parser.getORcreateParam(std::string("SGA"), "operator",
|
||||
"Description of the operator (SGA only now)",
|
||||
'o', "Genetic Operators");
|
||||
|
||||
if (operatorParam.value() != std::string("SGA"))
|
||||
throw std::runtime_error("Sorry, only SGA-like operator available right now\n");
|
||||
|
||||
// now we read Pcross and Pmut,
|
||||
// now we read Pcross and Pmut,
|
||||
// the relative weights for all crossovers -> proportional choice
|
||||
// the relative weights for all mutations -> proportional choice
|
||||
// and create the eoGenOp that is exactly
|
||||
// and create the eoGenOp that is exactly
|
||||
// crossover with pcross + mutation with pmut
|
||||
|
||||
eoValueParam<double>& pCrossParam = _parser.createParam(0.6, "pCross", "Probability of Crossover", 'C', "Genetic Operators" );
|
||||
eoValueParam<double>& pCrossParam
|
||||
= _parser.getORcreateParam(0.6, "pCross", "Probability of Crossover",
|
||||
'C', "Genetic Operators" );
|
||||
// minimum check
|
||||
if ( (pCrossParam.value() < 0) || (pCrossParam.value() > 1) )
|
||||
throw std::runtime_error("Invalid pCross");
|
||||
|
||||
eoValueParam<double>& pMutParam = _parser.createParam(0.1, "pMut", "Probability of Mutation", 'M', "Genetic Operators" );
|
||||
eoValueParam<double>& pMutParam
|
||||
= _parser.getORcreateParam(0.1, "pMut", "Probability of Mutation",
|
||||
'M', "Genetic Operators" );
|
||||
// minimum check
|
||||
if ( (pMutParam.value() < 0) || (pMutParam.value() > 1) )
|
||||
throw std::runtime_error("Invalid pMut");
|
||||
|
|
@ -137,12 +146,18 @@ eoGenOp<EOT> & do_make_op(eoParameterLoader& _parser, eoState& _state, eoInit<EO
|
|||
// the crossovers
|
||||
/////////////////
|
||||
// the parameters
|
||||
eoValueParam<double>& segmentRateParam = _parser.createParam(double(1.0), "segmentRate", "Relative rate for segment crossover", 's', "Genetic Operators" );
|
||||
eoValueParam<double>& segmentRateParam
|
||||
= _parser.getORcreateParam(double(1.0), "segmentRate",
|
||||
"Relative rate for segment crossover",
|
||||
's', "Genetic Operators" );
|
||||
// minimum check
|
||||
if ( (segmentRateParam.value() < 0) )
|
||||
throw std::runtime_error("Invalid segmentRate");
|
||||
|
||||
eoValueParam<double>& arithmeticRateParam = _parser.createParam(double(2.0), "arithmeticRate", "Relative rate for arithmetic crossover", 'A', "Genetic Operators" );
|
||||
eoValueParam<double>& arithmeticRateParam
|
||||
= _parser.getORcreateParam(double(2.0), "arithmeticRate",
|
||||
"Relative rate for arithmetic crossover",
|
||||
'A', "Genetic Operators" );
|
||||
// minimum check
|
||||
if ( (arithmeticRateParam.value() < 0) )
|
||||
throw std::runtime_error("Invalid arithmeticRate");
|
||||
|
|
@ -154,23 +169,23 @@ eoGenOp<EOT> & do_make_op(eoParameterLoader& _parser, eoState& _state, eoInit<EO
|
|||
std::cerr << "Warning: no crossover" << std::endl;
|
||||
bCross = false;
|
||||
}
|
||||
|
||||
|
||||
// Create the CombinedQuadOp
|
||||
eoPropCombinedQuadOp<EOT> *ptCombinedQuadOp = NULL;
|
||||
eoQuadOp<EOT> *ptQuad = NULL;
|
||||
|
||||
if (bCross)
|
||||
if (bCross)
|
||||
{
|
||||
// segment crossover for bitstring - pass it the bounds
|
||||
ptQuad = new eoSegmentCrossover<EOT>(*ptBounds);
|
||||
_state.storeFunctor(ptQuad);
|
||||
ptCombinedQuadOp = new eoPropCombinedQuadOp<EOT>(*ptQuad, segmentRateParam.value());
|
||||
|
||||
|
||||
// arithmetic crossover
|
||||
ptQuad = new eoArithmeticCrossover<EOT>(*ptBounds);
|
||||
_state.storeFunctor(ptQuad);
|
||||
ptCombinedQuadOp->add(*ptQuad, arithmeticRateParam.value());
|
||||
|
||||
|
||||
// don't forget to store the CombinedQuadOp
|
||||
_state.storeFunctor(ptCombinedQuadOp);
|
||||
}
|
||||
|
|
@ -178,27 +193,40 @@ eoGenOp<EOT> & do_make_op(eoParameterLoader& _parser, eoState& _state, eoInit<EO
|
|||
// the mutations
|
||||
/////////////////
|
||||
// the parameters
|
||||
eoValueParam<double> & epsilonParam = _parser.createParam(0.01, "epsilon", "Half-size of interval for Uniform Mutation", 'e', "Genetic Operators" );
|
||||
eoValueParam<double> & epsilonParam
|
||||
= _parser.getORcreateParam(0.01, "epsilon", "Half-size of interval for Uniform Mutation",
|
||||
'e', "Genetic Operators" );
|
||||
// minimum check
|
||||
if ( (epsilonParam.value() < 0) )
|
||||
throw std::runtime_error("Invalid epsilon");
|
||||
|
||||
eoValueParam<double> & uniformMutRateParam = _parser.createParam(1.0, "uniformMutRate", "Relative rate for uniform mutation", 'u', "Genetic Operators" );
|
||||
eoValueParam<double> & uniformMutRateParam
|
||||
= _parser.getORcreateParam(1.0, "uniformMutRate",
|
||||
"Relative rate for uniform mutation", 'u', "Genetic Operators" );
|
||||
// minimum check
|
||||
if ( (uniformMutRateParam.value() < 0) )
|
||||
throw std::runtime_error("Invalid uniformMutRate");
|
||||
|
||||
eoValueParam<double> & detMutRateParam = _parser.createParam(1.0, "detMutRate", "Relative rate for deterministic uniform mutation", 'd', "Genetic Operators" );
|
||||
|
||||
eoValueParam<double> & detMutRateParam
|
||||
= _parser.getORcreateParam(1.0, "detMutRate",
|
||||
"Relative rate for deterministic uniform mutation",
|
||||
'd', "Genetic Operators" );
|
||||
// minimum check
|
||||
if ( (detMutRateParam.value() < 0) )
|
||||
throw std::runtime_error("Invalid detMutRate");
|
||||
|
||||
eoValueParam<double> & normalMutRateParam = _parser.createParam(1.0, "normalMutRate", "Relative rate for Gaussian mutation", 'd', "Genetic Operators" );
|
||||
eoValueParam<double> & normalMutRateParam
|
||||
= _parser.getORcreateParam(1.0, "normalMutRate",
|
||||
"Relative rate for Gaussian mutation",
|
||||
'd', "Genetic Operators" );
|
||||
// minimum check
|
||||
if ( (normalMutRateParam.value() < 0) )
|
||||
throw std::runtime_error("Invalid normalMutRate");
|
||||
// and the sigma
|
||||
eoValueParam<double> & sigmaParam = _parser.createParam(1.0, "sigma", "Sigma (fixed) for Gaussian mutation", 'S', "Genetic Operators" );
|
||||
eoValueParam<double> & sigmaParam
|
||||
= _parser.getORcreateParam(1.0, "sigma",
|
||||
"Sigma (fixed) for Gaussian mutation",
|
||||
'S', "Genetic Operators" );
|
||||
// minimum check
|
||||
if ( (sigmaParam.value() < 0) )
|
||||
throw std::runtime_error("Invalid sigma");
|
||||
|
|
@ -225,14 +253,14 @@ eoGenOp<EOT> & do_make_op(eoParameterLoader& _parser, eoState& _state, eoInit<EO
|
|||
_state.storeFunctor(ptMon);
|
||||
// create the CombinedMonOp
|
||||
ptCombinedMonOp = new eoPropCombinedMonOp<EOT>(*ptMon, uniformMutRateParam.value());
|
||||
|
||||
|
||||
// mutate exactly 1 component (uniformly) per individual
|
||||
ptMon = new eoDetUniformMutation<EOT>(*ptBounds, epsilonParam.value());
|
||||
ptMon = new eoDetUniformMutation<EOT>(*ptBounds, epsilonParam.value());
|
||||
_state.storeFunctor(ptMon);
|
||||
ptCombinedMonOp->add(*ptMon, detMutRateParam.value());
|
||||
|
||||
|
||||
// mutate all component using Gaussian mutation
|
||||
ptMon = new eoNormalMutation<EOT>(*ptBounds, sigmaParam.value());
|
||||
ptMon = new eoNormalMutation<EOT>(*ptBounds, sigmaParam.value());
|
||||
_state.storeFunctor(ptMon);
|
||||
ptCombinedMonOp->add(*ptMon, normalMutRateParam.value());
|
||||
_state.storeFunctor(ptCombinedMonOp);
|
||||
|
|
@ -242,7 +270,7 @@ eoGenOp<EOT> & do_make_op(eoParameterLoader& _parser, eoState& _state, eoInit<EO
|
|||
// to simulate SGA (crossover with proba pCross + mutation with proba pMut
|
||||
// we must construct
|
||||
// a sequential combination of
|
||||
// with proba 1, a proportional combination of
|
||||
// with proba 1, a proportional combination of
|
||||
// a QuadCopy and our crossover
|
||||
// with proba pMut, our mutation
|
||||
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@
|
|||
//-----------------------------------------------------------------------------
|
||||
// make_op.h - the real-valued version
|
||||
// (c) Maarten Keijzer, Marc Schoenauer and GeNeura Team, 2001
|
||||
/*
|
||||
/*
|
||||
This library 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
|
||||
|
|
@ -59,9 +59,9 @@
|
|||
* This is why the template is the complete EOT even though only the fitness
|
||||
* is actually templatized here: the following only applies to bitstrings
|
||||
*
|
||||
* Note : the last parameter is an eoInit: if some operator needs some info
|
||||
* Note : the last parameter is an eoInit: if some operator needs some info
|
||||
* about the gneotypes, the init has it all (e.g. bounds, ...)
|
||||
* Simply do
|
||||
* Simply do
|
||||
* EOT myEO;
|
||||
* _init(myEO);
|
||||
* and myEO is then an ACTUAL object
|
||||
|
|
@ -74,24 +74,33 @@ eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoRealInitBounded<
|
|||
unsigned vecSize = _init.size();
|
||||
|
||||
// First, decide whether the objective variables are bounded
|
||||
eoValueParam<eoRealVectorBounds>& boundsParam = _parser.createParam(eoRealVectorBounds(vecSize,eoDummyRealNoBounds), "objectBounds", "Bounds for variables", 'B', "Variation Operators");
|
||||
eoValueParam<eoRealVectorBounds>& boundsParam
|
||||
= _parser.getORcreateParam(eoRealVectorBounds(vecSize,eoDummyRealNoBounds),
|
||||
"objectBounds", "Bounds for variables", 'B', "Variation Operators");
|
||||
|
||||
// now we read Pcross and Pmut,
|
||||
eoValueParam<std::string>& operatorParam = _parser.createParam(std::string("SGA"), "operator", "Description of the operator (SGA only now)", 'o', "Variation Operators");
|
||||
// now we read Pcross and Pmut,
|
||||
eoValueParam<std::string>& operatorParam
|
||||
= _parser.getORcreateParam(std::string("SGA"), "operator",
|
||||
"Description of the operator (SGA only now)",
|
||||
'o', "Variation Operators");
|
||||
|
||||
if (operatorParam.value() != std::string("SGA"))
|
||||
throw std::runtime_error("Sorry, only SGA-like operator available right now\n");
|
||||
|
||||
// now we read Pcross and Pmut,
|
||||
// and create the eoGenOp that is exactly
|
||||
// now we read Pcross and Pmut,
|
||||
// and create the eoGenOp that is exactly
|
||||
// crossover with pcross + mutation with pmut
|
||||
|
||||
eoValueParam<double>& pCrossParam = _parser.createParam(1.0, "pCross", "Probability of Crossover", 'C', "Variation Operators" );
|
||||
eoValueParam<double>& pCrossParam
|
||||
= _parser.getORcreateParam(1.0, "pCross", "Probability of Crossover",
|
||||
'C', "Variation Operators" );
|
||||
// minimum check
|
||||
if ( (pCrossParam.value() < 0) || (pCrossParam.value() > 1) )
|
||||
throw std::runtime_error("Invalid pCross");
|
||||
|
||||
eoValueParam<double>& pMutParam = _parser.createParam(1.0, "pMut", "Probability of Mutation", 'M', "Variation Operators" );
|
||||
eoValueParam<double>& pMutParam
|
||||
= _parser.getORcreateParam(1.0, "pMut", "Probability of Mutation",
|
||||
'M', "Variation Operators" );
|
||||
// minimum check
|
||||
if ( (pMutParam.value() < 0) || (pMutParam.value() > 1) )
|
||||
throw std::runtime_error("Invalid pMut");
|
||||
|
|
@ -100,10 +109,19 @@ eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoRealInitBounded<
|
|||
// crossover
|
||||
/////////////
|
||||
// ES crossover
|
||||
eoValueParam<std::string>& crossTypeParam = _parser.createParam(std::string("global"), "crossType", "Type of ES recombination (global or standard)", 'C', "Variation Operators");
|
||||
|
||||
eoValueParam<std::string>& crossObjParam = _parser.createParam(std::string("discrete"), "crossObj", "Recombination of object variables (discrete, intermediate or none)", 'O', "Variation Operators");
|
||||
eoValueParam<std::string>& crossStdevParam = _parser.createParam(std::string("intermediate"), "crossStdev", "Recombination of mutation strategy parameters (intermediate, discrete or none)", 'S', "Variation Operators");
|
||||
eoValueParam<std::string>& crossTypeParam
|
||||
= _parser.getORcreateParam(std::string("global"), "crossType",
|
||||
"Type of ES recombination (global or standard)",
|
||||
'C', "Variation Operators");
|
||||
|
||||
eoValueParam<std::string>& crossObjParam
|
||||
= _parser.getORcreateParam(std::string("discrete"), "crossObj",
|
||||
"Recombination of object variables (discrete, intermediate or none)",
|
||||
'O', "Variation Operators");
|
||||
eoValueParam<std::string>& crossStdevParam
|
||||
= _parser.getORcreateParam(std::string("intermediate"), "crossStdev",
|
||||
"Recombination of mutation strategy parameters (intermediate, discrete or none)",
|
||||
'S', "Variation Operators");
|
||||
|
||||
// The pointers: first the atom Xover
|
||||
eoBinOp<double> *ptObjAtomCross = NULL;
|
||||
|
|
@ -128,7 +146,7 @@ eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoRealInitBounded<
|
|||
ptStdevAtomCross = new eoBinCloneOp<double>;
|
||||
else throw std::runtime_error("Invalid mutation strategy parameter crossover type");
|
||||
|
||||
// and build the indi Xover
|
||||
// and build the indi Xover
|
||||
if (crossTypeParam.value() == std::string("global"))
|
||||
ptCross = new eoEsGlobalXover<EOT>(*ptObjAtomCross, *ptStdevAtomCross);
|
||||
else if (crossTypeParam.value() == std::string("standard"))
|
||||
|
|
@ -145,15 +163,15 @@ eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoRealInitBounded<
|
|||
_state.storeFunctor(ptStdevAtomCross);
|
||||
_state.storeFunctor(ptCross);
|
||||
|
||||
// mutation
|
||||
// mutation
|
||||
/////////////
|
||||
|
||||
// Ok, time to set up the self-adaptive mutation
|
||||
// Proxy for the mutation parameters
|
||||
eoEsMutationInit mutateInit(_parser, "Variation Operators");
|
||||
|
||||
|
||||
eoEsMutate<EOT> & mut = _state.storeFunctor(
|
||||
new eoEsMutate<EOT>(mutateInit, boundsParam.value()));
|
||||
new eoEsMutate<EOT>(mutateInit, boundsParam.value()));
|
||||
|
||||
// now the general op - a sequential application of crossover and mutatation
|
||||
// no need to first have crossover combined with a clone as it is an
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@
|
|||
//-----------------------------------------------------------------------------
|
||||
// make_op.h - the real-valued version
|
||||
// (c) Maarten Keijzer, Marc Schoenauer and GeNeura Team, 2001
|
||||
/*
|
||||
/*
|
||||
This library 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
|
||||
|
|
@ -56,9 +56,9 @@
|
|||
* This is why the template is the complete EOT even though only the fitness
|
||||
* is actually templatized here: the following only applies to bitstrings
|
||||
*
|
||||
* Note : the last parameter is an eoInit: if some operator needs some info
|
||||
* Note : the last parameter is an eoInit: if some operator needs some info
|
||||
* about the gneotypes, the init has it all (e.g. bounds, ...)
|
||||
* Simply do
|
||||
* Simply do
|
||||
* EOT myEO;
|
||||
* _init(myEO);
|
||||
* and myEO is then an ACTUAL object
|
||||
|
|
@ -71,29 +71,40 @@ eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoRealInitBounded<
|
|||
unsigned vecSize = _init.size();
|
||||
|
||||
// First, decide whether the objective variables are bounded
|
||||
eoValueParam<eoRealVectorBounds>& boundsParam = _parser.createParam(eoRealVectorBounds(vecSize,eoDummyRealNoBounds), "objectBounds", "Bounds for variables", 'B', "Variation Operators");
|
||||
eoValueParam<eoRealVectorBounds>& boundsParam
|
||||
= _parser.getORcreateParam(eoRealVectorBounds(vecSize,eoDummyRealNoBounds), "objectBounds",
|
||||
"Bounds for variables", 'B', "Variation Operators");
|
||||
|
||||
// this is a temporary version(!),
|
||||
// this is a temporary version(!),
|
||||
// while Maarten codes the full tree-structured general operator input
|
||||
// BTW we must leave that simple version available somehow, as it is the one
|
||||
// that 90% people use!
|
||||
eoValueParam<std::string>& operatorParam = _parser.createParam(std::string("SGA"), "operator", "Description of the operator (SGA only now)", 'o', "Variation Operators");
|
||||
eoValueParam<std::string>& operatorParam
|
||||
= _parser.getORcreateParam(std::string("SGA"), "operator",
|
||||
"Description of the operator (SGA only now)",
|
||||
'o', "Variation Operators");
|
||||
|
||||
if (operatorParam.value() != std::string("SGA"))
|
||||
throw std::runtime_error("Sorry, only SGA-like operator available right now\n");
|
||||
|
||||
// now we read Pcross and Pmut,
|
||||
// now we read Pcross and Pmut,
|
||||
// the relative weights for all crossovers -> proportional choice
|
||||
// the relative weights for all mutations -> proportional choice
|
||||
// and create the eoGenOp that is exactly
|
||||
// and create the eoGenOp that is exactly
|
||||
// crossover with pcross + mutation with pmut
|
||||
|
||||
eoValueParam<double>& pCrossParam = _parser.createParam(0.6, "pCross", "Probability of Crossover", 'C', "Variation Operators" );
|
||||
eoValueParam<double>& pCrossParam
|
||||
= _parser.getORcreateParam(0.6, "pCross",
|
||||
"Probability of Crossover",
|
||||
'C', "Variation Operators" );
|
||||
// minimum check
|
||||
if ( (pCrossParam.value() < 0) || (pCrossParam.value() > 1) )
|
||||
throw std::runtime_error("Invalid pCross");
|
||||
|
||||
eoValueParam<double>& pMutParam = _parser.createParam(0.1, "pMut", "Probability of Mutation", 'M', "Variation Operators" );
|
||||
eoValueParam<double>& pMutParam
|
||||
= _parser.getORcreateParam(0.1, "pMut",
|
||||
"Probability of Mutation",
|
||||
'M', "Variation Operators" );
|
||||
// minimum check
|
||||
if ( (pMutParam.value() < 0) || (pMutParam.value() > 1) )
|
||||
throw std::runtime_error("Invalid pMut");
|
||||
|
|
@ -101,23 +112,35 @@ eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoRealInitBounded<
|
|||
// the crossovers
|
||||
/////////////////
|
||||
// the parameters
|
||||
eoValueParam<double>& alphaParam = _parser.createParam(double(0.0), "alpha", "Bound for factor of linear recombinations", 'a', "Variation Operators" );
|
||||
eoValueParam<double>& alphaParam
|
||||
= _parser.getORcreateParam(double(0.0), "alpha",
|
||||
"Bound for factor of linear recombinations",
|
||||
'a', "Variation Operators" );
|
||||
// minimum check
|
||||
if ( (alphaParam.value() < 0) )
|
||||
throw std::runtime_error("Invalid BLX coefficient alpha");
|
||||
|
||||
|
||||
eoValueParam<double>& segmentRateParam = _parser.createParam(double(1.0), "segmentRate", "Relative rate for segment crossover", 's', "Variation Operators" );
|
||||
eoValueParam<double>& segmentRateParam
|
||||
= _parser.getORcreateParam(double(1.0), "segmentRate",
|
||||
"Relative rate for segment crossover",
|
||||
's', "Variation Operators" );
|
||||
// minimum check
|
||||
if ( (segmentRateParam.value() < 0) )
|
||||
throw std::runtime_error("Invalid segmentRate");
|
||||
|
||||
eoValueParam<double>& hypercubeRateParam = _parser.createParam(double(1.0), "hypercubeRate", "Relative rate for hypercube crossover", 'A', "Variation Operators" );
|
||||
eoValueParam<double>& hypercubeRateParam
|
||||
= _parser.getORcreateParam(double(1.0), "hypercubeRate",
|
||||
"Relative rate for hypercube crossover",
|
||||
'A', "Variation Operators" );
|
||||
// minimum check
|
||||
if ( (hypercubeRateParam.value() < 0) )
|
||||
throw std::runtime_error("Invalid hypercubeRate");
|
||||
|
||||
eoValueParam<double>& uxoverRateParam = _parser.createParam(double(1.0), "uxoverRate", "Relative rate for uniform crossover", 'A', "Variation Operators" );
|
||||
eoValueParam<double>& uxoverRateParam
|
||||
= _parser.getORcreateParam(double(1.0), "uxoverRate",
|
||||
"Relative rate for uniform crossover",
|
||||
'A', "Variation Operators" );
|
||||
// minimum check
|
||||
if ( (uxoverRateParam.value() < 0) )
|
||||
throw std::runtime_error("Invalid uxoverRate");
|
||||
|
|
@ -129,28 +152,28 @@ eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoRealInitBounded<
|
|||
std::cerr << "Warning: no crossover" << std::endl;
|
||||
bCross = false;
|
||||
}
|
||||
|
||||
|
||||
// Create the CombinedQuadOp
|
||||
eoPropCombinedQuadOp<EOT> *ptCombinedQuadOp = NULL;
|
||||
eoQuadOp<EOT> *ptQuad = NULL;
|
||||
|
||||
if (bCross)
|
||||
if (bCross)
|
||||
{
|
||||
// segment crossover for bitstring - pass it the bounds
|
||||
ptQuad = new eoSegmentCrossover<EOT>(boundsParam.value(), alphaParam.value());
|
||||
_state.storeFunctor(ptQuad);
|
||||
ptCombinedQuadOp = new eoPropCombinedQuadOp<EOT>(*ptQuad, segmentRateParam.value());
|
||||
|
||||
|
||||
// hypercube crossover
|
||||
ptQuad = new eoHypercubeCrossover<EOT>(boundsParam.value(), alphaParam.value());
|
||||
_state.storeFunctor(ptQuad);
|
||||
ptCombinedQuadOp->add(*ptQuad, hypercubeRateParam.value());
|
||||
|
||||
|
||||
// uniform crossover
|
||||
ptQuad = new eoRealUXover<EOT>();
|
||||
_state.storeFunctor(ptQuad);
|
||||
ptCombinedQuadOp->add(*ptQuad, uxoverRateParam.value());
|
||||
|
||||
|
||||
// don't forget to store the CombinedQuadOp
|
||||
_state.storeFunctor(ptCombinedQuadOp);
|
||||
}
|
||||
|
|
@ -158,29 +181,46 @@ eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoRealInitBounded<
|
|||
// the mutations
|
||||
/////////////////
|
||||
// the parameters
|
||||
eoValueParam<double> & epsilonParam = _parser.createParam(0.01, "epsilon", "Half-size of interval for Uniform Mutation", 'e', "Variation Operators" );
|
||||
eoValueParam<double> & epsilonParam
|
||||
= _parser.getORcreateParam(0.01, "epsilon",
|
||||
"Half-size of interval for Uniform Mutation",
|
||||
'e', "Variation Operators" );
|
||||
// minimum check
|
||||
if ( (epsilonParam.value() < 0) )
|
||||
throw std::runtime_error("Invalid epsilon");
|
||||
|
||||
eoValueParam<double> & uniformMutRateParam = _parser.createParam(1.0, "uniformMutRate", "Relative rate for uniform mutation", 'u', "Variation Operators" );
|
||||
eoValueParam<double> & uniformMutRateParam
|
||||
= _parser.getORcreateParam(1.0, "uniformMutRate",
|
||||
"Relative rate for uniform mutation",
|
||||
'u', "Variation Operators" );
|
||||
// minimum check
|
||||
if ( (uniformMutRateParam.value() < 0) )
|
||||
throw std::runtime_error("Invalid uniformMutRate");
|
||||
|
||||
eoValueParam<double> & detMutRateParam = _parser.createParam(1.0, "detMutRate", "Relative rate for deterministic uniform mutation", 'd', "Variation Operators" );
|
||||
|
||||
eoValueParam<double> & detMutRateParam
|
||||
= _parser.getORcreateParam(1.0, "detMutRate",
|
||||
"Relative rate for deterministic uniform mutation",
|
||||
'd', "Variation Operators" );
|
||||
// minimum check
|
||||
if ( (detMutRateParam.value() < 0) )
|
||||
throw std::runtime_error("Invalid detMutRate");
|
||||
|
||||
eoValueParam<double> & normalMutRateParam = _parser.createParam(1.0, "normalMutRate", "Relative rate for Gaussian mutation", 'd', "Variation Operators" );
|
||||
eoValueParam<double> & normalMutRateParam
|
||||
= _parser.getORcreateParam(1.0, "normalMutRate",
|
||||
"Relative rate for Gaussian mutation", 'd', "Variation Operators" );
|
||||
// minimum check
|
||||
if ( (normalMutRateParam.value() < 0) )
|
||||
throw std::runtime_error("Invalid normalMutRate");
|
||||
|
||||
eoValueParam<double> & sigmaParam = _parser.createParam(0.3, "sigma", "Sigma (fixed) for Gaussian mutation", 's', "Variation Operators" );
|
||||
eoValueParam<double> & sigmaParam
|
||||
= _parser.getORcreateParam(0.3, "sigma",
|
||||
"Sigma (fixed) for Gaussian mutation",
|
||||
's', "Variation Operators" );
|
||||
|
||||
eoValueParam<double> & pNormalParam = _parser.createParam(1.0, "pNormal", "Proba. to change each variable for Gaussian mutation", 's', "Variation Operators" );
|
||||
eoValueParam<double> & pNormalParam
|
||||
= _parser.getORcreateParam(1.0, "pNormal",
|
||||
"Proba. to change each variable for Gaussian mutation",
|
||||
's', "Variation Operators" );
|
||||
|
||||
// minimum check
|
||||
bool bMut = true;
|
||||
|
|
@ -204,14 +244,14 @@ eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoRealInitBounded<
|
|||
_state.storeFunctor(ptMon);
|
||||
// create the CombinedMonOp
|
||||
ptCombinedMonOp = new eoPropCombinedMonOp<EOT>(*ptMon, uniformMutRateParam.value());
|
||||
|
||||
|
||||
// mutate exactly 1 component (uniformly) per individual
|
||||
ptMon = new eoDetUniformMutation<EOT>(boundsParam.value(), epsilonParam.value());
|
||||
ptMon = new eoDetUniformMutation<EOT>(boundsParam.value(), epsilonParam.value());
|
||||
_state.storeFunctor(ptMon);
|
||||
ptCombinedMonOp->add(*ptMon, detMutRateParam.value());
|
||||
|
||||
|
||||
// mutate all component using Gaussian mutation
|
||||
ptMon = new eoNormalVecMutation<EOT>(boundsParam.value(), sigmaParam.value(), pNormalParam.value());
|
||||
ptMon = new eoNormalVecMutation<EOT>(boundsParam.value(), sigmaParam.value(), pNormalParam.value());
|
||||
_state.storeFunctor(ptMon);
|
||||
ptCombinedMonOp->add(*ptMon, normalMutRateParam.value());
|
||||
_state.storeFunctor(ptCombinedMonOp);
|
||||
|
|
@ -221,7 +261,7 @@ eoGenOp<EOT> & do_make_op(eoParser& _parser, eoState& _state, eoRealInitBounded<
|
|||
// to simulate SGA (crossover with proba pCross + mutation with proba pMut
|
||||
// we must construct
|
||||
// a sequential combination of
|
||||
// with proba 1, a proportional combination of
|
||||
// with proba 1, a proportional combination of
|
||||
// a QuadCopy and our crossover
|
||||
// with proba pMut, our mutation
|
||||
|
||||
|
|
|
|||
Reference in a new issue