示例#1
0
        private static void AllocateEliteSelectionOffspringCounts(
            Species <T> species,
            NeatEvolutionAlgorithmSettings eaSettings,
            bool isBestGenomeSpecies,
            IRandomSource rng)
        {
            SpeciesStats stats = species.Stats;

            // Special case - zero target size.
            if (stats.TargetSizeInt == 0)
            {
                stats.EliteSizeInt          = 0;
                stats.OffspringCount        = 0;
                stats.OffspringAsexualCount = 0;
                stats.OffspringSexualCount  = 0;
                stats.SelectionSizeInt      = 0;
                return;
            }

            // Calculate the elite size as a proportion of the current species size.
            // Note. We discretize the real size with a probabilistic handling of the fractional part.
            double eliteSizeReal = species.GenomeList.Count * eaSettings.ElitismProportion;
            int    eliteSizeInt  = (int)NumericsUtils.ProbabilisticRound(eliteSizeReal, rng);

            // Ensure eliteSizeInt is no larger than the current target size. (I.e. the value was
            // calculated as a proportion of the current size, not the new target size).
            stats.EliteSizeInt = Math.Min(eliteSizeInt, stats.TargetSizeInt);

            // Special case: ensure the species with the best genome preserves that genome.
            // Note. This is done even for a target size of one, which would mean that no offspring are
            // produced from the best genome, apart from the (usually small) chance of a cross-species mating.
            if (isBestGenomeSpecies && stats.EliteSizeInt == 0)
            {
                Debug.Assert(stats.TargetSizeInt != 0, "Zero target size assigned to specie that contains the best genome.");
                stats.EliteSizeInt = 1;
            }

            // Determine how many offspring to produce for the species.
            stats.OffspringCount = stats.TargetSizeInt - stats.EliteSizeInt;

            // Determine the split between asexual and sexual reproduction. Again using probabilistic
            // rounding to compensate for any rounding bias.
            double offspringAsexualCountReal = stats.OffspringCount * eaSettings.OffspringAsexualProportion;

            stats.OffspringAsexualCount = (int)NumericsUtils.ProbabilisticRound(offspringAsexualCountReal, rng);
            stats.OffspringSexualCount  = stats.OffspringCount - stats.OffspringAsexualCount;

            // Calculate the selectionSize. The number of the species' fittest genomes that are selected from
            // to create offspring.
            // We ensure this is at least one; if TargetSizeInt is zero then it doesn't matter because no genomes will be
            // selected from this species to produce offspring, except for cross-species mating, hence the minimum of one is
            // a useful general approach.
            double selectionSizeReal = species.GenomeList.Count * eaSettings.SelectionProportion;

            stats.SelectionSizeInt = Math.Max(1, (int)NumericsUtils.ProbabilisticRound(selectionSizeReal, rng));
        }
示例#2
0
 /// <summary>
 /// Copy constructor.
 /// </summary>
 /// <param name="copyFrom">The settings object to copy.</param>
 public NeatEvolutionAlgorithmSettings(NeatEvolutionAlgorithmSettings copyFrom)
 {
     this.SpeciesCount                         = copyFrom.SpeciesCount;
     this.ElitismProportion                    = copyFrom.ElitismProportion;
     this.SelectionProportion                  = copyFrom.SelectionProportion;
     this.OffspringAsexualProportion           = copyFrom.OffspringAsexualProportion;
     this.OffspringSexualProportion            = copyFrom.OffspringSexualProportion;
     this.InterspeciesMatingProportion         = copyFrom.InterspeciesMatingProportion;
     this.StatisticsMovingAverageHistoryLength = copyFrom.StatisticsMovingAverageHistoryLength;
 }
示例#3
0
        /// <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);
        }
