/// <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)
{
// Extract the specified number of seed genomes from the randomly generated population
List<NeatGenome> seedPopulation = genomeList.Take(SeedGenomeCount).ToList();
// 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),
true, _evolutionDataLogger, _experimentLogFieldEnableMap, null, null, false,
_minimalCriteriaUpdateInterval);
// Create IBlackBox evaluator.
IPhenomeEvaluator<IBlackBox, BehaviorInfo> mazeNavigationEvaluator =
new MazeNavigationMCSEvaluator(MaxDistanceToTarget, MaxTimesteps,
MazeVariant, MinSuccessDistance, _behaviorCharacterizationFactory, _bridgingMagnitude,
_bridgingApplications);
// 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;
}
/// <summary>
/// Create and return a GenerationalNeatEvolutionAlgorithm object (specific to fitness-based evaluations) ready for
/// running the
/// NEAT algorithm/search based on the given genome factory and genome list. Various sub-parts of the algorithm are
/// also constructed and connected up.
/// </summary>
/// <param name="genomeFactory">The genome factory from which to generate new genomes</param>
/// <param name="genomeList">The current genome population</param>
/// <param name="startingEvaluations">The number of evaluations that have been executed prior to the current run.</param>
/// <returns>Constructed evolutionary algorithm</returns>
public override INeatEvolutionAlgorithm<NeatGenome> CreateEvolutionAlgorithm(
IGenomeFactory<NeatGenome> genomeFactory,
List<NeatGenome> genomeList, ulong startingEvaluations)
{
// Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference.
IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
ISpeciationStrategy<NeatGenome> speciationStrategy =
new ParallelKMeansClusteringStrategy<NeatGenome>(distanceMetric, ParallelOptions);
// Create complexity regulation strategy.
var complexityRegulationStrategy =
ExperimentUtils.CreateComplexityRegulationStrategy(ComplexityRegulationStrategy, Complexitythreshold);
// Create the evolution algorithm.
var ea = new GenerationalNeatEvolutionAlgorithm<NeatGenome>(NeatEvolutionAlgorithmParameters,
speciationStrategy,
complexityRegulationStrategy);
// Create IBlackBox evaluator.
var mazeNavigationEvaluator = new MazeNavigationNoveltyEvaluator(MaxDistanceToTarget, MaxTimesteps,
MazeVariant,
MinSuccessDistance, _behaviorCharacterizationFactory);
// Create genome decoder.
var genomeDecoder = CreateGenomeDecoder();
// Create a novelty archive.
AbstractNoveltyArchive<NeatGenome> archive =
new BehavioralNoveltyArchive<NeatGenome>(_archiveAdditionThreshold,
_archiveThresholdDecreaseMultiplier, _archiveThresholdIncreaseMultiplier,
_maxGenerationArchiveAddition, _maxGenerationsWithoutArchiveAddition);
// Create a genome list evaluator. This packages up the genome decoder with the genome evaluator.
// IGenomeFitnessEvaluator<NeatGenome> fitnessEvaluator =
// new SerialGenomeBehaviorEvaluator<NeatGenome, IBlackBox>(genomeDecoder, mazeNavigationEvaluator, _nearestNeighbors, archive);
IGenomeEvaluator<NeatGenome> fitnessEvaluator =
new ParallelGenomeBehaviorEvaluator<NeatGenome, IBlackBox>(genomeDecoder, mazeNavigationEvaluator,
SelectionType.Generational, SearchType.NoveltySearch,
ParallelOptions, _nearestNeighbors, archive);
// Initialize the evolution algorithm.
ea.Initialize(fitnessEvaluator, genomeFactory, genomeList, MaxGenerations, null, archive);
// Finished. Return the evolution algorithm
return ea;
}
/// <summary>
/// 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 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.
AbstractNeatEvolutionAlgorithm<NeatGenome> ea =
new SteadyStateNeatEvolutionAlgorithm<NeatGenome>(NeatEvolutionAlgorithmParameters,
speciationStrategy, complexityRegulationStrategy, _batchSize, _populationEvaluationFrequency,
RunPhase.Primary, _evolutionDataLogger);
// Create IBlackBox evaluator.
MazeNavigationMCSEvaluator mazeNavigationEvaluator = new MazeNavigationMCSEvaluator(MaxDistanceToTarget,
MaxTimesteps,
MazeVariant,
MinSuccessDistance, _behaviorCharacterizationFactory);
// Create genome decoder.
var genomeDecoder = CreateGenomeDecoder();
// IGenomeEvaluator<NeatGenome> fitnessEvaluator =
// new SerialGenomeBehaviorEvaluator<NeatGenome, IBlackBox>(genomeDecoder, mazeNavigationEvaluator,
// SearchType.MinimalCriteriaSearch);
IGenomeEvaluator<NeatGenome> fitnessEvaluator =
new ParallelGenomeBehaviorEvaluator<NeatGenome, IBlackBox>(genomeDecoder, mazeNavigationEvaluator,
SelectionType.SteadyState, SearchType.MinimalCriteriaSearch, _evaluationDataLogger);
// Initialize the evolution algorithm.
ea.Initialize(fitnessEvaluator, genomeFactory, genomeList, null, MaxEvaluations);
// 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>
/// 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;
}
/// <inheritdoc />
/// <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>
/// <param name="isAgentListPreevolved">
/// Indicates whether the given agents have been pre-evolved to satisfy the MC with
/// respect to the maze population.
/// </param>
/// <returns>The instantiated MCC algorithm container.</returns>
public override IMCCAlgorithmContainer <NeatGenome, MazeGenome> CreateMCCAlgorithmContainer(
IGenomeFactory <NeatGenome> genomeFactory1, IGenomeFactory <MazeGenome> genomeFactory2,
List <NeatGenome> genomeList1, List <MazeGenome> genomeList2, bool isAgentListPreevolved)
{
// Either use pre-evolved agents or evolve the seed agents that meet the MC
var seedAgentPopulation = isAgentListPreevolved
? genomeList1
: EvolveSeedAgents(genomeList1, genomeList2, genomeFactory1, AgentSeedGenomeCount);
// Set dummy fitness so that seed maze(s) will be marked as evaluated
foreach (var mazeGenome in genomeList2)
{
mazeGenome.EvaluationInfo.SetFitness(0);
}
// Create the NEAT evolution algorithm parameters
var neatEaParams = new EvolutionAlgorithmParameters
{
SpecieCount = AgentNumSpecies,
MaxSpecieSize =
AgentNumSpecies > 0
? AgentDefaultPopulationSize / AgentNumSpecies
: AgentDefaultPopulationSize
};
// Create the maze evolution algorithm parameters
var mazeEaParams = new EvolutionAlgorithmParameters
{
SpecieCount = MazeNumSpecies,
MaxSpecieSize =
MazeNumSpecies > 0 ? MazeDefaultPopulationSize / MazeNumSpecies : MazeDefaultPopulationSize
};
// Create the NEAT (i.e. navigator) queueing evolution algorithm
AbstractEvolutionAlgorithm <NeatGenome> neatEvolutionAlgorithm = new QueueEvolutionAlgorithm <NeatGenome>(
neatEaParams, new NeatAlgorithmStats(neatEaParams), null, NavigatorBatchSize, RunPhase.Primary,
_navigatorEvolutionDataLogger, _navigatorLogFieldEnableMap, _navigatorPopulationDataLogger,
_navigatorGenomeDataLogger, _populationLoggingBatchInterval);
// Create the maze queueing evolution algorithm
AbstractEvolutionAlgorithm <MazeGenome> mazeEvolutionAlgorithm = new QueueEvolutionAlgorithm <MazeGenome>(
mazeEaParams, new MazeAlgorithmStats(mazeEaParams), null, MazeBatchSize, RunPhase.Primary,
_mazeEvolutionDataLogger, _mazeLogFieldEnableMap, _mazePopulationDataLogger, _mazeGenomeDataLogger,
_populationLoggingBatchInterval);
// Create the maze phenome evaluator
IPhenomeEvaluator <MazeStructure, BehaviorInfo> mazeEvaluator =
new MazeEnvironmentMCCEvaluator(MinSuccessDistance, BehaviorCharacterizationFactory,
NumAgentSuccessCriteria, NumAgentFailedCriteria);
// Create navigator phenome evaluator
IPhenomeEvaluator <IBlackBox, BehaviorInfo> navigatorEvaluator =
new MazeNavigatorMCCEvaluator(MinSuccessDistance, BehaviorCharacterizationFactory,
NumMazeSuccessCriteria);
// Create maze genome decoder
IGenomeDecoder <MazeGenome, MazeStructure> mazeGenomeDecoder = new MazeDecoder(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, SearchType.MinimalCriteriaSearch, ParallelOptions);
// Create navigator genome evaluator
IGenomeEvaluator <NeatGenome> navigatorFitnessEvaluator =
new ParallelGenomeBehaviorEvaluator <NeatGenome, IBlackBox>(navigatorGenomeDecoder, navigatorEvaluator, SearchType.MinimalCriteriaSearch, ParallelOptions);
// Verify that the seed agent population satisfies MC constraints of both populations so that MCC starts in
// a valid state
if (isAgentListPreevolved &&
VerifyPreevolvedSeedAgents(genomeList1, genomeList2, navigatorFitnessEvaluator, mazeFitnessEvaluator) ==
false)
{
throw new SharpNeatException("Seed agent population failed viability verification.");
}
// Create the MCC container
IMCCAlgorithmContainer <NeatGenome, MazeGenome> mccAlgorithmContainer =
new MCCAlgorithmContainer <NeatGenome, MazeGenome>(neatEvolutionAlgorithm, mazeEvolutionAlgorithm);
// Initialize the container and component algorithms
mccAlgorithmContainer.Initialize(navigatorFitnessEvaluator, genomeFactory1, seedAgentPopulation,
AgentDefaultPopulationSize, mazeFitnessEvaluator, genomeFactory2, genomeList2,
MazeDefaultPopulationSize,
MaxGenerations, MaxEvaluations);
return(mccAlgorithmContainer);
}
/// <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="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 void InitializeAlgorithm(ParallelOptions parallelOptions, List<NeatGenome> genomeList,
IGenomeFactory<NeatGenome> genomeFactory, 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 SteadyStateNeatEvolutionAlgorithm<NeatGenome>(NeatEvolutionAlgorithmParameters,
SpeciationStrategy, ComplexityRegulationStrategy, _batchSize, _populationEvaluationFrequency,
RunPhase.Initialization, _evolutionDataLogger, _initializationLogFieldEnableMap);
// Create IBlackBox evaluator.
MazeNavigationMCSInitializationEvaluator mazeNavigationEvaluator =
new MazeNavigationMCSInitializationEvaluator(MaxDistanceToTarget, MaxTimesteps,
_mazeVariant,
MinSuccessDistance, _behaviorCharacterizationFactory, startingEvaluations);
// Create a novelty archive.
AbstractNoveltyArchive<NeatGenome> archive =
new BehavioralNoveltyArchive<NeatGenome>(_archiveAdditionThreshold,
_archiveThresholdDecreaseMultiplier, _archiveThresholdIncreaseMultiplier,
_maxGenerationArchiveAddition, _maxGenerationsWithoutArchiveAddition);
// IGenomeEvaluator<NeatGenome> fitnessEvaluator =
// new SerialGenomeBehaviorEvaluator<NeatGenome, IBlackBox>(genomeDecoder, mazeNavigationEvaluator,
// SelectionType.SteadyState, SearchType.NoveltySearch,
// _nearestNeighbors, archive, _evaluationDataLogger, _serializeGenomeToXml);
IGenomeEvaluator<NeatGenome> fitnessEvaluator =
new ParallelGenomeBehaviorEvaluator<NeatGenome, IBlackBox>(genomeDecoder, mazeNavigationEvaluator,
SelectionType.SteadyState, SearchType.NoveltySearch,
_nearestNeighbors, archive, _evaluationDataLogger, _serializeGenomeToXml);
// 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 could have been 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, PopulationSize, null,
_maxEvaluations + startingEvaluations,
archive);
}
/// <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>
/// <returns>Constructed evolutionary algorithm</returns>
public override 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.
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, logger);
// Create IBlackBox evaluator.
var mazeNavigationEvaluator = new MazeNavigationNoveltyEvaluator(MaxDistanceToTarget, MaxTimesteps,
MazeVariant,
MinSuccessDistance, _behaviorCharacterization);
// 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,
_nearestNeighbors, archive);
// Initialize the evolution algorithm.
ea.Initialize(fitnessEvaluator, genomeFactory, genomeList, archive);
// Finished. Return the evolution algorithm
return ea;
}
