/// <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;
}
public NeatTrainer(ExperimentSettings experimentSettings, NeatEvolutionAlgorithmParameters evolutionAlgorithmParameters, TrainingGameSettings gameSettings)
{
var neuromonPhenomeEvaluator = new NeuromonEvaluator(gameSettings, experimentSettings);
var neatGenomeParameters = new NeatGenomeParameters();
_neuromonExperiment = new NeuromonExperiment(experimentSettings, evolutionAlgorithmParameters, neuromonPhenomeEvaluator, neatGenomeParameters);
_genomeIo = new GenomeIo(_neuromonExperiment);
_genomeFactory = _neuromonExperiment.CreateGenomeFactory();
if (experimentSettings.LoadExistingPopulation)
{
_genomePopulation = _genomeIo.Read(experimentSettings.ExistingPopulationFilePath);
}
else
{
// Randomly generate a new population
_genomePopulation = _genomeFactory.CreateGenomeList(experimentSettings.PopulationSize, 0);
}
_genomeIo.CacheChampion(_genomePopulation.OrderByDescending(g => g.EvaluationInfo.Fitness).First());
_fitnessStagnationDetector = new FitnessStagnationDetector(experimentSettings.StagnationDetectionTriggerValue);
_desiredFitness = experimentSettings.DesiredFitness;
_previousGeneration = 0;
_overallBestFitness = 0.0;
}
static void Main(string[] args)
{
// Initialise log4net (log to console).
XmlConfigurator.Configure(new FileInfo("log4net.properties"));
// Experiment classes encapsulate much of the nuts and bolts of setting up a NEAT search.
XorExperiment experiment = new XorExperiment();
// Load config XML.
XmlDocument xmlConfig = new XmlDocument();
xmlConfig.Load("xor.config.xml");
experiment.Initialize("XOR", xmlConfig.DocumentElement);
// Create a genome factory with our neat genome parameters object and the appropriate number of input and output neuron genes.
_genomeFactory = experiment.CreateGenomeFactory();
// Create an initial population of randomly generated genomes.
_genomeList = _genomeFactory.CreateGenomeList(150, 0);
// Create evolution algorithm and attach update event.
_ea = experiment.CreateEvolutionAlgorithm(_genomeFactory, _genomeList);
_ea.UpdateEvent += new EventHandler(ea_UpdateEvent);
// Start algorithm (it will run on a background thread).
_ea.StartContinue();
// Hit return to quit.
Console.ReadLine();
}
/// <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;
}
public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(int populationSize)
{
// Create a genome factory with our neat genome parameters object and the appropriate number of input and output neuron genes.
IGenomeFactory <NeatGenome> genomeFactory = CreateGenomeFactory();
// Create an initial population of randomly generated genomes.
List <NeatGenome> genomeList = genomeFactory.CreateGenomeList(populationSize, 0);
// Create evolution algorithm.
return(CreateEvolutionAlgorithm(genomeFactory, genomeList));
}
public void Initialize(IGenomeFactory <NeatGenome> genomeFactory1, IGenomeFactory <NeatGenome> genomeFactory2, int populationSize)
{
// Make sure a parasite module has been attached.
Debug.Assert(OtherModules != null);
RhythmEvolutionAlgorithm.Initialize(_genomeRhythmModulesEvaluator, genomeFactory1, genomeFactory1.CreateGenomeList(populationSize, GENERATION_ZERO));
PitchEvolutionAlgorithm.Initialize(_genomePitchModulesEvaluator, genomeFactory2, genomeFactory2.CreateGenomeList(populationSize, GENERATION_ZERO));
RhythmEvolutionAlgorithm.UpdateScheme = new UpdateScheme(1);
PitchEvolutionAlgorithm.UpdateScheme = new UpdateScheme(1);
}
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>
/// Initializes the evolution algorithm with the provided IGenomeListEvaluator
/// and an IGenomeFactory that can be used to create an initial population of genomes.
/// </summary>
/// <param name="genomeListEvaluator">The genome evaluation scheme for the evolution algorithm.</param>
/// <param name="genomeFactory">The factory that was used to create the genomeList and which is therefore referenced by the genomes.</param>
/// <param name="populationSize">The number of genomes to create for the initial population.</param>
public virtual void Initialize(IGenomeListEvaluator <TGenome> genomeListEvaluator,
IGenomeFactory <TGenome> genomeFactory,
int populationSize)
{
_currentGeneration = 0;
_genomeListEvaluator = genomeListEvaluator;
_genomeFactory = genomeFactory;
_genomeList = genomeFactory.CreateGenomeList(populationSize, _currentGeneration);
_populationSize = populationSize;
_runState = RunState.Ready;
_updateScheme = new UpdateScheme(new TimeSpan(0, 0, 1));
}
/// <summary>
/// Creates and returns a NeatEvolutionAlgorithm object ready for running
/// the NEAT algorithm/search. An initial genome population is read from
/// the file provided. If this file does not exist, it is created and
/// the genomeFactory builds an initial population.
/// </summary>
public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(string fileName)
{
List <NeatGenome> genomeList = null;
IGenomeFactory <NeatGenome> genomeFactory = CreateGenomeFactory();
genomeList = LoadPopulationFromFile(fileName);
if (genomeList == null)
{
genomeList = CreateNewGenome(genomeFactory);
}
return(CreateEvolutionAlgorithm(genomeFactory, genomeList));
}
/// <summary>
/// Initializes the evolution algorithm with the provided IGenomeListEvaluator, IGenomeFactory
/// and an initial population of genomes.
/// </summary>
/// <param name="genomeListEvaluator">The genome evaluation scheme for the evolution algorithm.</param>
/// <param name="genomeFactory">The factory that was used to create the genomeList and which is therefore referenced by the genomes.</param>
/// <param name="genomeList">An initial genome population.</param>
public virtual void Initialize(IGenomeListEvaluator <TGenome> genomeListEvaluator,
IGenomeFactory <TGenome> genomeFactory,
List <TGenome> genomeList)
{
_currentGeneration = 0;
_genomeListEvaluator = genomeListEvaluator;
_genomeFactory = genomeFactory;
_genomeList = genomeList;
_populationSize = _genomeList.Count;
_runState = RunState.Ready;
_updateScheme = new UpdateScheme(new TimeSpan(0, 0, 1));
}
/// <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)
{
ulong initializationEvaluations;
// Instantiate the internal initialization algorithm
_mazeNavigationInitializer.InitializeAlgorithm(ParallelOptions, genomeList,
CreateGenomeDecoder(), startingEvaluations);
// Run the initialization algorithm until the requested number of viable seed genomes are found
List<NeatGenome> seedPopulation = _mazeNavigationInitializer.EvolveViableGenomes(SeedGenomeCount, true,
out initializationEvaluations);
// Create complexity regulation strategy.
var complexityRegulationStrategy =
ExperimentUtils.CreateComplexityRegulationStrategy(ComplexityRegulationStrategy, Complexitythreshold);
// Create the evolution algorithm.
AbstractNeatEvolutionAlgorithm<NeatGenome> ea =
new QueueingNeatEvolutionAlgorithm<NeatGenome>(NeatEvolutionAlgorithmParameters,
new ParallelKMeansClusteringStrategy<NeatGenome>(new ManhattanDistanceMetric(1.0, 0.0, 10.0),
ParallelOptions),
complexityRegulationStrategy, _batchSize, RunPhase.Primary, (_bridgingMagnitude > 0),
false, _evolutionDataLogger, _experimentLogFieldEnableMap);
// Create IBlackBox evaluator.
IPhenomeEvaluator<IBlackBox, BehaviorInfo> mazeNavigationEvaluator =
new MazeNavigationMCSEvaluator(MaxDistanceToTarget, MaxTimesteps,
MazeVariant, MinSuccessDistance, _behaviorCharacterizationFactory,
_bridgingMagnitude, _bridgingApplications, initializationEvaluations);
// Create genome decoder.
IGenomeDecoder<NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder();
// IGenomeEvaluator<NeatGenome> fitnessEvaluator =
// new SerialGenomeBehaviorEvaluator<NeatGenome, IBlackBox>(genomeDecoder, mazeNavigationEvaluator,
// SelectionType.Queueing, SearchType.MinimalCriteriaSearch, _evaluationDataLogger,
// SerializeGenomeToXml);
IGenomeEvaluator<NeatGenome> fitnessEvaluator =
new ParallelGenomeBehaviorEvaluator<NeatGenome, IBlackBox>(genomeDecoder, mazeNavigationEvaluator,
SelectionType.Queueing, SearchType.MinimalCriteriaSearch, _evaluationDataLogger,
SerializeGenomeToXml);
// Initialize the evolution algorithm.
ea.Initialize(fitnessEvaluator, genomeFactory, seedPopulation, DefaultPopulationSize,
null, MaxEvaluations + startingEvaluations);
// Finished. Return the evolution algorithm
return ea;
}
public Solver(IGenomeFactory <T> genomeFactory,
IGenomeEvaluator <T, TScore> evaluator,
ISolverLogger <T, TScore> logger, ISolverParameters solverParameters,
IEnumerable <IEarlyStoppingCondition <T, TScore> > earlyStoppingConditions,
IEnumerable <IGenomeReproductionStrategy <T> > genomeReproductionStrategies)
{
_genomeFactory = genomeFactory;
_evaluator = evaluator;
_logger = logger;
_solverParameters = solverParameters;
_earlyStoppingConditions = earlyStoppingConditions;
_genomeReproductionStrategies = genomeReproductionStrategies;
}
private void Initialize_private(IGenomeListEvaluator <TGenome> genomeListEvaluator, IGenomeFactory <TGenome> genomeFactory, List <TGenome> genomeList)
{
_prevUpdateGeneration = 0;
_prevUpdateTimeTick = DateTime.UtcNow.Ticks;
_currentGeneration = 0;
_genomeListEvaluator = genomeListEvaluator;
_genomeFactory = genomeFactory;
_genomeList = genomeList;
_populationSize = _genomeList.Count;
_runState = RunState.Ready;
_updateScheme = new UpdateScheme(new TimeSpan(0, 0, 1));
}
/// <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>
/// Initializes the evolution algorithm with the provided IGenomeListEvaluator
/// and an IGenomeFactory that can be used to create an initial population of genomes.
/// </summary>
/// <param name="genomeListEvaluator">The genome evaluation scheme for
/// the evolution algorithm.</param>
/// <param name="genomeFactory">The factory that was used to create the
/// genomeList and which is therefore referenced by the genomes.</param>
/// <param name="populationSize">The number of genomes to create for the
/// initial population.</param>
public virtual void Initialize(IGenomeListEvaluator <TGenome> genomeListEvaluator,
IGenomeFactory <TGenome> genomeFactory,
int populationSize)
{
_currentGeneration = 0;
_genomeListEvaluator = genomeListEvaluator;
_genomeFactory = genomeFactory;
_genomeList = genomeFactory.CreateGenomeList(populationSize, _currentGeneration);
// We set an arbitrary genome as champion to avoid possible null exceptions.
_currentBestGenome = _genomeList[0];
_populationSize = populationSize;
_runState = RunState.Ready;
_updateScheme = new UpdateScheme(new TimeSpan(0, 0, 1));
}
/// <summary>
/// Tries to load a genome population using a given file path. If this is
/// unsuccessful then calls to the default method.
/// </summary>
public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(string fileName)
{
IGenomeFactory <NeatGenome> genomeFactory = CreateGenomeFactory();
List <NeatGenome> genomeList = null;
genomeList = LoadPopulationFromFile(fileName);
if (genomeList == null)
{
return(CreateEvolutionAlgorithm());
}
NeatEvolutionAlgorithm <NeatGenome> evolutionAlgorithm = CreateEvolutionAlgorithm(genomeFactory, genomeList);
evolutionAlgorithm.FindLastGeneration();
return(evolutionAlgorithm);
}
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);
}
static void RunTrial(int offset)
{
RESULTS_FILE = EXPERIMENTS_DIR + RESULTS_FILE_BASE + offset + ".csv";
_random = new FastRandom();
_experiment = new SocialExperiment();
XmlDocument xmlConfig = new XmlDocument();
xmlConfig.Load(CONFIG_FILE);
_experiment.Initialize("SimpleEvolution", xmlConfig.DocumentElement);
_experiment.NeatGenomeParameters.AddConnectionMutationProbability = 0;
_experiment.NeatGenomeParameters.AddNodeMutationProbability = 0;
_experiment.NeatGenomeParameters.DeleteConnectionMutationProbability = 0;
SocialExperiment.CreateNetwork(FEED_FORWARD_NETWORK_FILE, _experiment.InputCount, _experiment.OutputCount);
// Record the changes at each step
_experiment.World.Stepped += new social_learning.World.StepEventHandler(World_Stepped);
// Read in the seed genome from file. This is the prototype for our other population of networks.
var seed = _experiment.LoadPopulation(XmlReader.Create(FEED_FORWARD_NETWORK_FILE))[0];
// Create a genome factory with our neat genome parameters object and the appropriate number of input and output neuron genes.
IGenomeFactory <NeatGenome> genomeFactory = _experiment.CreateGenomeFactory();
// Create an initial population of randomly generated genomes.
List <NeatGenome> genomeList = genomeFactory.CreateGenomeList(_experiment.DefaultPopulationSize, 0, seed);
// Randomize the genomes
RandomizeGenomes(genomeList);
// Create genome decoder.
IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = _experiment.CreateGenomeDecoder();
// Create the evaluator that will handle the simulation
_evaluator = new ForagingEvaluator <NeatGenome>(genomeDecoder, _experiment.World, AgentTypes.Social)
{
MaxTimeSteps = 200000UL,
BackpropEpochsPerExample = 1
};
using (TextWriter writer = new StreamWriter(RESULTS_FILE))
writer.WriteLine("Step,Best,Average");
// Start the simulation
_evaluator.Evaluate(genomeList);
}
public SexualGenomeReproductionStrategy(
IMutator <T> mutator,
IPairingStrategy pairingStrategy,
IGenomeFactory <T> genomeFactory,
IGenomeDescription <T> genomeDescription,
IGenomeEvaluator <T, TScore> genomeEvaluator,
int childrenToCreate,
int childrenToKeepPerPair)
{
_mutator = mutator;
_pairingStrategy = pairingStrategy;
_genomeFactory = genomeFactory;
_genomeDescription = genomeDescription;
_genomeEvaluator = genomeEvaluator;
_childrenToCreate = childrenToCreate;
_childrenToKeepPerPair = childrenToKeepPerPair;
}
/// <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;
}
public override NeatEvolutionAlgorithm<NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory<NeatGenome> genomeFactory, List<NeatGenome> genomeList)
{
var ea = DefaultNeatEvolutionAlgorithm;
var evaluator = new LocalXorEvaluator();
// 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 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>[] 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;
}
public override NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory <NeatGenome> genomeFactory, List <NeatGenome> genomeList)
{
var ea = DefaultNeatEvolutionAlgorithm;
var evaluator = new LocalXorEvaluator();
// 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 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 IGenome <G, V> ApplyOperator(IGenomeFactory <G, V> gf, IPopulation <G, V> population)
{
if (gf is IGenomeCreator <G, V> )
{
return(((IGenomeCreator <G, V>)gf).Create());
}
if (gf is IGenomeMutator <G, V> )
{
return(((IGenomeMutator <G, V>)gf).Mutate(this.ChooseGenome(population)));
}
if (gf is IGenomeCrossover <G, V> )
{
return(((IGenomeCrossover <G, V>)gf).Crossover(this.ChooseGenome(population), this.ChooseGenome(population)));
}
throw new ArgumentException();
}
public override NeatEvolutionAlgorithm<NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory<NeatGenome> genomeFactory, List<NeatGenome> genomeList)
{
// Create the evolution algorithm.
var ea = DefaultNeatEvolutionAlgorithm;
var evaluator = new RemoteBatchSixMultiplexerEvaluator(ea);
IGenomeDecoder<NeatGenome, FastCyclicNetwork> genomeDecoder = _decoder;
// Evaluates list of phenotypes
IGenomeListEvaluator<NeatGenome> innerEvaluator =
new BatchGenomeListEvaluator<NeatGenome, FastCyclicNetwork>(
genomeDecoder,
evaluator);
// Weeds down the list to be evaluated
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 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);
}
/// <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.
DeepBeliefNetworkBiasEvaluator evaluator = new DeepBeliefNetworkBiasEvaluator();
// 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(_lengthCppnInput);
// Create a genome list evaluator. This packages up the genome decoder with the genome evaluator.
IGenomeListEvaluator <NeatGenome> innerEvaluator = null;
if (Constants.IS_MULTI_THREADING)
{
innerEvaluator = new ParallelGenomeListEvaluator <NeatGenome, IBlackBox>(genomeDecoder, evaluator, _parallelOptions);
}
else
{
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);
}
private static void Main(string[] args)
{
Debug.Assert(args != null && args.Length == 2,
"Experiment configuration file and number of runs are required!");
// Read in experiment configuration file
string experimentName = args[0];
int numRuns = Int32.Parse(args[1]);
// Initialise log4net (log to console).
XmlConfigurator.Configure(new FileInfo("log4net.properties"));
// Experiment classes encapsulate much of the nuts and bolts of setting up a NEAT search.
SteadyStateMazeNavigationNoveltyExperiment experiment = new SteadyStateMazeNavigationNoveltyExperiment();
// Load config XML.
XmlDocument xmlConfig = new XmlDocument();
xmlConfig.Load("./ExperimentConfigurations/" + experimentName);
experiment.Initialize("Novelty", xmlConfig.DocumentElement, null, null);
// Create a genome factory with our neat genome parameters object and the appropriate number of input and output neuron genes.
_genomeFactory = experiment.CreateGenomeFactory();
// Create an initial population of randomly generated genomes.
_genomeList = _genomeFactory.CreateGenomeList(experiment.DefaultPopulationSize, 0);
// Create evolution algorithm and attach update event.
_ea = experiment.CreateEvolutionAlgorithm(_genomeFactory, _genomeList);
_ea.UpdateEvent += ea_UpdateEvent;
// Start algorithm (it will run on a background thread).
_ea.StartContinue();
/*while (RunState.Terminated != _ea.RunState && RunState.Paused != _ea.RunState &&
_ea.CurrentGeneration < maxGenerations)
{
Thread.Sleep(2000);
}*/
// Hit return to quit.
//Console.ReadLine();
}
/*
* 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 weight difference.
IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
ISpeciationStrategy <NeatGenome> speciationStrategy =
new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetric);
// Create complexity regulation strategy.
IComplexityRegulationStrategy complexityRegulationStrategy = new NullComplexityRegulationStrategy();
// Create the evolution algorithm.
NeatEvolutionAlgorithm <NeatGenome> ea =
new NeatEvolutionAlgorithm <NeatGenome>(this.eaParams, speciationStrategy, complexityRegulationStrategy);
// Create genome decoder.
IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = this.CreateGenomeDecoder();
var evaluator = new Evaluator();
// Create a genome list evaluator. This packages up the genome decoder with the genome evaluator.
//IGenomeListEvaluator<NeatGenome> innerEvaluator =
// new SerialGenomeListEvaluator<NeatGenome, IBlackBox>(genomeDecoder, evaluator);
IGenomeListEvaluator <NeatGenome> innerEvaluator =
new ParallelGenomeListEvaluator <NeatGenome, IBlackBox>(genomeDecoder, evaluator);
// 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_OnceOnly());
// Initialize the evolution algorithm.
ea.Initialize(selectiveEvaluator, genomeFactory, genomeList);
ea.UpdateScheme = new UpdateScheme(1);
// Finished. Return the evolution algorithm
return(ea);
}
/// <summary>
/// Initializes the evolution algorithm with the provided IGenomeListEvaluator, IGenomeFactory
/// an initial population of genomes and a boolean to update the currentGeneration value.
/// </summary>
/// <param name="genomeListEvaluator">The genome evaluation scheme for the evolution algorithm.</param>
/// <param name="genomeFactory">The factory that was used to create the genomeList and which is therefore referenced by the genomes.</param>
/// <param name="genomeList">An initial genome population.</param>
/// <param name="addGenerationValue">boolean to trigger currentGeneration value from last genome in list</param>
public virtual void Initialize(IGenomeListEvaluator <TGenome> genomeListEvaluator,
IGenomeFactory <TGenome> genomeFactory,
List <TGenome> genomeList,
bool addGenerationValue)
{
_currentGeneration = 0;
if (genomeList.Count > 0)
{
int LastIndex = genomeList.Count - 1;
_currentGeneration = genomeList.Min <TGenome, uint>(genome => genome.BirthGeneration);
}
_genomeListEvaluator = genomeListEvaluator;
_genomeFactory = genomeFactory;
_genomeList = genomeList;
_populationSize = _genomeList.Count;
_runState = RunState.Ready;
_updateScheme = new UpdateScheme(new TimeSpan(0, 0, 1));
}
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);
// Creates 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(innerEvaluator, genomeFactory, genomeList);
return(ea);
}
public override NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory <NeatGenome> genomeFactory, List <NeatGenome> genomeList)
{
// Create the evolution algorithm.
var ea = DefaultNeatEvolutionAlgorithm;
var evaluator = new RemoteBatchSixMultiplexerEvaluator(ea);
IGenomeDecoder <NeatGenome, FastCyclicNetwork> genomeDecoder = _decoder;
// Evaluates list of phenotypes
IGenomeListEvaluator <NeatGenome> innerEvaluator =
new BatchGenomeListEvaluator <NeatGenome, FastCyclicNetwork>(
genomeDecoder,
evaluator);
// Weeds down the list to be evaluated
IGenomeListEvaluator <NeatGenome> selectiveEvaluator =
new SelectiveGenomeListEvaluator <NeatGenome>(
innerEvaluator,
SelectiveGenomeListEvaluator <NeatGenome> .CreatePredicate_OnceOnly());
ea.Initialize(selectiveEvaluator, genomeFactory, genomeList);
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);
}
/// <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="genomeFactory">The genome factory initialized by the main evolution thread.</param>
/// <param name="mazeEnvironment">The maze on which to evaluate the navigators.</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>
public override void InitializeAlgorithm(ParallelOptions parallelOptions, List <NeatGenome> genomeList,
IGenomeFactory <NeatGenome> genomeFactory, MazeStructure mazeEnvironment,
IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder, ulong startingEvaluations)
{
// Set the boiler plate algorithm parameters
base.InitializeAlgorithm(parallelOptions, genomeList, genomeDecoder, startingEvaluations);
// Create the initialization evolution algorithm.
InitializationEa = new SteadyStateComplexifyingEvolutionAlgorithm <NeatGenome>(EvolutionAlgorithmParameters,
SpeciationStrategy, ComplexityRegulationStrategy, _batchSize, _populationEvaluationFrequency,
RunPhase.Initialization, NavigatorEvolutionDataLogger, NavigatorEvolutionLogFieldEnableMap,
NavigatorPopulationDataLogger, PopulationLoggingBatchInterval);
// Create IBlackBox evaluator.
MazeNavigatorNoveltySearchInitializationEvaluator mazeNavigatorEvaluator =
new MazeNavigatorNoveltySearchInitializationEvaluator(MinSuccessDistance,
MaxDistanceToTarget, mazeEnvironment, _behaviorCharacterizationFactory, startingEvaluations);
// Create a novelty archive
AbstractNoveltyArchive <NeatGenome> archive =
new BehavioralNoveltyArchive <NeatGenome>(_archiveAdditionThreshold,
_archiveThresholdDecreaseMultiplier, _archiveThresholdIncreaseMultiplier,
_maxGenerationArchiveAddition, _maxGenerationsWithoutArchiveAddition);
// Create the genome evaluator
IGenomeEvaluator <NeatGenome> fitnessEvaluator =
new ParallelGenomeBehaviorEvaluator <NeatGenome, IBlackBox>(genomeDecoder, mazeNavigatorEvaluator,
SearchType.NoveltySearch, _nearestNeighbors);
// Only pull the number of genomes from the list equivalent to the initialization algorithm population size
// (this is to handle the case where the list was created in accordance with the primary algorithm
// population size, which is quite likely larger)
genomeList = genomeList.Take(PopulationSize).ToList();
// Replace genome factory primary NEAT parameters with initialization parameters
((NeatGenomeFactory)genomeFactory).ResetNeatGenomeParameters(NeatGenomeParameters);
// Initialize the evolution algorithm
InitializationEa.Initialize(fitnessEvaluator, genomeFactory, genomeList, null, null, archive);
}
/// <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);
}
public NeatExperiment(Simulation simulation)
{
_simulation = simulation;
_name = "Trader";
_populationSize = 100;
_specieCount = 1;
_activationScheme = NetworkActivationScheme.CreateAcyclicScheme();
_complexityRegulationStr = "Relative";
_complexityThreshold = 10;
_description = "Generate trader neural network";
_parallelOptions = new ParallelOptions {
MaxDegreeOfParallelism = 2
};
UnityThread.SetUnityValue(() => _inputCount = 6 + UnityEngine.Object.FindObjectsOfType <Coin>().Length * 5);
_outputCount = 8;
_eaParams = new NeatEvolutionAlgorithmParameters();
_eaParams.SpecieCount = _specieCount;
_neatGenomeParams = new NeatGenomeParameters();
_neatGenomeParams.FeedforwardOnly = _activationScheme.AcyclicNetwork;
//_neatGenomeParams.ActivationFn = LeakyReLU.__DefaultInstance;
_neatGenomeParams.ActivationFn = SharpNeat.Network.SReLU.__DefaultInstance;
// Create a genome factory with our neat genome parameters object and the appropriate number of input and output neuron genes.
_genomeFactory = CreateGenomeFactory();
// Create an initial population of randomly generated genomes.
_genomeList = _genomeFactory.CreateGenomeList(_populationSize, 0);
// Create evolution algorithm and attach update event.
_ea = CreateEvolutionAlgorithm(_genomeFactory, _genomeList);
// _ea.UpdateEvent += new EventHandler(ea_UpdateEvent);
// Start algorithm (it will run on a background thread).
_ea.StartContinue();
}
/// <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)
{
// Create complexity regulation strategy.
var complexityRegulationStrategy =
ExperimentUtils.CreateComplexityRegulationStrategy(ComplexityRegulationStrategy, Complexitythreshold);
// Create the evolution algorithm.
AbstractNeatEvolutionAlgorithm<NeatGenome> ea =
new QueueingNeatEvolutionAlgorithm<NeatGenome>(NeatEvolutionAlgorithmParameters,
new ParallelKMeansClusteringStrategy<NeatGenome>(new ManhattanDistanceMetric(1.0, 0.0, 10.0),
ParallelOptions),
complexityRegulationStrategy, _batchSize, RunPhase.Primary);
// Create IBlackBox evaluator.
IPhenomeEvaluator<IBlackBox, FitnessInfo> mazeNavigationEvaluator =
new MazeNavigationRandomEvaluator(MaxDistanceToTarget, MaxTimesteps,
MazeVariant, MinSuccessDistance);
// Create genome decoder.
IGenomeDecoder<NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder();
IGenomeEvaluator<NeatGenome> fitnessEvaluator =
new SerialGenomeFitnessEvaluator<NeatGenome, IBlackBox>(genomeDecoder, mazeNavigationEvaluator,
_evaluationDataLogger);
// IGenomeEvaluator<NeatGenome> fitnessEvaluator =
// new ParallelGenomeFitnessEvaluator<NeatGenome, IBlackBox>(genomeDecoder, mazeNavigationEvaluator,
// _evaluationDataLogger, SerializeGenomeToXml);
// Initialize the evolution algorithm.
ea.Initialize(fitnessEvaluator, genomeFactory, genomeList, DefaultPopulationSize,
null, MaxEvaluations);
// 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();
// 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 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;
}
public abstract NeatEvolutionAlgorithm<NeatGenome> CreateEvolutionAlgorithm(
IGenomeFactory<NeatGenome> genomeFactory,
List<NeatGenome> genomeList);
public NeatInteractiveEvolutionAlgorithm<NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory<NeatGenome> genomeFactory, List<NeatGenome> genomeList)
{
_genomeDecoder = CreateGenomeDecoder();
var ea = new NeatInteractiveEvolutionAlgorithm< NeatGenome>(_eaParams);
ea.Initialize(genomeList);
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 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 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>
/// Construct a population.
/// </summary>
/// <param name="thePopulationSize"></param>
/// <param name="theGenomeFactory"></param>
public BasicPopulation(int thePopulationSize,
IGenomeFactory theGenomeFactory)
{
PopulationSize = thePopulationSize;
GenomeFactory = theGenomeFactory;
}
/// <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;
}
/// <summary>
/// Evolves the requisite number of agents who satisfy the MC of the given maze.
/// </summary>
/// <param name="genomeFactory">The agent genome factory.</param>
/// <param name="seedAgentList">The seed population of agents.</param>
/// <param name="mazeStructure">The maze structure on which agents are to be evaluated.</param>
/// <returns></returns>
private List<NeatGenome> EvolveViableAgents(IGenomeFactory<NeatGenome> genomeFactory,
List<NeatGenome> seedAgentList, MazeStructure mazeStructure)
{
List<NeatGenome> viableMazeAgents;
uint restartCount = 0;
ulong initializationEvaluations;
do
{
// Instantiate the internal initialization algorithm
_mazeNavigationInitializer.InitializeAlgorithm(ParallelOptions, seedAgentList.ToList(), genomeFactory,
mazeStructure, new NeatGenomeDecoder(ActivationScheme), 0);
// Run the initialization algorithm until the requested number of viable seed genomes are found
viableMazeAgents = _mazeNavigationInitializer.EvolveViableGenomes(out initializationEvaluations,
_maxInitializationEvaluations, restartCount);
restartCount++;
// Repeat if maximum allotted evaluations is exceeded
} while (_maxInitializationEvaluations != null && viableMazeAgents == null &&
initializationEvaluations > _maxInitializationEvaluations);
return viableMazeAgents;
}
/// <summary>
/// Creates the evolution algorithm container using the given factories and genome lists.
/// </summary>
/// <param name="genomeFactory1">The agent genome factory.</param>
/// <param name="genomeFactory2">The maze genome factory.</param>
/// <param name="genomeList1">The agent genome list.</param>
/// <param name="genomeList2">The maze genome list.</param>
/// <returns>The instantiated coevolution algorithm container.</returns>
public override ICoevolutionAlgorithmContainer<NeatGenome, MazeGenome> CreateCoevolutionAlgorithmContainer(
IGenomeFactory<NeatGenome> genomeFactory1,
IGenomeFactory<MazeGenome> genomeFactory2, List<NeatGenome> genomeList1, List<MazeGenome> genomeList2)
{
List<NeatGenome> seedAgentPopulation = new List<NeatGenome>();
// Compute the maze max complexity
((MazeGenomeFactory) genomeFactory2).MaxComplexity = MazeUtils.DetermineMaxPartitions(_mazeHeight,
_mazeWidth, 200);
// Create maze decoder to decode initialization mazes
MazeDecoder mazeDecoder = new MazeDecoder(_mazeHeight, _mazeWidth, _mazeScaleMultiplier);
// Loop through every maze and evolve the requisite number of viable genomes that solve it
for (int idx = 0; idx < genomeList2.Count; idx++)
{
Console.WriteLine(@"Evolving viable agents for maze population index {0} and maze ID {1}", idx,
genomeList2[idx].Id);
// Evolve the number of agents required to meet the success MC for the current maze
List<NeatGenome> viableMazeAgents = EvolveViableAgents(genomeFactory1, genomeList1.ToList(),
mazeDecoder.Decode(genomeList2[idx]));
// Add the viable agent genomes who solve the current maze (but avoid adding duplicates, as identified by the genome ID)
// Note that it's fine to have multiple mazes solved by the same agent, so in this case, we'll leave the agent
// in the pool of seed agent genomes
foreach (
NeatGenome viableMazeAgent in
viableMazeAgents.Where(
viableMazeAgent =>
seedAgentPopulation.Select(sap => sap.Id).Contains(viableMazeAgent.Id) == false))
{
seedAgentPopulation.Add(viableMazeAgent);
}
}
// If we still lack the genomes to fill out agent specie count while still satisfying the maze MC,
// iteratively pick a random maze and evolve agents on that maze until we reach the requisite number
while (seedAgentPopulation.ToList().Count < _numAgentSuccessCriteria*AgentNumSpecies)
{
FastRandom rndMazePicker = new FastRandom();
// Pick a random maze on which to evolve agent(s)
MazeGenome mazeGenome = genomeList2[rndMazePicker.Next(genomeList2.Count - 1)];
Console.WriteLine(
@"Continuing viable agent evolution on maze {0}, with {1} of {2} required agents in place",
mazeGenome.Id, seedAgentPopulation.Count, (_numAgentSuccessCriteria*AgentNumSpecies));
// Evolve the number of agents required to meet the success MC for the maze
List<NeatGenome> viableMazeAgents = EvolveViableAgents(genomeFactory1, genomeList1.ToList(),
mazeDecoder.Decode(mazeGenome));
// Iterate through each viable agent and remove them if they've already solved a maze or add them to the list
// of viable agents if they have not
foreach (NeatGenome viableMazeAgent in viableMazeAgents)
{
// If they agent has already solved maze and is in the list of viable agents, remove that agent
// from the pool of seed genomes (this is done because here, we're interested in getting unique
// agents and want to avoid an endless loop wherein the same viable agents are returned)
if (seedAgentPopulation.Select(sap => sap.Id).Contains(viableMazeAgent.Id))
{
genomeList1.Remove(viableMazeAgent);
}
// Otherwise, add that agent to the list of viable agents
else
{
seedAgentPopulation.Add(viableMazeAgent);
}
}
}
// Set dummy fitness so that seed maze(s) will be marked as evaluated
foreach (MazeGenome mazeGenome in genomeList2)
{
mazeGenome.EvaluationInfo.SetFitness(0);
}
// Reset primary NEAT genome parameters on agent genome factory
((NeatGenomeFactory) genomeFactory1).ResetNeatGenomeParameters(NeatGenomeParameters);
// Create the NEAT (i.e. navigator) queueing evolution algorithm
AbstractEvolutionAlgorithm<NeatGenome> neatEvolutionAlgorithm =
new MultiQueueNeatEvolutionAlgorithm<NeatGenome>(
new NeatEvolutionAlgorithmParameters
{
SpecieCount = AgentNumSpecies,
MaxSpecieSize = AgentDefaultPopulationSize/AgentNumSpecies
},
new ParallelKMeansClusteringStrategy<NeatGenome>(new ManhattanDistanceMetric(1.0, 0.0, 10.0),
ParallelOptions), null, NavigatorBatchSize, RunPhase.Primary, _navigatorEvolutionDataLogger,
_navigatorLogFieldEnableMap, _navigatorPopulationGenomesDataLogger, _populationLoggingBatchInterval);
// Create the maze queueing evolution algorithm
AbstractEvolutionAlgorithm<MazeGenome> mazeEvolutionAlgorithm =
new MultiQueueNeatEvolutionAlgorithm<MazeGenome>(
new NeatEvolutionAlgorithmParameters
{
SpecieCount = MazeNumSpecies,
MaxSpecieSize = MazeDefaultPopulationSize/MazeNumSpecies
},
new ParallelKMeansClusteringStrategy<MazeGenome>(new ManhattanDistanceMetric(1.0, 0.0, 10.0),
ParallelOptions), null, MazeBatchSize, RunPhase.Primary, _mazeEvolutionDataLogger,
_mazeLogFieldEnableMap, _mazePopulationGenomesDataLogger, _populationLoggingBatchInterval);
// Create the maze phenome evaluator
IPhenomeEvaluator<MazeStructure, BehaviorInfo> mazeEvaluator = new MazeEnvironmentMCSEvaluator(
_maxTimesteps, _minSuccessDistance, BehaviorCharacterizationFactory, _numAgentSuccessCriteria, 0);
// Create navigator phenome evaluator
IPhenomeEvaluator<IBlackBox, BehaviorInfo> navigatorEvaluator = new MazeNavigatorMCSEvaluator(
_maxTimesteps, _minSuccessDistance, BehaviorCharacterizationFactory, _numMazeSuccessCriteria);
// Create maze genome decoder
IGenomeDecoder<MazeGenome, MazeStructure> mazeGenomeDecoder = new MazeDecoder(_mazeHeight, _mazeWidth,
_mazeScaleMultiplier);
// Create navigator genome decoder
IGenomeDecoder<NeatGenome, IBlackBox> navigatorGenomeDecoder = new NeatGenomeDecoder(ActivationScheme);
// Create the maze genome evaluator
IGenomeEvaluator<MazeGenome> mazeFitnessEvaluator =
new ParallelGenomeBehaviorEvaluator<MazeGenome, MazeStructure>(mazeGenomeDecoder, mazeEvaluator,
SelectionType.Queueing, SearchType.MinimalCriteriaSearch, ParallelOptions);
// Create navigator genome evaluator
IGenomeEvaluator<NeatGenome> navigatorFitnessEvaluator =
new ParallelGenomeBehaviorEvaluator<NeatGenome, IBlackBox>(navigatorGenomeDecoder, navigatorEvaluator,
SelectionType.Queueing, SearchType.MinimalCriteriaSearch, ParallelOptions);
// Create the coevolution container
ICoevolutionAlgorithmContainer<NeatGenome, MazeGenome> coevolutionAlgorithmContainer =
new CoevolutionAlgorithmContainer<NeatGenome, MazeGenome>(neatEvolutionAlgorithm, mazeEvolutionAlgorithm);
// Initialize the container and component algorithms
coevolutionAlgorithmContainer.Initialize(navigatorFitnessEvaluator, genomeFactory1, seedAgentPopulation,
AgentDefaultPopulationSize, mazeFitnessEvaluator, genomeFactory2, genomeList2, MazeDefaultPopulationSize,
MaxGenerations, MaxEvaluations);
return coevolutionAlgorithmContainer;
}
private void loadSeedGenomesToolStripMenuItem_Click(object sender, EventArgs e)
{
string popFilePath = SelectFileToOpen("Load seed genomes", "pop.xml", "(*.pop.xml)|*.pop.xml");
if(string.IsNullOrEmpty(popFilePath)) {
return;
}
// Parse population size from GUI field.
int? popSize = ParseInt(txtParamPopulationSize);
if(null == popSize) {
return;
}
try
{
// Get the currently selected experiment.
INeatExperiment experiment = GetSelectedExperiment();
// Load genome from file.
List<NeatGenome> genomeList;
using(XmlReader xr = XmlReader.Create(popFilePath))
{
genomeList = experiment.LoadPopulation(xr);
}
if(genomeList.Count == 0) {
__log.WarnFormat("No seed genomes loaded from file [{0}]", popFilePath);
return;
}
// Create genome list from seed genomes, assign to local variables and update GUI.
_genomeFactory = genomeList[0].GenomeFactory;
_genomeList = _genomeFactory.CreateGenomeList(popSize.Value, 0u, genomeList);
UpdateGuiState();
}
catch(Exception ex)
{
__log.ErrorFormat("Error loading seed genomes. Error message [{0}]", ex.Message);
}
}
private void btnSearchReset_Click(object sender, EventArgs e)
{
_genomeFactory = null;
_genomeList = null;
// TODO: Proper cleanup of EA - e.g. main worker thread termination.
_ea = null;
_champGenomeFitness = 0.0;
Logger.Clear();
UpdateGuiState_ResetStats();
UpdateGuiState();
}
private void btnCreateRandomPop_Click(object sender, EventArgs e)
{
// Parse population size and interconnection proportion from GUI fields.
int? popSize = ParseInt(txtParamPopulationSize);
if(null == popSize) {
return;
}
double? initConnProportion = ParseDouble(txtParamInitialConnectionProportion);
if(null == initConnProportion) {
return;
}
INeatExperiment experiment = GetSelectedExperiment();
experiment.NeatGenomeParameters.InitialInterconnectionsProportion = initConnProportion.Value;
// Create a genome factory appropriate for the experiment.
IGenomeFactory<NeatGenome> genomeFactory = experiment.CreateGenomeFactory();
// Create an initial population of randomly generated genomes.
List<NeatGenome> genomeList = genomeFactory.CreateGenomeList(popSize.Value, 0u);
// Assign population to form variables & update GUI appropriately.
_genomeFactory = genomeFactory;
_genomeList = genomeList;
UpdateGuiState();
}
/// <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="genomeFactory">The genome factory initialized by the main evolution thread.</param>
/// <param name="mazeEnvironment">The maze on which to evaluate the navigators.</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>
public override void InitializeAlgorithm(ParallelOptions parallelOptions, List<NeatGenome> genomeList,
IGenomeFactory<NeatGenome> genomeFactory,
MazeStructure mazeEnvironment, IGenomeDecoder<NeatGenome, IBlackBox> genomeDecoder,
ulong startingEvaluations)
{
// Set the boiler plate algorithm parameters
base.InitializeAlgorithm(parallelOptions, genomeList, genomeDecoder, startingEvaluations);
// Create the initialization evolution algorithm.
InitializationEa = new GenerationalNeatEvolutionAlgorithm<NeatGenome>(SpeciationStrategy,
ComplexityRegulationStrategy, RunPhase.Initialization);
// Create IBlackBox evaluator.
MazeNavigatorFitnessInitializationEvaluator mazeNavigatorEvaluator =
new MazeNavigatorFitnessInitializationEvaluator(MaxTimesteps, MinSuccessDistance, MaxDistanceToTarget,
mazeEnvironment, startingEvaluations);
// Create the genome evaluator
IGenomeEvaluator<NeatGenome> fitnessEvaluator = new ParallelGenomeFitnessEvaluator<NeatGenome, IBlackBox>(
genomeDecoder, mazeNavigatorEvaluator, parallelOptions);
// Only pull the number of genomes from the list equivalent to the initialization algorithm population size
// (this is to handle the case where the list was created in accordance with the primary algorithm
// population size, which is quite likely larger)
genomeList = genomeList.Take(PopulationSize).ToList();
// Replace genome factory primary NEAT parameters with initialization parameters
((NeatGenomeFactory) genomeFactory).ResetNeatGenomeParameters(NeatGenomeParameters);
// Initialize the evolution algorithm
InitializationEa.Initialize(fitnessEvaluator, genomeFactory, genomeList, null, null);
}
/// <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>
/// 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;
}
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);
return ea;
}
private void loadPopulationToolStripMenuItem_Click(object sender, EventArgs e)
{
string popFilePath = SelectFileToOpen("Load population", "pop.xml", "(*.pop.xml)|*.pop.xml");
if(string.IsNullOrEmpty(popFilePath)) {
return;
}
try
{
// Get the currently selected experiment.
INeatExperiment experiment = GetSelectedExperiment();
// Load population of genomes from file.
List<NeatGenome> genomeList;
using(XmlReader xr = XmlReader.Create(popFilePath))
{
genomeList = experiment.LoadPopulation(xr);
}
if(genomeList.Count == 0) {
__log.WarnFormat("No genomes loaded from population file [{0}]", popFilePath);
return;
}
// Assign genome list and factory to class variables and update GUI.
_genomeFactory = genomeList[0].GenomeFactory;
_genomeList = genomeList;
UpdateGuiState();
}
catch(Exception ex)
{
__log.ErrorFormat("Error loading population. Error message [{0}]", ex.Message);
}
}
/// <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);
// 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;
}
