nojhan/eodev
Archived
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Changed the directory structure for gp

Browse source 
now: eoParseTree <-- the eoParseTree class
     eoParseTreeDepthInit <-- the eoParseTree depth initializer (eoGpDepthInitializer)
     eoParseTreeOp <-- the operators (xover and mutation)

base documentation written for:
* eoParseTree
* eoGpDepthInitializer
* eoSubtreeXOver
* eoBranchMutation
* eoPointMutation
* eoExpansionMutation
* eoCollapseSubtreeMutation
* eoHoistMutation

I also created a group ParseTree which contains all classes related to eoParseTree

eoGpMutate.h has been removed (merged with eoParseTree operators into eoParseTreeOp
This commit is contained in:
jeggermo 2001-07-02 13:31:04 +00:00
commit a611939e68
7 changed files with 340 additions and 198 deletions
Download patch file Download diff file Expand all files Collapse all files

10
eo/app/gpsymreg/fitness.h
View file

@ -43,7 +43,7 @@ using namespace std;
class MinimizingFitnessTraits : public eoParetoFitnessTraits
{
public :
static bool maximizing(int which) { return false;} // we want to minimize both fitnesses}
static bool maximizing(int which) { return false;} // we want to minimize both fitnesses
static unsigned nObjectives() { return 2;} // the number of fitnesses }
};
@ -148,7 +148,7 @@ void init(vector<TreeNode> &initSequence)
}
// next we add the unary functions
/*
initSequence.push_back( NEGATE );
initSequence.push_back( SIN );
initSequence.push_back( COS );
@ -162,14 +162,14 @@ void init(vector<TreeNode> &initSequence)
initSequence.push_back( MULTIPLIES );
initSequence.push_back( DIVIDE );
initSequence.push_back( POW );
*/
// and the binary operators
initSequence.push_back( OpPLUS);
initSequence.push_back( OpMINUS );
/*
initSequence.push_back( OpMULTIPLIES );
initSequence.push_back( OpDIVIDE );
*/
initSequence.push_back( OpPOW );

5
eo/app/gpsymreg/main.cc
View file

@ -23,7 +23,6 @@
#include <iostream>
#include <gp/eoParseTree.h>
#include <gp/eoGpMutate.h>
#include <eo>
using namespace gp_parse_tree;
@ -84,7 +83,9 @@ int main(int argc, char *argv[])
// define X-OVER
eoSubtreeXOver<FitnessType, Node> xover(parameter.MaxSize);
eoSubtreeXOver<FitnessType, Node> xover(parameter.MaxSize);
// define MUTATION
eoBranchMutation<FitnessType, Node> mutation(initializer, parameter.MaxSize);
// eoExpansionMutation<FitnessType, Node> mutation(initializer, parameter.MaxSize);

2
eo/doc/eo.cfg
View file

@ -214,7 +214,7 @@ RECURSIVE = YES
# excluded from the INPUT source files. This way you can easily exclude a
# subdirectory from a directory tree whose root is specified with the INPUT tag.
EXCLUDE = ../src/obsolete ../src/gp
EXCLUDE = ../src/obsolete
# If the value of the INPUT tag contains directories, you can use the
# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude

2
eo/src/gp/Makefile.am
View file

@ -5,4 +5,4 @@
###############################################################################
libeoincdir = $(includedir)/eo/gp
libeoinc_HEADERS = eoParseTree.h node_pool.h parse_tree.h eoGpMutate.h
libeoinc_HEADERS = eoParseTree.h node_pool.h parse_tree.h eoParseTreeDepthInit.h eoParseTreeOp.h

236
eo/src/gp/eoParseTree.h
View file

