protected internal virtual GAIndividual ReproduceBySimplification(int inIndex) { PushGPIndividual i = (PushGPIndividual)ReproduceByClone(inIndex); i = Autosimplify(i, _reproductionSimplifications); return(i); }
protected internal override GAIndividual ReproduceByMutation(int inIndex) { PushGPIndividual i = (PushGPIndividual)ReproduceByClone(inIndex); int totalsize = i._program.ProgramSize(); int which = ReproductionNodeSelection(i); int oldsize = i._program.SubtreeSize(which); int newsize = 0; if (_useFairMutation) { int range = (int)Math.Max(1, _fairMutationRange * oldsize); newsize = Math.Max(1, oldsize + Rng.Next(2 * range) - range); } else { newsize = Rng.Next(_maxRandomCodeSize); } object newtree; if (newsize == 1) { newtree = _interpreter.randProgram.RandomAtom(); } else { newtree = _interpreter.randProgram.RandomCode(newsize); } if (newsize + totalsize - oldsize <= _maxPointsInProgram) { i._program.ReplaceSubtree(which, newtree); } return(i); }
protected internal override void InitIndividual(GAIndividual inIndividual) { PushGPIndividual i = (PushGPIndividual)inIndividual; int randomCodeSize = Rng.Next(_maxRandomCodeSize) + 2; Program p = _interpreter.randProgram.RandomCode(randomCodeSize); i.SetProgram(p); }
public virtual void RunTestProgram(Program p, int inTestCaseIndex) { PushGPIndividual i = new PushGPIndividual(p); GATestCase test = _testCases[inTestCaseIndex]; Console.Out.WriteLine("Executing program: " + p); EvaluateTestCase(i, test._input, test._output); Console.Out.WriteLine(_interpreter); }
protected internal virtual PushGPIndividual Autosimplify(PushGPIndividual inIndividual, int steps) { PushGPIndividual simplest = (PushGPIndividual)inIndividual.Clone(); PushGPIndividual trial = (PushGPIndividual)inIndividual.Clone(); EvaluateIndividual(simplest, true); float bestError = simplest.GetFitness(); bool madeSimpler = false; for (int i = 0; i < steps; i++) { madeSimpler = false; float method = Rng.Next(100); if (trial._program.ProgramSize() <= 0) { break; } if (method < _simplifyFlattenPercent) { // Flatten random thing int pointIndex = Rng.Next(trial._program.ProgramSize()); object point = trial._program.Subtree(pointIndex); if (point is Program) { trial._program.Flatten(pointIndex); madeSimpler = true; } } else { // Remove small number of random things int numberToRemove = Rng.Next(3) + 1; for (int j = 0; j < numberToRemove; j++) { int trialSize = trial._program.ProgramSize(); if (trialSize > 0) { int pointIndex = Rng.Next(trialSize); trial._program.ReplaceSubtree(pointIndex, new Program()); trial._program.Flatten(pointIndex); madeSimpler = true; } } } if (madeSimpler) { EvaluateIndividual(trial, true); if (trial.GetFitness() <= bestError) { simplest = (PushGPIndividual)trial.Clone(); bestError = trial.GetFitness(); } } trial = (PushGPIndividual)simplest.Clone(); } return(simplest); }
/// <summary>Selects a node to use during crossover or mutation.</summary> /// <remarks> /// Selects a node to use during crossover or mutation. The selection /// mechanism depends on the global parameter _nodeSelectionMode. /// </remarks> /// <param name="inInd">= Individual to select node from.</param> /// <returns>Index of the node to use for reproduction.</returns> protected internal virtual int ReproductionNodeSelection(PushGPIndividual inInd) { int totalSize = inInd._program.ProgramSize(); int selectedNode = 0; if (totalSize <= 1) { selectedNode = 0; } else { if (_nodeSelectionMode.Equals("unbiased")) { selectedNode = Rng.Next(totalSize); } else { if (_nodeSelectionMode.Equals("leaf-probability")) { // TODO Implement. Currently runs unbiased // note: if there aren't any internal nodes, must select leaf, and // if no leaf, must select internal selectedNode = Rng.Next(totalSize); } else { // size-tournament int maxSize = -1; selectedNode = 0; for (int j = 0; j < _nodeSelectionTournamentSize; j++) { int nextwhich = Rng.Next(totalSize); int nextwhichsize = inInd._program.SubtreeSize(nextwhich); if (nextwhichsize > maxSize) { selectedNode = nextwhich; maxSize = nextwhichsize; } } } } } return(selectedNode); }
protected internal override string FinalReport() { string report = string.Empty; report += base.FinalReport(); if (!_targetFunctionString.Equals(string.Empty)) { report += ">> Target Function: " + _targetFunctionString + "\n\n"; } PushGPIndividual simplified = Autosimplify((PushGPIndividual)_populations[_currentPopulation][_bestIndividual], _finalSimplifications); // Note: The number of evaluations here will likely be higher than that // given during the last generational report, since evaluations made // during simplification count towards the total number of // simplifications. report += ">> Number of Evaluations: " + _interpreter.GetEvaluationExecutions() + "\n"; report += ">> Best Program: " + _populations[_currentPopulation][_bestIndividual] + "\n"; report += ">> Fitness (mean): " + _bestMeanFitness + "\n"; if (_testCases.Count == _bestErrors.Count) { report += ">> Errors: ("; for (int i = 0; i < _testCases.Count; i++) { if (i != 0) { report += " "; } report += "(" + _testCases[i]._input + " "; report += Math.Abs(_bestErrors[i]) + ")"; } report += ")\n"; } report += ">> Size: " + _bestSize + "\n\n"; report += "<<<<<<<<<< After Simplification >>>>>>>>>>\n"; report += ">> Best Program: "; report += simplified._program + "\n"; report += ">> Size: "; report += simplified._program.ProgramSize() + "\n\n"; return(report); }
protected internal override GAIndividual ReproduceByCrossover(int inIndex) { PushGPIndividual a = (PushGPIndividual)ReproduceByClone(inIndex); PushGPIndividual b = (PushGPIndividual)TournamentSelect(_tournamentSize, inIndex); if (a._program.ProgramSize() <= 0) { return(b); } if (b._program.ProgramSize() <= 0) { return(a); } int aindex = ReproductionNodeSelection(a); int bindex = ReproductionNodeSelection(b); if (a._program.ProgramSize() + b._program.SubtreeSize(bindex) - a._program.SubtreeSize(aindex) <= _maxPointsInProgram) { a._program.ReplaceSubtree(aindex, b._program.Subtree(bindex)); } return(a); }
protected internal override string Report() { string report = base.Report(); if (double.IsInfinity(_populationMeanFitness)) { _populationMeanFitness = double.MaxValue; } report += ";; Best Program:\n " + _populations[_currentPopulation][_bestIndividual] + "\n\n"; report += ";; Best Program Fitness (mean): " + _bestMeanFitness + "\n"; if (_testCases.Count == _bestErrors.Count) { report += ";; Best Program Errors: ("; for (int i = 0; i < _testCases.Count; i++) { if (i != 0) { report += " "; } report += "(" + _testCases[i]._input + " "; report += Math.Abs(_bestErrors[i]) + ")"; } report += ")\n"; } report += ";; Best Program Size: " + _bestSize + "\n\n"; report += ";; Mean Fitness: " + _populationMeanFitness + "\n"; report += ";; Mean Program Size: " + _averageSize + "\n"; PushGPIndividual simplified = Autosimplify((PushGPIndividual)_populations[_currentPopulation][_bestIndividual], _reportSimplifications); report += ";; Number of Evaluations Thus Far: " + _interpreter.GetEvaluationExecutions() + "\n"; // string mem = (Runtime.GetRuntime().TotalMemory() / 10000000.0f).ToString(); // report += ";; Memory usage: " + mem + "\n\n"; report += ";; Partial Simplification (may beat best):\n "; report += simplified._program + "\n"; report += ";; Partial Simplification Size: "; report += simplified._program.ProgramSize() + "\n\n"; return(report); }