gpkernel_1.html

用C++编写的遗传算法

Demetic migration takes place after a new generation has been created.
The members being swapped are chosen using the same selection scheme
used for crossover and reproduction.
  
<A NAME="IDX143"></A>
<DT><STRONG>SwapMutationProbability (double, <CODE>[0.0..100.0]</CODE>)</STRONG>
<DD>
The probability (in percent) that swap mutation takes place.  Whenever a
genetic program is evolved (by creation, reproduction or crossover) and
is going to be put into the new generation, this parameter determines
the probability that that member should be mutated.
  
<A NAME="IDX144"></A>
<DT><STRONG>ShrinkMutationProbability (double, <CODE>[0.0..100.0]</CODE>)</STRONG>
<DD>
The probability (in percent) that shrink mutation takes place, otherwise
similar to <EM>SwapMutationProbability</EM>.
  
<A NAME="IDX145"></A>
<DT><STRONG>AddBestToNewPopulation (integer, <CODE>[0..1]</CODE>)</STRONG>
<DD>
If this flag is set and steady state Genetic Programming is not used,
the best performing genetic program from the old population will be
moved unchanged to the new one.
  
<A NAME="IDX146"></A>
<DT><STRONG>SteadyState (integer, <CODE>[0..1]</CODE>)</STRONG>
<DD>
If this flag is set, then steady state Genetic Programming is used,
which means that during the invocation of function
<EM>GPPopulation::generate()</EM> no new generation is built up, but the
old one is gradually replaced by the new one.  The advantage is that
memory is needed only for one population instead of two.  This parameter
also influences the main loop which resides in the user's code.  If
steady state is not used, the old generation must be deleted and the new
generation must replace the old one.

</DL>



<H2><A NAME="SEC16" HREF="gpkernel_toc.html#TOC16">1.9  Loading and Saving of Populations</A></H2>

<P>
<A NAME="IDX147"></A>

</P>
<P>
To save or to load an object seems to be quite simple: one has only to
write all member variables to the stream in a way that they can be read
later by the complementary load function.  Problems arise when a class
that owns objects, class <EM>GPContainer</EM>, has to do the same for all
the objects it owns.  To save objects is easy: just a virtual function
has to be provided.  But to load them implies that they are created
first.

</P>



<H3><A NAME="SEC17" HREF="gpkernel_toc.html#TOC17">1.9.1  Registration</A></H3>

<P>
<A NAME="IDX148"></A>

</P>
<P>
<A NAME="IDX149"></A>
<A NAME="IDX150"></A>
<A NAME="IDX151"></A>

</P>

<BLOCKQUOTE>

<PRE>
GPObject* GPCreateRegisteredClassObject (int ID);
void GPRegisterClass (GPObject* gpo);
void GPRegisterKernelClasses ();
</PRE>

</BLOCKQUOTE>

<P>
What is often done in such a case is to implement a registration
mechanism for all classes that want to participate in the load and save
operation.  Each class gets a unique identification value that can be
obtained by a virtual function every class has to define.  Before
members of a certain class can be loaded, they must be registered,
e.g. an object of the class must be created and function
<EM>GPRegisterClass()</EM> must be called.

</P>
<P>
<A NAME="IDX152"></A>

</P>
<P>
The trick is that class <EM>GPContainer</EM> saves not only the objects it
contains, but also their identification value.  If they are to be loaded
again, function <EM>GPCreateRegisteredClassObject()</EM> is called which
creates a new object of the given identification value.  For that, it
loops through all the objects that are registered until it finds one
that matches the identification value, and calls a virtual function,
<EM>createObject()</EM>, for that object to create a new object of the
same class.

</P>
<P>
During the initialisation process, the kernel calls
<EM>GPRegisterKernelClasses()</EM> to register all kernel classes.

</P>



<H3><A NAME="SEC18" HREF="gpkernel_toc.html#TOC18">1.9.2  Requirements</A></H3>

<P>
We consider a new class that inherits from <EM>GPObject</EM>:

</P>
<P>
<A NAME="IDX153"></A>
<A NAME="IDX154"></A>
<A NAME="IDX155"></A>
<A NAME="IDX156"></A>

</P>

<BLOCKQUOTE>