@ -1,5 +1,31 @@
#ifndef EO_PARSE_TREE_H
#define EO_PARSE_TREE_H
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
//-----------------------------------------------------------------------------
// eoParseTree.h : eoParseTree class (for Tree-based Genetic Programming)
// (c) 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
version 2 of the License, or (at your option) any later version.
This library 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 library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact: todos@geneura.ugr.es, http://geneura.ugr.es
mak@dhi.dk
*/
//-----------------------------------------------------------------------------
#ifndef eoParseTree_h
#define eoParseTree_h
#include <list>
@ -11,6 +37,18 @@
using namespace gp_parse_tree;
using namespace std;
/**
\defgroup ParseTree
Various functions for a tree-based Genetic Programming
*/
/** eoParseTree : implementation of parse-tree for genetic programming
\class eoParseTree eoParseTree.h gp/eoParseTree.h
\ingroup ParseTree
*/
template <class FType, class Node>
class eoParseTree : public EO<FType>, public parse_tree<Node>
{
@ -18,9 +56,20 @@ public :
typedef parse_tree<Node>::subtree Subtree;
/**
* Default Constructor
*/
eoParseTree(void) {}
/**
* Copy Constructor
* @param tree The tree to copy
*/
eoParseTree(const parse_tree<Node>& tree) : parse_tree<Node>(tree) {}
/**
* To prune me to a certain size
* @param _size My maximum size
*/
virtual void pruneTree(unsigned _size)
{
if (_size < 1)
@ -32,20 +81,34 @@ public :
}
}
/**
* To read me from a stream
* @param is The istream
*/
eoParseTree(std::istream& is) : EO<FType>(), parse_tree<Node>()
{
readFrom(is);
}
/// My class name
string className(void) const { return "eoParseTree"; }
/**
* To print me on a stream
* @param os The ostream
*/
void printOn(std::ostream& os) const
{
os << fitness() << ' ';
std::copy(ebegin(), eend(), ostream_iterator<Node>(os));
}
/**
* To read me from a stream
* @param is The istream
*/
void readFrom(std::istream& is)
{
FType fit;
@ -58,6 +121,7 @@ public :
}
};
// friend function to print eoParseTree
template <class FType, class Node>
std::ostream& operator<<(std::ostream& os, const eoParseTree<FType, Node>& eot)
{
@ -65,6 +129,7 @@ std::ostream& operator<<(std::ostream& os, const eoParseTree<FType, Node>& eot)
return os;
}
// friend function to read eoParseTree
template <class FType, class Node>
std::istream& operator>>(std::istream& is, eoParseTree<FType, Node>& eot)
{
@ -72,167 +137,8 @@ std::istream& operator>>(std::istream& is, eoParseTree<FType, Node>& eot)
return is;
}
template <class Node>
bool lt_arity(const Node &node1, const Node &node2)
{
return (node1.arity() < node2.arity());
}
template <class FType, class Node>
class eoGpDepthInitializer : public eoInit< eoParseTree<FType, Node> >
{
public :
typedef eoParseTree<FType, Node> EoType;
eoGpDepthInitializer(
unsigned _max_depth,
const vector<Node>& _initializor,
bool _grow = true)
:
eoInit<EoType>(),
max_depth(_max_depth),
initializor(_initializor),
grow(_grow)
{
if(initializor.empty())
{
throw logic_error("eoGpDepthInitializer: uhm, wouldn't you rather give a non-empty set of Nodes?");
}
// lets sort the initializor vector according to arity (so we can be sure the terminals are in front)
// we use stable_sort so that if element i was in front of element j and they have the same arity i remains in front of j
stable_sort(initializor.begin(), initializor.end(), lt_arity<Node>);
}
virtual string className() const { return "eoDepthInitializer"; };
void operator()(EoType& _tree)
{
list<Node> sequence;
generate(sequence, max_depth);
parse_tree<Node> tmp(sequence.begin(), sequence.end());
_tree.swap(tmp);
}
void generate(list<Node>& sequence, int the_max, int last_terminal = -1)
{
if (last_terminal == -1)
{ // check where the last terminal in the sequence resides
vector<Node>::iterator it;
for (it = initializor.begin(); it != initializor.end(); ++it)
{
if (it->arity() > 0)
break;
}
last_terminal = it - initializor.begin();
}
if (the_max == 1)
{ // generate terminals only
vector<Node>::iterator it = initializor.begin() + rng.random(last_terminal);
sequence.push_front(*it);
return;
}
vector<Node>::iterator what_it;
if (grow)
{
what_it = initializor.begin() + rng.random(initializor.size());
}
else // full
{
what_it = initializor.begin() + last_terminal + rng.random(initializor.size() - last_terminal);
}
what_it->randomize();
sequence.push_front(*what_it);
for (int i = 0; i < what_it->arity(); ++i)
generate(sequence, the_max - 1, last_terminal);
}
private :
unsigned max_depth;
std::vector<Node> initializor;
bool grow;
};
template<class FType, class Node>
class eoSubtreeXOver: public eoQuadOp< eoParseTree<FType, Node> > {
public:
typedef eoParseTree<FType, Node> EoType;
eoSubtreeXOver( unsigned _max_length)
: eoQuadOp<EoType>(), max_length(_max_length) {};
virtual string className() const { return "eoSubtreeXOver"; };
/// Dtor
virtual ~eoSubtreeXOver () {};
bool operator()(EoType & _eo1, EoType & _eo2 )
{
int i = rng.random(_eo1.size());
int j = rng.random(_eo2.size());
parse_tree<Node>::subtree tmp = _eo1[i];
_eo1[i] = _eo2[j]; // insert subtree
_eo2[j] = tmp;
_eo1.pruneTree(max_length);
_eo2.pruneTree(max_length);
return true;
}
unsigned max_length;
};
template<class FType, class Node>
class eoBranchMutation: public eoMonOp< eoParseTree<FType, Node> >
{
public:
typedef eoParseTree<FType, Node> EoType;
eoBranchMutation(eoInit<EoType>& _init, unsigned _max_length)
: eoMonOp<EoType>(), max_length(_max_length), initializer(_init)
{};
virtual string className() const { return "eoBranchMutation"; };
/// Dtor
virtual ~eoBranchMutation() {};
bool operator()(EoType& _eo1 )
{
int i = rng.random(_eo1.size());
EoType eo2;
initializer(eo2);
int j = rng.random(eo2.size());
_eo1[i] = eo2[j]; // insert subtree
_eo1.pruneTree(max_length);
return true;
}
private :
unsigned max_length;
eoInit<EoType>& initializer;
};
// for backward compatibility
#include <gp/eoParseTreeOp.h>
#include <gp/eoParseTreeDepthInit.h>
#endif

