public virtual void Initialize(string name, XmlElement xmlConfig)
{
_name = name;
_populationSize = XmlUtils.GetValueAsInt(xmlConfig, "PopulationSize");
_specieCount = XmlUtils.GetValueAsInt(xmlConfig, "SpecieCount");
_activationScheme = ExperimentUtils.CreateActivationScheme(xmlConfig, "Activation");
_complexityRegulationStr = XmlUtils.TryGetValueAsString(xmlConfig,
"DefaultComplexityRegulationStrategy");
_complexityThreshold = XmlUtils.TryGetValueAsInt(xmlConfig, "ComplexityThreshold");
_description = XmlUtils.TryGetValueAsString(xmlConfig, "Description");
_parallelOptions = ExperimentUtils.ReadParallelOptions(xmlConfig);
_eaParams = new NeatEvolutionAlgorithmParameters();
_eaParams.SpecieCount = _specieCount;
_neatGenomeParams = new NeatGenomeParameters();
_neatGenomeParams.FeedforwardOnly = _activationScheme.AcyclicNetwork;
DefaultComplexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(
_complexityRegulationStr,
_complexityThreshold);
DefaultSpeciationStrategy = new KMeansClusteringStrategy<NeatGenome>(new ManhattanDistanceMetric(1.0, 0.0, 10.0));
DefaultNeatEvolutionAlgorithm = new NeatEvolutionAlgorithm<NeatGenome>(
NeatEvolutionAlgorithmParameters,
DefaultSpeciationStrategy,
DefaultComplexityRegulationStrategy);
}
public virtual void Initialize(string name, XmlElement xmlConfig)
{
_name = name;
_populationSize = XmlUtils.GetValueAsInt(xmlConfig, "PopulationSize");
_specieCount = XmlUtils.GetValueAsInt(xmlConfig, "SpecieCount");
_activationScheme = ExperimentUtils.CreateActivationScheme(xmlConfig, "Activation");
_complexityRegulationStr = XmlUtils.TryGetValueAsString(xmlConfig,
"DefaultComplexityRegulationStrategy");
_complexityThreshold = XmlUtils.TryGetValueAsInt(xmlConfig, "ComplexityThreshold");
_description = XmlUtils.TryGetValueAsString(xmlConfig, "Description");
_parallelOptions = ExperimentUtils.ReadParallelOptions(xmlConfig);
_eaParams = new NeatEvolutionAlgorithmParameters();
_eaParams.SpecieCount = _specieCount;
_neatGenomeParams = new NeatGenomeParameters();
_neatGenomeParams.FeedforwardOnly = _activationScheme.AcyclicNetwork;
DefaultComplexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(
_complexityRegulationStr,
_complexityThreshold);
DefaultSpeciationStrategy = new KMeansClusteringStrategy <NeatGenome>(new ManhattanDistanceMetric(1.0, 0.0, 10.0));
DefaultNeatEvolutionAlgorithm = new NeatEvolutionAlgorithm <NeatGenome>(
NeatEvolutionAlgorithmParameters,
DefaultSpeciationStrategy,
DefaultComplexityRegulationStrategy);
}
public NeatSelectionReproductionStrategy(
ISpeciationStrategy <NeatGenome <T>, T> speciationStrategy,
int speciesCount,
IRandomSource rng)
{
_speciationStrategy = speciationStrategy;
_speciesCount = speciesCount;
_rng = rng;
}
public BraidNeatEvolutionAlgorithm(NeatEvolutionAlgorithmParameters eaParams,
ISpeciationStrategy <TGenome> speciationStrategy,
IComplexityRegulationStrategy complexityRegulationStrategy) : base(eaParams,
speciationStrategy,
complexityRegulationStrategy)
{
myLogger = new Logger(new MyLogger());
myLogger.Log(logTag, "Initialized: ");
}
/// <summary>
/// Construct a new instance.
/// </summary>
/// <param name="eaSettings">NEAT evolution algorithm settings.</param>
/// <param name="evaluator">An evaluator of lists of genomes.</param>
/// <param name="speciationStrategy">Speciation strategy.</param>
/// <param name="population">An initial population of genomes.</param>
/// <param name="complexityRegulationStrategy">Complexity regulation strategy.</param>
/// <param name="reproductionAsexualSettings">Asexual reproduction settings.</param>
/// <param name="reproductionSexualSettings">Sexual reproduction settings.</param>
/// <param name="weightMutationScheme">Connection weight mutation scheme.</param>
/// <param name="rng">Random source.</param>
public NeatEvolutionAlgorithm(
NeatEvolutionAlgorithmSettings eaSettings,
IGenomeListEvaluator <NeatGenome <T> > evaluator,
ISpeciationStrategy <NeatGenome <T>, T> speciationStrategy,
NeatPopulation <T> population,
IComplexityRegulationStrategy complexityRegulationStrategy,
NeatReproductionAsexualSettings reproductionAsexualSettings,
NeatReproductionSexualSettings reproductionSexualSettings,
WeightMutationScheme <T> weightMutationScheme,
IRandomSource rng)
{
_eaSettingsCurrent = eaSettings ?? throw new ArgumentNullException(nameof(eaSettings));
_eaSettingsComplexifying = eaSettings;
_eaSettingsSimplifying = eaSettings.CreateSimplifyingSettings();
_evaluator = evaluator ?? throw new ArgumentNullException(nameof(evaluator));
_speciationStrategy = speciationStrategy ?? throw new ArgumentNullException(nameof(speciationStrategy));
_pop = population ?? throw new ArgumentNullException(nameof(population));
_complexityRegulationStrategy = complexityRegulationStrategy ?? throw new ArgumentNullException(nameof(complexityRegulationStrategy));
if (reproductionAsexualSettings == null)
{
throw new ArgumentNullException(nameof(reproductionAsexualSettings));
}
if (reproductionSexualSettings == null)
{
throw new ArgumentNullException(nameof(reproductionSexualSettings));
}
_rng = rng;
_genomeComparerDescending = new GenomeComparerDescending(evaluator.FitnessComparer);
if (eaSettings.SpeciesCount > population.PopulationSize)
{
throw new ArgumentException("Species count is higher then the population size.");
}
_generationSeq = new Int32Sequence();
_reproductionAsexual = new NeatReproductionAsexual <T>(
_pop.MetaNeatGenome, _pop.GenomeBuilder,
_pop.GenomeIdSeq, population.InnovationIdSeq, _generationSeq,
_pop.AddedNodeBuffer, reproductionAsexualSettings, weightMutationScheme);
_reproductionSexual = new NeatReproductionSexual <T>(
_pop.MetaNeatGenome, _pop.GenomeBuilder,
_pop.GenomeIdSeq, _generationSeq,
reproductionSexualSettings);
_offspringBuilder = new OffspringBuilder <T>(
_reproductionAsexual,
_reproductionSexual,
eaSettings.InterspeciesMatingProportion,
evaluator.FitnessComparer);
}
/// <summary>
/// Constructs with the default NeatEvolutionAlgorithmParameters and speciation strategy
/// (KMeansClusteringStrategy with ManhattanDistanceMetric).
/// </summary>
public NeatEvolutionAlgorithm()
{
_eaParams = new NeatEvolutionAlgorithmParameters();
_eaParamsComplexifying = _eaParams;
_eaParamsSimplifying = _eaParams.CreateSimplifyingParameters();
_stats = new NeatAlgorithmStats(_eaParams);
_speciationStrategy = new KMeansClusteringStrategy <TGenome>(new ManhattanDistanceMetric());
_complexityRegulationMode = ComplexityRegulationMode.Complexifying;
_complexityRegulationStrategy = new NullComplexityRegulationStrategy();
}
public Module(int id, NeatEvolutionAlgorithmParameters evolutionAlgorithmParameters,
ISpeciationStrategy <NeatGenome> speciationStrategyPitch, ISpeciationStrategy <NeatGenome> speciationStrategyRhythm,
IComplexityRegulationStrategy complexityRegulationStrategyPitch, IComplexityRegulationStrategy complexityRegulationStrategyRhythm)
{
Name = "M" + id;
Id = id;
//RhythmEvolutionAlgorithm = new NeatEvolutionAlgorithm<NeatGenome>(evolutionAlgorithmParameters, speciationStrategyRhythm, complexityRegulationStrategyRhythm);
//PitchEvolutionAlgorithm = new NeatEvolutionAlgorithm<NeatGenome>(evolutionAlgorithmParameters, speciationStrategyPitch, complexityRegulationStrategyPitch);
RhythmEvolutionAlgorithm = new ModuleNeatEvolutionAlgorithm <NeatGenome>(Name + "_R", Id, evolutionAlgorithmParameters, speciationStrategyRhythm, complexityRegulationStrategyRhythm);
PitchEvolutionAlgorithm = new ModuleNeatEvolutionAlgorithm <NeatGenome>(Name + "_P", Id, evolutionAlgorithmParameters, speciationStrategyPitch, complexityRegulationStrategyPitch);
}
/// <summary>
/// Constructs with the provided NeatEvolutionAlgorithmParameters and ISpeciationStrategy.
/// </summary>
public NeatEvolutionAlgorithm(NeatEvolutionAlgorithmParameters eaParams,
ISpeciationStrategy <TGenome> speciationStrategy,
IComplexityRegulationStrategy complexityRegulationStrategy)
{
_eaParams = eaParams;
_eaParamsComplexifying = _eaParams;
_eaParamsSimplifying = _eaParams.CreateSimplifyingParameters();
_stats = new NeatAlgorithmStats(_eaParams);
_speciationStrategy = speciationStrategy;
_complexityRegulationMode = ComplexityRegulationMode.Complexifying;
_complexityRegulationStrategy = complexityRegulationStrategy;
}
/// <summary>
/// Construct a new instance.
/// </summary>
/// <param name="eaSettings">NEAT evolution algorithm settings.</param>
/// <param name="evaluator">An evaluator of lists of genomes.</param>
/// <param name="speciationStrategy">Speciation strategy.</param>
/// <param name="population">An initial population of genomes.</param>
/// <param name="reproductionAsexualSettings">Asexual reproduction settings.</param>
/// <param name="reproductionSexualSettings">Sexual reproduction settings.</param>
/// <param name="weightMutationScheme">Connection weight mutation scheme.</param>
public NeatEvolutionAlgorithm(
NeatEvolutionAlgorithmSettings eaSettings,
IGenomeListEvaluator <NeatGenome <T> > evaluator,
ISpeciationStrategy <NeatGenome <T>, T> speciationStrategy,
NeatPopulation <T> population,
NeatReproductionAsexualSettings reproductionAsexualSettings,
NeatReproductionSexualSettings reproductionSexualSettings,
WeightMutationScheme <T> weightMutationScheme)
: this(eaSettings, evaluator, speciationStrategy, population,
reproductionAsexualSettings, reproductionSexualSettings,
weightMutationScheme,
RandomDefaults.CreateRandomSource())
{
}
public ModuleNeatEvolutionAlgorithm(String name, int id,
NeatEvolutionAlgorithmParameters evolutionAlgorithmParameters,
ISpeciationStrategy <TGenome> speciationStrategy,
IComplexityRegulationStrategy complexityRegulationStrategy)
: base(evolutionAlgorithmParameters, speciationStrategy, complexityRegulationStrategy)
{
Name = name;
Id = id;
NextParasite = 0;
ParasiteGenomes = new List <TGenome> [MusicEnvironment.MODULE_COUNT - 1];
for (int i = 0; i < ParasiteGenomes.Length; i++)
{
ParasiteGenomes[i] = new List <TGenome>();
}
}
/// <summary>
/// Constructs with the default NeatEvolutionAlgorithmParameters and speciation strategy
/// (KMeansClusteringStrategy with ManhattanDistanceMetric).
/// </summary>
/*
* public NeatEvolutionAlgorithm()
* {
* _eaParams = new NeatEvolutionAlgorithmParameters();
* _eaParamsComplexifying = _eaParams;
* _eaParamsSimplifying = _eaParams.CreateSimplifyingParameters();
* _stats = new NeatAlgorithmStats(_eaParams);
* _speciationStrategy = new KMeansClusteringStrategy<TGenome>(new ManhattanDistanceMetric());
*
* _complexityRegulationMode = ComplexityRegulationMode.Complexifying;
* _complexityRegulationStrategy = new NullComplexityRegulationStrategy();
* }
*/
/// <summary>
/// Constructs with the provided NeatEvolutionAlgorithmParameters and ISpeciationStrategy.
/// </summary>
/*
* public NeatEvolutionAlgorithm(NeatEvolutionAlgorithmParameters eaParams,
* ISpeciationStrategy<TGenome> speciationStrategy,
* IComplexityRegulationStrategy complexityRegulationStrategy)
* {
* _eaParams = eaParams;
* _eaParamsComplexifying = _eaParams;
* _eaParamsSimplifying = _eaParams.CreateSimplifyingParameters();
* _stats = new NeatAlgorithmStats(_eaParams);
* _speciationStrategy = speciationStrategy;
*
* _complexityRegulationMode = ComplexityRegulationMode.Complexifying;
* _complexityRegulationStrategy = complexityRegulationStrategy;
* }
*/
public void Construct(NeatEvolutionAlgorithmParameters eaParams,
ISpeciationStrategy <TGenome> speciationStrategy,
IComplexityRegulationStrategy complexityRegulationStrategy,
IGenomeListEvaluator <TGenome> initialGenomeListEvaluator)
{
_eaParams = eaParams;
_eaParamsComplexifying = _eaParams;
_eaParamsSimplifying = _eaParams.CreateSimplifyingParameters();
_stats = new NeatAlgorithmStats(_eaParams);
_speciationStrategy = speciationStrategy;
_complexityRegulationMode = ComplexityRegulationMode.Complexifying;
_complexityRegulationStrategy = complexityRegulationStrategy;
_initialGenomeListEvaluator = initialGenomeListEvaluator;
}
public static void TestSpeciateAdd(
int popSize,
int inputNodeCount,
int outputNodeCount,
double connectionsProportion,
IDistanceMetric <double> distanceMetric,
ISpeciationStrategy <NeatGenome <double>, double> speciationStrategy,
IRandomSource rng,
bool validateNearestSpecies = true)
{
// Create population.
NeatPopulation <double> neatPop = CreateNeatPopulation(popSize, inputNodeCount, outputNodeCount, connectionsProportion);
// Split the population into three.
int popSize1 = popSize / 3;
int popSize2 = popSize / 3;
int popSize3 = popSize - (popSize1 + popSize2);
var genomeList1 = neatPop.GenomeList.GetRange(0, popSize1);
var genomeList2 = neatPop.GenomeList.GetRange(popSize1, popSize2);
var genomeList3 = neatPop.GenomeList.GetRange(popSize1 + popSize2, popSize3);
for (int i = 0; i < 6; i++)
{
int speciesCount = rng.Next(1, (neatPop.GenomeList.Count / 4) + 1);
var fullGenomeList = new List <NeatGenome <double> >(genomeList1);
// Invoke speciation strategy, and run tests
var speciesArr = speciationStrategy.SpeciateAll(genomeList1, speciesCount, rng);
ValidationTests(speciesArr, distanceMetric, speciesCount, fullGenomeList, validateNearestSpecies);
// Add second batch of genomes, and re-run tests.
speciationStrategy.SpeciateAdd(genomeList2, speciesArr, rng);
fullGenomeList.AddRange(genomeList2);
ValidationTests(speciesArr, distanceMetric, speciesCount, fullGenomeList, validateNearestSpecies);
// Add third batch of genomes, and re-run tests.
speciationStrategy.SpeciateAdd(genomeList3, speciesArr, rng);
fullGenomeList.AddRange(genomeList3);
ValidationTests(speciesArr, distanceMetric, speciesCount, fullGenomeList, validateNearestSpecies);
}
}
/// <summary>
/// Initialise (or re-initialise) the population species.
/// </summary>
/// <param name="speciationStrategy">The speciation strategy to use.</param>
/// <param name="speciesCount">The required number of species.</param>
/// <param name="rng">Random source.</param>
public void InitialiseSpecies(
ISpeciationStrategy <NeatGenome <T>, T> speciationStrategy,
int speciesCount,
IRandomSource rng)
{
// Allocate the genomes to species.
Species <T>[] speciesArr = speciationStrategy.SpeciateAll(this.GenomeList, speciesCount, rng);
if (null == speciesArr || speciesArr.Length != speciesCount)
{
throw new Exception("Species array is null or has incorrect length.");
}
this.SpeciesArray = speciesArr;
// Sort the genomes in each species. Highest fitness first, then secondary sorted by youngest genomes first.
foreach (Species <T> species in speciesArr)
{
SortUtils.SortUnstable(species.GenomeList, GenomeFitnessAndAgeComparer <T> .Singleton, rng);
}
}
/// <summary>
/// Initialise (or re-initialise) the population species.
/// </summary>
/// <param name="speciationStrategy">The speciation strategy to use.</param>
/// <param name="speciesCount">The required number of species.</param>
/// <param name="genomeComparerDescending">A genome comparer for sorting by fitness in descending order.</param>
/// <param name="rng">Random source.</param>
public void InitialiseSpecies(
ISpeciationStrategy <NeatGenome <T>, T> speciationStrategy,
int speciesCount,
IComparer <NeatGenome <T> > genomeComparerDescending,
IRandomSource rng)
{
// Allocate the genomes to species.
Species <T>[] speciesArr = speciationStrategy.SpeciateAll(this.GenomeList, speciesCount, rng);
if (speciesArr is null || speciesArr.Length != speciesCount)
{
throw new Exception("Species array is null or has incorrect length.");
}
this.SpeciesArray = speciesArr;
// Sort the genomes in each species by primary fitness, highest fitness first.
// We use an unstable sort; this ensures that the order of equally fit genomes is randomized, which in turn
// randomizes which genomes are in the subset if elite genomes that are preserved for the next generation - if lots
// of genomes have equally high fitness.
foreach (var species in speciesArr)
{
SortUtils.SortUnstable(species.GenomeList, genomeComparerDescending, rng);
}
}
public static void TestSpeciateAll(
int popSize,
int inputNodeCount,
int outputNodeCount,
double connectionsProportion,
IDistanceMetric <double> distanceMetric,
ISpeciationStrategy <NeatGenome <double>, double> speciationStrategy,
IRandomSource rng,
bool validateNearestSpecies = true)
{
// Create population.
NeatPopulation <double> neatPop = CreateNeatPopulation(popSize, inputNodeCount, outputNodeCount, connectionsProportion);
for (int i = 0; i < 6; i++)
{
int speciesCount = rng.Next(1, (neatPop.GenomeList.Count / 4) + 1);
// Invoke speciation strategy.
var speciesArr = speciationStrategy.SpeciateAll(neatPop.GenomeList, speciesCount, rng);
// Perform tests.
ValidationTests(speciesArr, distanceMetric, speciesCount, neatPop.GenomeList, validateNearestSpecies);
}
}
/// <summary>
/// Configures and instantiates the initialization evolutionary algorithm.
/// </summary>
/// <param name="parallelOptions">Synchronous/Asynchronous execution settings.</param>
/// <param name="genomeList">The initial population of genomes.</param>
/// <param name="genomeDecoder">The decoder to translate genomes into phenotypes.</param>
/// <param name="startingEvaluations">
/// The number of evaluations that preceeded this from which this process will pick up
/// (this is used in the case where we're restarting a run because it failed to find a solution in the allotted time).
/// </param>
public virtual void InitializeAlgorithm(ParallelOptions parallelOptions, List<NeatGenome> genomeList,
IGenomeDecoder<NeatGenome, IBlackBox> genomeDecoder, ulong startingEvaluations)
{
ParallelOptions = parallelOptions;
InitialPopulation = genomeList;
StartingEvaluations = startingEvaluations;
GenomeDecoder = genomeDecoder;
// Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference.
IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
SpeciationStrategy = new ParallelKMeansClusteringStrategy<NeatGenome>(distanceMetric, parallelOptions);
// Create complexity regulation strategy.
ComplexityRegulationStrategy =
ExperimentUtils.CreateComplexityRegulationStrategy(ComplexityRegulationStrategyDefinition,
ComplexityThreshold);
}
private void GetSpeciationStrategy()
{
_SpeciationStrategy = SpeciationStrategy();
}
