public override void Setup(IEvolutionState state, IParameter paramBase)
{
base.Setup(state, paramBase);
Velocity = new double[genome.Length];
}
public override void Eval(IEvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, IProblem problem)
{
ClassificationData result = (ClassificationData)input;
result.boolVal = true;
}
public override int Produce(
int min,
int max,
int subpop,
IList <Individual> inds,
IEvolutionState state,
int thread,
IDictionary <string, object> misc)
{
int start = inds.Count;
// how many individuals should we make?
int n = TypicalIndsProduced;
if (n < min)
{
n = min;
}
if (n > max)
{
n = max;
}
// should we bother?
if (!state.Random[thread].NextBoolean(Likelihood))
{
// just load from source 0 and clone 'em
Sources[0].Produce(n, n, subpop, inds, state, thread, misc);
return(n);
}
IntBag[] parentparents = null;
IntBag[] preserveParents = null;
if (misc != null && misc.ContainsKey(KEY_PARENTS))
{
preserveParents = (IntBag[])misc[KEY_PARENTS];
parentparents = new IntBag[2];
misc[KEY_PARENTS] = parentparents;
}
GPInitializer initializer = (GPInitializer)state.Initializer;
for (int q = start; q < n + start; /* no increment */) // keep on going until we're filled up
{
Parents.Clear();
// grab two individuals from our sources
if (Sources[0] == Sources[1]) // grab from the same source
{
Sources[0].Produce(2, 2, subpop, Parents, state, thread, misc);
}
else // grab from different sources
{
Sources[0].Produce(1, 1, subpop, Parents, state, thread, misc);
Sources[1].Produce(1, 1, subpop, Parents, state, thread, misc);
}
// at this point, Parents[] contains our two selected individuals
// are our tree values valid?
if (Tree1 != TREE_UNFIXED && (Tree1 < 0 || Tree1 >= ((GPIndividual)Parents[0]).Trees.Length))
{
// uh oh
state.Output.Fatal(
"GP Crossover Pipeline attempted to fix tree.0 to a value which was out of bounds of the array of the individual's trees. Check the pipeline's fixed tree values -- they may be negative or greater than the number of trees in an individual");
}
if (Tree2 != TREE_UNFIXED && (Tree2 < 0 || Tree2 >= ((GPIndividual)Parents[1]).Trees.Length))
{
// uh oh
state.Output.Fatal(
"GP Crossover Pipeline attempted to fix tree.1 to a value which was out of bounds of the array of the individual's trees. Check the pipeline's fixed tree values -- they may be negative or greater than the number of trees in an individual");
}
int t1;
int t2;
if (Tree1 == TREE_UNFIXED || Tree2 == TREE_UNFIXED)
{
do
// pick random trees -- their GPTreeConstraints must be the same
{
if (Tree1 == TREE_UNFIXED)
{
if (((GPIndividual)Parents[0]).Trees.Length > 1)
{
t1 = state.Random[thread].NextInt(((GPIndividual)Parents[0]).Trees.Length);
}
else
{
t1 = 0;
}
}
else
{
t1 = Tree1;
}
if (Tree2 == TREE_UNFIXED)
{
if (((GPIndividual)Parents[1]).Trees.Length > 1)
{
t2 = state.Random[thread].NextInt(((GPIndividual)Parents[1]).Trees.Length);
}
else
{
t2 = 0;
}
}
else
{
t2 = Tree2;
}
} while (((GPIndividual)Parents[0]).Trees[t1].Constraints(initializer) !=
((GPIndividual)Parents[1]).Trees[t2].Constraints(initializer));
}
else
{
t1 = Tree1;
t2 = Tree2;
// make sure the constraints are okay
if (((GPIndividual)Parents[0]).Trees[t1].Constraints(initializer) !=
((GPIndividual)Parents[1]).Trees[t2].Constraints(initializer)) // uh oh
{
state.Output.Fatal(
"GP Crossover Pipeline's two tree choices are both specified by the user -- but their GPTreeConstraints are not the same");
}
}
bool res1 = false;
bool res2 = false;
// BRS: This is kind of stupid to name it this way!
GPTree currTree = ((GPIndividual)Parents[1]).Trees[t2];
// pick some nodes
GPNode p1 = null;
GPNode p2 = null;
// lets walk on parent2 all nodes to get subtrees for each node, doing it once for O(N) and not O(N^2)
// because depth etc are computed and not stored
ArrayList nodeToSubtrees = new ArrayList();
// also Hashtable for size to List() of nodes in that size for O(1) lookup
Hashtable sizeToNodes = new Hashtable();
TraverseTreeForDepth(currTree.Child, nodeToSubtrees, sizeToNodes);
// sort the ArrayList with comparator that sorts by subtrees
nodeToSubtrees.Sort(new NodeComparator());
for (int x = 0; x < NumTries; x++)
{
// pick a node in individual 1
p1 = NodeSelect1.PickNode(state, subpop, thread, (GPIndividual)Parents[0], ((GPIndividual)Parents[0]).Trees[t1]);
// now lets find "similar" in parent 2
p2 = FindFairSizeNode(nodeToSubtrees, sizeToNodes, p1, currTree, state, thread);
// check for depth and swap-compatibility limits
res1 = VerifyPoints(initializer, p2, p1); // p2 can fill p1's spot -- order is important!
if (n - (q - start) < 2 || TossSecondParent)
{
res2 = true;
}
else
{
res2 = VerifyPoints(initializer, p1, p2); // p1 can fill p2's spot -- order is important!
}
// did we get something that had both nodes verified?
// we reject if EITHER of them is invalid. This is what lil-gp
// does.
// Koza only has numTries set to 1, so it's compatible as well.
if (res1 && res2)
{
break;
}
}
// at this point, res1 AND res2 are valid, OR
// either res1 OR res2 is valid and we ran out of tries, OR
// neither res1 nor res2 is valid and we rand out of tries.
// So now we will transfer to a tree which has res1 or res2
// valid, otherwise it'll just get replicated. This is
// compatible with both Koza and lil-gp.
// at this point I could check to see if my sources were breeding
// pipelines -- but I'm too lazy to write that code (it's a little
// complicated) to just swap one individual over or both over,
// -- it might still entail some copying. Perhaps in the future.
// It would make things faster perhaps, not requiring all that
// cloning.
// Create some new individuals based on the old ones -- since
// GPTree doesn't deep-clone, this should be just fine. Perhaps we
// should change this to proto off of the main species prototype,
// but
// we have to then copy so much stuff over; it's not worth it.
GPIndividual j1 = ((GPIndividual)Parents[0]).LightClone();
GPIndividual j2 = null;
if (n - (q - start) >= 2 && !TossSecondParent)
{
j2 = ((GPIndividual)Parents[1]).LightClone();
}
// Fill in various tree information that didn't get filled in there
j1.Trees = new GPTree[((GPIndividual)Parents[0]).Trees.Length];
if (n - (q - start) >= 2 && !TossSecondParent)
{
j2.Trees = new GPTree[((GPIndividual)Parents[1]).Trees.Length];
}
// at this point, p1 or p2, or both, may be null.
// If not, swap one in. Else just copy the parent.
for (int x = 0; x < j1.Trees.Length; x++)
{
if (x == t1 && res1) // we've got a tree with a kicking cross
// position!
{
j1.Trees[x] = ((GPIndividual)Parents[0]).Trees[x].LightClone();
j1.Trees[x].Owner = j1;
j1.Trees[x].Child = ((GPIndividual)Parents[0]).Trees[x].Child.CloneReplacing(p2, p1);
j1.Trees[x].Child.Parent = j1.Trees[x];
j1.Trees[x].Child.ArgPosition = 0;
j1.Evaluated = false;
} // it's changed
else
{
j1.Trees[x] = ((GPIndividual)Parents[0]).Trees[x].LightClone();
j1.Trees[x].Owner = j1;
j1.Trees[x].Child = (GPNode)((GPIndividual)Parents[0]).Trees[x].Child.Clone();
j1.Trees[x].Child.Parent = j1.Trees[x];
j1.Trees[x].Child.ArgPosition = 0;
}
}
if (n - (q - start) >= 2 && !TossSecondParent)
{
for (int x = 0; x < j2.Trees.Length; x++)
{
if (x == t2 && res2) // we've got a tree with a kicking
// cross position!
{
j2.Trees[x] = ((GPIndividual)Parents[1]).Trees[x].LightClone();
j2.Trees[x].Owner = j2;
j2.Trees[x].Child = ((GPIndividual)Parents[1]).Trees[x].Child.CloneReplacing(p1, p2);
j2.Trees[x].Child.Parent = j2.Trees[x];
j2.Trees[x].Child.ArgPosition = 0;
j2.Evaluated = false;
} // it's changed
else
{
j2.Trees[x] = ((GPIndividual)Parents[1]).Trees[x].LightClone();
j2.Trees[x].Owner = j2;
j2.Trees[x].Child = (GPNode)((GPIndividual)Parents[1]).Trees[x].Child.Clone();
j2.Trees[x].Child.Parent = j2.Trees[x];
j2.Trees[x].Child.ArgPosition = 0;
}
}
}
// add the individuals to the population
// by Ermo. I think this should be add
// inds.set(q,j1);
// Yes -- Sean
inds.Add(j1);
if (preserveParents != null)
{
parentparents[0].AddAll(parentparents[1]);
preserveParents[q] = parentparents[0];
}
q++;
if (q < n + start && !TossSecondParent)
{
// by Ermo. Same reason, should changed to add
//inds[q] = j2;
inds.Add(j2);
if (preserveParents != null)
{
preserveParents[q] = parentparents[0];
}
q++;
}
}
return(n);
}
public override void ReadNode(IEvolutionState state, BinaryReader dataInput) // throws IOException
{
value = dataInput.ReadDouble();
}
/**
* Where the actual reproduce is happening, it will grab the candidate
* parents, and calls the crossover or mutation method on these parents
* individuals.
*/
public bool Reproduce(IEvolutionState state, int thread, int subpop, IList <NEATSubspecies> sortedSubspecies)
{
if (ExpectedOffspring > 0 && Individuals.Count == 0)
{
state.Output.Fatal("Attempt to reproduce out of empty subspecies");
return(false);
}
if (ExpectedOffspring > state.Population.Subpops[subpop].InitialSize)
{
state.Output.Fatal("Attempt to reproduce too many individuals");
return(false);
}
NEATSpecies species = (NEATSpecies)state.Population.Subpops[subpop].Species;
// bestIndividual of the 'this' specie is the first element of the
// species
// note, we already sort the individuals based on the fitness (not sure
// if this is still correct to say)
NEATIndividual bestIndividual = (NEATIndividual)First();
// create the designated number of offspring for the Species one at a
// time
bool bestIndividualDone = false;
for (int i = 0; i < ExpectedOffspring; ++i)
{
NEATIndividual newInd;
if (bestIndividual.SuperChampionOffspring > 0)
{
newInd = (NEATIndividual)bestIndividual.Clone();
// Most super champion offspring will have their connection
// weights mutated only
// The last offspring will be an exact duplicate of this super
// champion
// Note: Super champion offspring only occur with stolen babies!
// Settings used for published experiments did not use this
if (bestIndividual.SuperChampionOffspring > 1)
{
if (state.Random[thread].NextBoolean(0.8) || species.MutateAddLinkProb.Equals(0.0))
{
newInd.MutateLinkWeights(state, thread, species, species.WeightMutationPower, 1.0,
NEATSpecies.MutationType.GAUSSIAN);
}
else
{
// Sometime we add a link to a superchamp
newInd.CreateNetwork(); // make sure we have the network
newInd.MutateAddLink(state, thread);
}
}
if (bestIndividual.SuperChampionOffspring == 1)
{
if (bestIndividual.PopChampion)
{
newInd.PopChampionChild = true;
newInd.HighFit = bestIndividual.Fitness.Value;
}
}
bestIndividual.SuperChampionOffspring--;
}
else if (!bestIndividualDone && ExpectedOffspring > 5)
{
newInd = (NEATIndividual)bestIndividual.Clone();
bestIndividualDone = true;
}
// Decide whether to mate or mutate
// If there is only one individual, then always mutate
else if (state.Random[thread].NextBoolean(species.MutateOnlyProb) || Individuals.Count == 1)
{
// Choose the random parent
int parentIndex = state.Random[thread].NextInt(Individuals.Count);
Individual parent = Individuals[parentIndex];
newInd = (NEATIndividual)parent.Clone();
newInd.DefaultMutate((EvolutionState)state, thread);
}
else // Otherwise we should mate
{
// random choose the first parent
int parentIndex = state.Random[thread].NextInt(Individuals.Count);
NEATIndividual firstParent = (NEATIndividual)Individuals[parentIndex];
NEATIndividual secondParent;
// Mate within subspecies, choose random second parent
if (state.Random[thread].NextBoolean(1.0 - species.InterspeciesMateRate))
{
parentIndex = state.Random[thread].NextInt(Individuals.Count);
secondParent = (NEATIndividual)Individuals[parentIndex];
}
else // Mate outside subspecies
{
// Select a random species
NEATSubspecies randomSubspecies = this;
// Give up if you cant find a different Species
int giveUp = 0;
while (randomSubspecies == this && giveUp < 5)
{
// Choose a random species tending towards better
// species
double value = state.Random[thread].NextGaussian() / 4;
if (value > 1.0)
{
value = 1.0;
}
// This tends to select better species
int upperBound = (int)Math.Floor(value * (sortedSubspecies.Count - 1.0) + 0.5);
int index = 0;
while (index < upperBound)
{
index++;
}
randomSubspecies = sortedSubspecies[index];
giveUp++;
}
secondParent = (NEATIndividual)randomSubspecies.First();
}
newInd = firstParent.Crossover(state, thread, secondParent);
// Determine whether to mutate the baby's Genome
// This is done randomly or if the parents are the same
// individual
if (state.Random[thread].NextBoolean(1.0 - species.MateOnlyProb) || firstParent == secondParent ||
species.Compatibility(firstParent, secondParent).Equals(0.0))
{
newInd.DefaultMutate((EvolutionState)state, thread);
}
}
newInd.SetGeneration(state);
newInd.CreateNetwork();
// Add the new individual to its proper subspecies
// this could create new subspecies
species.Speciate(state, newInd);
}
return(true);
}
public override void PrintIndividualForHumans(IEvolutionState state, int log)
{
state.Output.PrintLn(EVALUATED_PREAMBLE + (Evaluated ? "true" : "false"), log);
Fitness.PrintFitnessForHumans(state, log);
PrintTrees(state, log);
}
public override void Eval(IEvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
IProblem problem)
{
var md = (MultiplexerData)input;
long[] dat_11_1 = null; // quiets compiler complaints
long[] dat_11_2 = null; // quiets compiler complaints
long dat_6_1 = 0L;
long dat_6_2 = 0L;
byte dat_3_1 = 0;
byte dat_3_2 = 0;
// No shortcuts for now
Children[0].Eval(state, thread, input, stack, individual, problem);
if (md.Status == MultiplexerData.STATUS_3)
{
dat_3_1 = md.Dat3;
}
else if (md.Status == MultiplexerData.STATUS_6)
{
dat_6_1 = md.Dat6;
}
else // md.status == MultiplexerData.STATUS_11
{
dat_11_1 = md.PopDat11();
Array.Copy(md.Dat11, 0,
dat_11_1, 0,
MultiplexerData.MULTI_11_NUM_BITSTRINGS);
}
Children[1].Eval(state, thread, input, stack, individual, problem);
if (md.Status == MultiplexerData.STATUS_3)
{
dat_3_2 = md.Dat3;
}
else if (md.Status == MultiplexerData.STATUS_6)
{
dat_6_2 = md.Dat6;
}
else // md.status == MultiplexerData.STATUS_11
{
dat_11_2 = md.PopDat11();
Array.Copy(md.Dat11, 0,
dat_11_2, 0,
MultiplexerData.MULTI_11_NUM_BITSTRINGS);
}
// tweak -- if a then b else c is equivalent to
// (a -> b) ^ (~a -> c) which is equivalent to
// (~a v b) ^ (a v c). In Java, ^ (-1) is the same
// is bitwise not.
Children[2].Eval(state, thread, input, stack, individual, problem);
// BRS: NOTE: Byte vs. SByte needs some checking
if (md.Status == MultiplexerData.STATUS_3)
{
md.Dat3 = (byte)(
((dat_3_1 ^ (sbyte)(-1)) | dat_3_2) &
((dat_3_1 | md.Dat3)));
}
else if (md.Status == MultiplexerData.STATUS_6)
{
md.Dat6 =
((dat_6_1 ^ (-1L)) | dat_6_2) &
((dat_6_1 | md.Dat6));
}
else // md.status == MultiplexerData.STATUS_11
{
for (var x = 0; x < MultiplexerData.MULTI_11_NUM_BITSTRINGS; x++)
{
md.Dat11[x] =
((dat_11_1[x] ^ (-1L)) | dat_11_2[x]) &
((dat_11_1[x] | md.Dat11[x]));
}
md.PushDat11(dat_11_2);
md.PushDat11(dat_11_1);
}
}
public static void Main(string[] args)
{
IEvolutionState state = null;
IParameterDatabase parameters = null;
Output output = null;
//bool store;
int x;
// 0. find the parameter database
for (x = 0; x < args.Length - 1; x++)
{
if (args[x].Equals(A_FILE))
{
try
{
parameters = new ParameterDatabase(new FileInfo(new FileInfo(args[x + 1]).FullName), args);
// add the fact that I am a slave: eval.i-am-slave = true
// this is used only by the Evaluator to determine whether to use the MasterProblem
parameters.SetParameter(new Parameter(EvolutionState.P_EVALUATOR).Push(Evaluator.P_IAMSLAVE),
"true");
break;
}
catch (FileNotFoundException e)
{
Output.InitialError(
"A File Not Found Exception was generated upon" + " reading the parameter file \""
+ args[x + 1] + "\".\nHere it is:\n" + e, false);
Environment.Exit(1);
// This was originally part of the InitialError call in ECJ. But we make Slave responsible.
}
catch (IOException e)
{
Output.InitialError("An IO Exception was generated upon reading the" + " parameter file \""
+ args[x + 1] + "\".\nHere it is:\n" + e, false);
Environment.Exit(1);
// This was originally part of the InitialError call in ECJ. But we make Slave responsible.
}
}
}
if (parameters == null)
{
Output.InitialError("No parameter file was specified.", false);
Environment.Exit(1);
// This was originally part of the InitialError call in ECJ. But we make Slave responsible.
}
// 5. Determine whether or not to return entire Individuals or just Fitnesses
// (plus whether or not the Individual has been evaluated).
var returnIndividuals = parameters.GetBoolean(new Parameter(P_RETURNINDIVIDUALS), null, false);
// 5.5 should we silence the whole thing?
bool silent = parameters.GetBoolean(new Parameter(P_SILENT), null, false);
if (parameters.ParameterExists(new Parameter(P_MUZZLE), null))
{
Output.InitialWarning("" + new Parameter(P_MUZZLE) + " has been deprecated. We suggest you use " +
new Parameter(P_SILENT) + " or similar newer options.");
}
silent = silent || parameters.GetBoolean(new Parameter(P_MUZZLE), null, false);
// 6. Open a server socket and listen for requests
var slaveName = parameters.GetString(new Parameter(P_EVALSLAVENAME), null);
var masterHost = parameters.GetString(new Parameter(P_EVALMASTERHOST), null);
if (masterHost == null)
{
Output.InitialError("Master Host missing", new Parameter(P_EVALMASTERHOST));
}
var masterPort = parameters.GetInt(new Parameter(P_EVALMASTERPORT), null, 0);
if (masterPort == -1)
{
Output.InitialError("Master Port missing", new Parameter(P_EVALMASTERPORT));
}
var useCompression = parameters.GetBoolean(new Parameter(P_EVALCOMPRESSION), null, false);
RunTime = parameters.GetInt(new Parameter(P_RUNTIME), null, 0);
RunEvolve = parameters.GetBoolean(new Parameter(P_RUNEVOLVE), null, false);
OneShot = parameters.GetBoolean(new Parameter(P_ONESHOT), null, true);
if (RunEvolve && !returnIndividuals)
{
Output.InitialError(
"You have the slave running in 'evolve' mode, but it's only returning fitnesses to the master, not whole individuals. This is almost certainly wrong.",
new Parameter(P_RUNEVOLVE), new Parameter(P_RETURNINDIVIDUALS));
Environment.Exit(1);
// This was originally part of the InitialError call in ECJ. But we make Slave responsible.
}
if (!silent)
{
Output.InitialMessage("ECCS Slave");
if (RunEvolve)
{
Output.InitialMessage("Running in Evolve mode, evolve time is " + RunTime + " milliseconds");
}
if (returnIndividuals)
{
Output.InitialMessage("Whole individuals will be returned");
}
else
{
Output.InitialMessage("Only fitnesses will be returned");
}
}
// Continue to serve new masters until killed.
TcpClient socket = null; // BRS: TcpClient is a wrapper around the Socket class
while (true)
{
try
{
long connectAttemptCount = 0;
if (!silent)
{
Output.InitialMessage("Connecting to master at " + masterHost + ":" + masterPort);
}
while (true)
{
try
{
socket = new TcpClient(masterHost, masterPort);
break;
}
catch (Exception)
// it's not up yet...
{
connectAttemptCount++;
try
{
Thread.Sleep(new TimeSpan((Int64)10000 * SLEEP_TIME));
}
catch (ThreadInterruptedException)
{
}
}
}
if (!silent)
{
Output.InitialMessage("Connected to master after " + (connectAttemptCount * SLEEP_TIME) + " ms");
}
BinaryReader dataIn = null;
BinaryWriter dataOut = null;
try
{
Stream tmpIn = socket.GetStream();
Stream tmpOut = socket.GetStream();
if (useCompression)
{
//Output.InitialError("JDK 1.5 has broken compression. For now, you must set eval.compression=false");
//Environment.Exit(1); // This was originally part of the InitialError call in ECJ. But we make Slave responsible.
/*
* tmpIn = new CompressingInputStream(tmpIn);
* tmpOut = new CompressingOutputStream(tmpOut);
*/
tmpIn = Output.MakeCompressingInputStream(tmpIn);
tmpOut = Output.MakeCompressingOutputStream(tmpOut);
if (tmpIn == null || tmpOut == null)
{
var err = "You do not appear to have JZLib installed on your system, and so must set eval.compression=false. "
+ "To get JZLib, download from the ECJ website or from http://www.jcraft.com/jzlib/";
if (!silent)
{
Output.InitialMessage(err);
}
throw new OutputExitException(err);
}
}
dataIn = new BinaryReader(tmpIn);
dataOut = new BinaryWriter(tmpOut);
}
catch (IOException e)
{
var err = "Unable to open input stream from socket:\n" + e;
if (!silent)
{
Output.InitialMessage(err);
}
throw new OutputExitException(err);
}
// specify the slaveName
if (slaveName == null)
{
// BRS : TODO : Check equivalence of the address returned from .NET socket.Client.LocalEndPoint
slaveName = socket.Client.LocalEndPoint + "/" + (DateTime.Now.Ticks - 621355968000000000) / 10000;
if (!silent)
{
Output.InitialMessage("No slave name specified. Using: " + slaveName);
}
}
dataOut.Write(slaveName); // Default encoding of BinaryWriter is UTF-8
dataOut.Flush();
// 1. create the output
// store = parameters.GetBoolean(new Parameter(P_STORE), null, false);
if (output != null)
{
output.Close();
}
output = new Output(storeAnnouncementsInMemory: false) // do not store messages, just print them
{
ThrowsErrors = true // don't do System.exit(1)
};
// stdout is always log #0. stderr is always log #1.
// stderr accepts announcements, and both are fully verbose by default.
output.AddLog(Log.D_STDOUT, false);
output.AddLog(Log.D_STDERR, true);
if (silent)
{
output.GetLog(0).Silent = true;
output.GetLog(1).Silent = true;
}
if (!silent)
{
output.SystemMessage(ECVersion.Message());
}
// 2. set up thread values
int breedthreads = Evolve.DetermineThreads(output, parameters, new Parameter(Evolve.P_BREEDTHREADS));
int evalthreads = Evolve.DetermineThreads(output, parameters, new Parameter(Evolve.P_EVALTHREADS));
// Note that either breedthreads or evalthreads (or both) may be 'auto'. We don't warn about this because
// the user isn't providing the thread seeds.
// 3. create the Mersenne Twister random number generators, one per thread
var random = new IMersenneTwister[breedthreads > evalthreads ? breedthreads : evalthreads];
var seed = dataIn.ReadInt32();
for (var i = 0; i < random.Length; i++)
{
random[i] = Evolve.PrimeGenerator(new MersenneTwisterFast(seed++));
}
// we prime the generator to be more sure of randomness.
// 4. Set up the evolution state
// what evolution state to use?
state =
(IEvolutionState)
parameters.GetInstanceForParameter(new Parameter(Evolve.P_STATE), null, typeof(IEvolutionState));
state.Parameters = new ParameterDatabase();
state.Parameters.AddParent(parameters);
state.Random = random;
state.Output = output;
state.EvalThreads = evalthreads;
state.BreedThreads = breedthreads;
state.Setup(state, null);
state.Population = state.Initializer.SetupPopulation(state, 0);
// 5. Optionally do further loading
var storage = state.Evaluator.MasterProblem;
storage.ReceiveAdditionalData(state, dataIn);
storage.TransferAdditionalData(state);
try
{
while (true)
{
var newState = state;
if (RunEvolve)
{
// Construct and use a new EvolutionState. This will be inefficient the first time around
// as we've set up TWO EvolutionStates in a row with no good reason.
IParameterDatabase coverDatabase = new ParameterDatabase();
// protect the underlying one
coverDatabase.AddParent(state.Parameters);
newState = Evolve.Initialize(coverDatabase, 0);
newState.StartFresh();
newState.Output.Message("Replacing random number generators, ignore above seed message");
newState.Random = state.Random; // continue with RNG
storage.TransferAdditionalData(newState); // load the arbitrary data again
}
// 0 means to shut down
//Console.Error.WriteLine("reading next problem");
int problemType = dataIn.ReadByte();
//Console.Error.WriteLine("Read problem: " + problemType);
switch (problemType)
{
case (int)SlaveEvaluationType.Shutdown:
socket.Close();
if (OneShot)
{
return; // we're outa here
}
else
{
throw new OutputExitException("SHUTDOWN");
}
case (int)SlaveEvaluationType.Simple:
EvaluateSimpleProblem(newState, returnIndividuals, dataIn, dataOut, args);
break;
case (int)SlaveEvaluationType.Grouped:
EvaluateGroupedProblem(newState, returnIndividuals, dataIn, dataOut);
break;
default:
state.Output.Fatal("Unknown problem form specified: " + problemType);
break;
}
//System.err.PrintLn("Done Evaluating Individual");
}
}
catch (IOException e)
{
// Since an IOException can happen here if the peer closes the socket
// on it's end, we don't necessarily have to exit. Maybe we don't
// even need to print a warning, but we'll do so just to indicate
// something happened.
state.Output.Fatal(
"Unable to read type of evaluation from master. Maybe the master closed its socket and exited?:\n" +
e);
}
catch (Exception e)
{
if (state != null)
{
state.Output.Fatal(e.Message);
}
else if (!silent)
{
Console.Error.WriteLine("FATAL ERROR (EvolutionState not created yet): " + e.Message);
}
}
}
catch (OutputExitException e)
{
// here we restart if necessary
try { socket.Close(); } catch (Exception e2) { }
if (OneShot)
{
Environment.Exit(0);
}
}
catch (OutOfMemoryException e)
{
// Let's try fixing things
state = null;
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
GC.WaitForPendingFinalizers();
try { socket.Close(); } catch (Exception e2) { }
socket = null;
// TODO: Overkill? Track memory before and after.
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
GC.WaitForPendingFinalizers();
Console.Error.WriteLine(e);
if (OneShot)
{
Environment.Exit(0);
}
}
if (!silent)
{
Output.InitialMessage("\n\nResetting Slave");
}
}
}
/// <summary>
/// Checks to make sure that the Problem implements ISimpleProblem.
/// </summary>
public override void Setup(IEvolutionState state, IParameter paramBase)
{
base.Setup(state, paramBase);
if (!(p_problem is ISimpleProblem))
{
state.Output.Fatal(GetType().Name + " used, but the Problem is not of ISimpleProblem", paramBase.Push(P_PROBLEM));
}
CloneProblem = state.Parameters.GetBoolean(paramBase.Push(P_CLONE_PROBLEM), null, true);
if (!CloneProblem && state.BreedThreads > 1) // uh oh, this can't be right
{
state.Output.Fatal("The Evaluator is not cloning its Problem, but you have more than one thread.", paramBase.Push(P_CLONE_PROBLEM));
}
numTests = state.Parameters.GetInt(paramBase.Push(P_NUM_TESTS), null, 1);
if (numTests < 1)
{
numTests = 1;
}
else if (numTests > 1)
{
String m = state.Parameters.GetString(paramBase.Push(P_MERGE), null);
if (m == null)
{
state.Output.Warning("Merge method not provided to SimpleEvaluator. Assuming 'mean'");
}
else if (m.Equals(V_MEAN))
{
mergeForm = MERGE_MEAN;
}
else if (m.Equals(V_MEDIAN))
{
mergeForm = MERGE_MEDIAN;
}
else if (m.Equals(V_BEST))
{
mergeForm = MERGE_BEST;
}
else
{
state.Output.Fatal("Bad merge method: " + m, paramBase.Push(P_NUM_TESTS), null);
}
}
if (!state.Parameters.ParameterExists(paramBase.Push(P_CHUNK_SIZE), null))
{
chunkSize = C_AUTO;
}
else if (state.Parameters.GetString(paramBase.Push(P_CHUNK_SIZE), null).Equals(V_AUTO, StringComparison.InvariantCultureIgnoreCase))
{
chunkSize = C_AUTO;
}
else
{
chunkSize = (state.Parameters.GetInt(paramBase.Push(P_CHUNK_SIZE), null, 1));
if (chunkSize == 0) // uh oh
{
state.Output.Fatal("Chunk Size must be either an integer >= 1 or 'auto'", paramBase.Push(P_CHUNK_SIZE), null);
}
}
}
private static void EvolveSimpleProblemCore(IEvolutionState state, bool returnIndividuals,
BinaryReader dataIn, BinaryWriter dataOut, int numInds, int[] subpops, int[] indsPerSubpop)
{
var updateFitness = new bool[numInds];
var inds = new Individual[numInds];
try // load up ALL the individuals
{
for (var i = 0; i < numInds; i++)
{
inds[i] = state.Population.Subpops[subpops[i]].Species.NewIndividual(state, dataIn);
updateFitness[i] = dataIn.ReadBoolean();
}
}
catch (IOException e)
{
state.Output.Fatal("Unable to read individual from master." + e);
}
var stopWatch = Stopwatch.StartNew();
// Now we need to reset the subpopulations. They were already set up with the right
// classes, Species, etc. in state.setup(), so all we need to do is modify the number
// of individuals in each subpopulation.
for (var subpop = 0; subpop < state.Population.Subpops.Count; subpop++)
{
if (state.Population.Subpops[subpop].Individuals.Count != indsPerSubpop[subpop])
{
state.Population.Subpops[subpop].Individuals = new Individual[indsPerSubpop[subpop]];
}
}
// Disperse into the population
var counts = new int[state.Population.Subpops.Count];
for (var i = 0; i < numInds; i++)
{
state.Population.Subpops[subpops[i]].Individuals[counts[subpops[i]]++] = inds[i];
}
// Evaluate the population until time is up, or the evolution stops
var result = EvolutionState.R_NOTDONE;
while (result == EvolutionState.R_NOTDONE)
{
result = state.Evolve();
if (stopWatch.ElapsedMilliseconds > RunTime)
{
break;
}
}
// re-gather from population in the same order
counts = new int[state.Population.Subpops.Count];
for (var i = 0; i < numInds; i++)
{
inds[i] = state.Population.Subpops[subpops[i]].Individuals[counts[subpops[i]]++];
}
state.Finish(result);
Evolve.Cleanup(state);
// Return the evaluated individual to the master
try
{
ReturnIndividualsToMaster(state, inds, updateFitness, dataOut, returnIndividuals, -1);
// -1 == write all individuals
dataOut.Flush();
}
catch (IOException e)
{
state.Output.Fatal("Caught fatal IOException\n" + e);
}
}
public static void EvaluateGroupedProblem(IEvolutionState state, bool returnIndividuals, BinaryReader dataIn, BinaryWriter dataOut)
{
var countVictoriesOnly = false;
// first load the individuals
var numInds = 1;
try
{
countVictoriesOnly = dataIn.ReadBoolean();
numInds = dataIn.ReadInt32();
}
catch (IOException e)
{
state.Output.Fatal("Unable to read the number of individuals from the master:\n" + e);
}
// load the subpops
var subpops = new int[numInds]; // subpops desired by each ind
var indsPerSubpop = new int[state.Population.Subpops.Count]; // num inds for each subpop
for (var i = 0; i < numInds; i++)
{
try
{
subpops[i] = dataIn.ReadInt32();
if (subpops[i] < 0 || subpops[i] >= state.Population.Subpops.Count)
{
state.Output.Fatal("Bad subpop number for individual #" + i + ": " + subpops[i]);
}
indsPerSubpop[subpops[i]]++;
}
catch (IOException e)
{
state.Output.Fatal("Unable to read the subpop number from the master:\n" + e);
}
}
// Read the individuals from the stream
var inds = new Individual[numInds];
var updateFitness = new bool[numInds];
try
{
for (var i = 0; i < inds.Length; ++i)
{
inds[i] = state.Population.Subpops[subpops[i]].Species.NewIndividual(state, dataIn);
updateFitness[i] = dataIn.ReadBoolean();
}
}
catch (IOException e)
{
state.Output.Fatal("Unable to read individual from master.");
}
// Evaluate the individuals together
((IGroupedProblem)state.Evaluator.p_problem).Evaluate(state, inds, updateFitness, countVictoriesOnly, subpops, 0);
try
{
ReturnIndividualsToMaster(state, inds, updateFitness, dataOut, returnIndividuals, -1);
// -1 == write all individuals
dataOut.Flush();
}
catch (IOException e)
{
state.Output.Fatal("Caught fatal IOException\n" + e);
}
}
private static void EvaluateSimpleProblemCore(IEvolutionState state, bool returnIndividuals,
BinaryReader dataIn, BinaryWriter dataOut, int numInds, int[] subpops)
{
// TODO: Refactor this to use TPL DataFlow!
var problems = new ISimpleProblem[numInds];
var updateFitness = new bool[numInds];
var inds = new Individual[numInds];
var indForThread = new int[numInds];
try
{
// BRS: TPL DataFlow BEGIN
var maxDegree = Math.Min(Environment.ProcessorCount, state.EvalThreads);
var options = new ExecutionDataflowBlockOptions {
MaxDegreeOfParallelism = maxDegree
};
var block = new TransformBlock <SlaveEvalThread, Individual>(eval =>
{
eval.Run();
return(eval.Ind);
}, options);
for (var i = 0; i < numInds; i++)
{
var ind = state.Population.Subpops[subpops[i]].Species.NewIndividual(state, dataIn);
if (problems[i] == null)
{
problems[i] = (ISimpleProblem)state.Evaluator.p_problem.Clone();
}
updateFitness[i] = dataIn.ReadBoolean();
var runnable = new SlaveEvalThread
{
ThreadNum = i,
State = state,
Problem = problems[i],
Ind = ind,
Subpop = subpops[i]
};
block.Post(runnable);
}
for (var i = 0; i < numInds; i++)
{
// This preserves the original block posting order so we can just use the index.
var ind = block.Receive();
// Return the evaluated Individual by index...
ReturnIndividualsToMaster(state, inds, updateFitness, dataOut, returnIndividuals, individualInQuestion: i); // return just that individual
}
// BRS: TPL DataFlow END
}
catch (IOException e)
{
state.Output.Fatal("Unable to read individual from master." + e);
}
// gather everyone
for (var i = 0; i < numInds; i++)
{
ReturnIndividualsToMaster(state, inds, updateFitness, dataOut, returnIndividuals,
indForThread[i]); // return just that individual
}
try
{
dataOut.Flush();
}
catch (IOException e)
{
state.Output.Fatal("Caught fatal IOException\n" + e);
}
}
public override void Setup(IEvolutionState state, IParameter paramBase)
{
// nothing to setup here
}
/**
* Reads a Node printed by printNode(...). The default form simply reads a
* line into a string, and then calls readNodeFromString() on that line.
*/
public void ReadNode(IEvolutionState state, StreamReader reader)
{
// NNode::NNode (const char *argline, std::vector<Trait*> &traits)
ReadNodeFromString(reader.ReadLine(), state);
}
public override void Setup(IEvolutionState state, IParameter paramBase)
{
// very important, remember this
base.Setup(state, paramBase);
// should we load our x parameters from a file, or generate them randomly?
var training_file = state.Parameters.GetResource(paramBase.Push(P_TRAINING_FILE), null);
var testing_file = state.Parameters.GetResource(paramBase.Push(P_TESTING_FILE), null);
var problem = state.Parameters.GetString(paramBase.Push(P_PROBLEM_TYPE), null);
var benchmark = -1;
if (problem == null)
{
state.Output.Message("Loading benchmark data from files");
if ((testing_file == null || training_file == null)) // must provide both
{
state.Output.Fatal("If you don't specify a problem type, you must provide a training file and a testing file",
(training_file == null ? paramBase.Push(P_TRAINING_FILE) : paramBase.Push(P_TESTING_FILE)));
}
else // load from files
{
try
{
int numInputs = 0;
// first load the number of input variables
var scan = new Scanner(training_file);
if (scan.HasNextInt())
{
numInputs = scan.NextInt();
}
else
{
state.Output.Fatal("Number of input variables not provided at beginning of training file ", paramBase.Push(P_TRAINING_FILE), null);
}
// Load into an array list each element
var input = new List <double[]>();
var output = new List <double>();
while (scan.HasNextDouble())
{
var in_ = new double[numInputs];
var out_ = 0.0;
for (var i = 0; i < numInputs; i++)
{
if (scan.HasNextDouble())
{
in_[i] = scan.NextDouble();
}
else
{
state.Output.Fatal("Non-normal number of data points in training file ", paramBase.Push(P_TRAINING_FILE), null);
}
}
if (scan.HasNextDouble())
{
out_ = scan.NextDouble();
}
else
{
state.Output.Fatal("Non-normal number of data points in training file ", paramBase.Push(P_TRAINING_FILE), null);
}
input.Add(in_);
output.Add(out_);
}
// dump to arrays
var len = input.Count;
trainingInputs = new double[len][];
for (var i = 0; i < len; i++)
{
trainingInputs[i] = new double[numInputs];
}
trainingOutputs = new double[len];
for (var i = 0; i < len; i++)
{
trainingInputs[i] = input[i];
trainingOutputs[i] = output[i];
}
// same thing for testing
scan = new Scanner(testing_file);
if (scan.HasNextInt())
{
numInputs = scan.NextInt();
}
else
{
state.Output.Fatal("Number of input variables not provided at beginning of testing file ", paramBase.Push(P_TESTING_FILE), null);
}
// Load into an array list each element
input = new List <double[]>();
output = new List <double>();
while (scan.HasNextDouble())
{
var in_ = new double[numInputs];
var out_ = 0.0;
for (var i = 0; i < numInputs; i++)
{
if (scan.HasNextDouble())
{
in_[i] = scan.NextDouble();
}
else
{
state.Output.Fatal("Non-normal number of data points in testing file ", paramBase.Push(P_TESTING_FILE), null);
}
}
if (scan.HasNextDouble())
{
out_ = scan.NextDouble();
}
else
{
state.Output.Fatal("Non-normal number of data points in testing file ", paramBase.Push(P_TESTING_FILE), null);
}
input.Add(in_);
output.Add(out_);
}
// dump to arrays
len = input.Count;
testingInputs = new double[len][];
for (var i = 0; i < len; i++)
{
testingInputs[i] = new double[numInputs];
}
testingOutputs = new double[len];
for (var i = 0; i < len; i++)
{
testingInputs[i] = input[i];
testingOutputs[i] = output[i];
}
}
catch (FormatException e)
{
state.Output.Fatal("Some tokens in the file were not numbers.");
}
}
}
else
{
// determine benchmark
for (var i = 0; i < names.Length; i++)
{
if (names[i].Equals(problem)) // got it
{
benchmark = i; break;
}
}
if (benchmark == -1) // uh oh
{
state.Output.Fatal("Could not find benchmark " + problem, paramBase.Push(P_PROBLEM_TYPE), null);
}
state.Output.Message("Doing benchmark " + names[benchmark]);
try
{
trainingInputs = trainPoints(state, benchmark, 0);
trainingOutputs = new double[trainingInputs.Length];
for (var i = 0; i < trainingOutputs.Length; i++)
{
trainingOutputs[i] = func(state, trainingInputs[i], benchmark);
}
}
catch (ArgumentException e)
{
state.Output.Fatal("Error in generating training data: " + e.Message);
}
try
{
testingInputs = testPoints(state, benchmark, 0, trainingInputs);
testingOutputs = new double[testingInputs.Length];
for (var i = 0; i < testingOutputs.Length; i++)
{
testingOutputs[i] = func(state, testingInputs[i], benchmark);
}
}
catch (ArgumentException e)
{
state.Output.Fatal("Error in generating testing data: " + e.Message);
}
}
var param = new Parameter("gp.tc.0.fset"); // we assume we have a single tree
var pval = state.Parameters.GetString(param, null);
// verify the number of variables match the expected function set
if (problem == null) // it's being loaded from file
{
var found = false;
var vars = fs_vars[trainingInputs[0].Length];
for (var i = 0; i < vars.Length; i++)
{
if (pval.Equals(vars[i]))
{
found = true; break;
}
}
if (!found)
{
state.Output.Warning("The number of variables in your problem data (" + trainingInputs[0].Length +
"does not match the variables found in the function set " + pval + ". Hope you know what you're doing.",
param);
}
else
{
state.Output.Message("Using function set " + pval);
}
}
else
{
if (!(pval.Equals(fs[benchmark]))) // uh oh
{
state.Output.Warning("The number of variables for the " + names[benchmark] +
" problem (" + trainingInputs[0].Length +
") is normally handled by the function set " + fs[benchmark] +
" but you are using " + pval + ". Hope you know what you're doing. " +
"To correct this, try adding the parameter gp.tc.0.fset=" + fs[benchmark],
param);
}
else
{
state.Output.Message("Using function set " + pval);
}
}
// set up our input -- don't want to use the default base, it's unsafe
data = (RegressionData)state.Parameters.GetInstanceForParameterEq(paramBase.Push(P_DATA), null, typeof(RegressionData));
data.Setup(state, paramBase.Push(P_DATA));
}
private static void DemoteSomethingDirtyWork(GPNode node, IEvolutionState state, int thread, GPFunctionSet funcs)
{
var numDemotable = 0;
GPType t;
var initializer = ((GPInitializer)state.Initializer);
if (node.Parent is GPNode)
{
// ugh, expensive
t = ((GPNode)(node.Parent)).Constraints(initializer).ChildTypes[node.ArgPosition];
}
else
{
t = ((GPTree)(node.Parent)).Constraints(initializer).TreeType;
}
// Now, determine how many nodes we can demote this under --
// note this doesn't select based on the total population
// of "available child positions", but on the total population
// of *nodes* regardless of if they have more than one possible
// valid "child position".
for (var x = 0; x < funcs.Nonterminals[t.Type].Length; x++)
{
if (funcs.Nonterminals[t.Type][x].Constraints(initializer).ChildTypes
.Any(t1 => t1.CompatibleWith(initializer, node.Constraints(initializer).ReturnType)))
{
numDemotable++;
}
}
// pick a random item to demote -- numDemotable is assumed to be > 0
var demoteItem = state.Random[thread].NextInt(numDemotable);
numDemotable = 0;
// find it
for (var x = 0; x < funcs.Nonterminals[t.Type].Length; x++)
{
if (funcs.Nonterminals[t.Type][x].Constraints(initializer).ChildTypes
.Any(t1 => t1.CompatibleWith(initializer, node.Constraints(initializer).ReturnType)))
{
if (numDemotable == demoteItem)
{
// clone the node
var cnode = funcs.Nonterminals[t.Type][x].LightClone();
// choose a spot to hang the old parent under
var retyp = node.Constraints(initializer).ReturnType;
var chityp = cnode.Constraints(initializer).ChildTypes;
var numSpots = cnode.Children.Where((t1, z) => chityp[z].CompatibleWith(initializer, retyp)).Count();
var choice = state.Random[thread].NextInt(numSpots);
numSpots = 0;
for (var z = 0; z < cnode.Children.Length; z++)
{
if (chityp[z].CompatibleWith(initializer, retyp))
{
if (numSpots == choice)
{
// demote the parent, inserting cnode
cnode.Parent = node.Parent;
cnode.ArgPosition = node.ArgPosition;
cnode.Children[z] = node;
node.Parent = cnode;
node.ArgPosition = (sbyte)z;
if (cnode.Parent is GPNode)
{
((GPNode)(cnode.Parent)).Children[cnode.ArgPosition] = cnode;
}
else
{
((GPTree)(cnode.Parent)).Child = cnode;
}
// this is important to ensure that the
// demotion only happens once! Otherwise
// you'll get really nasty bugs
numSpots++; // notice no break
}
else
{
// hang a randomly-generated terminal off of cnode
var term = funcs.Terminals
[chityp[z].Type][state.Random[thread].NextInt(funcs.Terminals[chityp[z].Type].Length)].LightClone();
cnode.Children[z] = term;
term.Parent = cnode; // just in case
term.ArgPosition = (sbyte)z; // just in case
term.ResetNode(state, thread); // let it randomize itself if necessary
// increase numSpots
numSpots++; // notice no break
}
}
else
{
// hang a randomly-generated terminal off of cnode
var term = funcs.Terminals
[chityp[z].Type][state.Random[thread].NextInt(funcs.Terminals[chityp[z].Type].Length)].LightClone();
cnode.Children[z] = term;
term.Parent = cnode; // just in case
term.ArgPosition = (sbyte)z; // just in case
term.ResetNode(state, thread); // let it randomize itself if necessary
}
}
return;
}
numDemotable++;
}
}
// should never reach here
throw new ApplicationException("Bug in demoteSomething -- should never be able to reach the end of the function");
}
/// <summary>
/// I hard-code both Produce(...) methods for efficiency's sake.
/// </summary>
public override int Produce(int subpop, IEvolutionState state, int thread)
{
return(0);
}
public override int Produce(
int min,
int max,
int subpop,
IList <Individual> inds,
IEvolutionState state,
int thread,
IDictionary <string, object> misc)
{
int start = inds.Count;
// grab n individuals from our source and stick 'em right into inds.
// we'll modify them from there
var n = Sources[0].Produce(min, max, subpop, inds, state, thread, misc);
// should we bother?
if (!state.Random[thread].NextBoolean(Likelihood))
{
return(n);
}
var initializer = (GPInitializer)state.Initializer;
// now let's mutate 'em
for (var q = start; q < n + start; q++)
{
var i = (GPIndividual)inds[q];
if (Tree != TREE_UNFIXED && (Tree < 0 || Tree >= i.Trees.Length))
{
// uh oh
state.Output.Fatal("MutateDemotePipeline attempted to fix tree.0 to a value"
+ " which was out of bounds of the array of the individual's trees. "
+ " Check the pipeline's fixed tree values -- they may be negative"
+ " or greater than the number of trees in an individual");
}
for (var x = 0; x < NumTries; x++)
{
int t;
// pick random tree
if (Tree == TREE_UNFIXED)
{
if (i.Trees.Length > 1)
{
t = state.Random[thread].NextInt(i.Trees.Length);
}
else
{
t = 0;
}
}
else
{
t = Tree;
}
// is the tree demotable?
int numdemote = NumDemotableNodes(initializer, i.Trees[t].Child, 0, i.Trees[t].Constraints(initializer).FunctionSet);
if (numdemote == 0)
{
continue; // uh oh, try again
}
// demote the node, or if we're unsuccessful, just leave it alone
PickDemotableNode(initializer, i.Trees[t].Child, state.Random[thread].NextInt(numdemote),
i.Trees[t].Constraints(initializer).FunctionSet);
// does this node exceed the maximum depth limits?
if (!VerifyPoint(_demotableNode))
{
continue; // uh oh, try again
}
// demote it
DemoteSomething(_demotableNode, state, thread, i.Trees[t].Constraints(initializer).FunctionSet);
i.Evaluated = false;
break;
}
// add the new individual, replacing its previous source
inds[q] = i;
}
return(n);
}
/// <summary>
/// I hard-code both Produce(...) methods for efficiency's sake.
/// </summary>
public override int Produce(int subpop, IEvolutionState state, int thread)
{
return(state.Random[thread].NextInt(state.Population.Subpops[subpop].Individuals.Count));
}
/* Produce random sample points between min and max, inclusive, in one dimension. */
public double[][] generateRandomSamples(IEvolutionState state, double min, double max, int numPoints, int threadnum)
{
return(generateRandomSamples(state, new[] { min }, new[] { max }, numPoints, threadnum));
}
// making sure that we don't have any children is already
// done in ERC.checkConstraints(), so we don't need to implement that.
// this will produce numbers from [-1.0, 1.0), which is probably
// okay but you might want to modify it if you don't like seeing
// -1.0's occasionally showing up very rarely.
public override void ResetNode(IEvolutionState state, int thread)
{
value = state.Random[thread].NextDouble() * 2 - 1.0;
}
/* Produce sample points evenly spaced out between min and max in one dimension, with the given spacing interval. One dimension only. */
public double[][] generateIntervalSpacedSamples(IEvolutionState state, double min, double max, double interval, int threadnum)
{
return(generateIntervalSpacedSamples(state, new[] { min }, new[] { max }, new[] { interval }, threadnum));
}
public override void WriteNode(IEvolutionState state, BinaryWriter dataOutput) // throws IOException
{
dataOutput.Write(value);
}
/* Produce sample points for a given benchmark problem. */
public double[][] trainPoints(IEvolutionState state, int benchmark, int threadnum)
{
switch (benchmark)
{
case KOZA1:
case KOZA2:
case KOZA3:
return(generateRandomSamples(state, -1, 1, 20, threadnum));
case NGUYEN1:
case NGUYEN2:
case NGUYEN3:
case NGUYEN4:
case NGUYEN5:
case NGUYEN6:
return(generateRandomSamples(state, -1, 1, 20, threadnum));
case NGUYEN7:
return(generateRandomSamples(state, 0, 2, 20, threadnum));
case NGUYEN8:
return(generateRandomSamples(state, 0, 4, 20, threadnum));
case NGUYEN9:
case NGUYEN10:
case NGUYEN11:
case NGUYEN12:
return(generateRandomSamples(state, new double[] { 0, 0 }, new double[] { 1, 1 }, 100, threadnum));
case PAGIE1:
return(generateIntervalSpacedSamples(state, new[] { -5.0, -5.0 }, new[] { 5.0, 5.0 }, new[] { 0.4, 0.4 }, threadnum));
case PAGIE2:
return(generateIntervalSpacedSamples(state, new[] { -5.0, -5.0, -5.0 }, new[] { 5.0, 5.0, 5.0 }, new[] { 0.4, 0.4, 0.4 }, threadnum));
case KORNS1:
case KORNS2:
case KORNS3:
case KORNS4:
case KORNS5:
case KORNS6:
case KORNS7:
case KORNS8:
case KORNS9:
case KORNS10:
case KORNS11:
case KORNS12:
case KORNS13:
case KORNS14:
case KORNS15:
return(generateRandomSamples(state, new double[] { -50, -50, -50, -50, -50 }, new double[] { 50, 50, 50, 50, 50 }, 10000, threadnum)); // 10000 !!
case KEIJZER1:
return(generateIntervalSpacedSamples(state, -1, 1, 0.1, threadnum));
case KEIJZER2:
return(generateIntervalSpacedSamples(state, -2, 2, 0.1, threadnum));
case KEIJZER3:
return(generateIntervalSpacedSamples(state, -3, 3, 0.1, threadnum));
case KEIJZER4:
return(generateIntervalSpacedSamples(state, 0, 10, 0.05, threadnum));
case KEIJZER5:
return(generateRandomSamples(state, new double[] { -1, -1, 1 }, new double[] { 1, 1, 2 }, 1000, threadnum));
case KEIJZER6:
return(generateIntervalSpacedSamples(state, 1, 50, 1, threadnum));
case KEIJZER7:
return(generateIntervalSpacedSamples(state, 1, 100, 1, threadnum));
case KEIJZER8:
case KEIJZER9:
return(generateIntervalSpacedSamples(state, 0, 100, 1, threadnum));
case KEIJZER10:
return(generateRandomSamples(state, new double[] { 0, 0 }, new double[] { 1, 1 }, 100, threadnum));
case KEIJZER11:
case KEIJZER12:
case KEIJZER13:
case KEIJZER14:
case KEIJZER15:
return(generateRandomSamples(state, new double[] { -3, -3 }, new double[] { 3, 3 }, 20, threadnum));
case VLADISLAVLEVA1:
return(generateRandomSamples(state, new[] { 0.3, 0.3 }, new double[] { 4, 4 }, 100, threadnum));
case VLADISLAVLEVA2:
return(generateIntervalSpacedSamples(state, 0.05, 10, 0.1, threadnum));
case VLADISLAVLEVA3:
return(generateIntervalSpacedSamples(state, new[] { 0.05, 0.05 }, new[] { 10, 10.05 }, new[] { 0.1, 2 }, threadnum));
case VLADISLAVLEVA4:
return(generateRandomSamples(state, new[] { 0.05, 0.05, 0.05, 0.05, 0.05 }, new[] { 6.05, 6.05, 6.05, 6.05, 6.05 }, 1024, threadnum));
case VLADISLAVLEVA5:
return(generateRandomSamples(state, new[] { 0.05, 1, 0.05 }, new double[] { 2, 2, 2 }, 300, threadnum));
case VLADISLAVLEVA6:
return(generateRandomSamples(state, new[] { 0.1, 0.1 }, new[] { 5.9, 5.9 }, 30, threadnum));
case VLADISLAVLEVA7:
return(generateRandomSamples(state, new[] { 0.05, 0.05 }, new[] { 6.05, 6.05 }, 300, threadnum));
case VLADISLAVLEVA8:
return(generateRandomSamples(state, new[] { 0.05, 0.05 }, new[] { 6.05, 6.05 }, 50, threadnum));
default:
return(null);
}
}
static void Main(string[] args)
{
CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
ECActivator.AddSourceAssemblies(new[] { Assembly.GetAssembly(typeof(IEvolutionState)), Assembly.GetAssembly(typeof(FeatureExtractionProblem2)) });
IEvolutionState state = Evolve.Initialize(Evolve.LoadParameterDatabase(new[] { "-file", @"Parameters\problem2.params" }), 11);
state.Run(EvolutionState.C_STARTED_FRESH);
var problem = (FeatureExtractionProblem2)state.Evaluator.p_problem;
// var treeLog1 = state.Output.AddLog(@"F:\Gesty\logs\gvtree_gen1.txt");
//var treeLog2 = state.Output.AddLog(@"F:\Gesty\logs\gvtree_gen10.txt");
//var ecjGraph = state.Output.AddLog(@"F:\Gesty\logs\ecjGraph.txt");
//var bestOfRun = ((SimpleStatistics)state.Statistics).BestOfRun[0];
//((GPIndividual)bestOfRun).Trees[0].PrintTree(state, ecjGraph);
//((GPIndividual)bestOfRun).Trees[0].PrintStyle = GPTree.PRINT_STYLE_DOT;
//((GPIndividual)bestOfRun).Trees[0].PrintTreeForHumans(state, treeLog);
var input = problem.Input;
var stack = problem.Stack;
var stats = (SimpleStatistics)state.Statistics;
var bestOfRun = (GPIndividual)stats.BestOfRun[0];
var treeReader = new StreamReader(@"F:\Gesty\logs\ecjGraph.txt");
bestOfRun.Trees[0].ReadTree(state, treeReader);
bestOfRun.Evaluated = false;
var imageList = new string[] {
@"F:\Gesty\problem2\grayscale\A\a\color_0_0002.png",
@"F:\Gesty\problem2\grayscale\A\b\color_1_0002.png",
@"F:\Gesty\problem2\grayscale\A\c\color_2_0002.png",
@"F:\Gesty\problem2\grayscale\A\f\color_5_0002.png",
@"F:\Gesty\problem2\grayscale\A\h\color_7_0002.png"
};
int i = 0;
foreach (string image in imageList)
{
var dir = @"F:\Gesty\testy\examples";
var tempImg = new Image <Gray, Byte>(image);
tempImg.CopyTo(problem.currentImage[0]);
tempImg.CopyTo(problem.originalImage[0]);
bestOfRun.Trees[0].Child.Eval(state, 0, input, stack, bestOfRun, problem);
tempImg.Save(dir + @"\" + i + ".png");
problem.currentImage[0].Save(dir + @"\" + i + "_trans.png");
ImageTransformer.GetSquareSuperpixelImages(problem.currentImage[0], dir, i.ToString(), 8);
i++;
}
problem.Evaluate(state, bestOfRun, 0, 0);
Console.WriteLine(bestOfRun.Fitness);
/*
* var confMatFile = new StreamWriter(@"F:\Gesty\testy\confmatBest.csv");
* for (int x = 0; x < 10; x++)
* {
* var line = new StringBuilder();
* for (int j = 0; j < 10; j++)
* {
* line.Append(problem.confMat[x, j].ToString() + ';');
* }
* confMatFile.WriteLine(line.ToString().Trim(';'));
* }
* confMatFile.Close();
*/
// Console.WriteLine(bestOfRun.Fitness);
/*
* var tempImg = new Image<Gray, Byte>(@"F:\Gesty\problem2\grayscale\A\a\color_0_0002.png");
* tempImg.CopyTo(problem.currentImage[0]);
* tempImg.CopyTo(problem.originalImage[0]);
* ((GPIndividual)bestOfRun).Trees[0].Child.Eval(state, 0, input, stack, bestOfRun, problem);
* problem.currentImage[0].Save(@"F:\Gesty\testy\transformed.png");
*/
/*
* var gesty = new string[8] { "piesc", "dlon", "1p", "2p", "3p", "4p", "5p", "kciuk" };
* var imageIndex = 0;
* foreach (string gest in gesty)
* {
* var dir = @"F:\Gesty\superpixel\200x200\" + gest;
*
* //oryginalny
* var tempImg = new Image<Gray, Byte>(problem.imageList[imageIndex]);
* tempImg.CopyTo(problem.currentImage[0]);
* tempImg.CopyTo(problem.originalImage[0]);
* tempImg.Dispose();
* bestOfRun.Trees[0].Child.Eval(state, 0, input, stack, bestOfRun, problem);
* problem.imageTransformer.GetSuperpixelImages(problem.currentImage[0], dir, "oryginalny");
* imageIndex += 101;
*
* //obrocony
* var tempImg2 = new Image<Gray, Byte>(problem.imageList[imageIndex]);
* tempImg2.CopyTo(problem.currentImage[0]);
* tempImg2.CopyTo(problem.originalImage[0]);
* tempImg2.Dispose();
* bestOfRun.Trees[0].Child.Eval(state, 0, input, stack, bestOfRun, problem);
* problem.imageTransformer.GetSuperpixelImages(problem.currentImage[0], dir, "obrocony");
* imageIndex += 101;
*
* //zaklocony
* var tempImg3 = new Image<Gray, Byte>(problem.imageList[imageIndex]);
* tempImg3.CopyTo(problem.currentImage[0]);
* tempImg3.CopyTo(problem.originalImage[0]);
* tempImg3.Dispose();
* bestOfRun.Trees[0].Child.Eval(state, 0, input, stack, bestOfRun, problem);
* problem.imageTransformer.GetSuperpixelImages(problem.currentImage[0], dir, "zaklocony");
* imageIndex += 11;
* }
*/
Console.ReadKey();
}
/* Produce test sample points for a given benchmark problem, to test generalization. */
public double[][] testPoints(IEvolutionState state, int benchmark, int threadnum, double[][] trainpoints)
{
switch (benchmark)
{
case KOZA1:
case KOZA2:
case KOZA3:
return(trainpoints);
case NGUYEN1:
case NGUYEN2:
case NGUYEN3:
case NGUYEN4:
case NGUYEN5:
case NGUYEN6:
case NGUYEN7:
case NGUYEN8:
case NGUYEN9:
case NGUYEN10:
case NGUYEN11:
case NGUYEN12:
return(trainpoints);
case PAGIE1:
case PAGIE2:
return(trainpoints);
case KORNS1:
case KORNS2:
case KORNS3:
case KORNS4:
case KORNS5:
case KORNS6:
case KORNS7:
case KORNS8:
case KORNS9:
case KORNS10:
case KORNS11:
case KORNS12:
case KORNS13:
case KORNS14:
case KORNS15:
return(generateRandomSamples(state, new double[] { -50, -50, -50, -50, -50 }, new double[] { 50, 50, 50, 50, 50 }, 10000, threadnum)); // 10000 !!
case KEIJZER1:
return(generateIntervalSpacedSamples(state, -1, 1, 0.001, threadnum));
case KEIJZER2:
return(generateIntervalSpacedSamples(state, -2, 2, 0.001, threadnum));
case KEIJZER3:
return(generateIntervalSpacedSamples(state, -3, 3, 0.001, threadnum));
case KEIJZER4:
return(generateIntervalSpacedSamples(state, 0.05, 10.05, 0.05, threadnum));
case KEIJZER5:
return(generateRandomSamples(state, new double[] { -1, -1, 1 }, new double[] { 1, 1, 2 }, 10000, threadnum)); // 10000 cases for testing, different than for training
case KEIJZER6:
return(generateIntervalSpacedSamples(state, 1, 120, 1, threadnum));
case KEIJZER7:
return(generateIntervalSpacedSamples(state, 1, 100, 0.1, threadnum));
case KEIJZER8:
case KEIJZER9:
return(generateIntervalSpacedSamples(state, 0, 100, 0.1, threadnum));
case KEIJZER10:
return(generateIntervalSpacedSamples(state, new double[] { 0, 0 }, new double[] { 1, 1 }, new[] { 0.01, 0.01 }, threadnum));
case KEIJZER11:
case KEIJZER12:
case KEIJZER13:
case KEIJZER14:
case KEIJZER15:
return(generateIntervalSpacedSamples(state, new[] { -3.0, -3.0 }, new[] { 3.0, 3.0 }, new[] { 0.01, 0.01 }, threadnum));
case VLADISLAVLEVA1:
return(generateIntervalSpacedSamples(state, new[] { -0.2, -0.2 }, new[] { 4.2, 4.2 }, new[] { 0.1, 0.1 }, threadnum));
case VLADISLAVLEVA2:
return(generateIntervalSpacedSamples(state, -0.5, 10.5, 0.05, threadnum));
case VLADISLAVLEVA3:
return(generateIntervalSpacedSamples(state, new[] { -0.5, -0.5 }, new[] { 10.5, 10.5 }, new[] { 0.05, 0.5 }, threadnum)); // note 0.05 and 0.5, and also 10.5 which is different from training
case VLADISLAVLEVA4:
return(generateRandomSamples(state, new[] { -0.25, -0.25, -0.25, -0.25, -0.25 }, new[] { 6.35, 6.35, 6.35, 6.35, 6.35 }, 5000, threadnum));
case VLADISLAVLEVA5:
return(generateIntervalSpacedSamples(state, new[] { -0.05, 0.95, -0.05 }, new[] { 2.1, 2.05, 2.1 }, new[] { 0.15, 0.15, 0.1 }, threadnum)); // note 0.05 and 0.5, and also 10.5 which is different from training
case VLADISLAVLEVA6:
return(generateIntervalSpacedSamples(state, new[] { -0.05, -0.05 }, new[] { 6.05, 6.05 }, new[] { 0.02, 0.02 }, threadnum)); // note 0.05 and 0.5, and also 10.5 which is different from training
case VLADISLAVLEVA7:
return(generateRandomSamples(state, new[] { -0.25, -0.25 }, new[] { 6.35, 6.35 }, 1000, threadnum));
case VLADISLAVLEVA8:
return(generateIntervalSpacedSamples(state, new[] { -0.25, -0.25 }, new[] { 6.35, 6.35 }, new[] { 0.2, 0.2 }, threadnum)); // note 0.05 and 0.5, and also 10.5 which is different from training
default:
return(null);
}
}
public void Setup(IEvolutionState state, Parameter paramBase)
{
base.Setup(state, paramBase);
IParameter def = DefaultBase;
IParameter p = paramBase.Push(P_NODESELECTOR).Push("0");
IParameter d = def.Push(P_NODESELECTOR).Push("0");
NodeSelect1 = (IGPNodeSelector)state.Parameters.GetInstanceForParameter(p, d, typeof(IGPNodeSelector));
NodeSelect1.Setup(state, p);
p = paramBase.Push(P_NODESELECTOR).Push("1");
d = def.Push(P_NODESELECTOR).Push("1");
if (state.Parameters.ParameterExists(p, d) && state.Parameters.GetString(p, d).Equals(V_SAME))
{
// can't just copy it this time; the selectors
// use internal caches. So we have to clone it no matter what
NodeSelect2 = (IGPNodeSelector)NodeSelect1.Clone();
}
else
{
NodeSelect2 = (IGPNodeSelector)state.Parameters.GetInstanceForParameter(p, d, typeof(IGPNodeSelector));
NodeSelect2.Setup(state, p);
}
NumTries = state.Parameters.GetInt(paramBase.Push(P_NUM_TRIES), def.Push(P_NUM_TRIES), 1);
if (NumTries == 0)
{
state.Output.Fatal("GPCrossover Pipeline has an invalid number of tries (it must be >= 1).",
paramBase.Push(P_NUM_TRIES), def.Push(P_NUM_TRIES));
}
MaxDepth = state.Parameters.GetInt(paramBase.Push(P_MAXDEPTH), def.Push(P_MAXDEPTH), 1);
if (MaxDepth == 0)
{
state.Output.Fatal("GPCrossover Pipeline has an invalid maximum depth (it must be >= 1).",
paramBase.Push(P_MAXDEPTH), def.Push(P_MAXDEPTH));
}
Tree1 = TREE_UNFIXED;
if (state.Parameters.ParameterExists(paramBase.Push(P_TREE).Push("" + 0), def.Push(P_TREE).Push("" + 0)))
{
Tree1 = state.Parameters.GetInt(paramBase.Push(P_TREE).Push("" + 0), def.Push(P_TREE).Push("" + 0), 0);
if (Tree1 == -1)
{
state.Output.Fatal("Tree fixed value, if defined, must be >= 0");
}
}
Tree2 = TREE_UNFIXED;
if (state.Parameters.ParameterExists(paramBase.Push(P_TREE).Push("" + 1), def.Push(P_TREE).Push("" + 1)))
{
Tree2 = state.Parameters.GetInt(paramBase.Push(P_TREE).Push("" + 1), def.Push(P_TREE).Push("" + 1), 0);
if (Tree2 == -1)
{
state.Output.Fatal("Tree fixed value, if defined, must be >= 0");
}
}
TossSecondParent = state.Parameters.GetBoolean(paramBase.Push(P_TOSS), def.Push(P_TOSS), false);
if (state.Parameters.ParameterExists(paramBase.Push(P_HOMOLOGOUS), null))
{
//get the parameter
Homologous = state.Parameters.GetBoolean(paramBase.Push(P_HOMOLOGOUS), null, false);
}
}
/* Return the function applied to the given data by benchmark problem. */
public double func(IEvolutionState state, double[] xs, int benchmark) // throws ArgumentException
{
var x = xs[0];
var y = (xs.Length > 1 ? xs[1] : 0);
var z = (xs.Length > 2 ? xs[2] : 0);
switch (benchmark)
{
case KOZA1:
return(x * x * x * x + x * x * x + x * x + x); // traditional
case KOZA2:
return(x * x * x * x * x - 2.0 * x * x * x + x); // Quintic, from J. R. Koza, GP II, 1994
case KOZA3:
return(x * x * x * x * x * x - 2.0 * x * x * x * x + x * x); // Sextic, from J. R. Koza, GP II, 1994
case NGUYEN1:
return(x * x * x + x * x + x);
case NGUYEN2: // identical to KOZA1
return(x * x * x * x + x * x * x + x * x + x);
case NGUYEN3:
return(x * x * x * x * x + x * x * x * x + x * x * x + x * x + x);
case NGUYEN4:
return(x * x * x * x * x * x + x * x * x * x * x + x * x * x * x + x * x * x + x * x + x);
case NGUYEN5:
return(Math.Sin(x * x) * Math.Cos(x) - 1.0);
case NGUYEN6:
return(Math.Sin(x) + Math.Sin(x * x + x));
case NGUYEN7:
return(Math.Log(x + 1) + Math.Log(x * x + 1.0));
case NGUYEN8: // Note this presumes you don't have sqrt(x) in your function set!
return(Math.Sqrt(x));
case NGUYEN9:
return(Math.Sin(x) + Math.Sin(y * y));
case NGUYEN10:
return(2 * Math.Sin(x) * Math.Cos(y));
case NGUYEN11:
return(Math.Pow(x, y));
case NGUYEN12:
return(x * x * x * x - x * x * x + (y * y) / 2.0 - y);
case PAGIE1:
// otherwise known as 1 / (1 + Math.pow(x,-4)) + 1 / (1 + Math.pow(y,-1))
return(1.0 / (1.0 + 1.0 / (x * x * x * x)) + 1.0 / (1.0 + 1.0 / (y * y * y * y)));
case PAGIE2:
// otherwise known as (1 / (1 + Math.pow(x, -4)) + 1 / (1 + Math.pow(y, -4)) + 1 / (1 + Math.pow(z, -4)));
return(1.0 / (1.0 + 10 / (x * x * x * x)) + 1.0 / (1.0 + 1.0 / (y * y * y * y)) + 1.0 / (1.0 + 1.0 / (z * z * z * z)));
case KORNS1:
return(1.57 + (24.3 * xs[3]));
case KORNS2:
return(0.23 + (14.2 * ((xs[3] + xs[1]) / (3.0 * xs[4]))));
case KORNS3:
return(-5.41 + (4.9 * (((xs[3] - xs[0]) + (xs[1] / xs[4])) / (3 * xs[4]))));
case KORNS4:
return(-2.3 + (0.13 * Math.Sin(xs[2])));
case KORNS5:
return(3.0 + (2.13 * Math.Log(xs[4])));
case KORNS6:
return(1.3 + (0.13 * Math.Sqrt(xs[0])));
case KORNS7:
return(213.80940889 - (213.80940889 * Math.Exp(-0.54723748542 * xs[0])));
case KORNS8:
return(6.87 + (11.0 * Math.Sqrt(7.23 * xs[0] * xs[3] * xs[4])));
case KORNS9:
return(Math.Sqrt(xs[0]) / Math.Log(xs[1]) * Math.Exp(xs[2] / (xs[3] * xs[3])));
case KORNS10:
return(0.81 + (24.3 * (((2.0 * xs[1]) + (3.0 * (xs[2] * xs[2]))) / ((4.0 * (xs[3] * xs[3] * xs[3])) + (5.0 * (xs[4] * xs[4] * xs[4] * xs[4]))))));
case KORNS11:
return(6.87 + (11.0 * Math.Cos(7.23 * xs[0] * xs[0] * xs[0])));
case KORNS12:
return(2.0 - (2.1 * (Math.Cos(9.8 * xs[0]) * Math.Sin(1.3 * xs[4]))));
case KORNS13:
return(32.0 - (3.0 * ((Math.Tan(xs[0]) / Math.Tan(xs[1])) * (Math.Tan(xs[2]) / Math.Tan(xs[3])))));
case KORNS14:
return(22.0 - (4.2 * ((Math.Cos(xs[0]) - Math.Tan(xs[1])) * (Math.Tanh(xs[2]) / Math.Sin(xs[3])))));
case KORNS15:
return(12.0 - (6.0 * ((Math.Tan(xs[0]) / Math.Exp(xs[1])) * (Math.Log(xs[2]) - Math.Tan(xs[3])))));
case KEIJZER1: // fall thru
case KEIJZER2: // fall thru
case KEIJZER3:
return(0.3 * x * Math.Sin(2 * Math.PI * x));
case KEIJZER4:
return(x * x * x * Math.Exp(-x) * Math.Cos(x) * Math.Sin(x) * (Math.Sin(x) * Math.Sin(x) * Math.Cos(x) - 1));
case KEIJZER5:
return((30.0 * x * z) / ((x - 10.0) * y * y));
case KEIJZER6:
{
var sum = 0.0;
var fx = Math.Floor(x);
for (var i = 1; i < fx + 1; i++) // up to and including floor(x)
{
sum += (1.0 / i);
}
return(sum);
}
case KEIJZER7: // Note this presumes you don't have log(x) in your function set!
return(Math.Log(x));
case KEIJZER8: // same as NGUYEN8
return(Math.Sqrt(x));
case KEIJZER9:
return(asinh(x)); // Not a function in Math
case KEIJZER10:
return(Math.Pow(x, y)); // same as NGUYEN11
case KEIJZER11:
return(x * y + Math.Sin((x - 1.0) * (y - 1.0)));
case KEIJZER12:
return(x * x * x * x - x * x * x + y * y / 2.0 - y);
case KEIJZER13:
return(6.0 * Math.Sin(x) * Math.Cos(y));
case KEIJZER14:
return(8.0 / (2.0 + x * x + y * y));
case KEIJZER15:
return(x * x * x / 5.0 + y * y * y / 2.0 - y - x);
case VLADISLAVLEVA1:
return(Math.Exp(-(x - 1) * (x - 1)) / (1.2 + (y - 2.5) * (y - 2.5)));
case VLADISLAVLEVA2:
return(Math.Exp(-x) * x * x * x * Math.Cos(x) * Math.Sin(x) * (Math.Cos(x) * Math.Sin(x) * Math.Sin(x) - 1));
case VLADISLAVLEVA3:
return(Math.Exp(-x) * x * x * x * Math.Cos(x) * Math.Sin(x) * (Math.Cos(x) * Math.Sin(x) * Math.Sin(x) - 1) * (y - 5));
case VLADISLAVLEVA4:
{
double sum = 0;
for (var i = 0; i < 5; i++)
{
sum += (xs[i] - 3) * (xs[i] - 3);
}
return(10.0 / (5.0 + sum));
}
case VLADISLAVLEVA5:
return((30.0 * (x - 1.0) * (z - 1.0)) / (y * y * (x - 10.0)));
case VLADISLAVLEVA6:
return(6.0 * Math.Sin(x) * Math.Cos(y));
case VLADISLAVLEVA7:
return((x - 3.0) * (y - 3.0) + 2 * Math.Sin((x - 4.0) * (y - 4.0)));
case VLADISLAVLEVA8:
return(((x - 3.0) * (x - 3.0) * (x - 3.0) * (x - 3.0) + (y - 3.0) * (y - 3.0) * (y - 3.0) - (y - 3.0)) / ((y - 2.0) * (y - 2.0) * (y - 2.0) * (y - 2.0) + 10.0));
default:
throw new ArgumentException("Invalid benchmark value " + benchmark);
}
// never reaches here
}
/**
* This method finds a node using the logic given in the langdon paper.
* @param nodeToSubtrees For Tree of Parent2 all precomputed stats about depth,subtrees etc
* @param sizeToNodes Quick lookup for LinkedList of size to Nodes
* @param parent1SelectedNode Node selected in parent1
* @param Tree2 Tree of parent2
* @param state Evolution State passed for getting access to Random Object of MersenneTwiser
* @param thread thread number
*/
protected GPNode FindFairSizeNode(ArrayList nodeToSubtrees,
Hashtable sizeToNodes,
GPNode parent1SelectedNode,
GPTree tree2,
IEvolutionState state,
int thread)
{
GPNode selectedNode = null;
// get the size of subtrees of parent1
int parent1SubTrees = parent1SelectedNode.NumNodes(GPNode.NODESEARCH_NONTERMINALS);
// the maximum length in mate we are looking for
int maxmatesublen = parent1SubTrees == 0 ? 0 : 2 * parent1SubTrees + 1;
// lets see if for all lengths we have trees corresponding
bool[] mateSizeAvailable = new bool[maxmatesublen + 1];
// initialize the array to false
for (int i = 0; i < maxmatesublen; i++)
{
mateSizeAvailable[i] = false;
}
// check for ones we have
for (int i = 0; i < nodeToSubtrees.Count; i++)
{
NodeInfo nodeInfo = (NodeInfo)nodeToSubtrees[i];
// get the length of trees
int subtree = nodeInfo.NumberOfSubTreesBeneath;
if (subtree <= maxmatesublen)
{
mateSizeAvailable[subtree] = true;
}
}
// choose matesublen so mean size change=0 if possible
int countOfPositives = 0;
int countOfNegatives = 0;
int sumOfPositives = 0;
int sumOfNegatives = 0;
int l;
for (l = 1; l < parent1SubTrees; l++)
{
if (mateSizeAvailable[l])
{
countOfNegatives++;
sumOfNegatives += parent1SubTrees - l;
}
}
for (l = parent1SubTrees + 1; l <= maxmatesublen; l++)
{
if (mateSizeAvailable[l])
{
countOfPositives++;
sumOfPositives += l - parent1SubTrees;
}
}
// if they are missing use the same
int mateSublengthSelected = 0;
if (sumOfPositives == 0 || sumOfNegatives == 0)
{
//if so then check if mate has the length and use that
if (mateSizeAvailable[parent1SubTrees])
{
mateSublengthSelected = parent1SubTrees;
}
//else we go with zero
}
else
{
// probability of same is dependent on do we find same sub trees
// else 0.0
double pzero = (mateSizeAvailable[parent1SubTrees]) ? 1.0 / parent1SubTrees : 0.0;
// positive probability
double ppositive = (1.0 - pzero) /
(countOfPositives +
((double)(countOfNegatives * sumOfPositives) / (sumOfNegatives)));
// negative probability
double pnegative = (1.0 - pzero) /
(countOfNegatives +
((double)(countOfPositives * sumOfNegatives) / (sumOfPositives)));
// total probability, just for making sure math is right ;-)
double total = countOfNegatives * pnegative + pzero + countOfPositives * ppositive;
// putting an assert for floating point calculations, similar to what langdon does
// assert(total<1.01&&total>.99);
// now create a Roulette Wheel
RouletteWheelSelector wheel = new RouletteWheelSelector(maxmatesublen);
// add probabilities to the wheel
// all below the length of parent node get pnegative
// all above get ppositive and one on node gets pzero
for (l = 1; l < parent1SubTrees; l++)
{
if (mateSizeAvailable[l])
{
wheel.Add(pnegative, l);
}
}
if (mateSizeAvailable[parent1SubTrees])
{
wheel.Add(pzero, parent1SubTrees);
}
for (l = parent1SubTrees + 1; l <= maxmatesublen; l++)
{
if (mateSizeAvailable[l])
{
wheel.Add(ppositive, l);
}
}
// spin the wheel
mateSublengthSelected = wheel.Roulette(state, thread);
}
// now we have length chosen, but there can be many nodes with that
//
LinkedList <NodeInfo> listOfNodes = (LinkedList <NodeInfo>)sizeToNodes[mateSublengthSelected];
if (listOfNodes == null)
{
state.Output.Fatal("In SizeFairCrossoverPipeline, nodes for tree length " + mateSublengthSelected + " is null, indicates some serious error");
}
// in size fair we choose the elements at random for given length
int chosenNode = 0;
// if using fair size get random from the list
if (!Homologous)
{
chosenNode = state.Random[thread].NextInt(listOfNodes.Count);
}
// if Homologous
else
{
if (listOfNodes.Count > 1)
{
GPInitializer initializer = ((GPInitializer)state.Initializer);
int currentMinDistance = int.MaxValue;
for (int i = 0; i < listOfNodes.Count; i++)
{
// get the GP node
GPNode selectedMateNode = listOfNodes.ElementAt(i).Node;
// now lets traverse selected and parent 1 to see divergence
GPNode currentMateNode = selectedMateNode;
GPNode currentParent1Node = parent1SelectedNode;
// found a match?
bool foundAMatchInAncestor = false;
int distance = 0;
while (currentMateNode.Parent != null &&
currentMateNode.Parent is GPNode &&
currentParent1Node.Parent != null &&
currentParent1Node.Parent is GPNode &&
!foundAMatchInAncestor)
{
GPNode parent1 = (GPNode)currentParent1Node.Parent;
GPNode parent2 = (GPNode)currentMateNode.Parent;
// if there is match between compatibility of Parents break
if (parent1.SwapCompatibleWith(initializer, parent2))
{
foundAMatchInAncestor = true;
break;
}
else
{
// need to go one level above of both
currentMateNode = parent2;
currentParent1Node = parent1;
//increment the distance
distance = distance + 1;
}
}
// find the one with least distance
if (distance < currentMinDistance)
{
currentMinDistance = distance;
chosenNode = i;
}
}
}
// else take the first node, no choice
}
NodeInfo nodeInfoSelected = listOfNodes.ElementAt(chosenNode);
selectedNode = nodeInfoSelected.Node;
return(selectedNode);
}
public override void ReadIndividual(IEvolutionState state, BinaryReader dataInput)
{
base.ReadIndividual(state, dataInput);
// Next, read auxillary arrays.
if (dataInput.ReadBoolean())
{
Velocity = new double[dataInput.ReadInt32()];
for (int i = 0; i < Velocity.Length; i++)
{
Velocity[i] = dataInput.ReadDouble();
}
}
else
{
Velocity = new double[genome.Length];
}
if (dataInput.ReadBoolean())
{
Neighborhood = new int[dataInput.ReadInt32()];
for (int i = 0; i < Neighborhood.Length; i++)
{
Neighborhood[i] = dataInput.ReadInt32();
}
}
else
{
Neighborhood = null;
}
if (dataInput.ReadBoolean())
{
NeighborhoodBestGenome = new double[dataInput.ReadInt32()];
for (int i = 0; i < NeighborhoodBestGenome.Length; i++)
{
NeighborhoodBestGenome[i] = dataInput.ReadDouble();
}
}
else
{
NeighborhoodBestGenome = null;
}
if (dataInput.ReadBoolean())
{
NeighborhoodBestFitness = (Fitness)Fitness.Clone();
NeighborhoodBestFitness.ReadFitness(state, dataInput);
}
if (dataInput.ReadBoolean())
{
PersonalBestGenome = new double[dataInput.ReadInt32()];
for (int i = 0; i < PersonalBestGenome.Length; i++)
{
PersonalBestGenome[i] = dataInput.ReadDouble();
}
}
else
{
PersonalBestGenome = null;
}
if (dataInput.ReadBoolean())
{
PersonalBestFitness = (Fitness)Fitness.Clone();
PersonalBestFitness.ReadFitness(state, dataInput);
}
}