145
eo/src/gp/eoParseTreeDepthInit.h Normal file
View file

@ -0,0 +1,145 @@
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
//-----------------------------------------------------------------------------
// eoParseTreeDepthInit.h : initializor for eoParseTree class
// (c) 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
version 2 of the License, or (at your option) any later version.
This library 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 library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact: todos@geneura.ugr.es, http://geneura.ugr.es
mak@dhi.dk
*/
//-----------------------------------------------------------------------------
#ifndef eoParseTreeDepthInit_h
#define eoParseTreeDepthInit_h
#include <EO.h>
#include <gp/eoParseTree.h>
#include <eoInit.h>
#include <eoOp.h>
using namespace gp_parse_tree;
using namespace std;
// we need this for sorting the initializor vector
template <class Node>
bool lt_arity(const Node &node1, const Node &node2)
{
return (node1.arity() < node2.arity());
}
/** eoGpDepthInitializer : the initializer class for eoParseTree
\class eoGpDepthInitializer eoParseTreeDepthInit.h gp/eoParseTreeDepthInit.h
\ingroup ParseTree
*/
template <class FType, class Node>
class eoGpDepthInitializer : public eoInit< eoParseTree<FType, Node> >
{
public :
typedef eoParseTree<FType, Node> EoType;
/**
* Constructor
* @parm _max_depth The maximum depth of a tree
* @param _initializor A vector containing the possible nodes
* @param _grow False results in a full tree, True result is a randomly grown tree
*/
eoGpDepthInitializer(
unsigned _max_depth,
const vector<Node>& _initializor,
bool _grow = true)
:
eoInit<EoType>(),
max_depth(_max_depth),
initializor(_initializor),
grow(_grow)
{
if(initializor.empty())
{
throw logic_error("eoGpDepthInitializer: uhm, wouldn't you rather give a non-empty set of Nodes?");
}
// lets sort the initializor vector according to arity (so we can be sure the terminals are in front)
// we use stable_sort so that if element i was in front of element j and they have the same arity i remains in front of j
stable_sort(initializor.begin(), initializor.end(), lt_arity<Node>);
}
/// My class name
virtual string className() const { return "eoDepthInitializer"; };
/**initialize a tree
* @param _tree : the tree to be initialized
*/
void operator()(EoType& _tree)
{
list<Node> sequence;
generate(sequence, max_depth);
parse_tree<Node> tmp(sequence.begin(), sequence.end());
_tree.swap(tmp);
}
private :
void generate(list<Node>& sequence, int the_max, int last_terminal = -1)
{
if (last_terminal == -1)
{ // check where the last terminal in the sequence resides
vector<Node>::iterator it;
for (it = initializor.begin(); it != initializor.end(); ++it)
{
if (it->arity() > 0)
break;
}
last_terminal = it - initializor.begin();
}
if (the_max == 1)
{ // generate terminals only
vector<Node>::iterator it = initializor.begin() + rng.random(last_terminal);
sequence.push_front(*it);
return;
}
vector<Node>::iterator what_it;
if (grow)
{
what_it = initializor.begin() + rng.random(initializor.size());
}
else // full
{
what_it = initializor.begin() + last_terminal + rng.random(initializor.size() - last_terminal);
}
what_it->randomize();
sequence.push_front(*what_it);
for (int i = 0; i < what_it->arity(); ++i)
generate(sequence, the_max - 1, last_terminal);
}
unsigned max_depth;
std::vector<Node> initializor;
bool grow;
};
#endif

