/// <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.
PreyCaptureEvaluator evaluator = new PreyCaptureEvaluator(_trialsPerEvaluation, _gridSize, _preyInitMoves, _preySpeed, _sensorRange, _maxTimesteps);
// Create genome decoder.
IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder();
// TODO: evaluation scheme that re-evaluates 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);
}
/// <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.
_evaluator = CreateEvaluator();
// 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);
/*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 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);
}
/// <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 GenerationalNeatEvolutionAlgorithm object (specific to fitness-based evaluations) ready for running the
/// NEAT algorithm/search based on the given genome factory and genome list. Various sub-parts of the algorithm are
/// also constructed and connected up.
/// </summary>
/// <param name="genomeFactory">The genome factory from which to generate new genomes</param>
/// <param name="genomeList">The current genome population</param>
/// <returns>Constructed evolutionary algorithm</returns>
public override INeatEvolutionAlgorithm<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.
var complexityRegulationStrategy =
ExperimentUtils.CreateComplexityRegulationStrategy(ComplexityRegulationStrategy, Complexitythreshold);
// Create the evolution algorithm.
var ea = new GenerationalNeatEvolutionAlgorithm<NeatGenome>(NeatEvolutionAlgorithmParameters, speciationStrategy,
complexityRegulationStrategy);
// Create IBlackBox evaluator.
var mazeNavigationEvaluator = new MazeNavigationFitnessEvaluator(MaxDistanceToTarget, MaxTimesteps, MazeVariant,
MinSuccessDistance);
// Create genome decoder.
var genomeDecoder = CreateGenomeDecoder();
// Create a genome list evaluator. This packages up the genome decoder with the genome evaluator.
IGenomeEvaluator<NeatGenome> fitnessEvaluator =
new ParallelGenomeFitnessEvaluator<NeatGenome, IBlackBox>(genomeDecoder, mazeNavigationEvaluator,
ParallelOptions);
// Initialize the evolution algorithm.
ea.Initialize(fitnessEvaluator, genomeFactory, genomeList);
// Finished. Return the evolution algorithm
return ea;
}
NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(bool load)
{
// Create a genome2 factory with our neat genome2 parameters object and the appropriate number of input and output neuron genes.
var genomeFactory = new NeatGenomeFactory(TetrisEvaluator.NumInputs, TetrisEvaluator.NumOutputs);
// Create an initial population of randomly generated genomes.
List <NeatGenome> genomeList = null;
if (load)
{
try
{
using (var reader = XmlReader.Create("SavedProgress.xml"))
genomeList = NeatGenomeXmlIO.ReadCompleteGenomeList(reader, true, genomeFactory);
Console.WriteLine("Loaded network!");
}
catch
{
load = false;
}
}
if (!load)
{
genomeList = genomeFactory.CreateGenomeList(150, 0);
}
var parallelOpts = new ParallelOptions()
{
MaxDegreeOfParallelism = -1
};
// Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference.
var distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
var speciationStrategy = new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetric, parallelOpts);
// Create the evolution algorithm.
var ea = new NeatEvolutionAlgorithm <NeatGenome>(new NeatEvolutionAlgorithmParameters {
SpecieCount = 10
}, speciationStrategy, new DefaultComplexityRegulationStrategy(ComplexityCeilingType.Absolute, 50));
// Create genome2 decoder.
var genomeDecoder = new NeatGenomeDecoder(NetworkActivationScheme.CreateCyclicFixedTimestepsScheme(2));
// Create a genome2 list evaluator. This packages up the genome2 decoder with the genome2 evaluator.
IGenomeListEvaluator <NeatGenome> genomeListEvaluator = new ParallelGenomeListEvaluator <NeatGenome, IBlackBox>(genomeDecoder, tetrisEvaluator, parallelOpts);
// 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());
ea.UpdateEvent += Ea_UpdateEvent;
// Initialize the evolution algorithm.
ea.Initialize(genomeListEvaluator, genomeFactory, genomeList);
// Finished. Return the evolution algorithm
return(ea);
}
/// <summary>
/// Create and return a SteadyStateNeatEvolutionAlgorithm object (specific to fitness-based evaluations) ready for
/// running the
/// NEAT algorithm/search based on the given genome factory and genome list. Various sub-parts of the algorithm are
/// also constructed and connected up.
/// </summary>
/// <param name="genomeFactory">The genome factory from which to generate new genomes</param>
/// <param name="genomeList">The current genome population</param>
/// <param name="startingEvaluations">The number of evaluations that have been executed prior to the current run.</param>
/// <returns>Constructed evolutionary algorithm</returns>
public override INeatEvolutionAlgorithm<NeatGenome> CreateEvolutionAlgorithm(
IGenomeFactory<NeatGenome> genomeFactory,
List<NeatGenome> genomeList, ulong startingEvaluations)
{
FileDataLogger logger = 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, 0.0, 10.0);
ISpeciationStrategy<NeatGenome> speciationStrategy =
new ParallelKMeansClusteringStrategy<NeatGenome>(distanceMetric, ParallelOptions);
// Create complexity regulation strategy.
var complexityRegulationStrategy =
ExperimentUtils.CreateComplexityRegulationStrategy(ComplexityRegulationStrategy, Complexitythreshold);
// Initialize the logger
if (_generationalLogFile != null)
{
logger =
new FileDataLogger(_generationalLogFile);
}
// Create the evolution algorithm.
var ea = new SteadyStateNeatEvolutionAlgorithm<NeatGenome>(NeatEvolutionAlgorithmParameters,
speciationStrategy, complexityRegulationStrategy, _batchSize, _populationEvaluationFrequency,
RunPhase.Primary, logger);
// Create IBlackBox evaluator.
var mazeNavigationEvaluator = new MazeNavigationMCNSEvaluator(MaxDistanceToTarget, MaxTimesteps,
MazeVariant,
MinSuccessDistance, _behaviorCharacterizationFactory);
// Create genome decoder.
var genomeDecoder = CreateGenomeDecoder();
// Create a novelty archive.
AbstractNoveltyArchive<NeatGenome> archive =
new BehavioralNoveltyArchive<NeatGenome>(_archiveAdditionThreshold,
_archiveThresholdDecreaseMultiplier, _archiveThresholdIncreaseMultiplier,
_maxGenerationArchiveAddition, _maxGenerationsWithoutArchiveAddition);
// IGenomeEvaluator<NeatGenome> fitnessEvaluator =
// new SerialGenomeBehaviorEvaluator<NeatGenome, IBlackBox>(genomeDecoder, mazeNavigationEvaluator,
// _nearestNeighbors, archive);
IGenomeEvaluator<NeatGenome> fitnessEvaluator =
new ParallelGenomeBehaviorEvaluator<NeatGenome, IBlackBox>(genomeDecoder, mazeNavigationEvaluator,
SelectionType.SteadyState,
SearchType.MinimalCriteriaNoveltySearch,
_nearestNeighbors, archive);
// Initialize the evolution algorithm.
ea.Initialize(fitnessEvaluator, genomeFactory, genomeList, 0, MaxEvaluations, archive);
// 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> GenerateTeam()
{
NeatEvolutionAlgorithmParameters neatParams = new NeatEvolutionAlgorithmParameters();
IDistanceMetric distanceMetric = new ManhattanDistanceMetric(0.4, 1.0, 0.0);
ISpeciationStrategy <NeatGenome> speciationStrategy = new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetric);
IComplexityRegulationStrategy complexityStrategy = new NullComplexityRegulationStrategy();
return(new NeatEvolutionAlgorithm <NeatGenome>(neatParams, speciationStrategy, complexityStrategy));
}
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, IGenomeListEvaluator <NeatGenome> eval = 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, 0.0, 10.0);
ISpeciationStrategy <NeatGenome> speciationStrategy = new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetric, _parallelOptions);
// Create complexity regulation strategy.
IComplexityRegulationStrategy complexityRegulationStrategy = new NullComplexityRegulationStrategy();// ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold);
// Create the evolution algorithm.
NeatEvolutionAlgorithm <NeatGenome> ea = new NeatEvolutionAlgorithm <NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy);
// Create the MC evaluator
PasswordCrackingEvaluator.Passwords = _passwords;
// Create genome decoder.
IGenomeDecoder <NeatGenome, MarkovChain> genomeDecoder = CreateGenomeDecoder();
// If we're running specially on Condor, skip this
if (eval == null)
{
_evaluator = new PasswordCrackingEvaluator(_guesses, Hashed);
// Create a genome list evaluator. This packages up the genome decoder with the genome evaluator.
// IGenomeListEvaluator<NeatGenome> innerEvaluator = new ParallelGenomeListEvaluator<NeatGenome, MarkovChain>(genomeDecoder, _evaluator, _parallelOptions);
IGenomeListEvaluator <NeatGenome> innerEvaluator = new ParallelNEATGenomeListEvaluator <NeatGenome, MarkovChain>(genomeDecoder, _evaluator, this);
/*
* // 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(innerEvaluator, genomeFactory, genomeList);
}
else
{
// Initialize the evolution algorithm.
ea.Initialize(eval, genomeFactory, genomeList);
}
// Finished. Return the evolution algorithm
return(ea);
}
/// <summary>
/// Create and return a GenerationalNeatEvolutionAlgorithm object (specific to fitness-based evaluations) ready for
/// running the
/// NEAT algorithm/search based on the given genome factory and genome list. Various sub-parts of the algorithm are
/// also constructed and connected up.
/// </summary>
/// <param name="genomeFactory">The genome factory from which to generate new genomes</param>
/// <param name="genomeList">The current genome population</param>
/// <param name="startingEvaluations">The number of evaluations that have been executed prior to the current run.</param>
/// <returns>Constructed evolutionary algorithm</returns>
public override INeatEvolutionAlgorithm<NeatGenome> CreateEvolutionAlgorithm(
IGenomeFactory<NeatGenome> genomeFactory,
List<NeatGenome> genomeList, ulong startingEvaluations)
{
// 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.
var complexityRegulationStrategy =
ExperimentUtils.CreateComplexityRegulationStrategy(ComplexityRegulationStrategy, Complexitythreshold);
// Create the evolution algorithm.
var ea = new GenerationalNeatEvolutionAlgorithm<NeatGenome>(NeatEvolutionAlgorithmParameters,
speciationStrategy,
complexityRegulationStrategy);
// Create IBlackBox evaluator.
var mazeNavigationEvaluator = new MazeNavigationNoveltyEvaluator(MaxDistanceToTarget, MaxTimesteps,
MazeVariant,
MinSuccessDistance, _behaviorCharacterizationFactory);
// Create genome decoder.
var genomeDecoder = CreateGenomeDecoder();
// Create a novelty archive.
AbstractNoveltyArchive<NeatGenome> archive =
new BehavioralNoveltyArchive<NeatGenome>(_archiveAdditionThreshold,
_archiveThresholdDecreaseMultiplier, _archiveThresholdIncreaseMultiplier,
_maxGenerationArchiveAddition, _maxGenerationsWithoutArchiveAddition);
// Create a genome list evaluator. This packages up the genome decoder with the genome evaluator.
// IGenomeFitnessEvaluator<NeatGenome> fitnessEvaluator =
// new SerialGenomeBehaviorEvaluator<NeatGenome, IBlackBox>(genomeDecoder, mazeNavigationEvaluator, _nearestNeighbors, archive);
IGenomeEvaluator<NeatGenome> fitnessEvaluator =
new ParallelGenomeBehaviorEvaluator<NeatGenome, IBlackBox>(genomeDecoder, mazeNavigationEvaluator,
SelectionType.Generational, SearchType.NoveltySearch,
ParallelOptions, _nearestNeighbors, archive);
// Initialize the evolution algorithm.
ea.Initialize(fitnessEvaluator, genomeFactory, genomeList, MaxGenerations, null, archive);
// Finished. Return the evolution algorithm
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 SteadyStateNeatEvolutionAlgorithm object (specific to fitness-based evaluations) ready for
/// running the
/// NEAT algorithm/search based on the given genome factory and genome list. Various sub-parts of the algorithm are
/// also constructed and connected up.
/// </summary>
/// <param name="genomeFactory">The genome factory from which to generate new genomes</param>
/// <param name="genomeList">The current genome population</param>
/// <param name="startingEvaluations">The number of evaluations that have been executed prior to the current run.</param>
/// <returns>Constructed evolutionary algorithm</returns>
public override INeatEvolutionAlgorithm<NeatGenome> CreateEvolutionAlgorithm(
IGenomeFactory<NeatGenome> genomeFactory,
List<NeatGenome> genomeList, ulong startingEvaluations)
{
FileDataLogger logger = 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, 0.0, 10.0);
ISpeciationStrategy<NeatGenome> speciationStrategy =
new ParallelKMeansClusteringStrategy<NeatGenome>(distanceMetric, ParallelOptions);
// Create complexity regulation strategy.
var complexityRegulationStrategy =
ExperimentUtils.CreateComplexityRegulationStrategy(ComplexityRegulationStrategy, Complexitythreshold);
// Initialize the logger
if (_generationalLogFile != null)
{
logger =
new FileDataLogger(_generationalLogFile);
}
// Create the evolution algorithm.
var ea = new SteadyStateNeatEvolutionAlgorithm<NeatGenome>(NeatEvolutionAlgorithmParameters,
speciationStrategy, complexityRegulationStrategy, _batchSize, _populationEvaluationFrequency,
RunPhase.Primary, logger);
// Create IBlackBox evaluator.
var mazeNavigationEvaluator = new MazeNavigationRandomEvaluator(MaxDistanceToTarget, MaxTimesteps,
MazeVariant, MinSuccessDistance);
// Create genome decoder.
var genomeDecoder = CreateGenomeDecoder();
IGenomeEvaluator<NeatGenome> fitnessEvaluator =
new ParallelGenomeFitnessEvaluator<NeatGenome, IBlackBox>(genomeDecoder, mazeNavigationEvaluator,
ParallelOptions);
// Initialize the evolution algorithm.
ea.Initialize(fitnessEvaluator, genomeFactory, genomeList, null, MaxEvaluations);
// 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, 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 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 = new NullComplexityRegulationStrategy();// 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.
_evaluator = new ForagingEvaluator <NeatGenome>(genomeDecoder, _world, _agentType, _navigationEnabled, _hidingEnabled)
{
MaxTimeSteps = _timeStepsPerGeneration,
EvoParadigm = _paradigm,
MemParadigm = _memory,
GenerationsPerMemorySize = _memGens,
MaxMemorySize = _maxMemorySize,
TeachParadigm = _teaching,
TrialId = TrialId,
PredatorCount = _predCount,
PredatorDistribution = PredatorDistribution,
PredatorTypes = _predTypes,
PredatorGenerations = _predGens,
DistinguishPredators = _distinguishPreds,
LogDiversity = _logDiversity
};
// Initialize the evolution algorithm.
ea.Initialize(_evaluator, 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 the evolution algorithm.
NeatEvolutionAlgorithm <NeatGenome> ea = new NeatEvolutionAlgorithm <NeatGenome>(_eaParams, speciationStrategy, _complexityRegulationStrategy);
// Create genome decoder.
IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder();
INoveltyScorer <NeatGenome> noveltyScorer = new TuringNoveltyScorer <NeatGenome>(_noveltySearchParams);
IGeneticDiversityScorer <NeatGenome> geneticDiversityScorer = new GeneticDiversityKnn <NeatGenome>(_neatGenomeParams.ConnectionWeightRange);
IMultiObjectiveScorer multiObjectiveScorer = new NSGAII(_multiObjectiveParams);
_listEvaluator = new MultiObjectiveListEvaluator <NeatGenome, IBlackBox>(
genomeDecoder,
_evaluator,
noveltyScorer,
geneticDiversityScorer,
multiObjectiveScorer,
_multiThreading,
_parallelOptions);
_listEvaluator.MultiObjectiveParams = _multiObjectiveParams;
_listEvaluator.ReportInterval = _logInterval;
NoveltySearchEnabled = _noveltySearchParams?.Enabled ?? false;
MultiObjectiveEnabled = _multiObjectiveParams?.Enabled ?? false;
// Initialize the evolution algorithm.
ea.Initialize(_listEvaluator, genomeFactory, genomeList);
ea.UpdateScheme = new UpdateScheme(1);
// Finished. Return the evolution algorithm
return(ea);
}
private static void Train()
{
File.WriteAllText($"{NeatConsts.experimentName}/fitness.csv", "generation,firness\n");
var neatGenomeFactory = new NeatGenomeFactory(NeatConsts.ViewX * NeatConsts.ViewY * NeatConsts.typeIds.Count, 1);
var genomeList = neatGenomeFactory.CreateGenomeList(NeatConsts.SpecCount, 0);
var eaParams = new NeatEvolutionAlgorithmParameters
{
SpecieCount = NeatConsts.SpecCount
};
//var distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
var distanceMetric = new ManhattanDistanceMetric();
var parallelOptions = new ParallelOptions();
var speciationStrategy = new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetric, parallelOptions);
//var speciationStrategy = new KMeansClusteringStrategy<NeatGenome>(distanceMetric);
//var speciationStrategy = new RandomClusteringStrategy<NeatGenome>();
var complexityRegulationStrategy = new NullComplexityRegulationStrategy();
//var complexityRegulationStrategy = new DefaultComplexityRegulationStrategy(ComplexityCeilingType.Relative, 0.50);
var ea = new NeatEvolutionAlgorithm <NeatGenome>(eaParams, speciationStrategy, complexityRegulationStrategy);
var activationScheme = NetworkActivationScheme.CreateCyclicFixedTimestepsScheme(1);
var genomeDecoder = new NeatGenomeDecoder(activationScheme);
var phenomeEvaluator = new GameEvaluator();
var genomeListEvaluator = new ParallelGenomeListEvaluator <NeatGenome, IBlackBox>(genomeDecoder, phenomeEvaluator, parallelOptions);
ea.Initialize(genomeListEvaluator, neatGenomeFactory, genomeList);
ea.UpdateScheme = new UpdateScheme(NeatConsts.LogRate);
ea.StartContinue();
ea.UpdateEvent += Ea_UpdateEvent;
while (ea.RunState != RunState.Paused)
{
}
ea.Stop();
}
/// <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.
InvertedDoublePendulumEvaluator evaluator = new InvertedDoublePendulumEvaluator();
// 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);
//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>
/// Creates and returns a GenerationalNeatEvolutionAlgorithm 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>
/// <param name="genomeFactory">The NEAT genome factory.</param>
/// <param name="genomeList">The initial list of genomes.</param>
/// <returns>The NEAT evolution algorithm.</returns>
public INeatEvolutionAlgorithm<NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory<NeatGenome> genomeFactory,
List<NeatGenome> genomeList)
{
FileDataLogger logger = 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, 0.0, 10.0);
ISpeciationStrategy<NeatGenome> speciationStrategy =
new ParallelKMeansClusteringStrategy<NeatGenome>(distanceMetric, _parallelOptions);
// Create complexity regulation strategy
IComplexityRegulationStrategy complexityRegulationStrategy =
ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold);
// Initialize the logger
if (_generationalLogFile != null)
{
logger =
new FileDataLogger(_generationalLogFile);
}
// Create the evolution algorithm
GenerationalNeatEvolutionAlgorithm<NeatGenome> ea =
new GenerationalNeatEvolutionAlgorithm<NeatGenome>(NeatEvolutionAlgorithmParameters, speciationStrategy,
complexityRegulationStrategy, logger);
// Create evalutor
BinaryEvolvedAutoencoderEvaluator evaluator = new BinaryEvolvedAutoencoderEvaluator(_trainingImagesFilename,
InputCount, _numImageSamples, _learningRate, _numBackpropIterations, _trainingSampleProportion);
// Create genome decoder
IGenomeDecoder<NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder();
// Create a genome list evaluator. This packages up the genome decoder with the genome evaluator
IGenomeEvaluator<NeatGenome> innerFitnessEvaluator =
new ParallelGenomeFitnessEvaluator<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 determined by examining each genome's evaluation info object.
IGenomeEvaluator<NeatGenome> selectiveFitnessEvaluator = new SelectiveGenomeFitnessEvaluator<NeatGenome>(
innerFitnessEvaluator,
SelectiveGenomeFitnessEvaluator<NeatGenome>.CreatePredicate_OnceOnly());
// Initialize the evolution algorithm
ea.Initialize(selectiveFitnessEvaluator, genomeFactory, genomeList, null);
// Finished. Return the evolution algorithm
return ea;
}
/// <summary>
/// Create and return a GenerationalNeatEvolutionAlgorithm 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 INeatEvolutionAlgorithm<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.
GenerationalNeatEvolutionAlgorithm<NeatGenome> ea = new GenerationalNeatEvolutionAlgorithm<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.
IGenomeEvaluator<NeatGenome> genomeFitnessEvaluator = new ParallelGenomeFitnessEvaluator<NeatGenome, IBlackBox>(genomeDecoder, evaluator, _parallelOptions);
// Initialize the evolution algorithm.
ea.Initialize(genomeFitnessEvaluator, genomeFactory, genomeList);
// Finished. Return the evolution algorithm
return ea;
}
public static void Main(string[] args)
{
var random = new Random();
var circuits = circuitsFilePaths().ToArray();
var perceptionStep = TimeSpan.FromSeconds(0.1);
var simulationStep = TimeSpan.FromSeconds(0.05); // 20Hz
var maximumSimulationTime = TimeSpan.FromSeconds(60);
var tracks = circuits.Select(circuitPath => Track.Load($"{circuitPath}/circuit_definition.json"));
var worlds = tracks.Select(track => new StandardWorld(track, simulationStep)).ToArray();
var inputSamplesCount = 3;
var maximumScanningDistance = 200;
ILidar createLidarFor(ITrack track)
=> new Lidar(track, inputSamplesCount, Angle.FromDegrees(135), maximumScanningDistance);
var settings = new EvolutionSettings
{
PopulationSize = 1000,
SpeciesCount = 30,
ElitismProportion = 0,
ComplexityThreshold = 50
};
// prepare simulation
var parameters = new NeatEvolutionAlgorithmParameters
{
ElitismProportion = settings.ElitismProportion,
SpecieCount = settings.SpeciesCount
};
var distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
var parallelOptions = new ParallelOptions {
MaxDegreeOfParallelism = 4
};
var speciationStrategy = new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetric, parallelOptions);
var complexityRegulationStrategy = new DefaultComplexityRegulationStrategy(ComplexityCeilingType.Absolute, settings.ComplexityThreshold);
var evolutionaryAlgorithm = new NeatEvolutionAlgorithm <NeatGenome>(
parameters,
speciationStrategy,
complexityRegulationStrategy);
var phenomeEvaluator = new RaceSimulationEvaluator(
random,
simulationStep,
perceptionStep,
maximumSimulationTime,
worlds,
createLidarFor);
var genomeDecoder = new NeatGenomeDecoder(NetworkActivationScheme.CreateAcyclicScheme());
var genomeListEvaluator = new ParallelGenomeListEvaluator <NeatGenome, IBlackBox>(
genomeDecoder,
phenomeEvaluator);
evolutionaryAlgorithm.Initialize(
genomeListEvaluator,
genomeFactory: new NeatGenomeFactory(
inputNeuronCount: inputSamplesCount,
outputNeuronCount: 2,
DefaultActivationFunctionLibrary.CreateLibraryNeat(new BipolarSigmoid()),
new NeatGenomeParameters
{
FeedforwardOnly = true,
AddNodeMutationProbability = 0.03,
DeleteConnectionMutationProbability = 0.05,
ConnectionWeightMutationProbability = 0.08,
FitnessHistoryLength = 10,
}),
settings.PopulationSize);
var lastVisualization = DateTimeOffset.Now;
evolutionaryAlgorithm.UpdateEvent += onUpdate;
evolutionaryAlgorithm.StartContinue();
Console.WriteLine("Press enter to stop the evolution.");
Console.ReadLine();
Console.WriteLine("Finishing the evolution.");
evolutionaryAlgorithm.Stop();
Console.WriteLine("Evolution is stopped.");
// simulate best individual
Console.WriteLine("Simulating best individual...");
evaluate(evolutionaryAlgorithm.CurrentChampGenome);
Console.WriteLine("Done.");
void onUpdate(object sender, EventArgs e)
{
Console.WriteLine($"Generation #{evolutionaryAlgorithm.CurrentGeneration}");
Console.WriteLine($"- max fitness: {evolutionaryAlgorithm.Statistics._maxFitness}");
Console.WriteLine($"- mean fitness: {evolutionaryAlgorithm.Statistics._meanFitness}");
Console.WriteLine();
if (DateTimeOffset.Now - lastVisualization > TimeSpan.FromSeconds(35))
{
lastVisualization = DateTimeOffset.Now;
Console.WriteLine("Simulating currently best individual...");
evaluate(evolutionaryAlgorithm.CurrentChampGenome);
}
}
void evaluate(NeatGenome genome)
{
var worldId = random.Next(0, worlds.Length - 1);
var world = worlds[worldId];
var bestIndividual = genomeDecoder.Decode(genome);
var agent = new NeuralNetworkAgent(createLidarFor(world.Track), bestIndividual);
var simulation = new Simulation.Simulation(agent, world);
var summary = simulation.Simulate(simulationStep, perceptionStep, maximumSimulationTime);
File.Copy($"{circuits[worldId]}/visualization.svg", "C:/Users/simon/Projects/racer-experiment/simulator/src/visualization.svg", overwrite: true);
IO.Simulation.StoreResult(world.Track, world.VehicleModel, summary, "", "C:/Users/simon/Projects/racer-experiment/simulator/src/report.json");
}
}
/// <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 = new NullComplexityRegulationStrategy();// 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.
_evaluator = new ForagingEvaluator<NeatGenome>(genomeDecoder, _world, _agentType, _navigationEnabled, _hidingEnabled)
{
MaxTimeSteps = _timeStepsPerGeneration,
EvoParadigm = _paradigm,
MemParadigm = _memory,
GenerationsPerMemorySize = _memGens,
MaxMemorySize = _maxMemorySize,
TeachParadigm = _teaching,
TrialId = TrialId,
PredatorCount = _predCount,
PredatorDistribution = PredatorDistribution,
PredatorTypes = _predTypes,
PredatorGenerations = _predGens,
DistinguishPredators = _distinguishPreds,
LogDiversity = _logDiversity
};
// Initialize the evolution algorithm.
ea.Initialize(_evaluator, genomeFactory, genomeList);
// Finished. Return the evolution algorithm
return ea;
}
/// <summary>
/// Constructs and returns a NEAT evolution algorithm, using the given genome factory and genome list.
/// </summary>
/// <param name="genomeFactory">The genome factory to use for generating offspring during evolution.</param>
/// <param name="genomeList">The initial list of genomes.</param>
/// <returns>The NEAT evolution algorithm.</returns>
public INeatEvolutionAlgorithm<NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory<NeatGenome> genomeFactory,
List<NeatGenome> genomeList)
{
FileDataLogger logger = 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, 0.0, 10.0);
ISpeciationStrategy<NeatGenome> speciationStrategy =
new ParallelKMeansClusteringStrategy<NeatGenome>(distanceMetric, _parallelOptions);
// Create complexity regulation strategy.
IComplexityRegulationStrategy complexityRegulationStrategy =
ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStrategy, _complexityThreshold);
// Initialize the logger
if (_generationalLogFile != null)
{
logger =
new FileDataLogger(_generationalLogFile);
}
// Create the evolution algorithm.
GenerationalNeatEvolutionAlgorithm<NeatGenome> ea =
new GenerationalNeatEvolutionAlgorithm<NeatGenome>(NeatEvolutionAlgorithmParameters,
speciationStrategy, complexityRegulationStrategy, logger);
// Create black box evaluator.
ThreeParityEvaluator evaluator = new ThreeParityEvaluator();
// Create genome decoder. Decodes to a neural network packaged with an activation scheme.
IGenomeDecoder<NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder();
// Create a genome list evaluator. This packages up the genome decoder with the genome evaluator.
IGenomeEvaluator<NeatGenome> innerFitnessEvaluator =
new ParallelGenomeFitnessEvaluator<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.
IGenomeEvaluator<NeatGenome> selectiveFitnessEvaluator = new SelectiveGenomeFitnessEvaluator<NeatGenome>(
innerFitnessEvaluator,
SelectiveGenomeFitnessEvaluator<NeatGenome>.CreatePredicate_OnceOnly());
// Initialize the evolution algorithm.
ea.Initialize(selectiveFitnessEvaluator, genomeFactory, genomeList);
// Finished. Return the evolution algorithm
return ea;
}
public NeatEvolutionAlgorithm<NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory<NeatGenome> genomeFactory, List<NeatGenome> genomeList)
{
var parallelOptions = new ParallelOptions();
// Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference.
var distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
var speciationStrategy = new ParallelKMeansClusteringStrategy<NeatGenome>(distanceMetric, parallelOptions);
// Create complexity regulation strategy.
var complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStrategy, _complexityThreshold);
// Create the evolution algorithm.
var evolutionAlgorithm = new NeatEvolutionAlgorithm<NeatGenome>(NeatEvolutionAlgorithmParameters, speciationStrategy, complexityRegulationStrategy);
// Create genome decoder.
var genomeDecoder = CreateGenomeDecoder();
// Create a genome list evaluator. This packages up the genome decoder with the genome evaluator.
var genomeListEvaluator = new ParallelGenomeListEvaluator<NeatGenome, IBlackBox>(genomeDecoder, _neuromonPhenomeEvaluator, parallelOptions);
// Initialize the evolution algorithm.
evolutionAlgorithm.Initialize(genomeListEvaluator, genomeFactory, genomeList);
return evolutionAlgorithm;
}
/// <summary>
/// Create and return a GenerationalNeatEvolutionAlgorithm 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 INeatEvolutionAlgorithm<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.
GenerationalNeatEvolutionAlgorithm<NeatGenome> ea = new GenerationalNeatEvolutionAlgorithm<NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy);
// Create IBlackBox evaluator.
EvolvedAutoencoderEvaluator evaluator = new EvolvedAutoencoderEvaluator(_trainingImagesFilename,
_visualFieldPixelCount, _numImageSamples, _learningRate, _numBackpropIterations, _trainingSampleProportion, _resolutionReductionPerSide);
// 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/ _resolutionReductionPerSide, _lengthCppnInput);
// Create a genome list evaluator. This packages up the genome decoder with the genome evaluator.
IGenomeEvaluator<NeatGenome> innerFitnessEvaluator = new ParallelGenomeFitnessEvaluator<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.
IGenomeEvaluator<NeatGenome> selectiveFitnessEvaluator = new SelectiveGenomeFitnessEvaluator<NeatGenome>(
innerFitnessEvaluator,
SelectiveGenomeFitnessEvaluator<NeatGenome>.CreatePredicate_OnceOnly());
// Initialize the evolution algorithm.
ea.Initialize(selectiveFitnessEvaluator, 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, new ParallelOptions());
// Create complexity regulation strategy.
IComplexityRegulationStrategy complexityRegulationStrategy = new NullComplexityRegulationStrategy();// ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold);
// Create the evolution algorithm.
NeatEvolutionAlgorithm<NeatGenome> ea = new NeatEvolutionAlgorithm<NeatGenome>(EvoParameters, speciationStrategy, complexityRegulationStrategy);
// Create a genome list evaluator. This packages up the genome decoder with the phenome evaluator.
if(Evaluator == null)
Evaluator = CreateEvaluator();
// Initialize the evolution algorithm.
ea.Initialize(Evaluator, 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>[] 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, _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;
}
public NeatEvolutionAlgorithm<NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory<NeatGenome> genomeFactory, List<NeatGenome> genomeList, IGenomeListEvaluator<NeatGenome> eval = 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, 0.0, 10.0);
ISpeciationStrategy<NeatGenome> speciationStrategy = new ParallelKMeansClusteringStrategy<NeatGenome>(distanceMetric, _parallelOptions);
// Create complexity regulation strategy.
IComplexityRegulationStrategy complexityRegulationStrategy = new NullComplexityRegulationStrategy();// ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold);
// Create the evolution algorithm.
NeatEvolutionAlgorithm<NeatGenome> ea = new NeatEvolutionAlgorithm<NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy);
// Create the MC evaluator
PasswordCrackingEvaluator.Passwords = _passwords;
// Create genome decoder.
IGenomeDecoder<NeatGenome, MarkovChain> genomeDecoder = CreateGenomeDecoder();
// If we're running specially on Condor, skip this
if (eval == null)
{
_evaluator = new PasswordCrackingEvaluator(_guesses, Hashed);
// Create a genome list evaluator. This packages up the genome decoder with the genome evaluator.
// IGenomeListEvaluator<NeatGenome> innerEvaluator = new ParallelGenomeListEvaluator<NeatGenome, MarkovChain>(genomeDecoder, _evaluator, _parallelOptions);
IGenomeListEvaluator<NeatGenome> innerEvaluator = new ParallelNEATGenomeListEvaluator<NeatGenome, MarkovChain>(genomeDecoder, _evaluator, this);
/*
// 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(innerEvaluator, genomeFactory, genomeList);
}
else
// Initialize the evolution algorithm.
ea.Initialize(eval, 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.
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;
}
/// <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;
}