<PRE>
const int UserClassID=GPUserID;
class UserClass : public GPObject
{
  ...
  virtual char* load (istream&#38; is);
  virtual void save (ostream&#38; os);
  virtual int isA () { return UserClassID; }
  virtual GPObject* createObject() { return new UserClass; }
  ...
}
</PRE>

</BLOCKQUOTE>

<P>
Every class has to define those four virtual functions.  <EM>load()</EM>
tries to load objects from a stream, and returns NULL or an error
message, if something went wrong.  <EM>save()</EM> simply saves the object
to the stream.

</P>
<P>
<A NAME="IDX157"></A>

</P>
<P>
<EM>isA()</EM> returns the identification value of the class.  If the user
inherits from any kernel class, he has to use different identification
values.  All values greater or equal than <EM>GPUserID</EM> can be used
for that purpose.

</P>
<P>
<EM>createObject()</EM> allocates a new object of the same class by
calling a parameterless constructor.  Every class should therefore
define such a constructor.

</P>



<H3><A NAME="SEC19" HREF="gpkernel_toc.html#TOC19">1.9.3  Loading and Saving of Gene and Population Objects</A></H3>

<P>
As mentioned before, the gene class saves not the pointer to its node
information object, but the node identification value.  This value is
read in from the stream during the load operation and must afterwards be
converted again to a pointer to the node.  This is done by the following
functions.

</P>
<P>
Similarly, a population object has a pointer to its node set.  When a
population is saved, this node set is not saved.  This object component
is therefore not initialised when a population is loaded again, and has
to be set manually.

</P>
<P>
<A NAME="IDX158"></A>
<A NAME="IDX159"></A>
<A NAME="IDX160"></A>

</P>

<BLOCKQUOTE>

<PRE>
class GPGene : public GPContainer
{
  ...
  void resolveNodeValues (GPNodeSet&#38; ns);
  ...
}

class GP : public GPContainer
{
  ...
  void resolveNodeValues (GPAdfNodeSet&#38; adfNs);
  ...
}

class GPPopulation : public GPContainer
{
  ...
  void setNodeSets (GPAdfNodeSet&#38; adfNs_);
  ...
}
</PRE>

</BLOCKQUOTE>



<H3><A NAME="SEC20" HREF="gpkernel_toc.html#TOC20">1.9.4  Example</A></H3>

<P>
Consider a complete population in pointer variable <EM>pop</EM> and the
appropriate container of the node sets in pointer variable <EM>adfNn</EM>.
To save the population and the node set, simply open a stream and call
the function <EM>save()</EM> for each object.

</P>

<BLOCKQUOTE>

<PRE>
  GPPopulation* pop;
  GPAdfNodeSet* adfNs;
  ...
  ofstream savePop ("pop.dat");
  adfNs-&#62;save (savePop);
  pop-&#62;save (savePop);
</PRE>

</BLOCKQUOTE>

<P>
<A NAME="IDX161"></A>

</P>
<P>
To reload that population, again open a stream, create an empty
population and call <EM>load()</EM> for each the node set and the
population.  Afterwards, call <EM>GPPopulation::setNodeSets()</EM> to
resolve the pointers to the nodes.

</P>

<BLOCKQUOTE>

<PRE>
  ifstream loadPop ("pop.dat");
  pop=new GPPopulation();
  adfNs-&#62;load (loadPop);
  pop-&#62;load (loadPop);
  pop-&#62;setNodeSets (*adfNs);
</PRE>

</BLOCKQUOTE>



<H2><A NAME="SEC21" HREF="gpkernel_toc.html#TOC21">1.10  Miscellaneous</A></H2>



<H3><A NAME="SEC22" HREF="gpkernel_toc.html#TOC22">1.10.1  Error Handling</A></H3>

<P>
<A NAME="IDX162"></A>

</P>
<P>
The Genetic Programming kernel makes a lot of run time checks.  Mostly,
parameters of functions are checked to make the system safer and to
detect errors in the early program development stage.  These checks can
be suppressed by a compiler switch which then also speeds up execution
time.

</P>
<P>
<A NAME="IDX163"></A>
<A NAME="IDX164"></A>
<A NAME="IDX165"></A>
<A NAME="IDX166"></A>

</P>

<BLOCKQUOTE>

<PRE>
#define GPINTERNALCHECK 1
#define GPCREATE_SEGMENTATIONFAULT_ON_ERROR 1
void GPExitSystem (char *functionName, char *errorMessage); 
</PRE>

</BLOCKQUOTE>

<P>
If an error is detected, the function <EM>GPExitSystem()</EM> is called
which reports the name of the function where the error was detected and
the error message itself, and then exits.  If a special compiler switch
is on, the program tries to create a segmentation fault so that it is
easier to track down the error with a debugger and find out which piece
of code really caused the error.  This works only on computers and
operating systems that are able to detect a segmentation fault.  It
certainly does not work with MS-DOS!

</P>



<H3><A NAME="SEC23" HREF="gpkernel_toc.html#TOC23">1.10.2  Kernel Initialisation</A></H3>

<P>
<A NAME="IDX167"></A>
<A NAME="IDX168"></A>

</P>

<BLOCKQUOTE>

<PRE>
void GPInit (int printCopyright, long seedRandomGenerator);
</PRE>

</BLOCKQUOTE>

<P>
Before the Genetic Programming kernel is used, this function should be
called once.  It prints out a copyright message, if flag
<EM>printCopyright</EM> is true, initialises the random number generator
with the value <EM>seedRandomGenerator</EM> and registers all kernel
classes for the load and save operations.

</P>
<P>
<A NAME="IDX169"></A>

</P>
<P>
If <EM>seedRandomGenerator</EM> has the value <CODE>-1</CODE>, the random number
generator is initialised with the return value from the system function
<EM>time()</EM>, otherwise with the given value.  This can be very helpful
in the debugging stage where errors must be reproduced: even though
random numbers are used, the program behaviour stays the same.

</P>



<H3><A NAME="SEC24" HREF="gpkernel_toc.html#TOC24">1.10.3  Random Functions</A></H3>

<P>
<A NAME="IDX170"></A>

</P>
<P>
The Genetic Programming kernel uses its own random number generator
mostly due to the fact that the random number generators of many
standard C libraries are usually of poor performance with respect to the
random numbers that are generated.

</P>
<P>
<A NAME="IDX171"></A>
<A NAME="IDX172"></A>
<A NAME="IDX173"></A>

</P>

<BLOCKQUOTE>

<PRE>
void GPsrand (long);
long GPrand ();
int GPRandomPercent (double percent);
</PRE>

</BLOCKQUOTE>

<P>
<EM>GPsrand()</EM> initialises the random number generator.  This is
normally done by <EM>GPInit()</EM>.  <EM>GPrand()</EM> returns a random
number in the range <CODE>0..2^31-2</CODE>.  <EM>GPRandomPercent()</EM> returns
0 or 1, depending on the probability of the parameter <EM>percent</EM>.
The resolution for <EM>percent</EM> is <CODE>0.0001</CODE>.

</P>



<H3><A NAME="SEC25" HREF="gpkernel_toc.html#TOC25">1.10.4  Reading a Configuration File</A></H3>

<P>
<A NAME="IDX174"></A>
<A NAME="IDX175"></A>

</P>
<P>
<STRONG>Note:</STRONG> this module will probably be replaced one day by a more
sophisticated one.

</P>
<P>
<A NAME="IDX176"></A>

</P>
<P>
The module <EM>Config</EM> defines a class called <EM>GPConfiguration</EM>
and provides an easy and simple to use way to define configuration
variables in a <EM>.ini</EM> file, which are read in by the constructor of
this class.

</P>
<P>
<A NAME="IDX177"></A>

</P>
<P>
Simply call the constructor of the class with the stream to put any
messages on (only for error messages, in case the file is malformed),
the name of the file that should be read, and an array of structures
<EM>GPConfigVarInformation</EM> describing the variables.  The array must
end with a <EM>NULL</EM> pointer in the structure variable <EM>varPtr</EM>.
The constructor reads the file and puts all the values of the variables
he finds in the denoted memory location.

</P>
<P>
The file format of a configuration file consists of the variable name,
the character <SAMP>`='</SAMP> and the value which can be a string, an integer
of a floating point value.  Comments are allowed and recognised by lines
starting with the character <SAMP>`#'</SAMP>.

</P>
<P>
Strings are duplicated; space is allocated with <CODE>new char[]</CODE> and
should be freed, if no longer used.  In case any configuration variable
is of type string, the structure variable <EM>varPtr</EM> points to a
variable of type <EM>(char *)</EM>.  That's a better way than letting the
user provide