142
eo/src/gp/eoGpMutate.h → eo/src/gp/eoParseTreeOp.h
View file

@ -1,8 +1,9 @@
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
//-----------------------------------------------------------------------------
// eoGpMutate.h : GP mutation
// (c) Jeroen Eggermont 2001 for mutation operators
// eoParseTreeOp.h : crossover and mutation operator for the eoParseTree class
// (c) Maarten Keijzer 2000 for eoSubtreeXOver, eoBranchMutation
// (c) Jeroen Eggermont 2001 for other mutation operators
/*
This library is free software; you can redistribute it and/or
@ -20,27 +21,114 @@
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact: todos@geneura.ugr.es, http://geneura.ugr.es
mak@dhi.dk
jeggermo@liacs.nl
*/
//-----------------------------------------------------------------------------
#ifndef eoGpMutate_h
#define eoGpMutate_h
//-----------------------------------------------------------------------------
#include <gp/eoParseTree.h>
#include <list>
#include <string>
#ifndef eoParseTreeOp_h
#define eoParseTreeOp_h
#include <EO.h>
#include <eoOp.h>
#include <gp/eoParseTree.h>
#include <eoInit.h>
using namespace gp_parse_tree;
using namespace std;
#include <gp/eoParseTree.h>
/** eoSubtreeXOver --> subtree xover
\class eoSubtreeXOver eoParseTreeOp.h gp/eoParseTreeOp.h
\ingroup ParseTree
*/
template<class FType, class Node>
class eoSubtreeXOver: public eoQuadOp< eoParseTree<FType, Node> > {
public:
typedef eoParseTree<FType,Node> EoType;
/**
* Constructor
* @param _max_length the maximum size of an individual
*/
eoSubtreeXOver( unsigned _max_length)
: eoQuadOp<EoType>(), max_length(_max_length) {};
/// the ckassname
virtual string className() const { return "eoSubtreeXOver"; };
/// Dtor
virtual ~eoSubtreeXOver () {};
/**
* Perform crossover on two individuals
* param _eo1 The first parent individual
* param _eo2 The second parent individual
*/
bool operator()(EoType & _eo1, EoType & _eo2 )
{
int i = rng.random(_eo1.size());
int j = rng.random(_eo2.size());
parse_tree<Node>::subtree tmp = _eo1[i];
_eo1[i] = _eo2[j]; // insert subtree
_eo2[j] = tmp;
_eo1.pruneTree(max_length);
_eo2.pruneTree(max_length);
return true;
}
private:
unsigned max_length;
};
/** eoBranchMutation --> replace a subtree with a randomly created subtree
\class eoBranchMutation eoParseTreeOp.h gp/eoParseTreeOp.h
\ingroup ParseTree
*/
template<class FType, class Node>
class eoBranchMutation: public eoMonOp< eoParseTree<FType, Node> >
{
public:
typedef eoParseTree<FType,Node> EoType;
/**
* Constructor
* @param _init An instantiation of eoGpDepthInitializer
* @param _max_length the maximum size of an individual
*/
eoBranchMutation(eoInit<EoType>& _init, unsigned _max_length)
: eoMonOp<EoType>(), max_length(_max_length), initializer(_init)
{};
/// the class name
virtual string className() const { return "eoBranchMutation"; };
/// Dtor
virtual ~eoBranchMutation() {};
/**
* Mutate an individual
* @param _eo1 The individual that is to be changed
*/
bool operator()(EoType& _eo1 )
{
int i = rng.random(_eo1.size());
EoType eo2;
initializer(eo2);
int j = rng.random(eo2.size());
_eo1[i] = eo2[j]; // insert subtree
_eo1.pruneTree(max_length);
return true;
}
private :
unsigned max_length;
eoInit<EoType>& initializer;
};
// Additional Mutation operators from
// TITLE:"Genetic Programming~An Introduction"
@ -51,7 +139,8 @@ using namespace std;
// For the eoParseTree class
/** eoPointMutation --> replace a Node with a Node of the same arity
\class eoPointMutation eoGpMutate.h gp/eoGpMutate.h
\class eoPointMutation eoParseTreeOp.h gp/eoParseTreeOp.h
\ingroup ParseTree
*/
template<class FType, class Node>
@ -59,7 +148,7 @@ class eoPointMutation: public eoMonOp< eoParseTree<FType, Node> >
{
public:
typedef eoParseTree<FType, Node> EoType;
typedef eoParseTree<FType,Node> EoType;
/**
* Constructor
@ -107,7 +196,8 @@ private :
};
/** eoExpansionMutation --> replace a terminal with a randomly created subtree
\class eoExpansionMutation eoGpMutate.h gp/eoGpMutate.h
\class eoExpansionMutation eoParseTreeOp.h gp/eoParseTreeOp.h
\ingroup ParseTree
*/
template<class FType, class Node>
@ -174,7 +264,8 @@ private :
};
/** eoCollapseSubtree --> replace a subtree with a randomly chosen terminal
\class eoCollapseSubtreeMutation eoGpMutate.h gp/eoGpMutate.h
\class eoCollapseSubtreeMutation eoParseTreeOp.h gp/eoParseTreeOp.h
\ingroup ParseTree
*/
template<class FType, class Node>
@ -182,7 +273,7 @@ class eoCollapseSubtreeMutation: public eoMonOp< eoParseTree<FType, Node> >
{
public:
typedef eoParseTree<FType, Node> EoType;
typedef eoParseTree<FType,Node> EoType;
/**
* Constructor
* @param _init An instantiation of eoGpDepthInitializer
@ -236,11 +327,9 @@ private :
};
/** eoHoist --> replace the individual with one of its subtree's
\class eoHoist eoGpMutate.h gp/eoGpMutate.h
/** eoHoistMutation --> replace the individual with one of its subtree's
\class eoHoistMutation eoParseTreeOp.h gp/eoParseTreeOp.h
\ingroup ParseTree
*/
template<class FType, class Node>
@ -248,9 +337,10 @@ class eoHoistMutation: public eoMonOp< eoParseTree<FType, Node> >
{
public:
typedef eoParseTree<FType, Node> EoType;
typedef eoParseTree<FType,Node> EoType;
/**
* Constructor
* @param none
*/
eoHoistMutation()
: eoMonOp<EoType>()