Added symbolic regression, which tests combined ops as well
This commit is contained in:
mac
parent
04bc4ecde8
commit
8ae796ab28
14 changed files with 161 additions and 199 deletions
|
|
@ -4,7 +4,7 @@
|
|||
##
|
||||
###############################################################################
|
||||
|
||||
SUBDIRS = es ga utils other
|
||||
SUBDIRS = es ga gp utils other
|
||||
|
||||
lib_LIBRARIES = libeo.a
|
||||
libeo_a_SOURCES = eoPrintable.cpp eoPersistent.cpp eoFunctorStore.cpp
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ class eoGOpBreeder: public eoUnaryFunctor<void, eoPop<EOT>&>
|
|||
public:
|
||||
/// Default constructor.
|
||||
eoGOpBreeder( eoGOpSelector<EOT>& _opSel,
|
||||
eoPopIndiSelector<EOT>& _selector)
|
||||
eoSelectOneIndiSelector<EOT>& _selector)
|
||||
: opSel( _opSel ), selector(_selector)
|
||||
{}
|
||||
|
||||
|
|
@ -47,7 +47,7 @@ class eoGOpBreeder: public eoUnaryFunctor<void, eoPop<EOT>&>
|
|||
|
||||
private:
|
||||
eoGOpSelector<EOT>& opSel;
|
||||
eoPopIndiSelector<EOT>& selector;
|
||||
eoSelectOneIndiSelector<EOT>& selector;
|
||||
|
||||
// the inserter can be local as there's no point in changing it from the outside
|
||||
eoBackInserter<EOT> inserter;
|
||||
|
|
|
|||
|
|
@ -185,78 +185,5 @@ class eoPop: public vector<EOT>, public eoObject, public eoPersistent
|
|||
|
||||
};
|
||||
|
||||
/**
|
||||
Keeps and calculates information about a population such
|
||||
as the sum of fitnesses and whether the population is sorted.
|
||||
It can be used to cache information about a population between
|
||||
calls of functors, see for instance how this makes eoProportional
|
||||
just this tat more efficient
|
||||
|
||||
@see eoSelectOne, eoSelect, eoProportional
|
||||
|
||||
template <class EOT>
|
||||
class eoPopStats
|
||||
{
|
||||
public :
|
||||
typedef typename EOT::Fitness FitnessType;
|
||||
|
||||
/// Initialize by stating nothing is known
|
||||
eoPopStats() :
|
||||
sum_fitness_calculated(false),
|
||||
pop_sorted_calculated(false)
|
||||
{}
|
||||
|
||||
/// Call this function after the pop might have/is changed
|
||||
void reset()
|
||||
{
|
||||
sum_fitness_calculated = false;
|
||||
pop_sorted_calculated = false;
|
||||
}
|
||||
|
||||
/// Calculate sum_fitness or return cached value
|
||||
FitnessType get_sum_fitness(const eoPop<EOT>& _pop)
|
||||
{
|
||||
if (sum_fitness_calculated)
|
||||
return sum_fitness;
|
||||
|
||||
sum_fitness = 0.0;
|
||||
|
||||
for (int i = 0; i < _pop.size(); ++i)
|
||||
{
|
||||
sum_fitness += _pop[i].fitness();
|
||||
}
|
||||
|
||||
sum_fitness_calculated = true;
|
||||
return sum_fitness;
|
||||
}
|
||||
|
||||
/// Check if the pop is sorted or return cached_value
|
||||
bool is_pop_sorted(const eoPop<EOT>& _pop)
|
||||
{
|
||||
if (pop_sorted_calculated)
|
||||
return pop_sorted;
|
||||
|
||||
int i;
|
||||
for (i = 1; i < _pop.size(); ++i)
|
||||
{
|
||||
if (!(_pop[i-1] < _pop[i]))
|
||||
{ // not in sort order
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
pop_sorted = (i == _pop.size());
|
||||
pop_sorted_calculated = true;
|
||||
return pop_sorted;
|
||||
}
|
||||
|
||||
bool sum_fitness_calculated;
|
||||
FitnessType sum_fitness;
|
||||
|
||||
bool pop_sorted_calculated;
|
||||
bool pop_sorted;
|
||||
};
|
||||
*/
|
||||
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -40,12 +40,10 @@ template <class EOT>
|
|||
class eoSequentialGOpSel : public eoGOpSelector<EOT>
|
||||
{
|
||||
public :
|
||||
|
||||
eoSequentialGOpSel(void) : combined(*this, getRates()) {}
|
||||
|
||||
|
||||
virtual eoGeneralOp<EOT>& selectOp()
|
||||
{
|
||||
return combined;
|
||||
return combined.bind(*this, getRates());
|
||||
}
|
||||
|
||||
private :
|
||||
|
|
|
|||
|
|
@ -65,7 +65,7 @@ template<class EOT> class eoSteadyStateTransform: public eoTransform<EOT>
|
|||
nSteps = pop.size(); // make a 'generation equivalent'
|
||||
}
|
||||
|
||||
for (unsigned i = 0; i < steps; ++i)
|
||||
for (unsigned i = 0; i < nSteps; ++i)
|
||||
{
|
||||
selector.bind(pop);
|
||||
inserter.bind(pop);
|
||||
|
|
@ -77,7 +77,7 @@ template<class EOT> class eoSteadyStateTransform: public eoTransform<EOT>
|
|||
|
||||
private:
|
||||
eoGOpSelector<EOT>& opSelector;
|
||||
eoSelectOneIndiSelector<EOT>& selector;
|
||||
eoSelectOneIndiSelector<EOT> selector;
|
||||
eoSteadyStateInserter<EOT>& inserter;
|
||||
unsigned steps;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -117,8 +117,12 @@ template <class EOT>
|
|||
class eoCombinedOp : public eoGeneralOp<EOT>
|
||||
{
|
||||
public :
|
||||
eoCombinedOp(const std::vector<eoGeneralOp<EOT>*>& _ops, const std::vector<float>& rates)
|
||||
: ops(_ops), rates(_rates) {}
|
||||
eoCombinedOp& bind(const std::vector<eoGeneralOp<EOT>*>& _ops, const std::vector<float>& _rates)
|
||||
{
|
||||
ops = &_ops;
|
||||
rates = &_rates;
|
||||
return *this;
|
||||
}
|
||||
|
||||
class eoDelayedSelector : public eoIndiSelector<EOT>
|
||||
{
|
||||
|
|
@ -147,7 +151,7 @@ class eoCombinedOp : public eoGeneralOp<EOT>
|
|||
};
|
||||
|
||||
/** Applies all ops in the combined op
|
||||
It works in the following way
|
||||
It first applies the
|
||||
*/
|
||||
void operator()( eoIndiSelector<EOT>& _in,
|
||||
eoInserter<EOT>& _out )
|
||||
|
|
@ -156,7 +160,7 @@ class eoCombinedOp : public eoGeneralOp<EOT>
|
|||
eoPop<EOT> next;
|
||||
unsigned i;
|
||||
|
||||
for (i = 0; i < ops.size(); ++i)
|
||||
for (i = 0; i < ops->size(); ++i)
|
||||
{
|
||||
eoDelayedSelector delay(_in, intermediate);
|
||||
inserter.bind(next);
|
||||
|
|
@ -166,13 +170,13 @@ class eoCombinedOp : public eoGeneralOp<EOT>
|
|||
// apply operators until we have as many outputs as inputs
|
||||
do
|
||||
{
|
||||
if (flip(rates[i])) // should this flip be here?
|
||||
(*ops[i])(delayedSelector, inserter);
|
||||
if (rng.flip(rates->operator[](i))) // should this flip be here?
|
||||
(*ops->operator[](i))(delay, inserter);
|
||||
|
||||
counter++;
|
||||
if (counter > 1000)
|
||||
{
|
||||
throw logical_error("eoCombinedOp: no termination after 1000 tries, did you forget to insert individuals in your eoGeneralOp?");
|
||||
throw logic_error("eoCombinedOp: no termination after 1000 tries, did you forget to insert individuals in your eoGeneralOp?");
|
||||
}
|
||||
}
|
||||
while (next.size() < intermediate.size());
|
||||
|
|
@ -187,8 +191,8 @@ class eoCombinedOp : public eoGeneralOp<EOT>
|
|||
}
|
||||
|
||||
private :
|
||||
const std::vector<eoGeneralOp<EOT>*>& ops;
|
||||
const std::vector<float> rates;
|
||||
const std::vector<eoGeneralOp<EOT>*>* ops;
|
||||
const std::vector<float>* rates;
|
||||
eoBackInserter<EOT> inserter;
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -17,19 +17,12 @@ template <class FType, class Node>
|
|||
class eoParseTree : public EO<FType>, public parse_tree<Node>
|
||||
{
|
||||
public :
|
||||
|
||||
typedef parse_tree<Node>::subtree Subtree;
|
||||
|
||||
eoParseTree(void) {}
|
||||
eoParseTree(const parse_tree<Node>& tree) : parse_tree<Node>(tree) {}
|
||||
|
||||
typedef typename parse_tree<Node>::subtree Type;
|
||||
|
||||
eoParseTree(void) : EO<FType>(), parse_tree<Node>() {}
|
||||
eoParseTree(unsigned _size, eoRnd<Type>& _rnd)
|
||||
: EO<FType>(), parse_tree<Node>(_rnd())
|
||||
{
|
||||
pruneTree(_size);
|
||||
}
|
||||
eoParseTree(eoRnd<Type>& _rnd)
|
||||
: EO<FType>(), parse_tree<Node>(_rnd())
|
||||
{}
|
||||
|
||||
virtual void pruneTree(unsigned _size)
|
||||
{
|
||||
if (_size < 1)
|
||||
|
|
@ -37,7 +30,7 @@ public :
|
|||
|
||||
if (size() > _size)
|
||||
{
|
||||
Type* sub = &operator[](size() - 2); // prune tree
|
||||
Subtree* sub = &operator[](size() - 2); // prune tree
|
||||
|
||||
while (sub->size() > _size)
|
||||
{
|
||||
|
|
@ -101,7 +94,7 @@ class eoGpDepthInitializer : public eoInit< eoParseTree<FType, Node> >
|
|||
const vector<Node>& _initializor,
|
||||
bool _grow = true)
|
||||
:
|
||||
eoRnd<EoType::Type>(),
|
||||
eoInit<EoType>(),
|
||||
max_depth(_max_depth),
|
||||
initializor(_initializor),
|
||||
grow(_grow)
|
||||
|
|
@ -115,7 +108,8 @@ class eoGpDepthInitializer : public eoInit< eoParseTree<FType, Node> >
|
|||
|
||||
generate(sequence, max_depth);
|
||||
|
||||
_tree = parse_tree<Node>(sequence.begin(), sequence.end());
|
||||
parse_tree<Node> tmp(sequence.begin(), sequence.end());
|
||||
_tree.swap(tmp);
|
||||
}
|
||||
|
||||
void generate(list<Node>& sequence, int the_max, int last_terminal = -1)
|
||||
|
|
@ -180,10 +174,10 @@ public:
|
|||
/// Dtor
|
||||
virtual ~eoSubtreeXOver () {};
|
||||
|
||||
void operator()(eoIndiSelector<EoType>& _source, eoInserter<EoType>& _sink ) const
|
||||
void operator()(eoIndiSelector<EoType>& _select, eoInserter<EoType>& _insert )
|
||||
{
|
||||
EoType eo1 = _source.select();
|
||||
const EoType& eo2 = _source.select();
|
||||
EoType eo1 = _select();
|
||||
const EoType& eo2 = _select();
|
||||
|
||||
int i = rng.random(eo1.size());
|
||||
int j = rng.random(eo2.size());
|
||||
|
|
@ -193,7 +187,7 @@ public:
|
|||
eo1.pruneTree(max_length);
|
||||
|
||||
eo1.invalidate();
|
||||
_sink.insert(eo1);
|
||||
_insert(eo1);
|
||||
}
|
||||
|
||||
unsigned max_length;
|
||||
|
|
@ -206,7 +200,7 @@ public:
|
|||
|
||||
typedef eoParseTree<FType, Node> EoType;
|
||||
|
||||
eoBranchMutation(eoRnd<EoType::Type>& _init, unsigned _max_length)
|
||||
eoBranchMutation(eoInit<EoType>& _init, unsigned _max_length)
|
||||
: eoGeneralOp<EoType>(), max_length(_max_length), initializer(_init)
|
||||
{};
|
||||
|
||||
|
|
@ -215,25 +209,28 @@ public:
|
|||
/// Dtor
|
||||
virtual ~eoBranchMutation() {};
|
||||
|
||||
void operator()(eoIndiSelector<EoType>& _source, eoInserter<EoType>& _sink ) const
|
||||
void operator()(eoIndiSelector<EoType>& _select, eoInserter<EoType>& _insert )
|
||||
{
|
||||
EoType eo1 = _source.select();
|
||||
EoType eo1 = _select();
|
||||
int i = rng.random(eo1.size());
|
||||
|
||||
EoType eo2(eo1[i].size(), initializer); // create random other to cross with
|
||||
EoType eo2;
|
||||
initializer(eo2);
|
||||
|
||||
eo1[i] = eo2.back(); // insert subtree
|
||||
int j = rng.random(eo2.size());
|
||||
|
||||
eo1[i] = eo2[j]; // insert subtree
|
||||
|
||||
eo1.pruneTree(max_length);
|
||||
|
||||
|
||||
eo1.invalidate();
|
||||
_sink.insert(eo1);
|
||||
_insert(eo1);
|
||||
}
|
||||
|
||||
private :
|
||||
|
||||
unsigned max_length;
|
||||
eoRnd<EoType::Type>& initializer;
|
||||
eoInit<EoType>& initializer;
|
||||
};
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -148,7 +148,7 @@ public :
|
|||
if (arity == 0)
|
||||
return 0;
|
||||
|
||||
T* t new T [arity];
|
||||
T* t = new T [arity];
|
||||
|
||||
for (int i = 0; i < arity; ++i)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -16,15 +16,6 @@
|
|||
* modified is included with the above copyright notice.
|
||||
|
||||
|
||||
* Special disclaimer and political statement:
|
||||
|
||||
* In contrast with the rest of the EO package where you might have found this code, this software
|
||||
* does NOT fall under the GNU Lesser Public License or the GNU Public License, nor is anyone allowed
|
||||
* by the copyright holder (that's me) to put it under either license.
|
||||
* Doing this would limit my and your freedom to use this software in any way
|
||||
* you or I see fit, including but not limited to closed-source software.
|
||||
|
||||
|
||||
|
||||
Usage information.
|
||||
|
||||
|
|
@ -173,7 +164,7 @@ namespace gp_parse_tree
|
|||
|
||||
#include "node_pool.h"
|
||||
|
||||
|
||||
/// This ones defined because gcc does not always implement namespaces
|
||||
template <class T>
|
||||
inline void do_the_swap(T& a, T& b)
|
||||
{
|
||||
|
|
@ -371,21 +362,20 @@ public :
|
|||
|
||||
void swap(subtree& y)
|
||||
{
|
||||
do_the_swap(content, y.content);
|
||||
do_the_swap(args, y.args);
|
||||
do_the_swap(parent, y.parent);
|
||||
do_the_swap(content, y.content);
|
||||
do_the_swap(args, y.args);
|
||||
|
||||
adopt();
|
||||
y.adopt();
|
||||
|
||||
do_the_swap(_cumulative_size, y._cumulative_size);
|
||||
do_the_swap(_depth, y._depth);
|
||||
do_the_swap(_size, y._size);
|
||||
do_the_swap(parent, y.parent);
|
||||
|
||||
do_the_swap(_cumulative_size, y._cumulative_size);
|
||||
do_the_swap(_depth, y._depth);
|
||||
do_the_swap(_size, y._size);
|
||||
updateAfterInsert();
|
||||
}
|
||||
|
||||
friend void swap(subtree& x, subtree& y)
|
||||
{
|
||||
x.swap(y);
|
||||
}
|
||||
|
||||
protected :
|
||||
|
||||
virtual void updateAfterInsert(void)
|
||||
|
|
@ -973,7 +963,7 @@ ptrdiff_t* distance_type(gp_parse_tree::parse_tree<T>::iterator)
|
|||
return 0;
|
||||
}
|
||||
|
||||
// Put customized swaps also in std...
|
||||
/* Put customized swaps also in std...
|
||||
|
||||
template<class T> inline
|
||||
void swap(gp_parse_tree::parse_tree<T>& a, gp_parse_tree::parse_tree<T>& b)
|
||||
|
|
@ -985,7 +975,7 @@ template<class T> inline
|
|||
void iter_swap(vector<gp_parse_tree::parse_tree<T> >::iterator a, vector<gp_parse_tree::parse_tree<T> > b)
|
||||
{
|
||||
a->swap(*b);
|
||||
}
|
||||
}*/
|
||||
|
||||
|
||||
} // namespace std
|
||||
|
|
|
|||
|
|
@ -59,7 +59,7 @@ template <class EOT>
|
|||
class eoAverageStat : public eoStat<EOT, double>
|
||||
{
|
||||
public :
|
||||
eoAverageStat(std::string _description = "AverageFitness") : eoStat<EOT, double>(0.0, _description) {}
|
||||
eoAverageStat(std::string _description = "Average Fitness") : eoStat<EOT, double>(0.0, _description) {}
|
||||
|
||||
static double sumFitness(double _sum, const EOT& _eot)
|
||||
{
|
||||
|
|
@ -103,6 +103,20 @@ public :
|
|||
}
|
||||
};
|
||||
|
||||
template <class EOT>
|
||||
class eoBestFitnessStat : public eoStat<EOT, typename EOT::Fitness >
|
||||
{
|
||||
public :
|
||||
typedef typename EOT::Fitness Fitness;
|
||||
|
||||
eoBestFitnessStat(std::string _description = "Best Fitness") : eoStat<EOT, Fitness>(Fitness(), _description) {}
|
||||
|
||||
virtual void operator()(const eoPop<EOT>& _pop)
|
||||
{
|
||||
value() = _pop.nth_element_fitness(0);
|
||||
}
|
||||
};
|
||||
|
||||
/*
|
||||
template <class EOT>
|
||||
class eoStdevStat : public eoStat<EOT, double >
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ LDADDS = $(top_builddir)/src/libeo.a $(top_builddir)/src/utils/libeoutils.a
|
|||
|
||||
###############################################################################
|
||||
|
||||
noinst_PROGRAMS = t-eofitness t-eobin t-eoStateAndParser t-eoCheckpointing t-eoExternalEO t-eoESFull
|
||||
noinst_PROGRAMS = t-eofitness t-eobin t-eoStateAndParser t-eoCheckpointing t-eoExternalEO t-eoESFull t-eoSymreg
|
||||
|
||||
###############################################################################
|
||||
|
||||
|
|
@ -57,4 +57,13 @@ t_eoExternalEO_LDADD = $(LDADDS)
|
|||
|
||||
###############################################################################
|
||||
|
||||
###############################################################################
|
||||
|
||||
t_eoSymreg_SOURCES = t-eoSymreg.cpp
|
||||
t_eoSymreg_DEPENDENCIES = $(DEPS)
|
||||
t_eoSymreg_LDFLAGS = -lm
|
||||
t_eoSymreg_LDADD = $(LDADDS)
|
||||
|
||||
###############################################################################
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
#pragma warning(disable:4786)
|
||||
|
||||
#include "eoParseTree.h"
|
||||
#include "eoEvalFunc.h"
|
||||
#include <gp/eoParseTree.h>
|
||||
#include <eoEvalFunc.h>
|
||||
|
||||
using namespace gp_parse_tree;
|
||||
using namespace std;
|
||||
|
|
@ -20,34 +20,43 @@ public :
|
|||
|
||||
// arity function, need this function!
|
||||
int arity(void) const { return op == X? 0 : 2; }
|
||||
|
||||
|
||||
void randomize(void) {}
|
||||
|
||||
// evaluation function, single case, using first argument to give value of variable
|
||||
template <class Children>
|
||||
double operator()(double var, Children args) const
|
||||
void operator()(double& result, Children args, double var) const
|
||||
{
|
||||
double r1, r2;
|
||||
|
||||
if (arity() == 2)
|
||||
{
|
||||
args[0].apply(r1, var);
|
||||
args[1].apply(r2, var);
|
||||
}
|
||||
|
||||
switch (op)
|
||||
{
|
||||
case Plus : return args[0].apply(var) + args[1].apply(var);
|
||||
case Min : return args[0].apply(var) - args[1].apply(var);
|
||||
case Mult : return args[0].apply(var) * args[1].apply(var);
|
||||
case Plus : result = r1 + r2; break;
|
||||
case Min : result = r1 - r2; break;
|
||||
case Mult : result = r1 * r2; break;
|
||||
case PDiv :
|
||||
{
|
||||
double arg1 = args[1].apply(var);
|
||||
if (arg1 == 0.0)
|
||||
return 1.0; // protection a la Koza, realistic implementations should maybe throw an exception
|
||||
|
||||
return args[0].apply(var) / arg1;
|
||||
if (r2 == 0.0)
|
||||
result = 1.0; // protection a la Koza, realistic implementations should maybe throw an exception
|
||||
else
|
||||
result = r1 / r2;
|
||||
break;
|
||||
}
|
||||
|
||||
case X : return var;
|
||||
case X : result = var; break;
|
||||
}
|
||||
|
||||
return var; // to avoid compiler error
|
||||
}
|
||||
|
||||
/// 'Pretty' print to ostream function
|
||||
template <class Children>
|
||||
string operator()(string dummy, Children args)
|
||||
void operator()(string& result, Children args) const
|
||||
{
|
||||
static const string lb = "(";
|
||||
static const string rb = ")";
|
||||
|
|
@ -56,13 +65,16 @@ public :
|
|||
|
||||
if (arity() == 0)
|
||||
{
|
||||
return string("x");
|
||||
result = "x";
|
||||
return;
|
||||
}
|
||||
// else
|
||||
string result = lb + args[0].apply(dummy);
|
||||
string r1;
|
||||
args[0].apply(r1);
|
||||
result = lb + r1;
|
||||
result += opStr;
|
||||
result += args[1].apply(dummy) + rb;
|
||||
return result;
|
||||
args[1].apply(r1);
|
||||
result += r1 + rb;
|
||||
}
|
||||
|
||||
Operator getOp(void) const { return op; }
|
||||
|
|
@ -100,15 +112,15 @@ std::istream& operator>>(std::istream& is, SymregNode& eot)
|
|||
//-----------------------------------------------------------------------------
|
||||
/** Implementation of a function evaluation object. */
|
||||
|
||||
float targetFunction(float x)
|
||||
double targetFunction(double x)
|
||||
{
|
||||
return x * x * x * x - x * x * x + x * x * x - x * x + x - 1;
|
||||
return x * x * x * x - x * x * x + x * x * x - x * x + x - 10;
|
||||
}
|
||||
|
||||
// parameters controlling the sampling of points
|
||||
const float xbegin = -10.0f;
|
||||
const float xend = 10.0f;
|
||||
const float xstep = 1.3f;
|
||||
const double xbegin = -10.0f;
|
||||
const double xend = 10.0f;
|
||||
const double xstep = 1.3f;
|
||||
|
||||
template <class FType, class Node> struct RMS: public eoEvalFunc< eoParseTree<FType, Node> >
|
||||
{
|
||||
|
|
@ -128,7 +140,7 @@ public :
|
|||
|
||||
int i = 0;
|
||||
|
||||
for (double x = xbegin; x < xend && i < n; ++i)
|
||||
for (double x = xbegin; x < xend && i < n; ++i, x+=xstep)
|
||||
{
|
||||
target[i] = targetFunction(x);
|
||||
inputs[i] = x;
|
||||
|
|
@ -137,7 +149,7 @@ public :
|
|||
|
||||
~RMS() {}
|
||||
|
||||
void operator()( EoType & _eo ) const
|
||||
void operator()( EoType & _eo )
|
||||
{
|
||||
vector<double> outputs;
|
||||
outputs.resize(inputs.size());
|
||||
|
|
@ -146,7 +158,7 @@ public :
|
|||
|
||||
for (int i = 0; i < inputs.size(); ++i)
|
||||
{
|
||||
outputs[i] = _eo.apply(inputs[i]);
|
||||
_eo.apply(outputs[i], inputs[i]);
|
||||
fitness += (outputs[i] - target[i]) * (outputs[i] - target[i]);
|
||||
}
|
||||
|
||||
|
|
@ -164,25 +176,6 @@ private :
|
|||
vector<double> target;
|
||||
};
|
||||
|
||||
#include "eoTerm.h"
|
||||
|
||||
template <class EOT>
|
||||
class eoGenerationTerm : public eoTerm<EOT>
|
||||
{
|
||||
public :
|
||||
eoGenerationTerm(size_t _ngen) : eoTerm<EOT>(), ngen(_ngen) {}
|
||||
|
||||
bool operator()(const eoPop<EOT>&)
|
||||
{
|
||||
cout << '.'; // pacifier
|
||||
cout.flush();
|
||||
|
||||
return --ngen > 0;
|
||||
}
|
||||
private :
|
||||
unsigned ngen;
|
||||
};
|
||||
|
||||
template <class EOT, class FitnessType>
|
||||
void print_best(eoPop<EOT>& pop)
|
||||
{
|
||||
|
|
@ -201,7 +194,8 @@ void print_best(eoPop<EOT>& pop)
|
|||
|
||||
cout << "\t";
|
||||
|
||||
string str = pop[index].apply(string());
|
||||
string str;
|
||||
pop[index].apply(str);
|
||||
|
||||
cout << str.c_str();
|
||||
cout << endl << "RMS Error = " << pop[index].fitness() << endl;
|
||||
|
|
@ -210,16 +204,15 @@ void print_best(eoPop<EOT>& pop)
|
|||
|
||||
#include <eo>
|
||||
#include "eoGOpBreeder.h"
|
||||
#include "eoSequentialGOpSelector.h"
|
||||
#include "eoProportionalGOpSelector.h"
|
||||
#include "eoDetTournamentIndiSelector.h"
|
||||
#include "eoSequentialGOpSel.h"
|
||||
#include "eoProportionalGOpSel.h"
|
||||
#include "eoDetTournamentInserter.h"
|
||||
#include "eoSteadyStateEA.h"
|
||||
#include "eoScalarFitness.h"
|
||||
|
||||
void main()
|
||||
{
|
||||
typedef eoScalarFitness<double, greater<double> > FitnessType;
|
||||
typedef eoMinimizingFitness FitnessType;
|
||||
typedef SymregNode GpNode;
|
||||
|
||||
typedef eoParseTree<FitnessType, GpNode> EoType;
|
||||
|
|
@ -237,7 +230,9 @@ void main()
|
|||
// Root Mean Squared Error Measure
|
||||
RMS<FitnessType, GpNode> eval;
|
||||
|
||||
Pop pop(500, MaxSize, initializer, eval);
|
||||
Pop pop(500, initializer);
|
||||
|
||||
apply<EoType>(eval, pop);
|
||||
|
||||
eoSubtreeXOver<FitnessType, GpNode> xover(MaxSize);
|
||||
eoBranchMutation<FitnessType, GpNode> mutation(initializer, MaxSize);
|
||||
|
|
@ -247,15 +242,28 @@ void main()
|
|||
seqSel.addOp(mutation, 0.25);
|
||||
seqSel.addOp(xover, 0.75);
|
||||
|
||||
eoDetTournamentIndiSelector<EoType> selector(5);
|
||||
eoDetTournament<EoType> selector(5);
|
||||
|
||||
eoDetTournamentInserter<EoType> inserter(eval, 5);
|
||||
|
||||
// Terminators
|
||||
eoGenerationTerm<EoType> term(nGenerations);
|
||||
eoGenContinue<EoType> term(nGenerations);
|
||||
|
||||
eoCheckPoint<EoType> checkPoint(term);
|
||||
|
||||
eoAverageStat<EoType> avg;
|
||||
eoBestFitnessStat<EoType> best;
|
||||
eoStdoutMonitor monitor;
|
||||
|
||||
checkPoint.add(monitor);
|
||||
checkPoint.add(avg);
|
||||
checkPoint.add(best);
|
||||
|
||||
monitor.add(avg);
|
||||
monitor.add(best);
|
||||
|
||||
// GP generation
|
||||
eoSteadyStateEA<EoType> gp(seqSel, selector, inserter, term);
|
||||
eoSteadyStateEA<EoType> gp(seqSel, selector, inserter, checkPoint);
|
||||
|
||||
cout << "Initialization done" << endl;
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
|
||||
EXTRA_DIST=eo_win.dsw eo.dsp esfull.dsp t_eobin.dsp t_eoCheckpointing.dsp t_eofitness.dsp \
|
||||
t_eoFunctor.dsp t_externalEO.dsp t_StateAndParser.dsp
|
||||
t_eoFunctor.dsp t_externalEO.dsp t_StateAndParser.dsp t_eoSymreg.dsp
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -75,6 +75,21 @@ Package=<4>
|
|||
|
||||
###############################################################################
|
||||
|
||||
Project: "t_eoSymreg"=.\t_eoSymreg.dsp - Package Owner=<4>
|
||||
|
||||
Package=<5>
|
||||
{{{
|
||||
}}}
|
||||
|
||||
Package=<4>
|
||||
{{{
|
||||
Begin Project Dependency
|
||||
Project_Dep_Name eo
|
||||
End Project Dependency
|
||||
}}}
|
||||
|
||||
###############################################################################
|
||||
|
||||
Project: "t_eobin"=.\t_eobin.dsp - Package Owner=<4>
|
||||
|
||||
Package=<5>
|
||||
|
|
|
|||
Reference in a new issue