public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory <NeatGenome> genomeFactory, List <NeatGenome> genomeList)
{
IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
ISpeciationStrategy <NeatGenome> speciationStrategy = new KMeansClusteringStrategy <NeatGenome>(distanceMetric);
IComplexityRegulationStrategy complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold);
NeatEvolutionAlgorithm <NeatGenome> ea = new NeatEvolutionAlgorithm <NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy);
// Create black box evaluator
SimpleEvaluator evaluator = new SimpleEvaluator(_optimizer);
IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder();
IGenomeListEvaluator <NeatGenome> innerEvaluator = new UnityParallelListEvaluator <NeatGenome, IBlackBox>(genomeDecoder, evaluator, _optimizer);
IGenomeListEvaluator <NeatGenome> selectiveEvaluator = new SelectiveGenomeListEvaluator <NeatGenome>(innerEvaluator,
SelectiveGenomeListEvaluator <NeatGenome> .CreatePredicate_OnceOnly());
//ea.Initialize(selectiveEvaluator, genomeFactory, genomeList);
//ea.Initialize(innerEvaluator, genomeFactory, genomeList);//this can be used if the currentGeneration does not need to be updated at the start of the training
ea.Initialize(innerEvaluator, genomeFactory, genomeList, true);
return(ea);
}
public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory <NeatGenome> genomeFactory, List <NeatGenome> genomeList)
{
IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
ISpeciationStrategy <NeatGenome> speciationStrategy = new KMeansClusteringStrategy <NeatGenome>(distanceMetric);
IComplexityRegulationStrategy complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold);
NeatEvolutionAlgorithm <NeatGenome> ea = new NeatEvolutionAlgorithm <NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy);
// Create black box evaluator
//PhotoTaxisEvaluator evaluator = new PhotoTaxisEvaluator(_se);
ParallelEvaluator evaluator = new ParallelEvaluator(_se);
IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder();
//IGenomeListEvaluator<NeatGenome> innerEvaluator = new UnityListEvaluator<NeatGenome, IBlackBox>(genomeDecoder, evaluator);
// IGenomeListEvaluator<NeatGenome> innerEvaluator = new UnityParallelListEvaluator<NeatGenome, IBlackBox>(genomeDecoder, evaluator, _se);
//IGenomeListEvaluator<NeatGenome> selectiveEvaluator = new SelectiveGenomeListEvaluator<NeatGenome>(innerEvaluator,
// SelectiveGenomeListEvaluator<NeatGenome>.CreatePredicate_OnceOnly());
// ea.Initialize(selectiveEvaluator, genomeFactory, genomeList);
return(ea);
}
/// <summary>
/// Create and return a NeatEvolutionAlgorithm object ready for running the NEAT algorithm/search. Various sub-parts
/// of the algorithm are also constructed and connected up.
/// This overload accepts a pre-built genome population and their associated/parent genome factory.
/// </summary>
public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory <NeatGenome> genomeFactory, List <NeatGenome> genomeList)
{
// Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference.
IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
ISpeciationStrategy <NeatGenome> speciationStrategy = new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetric, _parallelOptions);
// Create complexity regulation strategy.
IComplexityRegulationStrategy complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold);
// Create the evolution algorithm.
NeatEvolutionAlgorithm <NeatGenome> ea = new NeatEvolutionAlgorithm <NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy);
// Create IBlackBox evaluator.
PreyCaptureEvaluator evaluator = new PreyCaptureEvaluator(_trialsPerEvaluation, _gridSize, _preyInitMoves, _preySpeed, _sensorRange, _maxTimesteps);
// Create genome decoder.
IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder();
// TODO: evaulation scheme that re-evaulates existing genomes and takes average over time.
// Create a genome list evaluator. This packages up the genome decoder with the genome evaluator.
IGenomeListEvaluator <NeatGenome> genomeListEvaluator = new ParallelGenomeListEvaluator <NeatGenome, IBlackBox>(genomeDecoder, evaluator, _parallelOptions);
// Initialize the evolution algorithm.
ea.Initialize(genomeListEvaluator, genomeFactory, genomeList);
// Finished. Return the evolution algorithm
return(ea);
}
public virtual void Initialize(string name, XmlElement xmlConfig)
{
_name = name;
_populationSize = XmlUtils.GetValueAsInt(xmlConfig, "PopulationSize");
_specieCount = XmlUtils.GetValueAsInt(xmlConfig, "SpecieCount");
_activationScheme = ExperimentUtils.CreateActivationScheme(xmlConfig, "Activation");
_complexityRegulationStr = XmlUtils.TryGetValueAsString(xmlConfig,
"DefaultComplexityRegulationStrategy");
_complexityThreshold = XmlUtils.TryGetValueAsInt(xmlConfig, "ComplexityThreshold");
_description = XmlUtils.TryGetValueAsString(xmlConfig, "Description");
_parallelOptions = ExperimentUtils.ReadParallelOptions(xmlConfig);
_eaParams = new NeatEvolutionAlgorithmParameters();
_eaParams.SpecieCount = _specieCount;
_neatGenomeParams = new NeatGenomeParameters();
_neatGenomeParams.FeedforwardOnly = _activationScheme.AcyclicNetwork;
DefaultComplexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(
_complexityRegulationStr,
_complexityThreshold);
DefaultSpeciationStrategy = new KMeansClusteringStrategy <NeatGenome>(new ManhattanDistanceMetric(1.0, 0.0, 10.0));
DefaultNeatEvolutionAlgorithm = new NeatEvolutionAlgorithm <NeatGenome>(
NeatEvolutionAlgorithmParameters,
DefaultSpeciationStrategy,
DefaultComplexityRegulationStrategy);
}
/// <summary>
/// Create and return a NeatEvolutionAlgorithm object ready for running the NEAT algorithm/search. Various sub-parts
/// of the algorithm are also constructed and connected up.
/// This overload accepts a pre-built genome2 population and their associated/parent genome2 factory.
/// </summary>
public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory <NeatGenome> genomeFactory, List <NeatGenome> genomeList)
{
// Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference.
IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
ISpeciationStrategy <NeatGenome> speciationStrategy = new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetric, _parallelOptions);
// Create complexity regulation strategy.
IComplexityRegulationStrategy complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold);
// Create the evolution algorithm.
NeatEvolutionAlgorithm <NeatGenome> ea = new NeatEvolutionAlgorithm <NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy);
// Create genome2 decoder.
IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = new NeatGenomeDecoder(_activationScheme);
// Create a genome2 list evaluator. This packages up the genome2 decoder with the genome2 evaluator.
IGenomeListEvaluator <NeatGenome> genomeListEvaluator = new ParallelGenomeListEvaluator <NeatGenome, IBlackBox>(genomeDecoder, PhenomeEvaluator, _parallelOptions);
//Using Serial Evaluator for easier debugging.
//IGenomeListEvaluator<NeatGenome> genomeListEvaluator = new SerialGenomeListEvaluator<NeatGenome, IBlackBox>(genomeDecoder, PhenomeEvaluator);
// Wrap the list evaluator in a 'selective' evaulator that will only evaluate new genomes. That is, we skip re-evaluating any genomes
// that were in the population in previous generations (elite genomes). This is determiend by examining each genome2's evaluation info object.
if (!EvaluateParents)
{
genomeListEvaluator = new SelectiveGenomeListEvaluator <NeatGenome>(genomeListEvaluator,
SelectiveGenomeListEvaluator <NeatGenome> .CreatePredicate_OnceOnly());
}
// Initialize the evolution algorithm.
ea.Initialize(genomeListEvaluator, genomeFactory, genomeList);
// Finished. Return the evolution algorithm
return(ea);
}
/// <summary>
/// Create and return a NeatEvolutionAlgorithm object ready for running the NEAT algorithm/search. Various sub-parts
/// of the algorithm are also constructed and connected up.
/// This overload accepts a pre-built genome population and their associated/parent genome factory.
/// </summary>
public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory <NeatGenome> genomeFactory, List <NeatGenome> genomeList)
{
// Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weight difference.
IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
ISpeciationStrategy <NeatGenome> speciationStrategy = new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetric, _parallelOptions);
// Create complexity regulation strategy.
IComplexityRegulationStrategy complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold);
// Create the evolution algorithm.
NeatEvolutionAlgorithm <NeatGenome> ea = new NeatEvolutionAlgorithm <NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy);
// Create IBlackBox evaluator.
WalkerBox2dEvaluator evaluator = new WalkerBox2dEvaluator();
// Create genome decoder.
IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder();
// Create a genome list evaluator. This packages up the genome decoder with the genome evaluator.
IGenomeListEvaluator <NeatGenome> innerEvaluator = new ParallelGenomeListEvaluator <NeatGenome, IBlackBox>(genomeDecoder, evaluator, _parallelOptions);
// Wrap the list evaluator in a 'selective' evaluator that will only evaluate new genomes. That is, we skip re-evaluating any genomes
// that were in the population in previous generations (elite genomes). This is determined by examining each genome's evaluation info object.
IGenomeListEvaluator <NeatGenome> selectiveEvaluator = new SelectiveGenomeListEvaluator <NeatGenome>(
innerEvaluator,
SelectiveGenomeListEvaluator <NeatGenome> .CreatePredicate_PeriodicReevaluation(5));
// Initialize the evolution algorithm.
ea.Initialize(selectiveEvaluator, genomeFactory, genomeList);
// Finished. Return the evolution algorithm
return(ea);
}
/// <summary>
/// Create and return a NeatEvolutionAlgorithm object ready for running the NEAT algorithm/search. Various sub-parts
/// of the algorithm are also constructed and connected up.
/// This overload accepts a pre-built genome population and their associated/parent genome factory.
/// </summary>
public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory <NeatGenome> genomeFactory, List <NeatGenome> genomeList)
{
// Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference.
IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
ISpeciationStrategy <NeatGenome> speciationStrategy = new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetric, _parallelOptions);
// Create complexity regulation strategy.
IComplexityRegulationStrategy complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold);
// Create the evolution algorithm.
NeatEvolutionAlgorithm <NeatGenome> ea = new NeatEvolutionAlgorithm <NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy);
// Create IBlackBox evaluator.
BoxesVisualDiscriminationEvaluator evaluator = new BoxesVisualDiscriminationEvaluator(_visualFieldResolution);
// Create genome decoder. Decodes to a neural network packaged with an activation scheme that defines a fixed number of activations per evaluation.
IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder(_visualFieldResolution, _lengthCppnInput);
// Create a genome list evaluator. This packages up the genome decoder with the genome evaluator.
//IGenomeListEvaluator<NeatGenome> innerEvaluator = new ParallelGenomeListEvaluator<NeatGenome, IBlackBox>(genomeDecoder, evaluator, _parallelOptions);
IGenomeListEvaluator <NeatGenome> innerEvaluator = new SerialGenomeListEvaluator <NeatGenome, IBlackBox>(genomeDecoder, evaluator);
// Wrap the list evaluator in a 'selective' evaulator that will only evaluate new genomes. That is, we skip re-evaluating any genomes
// that were in the population in previous generations (elite genomes). This is determiend by examining each genome's evaluation info object.
IGenomeListEvaluator <NeatGenome> selectiveEvaluator = new SelectiveGenomeListEvaluator <NeatGenome>(
innerEvaluator,
SelectiveGenomeListEvaluator <NeatGenome> .CreatePredicate_OnceOnly());
// Initialize the evolution algorithm.
ea.Initialize(selectiveEvaluator, genomeFactory, genomeList);
// Finished. Return the evolution algorithm
return(ea);
}
/// <summary>
/// Create and return a NeatEvolutionAlgorithm object ready for running the NEAT algorithm/search. Various sub-parts
/// of the algorithm are also constructed and connected up.
/// This overload accepts a pre-built genome2 population and their associated/parent genome2 factory.
/// </summary>
public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory <NeatGenome> genomeFactory, List <NeatGenome> genomeList)
{
// Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference.
IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
ISpeciationStrategy <NeatGenome> speciationStrategy = new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetric, _parallelOptions);
// Create complexity regulation strategy.
IComplexityRegulationStrategy complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold);
// Create the evolution algorithm.
NeatEvolutionAlgorithm <NeatGenome> ea = new NeatEvolutionAlgorithm <NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy);
// Create genome decoder.
IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder();
// Create a genome list evaluator. This packages up the genome decoder with the phenome evaluator.
IGenomeListEvaluator <NeatGenome> genomeListEvaluator = new ParallelCoevolutionListEvaluator <NeatGenome, IBlackBox>(genomeDecoder, PhenomeEvaluator);
// Wrap a hall of fame evaluator around the baseline evaluator.
genomeListEvaluator = new ParallelHallOfFameListEvaluator <NeatGenome, IBlackBox>(50, 0.5, ea, genomeListEvaluator, genomeDecoder, PhenomeEvaluator);
// Initialize the evolution algorithm.
ea.Initialize(genomeListEvaluator, genomeFactory, genomeList);
// Finished. Return the evolution algorithm
return(ea);
}
/// <summary>
/// Create and return a NeatEvolutionAlgorithm list ready for running the NEAT algorithm/search. Various sub-parts
/// of the algorithm are also constructed and connected up.
/// </summary>
public ModuleNeatEvolutionAlgorithm <NeatGenome>[] CreateEvolutionAlgorithms(int populationSize)
{
// Create the modules.
List <Module> modules = new List <Module>();
for (int i = 0; i < _moduleCount; i++)
{
// Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference.
IDistanceMetric distanceMetricPitch = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
ISpeciationStrategy <NeatGenome> speciationStrategyPitch = new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetricPitch, _parallelOptions);
IDistanceMetric distanceMetricRhythm = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
ISpeciationStrategy <NeatGenome> speciationStrategyRhythm = new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetricRhythm, _parallelOptions);
// Create complexity regulation strategy.
IComplexityRegulationStrategy complexityRegulationPitch =
ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold);
IComplexityRegulationStrategy complexityRegulationRhythm =
ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold);
// Create and add a new module with strategies and the evolution parameters.
Module module = new Module((i + 1), _eaParams,
speciationStrategyPitch, speciationStrategyRhythm,
complexityRegulationPitch, complexityRegulationRhythm);
modules.Add(module);
}
// Hook-up the modules with each other in circular order.
// TODO Right now, they are hooked-up in circular order. Check whether it should be done otherwise.
//for (int i = 0; i < modules.Count; i++)
//{
// modules[i].SetParasiteModule(i != modules.Count - 1 ? modules[i + 1] : modules[0], _parasiteCount,
// _championCount, CreateGenomeDecoder());
//}
foreach (var module in modules)
{
module.SetParasiteModules(modules.Except(new List <Module>()
{
module
}).ToList(), _parasiteCount, _championCount, CreateGenomeDecoder(), CreateGenomeDecoder());
}
// Initialize each module.
foreach (var module in modules)
{
var rhythmFactory = CreateGenomeFactory();
var pitchFactory = CreateGenomeFactory();
module.Initialize(rhythmFactory, pitchFactory, populationSize);
}
// Finished. Return the evolution algorithms
return
(modules.Select(m => m.RhythmEvolutionAlgorithm).Concat(modules.Select(m => m.PitchEvolutionAlgorithm)).ToArray());
}
private NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm_private(IGenomeFactory <NeatGenome> genomeFactory, List <NeatGenome> genomeList, HyperNEAT_Args args = null)
{
// Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference.
IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1, 0, 10);
ISpeciationStrategy <NeatGenome> speciationStrategy = new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetric, _parallelOptions);
// Create complexity regulation strategy.
IComplexityRegulationStrategy complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold);
// Create the evolution algorithm.
NeatEvolutionAlgorithm <NeatGenome> retVal = new NeatEvolutionAlgorithm <NeatGenome>(NeatEvolutionAlgorithmParameters, speciationStrategy, complexityRegulationStrategy);
// Genome Decoder
IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = null;
if (args == null)
{
genomeDecoder = CreateGenomeDecoder();
}
else
{
genomeDecoder = CreateGenomeDecoder(args);
}
// Create a genome list evaluator. This packages up the genome decoder with the genome evaluator.
IGenomeListEvaluator <NeatGenome> genomeEvaluator = null;
if (_phenomeEvaluator != null)
{
IGenomeListEvaluator <NeatGenome> innerEvaluator = new ParallelGenomeListEvaluator <NeatGenome, IBlackBox>(genomeDecoder, _phenomeEvaluator, _parallelOptions);
// Wrap the list evaluator in a 'selective' evaluator that will only evaluate new genomes. That is, we skip re-evaluating any genomes
// that were in the population in previous generations (elite genomes). This is determined by examining each genome's evaluation info object.
genomeEvaluator = new SelectiveGenomeListEvaluator <NeatGenome>(
innerEvaluator,
SelectiveGenomeListEvaluator <NeatGenome> .CreatePredicate_OnceOnly());
}
else if (_phenomeEvaluators != null)
{
// Use the multi tick evaluator
genomeEvaluator = new TickGenomeListEvaluator <NeatGenome, IBlackBox>(genomeDecoder, _phenomeEvaluators, _phenometickeval_roundRobinManager, _phenometickeval_worldTick);
}
else
{
throw new ApplicationException("One of the phenome evaluators needs to be populated");
}
// Initialize the evolution algorithm.
retVal.Initialize(genomeEvaluator, genomeFactory, genomeList);
// Finished. Return the evolution algorithm
return(retVal);
}
/// <summary>
/// Create and return a NeatEvolutionAlgorithm object ready for running the NEAT algorithm/search. Various sub-parts
/// of the algorithm are also constructed and connected up.
/// This overload accepts a pre-built genome population and their associated/parent genome factory.
/// </summary>
public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory <NeatGenome> genomeFactory, List <NeatGenome> genomeList)
{
// Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference.
IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
ISpeciationStrategy <NeatGenome> speciationStrategy = new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetric, _parallelOptions);
// Create complexity regulation strategy.
IComplexityRegulationStrategy complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold);
// Create the evolution algorithm.
NeatEvolutionAlgorithm <NeatGenome> ea = new NeatEvolutionAlgorithm <NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy);
// Create IBlackBox evaluator.
DoublePoleBalancingEvaluator evaluator;
switch (_variantStr)
{
case "DoublePole":
evaluator = new DoublePoleBalancingEvaluator();
break;
case "DoublePoleNv":
evaluator = new DoublePoleBalancingEvaluatorNv();
break;
case "DoublePoleNvAntiWiggle":
evaluator = new DoublePoleBalancingEvaluatorNvAntiWiggle();
break;
default:
throw new SharpNeatException(string.Format("DoublePoleBalancing experiment config XML specifies unknown variant [{0}]", _variantStr));
}
// Create genome decoder.
IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder();
// Create a genome list evaluator. This packages up the genome decoder with the genome evaluator.
IGenomeListEvaluator <NeatGenome> innerEvaluator = new ParallelGenomeListEvaluator <NeatGenome, IBlackBox>(genomeDecoder, evaluator, _parallelOptions);
// Wrap the list evaluator in a 'selective' evaulator that will only evaluate new genomes. That is, we skip re-evaluating any genomes
// that were in the population in previous generations (elite genomes). This is determiend by examining each genome's evaluation info object.
IGenomeListEvaluator <NeatGenome> selectiveEvaluator = new SelectiveGenomeListEvaluator <NeatGenome>(
innerEvaluator,
SelectiveGenomeListEvaluator <NeatGenome> .CreatePredicate_OnceOnly());
// Initialize the evolution algorithm.
ea.Initialize(selectiveEvaluator, genomeFactory, genomeList);
// Finished. Return the evolution algorithm
return(ea);
}
public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory <NeatGenome> genomeFactory, List <NeatGenome> genomeList)
{
IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
ISpeciationStrategy <NeatGenome> speciationStrategy = new KMeansClusteringStrategy <NeatGenome>(distanceMetric);
IComplexityRegulationStrategy complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold);
BraidNeatEvolutionAlgorithm <NeatGenome> ea = new BraidNeatEvolutionAlgorithm <NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy);
// Create black box evaluator
BraidEvaluator evaluator = new BraidEvaluator(m_optimizer);
IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder();
IGenomeListEvaluator <NeatGenome> innerEvaluator = new BraidListEvaluator <NeatGenome, IBlackBox>(genomeDecoder, evaluator, m_optimizer);
ea.Initialize(innerEvaluator, genomeFactory, genomeList);
return(ea);
}
/// <summary>
/// Configures and instantiates the initialization evolutionary algorithm.
/// </summary>
/// <param name="parallelOptions">Synchronous/Asynchronous execution settings.</param>
/// <param name="genomeList">The initial population of genomes.</param>
/// <param name="genomeDecoder">The decoder to translate genomes into phenotypes.</param>
/// <param name="startingEvaluations">
/// The number of evaluations that preceeded this from which this process will pick up
/// (this is used in the case where we're restarting a run because it failed to find a solution in the allotted time).
/// </param>
protected void InitializeAlgorithm(ParallelOptions parallelOptions, List <NeatGenome> genomeList,
IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder, ulong startingEvaluations)
{
ParallelOptions = parallelOptions;
InitialPopulation = genomeList;
StartingEvaluations = startingEvaluations;
GenomeDecoder = genomeDecoder;
// Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference.
IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
SpeciationStrategy = new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetric, parallelOptions);
// Create complexity regulation strategy.
ComplexityRegulationStrategy =
ExperimentUtils.CreateComplexityRegulationStrategy(ComplexityRegulationStrategyDefinition,
ComplexityThreshold);
}
/// <summary>
/// Create and return a NeatEvolutionAlgorithm object ready for running the NEAT algorithm/search. Various sub-parts
/// of the algorithm are also constructed and connected up.
/// This overload accepts a pre-built genome2 population and their associated/parent genome2 factory.
/// </summary>
public NeatEvolutionAlgorithm <NeatGenome>[] CreateEvolutionAlgorithms(IGenomeFactory <NeatGenome> genomeFactory1, List <NeatGenome> genomeList1,
IGenomeFactory <NeatGenome> genomeFactory2, List <NeatGenome> genomeList2)
{
// Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference.
IDistanceMetric distanceMetric1 = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
ISpeciationStrategy <NeatGenome> speciationStrategy1 = new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetric1, _parallelOptions);
// Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference.
IDistanceMetric distanceMetric2 = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
ISpeciationStrategy <NeatGenome> speciationStrategy2 = new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetric2, _parallelOptions);
// Create complexity regulation strategy.
IComplexityRegulationStrategy complexityRegulationStrategy1 = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold);
// Create complexity regulation strategy.
IComplexityRegulationStrategy complexityRegulationStrategy2 = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold);
// Create the evolution algorithm.
NeatEvolutionAlgorithm <NeatGenome> ea1 = new NeatEvolutionAlgorithm <NeatGenome>(_eaParams, speciationStrategy1, complexityRegulationStrategy1);
NeatEvolutionAlgorithm <NeatGenome> ea2 = new NeatEvolutionAlgorithm <NeatGenome>(_eaParams, speciationStrategy2, complexityRegulationStrategy2);
// Create genome decoder.
IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder1 = CreateGenomeDecoder();
IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder2 = CreateGenomeDecoder();
// Create phenome evaluators. Note we are evolving one population of X players and one of O players.
ICoevolutionPhenomeEvaluator <IBlackBox> phenomeEvaluator1 = new TicTacToeHostParasiteEvaluator(SquareTypes.X);
ICoevolutionPhenomeEvaluator <IBlackBox> phenomeEvaluator2 = new TicTacToeHostParasiteEvaluator(SquareTypes.O);
// Create a genome list evaluator. This packages up the genome decoder with the phenome evaluator.
HostParasiteCoevolutionListEvaluator <NeatGenome, IBlackBox> genomeListEvaluator1 = new HostParasiteCoevolutionListEvaluator <NeatGenome, IBlackBox>(_parasiteCount, _championCount, ea2, genomeDecoder1, phenomeEvaluator1);
HostParasiteCoevolutionListEvaluator <NeatGenome, IBlackBox> genomeListEvaluator2 = new HostParasiteCoevolutionListEvaluator <NeatGenome, IBlackBox>(_parasiteCount, _championCount, ea1, genomeDecoder2, phenomeEvaluator2);
// Initialize the evolution algorithms.
ea1.Initialize(genomeListEvaluator1, genomeFactory1, genomeList1);
ea2.Initialize(genomeListEvaluator2, genomeFactory2, genomeList2);
// Set the evolution algorithms to update every generation.
ea1.UpdateScheme = new UpdateScheme(1);
ea2.UpdateScheme = new UpdateScheme(1);
// Finished. Return the evolution algorithms
return(new [] { ea1, ea2 });
}
/// <summary>
/// Create and return a NeatEvolutionAlgorithm object ready for running the NEAT algorithm/search. Various sub-parts
/// of the algorithm are also constructed and connected up.
/// This overload accepts a pre-built genome2 population and their associated/parent genome2 factory.
/// </summary>
public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory <NeatGenome> genomeFactory, List <NeatGenome> genomeList)
{
// Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference.
IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
ISpeciationStrategy <NeatGenome> speciationStrategy = new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetric, new ParallelOptions());
// Create complexity regulation strategy.
IComplexityRegulationStrategy complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold);
// Create the evolution algorithm.
NeatEvolutionAlgorithm <NeatGenome> ea = new NeatEvolutionAlgorithm <NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy);
// Create genome decoder.
IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder();
// Finished. Return the evolution algorithm
return(ea);
}
/*
* List<NeatGenome> CreateNewGenome(IGenomeFactory<NeatGenome> genomeFactory)
* {
* Console.WriteLine("Saved genome not found, creating new files.");
* return genomeFactory.CreateGenomeList(_populationSize, 0);
* }
*/
/// <summary>
/// Creates and returns a NeatEvolutionAlgorithm object ready for running
/// the NEAT algorithm/search. Various sub-parts of the algorithm are also
/// constructed and connected up. This overload accepts a pre-built genome2
/// population and their associated/parent genome2 factory.
/// </summary>
public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(
IGenomeFactory <NeatGenome> genomeFactory, List <NeatGenome> genomeList)
{
// Creates distance metric. Mismatched genes have a fixed distance of 10;
// for matched genes the distance is their weigth difference.
IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
//ISpeciationStrategy<NeatGenome> speciationStrategy = new KMeansClusteringStrategy<NeatGenome>(distanceMetric);
ISpeciationStrategy <NeatGenome> speciationStrategy = new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetric, _parallelOptions);
IComplexityRegulationStrategy complexityRegulationStrategy =
ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold);
// Creates the evolution algorithm.
NeatEvolutionAlgorithm <NeatGenome> evolAlgorithm = new NeatEvolutionAlgorithm <NeatGenome>(
_eaParams, speciationStrategy, complexityRegulationStrategy, userName);
IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = new NeatGenomeDecoder(_activationScheme);
// Creates a genome2 list evaluator. This packages up the genome2 decoder with the genome2 evaluator.
IGenomeListEvaluator <NeatGenome> genomeListEvaluator =
new ParallelGenomeListEvaluator <NeatGenome, IBlackBox>(genomeDecoder, PhenomeEvaluator, _parallelOptions);
//To use single-thread evaluator:
//IGenomeListEvaluator<NeatGenome> genomeListEvaluator =
// new SerialGenomeListEvaluator<NeatGenome, IBlackBox>(genomeDecoder, PhenomeEvaluator, false);
// Wraps the list evaluator in a 'selective' evaulator that will only
// evaluate new genomes. That is, we skip re-evaluating any genomes
// that were in the population in previous generations (elite genomes).
// This is determiend by examining each genome's evaluation info object.
/*
* int reevaluationPeriod = 1;
* genomeListEvaluator = new SelectiveGenomeListEvaluator<NeatGenome>(
* genomeListEvaluator,
* SelectiveGenomeListEvaluator<NeatGenome>.CreatePredicate_PeriodicReevaluation(reevaluationPeriod));
*/
genomeListEvaluator = new SelectiveGenomeListEvaluator <NeatGenome>(
genomeListEvaluator,
SelectiveGenomeListEvaluator <NeatGenome> .CreatePredicate_OnceOnly());
// Initializes the evolution algorithm.
evolAlgorithm.Initialize(genomeListEvaluator, genomeFactory, genomeList);
// Finished. Return the evolution algorithm
return(evolAlgorithm);
}
/// <summary>
/// Create and return a NeatEvolutionAlgorithm object ready for running the NEAT algorithm/search. Various sub-parts
/// of the algorithm are also constructed and connected up.
/// This overload accepts a pre-built genome population and their associated/parent genome factory.
/// </summary>
public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory <NeatGenome> genomeFactory, List <NeatGenome> genomeList)
{
Debug.Log("........CreateEvolutionAlgorithm: Setting parameters");
// Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference.
IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
ISpeciationStrategy <NeatGenome> speciationStrategy = new KMeansClusteringStrategy <NeatGenome>(distanceMetric);
// Create complexity regulation strategy.
IComplexityRegulationStrategy complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold);
Debug.Log("........CreateEvolutionAlgorithm: Creating ea");
// Create the evolution algorithm.
NeatEvolutionAlgorithm <NeatGenome> ea = new NeatEvolutionAlgorithm <NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy);
Debug.Log("........CreateEvolutionAlgorithm: Creating evaluator");
// Create IBlackBox evaluator.
CPPNRepairEvaluator2 evaluator = new CPPNRepairEvaluator2(this);
evaluator.SetOriginalFeatures(_originalFeatures);
Debug.Log("........CreateEvolutionAlgorithm: Creating genome decoder and serial evaluator");
// Create genome decoder.
IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder();
// Create a genome list evaluator. This packages up the genome decoder with the genome evaluator.
IGenomeListEvaluator <NeatGenome> innerEvaluator = new SerialGenomeListEvaluator <NeatGenome, IBlackBox>(genomeDecoder, evaluator);
// Wrap the list evaluator in a 'selective' evaulator that will only evaluate new genomes. That is, we skip re-evaluating any genomes
// that were in the population in previous generations (elite genomes). This is determiend by examining each genome's evaluation info object.
/*IGenomeListEvaluator<NeatGenome> selectiveEvaluator = new SelectiveGenomeListEvaluator<NeatGenome>(
* innerEvaluator,
* SelectiveGenomeListEvaluator<NeatGenome>.CreatePredicate_OnceOnly());
*/
// Initialize the evolution algorithm.
Debug.Log("........CreateEvolutionAlgorithm: Initializing ea");
ea.Initialize(innerEvaluator, genomeFactory, genomeList);
Debug.Log("........CreateEvolutionAlgorithm: Returning");
// Finished. Return the evolution algorithm
return(ea);
}
public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory <NeatGenome> genomeFactory, List <NeatGenome> genomeList)
{
// Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference.
IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
ISpeciationStrategy <NeatGenome> speciationStrategy =
new KMeansClusteringStrategy <NeatGenome>(distanceMetric);
// Create complexity regulation strategy.
IComplexityRegulationStrategy complexityRegulationStrategy =
ExperimentUtils.CreateComplexityRegulationStrategy("absolute", 10);
// Create the evolution algorithm.
var ea = new NeatEvolutionAlgorithm <NeatGenome>(
NeatEvolutionAlgorithmParameters,
speciationStrategy,
complexityRegulationStrategy);
// Create IBlackBox evaluator.
// var evaluator = new RemoteXorEvaluator();
var evaluator = new RemoteBatchXorEvaluator();
//LocalXorEvaluator evaluator = new LocalXorEvaluator();
// Create genome decoder.
IGenomeDecoder <NeatGenome, FastCyclicNetwork> genomeDecoder = _decoder;
// Create a genome list evaluator. This packages up the genome decoder with the genome evaluator.
IGenomeListEvaluator <NeatGenome> innerEvaluator = new BatchGenomeListEvaluator <NeatGenome, FastCyclicNetwork>(genomeDecoder, evaluator);
// Wrap the list evaluator in a 'selective' evaulator that will only evaluate new genomes. That is, we skip re-evaluating any genomes
// that were in the population in previous generations (elite genomes). This is determined by examining each genome's evaluation info object.
IGenomeListEvaluator <NeatGenome> selectiveEvaluator = new SelectiveGenomeListEvaluator <NeatGenome>(
innerEvaluator,
SelectiveGenomeListEvaluator <NeatGenome> .CreatePredicate_OnceOnly());
// Initialize the evolution algorithm.
ea.Initialize(selectiveEvaluator, genomeFactory, genomeList);
// Finished. Return the evolution algorithm
return(ea);
}
private void GetComplexityRegulationStrategy()
{
_ComplexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(_ComplexityRegulationStr, _ComplexityThreshold);
}
/// <summary>
/// Initialize the experiment with some optional XML configutation data.
/// </summary>
public virtual void Initialize(string name, XmlElement xmlConfig)
{
_name = name;
_description = XmlUtils.TryGetValueAsString(xmlConfig, "Description") ?? "";
_comment = XmlUtils.TryGetValueAsString(xmlConfig, "Comment") ?? "";
_populationSize = XmlUtils.TryGetValueAsInt(xmlConfig, "PopulationSize") ?? 100;
_maxGenerations = XmlUtils.TryGetValueAsInt(xmlConfig, "MaxGenerations") ?? 1000;
_activationScheme = ExperimentUtils.CreateActivationScheme(xmlConfig, "Activation");
SeedGenome = XmlUtils.TryGetValueAsString(xmlConfig, "SeedGenome");
try
{
_complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(xmlConfig, "ComplexityRegulation");
}
catch (ArgumentException e)
{
_logger.Warn(e.Message);
}
_parallelOptions = ExperimentUtils.ReadParallelOptions(xmlConfig);
_multiThreading = XmlUtils.TryGetValueAsBool(xmlConfig, "MultiThreading") ?? true;
_logInterval = XmlUtils.TryGetValueAsInt(xmlConfig, "LogInterval") ?? 10;
// Evolutionary algorithm parameters
_eaParams = new NeatEvolutionAlgorithmParameters();
XmlElement xmlEAParams = xmlConfig.SelectSingleNode("EAParams") as XmlElement;
if (xmlEAParams != null)
{
_eaParams.SpecieCount = XmlUtils.GetValueAsInt(xmlEAParams, "SpecieCount");
_eaParams.ElitismProportion = XmlUtils.GetValueAsDouble(xmlEAParams, "ElitismProportion");
_eaParams.SelectionProportion = XmlUtils.GetValueAsDouble(xmlEAParams, "SelectionProportion");
_eaParams.OffspringAsexualProportion = XmlUtils.GetValueAsDouble(xmlEAParams, "OffspringAsexualProportion");
_eaParams.OffspringSexualProportion = XmlUtils.GetValueAsDouble(xmlEAParams, "OffspringSexualProportion");
_eaParams.InterspeciesMatingProportion = XmlUtils.GetValueAsDouble(xmlEAParams, "InterspeciesMatingProportion");
}
else
{
_logger.Info("EA parameters not found. Using default.");
}
// NEAT Genome parameters
_neatGenomeParams = new NeatGenomeParameters();
// Prevent recurrent connections if the activation scheme is acyclic
_neatGenomeParams.FeedforwardOnly = _activationScheme.AcyclicNetwork;
XmlElement xmlGenomeParams = xmlConfig.SelectSingleNode("GenomeParams") as XmlElement;
if (xmlGenomeParams != null)
{
_neatGenomeParams.ConnectionWeightRange = XmlUtils.GetValueAsDouble(xmlGenomeParams, "ConnectionWeightRange");
_neatGenomeParams.InitialInterconnectionsProportion = XmlUtils.GetValueAsDouble(xmlGenomeParams, "InitialInterconnectionsProportion");
_neatGenomeParams.DisjointExcessGenesRecombinedProbability = XmlUtils.GetValueAsDouble(xmlGenomeParams, "DisjointExcessGenesRecombinedProbability");
_neatGenomeParams.ConnectionWeightMutationProbability = XmlUtils.GetValueAsDouble(xmlGenomeParams, "ConnectionWeightMutationProbability");
_neatGenomeParams.AddNodeMutationProbability = XmlUtils.GetValueAsDouble(xmlGenomeParams, "AddNodeMutationProbability");
_neatGenomeParams.AddConnectionMutationProbability = XmlUtils.GetValueAsDouble(xmlGenomeParams, "AddConnectionMutationProbability");
_neatGenomeParams.DeleteConnectionMutationProbability = XmlUtils.GetValueAsDouble(xmlGenomeParams, "DeleteConnectionMutationProbability");
}
else
{
_logger.Info("Genome parameters not found. Using default.");
}
XmlElement xmlNoveltySearchParams = xmlConfig.SelectSingleNode("NoveltySearch") as XmlElement;
if (xmlNoveltySearchParams != null)
{
_noveltySearchParams = NoveltySearchParameters.ReadXmlProperties(xmlNoveltySearchParams);
}
else
{
_logger.Info("Novelty search parameters not found");
}
XmlElement xmlMultiObjectiveParams = xmlConfig.SelectSingleNode("MultiObjective") as XmlElement;
if (xmlMultiObjectiveParams != null)
{
_multiObjectiveParams = MultiObjectiveParameters.ReadXmlProperties(xmlMultiObjectiveParams);
}
else
{
_logger.Info("Multi objective parameters not found");
}
// Create IBlackBox evaluator.
_evaluator = new TEvaluator();
_evaluator.Initialize(xmlConfig);
_evaluator.NoveltySearchParameters = _noveltySearchParams;
}