示例#4
0
        /// <summary>
        /// Calculate and update a number of statistical values and target size values on each species in the givben population.
        /// </summary>
        /// <param name="pop">The population to update species statistics on.</param>
        /// <param name="eaSettings">Evolution algorithm settings.</param>
        /// <param name="rng">Random source.</param>
        public static void CalcAndStoreSpeciesStats(
            NeatPopulation <T> pop,
            NeatEvolutionAlgorithmSettings eaSettings,
            IRandomSource rng)
        {
            // Calc and store the mean fitness of each species.
            CalcAndStoreSpeciesFitnessMeans(pop);

            // Calc and store the target size of each species (based on the NEAT fitness sharing method).
            SpeciesAllocationCalcs <T> .CalcAndStoreSpeciesAllocationSizes(pop, eaSettings, rng);
        }
示例#5
0
        /// <summary>
        /// Calc and store species target sizes based on relative mean fitness of each species, i.e. as per NEAT fitness sharing method.
        /// Then calc and store the elite, selection and offspring allocations/counts, per species.
        /// </summary>
        public static void CalcAndStoreSpeciesAllocationSizes(
            NeatPopulation <T> pop,
            NeatEvolutionAlgorithmSettings eaSettings,
            IRandomSource rng)
        {
            // Calculate the new target size of each species using fitness sharing.
            CalcAndStoreSpeciesTargetSizes(pop, rng);

            // Calculate elite, selection and offspring counts, per species.
            CalculateAndStoreEliteSelectionOffspringCounts(pop, eaSettings, rng);
        }
示例#6
0
        /// <summary>
        /// Creates a new settings object based on the current settings object, but modified to be suitable for use when
        /// the evolution algorithm is in simplifying mode.
        /// </summary>
        /// <returns>A new instance of <see cref="NeatEvolutionAlgorithmSettings"/>.</returns>
        public NeatEvolutionAlgorithmSettings CreateSimplifyingSettings()
        {
            // Clone the current settings object.
            var settings = new NeatEvolutionAlgorithmSettings(this)
            {
                OffspringAsexualProportion = 1.0,
                OffspringSexualProportion  = 0.0
            };

            return(settings);
        }
 /// <summary>
 /// Read json into a target instance of <see cref="NeatEvolutionAlgorithmSettings"/>.
 /// Settings that are present are read and set on the target settings object; all other settings
 /// remain unchanged on the target object.
 /// </summary>
 /// <param name="target">The target settings object to store the read values on.</param>
 /// <param name="jobj">The json object to read from.</param>
 public static void Read(
     NeatEvolutionAlgorithmSettings target,
     JObject jobj)
 {
     ReadIntOptional(jobj, "speciesCount", x => target.SpeciesCount = x);
     ReadDoubleOptional(jobj, "elitismProportion", x => target.ElitismProportion     = x);
     ReadDoubleOptional(jobj, "selectionProportion", x => target.SelectionProportion = x);
     ReadDoubleOptional(jobj, "offspringAsexualProportion", x => target.OffspringAsexualProportion     = x);
     ReadDoubleOptional(jobj, "offspringSexualProportion", x => target.OffspringSexualProportion       = x);
     ReadDoubleOptional(jobj, "interspeciesMatingProportion", x => target.InterspeciesMatingProportion = x);
     ReadIntOptional(jobj, "statisticsMovingAverageHistoryLength", x => target.StatisticsMovingAverageHistoryLength = x);
 }
 /// <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())
 {
 }
示例#9
0
        /// <summary>
        /// For each species, allocate the EliteSizeInt, OffspringCount (broken down into OffspringAsexualCount and OffspringSexualCount),
        /// and SelectionSizeInt values.
        /// </summary>
        /// <param name="pop"></param>
        /// <param name="eaSettings"></param>
        /// <param name="rng"></param>
        private static void CalculateAndStoreEliteSelectionOffspringCounts(
            NeatPopulation <T> pop,
            NeatEvolutionAlgorithmSettings eaSettings,
            IRandomSource rng)
        {
            Species <T>[] speciesArr = pop.SpeciesArray;

            // Loop the species, calculating and storing the various size/count properties.
            for (int i = 0; i < speciesArr.Length; i++)
            {
                bool isBestGenomeSpecies = (pop.BestGenomeSpeciesIdx == i);
                AllocateEliteSelectionOffspringCounts(speciesArr[i], eaSettings, isBestGenomeSpecies, rng);
            }
        }